You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@echarts.apache.org by ov...@apache.org on 2024/02/04 07:03:19 UTC
(echarts) 01/01: chore: relase 5.5.0-rc.2
This is an automated email from the ASF dual-hosted git repository.
ovilia pushed a commit to branch release-dev
in repository https://gitbox.apache.org/repos/asf/echarts.git
commit b0b463919eca08852b815b662a390b007bd01f30
Author: Ovilia <zw...@gmail.com>
AuthorDate: Sun Feb 4 15:02:53 2024 +0800
chore: relase 5.5.0-rc.2
---
dist/echarts.esm.min.mjs | 45 +
dist/echarts.esm.mjs | 85617 +++++++++++++
dist/{echarts.js.map => echarts.esm.mjs.map} | 2 +-
dist/echarts.js | 155596 +++++++++++-------------
dist/echarts.js.map | 8 +-
5 files changed, 156624 insertions(+), 84644 deletions(-)
diff --git a/dist/echarts.esm.min.mjs b/dist/echarts.esm.min.mjs
new file mode 100644
index 000000000..036383714
--- /dev/null
+++ b/dist/echarts.esm.min.mjs
@@ -0,0 +1,45 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements. See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership. The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License. You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied. See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=e[n])},t(e,n)};function e(e,n){if("function"!=typeof n&&null!==n)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}var n=function(){this.firefox=!1,this.ie [...]
+/*!
+* ZRender, a high performance 2d drawing library.
+*
+* Copyright (c) 2013, Baidu Inc.
+* All rights reserved.
+*
+* LICENSE
+* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
+*/
+var Br={},Fr={};var Gr,Wr=function(){function t(t,e,n){var r=this;this._sleepAfterStill=10,this._stillFrameAccum=0,this._needsRefresh=!0,this._needsRefreshHover=!0,this._darkMode=!1,n=n||{},this.dom=e,this.id=t;var o=new nn,a=n.renderer||"canvas";Br[a]||(a=F(Br)[0]),n.useDirtyRect=null!=n.useDirtyRect&&n.useDirtyRect;var s=new Br[a](e,o,n,t),l=n.ssr||s.ssrOnly;this.storage=o,this.painter=s;var u,h=i.node||i.worker||l?null:new rr(s.getViewportRoot(),s.root),c=n.useCoarsePointer;(null==c|| [...]
diff --git a/dist/echarts.esm.mjs b/dist/echarts.esm.mjs
new file mode 100644
index 000000000..121c96fde
--- /dev/null
+++ b/dist/echarts.esm.mjs
@@ -0,0 +1,85617 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements. See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership. The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License. You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied. See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+ if (typeof b !== "function" && b !== null)
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var Browser = (function () {
+ function Browser() {
+ this.firefox = false;
+ this.ie = false;
+ this.edge = false;
+ this.newEdge = false;
+ this.weChat = false;
+ }
+ return Browser;
+}());
+var Env = (function () {
+ function Env() {
+ this.browser = new Browser();
+ this.node = false;
+ this.wxa = false;
+ this.worker = false;
+ this.svgSupported = false;
+ this.touchEventsSupported = false;
+ this.pointerEventsSupported = false;
+ this.domSupported = false;
+ this.transformSupported = false;
+ this.transform3dSupported = false;
+ this.hasGlobalWindow = typeof window !== 'undefined';
+ }
+ return Env;
+}());
+var env = new Env();
+if (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') {
+ env.wxa = true;
+ env.touchEventsSupported = true;
+}
+else if (typeof document === 'undefined' && typeof self !== 'undefined') {
+ env.worker = true;
+}
+else if (typeof navigator === 'undefined'
+ || navigator.userAgent.indexOf('Node.js') === 0) {
+ env.node = true;
+ env.svgSupported = true;
+}
+else {
+ detect(navigator.userAgent, env);
+}
+function detect(ua, env) {
+ var browser = env.browser;
+ var firefox = ua.match(/Firefox\/([\d.]+)/);
+ var ie = ua.match(/MSIE\s([\d.]+)/)
+ || ua.match(/Trident\/.+?rv:(([\d.]+))/);
+ var edge = ua.match(/Edge?\/([\d.]+)/);
+ var weChat = (/micromessenger/i).test(ua);
+ if (firefox) {
+ browser.firefox = true;
+ browser.version = firefox[1];
+ }
+ if (ie) {
+ browser.ie = true;
+ browser.version = ie[1];
+ }
+ if (edge) {
+ browser.edge = true;
+ browser.version = edge[1];
+ browser.newEdge = +edge[1].split('.')[0] > 18;
+ }
+ if (weChat) {
+ browser.weChat = true;
+ }
+ env.svgSupported = typeof SVGRect !== 'undefined';
+ env.touchEventsSupported = 'ontouchstart' in window && !browser.ie && !browser.edge;
+ env.pointerEventsSupported = 'onpointerdown' in window
+ && (browser.edge || (browser.ie && +browser.version >= 11));
+ env.domSupported = typeof document !== 'undefined';
+ var style = document.documentElement.style;
+ env.transform3dSupported = ((browser.ie && 'transition' in style)
+ || browser.edge
+ || (('WebKitCSSMatrix' in window) && ('m11' in new WebKitCSSMatrix()))
+ || 'MozPerspective' in style)
+ && !('OTransition' in style);
+ env.transformSupported = env.transform3dSupported
+ || (browser.ie && +browser.version >= 9);
+}
+
+var DEFAULT_FONT_SIZE = 12;
+var DEFAULT_FONT_FAMILY = 'sans-serif';
+var DEFAULT_FONT = DEFAULT_FONT_SIZE + "px " + DEFAULT_FONT_FAMILY;
+var OFFSET = 20;
+var SCALE = 100;
+var defaultWidthMapStr = "007LLmW'55;N0500LLLLLLLLLL00NNNLzWW\\\\WQb\\0FWLg\\bWb\\WQ\\WrWWQ000CL5LLFLL0LL**F*gLLLL5F0LF\\FFF5.5N";
+function getTextWidthMap(mapStr) {
+ var map = {};
+ if (typeof JSON === 'undefined') {
+ return map;
+ }
+ for (var i = 0; i < mapStr.length; i++) {
+ var char = String.fromCharCode(i + 32);
+ var size = (mapStr.charCodeAt(i) - OFFSET) / SCALE;
+ map[char] = size;
+ }
+ return map;
+}
+var DEFAULT_TEXT_WIDTH_MAP = getTextWidthMap(defaultWidthMapStr);
+var platformApi = {
+ createCanvas: function () {
+ return typeof document !== 'undefined'
+ && document.createElement('canvas');
+ },
+ measureText: (function () {
+ var _ctx;
+ var _cachedFont;
+ return function (text, font) {
+ if (!_ctx) {
+ var canvas = platformApi.createCanvas();
+ _ctx = canvas && canvas.getContext('2d');
+ }
+ if (_ctx) {
+ if (_cachedFont !== font) {
+ _cachedFont = _ctx.font = font || DEFAULT_FONT;
+ }
+ return _ctx.measureText(text);
+ }
+ else {
+ text = text || '';
+ font = font || DEFAULT_FONT;
+ var res = /(\d+)px/.exec(font);
+ var fontSize = res && +res[1] || DEFAULT_FONT_SIZE;
+ var width = 0;
+ if (font.indexOf('mono') >= 0) {
+ width = fontSize * text.length;
+ }
+ else {
+ for (var i = 0; i < text.length; i++) {
+ var preCalcWidth = DEFAULT_TEXT_WIDTH_MAP[text[i]];
+ width += preCalcWidth == null ? fontSize : (preCalcWidth * fontSize);
+ }
+ }
+ return { width: width };
+ }
+ };
+ })(),
+ loadImage: function (src, onload, onerror) {
+ var image = new Image();
+ image.onload = onload;
+ image.onerror = onerror;
+ image.src = src;
+ return image;
+ }
+};
+function setPlatformAPI(newPlatformApis) {
+ for (var key in platformApi) {
+ if (newPlatformApis[key]) {
+ platformApi[key] = newPlatformApis[key];
+ }
+ }
+}
+
+var BUILTIN_OBJECT = reduce([
+ 'Function',
+ 'RegExp',
+ 'Date',
+ 'Error',
+ 'CanvasGradient',
+ 'CanvasPattern',
+ 'Image',
+ 'Canvas'
+], function (obj, val) {
+ obj['[object ' + val + ']'] = true;
+ return obj;
+}, {});
+var TYPED_ARRAY = reduce([
+ 'Int8',
+ 'Uint8',
+ 'Uint8Clamped',
+ 'Int16',
+ 'Uint16',
+ 'Int32',
+ 'Uint32',
+ 'Float32',
+ 'Float64'
+], function (obj, val) {
+ obj['[object ' + val + 'Array]'] = true;
+ return obj;
+}, {});
+var objToString = Object.prototype.toString;
+var arrayProto = Array.prototype;
+var nativeForEach = arrayProto.forEach;
+var nativeFilter = arrayProto.filter;
+var nativeSlice = arrayProto.slice;
+var nativeMap = arrayProto.map;
+var ctorFunction = function () { }.constructor;
+var protoFunction = ctorFunction ? ctorFunction.prototype : null;
+var protoKey = '__proto__';
+var idStart = 0x0907;
+function guid() {
+ return idStart++;
+}
+function logError() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ if (typeof console !== 'undefined') {
+ console.error.apply(console, args);
+ }
+}
+function clone(source) {
+ if (source == null || typeof source !== 'object') {
+ return source;
+ }
+ var result = source;
+ var typeStr = objToString.call(source);
+ if (typeStr === '[object Array]') {
+ if (!isPrimitive(source)) {
+ result = [];
+ for (var i = 0, len = source.length; i < len; i++) {
+ result[i] = clone(source[i]);
+ }
+ }
+ }
+ else if (TYPED_ARRAY[typeStr]) {
+ if (!isPrimitive(source)) {
+ var Ctor = source.constructor;
+ if (Ctor.from) {
+ result = Ctor.from(source);
+ }
+ else {
+ result = new Ctor(source.length);
+ for (var i = 0, len = source.length; i < len; i++) {
+ result[i] = source[i];
+ }
+ }
+ }
+ }
+ else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {
+ result = {};
+ for (var key in source) {
+ if (source.hasOwnProperty(key) && key !== protoKey) {
+ result[key] = clone(source[key]);
+ }
+ }
+ }
+ return result;
+}
+function merge(target, source, overwrite) {
+ if (!isObject(source) || !isObject(target)) {
+ return overwrite ? clone(source) : target;
+ }
+ for (var key in source) {
+ if (source.hasOwnProperty(key) && key !== protoKey) {
+ var targetProp = target[key];
+ var sourceProp = source[key];
+ if (isObject(sourceProp)
+ && isObject(targetProp)
+ && !isArray(sourceProp)
+ && !isArray(targetProp)
+ && !isDom(sourceProp)
+ && !isDom(targetProp)
+ && !isBuiltInObject(sourceProp)
+ && !isBuiltInObject(targetProp)
+ && !isPrimitive(sourceProp)
+ && !isPrimitive(targetProp)) {
+ merge(targetProp, sourceProp, overwrite);
+ }
+ else if (overwrite || !(key in target)) {
+ target[key] = clone(source[key]);
+ }
+ }
+ }
+ return target;
+}
+function mergeAll(targetAndSources, overwrite) {
+ var result = targetAndSources[0];
+ for (var i = 1, len = targetAndSources.length; i < len; i++) {
+ result = merge(result, targetAndSources[i], overwrite);
+ }
+ return result;
+}
+function extend(target, source) {
+ if (Object.assign) {
+ Object.assign(target, source);
+ }
+ else {
+ for (var key in source) {
+ if (source.hasOwnProperty(key) && key !== protoKey) {
+ target[key] = source[key];
+ }
+ }
+ }
+ return target;
+}
+function defaults(target, source, overlay) {
+ var keysArr = keys(source);
+ for (var i = 0; i < keysArr.length; i++) {
+ var key = keysArr[i];
+ if ((overlay ? source[key] != null : target[key] == null)) {
+ target[key] = source[key];
+ }
+ }
+ return target;
+}
+var createCanvas = platformApi.createCanvas;
+function indexOf(array, value) {
+ if (array) {
+ if (array.indexOf) {
+ return array.indexOf(value);
+ }
+ for (var i = 0, len = array.length; i < len; i++) {
+ if (array[i] === value) {
+ return i;
+ }
+ }
+ }
+ return -1;
+}
+function inherits(clazz, baseClazz) {
+ var clazzPrototype = clazz.prototype;
+ function F() { }
+ F.prototype = baseClazz.prototype;
+ clazz.prototype = new F();
+ for (var prop in clazzPrototype) {
+ if (clazzPrototype.hasOwnProperty(prop)) {
+ clazz.prototype[prop] = clazzPrototype[prop];
+ }
+ }
+ clazz.prototype.constructor = clazz;
+ clazz.superClass = baseClazz;
+}
+function mixin(target, source, override) {
+ target = 'prototype' in target ? target.prototype : target;
+ source = 'prototype' in source ? source.prototype : source;
+ if (Object.getOwnPropertyNames) {
+ var keyList = Object.getOwnPropertyNames(source);
+ for (var i = 0; i < keyList.length; i++) {
+ var key = keyList[i];
+ if (key !== 'constructor') {
+ if ((override ? source[key] != null : target[key] == null)) {
+ target[key] = source[key];
+ }
+ }
+ }
+ }
+ else {
+ defaults(target, source, override);
+ }
+}
+function isArrayLike(data) {
+ if (!data) {
+ return false;
+ }
+ if (typeof data === 'string') {
+ return false;
+ }
+ return typeof data.length === 'number';
+}
+function each(arr, cb, context) {
+ if (!(arr && cb)) {
+ return;
+ }
+ if (arr.forEach && arr.forEach === nativeForEach) {
+ arr.forEach(cb, context);
+ }
+ else if (arr.length === +arr.length) {
+ for (var i = 0, len = arr.length; i < len; i++) {
+ cb.call(context, arr[i], i, arr);
+ }
+ }
+ else {
+ for (var key in arr) {
+ if (arr.hasOwnProperty(key)) {
+ cb.call(context, arr[key], key, arr);
+ }
+ }
+ }
+}
+function map(arr, cb, context) {
+ if (!arr) {
+ return [];
+ }
+ if (!cb) {
+ return slice(arr);
+ }
+ if (arr.map && arr.map === nativeMap) {
+ return arr.map(cb, context);
+ }
+ else {
+ var result = [];
+ for (var i = 0, len = arr.length; i < len; i++) {
+ result.push(cb.call(context, arr[i], i, arr));
+ }
+ return result;
+ }
+}
+function reduce(arr, cb, memo, context) {
+ if (!(arr && cb)) {
+ return;
+ }
+ for (var i = 0, len = arr.length; i < len; i++) {
+ memo = cb.call(context, memo, arr[i], i, arr);
+ }
+ return memo;
+}
+function filter(arr, cb, context) {
+ if (!arr) {
+ return [];
+ }
+ if (!cb) {
+ return slice(arr);
+ }
+ if (arr.filter && arr.filter === nativeFilter) {
+ return arr.filter(cb, context);
+ }
+ else {
+ var result = [];
+ for (var i = 0, len = arr.length; i < len; i++) {
+ if (cb.call(context, arr[i], i, arr)) {
+ result.push(arr[i]);
+ }
+ }
+ return result;
+ }
+}
+function find(arr, cb, context) {
+ if (!(arr && cb)) {
+ return;
+ }
+ for (var i = 0, len = arr.length; i < len; i++) {
+ if (cb.call(context, arr[i], i, arr)) {
+ return arr[i];
+ }
+ }
+}
+function keys(obj) {
+ if (!obj) {
+ return [];
+ }
+ if (Object.keys) {
+ return Object.keys(obj);
+ }
+ var keyList = [];
+ for (var key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ keyList.push(key);
+ }
+ }
+ return keyList;
+}
+function bindPolyfill(func, context) {
+ var args = [];
+ for (var _i = 2; _i < arguments.length; _i++) {
+ args[_i - 2] = arguments[_i];
+ }
+ return function () {
+ return func.apply(context, args.concat(nativeSlice.call(arguments)));
+ };
+}
+var bind = (protoFunction && isFunction(protoFunction.bind))
+ ? protoFunction.call.bind(protoFunction.bind)
+ : bindPolyfill;
+function curry(func) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ return function () {
+ return func.apply(this, args.concat(nativeSlice.call(arguments)));
+ };
+}
+function isArray(value) {
+ if (Array.isArray) {
+ return Array.isArray(value);
+ }
+ return objToString.call(value) === '[object Array]';
+}
+function isFunction(value) {
+ return typeof value === 'function';
+}
+function isString(value) {
+ return typeof value === 'string';
+}
+function isStringSafe(value) {
+ return objToString.call(value) === '[object String]';
+}
+function isNumber(value) {
+ return typeof value === 'number';
+}
+function isObject(value) {
+ var type = typeof value;
+ return type === 'function' || (!!value && type === 'object');
+}
+function isBuiltInObject(value) {
+ return !!BUILTIN_OBJECT[objToString.call(value)];
+}
+function isTypedArray(value) {
+ return !!TYPED_ARRAY[objToString.call(value)];
+}
+function isDom(value) {
+ return typeof value === 'object'
+ && typeof value.nodeType === 'number'
+ && typeof value.ownerDocument === 'object';
+}
+function isGradientObject(value) {
+ return value.colorStops != null;
+}
+function isImagePatternObject(value) {
+ return value.image != null;
+}
+function isRegExp(value) {
+ return objToString.call(value) === '[object RegExp]';
+}
+function eqNaN(value) {
+ return value !== value;
+}
+function retrieve() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ for (var i = 0, len = args.length; i < len; i++) {
+ if (args[i] != null) {
+ return args[i];
+ }
+ }
+}
+function retrieve2(value0, value1) {
+ return value0 != null
+ ? value0
+ : value1;
+}
+function retrieve3(value0, value1, value2) {
+ return value0 != null
+ ? value0
+ : value1 != null
+ ? value1
+ : value2;
+}
+function slice(arr) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ return nativeSlice.apply(arr, args);
+}
+function normalizeCssArray(val) {
+ if (typeof (val) === 'number') {
+ return [val, val, val, val];
+ }
+ var len = val.length;
+ if (len === 2) {
+ return [val[0], val[1], val[0], val[1]];
+ }
+ else if (len === 3) {
+ return [val[0], val[1], val[2], val[1]];
+ }
+ return val;
+}
+function assert(condition, message) {
+ if (!condition) {
+ throw new Error(message);
+ }
+}
+function trim(str) {
+ if (str == null) {
+ return null;
+ }
+ else if (typeof str.trim === 'function') {
+ return str.trim();
+ }
+ else {
+ return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+ }
+}
+var primitiveKey = '__ec_primitive__';
+function setAsPrimitive(obj) {
+ obj[primitiveKey] = true;
+}
+function isPrimitive(obj) {
+ return obj[primitiveKey];
+}
+var MapPolyfill = (function () {
+ function MapPolyfill() {
+ this.data = {};
+ }
+ MapPolyfill.prototype["delete"] = function (key) {
+ var existed = this.has(key);
+ if (existed) {
+ delete this.data[key];
+ }
+ return existed;
+ };
+ MapPolyfill.prototype.has = function (key) {
+ return this.data.hasOwnProperty(key);
+ };
+ MapPolyfill.prototype.get = function (key) {
+ return this.data[key];
+ };
+ MapPolyfill.prototype.set = function (key, value) {
+ this.data[key] = value;
+ return this;
+ };
+ MapPolyfill.prototype.keys = function () {
+ return keys(this.data);
+ };
+ MapPolyfill.prototype.forEach = function (callback) {
+ var data = this.data;
+ for (var key in data) {
+ if (data.hasOwnProperty(key)) {
+ callback(data[key], key);
+ }
+ }
+ };
+ return MapPolyfill;
+}());
+var isNativeMapSupported = typeof Map === 'function';
+function maybeNativeMap() {
+ return (isNativeMapSupported ? new Map() : new MapPolyfill());
+}
+var HashMap = (function () {
+ function HashMap(obj) {
+ var isArr = isArray(obj);
+ this.data = maybeNativeMap();
+ var thisMap = this;
+ (obj instanceof HashMap)
+ ? obj.each(visit)
+ : (obj && each(obj, visit));
+ function visit(value, key) {
+ isArr ? thisMap.set(value, key) : thisMap.set(key, value);
+ }
+ }
+ HashMap.prototype.hasKey = function (key) {
+ return this.data.has(key);
+ };
+ HashMap.prototype.get = function (key) {
+ return this.data.get(key);
+ };
+ HashMap.prototype.set = function (key, value) {
+ this.data.set(key, value);
+ return value;
+ };
+ HashMap.prototype.each = function (cb, context) {
+ this.data.forEach(function (value, key) {
+ cb.call(context, value, key);
+ });
+ };
+ HashMap.prototype.keys = function () {
+ var keys = this.data.keys();
+ return isNativeMapSupported
+ ? Array.from(keys)
+ : keys;
+ };
+ HashMap.prototype.removeKey = function (key) {
+ this.data["delete"](key);
+ };
+ return HashMap;
+}());
+function createHashMap(obj) {
+ return new HashMap(obj);
+}
+function concatArray(a, b) {
+ var newArray = new a.constructor(a.length + b.length);
+ for (var i = 0; i < a.length; i++) {
+ newArray[i] = a[i];
+ }
+ var offset = a.length;
+ for (var i = 0; i < b.length; i++) {
+ newArray[i + offset] = b[i];
+ }
+ return newArray;
+}
+function createObject(proto, properties) {
+ var obj;
+ if (Object.create) {
+ obj = Object.create(proto);
+ }
+ else {
+ var StyleCtor = function () { };
+ StyleCtor.prototype = proto;
+ obj = new StyleCtor();
+ }
+ if (properties) {
+ extend(obj, properties);
+ }
+ return obj;
+}
+function disableUserSelect(dom) {
+ var domStyle = dom.style;
+ domStyle.webkitUserSelect = 'none';
+ domStyle.userSelect = 'none';
+ domStyle.webkitTapHighlightColor = 'rgba(0,0,0,0)';
+ domStyle['-webkit-touch-callout'] = 'none';
+}
+function hasOwn(own, prop) {
+ return own.hasOwnProperty(prop);
+}
+function noop() { }
+var RADIAN_TO_DEGREE = 180 / Math.PI;
+
+var util = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ guid: guid,
+ logError: logError,
+ clone: clone,
+ merge: merge,
+ mergeAll: mergeAll,
+ extend: extend,
+ defaults: defaults,
+ createCanvas: createCanvas,
+ indexOf: indexOf,
+ inherits: inherits,
+ mixin: mixin,
+ isArrayLike: isArrayLike,
+ each: each,
+ map: map,
+ reduce: reduce,
+ filter: filter,
+ find: find,
+ keys: keys,
+ bind: bind,
+ curry: curry,
+ isArray: isArray,
+ isFunction: isFunction,
+ isString: isString,
+ isStringSafe: isStringSafe,
+ isNumber: isNumber,
+ isObject: isObject,
+ isBuiltInObject: isBuiltInObject,
+ isTypedArray: isTypedArray,
+ isDom: isDom,
+ isGradientObject: isGradientObject,
+ isImagePatternObject: isImagePatternObject,
+ isRegExp: isRegExp,
+ eqNaN: eqNaN,
+ retrieve: retrieve,
+ retrieve2: retrieve2,
+ retrieve3: retrieve3,
+ slice: slice,
+ normalizeCssArray: normalizeCssArray,
+ assert: assert,
+ trim: trim,
+ setAsPrimitive: setAsPrimitive,
+ isPrimitive: isPrimitive,
+ HashMap: HashMap,
+ createHashMap: createHashMap,
+ concatArray: concatArray,
+ createObject: createObject,
+ disableUserSelect: disableUserSelect,
+ hasOwn: hasOwn,
+ noop: noop,
+ RADIAN_TO_DEGREE: RADIAN_TO_DEGREE
+});
+
+function create(x, y) {
+ if (x == null) {
+ x = 0;
+ }
+ if (y == null) {
+ y = 0;
+ }
+ return [x, y];
+}
+function copy(out, v) {
+ out[0] = v[0];
+ out[1] = v[1];
+ return out;
+}
+function clone$1(v) {
+ return [v[0], v[1]];
+}
+function set(out, a, b) {
+ out[0] = a;
+ out[1] = b;
+ return out;
+}
+function add(out, v1, v2) {
+ out[0] = v1[0] + v2[0];
+ out[1] = v1[1] + v2[1];
+ return out;
+}
+function scaleAndAdd(out, v1, v2, a) {
+ out[0] = v1[0] + v2[0] * a;
+ out[1] = v1[1] + v2[1] * a;
+ return out;
+}
+function sub(out, v1, v2) {
+ out[0] = v1[0] - v2[0];
+ out[1] = v1[1] - v2[1];
+ return out;
+}
+function len(v) {
+ return Math.sqrt(lenSquare(v));
+}
+var length = len;
+function lenSquare(v) {
+ return v[0] * v[0] + v[1] * v[1];
+}
+var lengthSquare = lenSquare;
+function mul(out, v1, v2) {
+ out[0] = v1[0] * v2[0];
+ out[1] = v1[1] * v2[1];
+ return out;
+}
+function div(out, v1, v2) {
+ out[0] = v1[0] / v2[0];
+ out[1] = v1[1] / v2[1];
+ return out;
+}
+function dot(v1, v2) {
+ return v1[0] * v2[0] + v1[1] * v2[1];
+}
+function scale(out, v, s) {
+ out[0] = v[0] * s;
+ out[1] = v[1] * s;
+ return out;
+}
+function normalize(out, v) {
+ var d = len(v);
+ if (d === 0) {
+ out[0] = 0;
+ out[1] = 0;
+ }
+ else {
+ out[0] = v[0] / d;
+ out[1] = v[1] / d;
+ }
+ return out;
+}
+function distance(v1, v2) {
+ return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0])
+ + (v1[1] - v2[1]) * (v1[1] - v2[1]));
+}
+var dist = distance;
+function distanceSquare(v1, v2) {
+ return (v1[0] - v2[0]) * (v1[0] - v2[0])
+ + (v1[1] - v2[1]) * (v1[1] - v2[1]);
+}
+var distSquare = distanceSquare;
+function negate(out, v) {
+ out[0] = -v[0];
+ out[1] = -v[1];
+ return out;
+}
+function lerp(out, v1, v2, t) {
+ out[0] = v1[0] + t * (v2[0] - v1[0]);
+ out[1] = v1[1] + t * (v2[1] - v1[1]);
+ return out;
+}
+function applyTransform(out, v, m) {
+ var x = v[0];
+ var y = v[1];
+ out[0] = m[0] * x + m[2] * y + m[4];
+ out[1] = m[1] * x + m[3] * y + m[5];
+ return out;
+}
+function min(out, v1, v2) {
+ out[0] = Math.min(v1[0], v2[0]);
+ out[1] = Math.min(v1[1], v2[1]);
+ return out;
+}
+function max(out, v1, v2) {
+ out[0] = Math.max(v1[0], v2[0]);
+ out[1] = Math.max(v1[1], v2[1]);
+ return out;
+}
+
+var vector = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ create: create,
+ copy: copy,
+ clone: clone$1,
+ set: set,
+ add: add,
+ scaleAndAdd: scaleAndAdd,
+ sub: sub,
+ len: len,
+ length: length,
+ lenSquare: lenSquare,
+ lengthSquare: lengthSquare,
+ mul: mul,
+ div: div,
+ dot: dot,
+ scale: scale,
+ normalize: normalize,
+ distance: distance,
+ dist: dist,
+ distanceSquare: distanceSquare,
+ distSquare: distSquare,
+ negate: negate,
+ lerp: lerp,
+ applyTransform: applyTransform,
+ min: min,
+ max: max
+});
+
+var Param = (function () {
+ function Param(target, e) {
+ this.target = target;
+ this.topTarget = e && e.topTarget;
+ }
+ return Param;
+}());
+var Draggable = (function () {
+ function Draggable(handler) {
+ this.handler = handler;
+ handler.on('mousedown', this._dragStart, this);
+ handler.on('mousemove', this._drag, this);
+ handler.on('mouseup', this._dragEnd, this);
+ }
+ Draggable.prototype._dragStart = function (e) {
+ var draggingTarget = e.target;
+ while (draggingTarget && !draggingTarget.draggable) {
+ draggingTarget = draggingTarget.parent || draggingTarget.__hostTarget;
+ }
+ if (draggingTarget) {
+ this._draggingTarget = draggingTarget;
+ draggingTarget.dragging = true;
+ this._x = e.offsetX;
+ this._y = e.offsetY;
+ this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragstart', e.event);
+ }
+ };
+ Draggable.prototype._drag = function (e) {
+ var draggingTarget = this._draggingTarget;
+ if (draggingTarget) {
+ var x = e.offsetX;
+ var y = e.offsetY;
+ var dx = x - this._x;
+ var dy = y - this._y;
+ this._x = x;
+ this._y = y;
+ draggingTarget.drift(dx, dy, e);
+ this.handler.dispatchToElement(new Param(draggingTarget, e), 'drag', e.event);
+ var dropTarget = this.handler.findHover(x, y, draggingTarget).target;
+ var lastDropTarget = this._dropTarget;
+ this._dropTarget = dropTarget;
+ if (draggingTarget !== dropTarget) {
+ if (lastDropTarget && dropTarget !== lastDropTarget) {
+ this.handler.dispatchToElement(new Param(lastDropTarget, e), 'dragleave', e.event);
+ }
+ if (dropTarget && dropTarget !== lastDropTarget) {
+ this.handler.dispatchToElement(new Param(dropTarget, e), 'dragenter', e.event);
+ }
+ }
+ }
+ };
+ Draggable.prototype._dragEnd = function (e) {
+ var draggingTarget = this._draggingTarget;
+ if (draggingTarget) {
+ draggingTarget.dragging = false;
+ }
+ this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragend', e.event);
+ if (this._dropTarget) {
+ this.handler.dispatchToElement(new Param(this._dropTarget, e), 'drop', e.event);
+ }
+ this._draggingTarget = null;
+ this._dropTarget = null;
+ };
+ return Draggable;
+}());
+
+var Eventful = (function () {
+ function Eventful(eventProcessors) {
+ if (eventProcessors) {
+ this._$eventProcessor = eventProcessors;
+ }
+ }
+ Eventful.prototype.on = function (event, query, handler, context) {
+ if (!this._$handlers) {
+ this._$handlers = {};
+ }
+ var _h = this._$handlers;
+ if (typeof query === 'function') {
+ context = handler;
+ handler = query;
+ query = null;
+ }
+ if (!handler || !event) {
+ return this;
+ }
+ var eventProcessor = this._$eventProcessor;
+ if (query != null && eventProcessor && eventProcessor.normalizeQuery) {
+ query = eventProcessor.normalizeQuery(query);
+ }
+ if (!_h[event]) {
+ _h[event] = [];
+ }
+ for (var i = 0; i < _h[event].length; i++) {
+ if (_h[event][i].h === handler) {
+ return this;
+ }
+ }
+ var wrap = {
+ h: handler,
+ query: query,
+ ctx: (context || this),
+ callAtLast: handler.zrEventfulCallAtLast
+ };
+ var lastIndex = _h[event].length - 1;
+ var lastWrap = _h[event][lastIndex];
+ (lastWrap && lastWrap.callAtLast)
+ ? _h[event].splice(lastIndex, 0, wrap)
+ : _h[event].push(wrap);
+ return this;
+ };
+ Eventful.prototype.isSilent = function (eventName) {
+ var _h = this._$handlers;
+ return !_h || !_h[eventName] || !_h[eventName].length;
+ };
+ Eventful.prototype.off = function (eventType, handler) {
+ var _h = this._$handlers;
+ if (!_h) {
+ return this;
+ }
+ if (!eventType) {
+ this._$handlers = {};
+ return this;
+ }
+ if (handler) {
+ if (_h[eventType]) {
+ var newList = [];
+ for (var i = 0, l = _h[eventType].length; i < l; i++) {
+ if (_h[eventType][i].h !== handler) {
+ newList.push(_h[eventType][i]);
+ }
+ }
+ _h[eventType] = newList;
+ }
+ if (_h[eventType] && _h[eventType].length === 0) {
+ delete _h[eventType];
+ }
+ }
+ else {
+ delete _h[eventType];
+ }
+ return this;
+ };
+ Eventful.prototype.trigger = function (eventType) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ if (!this._$handlers) {
+ return this;
+ }
+ var _h = this._$handlers[eventType];
+ var eventProcessor = this._$eventProcessor;
+ if (_h) {
+ var argLen = args.length;
+ var len = _h.length;
+ for (var i = 0; i < len; i++) {
+ var hItem = _h[i];
+ if (eventProcessor
+ && eventProcessor.filter
+ && hItem.query != null
+ && !eventProcessor.filter(eventType, hItem.query)) {
+ continue;
+ }
+ switch (argLen) {
+ case 0:
+ hItem.h.call(hItem.ctx);
+ break;
+ case 1:
+ hItem.h.call(hItem.ctx, args[0]);
+ break;
+ case 2:
+ hItem.h.call(hItem.ctx, args[0], args[1]);
+ break;
+ default:
+ hItem.h.apply(hItem.ctx, args);
+ break;
+ }
+ }
+ }
+ eventProcessor && eventProcessor.afterTrigger
+ && eventProcessor.afterTrigger(eventType);
+ return this;
+ };
+ Eventful.prototype.triggerWithContext = function (type) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ if (!this._$handlers) {
+ return this;
+ }
+ var _h = this._$handlers[type];
+ var eventProcessor = this._$eventProcessor;
+ if (_h) {
+ var argLen = args.length;
+ var ctx = args[argLen - 1];
+ var len = _h.length;
+ for (var i = 0; i < len; i++) {
+ var hItem = _h[i];
+ if (eventProcessor
+ && eventProcessor.filter
+ && hItem.query != null
+ && !eventProcessor.filter(type, hItem.query)) {
+ continue;
+ }
+ switch (argLen) {
+ case 0:
+ hItem.h.call(ctx);
+ break;
+ case 1:
+ hItem.h.call(ctx, args[0]);
+ break;
+ case 2:
+ hItem.h.call(ctx, args[0], args[1]);
+ break;
+ default:
+ hItem.h.apply(ctx, args.slice(1, argLen - 1));
+ break;
+ }
+ }
+ }
+ eventProcessor && eventProcessor.afterTrigger
+ && eventProcessor.afterTrigger(type);
+ return this;
+ };
+ return Eventful;
+}());
+
+var LN2 = Math.log(2);
+function determinant(rows, rank, rowStart, rowMask, colMask, detCache) {
+ var cacheKey = rowMask + '-' + colMask;
+ var fullRank = rows.length;
+ if (detCache.hasOwnProperty(cacheKey)) {
+ return detCache[cacheKey];
+ }
+ if (rank === 1) {
+ var colStart = Math.round(Math.log(((1 << fullRank) - 1) & ~colMask) / LN2);
+ return rows[rowStart][colStart];
+ }
+ var subRowMask = rowMask | (1 << rowStart);
+ var subRowStart = rowStart + 1;
+ while (rowMask & (1 << subRowStart)) {
+ subRowStart++;
+ }
+ var sum = 0;
+ for (var j = 0, colLocalIdx = 0; j < fullRank; j++) {
+ var colTag = 1 << j;
+ if (!(colTag & colMask)) {
+ sum += (colLocalIdx % 2 ? -1 : 1) * rows[rowStart][j]
+ * determinant(rows, rank - 1, subRowStart, subRowMask, colMask | colTag, detCache);
+ colLocalIdx++;
+ }
+ }
+ detCache[cacheKey] = sum;
+ return sum;
+}
+function buildTransformer(src, dest) {
+ var mA = [
+ [src[0], src[1], 1, 0, 0, 0, -dest[0] * src[0], -dest[0] * src[1]],
+ [0, 0, 0, src[0], src[1], 1, -dest[1] * src[0], -dest[1] * src[1]],
+ [src[2], src[3], 1, 0, 0, 0, -dest[2] * src[2], -dest[2] * src[3]],
+ [0, 0, 0, src[2], src[3], 1, -dest[3] * src[2], -dest[3] * src[3]],
+ [src[4], src[5], 1, 0, 0, 0, -dest[4] * src[4], -dest[4] * src[5]],
+ [0, 0, 0, src[4], src[5], 1, -dest[5] * src[4], -dest[5] * src[5]],
+ [src[6], src[7], 1, 0, 0, 0, -dest[6] * src[6], -dest[6] * src[7]],
+ [0, 0, 0, src[6], src[7], 1, -dest[7] * src[6], -dest[7] * src[7]]
+ ];
+ var detCache = {};
+ var det = determinant(mA, 8, 0, 0, 0, detCache);
+ if (det === 0) {
+ return;
+ }
+ var vh = [];
+ for (var i = 0; i < 8; i++) {
+ for (var j = 0; j < 8; j++) {
+ vh[j] == null && (vh[j] = 0);
+ vh[j] += ((i + j) % 2 ? -1 : 1)
+ * determinant(mA, 7, i === 0 ? 1 : 0, 1 << i, 1 << j, detCache)
+ / det * dest[i];
+ }
+ }
+ return function (out, srcPointX, srcPointY) {
+ var pk = srcPointX * vh[6] + srcPointY * vh[7] + 1;
+ out[0] = (srcPointX * vh[0] + srcPointY * vh[1] + vh[2]) / pk;
+ out[1] = (srcPointX * vh[3] + srcPointY * vh[4] + vh[5]) / pk;
+ };
+}
+
+var EVENT_SAVED_PROP = '___zrEVENTSAVED';
+var _calcOut = [];
+function transformLocalCoord(out, elFrom, elTarget, inX, inY) {
+ return transformCoordWithViewport(_calcOut, elFrom, inX, inY, true)
+ && transformCoordWithViewport(out, elTarget, _calcOut[0], _calcOut[1]);
+}
+function transformCoordWithViewport(out, el, inX, inY, inverse) {
+ if (el.getBoundingClientRect && env.domSupported && !isCanvasEl(el)) {
+ var saved = el[EVENT_SAVED_PROP] || (el[EVENT_SAVED_PROP] = {});
+ var markers = prepareCoordMarkers(el, saved);
+ var transformer = preparePointerTransformer(markers, saved, inverse);
+ if (transformer) {
+ transformer(out, inX, inY);
+ return true;
+ }
+ }
+ return false;
+}
+function prepareCoordMarkers(el, saved) {
+ var markers = saved.markers;
+ if (markers) {
+ return markers;
+ }
+ markers = saved.markers = [];
+ var propLR = ['left', 'right'];
+ var propTB = ['top', 'bottom'];
+ for (var i = 0; i < 4; i++) {
+ var marker = document.createElement('div');
+ var stl = marker.style;
+ var idxLR = i % 2;
+ var idxTB = (i >> 1) % 2;
+ stl.cssText = [
+ 'position: absolute',
+ 'visibility: hidden',
+ 'padding: 0',
+ 'margin: 0',
+ 'border-width: 0',
+ 'user-select: none',
+ 'width:0',
+ 'height:0',
+ propLR[idxLR] + ':0',
+ propTB[idxTB] + ':0',
+ propLR[1 - idxLR] + ':auto',
+ propTB[1 - idxTB] + ':auto',
+ ''
+ ].join('!important;');
+ el.appendChild(marker);
+ markers.push(marker);
+ }
+ return markers;
+}
+function preparePointerTransformer(markers, saved, inverse) {
+ var transformerName = inverse ? 'invTrans' : 'trans';
+ var transformer = saved[transformerName];
+ var oldSrcCoords = saved.srcCoords;
+ var srcCoords = [];
+ var destCoords = [];
+ var oldCoordTheSame = true;
+ for (var i = 0; i < 4; i++) {
+ var rect = markers[i].getBoundingClientRect();
+ var ii = 2 * i;
+ var x = rect.left;
+ var y = rect.top;
+ srcCoords.push(x, y);
+ oldCoordTheSame = oldCoordTheSame && oldSrcCoords && x === oldSrcCoords[ii] && y === oldSrcCoords[ii + 1];
+ destCoords.push(markers[i].offsetLeft, markers[i].offsetTop);
+ }
+ return (oldCoordTheSame && transformer)
+ ? transformer
+ : (saved.srcCoords = srcCoords,
+ saved[transformerName] = inverse
+ ? buildTransformer(destCoords, srcCoords)
+ : buildTransformer(srcCoords, destCoords));
+}
+function isCanvasEl(el) {
+ return el.nodeName.toUpperCase() === 'CANVAS';
+}
+var replaceReg = /([&<>"'])/g;
+var replaceMap = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ '\'': '''
+};
+function encodeHTML(source) {
+ return source == null
+ ? ''
+ : (source + '').replace(replaceReg, function (str, c) {
+ return replaceMap[c];
+ });
+}
+
+var MOUSE_EVENT_REG = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
+var _calcOut$1 = [];
+var firefoxNotSupportOffsetXY = env.browser.firefox
+ && +env.browser.version.split('.')[0] < 39;
+function clientToLocal(el, e, out, calculate) {
+ out = out || {};
+ if (calculate) {
+ calculateZrXY(el, e, out);
+ }
+ else if (firefoxNotSupportOffsetXY
+ && e.layerX != null
+ && e.layerX !== e.offsetX) {
+ out.zrX = e.layerX;
+ out.zrY = e.layerY;
+ }
+ else if (e.offsetX != null) {
+ out.zrX = e.offsetX;
+ out.zrY = e.offsetY;
+ }
+ else {
+ calculateZrXY(el, e, out);
+ }
+ return out;
+}
+function calculateZrXY(el, e, out) {
+ if (env.domSupported && el.getBoundingClientRect) {
+ var ex = e.clientX;
+ var ey = e.clientY;
+ if (isCanvasEl(el)) {
+ var box = el.getBoundingClientRect();
+ out.zrX = ex - box.left;
+ out.zrY = ey - box.top;
+ return;
+ }
+ else {
+ if (transformCoordWithViewport(_calcOut$1, el, ex, ey)) {
+ out.zrX = _calcOut$1[0];
+ out.zrY = _calcOut$1[1];
+ return;
+ }
+ }
+ }
+ out.zrX = out.zrY = 0;
+}
+function getNativeEvent(e) {
+ return e
+ || window.event;
+}
+function normalizeEvent(el, e, calculate) {
+ e = getNativeEvent(e);
+ if (e.zrX != null) {
+ return e;
+ }
+ var eventType = e.type;
+ var isTouch = eventType && eventType.indexOf('touch') >= 0;
+ if (!isTouch) {
+ clientToLocal(el, e, e, calculate);
+ var wheelDelta = getWheelDeltaMayPolyfill(e);
+ e.zrDelta = wheelDelta ? wheelDelta / 120 : -(e.detail || 0) / 3;
+ }
+ else {
+ var touch = eventType !== 'touchend'
+ ? e.targetTouches[0]
+ : e.changedTouches[0];
+ touch && clientToLocal(el, touch, e, calculate);
+ }
+ var button = e.button;
+ if (e.which == null && button !== undefined && MOUSE_EVENT_REG.test(e.type)) {
+ e.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));
+ }
+ return e;
+}
+function getWheelDeltaMayPolyfill(e) {
+ var rawWheelDelta = e.wheelDelta;
+ if (rawWheelDelta) {
+ return rawWheelDelta;
+ }
+ var deltaX = e.deltaX;
+ var deltaY = e.deltaY;
+ if (deltaX == null || deltaY == null) {
+ return rawWheelDelta;
+ }
+ var delta = deltaY !== 0 ? Math.abs(deltaY) : Math.abs(deltaX);
+ var sign = deltaY > 0 ? -1
+ : deltaY < 0 ? 1
+ : deltaX > 0 ? -1
+ : 1;
+ return 3 * delta * sign;
+}
+function addEventListener(el, name, handler, opt) {
+ el.addEventListener(name, handler, opt);
+}
+function removeEventListener(el, name, handler, opt) {
+ el.removeEventListener(name, handler, opt);
+}
+var stop = function (e) {
+ e.preventDefault();
+ e.stopPropagation();
+ e.cancelBubble = true;
+};
+function isMiddleOrRightButtonOnMouseUpDown(e) {
+ return e.which === 2 || e.which === 3;
+}
+
+var GestureMgr = (function () {
+ function GestureMgr() {
+ this._track = [];
+ }
+ GestureMgr.prototype.recognize = function (event, target, root) {
+ this._doTrack(event, target, root);
+ return this._recognize(event);
+ };
+ GestureMgr.prototype.clear = function () {
+ this._track.length = 0;
+ return this;
+ };
+ GestureMgr.prototype._doTrack = function (event, target, root) {
+ var touches = event.touches;
+ if (!touches) {
+ return;
+ }
+ var trackItem = {
+ points: [],
+ touches: [],
+ target: target,
+ event: event
+ };
+ for (var i = 0, len = touches.length; i < len; i++) {
+ var touch = touches[i];
+ var pos = clientToLocal(root, touch, {});
+ trackItem.points.push([pos.zrX, pos.zrY]);
+ trackItem.touches.push(touch);
+ }
+ this._track.push(trackItem);
+ };
+ GestureMgr.prototype._recognize = function (event) {
+ for (var eventName in recognizers) {
+ if (recognizers.hasOwnProperty(eventName)) {
+ var gestureInfo = recognizers[eventName](this._track, event);
+ if (gestureInfo) {
+ return gestureInfo;
+ }
+ }
+ }
+ };
+ return GestureMgr;
+}());
+function dist$1(pointPair) {
+ var dx = pointPair[1][0] - pointPair[0][0];
+ var dy = pointPair[1][1] - pointPair[0][1];
+ return Math.sqrt(dx * dx + dy * dy);
+}
+function center(pointPair) {
+ return [
+ (pointPair[0][0] + pointPair[1][0]) / 2,
+ (pointPair[0][1] + pointPair[1][1]) / 2
+ ];
+}
+var recognizers = {
+ pinch: function (tracks, event) {
+ var trackLen = tracks.length;
+ if (!trackLen) {
+ return;
+ }
+ var pinchEnd = (tracks[trackLen - 1] || {}).points;
+ var pinchPre = (tracks[trackLen - 2] || {}).points || pinchEnd;
+ if (pinchPre
+ && pinchPre.length > 1
+ && pinchEnd
+ && pinchEnd.length > 1) {
+ var pinchScale = dist$1(pinchEnd) / dist$1(pinchPre);
+ !isFinite(pinchScale) && (pinchScale = 1);
+ event.pinchScale = pinchScale;
+ var pinchCenter = center(pinchEnd);
+ event.pinchX = pinchCenter[0];
+ event.pinchY = pinchCenter[1];
+ return {
+ type: 'pinch',
+ target: tracks[0].target,
+ event: event
+ };
+ }
+ }
+};
+
+function create$1() {
+ return [1, 0, 0, 1, 0, 0];
+}
+function identity(out) {
+ out[0] = 1;
+ out[1] = 0;
+ out[2] = 0;
+ out[3] = 1;
+ out[4] = 0;
+ out[5] = 0;
+ return out;
+}
+function copy$1(out, m) {
+ out[0] = m[0];
+ out[1] = m[1];
+ out[2] = m[2];
+ out[3] = m[3];
+ out[4] = m[4];
+ out[5] = m[5];
+ return out;
+}
+function mul$1(out, m1, m2) {
+ var out0 = m1[0] * m2[0] + m1[2] * m2[1];
+ var out1 = m1[1] * m2[0] + m1[3] * m2[1];
+ var out2 = m1[0] * m2[2] + m1[2] * m2[3];
+ var out3 = m1[1] * m2[2] + m1[3] * m2[3];
+ var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];
+ var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];
+ out[0] = out0;
+ out[1] = out1;
+ out[2] = out2;
+ out[3] = out3;
+ out[4] = out4;
+ out[5] = out5;
+ return out;
+}
+function translate(out, a, v) {
+ out[0] = a[0];
+ out[1] = a[1];
+ out[2] = a[2];
+ out[3] = a[3];
+ out[4] = a[4] + v[0];
+ out[5] = a[5] + v[1];
+ return out;
+}
+function rotate(out, a, rad, pivot) {
+ if (pivot === void 0) { pivot = [0, 0]; }
+ var aa = a[0];
+ var ac = a[2];
+ var atx = a[4];
+ var ab = a[1];
+ var ad = a[3];
+ var aty = a[5];
+ var st = Math.sin(rad);
+ var ct = Math.cos(rad);
+ out[0] = aa * ct + ab * st;
+ out[1] = -aa * st + ab * ct;
+ out[2] = ac * ct + ad * st;
+ out[3] = -ac * st + ct * ad;
+ out[4] = ct * (atx - pivot[0]) + st * (aty - pivot[1]) + pivot[0];
+ out[5] = ct * (aty - pivot[1]) - st * (atx - pivot[0]) + pivot[1];
+ return out;
+}
+function scale$1(out, a, v) {
+ var vx = v[0];
+ var vy = v[1];
+ out[0] = a[0] * vx;
+ out[1] = a[1] * vy;
+ out[2] = a[2] * vx;
+ out[3] = a[3] * vy;
+ out[4] = a[4] * vx;
+ out[5] = a[5] * vy;
+ return out;
+}
+function invert(out, a) {
+ var aa = a[0];
+ var ac = a[2];
+ var atx = a[4];
+ var ab = a[1];
+ var ad = a[3];
+ var aty = a[5];
+ var det = aa * ad - ab * ac;
+ if (!det) {
+ return null;
+ }
+ det = 1.0 / det;
+ out[0] = ad * det;
+ out[1] = -ab * det;
+ out[2] = -ac * det;
+ out[3] = aa * det;
+ out[4] = (ac * aty - ad * atx) * det;
+ out[5] = (ab * atx - aa * aty) * det;
+ return out;
+}
+function clone$2(a) {
+ var b = create$1();
+ copy$1(b, a);
+ return b;
+}
+
+var matrix = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ create: create$1,
+ identity: identity,
+ copy: copy$1,
+ mul: mul$1,
+ translate: translate,
+ rotate: rotate,
+ scale: scale$1,
+ invert: invert,
+ clone: clone$2
+});
+
+var Point = (function () {
+ function Point(x, y) {
+ this.x = x || 0;
+ this.y = y || 0;
+ }
+ Point.prototype.copy = function (other) {
+ this.x = other.x;
+ this.y = other.y;
+ return this;
+ };
+ Point.prototype.clone = function () {
+ return new Point(this.x, this.y);
+ };
+ Point.prototype.set = function (x, y) {
+ this.x = x;
+ this.y = y;
+ return this;
+ };
+ Point.prototype.equal = function (other) {
+ return other.x === this.x && other.y === this.y;
+ };
+ Point.prototype.add = function (other) {
+ this.x += other.x;
+ this.y += other.y;
+ return this;
+ };
+ Point.prototype.scale = function (scalar) {
+ this.x *= scalar;
+ this.y *= scalar;
+ };
+ Point.prototype.scaleAndAdd = function (other, scalar) {
+ this.x += other.x * scalar;
+ this.y += other.y * scalar;
+ };
+ Point.prototype.sub = function (other) {
+ this.x -= other.x;
+ this.y -= other.y;
+ return this;
+ };
+ Point.prototype.dot = function (other) {
+ return this.x * other.x + this.y * other.y;
+ };
+ Point.prototype.len = function () {
+ return Math.sqrt(this.x * this.x + this.y * this.y);
+ };
+ Point.prototype.lenSquare = function () {
+ return this.x * this.x + this.y * this.y;
+ };
+ Point.prototype.normalize = function () {
+ var len = this.len();
+ this.x /= len;
+ this.y /= len;
+ return this;
+ };
+ Point.prototype.distance = function (other) {
+ var dx = this.x - other.x;
+ var dy = this.y - other.y;
+ return Math.sqrt(dx * dx + dy * dy);
+ };
+ Point.prototype.distanceSquare = function (other) {
+ var dx = this.x - other.x;
+ var dy = this.y - other.y;
+ return dx * dx + dy * dy;
+ };
+ Point.prototype.negate = function () {
+ this.x = -this.x;
+ this.y = -this.y;
+ return this;
+ };
+ Point.prototype.transform = function (m) {
+ if (!m) {
+ return;
+ }
+ var x = this.x;
+ var y = this.y;
+ this.x = m[0] * x + m[2] * y + m[4];
+ this.y = m[1] * x + m[3] * y + m[5];
+ return this;
+ };
+ Point.prototype.toArray = function (out) {
+ out[0] = this.x;
+ out[1] = this.y;
+ return out;
+ };
+ Point.prototype.fromArray = function (input) {
+ this.x = input[0];
+ this.y = input[1];
+ };
+ Point.set = function (p, x, y) {
+ p.x = x;
+ p.y = y;
+ };
+ Point.copy = function (p, p2) {
+ p.x = p2.x;
+ p.y = p2.y;
+ };
+ Point.len = function (p) {
+ return Math.sqrt(p.x * p.x + p.y * p.y);
+ };
+ Point.lenSquare = function (p) {
+ return p.x * p.x + p.y * p.y;
+ };
+ Point.dot = function (p0, p1) {
+ return p0.x * p1.x + p0.y * p1.y;
+ };
+ Point.add = function (out, p0, p1) {
+ out.x = p0.x + p1.x;
+ out.y = p0.y + p1.y;
+ };
+ Point.sub = function (out, p0, p1) {
+ out.x = p0.x - p1.x;
+ out.y = p0.y - p1.y;
+ };
+ Point.scale = function (out, p0, scalar) {
+ out.x = p0.x * scalar;
+ out.y = p0.y * scalar;
+ };
+ Point.scaleAndAdd = function (out, p0, p1, scalar) {
+ out.x = p0.x + p1.x * scalar;
+ out.y = p0.y + p1.y * scalar;
+ };
+ Point.lerp = function (out, p0, p1, t) {
+ var onet = 1 - t;
+ out.x = onet * p0.x + t * p1.x;
+ out.y = onet * p0.y + t * p1.y;
+ };
+ return Point;
+}());
+
+var mathMin = Math.min;
+var mathMax = Math.max;
+var lt = new Point();
+var rb = new Point();
+var lb = new Point();
+var rt = new Point();
+var minTv = new Point();
+var maxTv = new Point();
+var BoundingRect = (function () {
+ function BoundingRect(x, y, width, height) {
+ if (width < 0) {
+ x = x + width;
+ width = -width;
+ }
+ if (height < 0) {
+ y = y + height;
+ height = -height;
+ }
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ }
+ BoundingRect.prototype.union = function (other) {
+ var x = mathMin(other.x, this.x);
+ var y = mathMin(other.y, this.y);
+ if (isFinite(this.x) && isFinite(this.width)) {
+ this.width = mathMax(other.x + other.width, this.x + this.width) - x;
+ }
+ else {
+ this.width = other.width;
+ }
+ if (isFinite(this.y) && isFinite(this.height)) {
+ this.height = mathMax(other.y + other.height, this.y + this.height) - y;
+ }
+ else {
+ this.height = other.height;
+ }
+ this.x = x;
+ this.y = y;
+ };
+ BoundingRect.prototype.applyTransform = function (m) {
+ BoundingRect.applyTransform(this, this, m);
+ };
+ BoundingRect.prototype.calculateTransform = function (b) {
+ var a = this;
+ var sx = b.width / a.width;
+ var sy = b.height / a.height;
+ var m = create$1();
+ translate(m, m, [-a.x, -a.y]);
+ scale$1(m, m, [sx, sy]);
+ translate(m, m, [b.x, b.y]);
+ return m;
+ };
+ BoundingRect.prototype.intersect = function (b, mtv) {
+ if (!b) {
+ return false;
+ }
+ if (!(b instanceof BoundingRect)) {
+ b = BoundingRect.create(b);
+ }
+ var a = this;
+ var ax0 = a.x;
+ var ax1 = a.x + a.width;
+ var ay0 = a.y;
+ var ay1 = a.y + a.height;
+ var bx0 = b.x;
+ var bx1 = b.x + b.width;
+ var by0 = b.y;
+ var by1 = b.y + b.height;
+ var overlap = !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);
+ if (mtv) {
+ var dMin = Infinity;
+ var dMax = 0;
+ var d0 = Math.abs(ax1 - bx0);
+ var d1 = Math.abs(bx1 - ax0);
+ var d2 = Math.abs(ay1 - by0);
+ var d3 = Math.abs(by1 - ay0);
+ var dx = Math.min(d0, d1);
+ var dy = Math.min(d2, d3);
+ if (ax1 < bx0 || bx1 < ax0) {
+ if (dx > dMax) {
+ dMax = dx;
+ if (d0 < d1) {
+ Point.set(maxTv, -d0, 0);
+ }
+ else {
+ Point.set(maxTv, d1, 0);
+ }
+ }
+ }
+ else {
+ if (dx < dMin) {
+ dMin = dx;
+ if (d0 < d1) {
+ Point.set(minTv, d0, 0);
+ }
+ else {
+ Point.set(minTv, -d1, 0);
+ }
+ }
+ }
+ if (ay1 < by0 || by1 < ay0) {
+ if (dy > dMax) {
+ dMax = dy;
+ if (d2 < d3) {
+ Point.set(maxTv, 0, -d2);
+ }
+ else {
+ Point.set(maxTv, 0, d3);
+ }
+ }
+ }
+ else {
+ if (dx < dMin) {
+ dMin = dx;
+ if (d2 < d3) {
+ Point.set(minTv, 0, d2);
+ }
+ else {
+ Point.set(minTv, 0, -d3);
+ }
+ }
+ }
+ }
+ if (mtv) {
+ Point.copy(mtv, overlap ? minTv : maxTv);
+ }
+ return overlap;
+ };
+ BoundingRect.prototype.contain = function (x, y) {
+ var rect = this;
+ return x >= rect.x
+ && x <= (rect.x + rect.width)
+ && y >= rect.y
+ && y <= (rect.y + rect.height);
+ };
+ BoundingRect.prototype.clone = function () {
+ return new BoundingRect(this.x, this.y, this.width, this.height);
+ };
+ BoundingRect.prototype.copy = function (other) {
+ BoundingRect.copy(this, other);
+ };
+ BoundingRect.prototype.plain = function () {
+ return {
+ x: this.x,
+ y: this.y,
+ width: this.width,
+ height: this.height
+ };
+ };
+ BoundingRect.prototype.isFinite = function () {
+ return isFinite(this.x)
+ && isFinite(this.y)
+ && isFinite(this.width)
+ && isFinite(this.height);
+ };
+ BoundingRect.prototype.isZero = function () {
+ return this.width === 0 || this.height === 0;
+ };
+ BoundingRect.create = function (rect) {
+ return new BoundingRect(rect.x, rect.y, rect.width, rect.height);
+ };
+ BoundingRect.copy = function (target, source) {
+ target.x = source.x;
+ target.y = source.y;
+ target.width = source.width;
+ target.height = source.height;
+ };
+ BoundingRect.applyTransform = function (target, source, m) {
+ if (!m) {
+ if (target !== source) {
+ BoundingRect.copy(target, source);
+ }
+ return;
+ }
+ if (m[1] < 1e-5 && m[1] > -1e-5 && m[2] < 1e-5 && m[2] > -1e-5) {
+ var sx = m[0];
+ var sy = m[3];
+ var tx = m[4];
+ var ty = m[5];
+ target.x = source.x * sx + tx;
+ target.y = source.y * sy + ty;
+ target.width = source.width * sx;
+ target.height = source.height * sy;
+ if (target.width < 0) {
+ target.x += target.width;
+ target.width = -target.width;
+ }
+ if (target.height < 0) {
+ target.y += target.height;
+ target.height = -target.height;
+ }
+ return;
+ }
+ lt.x = lb.x = source.x;
+ lt.y = rt.y = source.y;
+ rb.x = rt.x = source.x + source.width;
+ rb.y = lb.y = source.y + source.height;
+ lt.transform(m);
+ rt.transform(m);
+ rb.transform(m);
+ lb.transform(m);
+ target.x = mathMin(lt.x, rb.x, lb.x, rt.x);
+ target.y = mathMin(lt.y, rb.y, lb.y, rt.y);
+ var maxX = mathMax(lt.x, rb.x, lb.x, rt.x);
+ var maxY = mathMax(lt.y, rb.y, lb.y, rt.y);
+ target.width = maxX - target.x;
+ target.height = maxY - target.y;
+ };
+ return BoundingRect;
+}());
+
+var SILENT = 'silent';
+function makeEventPacket(eveType, targetInfo, event) {
+ return {
+ type: eveType,
+ event: event,
+ target: targetInfo.target,
+ topTarget: targetInfo.topTarget,
+ cancelBubble: false,
+ offsetX: event.zrX,
+ offsetY: event.zrY,
+ gestureEvent: event.gestureEvent,
+ pinchX: event.pinchX,
+ pinchY: event.pinchY,
+ pinchScale: event.pinchScale,
+ wheelDelta: event.zrDelta,
+ zrByTouch: event.zrByTouch,
+ which: event.which,
+ stop: stopEvent
+ };
+}
+function stopEvent() {
+ stop(this.event);
+}
+var EmptyProxy = (function (_super) {
+ __extends(EmptyProxy, _super);
+ function EmptyProxy() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.handler = null;
+ return _this;
+ }
+ EmptyProxy.prototype.dispose = function () { };
+ EmptyProxy.prototype.setCursor = function () { };
+ return EmptyProxy;
+}(Eventful));
+var HoveredResult = (function () {
+ function HoveredResult(x, y) {
+ this.x = x;
+ this.y = y;
+ }
+ return HoveredResult;
+}());
+var handlerNames = [
+ 'click', 'dblclick', 'mousewheel', 'mouseout',
+ 'mouseup', 'mousedown', 'mousemove', 'contextmenu'
+];
+var tmpRect = new BoundingRect(0, 0, 0, 0);
+var Handler = (function (_super) {
+ __extends(Handler, _super);
+ function Handler(storage, painter, proxy, painterRoot, pointerSize) {
+ var _this = _super.call(this) || this;
+ _this._hovered = new HoveredResult(0, 0);
+ _this.storage = storage;
+ _this.painter = painter;
+ _this.painterRoot = painterRoot;
+ _this._pointerSize = pointerSize;
+ proxy = proxy || new EmptyProxy();
+ _this.proxy = null;
+ _this.setHandlerProxy(proxy);
+ _this._draggingMgr = new Draggable(_this);
+ return _this;
+ }
+ Handler.prototype.setHandlerProxy = function (proxy) {
+ if (this.proxy) {
+ this.proxy.dispose();
+ }
+ if (proxy) {
+ each(handlerNames, function (name) {
+ proxy.on && proxy.on(name, this[name], this);
+ }, this);
+ proxy.handler = this;
+ }
+ this.proxy = proxy;
+ };
+ Handler.prototype.mousemove = function (event) {
+ var x = event.zrX;
+ var y = event.zrY;
+ var isOutside = isOutsideBoundary(this, x, y);
+ var lastHovered = this._hovered;
+ var lastHoveredTarget = lastHovered.target;
+ if (lastHoveredTarget && !lastHoveredTarget.__zr) {
+ lastHovered = this.findHover(lastHovered.x, lastHovered.y);
+ lastHoveredTarget = lastHovered.target;
+ }
+ var hovered = this._hovered = isOutside ? new HoveredResult(x, y) : this.findHover(x, y);
+ var hoveredTarget = hovered.target;
+ var proxy = this.proxy;
+ proxy.setCursor && proxy.setCursor(hoveredTarget ? hoveredTarget.cursor : 'default');
+ if (lastHoveredTarget && hoveredTarget !== lastHoveredTarget) {
+ this.dispatchToElement(lastHovered, 'mouseout', event);
+ }
+ this.dispatchToElement(hovered, 'mousemove', event);
+ if (hoveredTarget && hoveredTarget !== lastHoveredTarget) {
+ this.dispatchToElement(hovered, 'mouseover', event);
+ }
+ };
+ Handler.prototype.mouseout = function (event) {
+ var eventControl = event.zrEventControl;
+ if (eventControl !== 'only_globalout') {
+ this.dispatchToElement(this._hovered, 'mouseout', event);
+ }
+ if (eventControl !== 'no_globalout') {
+ this.trigger('globalout', { type: 'globalout', event: event });
+ }
+ };
+ Handler.prototype.resize = function () {
+ this._hovered = new HoveredResult(0, 0);
+ };
+ Handler.prototype.dispatch = function (eventName, eventArgs) {
+ var handler = this[eventName];
+ handler && handler.call(this, eventArgs);
+ };
+ Handler.prototype.dispose = function () {
+ this.proxy.dispose();
+ this.storage = null;
+ this.proxy = null;
+ this.painter = null;
+ };
+ Handler.prototype.setCursorStyle = function (cursorStyle) {
+ var proxy = this.proxy;
+ proxy.setCursor && proxy.setCursor(cursorStyle);
+ };
+ Handler.prototype.dispatchToElement = function (targetInfo, eventName, event) {
+ targetInfo = targetInfo || {};
+ var el = targetInfo.target;
+ if (el && el.silent) {
+ return;
+ }
+ var eventKey = ('on' + eventName);
+ var eventPacket = makeEventPacket(eventName, targetInfo, event);
+ while (el) {
+ el[eventKey]
+ && (eventPacket.cancelBubble = !!el[eventKey].call(el, eventPacket));
+ el.trigger(eventName, eventPacket);
+ el = el.__hostTarget ? el.__hostTarget : el.parent;
+ if (eventPacket.cancelBubble) {
+ break;
+ }
+ }
+ if (!eventPacket.cancelBubble) {
+ this.trigger(eventName, eventPacket);
+ if (this.painter && this.painter.eachOtherLayer) {
+ this.painter.eachOtherLayer(function (layer) {
+ if (typeof (layer[eventKey]) === 'function') {
+ layer[eventKey].call(layer, eventPacket);
+ }
+ if (layer.trigger) {
+ layer.trigger(eventName, eventPacket);
+ }
+ });
+ }
+ }
+ };
+ Handler.prototype.findHover = function (x, y, exclude) {
+ var list = this.storage.getDisplayList();
+ var out = new HoveredResult(x, y);
+ setHoverTarget(list, out, x, y, exclude);
+ if (this._pointerSize && !out.target) {
+ var candidates = [];
+ var pointerSize = this._pointerSize;
+ var targetSizeHalf = pointerSize / 2;
+ var pointerRect = new BoundingRect(x - targetSizeHalf, y - targetSizeHalf, pointerSize, pointerSize);
+ for (var i = list.length - 1; i >= 0; i--) {
+ var el = list[i];
+ if (el !== exclude
+ && !el.ignore
+ && !el.ignoreCoarsePointer
+ && (!el.parent || !el.parent.ignoreCoarsePointer)) {
+ tmpRect.copy(el.getBoundingRect());
+ if (el.transform) {
+ tmpRect.applyTransform(el.transform);
+ }
+ if (tmpRect.intersect(pointerRect)) {
+ candidates.push(el);
+ }
+ }
+ }
+ if (candidates.length) {
+ var rStep = 4;
+ var thetaStep = Math.PI / 12;
+ var PI2 = Math.PI * 2;
+ for (var r = 0; r < targetSizeHalf; r += rStep) {
+ for (var theta = 0; theta < PI2; theta += thetaStep) {
+ var x1 = x + r * Math.cos(theta);
+ var y1 = y + r * Math.sin(theta);
+ setHoverTarget(candidates, out, x1, y1, exclude);
+ if (out.target) {
+ return out;
+ }
+ }
+ }
+ }
+ }
+ return out;
+ };
+ Handler.prototype.processGesture = function (event, stage) {
+ if (!this._gestureMgr) {
+ this._gestureMgr = new GestureMgr();
+ }
+ var gestureMgr = this._gestureMgr;
+ stage === 'start' && gestureMgr.clear();
+ var gestureInfo = gestureMgr.recognize(event, this.findHover(event.zrX, event.zrY, null).target, this.proxy.dom);
+ stage === 'end' && gestureMgr.clear();
+ if (gestureInfo) {
+ var type = gestureInfo.type;
+ event.gestureEvent = type;
+ var res = new HoveredResult();
+ res.target = gestureInfo.target;
+ this.dispatchToElement(res, type, gestureInfo.event);
+ }
+ };
+ return Handler;
+}(Eventful));
+each(['click', 'mousedown', 'mouseup', 'mousewheel', 'dblclick', 'contextmenu'], function (name) {
+ Handler.prototype[name] = function (event) {
+ var x = event.zrX;
+ var y = event.zrY;
+ var isOutside = isOutsideBoundary(this, x, y);
+ var hovered;
+ var hoveredTarget;
+ if (name !== 'mouseup' || !isOutside) {
+ hovered = this.findHover(x, y);
+ hoveredTarget = hovered.target;
+ }
+ if (name === 'mousedown') {
+ this._downEl = hoveredTarget;
+ this._downPoint = [event.zrX, event.zrY];
+ this._upEl = hoveredTarget;
+ }
+ else if (name === 'mouseup') {
+ this._upEl = hoveredTarget;
+ }
+ else if (name === 'click') {
+ if (this._downEl !== this._upEl
+ || !this._downPoint
+ || dist(this._downPoint, [event.zrX, event.zrY]) > 4) {
+ return;
+ }
+ this._downPoint = null;
+ }
+ this.dispatchToElement(hovered, name, event);
+ };
+});
+function isHover(displayable, x, y) {
+ if (displayable[displayable.rectHover ? 'rectContain' : 'contain'](x, y)) {
+ var el = displayable;
+ var isSilent = void 0;
+ var ignoreClip = false;
+ while (el) {
+ if (el.ignoreClip) {
+ ignoreClip = true;
+ }
+ if (!ignoreClip) {
+ var clipPath = el.getClipPath();
+ if (clipPath && !clipPath.contain(x, y)) {
+ return false;
+ }
+ }
+ if (el.silent) {
+ isSilent = true;
+ }
+ var hostEl = el.__hostTarget;
+ el = hostEl ? hostEl : el.parent;
+ }
+ return isSilent ? SILENT : true;
+ }
+ return false;
+}
+function setHoverTarget(list, out, x, y, exclude) {
+ for (var i = list.length - 1; i >= 0; i--) {
+ var el = list[i];
+ var hoverCheckResult = void 0;
+ if (el !== exclude
+ && !el.ignore
+ && (hoverCheckResult = isHover(el, x, y))) {
+ !out.topTarget && (out.topTarget = el);
+ if (hoverCheckResult !== SILENT) {
+ out.target = el;
+ break;
+ }
+ }
+ }
+}
+function isOutsideBoundary(handlerInstance, x, y) {
+ var painter = handlerInstance.painter;
+ return x < 0 || x > painter.getWidth() || y < 0 || y > painter.getHeight();
+}
+
+var DEFAULT_MIN_MERGE = 32;
+var DEFAULT_MIN_GALLOPING = 7;
+function minRunLength(n) {
+ var r = 0;
+ while (n >= DEFAULT_MIN_MERGE) {
+ r |= n & 1;
+ n >>= 1;
+ }
+ return n + r;
+}
+function makeAscendingRun(array, lo, hi, compare) {
+ var runHi = lo + 1;
+ if (runHi === hi) {
+ return 1;
+ }
+ if (compare(array[runHi++], array[lo]) < 0) {
+ while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) {
+ runHi++;
+ }
+ reverseRun(array, lo, runHi);
+ }
+ else {
+ while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) {
+ runHi++;
+ }
+ }
+ return runHi - lo;
+}
+function reverseRun(array, lo, hi) {
+ hi--;
+ while (lo < hi) {
+ var t = array[lo];
+ array[lo++] = array[hi];
+ array[hi--] = t;
+ }
+}
+function binaryInsertionSort(array, lo, hi, start, compare) {
+ if (start === lo) {
+ start++;
+ }
+ for (; start < hi; start++) {
+ var pivot = array[start];
+ var left = lo;
+ var right = start;
+ var mid;
+ while (left < right) {
+ mid = left + right >>> 1;
+ if (compare(pivot, array[mid]) < 0) {
+ right = mid;
+ }
+ else {
+ left = mid + 1;
+ }
+ }
+ var n = start - left;
+ switch (n) {
+ case 3:
+ array[left + 3] = array[left + 2];
+ case 2:
+ array[left + 2] = array[left + 1];
+ case 1:
+ array[left + 1] = array[left];
+ break;
+ default:
+ while (n > 0) {
+ array[left + n] = array[left + n - 1];
+ n--;
+ }
+ }
+ array[left] = pivot;
+ }
+}
+function gallopLeft(value, array, start, length, hint, compare) {
+ var lastOffset = 0;
+ var maxOffset = 0;
+ var offset = 1;
+ if (compare(value, array[start + hint]) > 0) {
+ maxOffset = length - hint;
+ while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) {
+ lastOffset = offset;
+ offset = (offset << 1) + 1;
+ if (offset <= 0) {
+ offset = maxOffset;
+ }
+ }
+ if (offset > maxOffset) {
+ offset = maxOffset;
+ }
+ lastOffset += hint;
+ offset += hint;
+ }
+ else {
+ maxOffset = hint + 1;
+ while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) {
+ lastOffset = offset;
+ offset = (offset << 1) + 1;
+ if (offset <= 0) {
+ offset = maxOffset;
+ }
+ }
+ if (offset > maxOffset) {
+ offset = maxOffset;
+ }
+ var tmp = lastOffset;
+ lastOffset = hint - offset;
+ offset = hint - tmp;
+ }
+ lastOffset++;
+ while (lastOffset < offset) {
+ var m = lastOffset + (offset - lastOffset >>> 1);
+ if (compare(value, array[start + m]) > 0) {
+ lastOffset = m + 1;
+ }
+ else {
+ offset = m;
+ }
+ }
+ return offset;
+}
+function gallopRight(value, array, start, length, hint, compare) {
+ var lastOffset = 0;
+ var maxOffset = 0;
+ var offset = 1;
+ if (compare(value, array[start + hint]) < 0) {
+ maxOffset = hint + 1;
+ while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) {
+ lastOffset = offset;
+ offset = (offset << 1) + 1;
+ if (offset <= 0) {
+ offset = maxOffset;
+ }
+ }
+ if (offset > maxOffset) {
+ offset = maxOffset;
+ }
+ var tmp = lastOffset;
+ lastOffset = hint - offset;
+ offset = hint - tmp;
+ }
+ else {
+ maxOffset = length - hint;
+ while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) {
+ lastOffset = offset;
+ offset = (offset << 1) + 1;
+ if (offset <= 0) {
+ offset = maxOffset;
+ }
+ }
+ if (offset > maxOffset) {
+ offset = maxOffset;
+ }
+ lastOffset += hint;
+ offset += hint;
+ }
+ lastOffset++;
+ while (lastOffset < offset) {
+ var m = lastOffset + (offset - lastOffset >>> 1);
+ if (compare(value, array[start + m]) < 0) {
+ offset = m;
+ }
+ else {
+ lastOffset = m + 1;
+ }
+ }
+ return offset;
+}
+function TimSort(array, compare) {
+ var minGallop = DEFAULT_MIN_GALLOPING;
+ var runStart;
+ var runLength;
+ var stackSize = 0;
+ var tmp = [];
+ runStart = [];
+ runLength = [];
+ function pushRun(_runStart, _runLength) {
+ runStart[stackSize] = _runStart;
+ runLength[stackSize] = _runLength;
+ stackSize += 1;
+ }
+ function mergeRuns() {
+ while (stackSize > 1) {
+ var n = stackSize - 2;
+ if ((n >= 1 && runLength[n - 1] <= runLength[n] + runLength[n + 1])
+ || (n >= 2 && runLength[n - 2] <= runLength[n] + runLength[n - 1])) {
+ if (runLength[n - 1] < runLength[n + 1]) {
+ n--;
+ }
+ }
+ else if (runLength[n] > runLength[n + 1]) {
+ break;
+ }
+ mergeAt(n);
+ }
+ }
+ function forceMergeRuns() {
+ while (stackSize > 1) {
+ var n = stackSize - 2;
+ if (n > 0 && runLength[n - 1] < runLength[n + 1]) {
+ n--;
+ }
+ mergeAt(n);
+ }
+ }
+ function mergeAt(i) {
+ var start1 = runStart[i];
+ var length1 = runLength[i];
+ var start2 = runStart[i + 1];
+ var length2 = runLength[i + 1];
+ runLength[i] = length1 + length2;
+ if (i === stackSize - 3) {
+ runStart[i + 1] = runStart[i + 2];
+ runLength[i + 1] = runLength[i + 2];
+ }
+ stackSize--;
+ var k = gallopRight(array[start2], array, start1, length1, 0, compare);
+ start1 += k;
+ length1 -= k;
+ if (length1 === 0) {
+ return;
+ }
+ length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare);
+ if (length2 === 0) {
+ return;
+ }
+ if (length1 <= length2) {
+ mergeLow(start1, length1, start2, length2);
+ }
+ else {
+ mergeHigh(start1, length1, start2, length2);
+ }
+ }
+ function mergeLow(start1, length1, start2, length2) {
+ var i = 0;
+ for (i = 0; i < length1; i++) {
+ tmp[i] = array[start1 + i];
+ }
+ var cursor1 = 0;
+ var cursor2 = start2;
+ var dest = start1;
+ array[dest++] = array[cursor2++];
+ if (--length2 === 0) {
+ for (i = 0; i < length1; i++) {
+ array[dest + i] = tmp[cursor1 + i];
+ }
+ return;
+ }
+ if (length1 === 1) {
+ for (i = 0; i < length2; i++) {
+ array[dest + i] = array[cursor2 + i];
+ }
+ array[dest + length2] = tmp[cursor1];
+ return;
+ }
+ var _minGallop = minGallop;
+ var count1;
+ var count2;
+ var exit;
+ while (1) {
+ count1 = 0;
+ count2 = 0;
+ exit = false;
+ do {
+ if (compare(array[cursor2], tmp[cursor1]) < 0) {
+ array[dest++] = array[cursor2++];
+ count2++;
+ count1 = 0;
+ if (--length2 === 0) {
+ exit = true;
+ break;
+ }
+ }
+ else {
+ array[dest++] = tmp[cursor1++];
+ count1++;
+ count2 = 0;
+ if (--length1 === 1) {
+ exit = true;
+ break;
+ }
+ }
+ } while ((count1 | count2) < _minGallop);
+ if (exit) {
+ break;
+ }
+ do {
+ count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare);
+ if (count1 !== 0) {
+ for (i = 0; i < count1; i++) {
+ array[dest + i] = tmp[cursor1 + i];
+ }
+ dest += count1;
+ cursor1 += count1;
+ length1 -= count1;
+ if (length1 <= 1) {
+ exit = true;
+ break;
+ }
+ }
+ array[dest++] = array[cursor2++];
+ if (--length2 === 0) {
+ exit = true;
+ break;
+ }
+ count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare);
+ if (count2 !== 0) {
+ for (i = 0; i < count2; i++) {
+ array[dest + i] = array[cursor2 + i];
+ }
+ dest += count2;
+ cursor2 += count2;
+ length2 -= count2;
+ if (length2 === 0) {
+ exit = true;
+ break;
+ }
+ }
+ array[dest++] = tmp[cursor1++];
+ if (--length1 === 1) {
+ exit = true;
+ break;
+ }
+ _minGallop--;
+ } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+ if (exit) {
+ break;
+ }
+ if (_minGallop < 0) {
+ _minGallop = 0;
+ }
+ _minGallop += 2;
+ }
+ minGallop = _minGallop;
+ minGallop < 1 && (minGallop = 1);
+ if (length1 === 1) {
+ for (i = 0; i < length2; i++) {
+ array[dest + i] = array[cursor2 + i];
+ }
+ array[dest + length2] = tmp[cursor1];
+ }
+ else if (length1 === 0) {
+ throw new Error();
+ }
+ else {
+ for (i = 0; i < length1; i++) {
+ array[dest + i] = tmp[cursor1 + i];
+ }
+ }
+ }
+ function mergeHigh(start1, length1, start2, length2) {
+ var i = 0;
+ for (i = 0; i < length2; i++) {
+ tmp[i] = array[start2 + i];
+ }
+ var cursor1 = start1 + length1 - 1;
+ var cursor2 = length2 - 1;
+ var dest = start2 + length2 - 1;
+ var customCursor = 0;
+ var customDest = 0;
+ array[dest--] = array[cursor1--];
+ if (--length1 === 0) {
+ customCursor = dest - (length2 - 1);
+ for (i = 0; i < length2; i++) {
+ array[customCursor + i] = tmp[i];
+ }
+ return;
+ }
+ if (length2 === 1) {
+ dest -= length1;
+ cursor1 -= length1;
+ customDest = dest + 1;
+ customCursor = cursor1 + 1;
+ for (i = length1 - 1; i >= 0; i--) {
+ array[customDest + i] = array[customCursor + i];
+ }
+ array[dest] = tmp[cursor2];
+ return;
+ }
+ var _minGallop = minGallop;
+ while (true) {
+ var count1 = 0;
+ var count2 = 0;
+ var exit = false;
+ do {
+ if (compare(tmp[cursor2], array[cursor1]) < 0) {
+ array[dest--] = array[cursor1--];
+ count1++;
+ count2 = 0;
+ if (--length1 === 0) {
+ exit = true;
+ break;
+ }
+ }
+ else {
+ array[dest--] = tmp[cursor2--];
+ count2++;
+ count1 = 0;
+ if (--length2 === 1) {
+ exit = true;
+ break;
+ }
+ }
+ } while ((count1 | count2) < _minGallop);
+ if (exit) {
+ break;
+ }
+ do {
+ count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare);
+ if (count1 !== 0) {
+ dest -= count1;
+ cursor1 -= count1;
+ length1 -= count1;
+ customDest = dest + 1;
+ customCursor = cursor1 + 1;
+ for (i = count1 - 1; i >= 0; i--) {
+ array[customDest + i] = array[customCursor + i];
+ }
+ if (length1 === 0) {
+ exit = true;
+ break;
+ }
+ }
+ array[dest--] = tmp[cursor2--];
+ if (--length2 === 1) {
+ exit = true;
+ break;
+ }
+ count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
+ if (count2 !== 0) {
+ dest -= count2;
+ cursor2 -= count2;
+ length2 -= count2;
+ customDest = dest + 1;
+ customCursor = cursor2 + 1;
+ for (i = 0; i < count2; i++) {
+ array[customDest + i] = tmp[customCursor + i];
+ }
+ if (length2 <= 1) {
+ exit = true;
+ break;
+ }
+ }
+ array[dest--] = array[cursor1--];
+ if (--length1 === 0) {
+ exit = true;
+ break;
+ }
+ _minGallop--;
+ } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+ if (exit) {
+ break;
+ }
+ if (_minGallop < 0) {
+ _minGallop = 0;
+ }
+ _minGallop += 2;
+ }
+ minGallop = _minGallop;
+ if (minGallop < 1) {
+ minGallop = 1;
+ }
+ if (length2 === 1) {
+ dest -= length1;
+ cursor1 -= length1;
+ customDest = dest + 1;
+ customCursor = cursor1 + 1;
+ for (i = length1 - 1; i >= 0; i--) {
+ array[customDest + i] = array[customCursor + i];
+ }
+ array[dest] = tmp[cursor2];
+ }
+ else if (length2 === 0) {
+ throw new Error();
+ }
+ else {
+ customCursor = dest - (length2 - 1);
+ for (i = 0; i < length2; i++) {
+ array[customCursor + i] = tmp[i];
+ }
+ }
+ }
+ return {
+ mergeRuns: mergeRuns,
+ forceMergeRuns: forceMergeRuns,
+ pushRun: pushRun
+ };
+}
+function sort(array, compare, lo, hi) {
+ if (!lo) {
+ lo = 0;
+ }
+ if (!hi) {
+ hi = array.length;
+ }
+ var remaining = hi - lo;
+ if (remaining < 2) {
+ return;
+ }
+ var runLength = 0;
+ if (remaining < DEFAULT_MIN_MERGE) {
+ runLength = makeAscendingRun(array, lo, hi, compare);
+ binaryInsertionSort(array, lo, hi, lo + runLength, compare);
+ return;
+ }
+ var ts = TimSort(array, compare);
+ var minRun = minRunLength(remaining);
+ do {
+ runLength = makeAscendingRun(array, lo, hi, compare);
+ if (runLength < minRun) {
+ var force = remaining;
+ if (force > minRun) {
+ force = minRun;
+ }
+ binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
+ runLength = force;
+ }
+ ts.pushRun(lo, runLength);
+ ts.mergeRuns();
+ remaining -= runLength;
+ lo += runLength;
+ } while (remaining !== 0);
+ ts.forceMergeRuns();
+}
+
+var REDRAW_BIT = 1;
+var STYLE_CHANGED_BIT = 2;
+var SHAPE_CHANGED_BIT = 4;
+
+var invalidZErrorLogged = false;
+function logInvalidZError() {
+ if (invalidZErrorLogged) {
+ return;
+ }
+ invalidZErrorLogged = true;
+ console.warn('z / z2 / zlevel of displayable is invalid, which may cause unexpected errors');
+}
+function shapeCompareFunc(a, b) {
+ if (a.zlevel === b.zlevel) {
+ if (a.z === b.z) {
+ return a.z2 - b.z2;
+ }
+ return a.z - b.z;
+ }
+ return a.zlevel - b.zlevel;
+}
+var Storage = (function () {
+ function Storage() {
+ this._roots = [];
+ this._displayList = [];
+ this._displayListLen = 0;
+ this.displayableSortFunc = shapeCompareFunc;
+ }
+ Storage.prototype.traverse = function (cb, context) {
+ for (var i = 0; i < this._roots.length; i++) {
+ this._roots[i].traverse(cb, context);
+ }
+ };
+ Storage.prototype.getDisplayList = function (update, includeIgnore) {
+ includeIgnore = includeIgnore || false;
+ var displayList = this._displayList;
+ if (update || !displayList.length) {
+ this.updateDisplayList(includeIgnore);
+ }
+ return displayList;
+ };
+ Storage.prototype.updateDisplayList = function (includeIgnore) {
+ this._displayListLen = 0;
+ var roots = this._roots;
+ var displayList = this._displayList;
+ for (var i = 0, len = roots.length; i < len; i++) {
+ this._updateAndAddDisplayable(roots[i], null, includeIgnore);
+ }
+ displayList.length = this._displayListLen;
+ sort(displayList, shapeCompareFunc);
+ };
+ Storage.prototype._updateAndAddDisplayable = function (el, clipPaths, includeIgnore) {
+ if (el.ignore && !includeIgnore) {
+ return;
+ }
+ el.beforeUpdate();
+ el.update();
+ el.afterUpdate();
+ var userSetClipPath = el.getClipPath();
+ if (el.ignoreClip) {
+ clipPaths = null;
+ }
+ else if (userSetClipPath) {
+ if (clipPaths) {
+ clipPaths = clipPaths.slice();
+ }
+ else {
+ clipPaths = [];
+ }
+ var currentClipPath = userSetClipPath;
+ var parentClipPath = el;
+ while (currentClipPath) {
+ currentClipPath.parent = parentClipPath;
+ currentClipPath.updateTransform();
+ clipPaths.push(currentClipPath);
+ parentClipPath = currentClipPath;
+ currentClipPath = currentClipPath.getClipPath();
+ }
+ }
+ if (el.childrenRef) {
+ var children = el.childrenRef();
+ for (var i = 0; i < children.length; i++) {
+ var child = children[i];
+ if (el.__dirty) {
+ child.__dirty |= REDRAW_BIT;
+ }
+ this._updateAndAddDisplayable(child, clipPaths, includeIgnore);
+ }
+ el.__dirty = 0;
+ }
+ else {
+ var disp = el;
+ if (clipPaths && clipPaths.length) {
+ disp.__clipPaths = clipPaths;
+ }
+ else if (disp.__clipPaths && disp.__clipPaths.length > 0) {
+ disp.__clipPaths = [];
+ }
+ if (isNaN(disp.z)) {
+ logInvalidZError();
+ disp.z = 0;
+ }
+ if (isNaN(disp.z2)) {
+ logInvalidZError();
+ disp.z2 = 0;
+ }
+ if (isNaN(disp.zlevel)) {
+ logInvalidZError();
+ disp.zlevel = 0;
+ }
+ this._displayList[this._displayListLen++] = disp;
+ }
+ var decalEl = el.getDecalElement && el.getDecalElement();
+ if (decalEl) {
+ this._updateAndAddDisplayable(decalEl, clipPaths, includeIgnore);
+ }
+ var textGuide = el.getTextGuideLine();
+ if (textGuide) {
+ this._updateAndAddDisplayable(textGuide, clipPaths, includeIgnore);
+ }
+ var textEl = el.getTextContent();
+ if (textEl) {
+ this._updateAndAddDisplayable(textEl, clipPaths, includeIgnore);
+ }
+ };
+ Storage.prototype.addRoot = function (el) {
+ if (el.__zr && el.__zr.storage === this) {
+ return;
+ }
+ this._roots.push(el);
+ };
+ Storage.prototype.delRoot = function (el) {
+ if (el instanceof Array) {
+ for (var i = 0, l = el.length; i < l; i++) {
+ this.delRoot(el[i]);
+ }
+ return;
+ }
+ var idx = indexOf(this._roots, el);
+ if (idx >= 0) {
+ this._roots.splice(idx, 1);
+ }
+ };
+ Storage.prototype.delAllRoots = function () {
+ this._roots = [];
+ this._displayList = [];
+ this._displayListLen = 0;
+ return;
+ };
+ Storage.prototype.getRoots = function () {
+ return this._roots;
+ };
+ Storage.prototype.dispose = function () {
+ this._displayList = null;
+ this._roots = null;
+ };
+ return Storage;
+}());
+
+var requestAnimationFrame;
+requestAnimationFrame = (env.hasGlobalWindow
+ && ((window.requestAnimationFrame && window.requestAnimationFrame.bind(window))
+ || (window.msRequestAnimationFrame && window.msRequestAnimationFrame.bind(window))
+ || window.mozRequestAnimationFrame
+ || window.webkitRequestAnimationFrame)) || function (func) {
+ return setTimeout(func, 16);
+};
+var requestAnimationFrame$1 = requestAnimationFrame;
+
+var easingFuncs = {
+ linear: function (k) {
+ return k;
+ },
+ quadraticIn: function (k) {
+ return k * k;
+ },
+ quadraticOut: function (k) {
+ return k * (2 - k);
+ },
+ quadraticInOut: function (k) {
+ if ((k *= 2) < 1) {
+ return 0.5 * k * k;
+ }
+ return -0.5 * (--k * (k - 2) - 1);
+ },
+ cubicIn: function (k) {
+ return k * k * k;
+ },
+ cubicOut: function (k) {
+ return --k * k * k + 1;
+ },
+ cubicInOut: function (k) {
+ if ((k *= 2) < 1) {
+ return 0.5 * k * k * k;
+ }
+ return 0.5 * ((k -= 2) * k * k + 2);
+ },
+ quarticIn: function (k) {
+ return k * k * k * k;
+ },
+ quarticOut: function (k) {
+ return 1 - (--k * k * k * k);
+ },
+ quarticInOut: function (k) {
+ if ((k *= 2) < 1) {
+ return 0.5 * k * k * k * k;
+ }
+ return -0.5 * ((k -= 2) * k * k * k - 2);
+ },
+ quinticIn: function (k) {
+ return k * k * k * k * k;
+ },
+ quinticOut: function (k) {
+ return --k * k * k * k * k + 1;
+ },
+ quinticInOut: function (k) {
+ if ((k *= 2) < 1) {
+ return 0.5 * k * k * k * k * k;
+ }
+ return 0.5 * ((k -= 2) * k * k * k * k + 2);
+ },
+ sinusoidalIn: function (k) {
+ return 1 - Math.cos(k * Math.PI / 2);
+ },
+ sinusoidalOut: function (k) {
+ return Math.sin(k * Math.PI / 2);
+ },
+ sinusoidalInOut: function (k) {
+ return 0.5 * (1 - Math.cos(Math.PI * k));
+ },
+ exponentialIn: function (k) {
+ return k === 0 ? 0 : Math.pow(1024, k - 1);
+ },
+ exponentialOut: function (k) {
+ return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);
+ },
+ exponentialInOut: function (k) {
+ if (k === 0) {
+ return 0;
+ }
+ if (k === 1) {
+ return 1;
+ }
+ if ((k *= 2) < 1) {
+ return 0.5 * Math.pow(1024, k - 1);
+ }
+ return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);
+ },
+ circularIn: function (k) {
+ return 1 - Math.sqrt(1 - k * k);
+ },
+ circularOut: function (k) {
+ return Math.sqrt(1 - (--k * k));
+ },
+ circularInOut: function (k) {
+ if ((k *= 2) < 1) {
+ return -0.5 * (Math.sqrt(1 - k * k) - 1);
+ }
+ return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
+ },
+ elasticIn: function (k) {
+ var s;
+ var a = 0.1;
+ var p = 0.4;
+ if (k === 0) {
+ return 0;
+ }
+ if (k === 1) {
+ return 1;
+ }
+ if (!a || a < 1) {
+ a = 1;
+ s = p / 4;
+ }
+ else {
+ s = p * Math.asin(1 / a) / (2 * Math.PI);
+ }
+ return -(a * Math.pow(2, 10 * (k -= 1))
+ * Math.sin((k - s) * (2 * Math.PI) / p));
+ },
+ elasticOut: function (k) {
+ var s;
+ var a = 0.1;
+ var p = 0.4;
+ if (k === 0) {
+ return 0;
+ }
+ if (k === 1) {
+ return 1;
+ }
+ if (!a || a < 1) {
+ a = 1;
+ s = p / 4;
+ }
+ else {
+ s = p * Math.asin(1 / a) / (2 * Math.PI);
+ }
+ return (a * Math.pow(2, -10 * k)
+ * Math.sin((k - s) * (2 * Math.PI) / p) + 1);
+ },
+ elasticInOut: function (k) {
+ var s;
+ var a = 0.1;
+ var p = 0.4;
+ if (k === 0) {
+ return 0;
+ }
+ if (k === 1) {
+ return 1;
+ }
+ if (!a || a < 1) {
+ a = 1;
+ s = p / 4;
+ }
+ else {
+ s = p * Math.asin(1 / a) / (2 * Math.PI);
+ }
+ if ((k *= 2) < 1) {
+ return -0.5 * (a * Math.pow(2, 10 * (k -= 1))
+ * Math.sin((k - s) * (2 * Math.PI) / p));
+ }
+ return a * Math.pow(2, -10 * (k -= 1))
+ * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1;
+ },
+ backIn: function (k) {
+ var s = 1.70158;
+ return k * k * ((s + 1) * k - s);
+ },
+ backOut: function (k) {
+ var s = 1.70158;
+ return --k * k * ((s + 1) * k + s) + 1;
+ },
+ backInOut: function (k) {
+ var s = 1.70158 * 1.525;
+ if ((k *= 2) < 1) {
+ return 0.5 * (k * k * ((s + 1) * k - s));
+ }
+ return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);
+ },
+ bounceIn: function (k) {
+ return 1 - easingFuncs.bounceOut(1 - k);
+ },
+ bounceOut: function (k) {
+ if (k < (1 / 2.75)) {
+ return 7.5625 * k * k;
+ }
+ else if (k < (2 / 2.75)) {
+ return 7.5625 * (k -= (1.5 / 2.75)) * k + 0.75;
+ }
+ else if (k < (2.5 / 2.75)) {
+ return 7.5625 * (k -= (2.25 / 2.75)) * k + 0.9375;
+ }
+ else {
+ return 7.5625 * (k -= (2.625 / 2.75)) * k + 0.984375;
+ }
+ },
+ bounceInOut: function (k) {
+ if (k < 0.5) {
+ return easingFuncs.bounceIn(k * 2) * 0.5;
+ }
+ return easingFuncs.bounceOut(k * 2 - 1) * 0.5 + 0.5;
+ }
+};
+
+var mathPow = Math.pow;
+var mathSqrt = Math.sqrt;
+var EPSILON = 1e-8;
+var EPSILON_NUMERIC = 1e-4;
+var THREE_SQRT = mathSqrt(3);
+var ONE_THIRD = 1 / 3;
+var _v0 = create();
+var _v1 = create();
+var _v2 = create();
+function isAroundZero(val) {
+ return val > -EPSILON && val < EPSILON;
+}
+function isNotAroundZero(val) {
+ return val > EPSILON || val < -EPSILON;
+}
+function cubicAt(p0, p1, p2, p3, t) {
+ var onet = 1 - t;
+ return onet * onet * (onet * p0 + 3 * t * p1)
+ + t * t * (t * p3 + 3 * onet * p2);
+}
+function cubicDerivativeAt(p0, p1, p2, p3, t) {
+ var onet = 1 - t;
+ return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet
+ + (p3 - p2) * t * t);
+}
+function cubicRootAt(p0, p1, p2, p3, val, roots) {
+ var a = p3 + 3 * (p1 - p2) - p0;
+ var b = 3 * (p2 - p1 * 2 + p0);
+ var c = 3 * (p1 - p0);
+ var d = p0 - val;
+ var A = b * b - 3 * a * c;
+ var B = b * c - 9 * a * d;
+ var C = c * c - 3 * b * d;
+ var n = 0;
+ if (isAroundZero(A) && isAroundZero(B)) {
+ if (isAroundZero(b)) {
+ roots[0] = 0;
+ }
+ else {
+ var t1 = -c / b;
+ if (t1 >= 0 && t1 <= 1) {
+ roots[n++] = t1;
+ }
+ }
+ }
+ else {
+ var disc = B * B - 4 * A * C;
+ if (isAroundZero(disc)) {
+ var K = B / A;
+ var t1 = -b / a + K;
+ var t2 = -K / 2;
+ if (t1 >= 0 && t1 <= 1) {
+ roots[n++] = t1;
+ }
+ if (t2 >= 0 && t2 <= 1) {
+ roots[n++] = t2;
+ }
+ }
+ else if (disc > 0) {
+ var discSqrt = mathSqrt(disc);
+ var Y1 = A * b + 1.5 * a * (-B + discSqrt);
+ var Y2 = A * b + 1.5 * a * (-B - discSqrt);
+ if (Y1 < 0) {
+ Y1 = -mathPow(-Y1, ONE_THIRD);
+ }
+ else {
+ Y1 = mathPow(Y1, ONE_THIRD);
+ }
+ if (Y2 < 0) {
+ Y2 = -mathPow(-Y2, ONE_THIRD);
+ }
+ else {
+ Y2 = mathPow(Y2, ONE_THIRD);
+ }
+ var t1 = (-b - (Y1 + Y2)) / (3 * a);
+ if (t1 >= 0 && t1 <= 1) {
+ roots[n++] = t1;
+ }
+ }
+ else {
+ var T = (2 * A * b - 3 * a * B) / (2 * mathSqrt(A * A * A));
+ var theta = Math.acos(T) / 3;
+ var ASqrt = mathSqrt(A);
+ var tmp = Math.cos(theta);
+ var t1 = (-b - 2 * ASqrt * tmp) / (3 * a);
+ var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a);
+ var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a);
+ if (t1 >= 0 && t1 <= 1) {
+ roots[n++] = t1;
+ }
+ if (t2 >= 0 && t2 <= 1) {
+ roots[n++] = t2;
+ }
+ if (t3 >= 0 && t3 <= 1) {
+ roots[n++] = t3;
+ }
+ }
+ }
+ return n;
+}
+function cubicExtrema(p0, p1, p2, p3, extrema) {
+ var b = 6 * p2 - 12 * p1 + 6 * p0;
+ var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2;
+ var c = 3 * p1 - 3 * p0;
+ var n = 0;
+ if (isAroundZero(a)) {
+ if (isNotAroundZero(b)) {
+ var t1 = -c / b;
+ if (t1 >= 0 && t1 <= 1) {
+ extrema[n++] = t1;
+ }
+ }
+ }
+ else {
+ var disc = b * b - 4 * a * c;
+ if (isAroundZero(disc)) {
+ extrema[0] = -b / (2 * a);
+ }
+ else if (disc > 0) {
+ var discSqrt = mathSqrt(disc);
+ var t1 = (-b + discSqrt) / (2 * a);
+ var t2 = (-b - discSqrt) / (2 * a);
+ if (t1 >= 0 && t1 <= 1) {
+ extrema[n++] = t1;
+ }
+ if (t2 >= 0 && t2 <= 1) {
+ extrema[n++] = t2;
+ }
+ }
+ }
+ return n;
+}
+function cubicSubdivide(p0, p1, p2, p3, t, out) {
+ var p01 = (p1 - p0) * t + p0;
+ var p12 = (p2 - p1) * t + p1;
+ var p23 = (p3 - p2) * t + p2;
+ var p012 = (p12 - p01) * t + p01;
+ var p123 = (p23 - p12) * t + p12;
+ var p0123 = (p123 - p012) * t + p012;
+ out[0] = p0;
+ out[1] = p01;
+ out[2] = p012;
+ out[3] = p0123;
+ out[4] = p0123;
+ out[5] = p123;
+ out[6] = p23;
+ out[7] = p3;
+}
+function cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) {
+ var t;
+ var interval = 0.005;
+ var d = Infinity;
+ var prev;
+ var next;
+ var d1;
+ var d2;
+ _v0[0] = x;
+ _v0[1] = y;
+ for (var _t = 0; _t < 1; _t += 0.05) {
+ _v1[0] = cubicAt(x0, x1, x2, x3, _t);
+ _v1[1] = cubicAt(y0, y1, y2, y3, _t);
+ d1 = distSquare(_v0, _v1);
+ if (d1 < d) {
+ t = _t;
+ d = d1;
+ }
+ }
+ d = Infinity;
+ for (var i = 0; i < 32; i++) {
+ if (interval < EPSILON_NUMERIC) {
+ break;
+ }
+ prev = t - interval;
+ next = t + interval;
+ _v1[0] = cubicAt(x0, x1, x2, x3, prev);
+ _v1[1] = cubicAt(y0, y1, y2, y3, prev);
+ d1 = distSquare(_v1, _v0);
+ if (prev >= 0 && d1 < d) {
+ t = prev;
+ d = d1;
+ }
+ else {
+ _v2[0] = cubicAt(x0, x1, x2, x3, next);
+ _v2[1] = cubicAt(y0, y1, y2, y3, next);
+ d2 = distSquare(_v2, _v0);
+ if (next <= 1 && d2 < d) {
+ t = next;
+ d = d2;
+ }
+ else {
+ interval *= 0.5;
+ }
+ }
+ }
+ if (out) {
+ out[0] = cubicAt(x0, x1, x2, x3, t);
+ out[1] = cubicAt(y0, y1, y2, y3, t);
+ }
+ return mathSqrt(d);
+}
+function cubicLength(x0, y0, x1, y1, x2, y2, x3, y3, iteration) {
+ var px = x0;
+ var py = y0;
+ var d = 0;
+ var step = 1 / iteration;
+ for (var i = 1; i <= iteration; i++) {
+ var t = i * step;
+ var x = cubicAt(x0, x1, x2, x3, t);
+ var y = cubicAt(y0, y1, y2, y3, t);
+ var dx = x - px;
+ var dy = y - py;
+ d += Math.sqrt(dx * dx + dy * dy);
+ px = x;
+ py = y;
+ }
+ return d;
+}
+function quadraticAt(p0, p1, p2, t) {
+ var onet = 1 - t;
+ return onet * (onet * p0 + 2 * t * p1) + t * t * p2;
+}
+function quadraticDerivativeAt(p0, p1, p2, t) {
+ return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1));
+}
+function quadraticRootAt(p0, p1, p2, val, roots) {
+ var a = p0 - 2 * p1 + p2;
+ var b = 2 * (p1 - p0);
+ var c = p0 - val;
+ var n = 0;
+ if (isAroundZero(a)) {
+ if (isNotAroundZero(b)) {
+ var t1 = -c / b;
+ if (t1 >= 0 && t1 <= 1) {
+ roots[n++] = t1;
+ }
+ }
+ }
+ else {
+ var disc = b * b - 4 * a * c;
+ if (isAroundZero(disc)) {
+ var t1 = -b / (2 * a);
+ if (t1 >= 0 && t1 <= 1) {
+ roots[n++] = t1;
+ }
+ }
+ else if (disc > 0) {
+ var discSqrt = mathSqrt(disc);
+ var t1 = (-b + discSqrt) / (2 * a);
+ var t2 = (-b - discSqrt) / (2 * a);
+ if (t1 >= 0 && t1 <= 1) {
+ roots[n++] = t1;
+ }
+ if (t2 >= 0 && t2 <= 1) {
+ roots[n++] = t2;
+ }
+ }
+ }
+ return n;
+}
+function quadraticExtremum(p0, p1, p2) {
+ var divider = p0 + p2 - 2 * p1;
+ if (divider === 0) {
+ return 0.5;
+ }
+ else {
+ return (p0 - p1) / divider;
+ }
+}
+function quadraticSubdivide(p0, p1, p2, t, out) {
+ var p01 = (p1 - p0) * t + p0;
+ var p12 = (p2 - p1) * t + p1;
+ var p012 = (p12 - p01) * t + p01;
+ out[0] = p0;
+ out[1] = p01;
+ out[2] = p012;
+ out[3] = p012;
+ out[4] = p12;
+ out[5] = p2;
+}
+function quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) {
+ var t;
+ var interval = 0.005;
+ var d = Infinity;
+ _v0[0] = x;
+ _v0[1] = y;
+ for (var _t = 0; _t < 1; _t += 0.05) {
+ _v1[0] = quadraticAt(x0, x1, x2, _t);
+ _v1[1] = quadraticAt(y0, y1, y2, _t);
+ var d1 = distSquare(_v0, _v1);
+ if (d1 < d) {
+ t = _t;
+ d = d1;
+ }
+ }
+ d = Infinity;
+ for (var i = 0; i < 32; i++) {
+ if (interval < EPSILON_NUMERIC) {
+ break;
+ }
+ var prev = t - interval;
+ var next = t + interval;
+ _v1[0] = quadraticAt(x0, x1, x2, prev);
+ _v1[1] = quadraticAt(y0, y1, y2, prev);
+ var d1 = distSquare(_v1, _v0);
+ if (prev >= 0 && d1 < d) {
+ t = prev;
+ d = d1;
+ }
+ else {
+ _v2[0] = quadraticAt(x0, x1, x2, next);
+ _v2[1] = quadraticAt(y0, y1, y2, next);
+ var d2 = distSquare(_v2, _v0);
+ if (next <= 1 && d2 < d) {
+ t = next;
+ d = d2;
+ }
+ else {
+ interval *= 0.5;
+ }
+ }
+ }
+ if (out) {
+ out[0] = quadraticAt(x0, x1, x2, t);
+ out[1] = quadraticAt(y0, y1, y2, t);
+ }
+ return mathSqrt(d);
+}
+function quadraticLength(x0, y0, x1, y1, x2, y2, iteration) {
+ var px = x0;
+ var py = y0;
+ var d = 0;
+ var step = 1 / iteration;
+ for (var i = 1; i <= iteration; i++) {
+ var t = i * step;
+ var x = quadraticAt(x0, x1, x2, t);
+ var y = quadraticAt(y0, y1, y2, t);
+ var dx = x - px;
+ var dy = y - py;
+ d += Math.sqrt(dx * dx + dy * dy);
+ px = x;
+ py = y;
+ }
+ return d;
+}
+
+var regexp = /cubic-bezier\(([0-9,\.e ]+)\)/;
+function createCubicEasingFunc(cubicEasingStr) {
+ var cubic = cubicEasingStr && regexp.exec(cubicEasingStr);
+ if (cubic) {
+ var points = cubic[1].split(',');
+ var a_1 = +trim(points[0]);
+ var b_1 = +trim(points[1]);
+ var c_1 = +trim(points[2]);
+ var d_1 = +trim(points[3]);
+ if (isNaN(a_1 + b_1 + c_1 + d_1)) {
+ return;
+ }
+ var roots_1 = [];
+ return function (p) {
+ return p <= 0
+ ? 0 : p >= 1
+ ? 1
+ : cubicRootAt(0, a_1, c_1, 1, p, roots_1) && cubicAt(0, b_1, d_1, 1, roots_1[0]);
+ };
+ }
+}
+
+var Clip = (function () {
+ function Clip(opts) {
+ this._inited = false;
+ this._startTime = 0;
+ this._pausedTime = 0;
+ this._paused = false;
+ this._life = opts.life || 1000;
+ this._delay = opts.delay || 0;
+ this.loop = opts.loop || false;
+ this.onframe = opts.onframe || noop;
+ this.ondestroy = opts.ondestroy || noop;
+ this.onrestart = opts.onrestart || noop;
+ opts.easing && this.setEasing(opts.easing);
+ }
+ Clip.prototype.step = function (globalTime, deltaTime) {
+ if (!this._inited) {
+ this._startTime = globalTime + this._delay;
+ this._inited = true;
+ }
+ if (this._paused) {
+ this._pausedTime += deltaTime;
+ return;
+ }
+ var life = this._life;
+ var elapsedTime = globalTime - this._startTime - this._pausedTime;
+ var percent = elapsedTime / life;
+ if (percent < 0) {
+ percent = 0;
+ }
+ percent = Math.min(percent, 1);
+ var easingFunc = this.easingFunc;
+ var schedule = easingFunc ? easingFunc(percent) : percent;
+ this.onframe(schedule);
+ if (percent === 1) {
+ if (this.loop) {
+ var remainder = elapsedTime % life;
+ this._startTime = globalTime - remainder;
+ this._pausedTime = 0;
+ this.onrestart();
+ }
+ else {
+ return true;
+ }
+ }
+ return false;
+ };
+ Clip.prototype.pause = function () {
+ this._paused = true;
+ };
+ Clip.prototype.resume = function () {
+ this._paused = false;
+ };
+ Clip.prototype.setEasing = function (easing) {
+ this.easing = easing;
+ this.easingFunc = isFunction(easing)
+ ? easing
+ : easingFuncs[easing] || createCubicEasingFunc(easing);
+ };
+ return Clip;
+}());
+
+var Entry = (function () {
+ function Entry(val) {
+ this.value = val;
+ }
+ return Entry;
+}());
+var LinkedList = (function () {
+ function LinkedList() {
+ this._len = 0;
+ }
+ LinkedList.prototype.insert = function (val) {
+ var entry = new Entry(val);
+ this.insertEntry(entry);
+ return entry;
+ };
+ LinkedList.prototype.insertEntry = function (entry) {
+ if (!this.head) {
+ this.head = this.tail = entry;
+ }
+ else {
+ this.tail.next = entry;
+ entry.prev = this.tail;
+ entry.next = null;
+ this.tail = entry;
+ }
+ this._len++;
+ };
+ LinkedList.prototype.remove = function (entry) {
+ var prev = entry.prev;
+ var next = entry.next;
+ if (prev) {
+ prev.next = next;
+ }
+ else {
+ this.head = next;
+ }
+ if (next) {
+ next.prev = prev;
+ }
+ else {
+ this.tail = prev;
+ }
+ entry.next = entry.prev = null;
+ this._len--;
+ };
+ LinkedList.prototype.len = function () {
+ return this._len;
+ };
+ LinkedList.prototype.clear = function () {
+ this.head = this.tail = null;
+ this._len = 0;
+ };
+ return LinkedList;
+}());
+var LRU = (function () {
+ function LRU(maxSize) {
+ this._list = new LinkedList();
+ this._maxSize = 10;
+ this._map = {};
+ this._maxSize = maxSize;
+ }
+ LRU.prototype.put = function (key, value) {
+ var list = this._list;
+ var map = this._map;
+ var removed = null;
+ if (map[key] == null) {
+ var len = list.len();
+ var entry = this._lastRemovedEntry;
+ if (len >= this._maxSize && len > 0) {
+ var leastUsedEntry = list.head;
+ list.remove(leastUsedEntry);
+ delete map[leastUsedEntry.key];
+ removed = leastUsedEntry.value;
+ this._lastRemovedEntry = leastUsedEntry;
+ }
+ if (entry) {
+ entry.value = value;
+ }
+ else {
+ entry = new Entry(value);
+ }
+ entry.key = key;
+ list.insertEntry(entry);
+ map[key] = entry;
+ }
+ return removed;
+ };
+ LRU.prototype.get = function (key) {
+ var entry = this._map[key];
+ var list = this._list;
+ if (entry != null) {
+ if (entry !== list.tail) {
+ list.remove(entry);
+ list.insertEntry(entry);
+ }
+ return entry.value;
+ }
+ };
+ LRU.prototype.clear = function () {
+ this._list.clear();
+ this._map = {};
+ };
+ LRU.prototype.len = function () {
+ return this._list.len();
+ };
+ return LRU;
+}());
+
+var kCSSColorTable = {
+ 'transparent': [0, 0, 0, 0], 'aliceblue': [240, 248, 255, 1],
+ 'antiquewhite': [250, 235, 215, 1], 'aqua': [0, 255, 255, 1],
+ 'aquamarine': [127, 255, 212, 1], 'azure': [240, 255, 255, 1],
+ 'beige': [245, 245, 220, 1], 'bisque': [255, 228, 196, 1],
+ 'black': [0, 0, 0, 1], 'blanchedalmond': [255, 235, 205, 1],
+ 'blue': [0, 0, 255, 1], 'blueviolet': [138, 43, 226, 1],
+ 'brown': [165, 42, 42, 1], 'burlywood': [222, 184, 135, 1],
+ 'cadetblue': [95, 158, 160, 1], 'chartreuse': [127, 255, 0, 1],
+ 'chocolate': [210, 105, 30, 1], 'coral': [255, 127, 80, 1],
+ 'cornflowerblue': [100, 149, 237, 1], 'cornsilk': [255, 248, 220, 1],
+ 'crimson': [220, 20, 60, 1], 'cyan': [0, 255, 255, 1],
+ 'darkblue': [0, 0, 139, 1], 'darkcyan': [0, 139, 139, 1],
+ 'darkgoldenrod': [184, 134, 11, 1], 'darkgray': [169, 169, 169, 1],
+ 'darkgreen': [0, 100, 0, 1], 'darkgrey': [169, 169, 169, 1],
+ 'darkkhaki': [189, 183, 107, 1], 'darkmagenta': [139, 0, 139, 1],
+ 'darkolivegreen': [85, 107, 47, 1], 'darkorange': [255, 140, 0, 1],
+ 'darkorchid': [153, 50, 204, 1], 'darkred': [139, 0, 0, 1],
+ 'darksalmon': [233, 150, 122, 1], 'darkseagreen': [143, 188, 143, 1],
+ 'darkslateblue': [72, 61, 139, 1], 'darkslategray': [47, 79, 79, 1],
+ 'darkslategrey': [47, 79, 79, 1], 'darkturquoise': [0, 206, 209, 1],
+ 'darkviolet': [148, 0, 211, 1], 'deeppink': [255, 20, 147, 1],
+ 'deepskyblue': [0, 191, 255, 1], 'dimgray': [105, 105, 105, 1],
+ 'dimgrey': [105, 105, 105, 1], 'dodgerblue': [30, 144, 255, 1],
+ 'firebrick': [178, 34, 34, 1], 'floralwhite': [255, 250, 240, 1],
+ 'forestgreen': [34, 139, 34, 1], 'fuchsia': [255, 0, 255, 1],
+ 'gainsboro': [220, 220, 220, 1], 'ghostwhite': [248, 248, 255, 1],
+ 'gold': [255, 215, 0, 1], 'goldenrod': [218, 165, 32, 1],
+ 'gray': [128, 128, 128, 1], 'green': [0, 128, 0, 1],
+ 'greenyellow': [173, 255, 47, 1], 'grey': [128, 128, 128, 1],
+ 'honeydew': [240, 255, 240, 1], 'hotpink': [255, 105, 180, 1],
+ 'indianred': [205, 92, 92, 1], 'indigo': [75, 0, 130, 1],
+ 'ivory': [255, 255, 240, 1], 'khaki': [240, 230, 140, 1],
+ 'lavender': [230, 230, 250, 1], 'lavenderblush': [255, 240, 245, 1],
+ 'lawngreen': [124, 252, 0, 1], 'lemonchiffon': [255, 250, 205, 1],
+ 'lightblue': [173, 216, 230, 1], 'lightcoral': [240, 128, 128, 1],
+ 'lightcyan': [224, 255, 255, 1], 'lightgoldenrodyellow': [250, 250, 210, 1],
+ 'lightgray': [211, 211, 211, 1], 'lightgreen': [144, 238, 144, 1],
+ 'lightgrey': [211, 211, 211, 1], 'lightpink': [255, 182, 193, 1],
+ 'lightsalmon': [255, 160, 122, 1], 'lightseagreen': [32, 178, 170, 1],
+ 'lightskyblue': [135, 206, 250, 1], 'lightslategray': [119, 136, 153, 1],
+ 'lightslategrey': [119, 136, 153, 1], 'lightsteelblue': [176, 196, 222, 1],
+ 'lightyellow': [255, 255, 224, 1], 'lime': [0, 255, 0, 1],
+ 'limegreen': [50, 205, 50, 1], 'linen': [250, 240, 230, 1],
+ 'magenta': [255, 0, 255, 1], 'maroon': [128, 0, 0, 1],
+ 'mediumaquamarine': [102, 205, 170, 1], 'mediumblue': [0, 0, 205, 1],
+ 'mediumorchid': [186, 85, 211, 1], 'mediumpurple': [147, 112, 219, 1],
+ 'mediumseagreen': [60, 179, 113, 1], 'mediumslateblue': [123, 104, 238, 1],
+ 'mediumspringgreen': [0, 250, 154, 1], 'mediumturquoise': [72, 209, 204, 1],
+ 'mediumvioletred': [199, 21, 133, 1], 'midnightblue': [25, 25, 112, 1],
+ 'mintcream': [245, 255, 250, 1], 'mistyrose': [255, 228, 225, 1],
+ 'moccasin': [255, 228, 181, 1], 'navajowhite': [255, 222, 173, 1],
+ 'navy': [0, 0, 128, 1], 'oldlace': [253, 245, 230, 1],
+ 'olive': [128, 128, 0, 1], 'olivedrab': [107, 142, 35, 1],
+ 'orange': [255, 165, 0, 1], 'orangered': [255, 69, 0, 1],
+ 'orchid': [218, 112, 214, 1], 'palegoldenrod': [238, 232, 170, 1],
+ 'palegreen': [152, 251, 152, 1], 'paleturquoise': [175, 238, 238, 1],
+ 'palevioletred': [219, 112, 147, 1], 'papayawhip': [255, 239, 213, 1],
+ 'peachpuff': [255, 218, 185, 1], 'peru': [205, 133, 63, 1],
+ 'pink': [255, 192, 203, 1], 'plum': [221, 160, 221, 1],
+ 'powderblue': [176, 224, 230, 1], 'purple': [128, 0, 128, 1],
+ 'red': [255, 0, 0, 1], 'rosybrown': [188, 143, 143, 1],
+ 'royalblue': [65, 105, 225, 1], 'saddlebrown': [139, 69, 19, 1],
+ 'salmon': [250, 128, 114, 1], 'sandybrown': [244, 164, 96, 1],
+ 'seagreen': [46, 139, 87, 1], 'seashell': [255, 245, 238, 1],
+ 'sienna': [160, 82, 45, 1], 'silver': [192, 192, 192, 1],
+ 'skyblue': [135, 206, 235, 1], 'slateblue': [106, 90, 205, 1],
+ 'slategray': [112, 128, 144, 1], 'slategrey': [112, 128, 144, 1],
+ 'snow': [255, 250, 250, 1], 'springgreen': [0, 255, 127, 1],
+ 'steelblue': [70, 130, 180, 1], 'tan': [210, 180, 140, 1],
+ 'teal': [0, 128, 128, 1], 'thistle': [216, 191, 216, 1],
+ 'tomato': [255, 99, 71, 1], 'turquoise': [64, 224, 208, 1],
+ 'violet': [238, 130, 238, 1], 'wheat': [245, 222, 179, 1],
+ 'white': [255, 255, 255, 1], 'whitesmoke': [245, 245, 245, 1],
+ 'yellow': [255, 255, 0, 1], 'yellowgreen': [154, 205, 50, 1]
+};
+function clampCssByte(i) {
+ i = Math.round(i);
+ return i < 0 ? 0 : i > 255 ? 255 : i;
+}
+function clampCssAngle(i) {
+ i = Math.round(i);
+ return i < 0 ? 0 : i > 360 ? 360 : i;
+}
+function clampCssFloat(f) {
+ return f < 0 ? 0 : f > 1 ? 1 : f;
+}
+function parseCssInt(val) {
+ var str = val;
+ if (str.length && str.charAt(str.length - 1) === '%') {
+ return clampCssByte(parseFloat(str) / 100 * 255);
+ }
+ return clampCssByte(parseInt(str, 10));
+}
+function parseCssFloat(val) {
+ var str = val;
+ if (str.length && str.charAt(str.length - 1) === '%') {
+ return clampCssFloat(parseFloat(str) / 100);
+ }
+ return clampCssFloat(parseFloat(str));
+}
+function cssHueToRgb(m1, m2, h) {
+ if (h < 0) {
+ h += 1;
+ }
+ else if (h > 1) {
+ h -= 1;
+ }
+ if (h * 6 < 1) {
+ return m1 + (m2 - m1) * h * 6;
+ }
+ if (h * 2 < 1) {
+ return m2;
+ }
+ if (h * 3 < 2) {
+ return m1 + (m2 - m1) * (2 / 3 - h) * 6;
+ }
+ return m1;
+}
+function lerpNumber(a, b, p) {
+ return a + (b - a) * p;
+}
+function setRgba(out, r, g, b, a) {
+ out[0] = r;
+ out[1] = g;
+ out[2] = b;
+ out[3] = a;
+ return out;
+}
+function copyRgba(out, a) {
+ out[0] = a[0];
+ out[1] = a[1];
+ out[2] = a[2];
+ out[3] = a[3];
+ return out;
+}
+var colorCache = new LRU(20);
+var lastRemovedArr = null;
+function putToCache(colorStr, rgbaArr) {
+ if (lastRemovedArr) {
+ copyRgba(lastRemovedArr, rgbaArr);
+ }
+ lastRemovedArr = colorCache.put(colorStr, lastRemovedArr || (rgbaArr.slice()));
+}
+function parse(colorStr, rgbaArr) {
+ if (!colorStr) {
+ return;
+ }
+ rgbaArr = rgbaArr || [];
+ var cached = colorCache.get(colorStr);
+ if (cached) {
+ return copyRgba(rgbaArr, cached);
+ }
+ colorStr = colorStr + '';
+ var str = colorStr.replace(/ /g, '').toLowerCase();
+ if (str in kCSSColorTable) {
+ copyRgba(rgbaArr, kCSSColorTable[str]);
+ putToCache(colorStr, rgbaArr);
+ return rgbaArr;
+ }
+ var strLen = str.length;
+ if (str.charAt(0) === '#') {
+ if (strLen === 4 || strLen === 5) {
+ var iv = parseInt(str.slice(1, 4), 16);
+ if (!(iv >= 0 && iv <= 0xfff)) {
+ setRgba(rgbaArr, 0, 0, 0, 1);
+ return;
+ }
+ setRgba(rgbaArr, ((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8), (iv & 0xf0) | ((iv & 0xf0) >> 4), (iv & 0xf) | ((iv & 0xf) << 4), strLen === 5 ? parseInt(str.slice(4), 16) / 0xf : 1);
+ putToCache(colorStr, rgbaArr);
+ return rgbaArr;
+ }
+ else if (strLen === 7 || strLen === 9) {
+ var iv = parseInt(str.slice(1, 7), 16);
+ if (!(iv >= 0 && iv <= 0xffffff)) {
+ setRgba(rgbaArr, 0, 0, 0, 1);
+ return;
+ }
+ setRgba(rgbaArr, (iv & 0xff0000) >> 16, (iv & 0xff00) >> 8, iv & 0xff, strLen === 9 ? parseInt(str.slice(7), 16) / 0xff : 1);
+ putToCache(colorStr, rgbaArr);
+ return rgbaArr;
+ }
+ return;
+ }
+ var op = str.indexOf('(');
+ var ep = str.indexOf(')');
+ if (op !== -1 && ep + 1 === strLen) {
+ var fname = str.substr(0, op);
+ var params = str.substr(op + 1, ep - (op + 1)).split(',');
+ var alpha = 1;
+ switch (fname) {
+ case 'rgba':
+ if (params.length !== 4) {
+ return params.length === 3
+ ? setRgba(rgbaArr, +params[0], +params[1], +params[2], 1)
+ : setRgba(rgbaArr, 0, 0, 0, 1);
+ }
+ alpha = parseCssFloat(params.pop());
+ case 'rgb':
+ if (params.length >= 3) {
+ setRgba(rgbaArr, parseCssInt(params[0]), parseCssInt(params[1]), parseCssInt(params[2]), params.length === 3 ? alpha : parseCssFloat(params[3]));
+ putToCache(colorStr, rgbaArr);
+ return rgbaArr;
+ }
+ else {
+ setRgba(rgbaArr, 0, 0, 0, 1);
+ return;
+ }
+ case 'hsla':
+ if (params.length !== 4) {
+ setRgba(rgbaArr, 0, 0, 0, 1);
+ return;
+ }
+ params[3] = parseCssFloat(params[3]);
+ hsla2rgba(params, rgbaArr);
+ putToCache(colorStr, rgbaArr);
+ return rgbaArr;
+ case 'hsl':
+ if (params.length !== 3) {
+ setRgba(rgbaArr, 0, 0, 0, 1);
+ return;
+ }
+ hsla2rgba(params, rgbaArr);
+ putToCache(colorStr, rgbaArr);
+ return rgbaArr;
+ default:
+ return;
+ }
+ }
+ setRgba(rgbaArr, 0, 0, 0, 1);
+ return;
+}
+function hsla2rgba(hsla, rgba) {
+ var h = (((parseFloat(hsla[0]) % 360) + 360) % 360) / 360;
+ var s = parseCssFloat(hsla[1]);
+ var l = parseCssFloat(hsla[2]);
+ var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
+ var m1 = l * 2 - m2;
+ rgba = rgba || [];
+ setRgba(rgba, clampCssByte(cssHueToRgb(m1, m2, h + 1 / 3) * 255), clampCssByte(cssHueToRgb(m1, m2, h) * 255), clampCssByte(cssHueToRgb(m1, m2, h - 1 / 3) * 255), 1);
+ if (hsla.length === 4) {
+ rgba[3] = hsla[3];
+ }
+ return rgba;
+}
+function rgba2hsla(rgba) {
+ if (!rgba) {
+ return;
+ }
+ var R = rgba[0] / 255;
+ var G = rgba[1] / 255;
+ var B = rgba[2] / 255;
+ var vMin = Math.min(R, G, B);
+ var vMax = Math.max(R, G, B);
+ var delta = vMax - vMin;
+ var L = (vMax + vMin) / 2;
+ var H;
+ var S;
+ if (delta === 0) {
+ H = 0;
+ S = 0;
+ }
+ else {
+ if (L < 0.5) {
+ S = delta / (vMax + vMin);
+ }
+ else {
+ S = delta / (2 - vMax - vMin);
+ }
+ var deltaR = (((vMax - R) / 6) + (delta / 2)) / delta;
+ var deltaG = (((vMax - G) / 6) + (delta / 2)) / delta;
+ var deltaB = (((vMax - B) / 6) + (delta / 2)) / delta;
+ if (R === vMax) {
+ H = deltaB - deltaG;
+ }
+ else if (G === vMax) {
+ H = (1 / 3) + deltaR - deltaB;
+ }
+ else if (B === vMax) {
+ H = (2 / 3) + deltaG - deltaR;
+ }
+ if (H < 0) {
+ H += 1;
+ }
+ if (H > 1) {
+ H -= 1;
+ }
+ }
+ var hsla = [H * 360, S, L];
+ if (rgba[3] != null) {
+ hsla.push(rgba[3]);
+ }
+ return hsla;
+}
+function lift(color, level) {
+ var colorArr = parse(color);
+ if (colorArr) {
+ for (var i = 0; i < 3; i++) {
+ if (level < 0) {
+ colorArr[i] = colorArr[i] * (1 - level) | 0;
+ }
+ else {
+ colorArr[i] = ((255 - colorArr[i]) * level + colorArr[i]) | 0;
+ }
+ if (colorArr[i] > 255) {
+ colorArr[i] = 255;
+ }
+ else if (colorArr[i] < 0) {
+ colorArr[i] = 0;
+ }
+ }
+ return stringify(colorArr, colorArr.length === 4 ? 'rgba' : 'rgb');
+ }
+}
+function toHex(color) {
+ var colorArr = parse(color);
+ if (colorArr) {
+ return ((1 << 24) + (colorArr[0] << 16) + (colorArr[1] << 8) + (+colorArr[2])).toString(16).slice(1);
+ }
+}
+function fastLerp(normalizedValue, colors, out) {
+ if (!(colors && colors.length)
+ || !(normalizedValue >= 0 && normalizedValue <= 1)) {
+ return;
+ }
+ out = out || [];
+ var value = normalizedValue * (colors.length - 1);
+ var leftIndex = Math.floor(value);
+ var rightIndex = Math.ceil(value);
+ var leftColor = colors[leftIndex];
+ var rightColor = colors[rightIndex];
+ var dv = value - leftIndex;
+ out[0] = clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv));
+ out[1] = clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv));
+ out[2] = clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv));
+ out[3] = clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv));
+ return out;
+}
+var fastMapToColor = fastLerp;
+function lerp$1(normalizedValue, colors, fullOutput) {
+ if (!(colors && colors.length)
+ || !(normalizedValue >= 0 && normalizedValue <= 1)) {
+ return;
+ }
+ var value = normalizedValue * (colors.length - 1);
+ var leftIndex = Math.floor(value);
+ var rightIndex = Math.ceil(value);
+ var leftColor = parse(colors[leftIndex]);
+ var rightColor = parse(colors[rightIndex]);
+ var dv = value - leftIndex;
+ var color = stringify([
+ clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv)),
+ clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv)),
+ clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv)),
+ clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv))
+ ], 'rgba');
+ return fullOutput
+ ? {
+ color: color,
+ leftIndex: leftIndex,
+ rightIndex: rightIndex,
+ value: value
+ }
+ : color;
+}
+var mapToColor = lerp$1;
+function modifyHSL(color, h, s, l) {
+ var colorArr = parse(color);
+ if (color) {
+ colorArr = rgba2hsla(colorArr);
+ h != null && (colorArr[0] = clampCssAngle(h));
+ s != null && (colorArr[1] = parseCssFloat(s));
+ l != null && (colorArr[2] = parseCssFloat(l));
+ return stringify(hsla2rgba(colorArr), 'rgba');
+ }
+}
+function modifyAlpha(color, alpha) {
+ var colorArr = parse(color);
+ if (colorArr && alpha != null) {
+ colorArr[3] = clampCssFloat(alpha);
+ return stringify(colorArr, 'rgba');
+ }
+}
+function stringify(arrColor, type) {
+ if (!arrColor || !arrColor.length) {
+ return;
+ }
+ var colorStr = arrColor[0] + ',' + arrColor[1] + ',' + arrColor[2];
+ if (type === 'rgba' || type === 'hsva' || type === 'hsla') {
+ colorStr += ',' + arrColor[3];
+ }
+ return type + '(' + colorStr + ')';
+}
+function lum(color, backgroundLum) {
+ var arr = parse(color);
+ return arr
+ ? (0.299 * arr[0] + 0.587 * arr[1] + 0.114 * arr[2]) * arr[3] / 255
+ + (1 - arr[3]) * backgroundLum
+ : 0;
+}
+function random() {
+ return stringify([
+ Math.round(Math.random() * 255),
+ Math.round(Math.random() * 255),
+ Math.round(Math.random() * 255)
+ ], 'rgb');
+}
+var liftedColorCache = new LRU(100);
+function liftColor(color) {
+ if (isString(color)) {
+ var liftedColor = liftedColorCache.get(color);
+ if (!liftedColor) {
+ liftedColor = lift(color, -0.1);
+ liftedColorCache.put(color, liftedColor);
+ }
+ return liftedColor;
+ }
+ else if (isGradientObject(color)) {
+ var ret = extend({}, color);
+ ret.colorStops = map(color.colorStops, function (stop) { return ({
+ offset: stop.offset,
+ color: lift(stop.color, -0.1)
+ }); });
+ return ret;
+ }
+ return color;
+}
+
+var color = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ parse: parse,
+ lift: lift,
+ toHex: toHex,
+ fastLerp: fastLerp,
+ fastMapToColor: fastMapToColor,
+ lerp: lerp$1,
+ mapToColor: mapToColor,
+ modifyHSL: modifyHSL,
+ modifyAlpha: modifyAlpha,
+ stringify: stringify,
+ lum: lum,
+ random: random,
+ liftColor: liftColor
+});
+
+var mathRound = Math.round;
+function normalizeColor(color) {
+ var opacity;
+ if (!color || color === 'transparent') {
+ color = 'none';
+ }
+ else if (typeof color === 'string' && color.indexOf('rgba') > -1) {
+ var arr = parse(color);
+ if (arr) {
+ color = 'rgb(' + arr[0] + ',' + arr[1] + ',' + arr[2] + ')';
+ opacity = arr[3];
+ }
+ }
+ return {
+ color: color,
+ opacity: opacity == null ? 1 : opacity
+ };
+}
+var EPSILON$1 = 1e-4;
+function isAroundZero$1(transform) {
+ return transform < EPSILON$1 && transform > -EPSILON$1;
+}
+function round3(transform) {
+ return mathRound(transform * 1e3) / 1e3;
+}
+function round4(transform) {
+ return mathRound(transform * 1e4) / 1e4;
+}
+function getMatrixStr(m) {
+ return 'matrix('
+ + round3(m[0]) + ','
+ + round3(m[1]) + ','
+ + round3(m[2]) + ','
+ + round3(m[3]) + ','
+ + round4(m[4]) + ','
+ + round4(m[5])
+ + ')';
+}
+var TEXT_ALIGN_TO_ANCHOR = {
+ left: 'start',
+ right: 'end',
+ center: 'middle',
+ middle: 'middle'
+};
+function adjustTextY(y, lineHeight, textBaseline) {
+ if (textBaseline === 'top') {
+ y += lineHeight / 2;
+ }
+ else if (textBaseline === 'bottom') {
+ y -= lineHeight / 2;
+ }
+ return y;
+}
+function hasShadow(style) {
+ return style
+ && (style.shadowBlur || style.shadowOffsetX || style.shadowOffsetY);
+}
+function getShadowKey(displayable) {
+ var style = displayable.style;
+ var globalScale = displayable.getGlobalScale();
+ return [
+ style.shadowColor,
+ (style.shadowBlur || 0).toFixed(2),
+ (style.shadowOffsetX || 0).toFixed(2),
+ (style.shadowOffsetY || 0).toFixed(2),
+ globalScale[0],
+ globalScale[1]
+ ].join(',');
+}
+function isImagePattern(val) {
+ return val && (!!val.image);
+}
+function isSVGPattern(val) {
+ return val && (!!val.svgElement);
+}
+function isPattern(val) {
+ return isImagePattern(val) || isSVGPattern(val);
+}
+function isLinearGradient(val) {
+ return val.type === 'linear';
+}
+function isRadialGradient(val) {
+ return val.type === 'radial';
+}
+function isGradient(val) {
+ return val && (val.type === 'linear'
+ || val.type === 'radial');
+}
+function getIdURL(id) {
+ return "url(#" + id + ")";
+}
+function getPathPrecision(el) {
+ var scale = el.getGlobalScale();
+ var size = Math.max(scale[0], scale[1]);
+ return Math.max(Math.ceil(Math.log(size) / Math.log(10)), 1);
+}
+function getSRTTransformString(transform) {
+ var x = transform.x || 0;
+ var y = transform.y || 0;
+ var rotation = (transform.rotation || 0) * RADIAN_TO_DEGREE;
+ var scaleX = retrieve2(transform.scaleX, 1);
+ var scaleY = retrieve2(transform.scaleY, 1);
+ var skewX = transform.skewX || 0;
+ var skewY = transform.skewY || 0;
+ var res = [];
+ if (x || y) {
+ res.push("translate(" + x + "px," + y + "px)");
+ }
+ if (rotation) {
+ res.push("rotate(" + rotation + ")");
+ }
+ if (scaleX !== 1 || scaleY !== 1) {
+ res.push("scale(" + scaleX + "," + scaleY + ")");
+ }
+ if (skewX || skewY) {
+ res.push("skew(" + mathRound(skewX * RADIAN_TO_DEGREE) + "deg, " + mathRound(skewY * RADIAN_TO_DEGREE) + "deg)");
+ }
+ return res.join(' ');
+}
+var encodeBase64 = (function () {
+ if (env.hasGlobalWindow && isFunction(window.btoa)) {
+ return function (str) {
+ return window.btoa(unescape(encodeURIComponent(str)));
+ };
+ }
+ if (typeof Buffer !== 'undefined') {
+ return function (str) {
+ return Buffer.from(str).toString('base64');
+ };
+ }
+ return function (str) {
+ if ("development" !== 'production') {
+ logError('Base64 isn\'t natively supported in the current environment.');
+ }
+ return null;
+ };
+})();
+
+var arraySlice = Array.prototype.slice;
+function interpolateNumber(p0, p1, percent) {
+ return (p1 - p0) * percent + p0;
+}
+function interpolate1DArray(out, p0, p1, percent) {
+ var len = p0.length;
+ for (var i = 0; i < len; i++) {
+ out[i] = interpolateNumber(p0[i], p1[i], percent);
+ }
+ return out;
+}
+function interpolate2DArray(out, p0, p1, percent) {
+ var len = p0.length;
+ var len2 = len && p0[0].length;
+ for (var i = 0; i < len; i++) {
+ if (!out[i]) {
+ out[i] = [];
+ }
+ for (var j = 0; j < len2; j++) {
+ out[i][j] = interpolateNumber(p0[i][j], p1[i][j], percent);
+ }
+ }
+ return out;
+}
+function add1DArray(out, p0, p1, sign) {
+ var len = p0.length;
+ for (var i = 0; i < len; i++) {
+ out[i] = p0[i] + p1[i] * sign;
+ }
+ return out;
+}
+function add2DArray(out, p0, p1, sign) {
+ var len = p0.length;
+ var len2 = len && p0[0].length;
+ for (var i = 0; i < len; i++) {
+ if (!out[i]) {
+ out[i] = [];
+ }
+ for (var j = 0; j < len2; j++) {
+ out[i][j] = p0[i][j] + p1[i][j] * sign;
+ }
+ }
+ return out;
+}
+function fillColorStops(val0, val1) {
+ var len0 = val0.length;
+ var len1 = val1.length;
+ var shorterArr = len0 > len1 ? val1 : val0;
+ var shorterLen = Math.min(len0, len1);
+ var last = shorterArr[shorterLen - 1] || { color: [0, 0, 0, 0], offset: 0 };
+ for (var i = shorterLen; i < Math.max(len0, len1); i++) {
+ shorterArr.push({
+ offset: last.offset,
+ color: last.color.slice()
+ });
+ }
+}
+function fillArray(val0, val1, arrDim) {
+ var arr0 = val0;
+ var arr1 = val1;
+ if (!arr0.push || !arr1.push) {
+ return;
+ }
+ var arr0Len = arr0.length;
+ var arr1Len = arr1.length;
+ if (arr0Len !== arr1Len) {
+ var isPreviousLarger = arr0Len > arr1Len;
+ if (isPreviousLarger) {
+ arr0.length = arr1Len;
+ }
+ else {
+ for (var i = arr0Len; i < arr1Len; i++) {
+ arr0.push(arrDim === 1 ? arr1[i] : arraySlice.call(arr1[i]));
+ }
+ }
+ }
+ var len2 = arr0[0] && arr0[0].length;
+ for (var i = 0; i < arr0.length; i++) {
+ if (arrDim === 1) {
+ if (isNaN(arr0[i])) {
+ arr0[i] = arr1[i];
+ }
+ }
+ else {
+ for (var j = 0; j < len2; j++) {
+ if (isNaN(arr0[i][j])) {
+ arr0[i][j] = arr1[i][j];
+ }
+ }
+ }
+ }
+}
+function cloneValue(value) {
+ if (isArrayLike(value)) {
+ var len = value.length;
+ if (isArrayLike(value[0])) {
+ var ret = [];
+ for (var i = 0; i < len; i++) {
+ ret.push(arraySlice.call(value[i]));
+ }
+ return ret;
+ }
+ return arraySlice.call(value);
+ }
+ return value;
+}
+function rgba2String(rgba) {
+ rgba[0] = Math.floor(rgba[0]) || 0;
+ rgba[1] = Math.floor(rgba[1]) || 0;
+ rgba[2] = Math.floor(rgba[2]) || 0;
+ rgba[3] = rgba[3] == null ? 1 : rgba[3];
+ return 'rgba(' + rgba.join(',') + ')';
+}
+function guessArrayDim(value) {
+ return isArrayLike(value && value[0]) ? 2 : 1;
+}
+var VALUE_TYPE_NUMBER = 0;
+var VALUE_TYPE_1D_ARRAY = 1;
+var VALUE_TYPE_2D_ARRAY = 2;
+var VALUE_TYPE_COLOR = 3;
+var VALUE_TYPE_LINEAR_GRADIENT = 4;
+var VALUE_TYPE_RADIAL_GRADIENT = 5;
+var VALUE_TYPE_UNKOWN = 6;
+function isGradientValueType(valType) {
+ return valType === VALUE_TYPE_LINEAR_GRADIENT || valType === VALUE_TYPE_RADIAL_GRADIENT;
+}
+function isArrayValueType(valType) {
+ return valType === VALUE_TYPE_1D_ARRAY || valType === VALUE_TYPE_2D_ARRAY;
+}
+var tmpRgba = [0, 0, 0, 0];
+var Track = (function () {
+ function Track(propName) {
+ this.keyframes = [];
+ this.discrete = false;
+ this._invalid = false;
+ this._needsSort = false;
+ this._lastFr = 0;
+ this._lastFrP = 0;
+ this.propName = propName;
+ }
+ Track.prototype.isFinished = function () {
+ return this._finished;
+ };
+ Track.prototype.setFinished = function () {
+ this._finished = true;
+ if (this._additiveTrack) {
+ this._additiveTrack.setFinished();
+ }
+ };
+ Track.prototype.needsAnimate = function () {
+ return this.keyframes.length >= 1;
+ };
+ Track.prototype.getAdditiveTrack = function () {
+ return this._additiveTrack;
+ };
+ Track.prototype.addKeyframe = function (time, rawValue, easing) {
+ this._needsSort = true;
+ var keyframes = this.keyframes;
+ var len = keyframes.length;
+ var discrete = false;
+ var valType = VALUE_TYPE_UNKOWN;
+ var value = rawValue;
+ if (isArrayLike(rawValue)) {
+ var arrayDim = guessArrayDim(rawValue);
+ valType = arrayDim;
+ if (arrayDim === 1 && !isNumber(rawValue[0])
+ || arrayDim === 2 && !isNumber(rawValue[0][0])) {
+ discrete = true;
+ }
+ }
+ else {
+ if (isNumber(rawValue) && !eqNaN(rawValue)) {
+ valType = VALUE_TYPE_NUMBER;
+ }
+ else if (isString(rawValue)) {
+ if (!isNaN(+rawValue)) {
+ valType = VALUE_TYPE_NUMBER;
+ }
+ else {
+ var colorArray = parse(rawValue);
+ if (colorArray) {
+ value = colorArray;
+ valType = VALUE_TYPE_COLOR;
+ }
+ }
+ }
+ else if (isGradientObject(rawValue)) {
+ var parsedGradient = extend({}, value);
+ parsedGradient.colorStops = map(rawValue.colorStops, function (colorStop) { return ({
+ offset: colorStop.offset,
+ color: parse(colorStop.color)
+ }); });
+ if (isLinearGradient(rawValue)) {
+ valType = VALUE_TYPE_LINEAR_GRADIENT;
+ }
+ else if (isRadialGradient(rawValue)) {
+ valType = VALUE_TYPE_RADIAL_GRADIENT;
+ }
+ value = parsedGradient;
+ }
+ }
+ if (len === 0) {
+ this.valType = valType;
+ }
+ else if (valType !== this.valType || valType === VALUE_TYPE_UNKOWN) {
+ discrete = true;
+ }
+ this.discrete = this.discrete || discrete;
+ var kf = {
+ time: time,
+ value: value,
+ rawValue: rawValue,
+ percent: 0
+ };
+ if (easing) {
+ kf.easing = easing;
+ kf.easingFunc = isFunction(easing)
+ ? easing
+ : easingFuncs[easing] || createCubicEasingFunc(easing);
+ }
+ keyframes.push(kf);
+ return kf;
+ };
+ Track.prototype.prepare = function (maxTime, additiveTrack) {
+ var kfs = this.keyframes;
+ if (this._needsSort) {
+ kfs.sort(function (a, b) {
+ return a.time - b.time;
+ });
+ }
+ var valType = this.valType;
+ var kfsLen = kfs.length;
+ var lastKf = kfs[kfsLen - 1];
+ var isDiscrete = this.discrete;
+ var isArr = isArrayValueType(valType);
+ var isGradient = isGradientValueType(valType);
+ for (var i = 0; i < kfsLen; i++) {
+ var kf = kfs[i];
+ var value = kf.value;
+ var lastValue = lastKf.value;
+ kf.percent = kf.time / maxTime;
+ if (!isDiscrete) {
+ if (isArr && i !== kfsLen - 1) {
+ fillArray(value, lastValue, valType);
+ }
+ else if (isGradient) {
+ fillColorStops(value.colorStops, lastValue.colorStops);
+ }
+ }
+ }
+ if (!isDiscrete
+ && valType !== VALUE_TYPE_RADIAL_GRADIENT
+ && additiveTrack
+ && this.needsAnimate()
+ && additiveTrack.needsAnimate()
+ && valType === additiveTrack.valType
+ && !additiveTrack._finished) {
+ this._additiveTrack = additiveTrack;
+ var startValue = kfs[0].value;
+ for (var i = 0; i < kfsLen; i++) {
+ if (valType === VALUE_TYPE_NUMBER) {
+ kfs[i].additiveValue = kfs[i].value - startValue;
+ }
+ else if (valType === VALUE_TYPE_COLOR) {
+ kfs[i].additiveValue =
+ add1DArray([], kfs[i].value, startValue, -1);
+ }
+ else if (isArrayValueType(valType)) {
+ kfs[i].additiveValue = valType === VALUE_TYPE_1D_ARRAY
+ ? add1DArray([], kfs[i].value, startValue, -1)
+ : add2DArray([], kfs[i].value, startValue, -1);
+ }
+ }
+ }
+ };
+ Track.prototype.step = function (target, percent) {
+ if (this._finished) {
+ return;
+ }
+ if (this._additiveTrack && this._additiveTrack._finished) {
+ this._additiveTrack = null;
+ }
+ var isAdditive = this._additiveTrack != null;
+ var valueKey = isAdditive ? 'additiveValue' : 'value';
+ var valType = this.valType;
+ var keyframes = this.keyframes;
+ var kfsNum = keyframes.length;
+ var propName = this.propName;
+ var isValueColor = valType === VALUE_TYPE_COLOR;
+ var frameIdx;
+ var lastFrame = this._lastFr;
+ var mathMin = Math.min;
+ var frame;
+ var nextFrame;
+ if (kfsNum === 1) {
+ frame = nextFrame = keyframes[0];
+ }
+ else {
+ if (percent < 0) {
+ frameIdx = 0;
+ }
+ else if (percent < this._lastFrP) {
+ var start = mathMin(lastFrame + 1, kfsNum - 1);
+ for (frameIdx = start; frameIdx >= 0; frameIdx--) {
+ if (keyframes[frameIdx].percent <= percent) {
+ break;
+ }
+ }
+ frameIdx = mathMin(frameIdx, kfsNum - 2);
+ }
+ else {
+ for (frameIdx = lastFrame; frameIdx < kfsNum; frameIdx++) {
+ if (keyframes[frameIdx].percent > percent) {
+ break;
+ }
+ }
+ frameIdx = mathMin(frameIdx - 1, kfsNum - 2);
+ }
+ nextFrame = keyframes[frameIdx + 1];
+ frame = keyframes[frameIdx];
+ }
+ if (!(frame && nextFrame)) {
+ return;
+ }
+ this._lastFr = frameIdx;
+ this._lastFrP = percent;
+ var interval = (nextFrame.percent - frame.percent);
+ var w = interval === 0 ? 1 : mathMin((percent - frame.percent) / interval, 1);
+ if (nextFrame.easingFunc) {
+ w = nextFrame.easingFunc(w);
+ }
+ var targetArr = isAdditive ? this._additiveValue
+ : (isValueColor ? tmpRgba : target[propName]);
+ if ((isArrayValueType(valType) || isValueColor) && !targetArr) {
+ targetArr = this._additiveValue = [];
+ }
+ if (this.discrete) {
+ target[propName] = w < 1 ? frame.rawValue : nextFrame.rawValue;
+ }
+ else if (isArrayValueType(valType)) {
+ valType === VALUE_TYPE_1D_ARRAY
+ ? interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w)
+ : interpolate2DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
+ }
+ else if (isGradientValueType(valType)) {
+ var val = frame[valueKey];
+ var nextVal_1 = nextFrame[valueKey];
+ var isLinearGradient_1 = valType === VALUE_TYPE_LINEAR_GRADIENT;
+ target[propName] = {
+ type: isLinearGradient_1 ? 'linear' : 'radial',
+ x: interpolateNumber(val.x, nextVal_1.x, w),
+ y: interpolateNumber(val.y, nextVal_1.y, w),
+ colorStops: map(val.colorStops, function (colorStop, idx) {
+ var nextColorStop = nextVal_1.colorStops[idx];
+ return {
+ offset: interpolateNumber(colorStop.offset, nextColorStop.offset, w),
+ color: rgba2String(interpolate1DArray([], colorStop.color, nextColorStop.color, w))
+ };
+ }),
+ global: nextVal_1.global
+ };
+ if (isLinearGradient_1) {
+ target[propName].x2 = interpolateNumber(val.x2, nextVal_1.x2, w);
+ target[propName].y2 = interpolateNumber(val.y2, nextVal_1.y2, w);
+ }
+ else {
+ target[propName].r = interpolateNumber(val.r, nextVal_1.r, w);
+ }
+ }
+ else if (isValueColor) {
+ interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
+ if (!isAdditive) {
+ target[propName] = rgba2String(targetArr);
+ }
+ }
+ else {
+ var value = interpolateNumber(frame[valueKey], nextFrame[valueKey], w);
+ if (isAdditive) {
+ this._additiveValue = value;
+ }
+ else {
+ target[propName] = value;
+ }
+ }
+ if (isAdditive) {
+ this._addToTarget(target);
+ }
+ };
+ Track.prototype._addToTarget = function (target) {
+ var valType = this.valType;
+ var propName = this.propName;
+ var additiveValue = this._additiveValue;
+ if (valType === VALUE_TYPE_NUMBER) {
+ target[propName] = target[propName] + additiveValue;
+ }
+ else if (valType === VALUE_TYPE_COLOR) {
+ parse(target[propName], tmpRgba);
+ add1DArray(tmpRgba, tmpRgba, additiveValue, 1);
+ target[propName] = rgba2String(tmpRgba);
+ }
+ else if (valType === VALUE_TYPE_1D_ARRAY) {
+ add1DArray(target[propName], target[propName], additiveValue, 1);
+ }
+ else if (valType === VALUE_TYPE_2D_ARRAY) {
+ add2DArray(target[propName], target[propName], additiveValue, 1);
+ }
+ };
+ return Track;
+}());
+var Animator = (function () {
+ function Animator(target, loop, allowDiscreteAnimation, additiveTo) {
+ this._tracks = {};
+ this._trackKeys = [];
+ this._maxTime = 0;
+ this._started = 0;
+ this._clip = null;
+ this._target = target;
+ this._loop = loop;
+ if (loop && additiveTo) {
+ logError('Can\' use additive animation on looped animation.');
+ return;
+ }
+ this._additiveAnimators = additiveTo;
+ this._allowDiscrete = allowDiscreteAnimation;
+ }
+ Animator.prototype.getMaxTime = function () {
+ return this._maxTime;
+ };
+ Animator.prototype.getDelay = function () {
+ return this._delay;
+ };
+ Animator.prototype.getLoop = function () {
+ return this._loop;
+ };
+ Animator.prototype.getTarget = function () {
+ return this._target;
+ };
+ Animator.prototype.changeTarget = function (target) {
+ this._target = target;
+ };
+ Animator.prototype.when = function (time, props, easing) {
+ return this.whenWithKeys(time, props, keys(props), easing);
+ };
+ Animator.prototype.whenWithKeys = function (time, props, propNames, easing) {
+ var tracks = this._tracks;
+ for (var i = 0; i < propNames.length; i++) {
+ var propName = propNames[i];
+ var track = tracks[propName];
+ if (!track) {
+ track = tracks[propName] = new Track(propName);
+ var initialValue = void 0;
+ var additiveTrack = this._getAdditiveTrack(propName);
+ if (additiveTrack) {
+ var addtiveTrackKfs = additiveTrack.keyframes;
+ var lastFinalKf = addtiveTrackKfs[addtiveTrackKfs.length - 1];
+ initialValue = lastFinalKf && lastFinalKf.value;
+ if (additiveTrack.valType === VALUE_TYPE_COLOR && initialValue) {
+ initialValue = rgba2String(initialValue);
+ }
+ }
+ else {
+ initialValue = this._target[propName];
+ }
+ if (initialValue == null) {
+ continue;
+ }
+ if (time > 0) {
+ track.addKeyframe(0, cloneValue(initialValue), easing);
+ }
+ this._trackKeys.push(propName);
+ }
+ track.addKeyframe(time, cloneValue(props[propName]), easing);
+ }
+ this._maxTime = Math.max(this._maxTime, time);
+ return this;
+ };
+ Animator.prototype.pause = function () {
+ this._clip.pause();
+ this._paused = true;
+ };
+ Animator.prototype.resume = function () {
+ this._clip.resume();
+ this._paused = false;
+ };
+ Animator.prototype.isPaused = function () {
+ return !!this._paused;
+ };
+ Animator.prototype.duration = function (duration) {
+ this._maxTime = duration;
+ this._force = true;
+ return this;
+ };
+ Animator.prototype._doneCallback = function () {
+ this._setTracksFinished();
+ this._clip = null;
+ var doneList = this._doneCbs;
+ if (doneList) {
+ var len = doneList.length;
+ for (var i = 0; i < len; i++) {
+ doneList[i].call(this);
+ }
+ }
+ };
+ Animator.prototype._abortedCallback = function () {
+ this._setTracksFinished();
+ var animation = this.animation;
+ var abortedList = this._abortedCbs;
+ if (animation) {
+ animation.removeClip(this._clip);
+ }
+ this._clip = null;
+ if (abortedList) {
+ for (var i = 0; i < abortedList.length; i++) {
+ abortedList[i].call(this);
+ }
+ }
+ };
+ Animator.prototype._setTracksFinished = function () {
+ var tracks = this._tracks;
+ var tracksKeys = this._trackKeys;
+ for (var i = 0; i < tracksKeys.length; i++) {
+ tracks[tracksKeys[i]].setFinished();
+ }
+ };
+ Animator.prototype._getAdditiveTrack = function (trackName) {
+ var additiveTrack;
+ var additiveAnimators = this._additiveAnimators;
+ if (additiveAnimators) {
+ for (var i = 0; i < additiveAnimators.length; i++) {
+ var track = additiveAnimators[i].getTrack(trackName);
+ if (track) {
+ additiveTrack = track;
+ }
+ }
+ }
+ return additiveTrack;
+ };
+ Animator.prototype.start = function (easing) {
+ if (this._started > 0) {
+ return;
+ }
+ this._started = 1;
+ var self = this;
+ var tracks = [];
+ var maxTime = this._maxTime || 0;
+ for (var i = 0; i < this._trackKeys.length; i++) {
+ var propName = this._trackKeys[i];
+ var track = this._tracks[propName];
+ var additiveTrack = this._getAdditiveTrack(propName);
+ var kfs = track.keyframes;
+ var kfsNum = kfs.length;
+ track.prepare(maxTime, additiveTrack);
+ if (track.needsAnimate()) {
+ if (!this._allowDiscrete && track.discrete) {
+ var lastKf = kfs[kfsNum - 1];
+ if (lastKf) {
+ self._target[track.propName] = lastKf.rawValue;
+ }
+ track.setFinished();
+ }
+ else {
+ tracks.push(track);
+ }
+ }
+ }
+ if (tracks.length || this._force) {
+ var clip = new Clip({
+ life: maxTime,
+ loop: this._loop,
+ delay: this._delay || 0,
+ onframe: function (percent) {
+ self._started = 2;
+ var additiveAnimators = self._additiveAnimators;
+ if (additiveAnimators) {
+ var stillHasAdditiveAnimator = false;
+ for (var i = 0; i < additiveAnimators.length; i++) {
+ if (additiveAnimators[i]._clip) {
+ stillHasAdditiveAnimator = true;
+ break;
+ }
+ }
+ if (!stillHasAdditiveAnimator) {
+ self._additiveAnimators = null;
+ }
+ }
+ for (var i = 0; i < tracks.length; i++) {
+ tracks[i].step(self._target, percent);
+ }
+ var onframeList = self._onframeCbs;
+ if (onframeList) {
+ for (var i = 0; i < onframeList.length; i++) {
+ onframeList[i](self._target, percent);
+ }
+ }
+ },
+ ondestroy: function () {
+ self._doneCallback();
+ }
+ });
+ this._clip = clip;
+ if (this.animation) {
+ this.animation.addClip(clip);
+ }
+ if (easing) {
+ clip.setEasing(easing);
+ }
+ }
+ else {
+ this._doneCallback();
+ }
+ return this;
+ };
+ Animator.prototype.stop = function (forwardToLast) {
+ if (!this._clip) {
+ return;
+ }
+ var clip = this._clip;
+ if (forwardToLast) {
+ clip.onframe(1);
+ }
+ this._abortedCallback();
+ };
+ Animator.prototype.delay = function (time) {
+ this._delay = time;
+ return this;
+ };
+ Animator.prototype.during = function (cb) {
+ if (cb) {
+ if (!this._onframeCbs) {
+ this._onframeCbs = [];
+ }
+ this._onframeCbs.push(cb);
+ }
+ return this;
+ };
+ Animator.prototype.done = function (cb) {
+ if (cb) {
+ if (!this._doneCbs) {
+ this._doneCbs = [];
+ }
+ this._doneCbs.push(cb);
+ }
+ return this;
+ };
+ Animator.prototype.aborted = function (cb) {
+ if (cb) {
+ if (!this._abortedCbs) {
+ this._abortedCbs = [];
+ }
+ this._abortedCbs.push(cb);
+ }
+ return this;
+ };
+ Animator.prototype.getClip = function () {
+ return this._clip;
+ };
+ Animator.prototype.getTrack = function (propName) {
+ return this._tracks[propName];
+ };
+ Animator.prototype.getTracks = function () {
+ var _this = this;
+ return map(this._trackKeys, function (key) { return _this._tracks[key]; });
+ };
+ Animator.prototype.stopTracks = function (propNames, forwardToLast) {
+ if (!propNames.length || !this._clip) {
+ return true;
+ }
+ var tracks = this._tracks;
+ var tracksKeys = this._trackKeys;
+ for (var i = 0; i < propNames.length; i++) {
+ var track = tracks[propNames[i]];
+ if (track && !track.isFinished()) {
+ if (forwardToLast) {
+ track.step(this._target, 1);
+ }
+ else if (this._started === 1) {
+ track.step(this._target, 0);
+ }
+ track.setFinished();
+ }
+ }
+ var allAborted = true;
+ for (var i = 0; i < tracksKeys.length; i++) {
+ if (!tracks[tracksKeys[i]].isFinished()) {
+ allAborted = false;
+ break;
+ }
+ }
+ if (allAborted) {
+ this._abortedCallback();
+ }
+ return allAborted;
+ };
+ Animator.prototype.saveTo = function (target, trackKeys, firstOrLast) {
+ if (!target) {
+ return;
+ }
+ trackKeys = trackKeys || this._trackKeys;
+ for (var i = 0; i < trackKeys.length; i++) {
+ var propName = trackKeys[i];
+ var track = this._tracks[propName];
+ if (!track || track.isFinished()) {
+ continue;
+ }
+ var kfs = track.keyframes;
+ var kf = kfs[firstOrLast ? 0 : kfs.length - 1];
+ if (kf) {
+ target[propName] = cloneValue(kf.rawValue);
+ }
+ }
+ };
+ Animator.prototype.__changeFinalValue = function (finalProps, trackKeys) {
+ trackKeys = trackKeys || keys(finalProps);
+ for (var i = 0; i < trackKeys.length; i++) {
+ var propName = trackKeys[i];
+ var track = this._tracks[propName];
+ if (!track) {
+ continue;
+ }
+ var kfs = track.keyframes;
+ if (kfs.length > 1) {
+ var lastKf = kfs.pop();
+ track.addKeyframe(lastKf.time, finalProps[propName]);
+ track.prepare(this._maxTime, track.getAdditiveTrack());
+ }
+ }
+ };
+ return Animator;
+}());
+
+function getTime() {
+ return new Date().getTime();
+}
+var Animation = (function (_super) {
+ __extends(Animation, _super);
+ function Animation(opts) {
+ var _this = _super.call(this) || this;
+ _this._running = false;
+ _this._time = 0;
+ _this._pausedTime = 0;
+ _this._pauseStart = 0;
+ _this._paused = false;
+ opts = opts || {};
+ _this.stage = opts.stage || {};
+ return _this;
+ }
+ Animation.prototype.addClip = function (clip) {
+ if (clip.animation) {
+ this.removeClip(clip);
+ }
+ if (!this._head) {
+ this._head = this._tail = clip;
+ }
+ else {
+ this._tail.next = clip;
+ clip.prev = this._tail;
+ clip.next = null;
+ this._tail = clip;
+ }
+ clip.animation = this;
+ };
+ Animation.prototype.addAnimator = function (animator) {
+ animator.animation = this;
+ var clip = animator.getClip();
+ if (clip) {
+ this.addClip(clip);
+ }
+ };
+ Animation.prototype.removeClip = function (clip) {
+ if (!clip.animation) {
+ return;
+ }
+ var prev = clip.prev;
+ var next = clip.next;
+ if (prev) {
+ prev.next = next;
+ }
+ else {
+ this._head = next;
+ }
+ if (next) {
+ next.prev = prev;
+ }
+ else {
+ this._tail = prev;
+ }
+ clip.next = clip.prev = clip.animation = null;
+ };
+ Animation.prototype.removeAnimator = function (animator) {
+ var clip = animator.getClip();
+ if (clip) {
+ this.removeClip(clip);
+ }
+ animator.animation = null;
+ };
+ Animation.prototype.update = function (notTriggerFrameAndStageUpdate) {
+ var time = getTime() - this._pausedTime;
+ var delta = time - this._time;
+ var clip = this._head;
+ while (clip) {
+ var nextClip = clip.next;
+ var finished = clip.step(time, delta);
+ if (finished) {
+ clip.ondestroy();
+ this.removeClip(clip);
+ clip = nextClip;
+ }
+ else {
+ clip = nextClip;
+ }
+ }
+ this._time = time;
+ if (!notTriggerFrameAndStageUpdate) {
+ this.trigger('frame', delta);
+ this.stage.update && this.stage.update();
+ }
+ };
+ Animation.prototype._startLoop = function () {
+ var self = this;
+ this._running = true;
+ function step() {
+ if (self._running) {
+ requestAnimationFrame$1(step);
+ !self._paused && self.update();
+ }
+ }
+ requestAnimationFrame$1(step);
+ };
+ Animation.prototype.start = function () {
+ if (this._running) {
+ return;
+ }
+ this._time = getTime();
+ this._pausedTime = 0;
+ this._startLoop();
+ };
+ Animation.prototype.stop = function () {
+ this._running = false;
+ };
+ Animation.prototype.pause = function () {
+ if (!this._paused) {
+ this._pauseStart = getTime();
+ this._paused = true;
+ }
+ };
+ Animation.prototype.resume = function () {
+ if (this._paused) {
+ this._pausedTime += getTime() - this._pauseStart;
+ this._paused = false;
+ }
+ };
+ Animation.prototype.clear = function () {
+ var clip = this._head;
+ while (clip) {
+ var nextClip = clip.next;
+ clip.prev = clip.next = clip.animation = null;
+ clip = nextClip;
+ }
+ this._head = this._tail = null;
+ };
+ Animation.prototype.isFinished = function () {
+ return this._head == null;
+ };
+ Animation.prototype.animate = function (target, options) {
+ options = options || {};
+ this.start();
+ var animator = new Animator(target, options.loop);
+ this.addAnimator(animator);
+ return animator;
+ };
+ return Animation;
+}(Eventful));
+
+var TOUCH_CLICK_DELAY = 300;
+var globalEventSupported = env.domSupported;
+var localNativeListenerNames = (function () {
+ var mouseHandlerNames = [
+ 'click', 'dblclick', 'mousewheel', 'wheel', 'mouseout',
+ 'mouseup', 'mousedown', 'mousemove', 'contextmenu'
+ ];
+ var touchHandlerNames = [
+ 'touchstart', 'touchend', 'touchmove'
+ ];
+ var pointerEventNameMap = {
+ pointerdown: 1, pointerup: 1, pointermove: 1, pointerout: 1
+ };
+ var pointerHandlerNames = map(mouseHandlerNames, function (name) {
+ var nm = name.replace('mouse', 'pointer');
+ return pointerEventNameMap.hasOwnProperty(nm) ? nm : name;
+ });
+ return {
+ mouse: mouseHandlerNames,
+ touch: touchHandlerNames,
+ pointer: pointerHandlerNames
+ };
+})();
+var globalNativeListenerNames = {
+ mouse: ['mousemove', 'mouseup'],
+ pointer: ['pointermove', 'pointerup']
+};
+var wheelEventSupported = false;
+function isPointerFromTouch(event) {
+ var pointerType = event.pointerType;
+ return pointerType === 'pen' || pointerType === 'touch';
+}
+function setTouchTimer(scope) {
+ scope.touching = true;
+ if (scope.touchTimer != null) {
+ clearTimeout(scope.touchTimer);
+ scope.touchTimer = null;
+ }
+ scope.touchTimer = setTimeout(function () {
+ scope.touching = false;
+ scope.touchTimer = null;
+ }, 700);
+}
+function markTouch(event) {
+ event && (event.zrByTouch = true);
+}
+function normalizeGlobalEvent(instance, event) {
+ return normalizeEvent(instance.dom, new FakeGlobalEvent(instance, event), true);
+}
+function isLocalEl(instance, el) {
+ var elTmp = el;
+ var isLocal = false;
+ while (elTmp && elTmp.nodeType !== 9
+ && !(isLocal = elTmp.domBelongToZr
+ || (elTmp !== el && elTmp === instance.painterRoot))) {
+ elTmp = elTmp.parentNode;
+ }
+ return isLocal;
+}
+var FakeGlobalEvent = (function () {
+ function FakeGlobalEvent(instance, event) {
+ this.stopPropagation = noop;
+ this.stopImmediatePropagation = noop;
+ this.preventDefault = noop;
+ this.type = event.type;
+ this.target = this.currentTarget = instance.dom;
+ this.pointerType = event.pointerType;
+ this.clientX = event.clientX;
+ this.clientY = event.clientY;
+ }
+ return FakeGlobalEvent;
+}());
+var localDOMHandlers = {
+ mousedown: function (event) {
+ event = normalizeEvent(this.dom, event);
+ this.__mayPointerCapture = [event.zrX, event.zrY];
+ this.trigger('mousedown', event);
+ },
+ mousemove: function (event) {
+ event = normalizeEvent(this.dom, event);
+ var downPoint = this.__mayPointerCapture;
+ if (downPoint && (event.zrX !== downPoint[0] || event.zrY !== downPoint[1])) {
+ this.__togglePointerCapture(true);
+ }
+ this.trigger('mousemove', event);
+ },
+ mouseup: function (event) {
+ event = normalizeEvent(this.dom, event);
+ this.__togglePointerCapture(false);
+ this.trigger('mouseup', event);
+ },
+ mouseout: function (event) {
+ event = normalizeEvent(this.dom, event);
+ var element = event.toElement || event.relatedTarget;
+ if (!isLocalEl(this, element)) {
+ if (this.__pointerCapturing) {
+ event.zrEventControl = 'no_globalout';
+ }
+ this.trigger('mouseout', event);
+ }
+ },
+ wheel: function (event) {
+ wheelEventSupported = true;
+ event = normalizeEvent(this.dom, event);
+ this.trigger('mousewheel', event);
+ },
+ mousewheel: function (event) {
+ if (wheelEventSupported) {
+ return;
+ }
+ event = normalizeEvent(this.dom, event);
+ this.trigger('mousewheel', event);
+ },
+ touchstart: function (event) {
+ event = normalizeEvent(this.dom, event);
+ markTouch(event);
+ this.__lastTouchMoment = new Date();
+ this.handler.processGesture(event, 'start');
+ localDOMHandlers.mousemove.call(this, event);
+ localDOMHandlers.mousedown.call(this, event);
+ },
+ touchmove: function (event) {
+ event = normalizeEvent(this.dom, event);
+ markTouch(event);
+ this.handler.processGesture(event, 'change');
+ localDOMHandlers.mousemove.call(this, event);
+ },
+ touchend: function (event) {
+ event = normalizeEvent(this.dom, event);
+ markTouch(event);
+ this.handler.processGesture(event, 'end');
+ localDOMHandlers.mouseup.call(this, event);
+ if (+new Date() - (+this.__lastTouchMoment) < TOUCH_CLICK_DELAY) {
+ localDOMHandlers.click.call(this, event);
+ }
+ },
+ pointerdown: function (event) {
+ localDOMHandlers.mousedown.call(this, event);
+ },
+ pointermove: function (event) {
+ if (!isPointerFromTouch(event)) {
+ localDOMHandlers.mousemove.call(this, event);
+ }
+ },
+ pointerup: function (event) {
+ localDOMHandlers.mouseup.call(this, event);
+ },
+ pointerout: function (event) {
+ if (!isPointerFromTouch(event)) {
+ localDOMHandlers.mouseout.call(this, event);
+ }
+ }
+};
+each(['click', 'dblclick', 'contextmenu'], function (name) {
+ localDOMHandlers[name] = function (event) {
+ event = normalizeEvent(this.dom, event);
+ this.trigger(name, event);
+ };
+});
+var globalDOMHandlers = {
+ pointermove: function (event) {
+ if (!isPointerFromTouch(event)) {
+ globalDOMHandlers.mousemove.call(this, event);
+ }
+ },
+ pointerup: function (event) {
+ globalDOMHandlers.mouseup.call(this, event);
+ },
+ mousemove: function (event) {
+ this.trigger('mousemove', event);
+ },
+ mouseup: function (event) {
+ var pointerCaptureReleasing = this.__pointerCapturing;
+ this.__togglePointerCapture(false);
+ this.trigger('mouseup', event);
+ if (pointerCaptureReleasing) {
+ event.zrEventControl = 'only_globalout';
+ this.trigger('mouseout', event);
+ }
+ }
+};
+function mountLocalDOMEventListeners(instance, scope) {
+ var domHandlers = scope.domHandlers;
+ if (env.pointerEventsSupported) {
+ each(localNativeListenerNames.pointer, function (nativeEventName) {
+ mountSingleDOMEventListener(scope, nativeEventName, function (event) {
+ domHandlers[nativeEventName].call(instance, event);
+ });
+ });
+ }
+ else {
+ if (env.touchEventsSupported) {
+ each(localNativeListenerNames.touch, function (nativeEventName) {
+ mountSingleDOMEventListener(scope, nativeEventName, function (event) {
+ domHandlers[nativeEventName].call(instance, event);
+ setTouchTimer(scope);
+ });
+ });
+ }
+ each(localNativeListenerNames.mouse, function (nativeEventName) {
+ mountSingleDOMEventListener(scope, nativeEventName, function (event) {
+ event = getNativeEvent(event);
+ if (!scope.touching) {
+ domHandlers[nativeEventName].call(instance, event);
+ }
+ });
+ });
+ }
+}
+function mountGlobalDOMEventListeners(instance, scope) {
+ if (env.pointerEventsSupported) {
+ each(globalNativeListenerNames.pointer, mount);
+ }
+ else if (!env.touchEventsSupported) {
+ each(globalNativeListenerNames.mouse, mount);
+ }
+ function mount(nativeEventName) {
+ function nativeEventListener(event) {
+ event = getNativeEvent(event);
+ if (!isLocalEl(instance, event.target)) {
+ event = normalizeGlobalEvent(instance, event);
+ scope.domHandlers[nativeEventName].call(instance, event);
+ }
+ }
+ mountSingleDOMEventListener(scope, nativeEventName, nativeEventListener, { capture: true });
+ }
+}
+function mountSingleDOMEventListener(scope, nativeEventName, listener, opt) {
+ scope.mounted[nativeEventName] = listener;
+ scope.listenerOpts[nativeEventName] = opt;
+ addEventListener(scope.domTarget, nativeEventName, listener, opt);
+}
+function unmountDOMEventListeners(scope) {
+ var mounted = scope.mounted;
+ for (var nativeEventName in mounted) {
+ if (mounted.hasOwnProperty(nativeEventName)) {
+ removeEventListener(scope.domTarget, nativeEventName, mounted[nativeEventName], scope.listenerOpts[nativeEventName]);
+ }
+ }
+ scope.mounted = {};
+}
+var DOMHandlerScope = (function () {
+ function DOMHandlerScope(domTarget, domHandlers) {
+ this.mounted = {};
+ this.listenerOpts = {};
+ this.touching = false;
+ this.domTarget = domTarget;
+ this.domHandlers = domHandlers;
+ }
+ return DOMHandlerScope;
+}());
+var HandlerDomProxy = (function (_super) {
+ __extends(HandlerDomProxy, _super);
+ function HandlerDomProxy(dom, painterRoot) {
+ var _this = _super.call(this) || this;
+ _this.__pointerCapturing = false;
+ _this.dom = dom;
+ _this.painterRoot = painterRoot;
+ _this._localHandlerScope = new DOMHandlerScope(dom, localDOMHandlers);
+ if (globalEventSupported) {
+ _this._globalHandlerScope = new DOMHandlerScope(document, globalDOMHandlers);
+ }
+ mountLocalDOMEventListeners(_this, _this._localHandlerScope);
+ return _this;
+ }
+ HandlerDomProxy.prototype.dispose = function () {
+ unmountDOMEventListeners(this._localHandlerScope);
+ if (globalEventSupported) {
+ unmountDOMEventListeners(this._globalHandlerScope);
+ }
+ };
+ HandlerDomProxy.prototype.setCursor = function (cursorStyle) {
+ this.dom.style && (this.dom.style.cursor = cursorStyle || 'default');
+ };
+ HandlerDomProxy.prototype.__togglePointerCapture = function (isPointerCapturing) {
+ this.__mayPointerCapture = null;
+ if (globalEventSupported
+ && ((+this.__pointerCapturing) ^ (+isPointerCapturing))) {
+ this.__pointerCapturing = isPointerCapturing;
+ var globalHandlerScope = this._globalHandlerScope;
+ isPointerCapturing
+ ? mountGlobalDOMEventListeners(this, globalHandlerScope)
+ : unmountDOMEventListeners(globalHandlerScope);
+ }
+ };
+ return HandlerDomProxy;
+}(Eventful));
+
+var dpr = 1;
+if (env.hasGlobalWindow) {
+ dpr = Math.max(window.devicePixelRatio
+ || (window.screen && window.screen.deviceXDPI / window.screen.logicalXDPI)
+ || 1, 1);
+}
+var devicePixelRatio = dpr;
+var DARK_MODE_THRESHOLD = 0.4;
+var DARK_LABEL_COLOR = '#333';
+var LIGHT_LABEL_COLOR = '#ccc';
+var LIGHTER_LABEL_COLOR = '#eee';
+
+var mIdentity = identity;
+var EPSILON$2 = 5e-5;
+function isNotAroundZero$1(val) {
+ return val > EPSILON$2 || val < -EPSILON$2;
+}
+var scaleTmp = [];
+var tmpTransform = [];
+var originTransform = create$1();
+var abs = Math.abs;
+var Transformable = (function () {
+ function Transformable() {
+ }
+ Transformable.prototype.getLocalTransform = function (m) {
+ return Transformable.getLocalTransform(this, m);
+ };
+ Transformable.prototype.setPosition = function (arr) {
+ this.x = arr[0];
+ this.y = arr[1];
+ };
+ Transformable.prototype.setScale = function (arr) {
+ this.scaleX = arr[0];
+ this.scaleY = arr[1];
+ };
+ Transformable.prototype.setSkew = function (arr) {
+ this.skewX = arr[0];
+ this.skewY = arr[1];
+ };
+ Transformable.prototype.setOrigin = function (arr) {
+ this.originX = arr[0];
+ this.originY = arr[1];
+ };
+ Transformable.prototype.needLocalTransform = function () {
+ return isNotAroundZero$1(this.rotation)
+ || isNotAroundZero$1(this.x)
+ || isNotAroundZero$1(this.y)
+ || isNotAroundZero$1(this.scaleX - 1)
+ || isNotAroundZero$1(this.scaleY - 1)
+ || isNotAroundZero$1(this.skewX)
+ || isNotAroundZero$1(this.skewY);
+ };
+ Transformable.prototype.updateTransform = function () {
+ var parentTransform = this.parent && this.parent.transform;
+ var needLocalTransform = this.needLocalTransform();
+ var m = this.transform;
+ if (!(needLocalTransform || parentTransform)) {
+ if (m) {
+ mIdentity(m);
+ this.invTransform = null;
+ }
+ return;
+ }
+ m = m || create$1();
+ if (needLocalTransform) {
+ this.getLocalTransform(m);
+ }
+ else {
+ mIdentity(m);
+ }
+ if (parentTransform) {
+ if (needLocalTransform) {
+ mul$1(m, parentTransform, m);
+ }
+ else {
+ copy$1(m, parentTransform);
+ }
+ }
+ this.transform = m;
+ this._resolveGlobalScaleRatio(m);
+ };
+ Transformable.prototype._resolveGlobalScaleRatio = function (m) {
+ var globalScaleRatio = this.globalScaleRatio;
+ if (globalScaleRatio != null && globalScaleRatio !== 1) {
+ this.getGlobalScale(scaleTmp);
+ var relX = scaleTmp[0] < 0 ? -1 : 1;
+ var relY = scaleTmp[1] < 0 ? -1 : 1;
+ var sx = ((scaleTmp[0] - relX) * globalScaleRatio + relX) / scaleTmp[0] || 0;
+ var sy = ((scaleTmp[1] - relY) * globalScaleRatio + relY) / scaleTmp[1] || 0;
+ m[0] *= sx;
+ m[1] *= sx;
+ m[2] *= sy;
+ m[3] *= sy;
+ }
+ this.invTransform = this.invTransform || create$1();
+ invert(this.invTransform, m);
+ };
+ Transformable.prototype.getComputedTransform = function () {
+ var transformNode = this;
+ var ancestors = [];
+ while (transformNode) {
+ ancestors.push(transformNode);
+ transformNode = transformNode.parent;
+ }
+ while (transformNode = ancestors.pop()) {
+ transformNode.updateTransform();
+ }
+ return this.transform;
+ };
+ Transformable.prototype.setLocalTransform = function (m) {
+ if (!m) {
+ return;
+ }
+ var sx = m[0] * m[0] + m[1] * m[1];
+ var sy = m[2] * m[2] + m[3] * m[3];
+ var rotation = Math.atan2(m[1], m[0]);
+ var shearX = Math.PI / 2 + rotation - Math.atan2(m[3], m[2]);
+ sy = Math.sqrt(sy) * Math.cos(shearX);
+ sx = Math.sqrt(sx);
+ this.skewX = shearX;
+ this.skewY = 0;
+ this.rotation = -rotation;
+ this.x = +m[4];
+ this.y = +m[5];
+ this.scaleX = sx;
+ this.scaleY = sy;
+ this.originX = 0;
+ this.originY = 0;
+ };
+ Transformable.prototype.decomposeTransform = function () {
+ if (!this.transform) {
+ return;
+ }
+ var parent = this.parent;
+ var m = this.transform;
+ if (parent && parent.transform) {
+ parent.invTransform = parent.invTransform || create$1();
+ mul$1(tmpTransform, parent.invTransform, m);
+ m = tmpTransform;
+ }
+ var ox = this.originX;
+ var oy = this.originY;
+ if (ox || oy) {
+ originTransform[4] = ox;
+ originTransform[5] = oy;
+ mul$1(tmpTransform, m, originTransform);
+ tmpTransform[4] -= ox;
+ tmpTransform[5] -= oy;
+ m = tmpTransform;
+ }
+ this.setLocalTransform(m);
+ };
+ Transformable.prototype.getGlobalScale = function (out) {
+ var m = this.transform;
+ out = out || [];
+ if (!m) {
+ out[0] = 1;
+ out[1] = 1;
+ return out;
+ }
+ out[0] = Math.sqrt(m[0] * m[0] + m[1] * m[1]);
+ out[1] = Math.sqrt(m[2] * m[2] + m[3] * m[3]);
+ if (m[0] < 0) {
+ out[0] = -out[0];
+ }
+ if (m[3] < 0) {
+ out[1] = -out[1];
+ }
+ return out;
+ };
+ Transformable.prototype.transformCoordToLocal = function (x, y) {
+ var v2 = [x, y];
+ var invTransform = this.invTransform;
+ if (invTransform) {
+ applyTransform(v2, v2, invTransform);
+ }
+ return v2;
+ };
+ Transformable.prototype.transformCoordToGlobal = function (x, y) {
+ var v2 = [x, y];
+ var transform = this.transform;
+ if (transform) {
+ applyTransform(v2, v2, transform);
+ }
+ return v2;
+ };
+ Transformable.prototype.getLineScale = function () {
+ var m = this.transform;
+ return m && abs(m[0] - 1) > 1e-10 && abs(m[3] - 1) > 1e-10
+ ? Math.sqrt(abs(m[0] * m[3] - m[2] * m[1]))
+ : 1;
+ };
+ Transformable.prototype.copyTransform = function (source) {
+ copyTransform(this, source);
+ };
+ Transformable.getLocalTransform = function (target, m) {
+ m = m || [];
+ var ox = target.originX || 0;
+ var oy = target.originY || 0;
+ var sx = target.scaleX;
+ var sy = target.scaleY;
+ var ax = target.anchorX;
+ var ay = target.anchorY;
+ var rotation = target.rotation || 0;
+ var x = target.x;
+ var y = target.y;
+ var skewX = target.skewX ? Math.tan(target.skewX) : 0;
+ var skewY = target.skewY ? Math.tan(-target.skewY) : 0;
+ if (ox || oy || ax || ay) {
+ var dx = ox + ax;
+ var dy = oy + ay;
+ m[4] = -dx * sx - skewX * dy * sy;
+ m[5] = -dy * sy - skewY * dx * sx;
+ }
+ else {
+ m[4] = m[5] = 0;
+ }
+ m[0] = sx;
+ m[3] = sy;
+ m[1] = skewY * sx;
+ m[2] = skewX * sy;
+ rotation && rotate(m, m, rotation);
+ m[4] += ox + x;
+ m[5] += oy + y;
+ return m;
+ };
+ Transformable.initDefaultProps = (function () {
+ var proto = Transformable.prototype;
+ proto.scaleX =
+ proto.scaleY =
+ proto.globalScaleRatio = 1;
+ proto.x =
+ proto.y =
+ proto.originX =
+ proto.originY =
+ proto.skewX =
+ proto.skewY =
+ proto.rotation =
+ proto.anchorX =
+ proto.anchorY = 0;
+ })();
+ return Transformable;
+}());
+var TRANSFORMABLE_PROPS = [
+ 'x', 'y', 'originX', 'originY', 'anchorX', 'anchorY', 'rotation', 'scaleX', 'scaleY', 'skewX', 'skewY'
+];
+function copyTransform(target, source) {
+ for (var i = 0; i < TRANSFORMABLE_PROPS.length; i++) {
+ var propName = TRANSFORMABLE_PROPS[i];
+ target[propName] = source[propName];
+ }
+}
+
+var textWidthCache = {};
+function getWidth(text, font) {
+ font = font || DEFAULT_FONT;
+ var cacheOfFont = textWidthCache[font];
+ if (!cacheOfFont) {
+ cacheOfFont = textWidthCache[font] = new LRU(500);
+ }
+ var width = cacheOfFont.get(text);
+ if (width == null) {
+ width = platformApi.measureText(text, font).width;
+ cacheOfFont.put(text, width);
+ }
+ return width;
+}
+function innerGetBoundingRect(text, font, textAlign, textBaseline) {
+ var width = getWidth(text, font);
+ var height = getLineHeight(font);
+ var x = adjustTextX(0, width, textAlign);
+ var y = adjustTextY$1(0, height, textBaseline);
+ var rect = new BoundingRect(x, y, width, height);
+ return rect;
+}
+function getBoundingRect(text, font, textAlign, textBaseline) {
+ var textLines = ((text || '') + '').split('\n');
+ var len = textLines.length;
+ if (len === 1) {
+ return innerGetBoundingRect(textLines[0], font, textAlign, textBaseline);
+ }
+ else {
+ var uniondRect = new BoundingRect(0, 0, 0, 0);
+ for (var i = 0; i < textLines.length; i++) {
+ var rect = innerGetBoundingRect(textLines[i], font, textAlign, textBaseline);
+ i === 0 ? uniondRect.copy(rect) : uniondRect.union(rect);
+ }
+ return uniondRect;
+ }
+}
+function adjustTextX(x, width, textAlign) {
+ if (textAlign === 'right') {
+ x -= width;
+ }
+ else if (textAlign === 'center') {
+ x -= width / 2;
+ }
+ return x;
+}
+function adjustTextY$1(y, height, verticalAlign) {
+ if (verticalAlign === 'middle') {
+ y -= height / 2;
+ }
+ else if (verticalAlign === 'bottom') {
+ y -= height;
+ }
+ return y;
+}
+function getLineHeight(font) {
+ return getWidth('国', font);
+}
+function parsePercent(value, maxValue) {
+ if (typeof value === 'string') {
+ if (value.lastIndexOf('%') >= 0) {
+ return parseFloat(value) / 100 * maxValue;
+ }
+ return parseFloat(value);
+ }
+ return value;
+}
+function calculateTextPosition(out, opts, rect) {
+ var textPosition = opts.position || 'inside';
+ var distance = opts.distance != null ? opts.distance : 5;
+ var height = rect.height;
+ var width = rect.width;
+ var halfHeight = height / 2;
+ var x = rect.x;
+ var y = rect.y;
+ var textAlign = 'left';
+ var textVerticalAlign = 'top';
+ if (textPosition instanceof Array) {
+ x += parsePercent(textPosition[0], rect.width);
+ y += parsePercent(textPosition[1], rect.height);
+ textAlign = null;
+ textVerticalAlign = null;
+ }
+ else {
+ switch (textPosition) {
+ case 'left':
+ x -= distance;
+ y += halfHeight;
+ textAlign = 'right';
+ textVerticalAlign = 'middle';
+ break;
+ case 'right':
+ x += distance + width;
+ y += halfHeight;
+ textVerticalAlign = 'middle';
+ break;
+ case 'top':
+ x += width / 2;
+ y -= distance;
+ textAlign = 'center';
+ textVerticalAlign = 'bottom';
+ break;
+ case 'bottom':
+ x += width / 2;
+ y += height + distance;
+ textAlign = 'center';
+ break;
+ case 'inside':
+ x += width / 2;
+ y += halfHeight;
+ textAlign = 'center';
+ textVerticalAlign = 'middle';
+ break;
+ case 'insideLeft':
+ x += distance;
+ y += halfHeight;
+ textVerticalAlign = 'middle';
+ break;
+ case 'insideRight':
+ x += width - distance;
+ y += halfHeight;
+ textAlign = 'right';
+ textVerticalAlign = 'middle';
+ break;
+ case 'insideTop':
+ x += width / 2;
+ y += distance;
+ textAlign = 'center';
+ break;
+ case 'insideBottom':
+ x += width / 2;
+ y += height - distance;
+ textAlign = 'center';
+ textVerticalAlign = 'bottom';
+ break;
+ case 'insideTopLeft':
+ x += distance;
+ y += distance;
+ break;
+ case 'insideTopRight':
+ x += width - distance;
+ y += distance;
+ textAlign = 'right';
+ break;
+ case 'insideBottomLeft':
+ x += distance;
+ y += height - distance;
+ textVerticalAlign = 'bottom';
+ break;
+ case 'insideBottomRight':
+ x += width - distance;
+ y += height - distance;
+ textAlign = 'right';
+ textVerticalAlign = 'bottom';
+ break;
+ }
+ }
+ out = out || {};
+ out.x = x;
+ out.y = y;
+ out.align = textAlign;
+ out.verticalAlign = textVerticalAlign;
+ return out;
+}
+
+var PRESERVED_NORMAL_STATE = '__zr_normal__';
+var PRIMARY_STATES_KEYS = TRANSFORMABLE_PROPS.concat(['ignore']);
+var DEFAULT_ANIMATABLE_MAP = reduce(TRANSFORMABLE_PROPS, function (obj, key) {
+ obj[key] = true;
+ return obj;
+}, { ignore: false });
+var tmpTextPosCalcRes = {};
+var tmpBoundingRect = new BoundingRect(0, 0, 0, 0);
+var Element = (function () {
+ function Element(props) {
+ this.id = guid();
+ this.animators = [];
+ this.currentStates = [];
+ this.states = {};
+ this._init(props);
+ }
+ Element.prototype._init = function (props) {
+ this.attr(props);
+ };
+ Element.prototype.drift = function (dx, dy, e) {
+ switch (this.draggable) {
+ case 'horizontal':
+ dy = 0;
+ break;
+ case 'vertical':
+ dx = 0;
+ break;
+ }
+ var m = this.transform;
+ if (!m) {
+ m = this.transform = [1, 0, 0, 1, 0, 0];
+ }
+ m[4] += dx;
+ m[5] += dy;
+ this.decomposeTransform();
+ this.markRedraw();
+ };
+ Element.prototype.beforeUpdate = function () { };
+ Element.prototype.afterUpdate = function () { };
+ Element.prototype.update = function () {
+ this.updateTransform();
+ if (this.__dirty) {
+ this.updateInnerText();
+ }
+ };
+ Element.prototype.updateInnerText = function (forceUpdate) {
+ var textEl = this._textContent;
+ if (textEl && (!textEl.ignore || forceUpdate)) {
+ if (!this.textConfig) {
+ this.textConfig = {};
+ }
+ var textConfig = this.textConfig;
+ var isLocal = textConfig.local;
+ var innerTransformable = textEl.innerTransformable;
+ var textAlign = void 0;
+ var textVerticalAlign = void 0;
+ var textStyleChanged = false;
+ innerTransformable.parent = isLocal ? this : null;
+ var innerOrigin = false;
+ innerTransformable.copyTransform(textEl);
+ if (textConfig.position != null) {
+ var layoutRect = tmpBoundingRect;
+ if (textConfig.layoutRect) {
+ layoutRect.copy(textConfig.layoutRect);
+ }
+ else {
+ layoutRect.copy(this.getBoundingRect());
+ }
+ if (!isLocal) {
+ layoutRect.applyTransform(this.transform);
+ }
+ if (this.calculateTextPosition) {
+ this.calculateTextPosition(tmpTextPosCalcRes, textConfig, layoutRect);
+ }
+ else {
+ calculateTextPosition(tmpTextPosCalcRes, textConfig, layoutRect);
+ }
+ innerTransformable.x = tmpTextPosCalcRes.x;
+ innerTransformable.y = tmpTextPosCalcRes.y;
+ textAlign = tmpTextPosCalcRes.align;
+ textVerticalAlign = tmpTextPosCalcRes.verticalAlign;
+ var textOrigin = textConfig.origin;
+ if (textOrigin && textConfig.rotation != null) {
+ var relOriginX = void 0;
+ var relOriginY = void 0;
+ if (textOrigin === 'center') {
+ relOriginX = layoutRect.width * 0.5;
+ relOriginY = layoutRect.height * 0.5;
+ }
+ else {
+ relOriginX = parsePercent(textOrigin[0], layoutRect.width);
+ relOriginY = parsePercent(textOrigin[1], layoutRect.height);
+ }
+ innerOrigin = true;
+ innerTransformable.originX = -innerTransformable.x + relOriginX + (isLocal ? 0 : layoutRect.x);
+ innerTransformable.originY = -innerTransformable.y + relOriginY + (isLocal ? 0 : layoutRect.y);
+ }
+ }
+ if (textConfig.rotation != null) {
+ innerTransformable.rotation = textConfig.rotation;
+ }
+ var textOffset = textConfig.offset;
+ if (textOffset) {
+ innerTransformable.x += textOffset[0];
+ innerTransformable.y += textOffset[1];
+ if (!innerOrigin) {
+ innerTransformable.originX = -textOffset[0];
+ innerTransformable.originY = -textOffset[1];
+ }
+ }
+ var isInside = textConfig.inside == null
+ ? (typeof textConfig.position === 'string' && textConfig.position.indexOf('inside') >= 0)
+ : textConfig.inside;
+ var innerTextDefaultStyle = this._innerTextDefaultStyle || (this._innerTextDefaultStyle = {});
+ var textFill = void 0;
+ var textStroke = void 0;
+ var autoStroke = void 0;
+ if (isInside && this.canBeInsideText()) {
+ textFill = textConfig.insideFill;
+ textStroke = textConfig.insideStroke;
+ if (textFill == null || textFill === 'auto') {
+ textFill = this.getInsideTextFill();
+ }
+ if (textStroke == null || textStroke === 'auto') {
+ textStroke = this.getInsideTextStroke(textFill);
+ autoStroke = true;
+ }
+ }
+ else {
+ textFill = textConfig.outsideFill;
+ textStroke = textConfig.outsideStroke;
+ if (textFill == null || textFill === 'auto') {
+ textFill = this.getOutsideFill();
+ }
+ if (textStroke == null || textStroke === 'auto') {
+ textStroke = this.getOutsideStroke(textFill);
+ autoStroke = true;
+ }
+ }
+ textFill = textFill || '#000';
+ if (textFill !== innerTextDefaultStyle.fill
+ || textStroke !== innerTextDefaultStyle.stroke
+ || autoStroke !== innerTextDefaultStyle.autoStroke
+ || textAlign !== innerTextDefaultStyle.align
+ || textVerticalAlign !== innerTextDefaultStyle.verticalAlign) {
+ textStyleChanged = true;
+ innerTextDefaultStyle.fill = textFill;
+ innerTextDefaultStyle.stroke = textStroke;
+ innerTextDefaultStyle.autoStroke = autoStroke;
+ innerTextDefaultStyle.align = textAlign;
+ innerTextDefaultStyle.verticalAlign = textVerticalAlign;
+ textEl.setDefaultTextStyle(innerTextDefaultStyle);
+ }
+ textEl.__dirty |= REDRAW_BIT;
+ if (textStyleChanged) {
+ textEl.dirtyStyle(true);
+ }
+ }
+ };
+ Element.prototype.canBeInsideText = function () {
+ return true;
+ };
+ Element.prototype.getInsideTextFill = function () {
+ return '#fff';
+ };
+ Element.prototype.getInsideTextStroke = function (textFill) {
+ return '#000';
+ };
+ Element.prototype.getOutsideFill = function () {
+ return this.__zr && this.__zr.isDarkMode() ? LIGHT_LABEL_COLOR : DARK_LABEL_COLOR;
+ };
+ Element.prototype.getOutsideStroke = function (textFill) {
+ var backgroundColor = this.__zr && this.__zr.getBackgroundColor();
+ var colorArr = typeof backgroundColor === 'string' && parse(backgroundColor);
+ if (!colorArr) {
+ colorArr = [255, 255, 255, 1];
+ }
+ var alpha = colorArr[3];
+ var isDark = this.__zr.isDarkMode();
+ for (var i = 0; i < 3; i++) {
+ colorArr[i] = colorArr[i] * alpha + (isDark ? 0 : 255) * (1 - alpha);
+ }
+ colorArr[3] = 1;
+ return stringify(colorArr, 'rgba');
+ };
+ Element.prototype.traverse = function (cb, context) { };
+ Element.prototype.attrKV = function (key, value) {
+ if (key === 'textConfig') {
+ this.setTextConfig(value);
+ }
+ else if (key === 'textContent') {
+ this.setTextContent(value);
+ }
+ else if (key === 'clipPath') {
+ this.setClipPath(value);
+ }
+ else if (key === 'extra') {
+ this.extra = this.extra || {};
+ extend(this.extra, value);
+ }
+ else {
+ this[key] = value;
+ }
+ };
+ Element.prototype.hide = function () {
+ this.ignore = true;
+ this.markRedraw();
+ };
+ Element.prototype.show = function () {
+ this.ignore = false;
+ this.markRedraw();
+ };
+ Element.prototype.attr = function (keyOrObj, value) {
+ if (typeof keyOrObj === 'string') {
+ this.attrKV(keyOrObj, value);
+ }
+ else if (isObject(keyOrObj)) {
+ var obj = keyOrObj;
+ var keysArr = keys(obj);
+ for (var i = 0; i < keysArr.length; i++) {
+ var key = keysArr[i];
+ this.attrKV(key, keyOrObj[key]);
+ }
+ }
+ this.markRedraw();
+ return this;
+ };
+ Element.prototype.saveCurrentToNormalState = function (toState) {
+ this._innerSaveToNormal(toState);
+ var normalState = this._normalState;
+ for (var i = 0; i < this.animators.length; i++) {
+ var animator = this.animators[i];
+ var fromStateTransition = animator.__fromStateTransition;
+ if (animator.getLoop() || fromStateTransition && fromStateTransition !== PRESERVED_NORMAL_STATE) {
+ continue;
+ }
+ var targetName = animator.targetName;
+ var target = targetName
+ ? normalState[targetName] : normalState;
+ animator.saveTo(target);
+ }
+ };
+ Element.prototype._innerSaveToNormal = function (toState) {
+ var normalState = this._normalState;
+ if (!normalState) {
+ normalState = this._normalState = {};
+ }
+ if (toState.textConfig && !normalState.textConfig) {
+ normalState.textConfig = this.textConfig;
+ }
+ this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS);
+ };
+ Element.prototype._savePrimaryToNormal = function (toState, normalState, primaryKeys) {
+ for (var i = 0; i < primaryKeys.length; i++) {
+ var key = primaryKeys[i];
+ if (toState[key] != null && !(key in normalState)) {
+ normalState[key] = this[key];
+ }
+ }
+ };
+ Element.prototype.hasState = function () {
+ return this.currentStates.length > 0;
+ };
+ Element.prototype.getState = function (name) {
+ return this.states[name];
+ };
+ Element.prototype.ensureState = function (name) {
+ var states = this.states;
+ if (!states[name]) {
+ states[name] = {};
+ }
+ return states[name];
+ };
+ Element.prototype.clearStates = function (noAnimation) {
+ this.useState(PRESERVED_NORMAL_STATE, false, noAnimation);
+ };
+ Element.prototype.useState = function (stateName, keepCurrentStates, noAnimation, forceUseHoverLayer) {
+ var toNormalState = stateName === PRESERVED_NORMAL_STATE;
+ var hasStates = this.hasState();
+ if (!hasStates && toNormalState) {
+ return;
+ }
+ var currentStates = this.currentStates;
+ var animationCfg = this.stateTransition;
+ if (indexOf(currentStates, stateName) >= 0 && (keepCurrentStates || currentStates.length === 1)) {
+ return;
+ }
+ var state;
+ if (this.stateProxy && !toNormalState) {
+ state = this.stateProxy(stateName);
+ }
+ if (!state) {
+ state = (this.states && this.states[stateName]);
+ }
+ if (!state && !toNormalState) {
+ logError("State " + stateName + " not exists.");
+ return;
+ }
+ if (!toNormalState) {
+ this.saveCurrentToNormalState(state);
+ }
+ var useHoverLayer = !!((state && state.hoverLayer) || forceUseHoverLayer);
+ if (useHoverLayer) {
+ this._toggleHoverLayerFlag(true);
+ }
+ this._applyStateObj(stateName, state, this._normalState, keepCurrentStates, !noAnimation && !this.__inHover && animationCfg && animationCfg.duration > 0, animationCfg);
+ var textContent = this._textContent;
+ var textGuide = this._textGuide;
+ if (textContent) {
+ textContent.useState(stateName, keepCurrentStates, noAnimation, useHoverLayer);
+ }
+ if (textGuide) {
+ textGuide.useState(stateName, keepCurrentStates, noAnimation, useHoverLayer);
+ }
+ if (toNormalState) {
+ this.currentStates = [];
+ this._normalState = {};
+ }
+ else {
+ if (!keepCurrentStates) {
+ this.currentStates = [stateName];
+ }
+ else {
+ this.currentStates.push(stateName);
+ }
+ }
+ this._updateAnimationTargets();
+ this.markRedraw();
+ if (!useHoverLayer && this.__inHover) {
+ this._toggleHoverLayerFlag(false);
+ this.__dirty &= ~REDRAW_BIT;
+ }
+ return state;
+ };
+ Element.prototype.useStates = function (states, noAnimation, forceUseHoverLayer) {
+ if (!states.length) {
+ this.clearStates();
+ }
+ else {
+ var stateObjects = [];
+ var currentStates = this.currentStates;
+ var len = states.length;
+ var notChange = len === currentStates.length;
+ if (notChange) {
+ for (var i = 0; i < len; i++) {
+ if (states[i] !== currentStates[i]) {
+ notChange = false;
+ break;
+ }
+ }
+ }
+ if (notChange) {
+ return;
+ }
+ for (var i = 0; i < len; i++) {
+ var stateName = states[i];
+ var stateObj = void 0;
+ if (this.stateProxy) {
+ stateObj = this.stateProxy(stateName, states);
+ }
+ if (!stateObj) {
+ stateObj = this.states[stateName];
+ }
+ if (stateObj) {
+ stateObjects.push(stateObj);
+ }
+ }
+ var lastStateObj = stateObjects[len - 1];
+ var useHoverLayer = !!((lastStateObj && lastStateObj.hoverLayer) || forceUseHoverLayer);
+ if (useHoverLayer) {
+ this._toggleHoverLayerFlag(true);
+ }
+ var mergedState = this._mergeStates(stateObjects);
+ var animationCfg = this.stateTransition;
+ this.saveCurrentToNormalState(mergedState);
+ this._applyStateObj(states.join(','), mergedState, this._normalState, false, !noAnimation && !this.__inHover && animationCfg && animationCfg.duration > 0, animationCfg);
+ var textContent = this._textContent;
+ var textGuide = this._textGuide;
+ if (textContent) {
+ textContent.useStates(states, noAnimation, useHoverLayer);
+ }
+ if (textGuide) {
+ textGuide.useStates(states, noAnimation, useHoverLayer);
+ }
+ this._updateAnimationTargets();
+ this.currentStates = states.slice();
+ this.markRedraw();
+ if (!useHoverLayer && this.__inHover) {
+ this._toggleHoverLayerFlag(false);
+ this.__dirty &= ~REDRAW_BIT;
+ }
+ }
+ };
+ Element.prototype.isSilent = function () {
+ var isSilent = this.silent;
+ var ancestor = this.parent;
+ while (!isSilent && ancestor) {
+ if (ancestor.silent) {
+ isSilent = true;
+ break;
+ }
+ ancestor = ancestor.parent;
+ }
+ return isSilent;
+ };
+ Element.prototype._updateAnimationTargets = function () {
+ for (var i = 0; i < this.animators.length; i++) {
+ var animator = this.animators[i];
+ if (animator.targetName) {
+ animator.changeTarget(this[animator.targetName]);
+ }
+ }
+ };
+ Element.prototype.removeState = function (state) {
+ var idx = indexOf(this.currentStates, state);
+ if (idx >= 0) {
+ var currentStates = this.currentStates.slice();
+ currentStates.splice(idx, 1);
+ this.useStates(currentStates);
+ }
+ };
+ Element.prototype.replaceState = function (oldState, newState, forceAdd) {
+ var currentStates = this.currentStates.slice();
+ var idx = indexOf(currentStates, oldState);
+ var newStateExists = indexOf(currentStates, newState) >= 0;
+ if (idx >= 0) {
+ if (!newStateExists) {
+ currentStates[idx] = newState;
+ }
+ else {
+ currentStates.splice(idx, 1);
+ }
+ }
+ else if (forceAdd && !newStateExists) {
+ currentStates.push(newState);
+ }
+ this.useStates(currentStates);
+ };
+ Element.prototype.toggleState = function (state, enable) {
+ if (enable) {
+ this.useState(state, true);
+ }
+ else {
+ this.removeState(state);
+ }
+ };
+ Element.prototype._mergeStates = function (states) {
+ var mergedState = {};
+ var mergedTextConfig;
+ for (var i = 0; i < states.length; i++) {
+ var state = states[i];
+ extend(mergedState, state);
+ if (state.textConfig) {
+ mergedTextConfig = mergedTextConfig || {};
+ extend(mergedTextConfig, state.textConfig);
+ }
+ }
+ if (mergedTextConfig) {
+ mergedState.textConfig = mergedTextConfig;
+ }
+ return mergedState;
+ };
+ Element.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
+ var needsRestoreToNormal = !(state && keepCurrentStates);
+ if (state && state.textConfig) {
+ this.textConfig = extend({}, keepCurrentStates ? this.textConfig : normalState.textConfig);
+ extend(this.textConfig, state.textConfig);
+ }
+ else if (needsRestoreToNormal) {
+ if (normalState.textConfig) {
+ this.textConfig = normalState.textConfig;
+ }
+ }
+ var transitionTarget = {};
+ var hasTransition = false;
+ for (var i = 0; i < PRIMARY_STATES_KEYS.length; i++) {
+ var key = PRIMARY_STATES_KEYS[i];
+ var propNeedsTransition = transition && DEFAULT_ANIMATABLE_MAP[key];
+ if (state && state[key] != null) {
+ if (propNeedsTransition) {
+ hasTransition = true;
+ transitionTarget[key] = state[key];
+ }
+ else {
+ this[key] = state[key];
+ }
+ }
+ else if (needsRestoreToNormal) {
+ if (normalState[key] != null) {
+ if (propNeedsTransition) {
+ hasTransition = true;
+ transitionTarget[key] = normalState[key];
+ }
+ else {
+ this[key] = normalState[key];
+ }
+ }
+ }
+ }
+ if (!transition) {
+ for (var i = 0; i < this.animators.length; i++) {
+ var animator = this.animators[i];
+ var targetName = animator.targetName;
+ if (!animator.getLoop()) {
+ animator.__changeFinalValue(targetName
+ ? (state || normalState)[targetName]
+ : (state || normalState));
+ }
+ }
+ }
+ if (hasTransition) {
+ this._transitionState(stateName, transitionTarget, animationCfg);
+ }
+ };
+ Element.prototype._attachComponent = function (componentEl) {
+ if (componentEl.__zr && !componentEl.__hostTarget) {
+ if ("development" !== 'production') {
+ throw new Error('Text element has been added to zrender.');
+ }
+ return;
+ }
+ if (componentEl === this) {
+ if ("development" !== 'production') {
+ throw new Error('Recursive component attachment.');
+ }
+ return;
+ }
+ var zr = this.__zr;
+ if (zr) {
+ componentEl.addSelfToZr(zr);
+ }
+ componentEl.__zr = zr;
+ componentEl.__hostTarget = this;
+ };
+ Element.prototype._detachComponent = function (componentEl) {
+ if (componentEl.__zr) {
+ componentEl.removeSelfFromZr(componentEl.__zr);
+ }
+ componentEl.__zr = null;
+ componentEl.__hostTarget = null;
+ };
+ Element.prototype.getClipPath = function () {
+ return this._clipPath;
+ };
+ Element.prototype.setClipPath = function (clipPath) {
+ if (this._clipPath && this._clipPath !== clipPath) {
+ this.removeClipPath();
+ }
+ this._attachComponent(clipPath);
+ this._clipPath = clipPath;
+ this.markRedraw();
+ };
+ Element.prototype.removeClipPath = function () {
+ var clipPath = this._clipPath;
+ if (clipPath) {
+ this._detachComponent(clipPath);
+ this._clipPath = null;
+ this.markRedraw();
+ }
+ };
+ Element.prototype.getTextContent = function () {
+ return this._textContent;
+ };
+ Element.prototype.setTextContent = function (textEl) {
+ var previousTextContent = this._textContent;
+ if (previousTextContent === textEl) {
+ return;
+ }
+ if (previousTextContent && previousTextContent !== textEl) {
+ this.removeTextContent();
+ }
+ if ("development" !== 'production') {
+ if (textEl.__zr && !textEl.__hostTarget) {
+ throw new Error('Text element has been added to zrender.');
+ }
+ }
+ textEl.innerTransformable = new Transformable();
+ this._attachComponent(textEl);
+ this._textContent = textEl;
+ this.markRedraw();
+ };
+ Element.prototype.setTextConfig = function (cfg) {
+ if (!this.textConfig) {
+ this.textConfig = {};
+ }
+ extend(this.textConfig, cfg);
+ this.markRedraw();
+ };
+ Element.prototype.removeTextConfig = function () {
+ this.textConfig = null;
+ this.markRedraw();
+ };
+ Element.prototype.removeTextContent = function () {
+ var textEl = this._textContent;
+ if (textEl) {
+ textEl.innerTransformable = null;
+ this._detachComponent(textEl);
+ this._textContent = null;
+ this._innerTextDefaultStyle = null;
+ this.markRedraw();
+ }
+ };
+ Element.prototype.getTextGuideLine = function () {
+ return this._textGuide;
+ };
+ Element.prototype.setTextGuideLine = function (guideLine) {
+ if (this._textGuide && this._textGuide !== guideLine) {
+ this.removeTextGuideLine();
+ }
+ this._attachComponent(guideLine);
+ this._textGuide = guideLine;
+ this.markRedraw();
+ };
+ Element.prototype.removeTextGuideLine = function () {
+ var textGuide = this._textGuide;
+ if (textGuide) {
+ this._detachComponent(textGuide);
+ this._textGuide = null;
+ this.markRedraw();
+ }
+ };
+ Element.prototype.markRedraw = function () {
+ this.__dirty |= REDRAW_BIT;
+ var zr = this.__zr;
+ if (zr) {
+ if (this.__inHover) {
+ zr.refreshHover();
+ }
+ else {
+ zr.refresh();
+ }
+ }
+ if (this.__hostTarget) {
+ this.__hostTarget.markRedraw();
+ }
+ };
+ Element.prototype.dirty = function () {
+ this.markRedraw();
+ };
+ Element.prototype._toggleHoverLayerFlag = function (inHover) {
+ this.__inHover = inHover;
+ var textContent = this._textContent;
+ var textGuide = this._textGuide;
+ if (textContent) {
+ textContent.__inHover = inHover;
+ }
+ if (textGuide) {
+ textGuide.__inHover = inHover;
+ }
+ };
+ Element.prototype.addSelfToZr = function (zr) {
+ if (this.__zr === zr) {
+ return;
+ }
+ this.__zr = zr;
+ var animators = this.animators;
+ if (animators) {
+ for (var i = 0; i < animators.length; i++) {
+ zr.animation.addAnimator(animators[i]);
+ }
+ }
+ if (this._clipPath) {
+ this._clipPath.addSelfToZr(zr);
+ }
+ if (this._textContent) {
+ this._textContent.addSelfToZr(zr);
+ }
+ if (this._textGuide) {
+ this._textGuide.addSelfToZr(zr);
+ }
+ };
+ Element.prototype.removeSelfFromZr = function (zr) {
+ if (!this.__zr) {
+ return;
+ }
+ this.__zr = null;
+ var animators = this.animators;
+ if (animators) {
+ for (var i = 0; i < animators.length; i++) {
+ zr.animation.removeAnimator(animators[i]);
+ }
+ }
+ if (this._clipPath) {
+ this._clipPath.removeSelfFromZr(zr);
+ }
+ if (this._textContent) {
+ this._textContent.removeSelfFromZr(zr);
+ }
+ if (this._textGuide) {
+ this._textGuide.removeSelfFromZr(zr);
+ }
+ };
+ Element.prototype.animate = function (key, loop, allowDiscreteAnimation) {
+ var target = key ? this[key] : this;
+ if ("development" !== 'production') {
+ if (!target) {
+ logError('Property "'
+ + key
+ + '" is not existed in element '
+ + this.id);
+ return;
+ }
+ }
+ var animator = new Animator(target, loop, allowDiscreteAnimation);
+ key && (animator.targetName = key);
+ this.addAnimator(animator, key);
+ return animator;
+ };
+ Element.prototype.addAnimator = function (animator, key) {
+ var zr = this.__zr;
+ var el = this;
+ animator.during(function () {
+ el.updateDuringAnimation(key);
+ }).done(function () {
+ var animators = el.animators;
+ var idx = indexOf(animators, animator);
+ if (idx >= 0) {
+ animators.splice(idx, 1);
+ }
+ });
+ this.animators.push(animator);
+ if (zr) {
+ zr.animation.addAnimator(animator);
+ }
+ zr && zr.wakeUp();
+ };
+ Element.prototype.updateDuringAnimation = function (key) {
+ this.markRedraw();
+ };
+ Element.prototype.stopAnimation = function (scope, forwardToLast) {
+ var animators = this.animators;
+ var len = animators.length;
+ var leftAnimators = [];
+ for (var i = 0; i < len; i++) {
+ var animator = animators[i];
+ if (!scope || scope === animator.scope) {
+ animator.stop(forwardToLast);
+ }
+ else {
+ leftAnimators.push(animator);
+ }
+ }
+ this.animators = leftAnimators;
+ return this;
+ };
+ Element.prototype.animateTo = function (target, cfg, animationProps) {
+ animateTo(this, target, cfg, animationProps);
+ };
+ Element.prototype.animateFrom = function (target, cfg, animationProps) {
+ animateTo(this, target, cfg, animationProps, true);
+ };
+ Element.prototype._transitionState = function (stateName, target, cfg, animationProps) {
+ var animators = animateTo(this, target, cfg, animationProps);
+ for (var i = 0; i < animators.length; i++) {
+ animators[i].__fromStateTransition = stateName;
+ }
+ };
+ Element.prototype.getBoundingRect = function () {
+ return null;
+ };
+ Element.prototype.getPaintRect = function () {
+ return null;
+ };
+ Element.initDefaultProps = (function () {
+ var elProto = Element.prototype;
+ elProto.type = 'element';
+ elProto.name = '';
+ elProto.ignore =
+ elProto.silent =
+ elProto.isGroup =
+ elProto.draggable =
+ elProto.dragging =
+ elProto.ignoreClip =
+ elProto.__inHover = false;
+ elProto.__dirty = REDRAW_BIT;
+ var logs = {};
+ function logDeprecatedError(key, xKey, yKey) {
+ if (!logs[key + xKey + yKey]) {
+ console.warn("DEPRECATED: '" + key + "' has been deprecated. use '" + xKey + "', '" + yKey + "' instead");
+ logs[key + xKey + yKey] = true;
+ }
+ }
+ function createLegacyProperty(key, privateKey, xKey, yKey) {
+ Object.defineProperty(elProto, key, {
+ get: function () {
+ if ("development" !== 'production') {
+ logDeprecatedError(key, xKey, yKey);
+ }
+ if (!this[privateKey]) {
+ var pos = this[privateKey] = [];
+ enhanceArray(this, pos);
+ }
+ return this[privateKey];
+ },
+ set: function (pos) {
+ if ("development" !== 'production') {
+ logDeprecatedError(key, xKey, yKey);
+ }
+ this[xKey] = pos[0];
+ this[yKey] = pos[1];
+ this[privateKey] = pos;
+ enhanceArray(this, pos);
+ }
+ });
+ function enhanceArray(self, pos) {
+ Object.defineProperty(pos, 0, {
+ get: function () {
+ return self[xKey];
+ },
+ set: function (val) {
+ self[xKey] = val;
+ }
+ });
+ Object.defineProperty(pos, 1, {
+ get: function () {
+ return self[yKey];
+ },
+ set: function (val) {
+ self[yKey] = val;
+ }
+ });
+ }
+ }
+ if (Object.defineProperty) {
+ createLegacyProperty('position', '_legacyPos', 'x', 'y');
+ createLegacyProperty('scale', '_legacyScale', 'scaleX', 'scaleY');
+ createLegacyProperty('origin', '_legacyOrigin', 'originX', 'originY');
+ }
+ })();
+ return Element;
+}());
+mixin(Element, Eventful);
+mixin(Element, Transformable);
+function animateTo(animatable, target, cfg, animationProps, reverse) {
+ cfg = cfg || {};
+ var animators = [];
+ animateToShallow(animatable, '', animatable, target, cfg, animationProps, animators, reverse);
+ var finishCount = animators.length;
+ var doneHappened = false;
+ var cfgDone = cfg.done;
+ var cfgAborted = cfg.aborted;
+ var doneCb = function () {
+ doneHappened = true;
+ finishCount--;
+ if (finishCount <= 0) {
+ doneHappened
+ ? (cfgDone && cfgDone())
+ : (cfgAborted && cfgAborted());
+ }
+ };
+ var abortedCb = function () {
+ finishCount--;
+ if (finishCount <= 0) {
+ doneHappened
+ ? (cfgDone && cfgDone())
+ : (cfgAborted && cfgAborted());
+ }
+ };
+ if (!finishCount) {
+ cfgDone && cfgDone();
+ }
+ if (animators.length > 0 && cfg.during) {
+ animators[0].during(function (target, percent) {
+ cfg.during(percent);
+ });
+ }
+ for (var i = 0; i < animators.length; i++) {
+ var animator = animators[i];
+ if (doneCb) {
+ animator.done(doneCb);
+ }
+ if (abortedCb) {
+ animator.aborted(abortedCb);
+ }
+ if (cfg.force) {
+ animator.duration(cfg.duration);
+ }
+ animator.start(cfg.easing);
+ }
+ return animators;
+}
+function copyArrShallow(source, target, len) {
+ for (var i = 0; i < len; i++) {
+ source[i] = target[i];
+ }
+}
+function is2DArray(value) {
+ return isArrayLike(value[0]);
+}
+function copyValue(target, source, key) {
+ if (isArrayLike(source[key])) {
+ if (!isArrayLike(target[key])) {
+ target[key] = [];
+ }
+ if (isTypedArray(source[key])) {
+ var len = source[key].length;
+ if (target[key].length !== len) {
+ target[key] = new (source[key].constructor)(len);
+ copyArrShallow(target[key], source[key], len);
+ }
+ }
+ else {
+ var sourceArr = source[key];
+ var targetArr = target[key];
+ var len0 = sourceArr.length;
+ if (is2DArray(sourceArr)) {
+ var len1 = sourceArr[0].length;
+ for (var i = 0; i < len0; i++) {
+ if (!targetArr[i]) {
+ targetArr[i] = Array.prototype.slice.call(sourceArr[i]);
+ }
+ else {
+ copyArrShallow(targetArr[i], sourceArr[i], len1);
+ }
+ }
+ }
+ else {
+ copyArrShallow(targetArr, sourceArr, len0);
+ }
+ targetArr.length = sourceArr.length;
+ }
+ }
+ else {
+ target[key] = source[key];
+ }
+}
+function isValueSame(val1, val2) {
+ return val1 === val2
+ || isArrayLike(val1) && isArrayLike(val2) && is1DArraySame(val1, val2);
+}
+function is1DArraySame(arr0, arr1) {
+ var len = arr0.length;
+ if (len !== arr1.length) {
+ return false;
+ }
+ for (var i = 0; i < len; i++) {
+ if (arr0[i] !== arr1[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+function animateToShallow(animatable, topKey, animateObj, target, cfg, animationProps, animators, reverse) {
+ var targetKeys = keys(target);
+ var duration = cfg.duration;
+ var delay = cfg.delay;
+ var additive = cfg.additive;
+ var setToFinal = cfg.setToFinal;
+ var animateAll = !isObject(animationProps);
+ var existsAnimators = animatable.animators;
+ var animationKeys = [];
+ for (var k = 0; k < targetKeys.length; k++) {
+ var innerKey = targetKeys[k];
+ var targetVal = target[innerKey];
+ if (targetVal != null && animateObj[innerKey] != null
+ && (animateAll || animationProps[innerKey])) {
+ if (isObject(targetVal)
+ && !isArrayLike(targetVal)
+ && !isGradientObject(targetVal)) {
+ if (topKey) {
+ if (!reverse) {
+ animateObj[innerKey] = targetVal;
+ animatable.updateDuringAnimation(topKey);
+ }
+ continue;
+ }
+ animateToShallow(animatable, innerKey, animateObj[innerKey], targetVal, cfg, animationProps && animationProps[innerKey], animators, reverse);
+ }
+ else {
+ animationKeys.push(innerKey);
+ }
+ }
+ else if (!reverse) {
+ animateObj[innerKey] = targetVal;
+ animatable.updateDuringAnimation(topKey);
+ animationKeys.push(innerKey);
+ }
+ }
+ var keyLen = animationKeys.length;
+ if (!additive && keyLen) {
+ for (var i = 0; i < existsAnimators.length; i++) {
+ var animator = existsAnimators[i];
+ if (animator.targetName === topKey) {
+ var allAborted = animator.stopTracks(animationKeys);
+ if (allAborted) {
+ var idx = indexOf(existsAnimators, animator);
+ existsAnimators.splice(idx, 1);
+ }
+ }
+ }
+ }
+ if (!cfg.force) {
+ animationKeys = filter(animationKeys, function (key) { return !isValueSame(target[key], animateObj[key]); });
+ keyLen = animationKeys.length;
+ }
+ if (keyLen > 0
+ || (cfg.force && !animators.length)) {
+ var revertedSource = void 0;
+ var reversedTarget = void 0;
+ var sourceClone = void 0;
+ if (reverse) {
+ reversedTarget = {};
+ if (setToFinal) {
+ revertedSource = {};
+ }
+ for (var i = 0; i < keyLen; i++) {
+ var innerKey = animationKeys[i];
+ reversedTarget[innerKey] = animateObj[innerKey];
+ if (setToFinal) {
+ revertedSource[innerKey] = target[innerKey];
+ }
+ else {
+ animateObj[innerKey] = target[innerKey];
+ }
+ }
+ }
+ else if (setToFinal) {
+ sourceClone = {};
+ for (var i = 0; i < keyLen; i++) {
+ var innerKey = animationKeys[i];
+ sourceClone[innerKey] = cloneValue(animateObj[innerKey]);
+ copyValue(animateObj, target, innerKey);
+ }
+ }
+ var animator = new Animator(animateObj, false, false, additive ? filter(existsAnimators, function (animator) { return animator.targetName === topKey; }) : null);
+ animator.targetName = topKey;
+ if (cfg.scope) {
+ animator.scope = cfg.scope;
+ }
+ if (setToFinal && revertedSource) {
+ animator.whenWithKeys(0, revertedSource, animationKeys);
+ }
+ if (sourceClone) {
+ animator.whenWithKeys(0, sourceClone, animationKeys);
+ }
+ animator.whenWithKeys(duration == null ? 500 : duration, reverse ? reversedTarget : target, animationKeys).delay(delay || 0);
+ animatable.addAnimator(animator, topKey);
+ animators.push(animator);
+ }
+}
+
+var Group = (function (_super) {
+ __extends(Group, _super);
+ function Group(opts) {
+ var _this = _super.call(this) || this;
+ _this.isGroup = true;
+ _this._children = [];
+ _this.attr(opts);
+ return _this;
+ }
+ Group.prototype.childrenRef = function () {
+ return this._children;
+ };
+ Group.prototype.children = function () {
+ return this._children.slice();
+ };
+ Group.prototype.childAt = function (idx) {
+ return this._children[idx];
+ };
+ Group.prototype.childOfName = function (name) {
+ var children = this._children;
+ for (var i = 0; i < children.length; i++) {
+ if (children[i].name === name) {
+ return children[i];
+ }
+ }
+ };
+ Group.prototype.childCount = function () {
+ return this._children.length;
+ };
+ Group.prototype.add = function (child) {
+ if (child) {
+ if (child !== this && child.parent !== this) {
+ this._children.push(child);
+ this._doAdd(child);
+ }
+ if ("development" !== 'production') {
+ if (child.__hostTarget) {
+ throw 'This elemenet has been used as an attachment';
+ }
+ }
+ }
+ return this;
+ };
+ Group.prototype.addBefore = function (child, nextSibling) {
+ if (child && child !== this && child.parent !== this
+ && nextSibling && nextSibling.parent === this) {
+ var children = this._children;
+ var idx = children.indexOf(nextSibling);
+ if (idx >= 0) {
+ children.splice(idx, 0, child);
+ this._doAdd(child);
+ }
+ }
+ return this;
+ };
+ Group.prototype.replace = function (oldChild, newChild) {
+ var idx = indexOf(this._children, oldChild);
+ if (idx >= 0) {
+ this.replaceAt(newChild, idx);
+ }
+ return this;
+ };
+ Group.prototype.replaceAt = function (child, index) {
+ var children = this._children;
+ var old = children[index];
+ if (child && child !== this && child.parent !== this && child !== old) {
+ children[index] = child;
+ old.parent = null;
+ var zr = this.__zr;
+ if (zr) {
+ old.removeSelfFromZr(zr);
+ }
+ this._doAdd(child);
+ }
+ return this;
+ };
+ Group.prototype._doAdd = function (child) {
+ if (child.parent) {
+ child.parent.remove(child);
+ }
+ child.parent = this;
+ var zr = this.__zr;
+ if (zr && zr !== child.__zr) {
+ child.addSelfToZr(zr);
+ }
+ zr && zr.refresh();
+ };
+ Group.prototype.remove = function (child) {
+ var zr = this.__zr;
+ var children = this._children;
+ var idx = indexOf(children, child);
+ if (idx < 0) {
+ return this;
+ }
+ children.splice(idx, 1);
+ child.parent = null;
+ if (zr) {
+ child.removeSelfFromZr(zr);
+ }
+ zr && zr.refresh();
+ return this;
+ };
+ Group.prototype.removeAll = function () {
+ var children = this._children;
+ var zr = this.__zr;
+ for (var i = 0; i < children.length; i++) {
+ var child = children[i];
+ if (zr) {
+ child.removeSelfFromZr(zr);
+ }
+ child.parent = null;
+ }
+ children.length = 0;
+ return this;
+ };
+ Group.prototype.eachChild = function (cb, context) {
+ var children = this._children;
+ for (var i = 0; i < children.length; i++) {
+ var child = children[i];
+ cb.call(context, child, i);
+ }
+ return this;
+ };
+ Group.prototype.traverse = function (cb, context) {
+ for (var i = 0; i < this._children.length; i++) {
+ var child = this._children[i];
+ var stopped = cb.call(context, child);
+ if (child.isGroup && !stopped) {
+ child.traverse(cb, context);
+ }
+ }
+ return this;
+ };
+ Group.prototype.addSelfToZr = function (zr) {
+ _super.prototype.addSelfToZr.call(this, zr);
+ for (var i = 0; i < this._children.length; i++) {
+ var child = this._children[i];
+ child.addSelfToZr(zr);
+ }
+ };
+ Group.prototype.removeSelfFromZr = function (zr) {
+ _super.prototype.removeSelfFromZr.call(this, zr);
+ for (var i = 0; i < this._children.length; i++) {
+ var child = this._children[i];
+ child.removeSelfFromZr(zr);
+ }
+ };
+ Group.prototype.getBoundingRect = function (includeChildren) {
+ var tmpRect = new BoundingRect(0, 0, 0, 0);
+ var children = includeChildren || this._children;
+ var tmpMat = [];
+ var rect = null;
+ for (var i = 0; i < children.length; i++) {
+ var child = children[i];
+ if (child.ignore || child.invisible) {
+ continue;
+ }
+ var childRect = child.getBoundingRect();
+ var transform = child.getLocalTransform(tmpMat);
+ if (transform) {
+ BoundingRect.applyTransform(tmpRect, childRect, transform);
+ rect = rect || tmpRect.clone();
+ rect.union(tmpRect);
+ }
+ else {
+ rect = rect || childRect.clone();
+ rect.union(childRect);
+ }
+ }
+ return rect || tmpRect;
+ };
+ return Group;
+}(Element));
+Group.prototype.type = 'group';
+
+/*!
+* ZRender, a high performance 2d drawing library.
+*
+* Copyright (c) 2013, Baidu Inc.
+* All rights reserved.
+*
+* LICENSE
+* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
+*/
+var painterCtors = {};
+var instances = {};
+function delInstance(id) {
+ delete instances[id];
+}
+function isDarkMode(backgroundColor) {
+ if (!backgroundColor) {
+ return false;
+ }
+ if (typeof backgroundColor === 'string') {
+ return lum(backgroundColor, 1) < DARK_MODE_THRESHOLD;
+ }
+ else if (backgroundColor.colorStops) {
+ var colorStops = backgroundColor.colorStops;
+ var totalLum = 0;
+ var len = colorStops.length;
+ for (var i = 0; i < len; i++) {
+ totalLum += lum(colorStops[i].color, 1);
+ }
+ totalLum /= len;
+ return totalLum < DARK_MODE_THRESHOLD;
+ }
+ return false;
+}
+var ZRender = (function () {
+ function ZRender(id, dom, opts) {
+ var _this = this;
+ this._sleepAfterStill = 10;
+ this._stillFrameAccum = 0;
+ this._needsRefresh = true;
+ this._needsRefreshHover = true;
+ this._darkMode = false;
+ opts = opts || {};
+ this.dom = dom;
+ this.id = id;
+ var storage = new Storage();
+ var rendererType = opts.renderer || 'canvas';
+ if (!painterCtors[rendererType]) {
+ rendererType = keys(painterCtors)[0];
+ }
+ if ("development" !== 'production') {
+ if (!painterCtors[rendererType]) {
+ throw new Error("Renderer '" + rendererType + "' is not imported. Please import it first.");
+ }
+ }
+ opts.useDirtyRect = opts.useDirtyRect == null
+ ? false
+ : opts.useDirtyRect;
+ var painter = new painterCtors[rendererType](dom, storage, opts, id);
+ var ssrMode = opts.ssr || painter.ssrOnly;
+ this.storage = storage;
+ this.painter = painter;
+ var handlerProxy = (!env.node && !env.worker && !ssrMode)
+ ? new HandlerDomProxy(painter.getViewportRoot(), painter.root)
+ : null;
+ var useCoarsePointer = opts.useCoarsePointer;
+ var usePointerSize = (useCoarsePointer == null || useCoarsePointer === 'auto')
+ ? env.touchEventsSupported
+ : !!useCoarsePointer;
+ var defaultPointerSize = 44;
+ var pointerSize;
+ if (usePointerSize) {
+ pointerSize = retrieve2(opts.pointerSize, defaultPointerSize);
+ }
+ this.handler = new Handler(storage, painter, handlerProxy, painter.root, pointerSize);
+ this.animation = new Animation({
+ stage: {
+ update: ssrMode ? null : function () { return _this._flush(true); }
+ }
+ });
+ if (!ssrMode) {
+ this.animation.start();
+ }
+ }
+ ZRender.prototype.add = function (el) {
+ if (this._disposed || !el) {
+ return;
+ }
+ this.storage.addRoot(el);
+ el.addSelfToZr(this);
+ this.refresh();
+ };
+ ZRender.prototype.remove = function (el) {
+ if (this._disposed || !el) {
+ return;
+ }
+ this.storage.delRoot(el);
+ el.removeSelfFromZr(this);
+ this.refresh();
+ };
+ ZRender.prototype.configLayer = function (zLevel, config) {
+ if (this._disposed) {
+ return;
+ }
+ if (this.painter.configLayer) {
+ this.painter.configLayer(zLevel, config);
+ }
+ this.refresh();
+ };
+ ZRender.prototype.setBackgroundColor = function (backgroundColor) {
+ if (this._disposed) {
+ return;
+ }
+ if (this.painter.setBackgroundColor) {
+ this.painter.setBackgroundColor(backgroundColor);
+ }
+ this.refresh();
+ this._backgroundColor = backgroundColor;
+ this._darkMode = isDarkMode(backgroundColor);
+ };
+ ZRender.prototype.getBackgroundColor = function () {
+ return this._backgroundColor;
+ };
+ ZRender.prototype.setDarkMode = function (darkMode) {
+ this._darkMode = darkMode;
+ };
+ ZRender.prototype.isDarkMode = function () {
+ return this._darkMode;
+ };
+ ZRender.prototype.refreshImmediately = function (fromInside) {
+ if (this._disposed) {
+ return;
+ }
+ if (!fromInside) {
+ this.animation.update(true);
+ }
+ this._needsRefresh = false;
+ this.painter.refresh();
+ this._needsRefresh = false;
+ };
+ ZRender.prototype.refresh = function () {
+ if (this._disposed) {
+ return;
+ }
+ this._needsRefresh = true;
+ this.animation.start();
+ };
+ ZRender.prototype.flush = function () {
+ if (this._disposed) {
+ return;
+ }
+ this._flush(false);
+ };
+ ZRender.prototype._flush = function (fromInside) {
+ var triggerRendered;
+ var start = getTime();
+ if (this._needsRefresh) {
+ triggerRendered = true;
+ this.refreshImmediately(fromInside);
+ }
+ if (this._needsRefreshHover) {
+ triggerRendered = true;
+ this.refreshHoverImmediately();
+ }
+ var end = getTime();
+ if (triggerRendered) {
+ this._stillFrameAccum = 0;
+ this.trigger('rendered', {
+ elapsedTime: end - start
+ });
+ }
+ else if (this._sleepAfterStill > 0) {
+ this._stillFrameAccum++;
+ if (this._stillFrameAccum > this._sleepAfterStill) {
+ this.animation.stop();
+ }
+ }
+ };
+ ZRender.prototype.setSleepAfterStill = function (stillFramesCount) {
+ this._sleepAfterStill = stillFramesCount;
+ };
+ ZRender.prototype.wakeUp = function () {
+ if (this._disposed) {
+ return;
+ }
+ this.animation.start();
+ this._stillFrameAccum = 0;
+ };
+ ZRender.prototype.refreshHover = function () {
+ this._needsRefreshHover = true;
+ };
+ ZRender.prototype.refreshHoverImmediately = function () {
+ if (this._disposed) {
+ return;
+ }
+ this._needsRefreshHover = false;
+ if (this.painter.refreshHover && this.painter.getType() === 'canvas') {
+ this.painter.refreshHover();
+ }
+ };
+ ZRender.prototype.resize = function (opts) {
+ if (this._disposed) {
+ return;
+ }
+ opts = opts || {};
+ this.painter.resize(opts.width, opts.height);
+ this.handler.resize();
+ };
+ ZRender.prototype.clearAnimation = function () {
+ if (this._disposed) {
+ return;
+ }
+ this.animation.clear();
+ };
+ ZRender.prototype.getWidth = function () {
+ if (this._disposed) {
+ return;
+ }
+ return this.painter.getWidth();
+ };
+ ZRender.prototype.getHeight = function () {
+ if (this._disposed) {
+ return;
+ }
+ return this.painter.getHeight();
+ };
+ ZRender.prototype.setCursorStyle = function (cursorStyle) {
+ if (this._disposed) {
+ return;
+ }
+ this.handler.setCursorStyle(cursorStyle);
+ };
+ ZRender.prototype.findHover = function (x, y) {
+ if (this._disposed) {
+ return;
+ }
+ return this.handler.findHover(x, y);
+ };
+ ZRender.prototype.on = function (eventName, eventHandler, context) {
+ if (!this._disposed) {
+ this.handler.on(eventName, eventHandler, context);
+ }
+ return this;
+ };
+ ZRender.prototype.off = function (eventName, eventHandler) {
+ if (this._disposed) {
+ return;
+ }
+ this.handler.off(eventName, eventHandler);
+ };
+ ZRender.prototype.trigger = function (eventName, event) {
+ if (this._disposed) {
+ return;
+ }
+ this.handler.trigger(eventName, event);
+ };
+ ZRender.prototype.clear = function () {
+ if (this._disposed) {
+ return;
+ }
+ var roots = this.storage.getRoots();
+ for (var i = 0; i < roots.length; i++) {
+ if (roots[i] instanceof Group) {
+ roots[i].removeSelfFromZr(this);
+ }
+ }
+ this.storage.delAllRoots();
+ this.painter.clear();
+ };
+ ZRender.prototype.dispose = function () {
+ if (this._disposed) {
+ return;
+ }
+ this.animation.stop();
+ this.clear();
+ this.storage.dispose();
+ this.painter.dispose();
+ this.handler.dispose();
+ this.animation =
+ this.storage =
+ this.painter =
+ this.handler = null;
+ this._disposed = true;
+ delInstance(this.id);
+ };
+ return ZRender;
+}());
+function init(dom, opts) {
+ var zr = new ZRender(guid(), dom, opts);
+ instances[zr.id] = zr;
+ return zr;
+}
+function dispose(zr) {
+ zr.dispose();
+}
+function disposeAll() {
+ for (var key in instances) {
+ if (instances.hasOwnProperty(key)) {
+ instances[key].dispose();
+ }
+ }
+ instances = {};
+}
+function getInstance(id) {
+ return instances[id];
+}
+function registerPainter(name, Ctor) {
+ painterCtors[name] = Ctor;
+}
+var ssrDataGetter;
+function getElementSSRData(el) {
+ if (typeof ssrDataGetter === 'function') {
+ return ssrDataGetter(el);
+ }
+}
+function registerSSRDataGetter(getter) {
+ ssrDataGetter = getter;
+}
+var version = '5.5.0';
+
+var zrender = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ init: init,
+ dispose: dispose,
+ disposeAll: disposeAll,
+ getInstance: getInstance,
+ registerPainter: registerPainter,
+ getElementSSRData: getElementSSRData,
+ registerSSRDataGetter: registerSSRDataGetter,
+ version: version
+});
+
+var RADIAN_EPSILON = 1e-4;
+// Although chrome already enlarge this number to 100 for `toFixed`, but
+// we sill follow the spec for compatibility.
+var ROUND_SUPPORTED_PRECISION_MAX = 20;
+function _trim(str) {
+ return str.replace(/^\s+|\s+$/g, '');
+}
+/**
+ * Linear mapping a value from domain to range
+ * @param val
+ * @param domain Domain extent domain[0] can be bigger than domain[1]
+ * @param range Range extent range[0] can be bigger than range[1]
+ * @param clamp Default to be false
+ */
+function linearMap(val, domain, range, clamp) {
+ var d0 = domain[0];
+ var d1 = domain[1];
+ var r0 = range[0];
+ var r1 = range[1];
+ var subDomain = d1 - d0;
+ var subRange = r1 - r0;
+ if (subDomain === 0) {
+ return subRange === 0 ? r0 : (r0 + r1) / 2;
+ }
+ // Avoid accuracy problem in edge, such as
+ // 146.39 - 62.83 === 83.55999999999999.
+ // See echarts/test/ut/spec/util/number.js#linearMap#accuracyError
+ // It is a little verbose for efficiency considering this method
+ // is a hotspot.
+ if (clamp) {
+ if (subDomain > 0) {
+ if (val <= d0) {
+ return r0;
+ } else if (val >= d1) {
+ return r1;
+ }
+ } else {
+ if (val >= d0) {
+ return r0;
+ } else if (val <= d1) {
+ return r1;
+ }
+ }
+ } else {
+ if (val === d0) {
+ return r0;
+ }
+ if (val === d1) {
+ return r1;
+ }
+ }
+ return (val - d0) / subDomain * subRange + r0;
+}
+/**
+ * Convert a percent string to absolute number.
+ * Returns NaN if percent is not a valid string or number
+ */
+function parsePercent$1(percent, all) {
+ switch (percent) {
+ case 'center':
+ case 'middle':
+ percent = '50%';
+ break;
+ case 'left':
+ case 'top':
+ percent = '0%';
+ break;
+ case 'right':
+ case 'bottom':
+ percent = '100%';
+ break;
+ }
+ if (isString(percent)) {
+ if (_trim(percent).match(/%$/)) {
+ return parseFloat(percent) / 100 * all;
+ }
+ return parseFloat(percent);
+ }
+ return percent == null ? NaN : +percent;
+}
+function round(x, precision, returnStr) {
+ if (precision == null) {
+ precision = 10;
+ }
+ // Avoid range error
+ precision = Math.min(Math.max(0, precision), ROUND_SUPPORTED_PRECISION_MAX);
+ // PENDING: 1.005.toFixed(2) is '1.00' rather than '1.01'
+ x = (+x).toFixed(precision);
+ return returnStr ? x : +x;
+}
+/**
+ * Inplacd asc sort arr.
+ * The input arr will be modified.
+ */
+function asc(arr) {
+ arr.sort(function (a, b) {
+ return a - b;
+ });
+ return arr;
+}
+/**
+ * Get precision.
+ */
+function getPrecision(val) {
+ val = +val;
+ if (isNaN(val)) {
+ return 0;
+ }
+ // It is much faster than methods converting number to string as follows
+ // let tmp = val.toString();
+ // return tmp.length - 1 - tmp.indexOf('.');
+ // especially when precision is low
+ // Notice:
+ // (1) If the loop count is over about 20, it is slower than `getPrecisionSafe`.
+ // (see https://jsbench.me/2vkpcekkvw/1)
+ // (2) If the val is less than for example 1e-15, the result may be incorrect.
+ // (see test/ut/spec/util/number.test.ts `getPrecision_equal_random`)
+ if (val > 1e-14) {
+ var e = 1;
+ for (var i = 0; i < 15; i++, e *= 10) {
+ if (Math.round(val * e) / e === val) {
+ return i;
+ }
+ }
+ }
+ return getPrecisionSafe(val);
+}
+/**
+ * Get precision with slow but safe method
+ */
+function getPrecisionSafe(val) {
+ // toLowerCase for: '3.4E-12'
+ var str = val.toString().toLowerCase();
+ // Consider scientific notation: '3.4e-12' '3.4e+12'
+ var eIndex = str.indexOf('e');
+ var exp = eIndex > 0 ? +str.slice(eIndex + 1) : 0;
+ var significandPartLen = eIndex > 0 ? eIndex : str.length;
+ var dotIndex = str.indexOf('.');
+ var decimalPartLen = dotIndex < 0 ? 0 : significandPartLen - 1 - dotIndex;
+ return Math.max(0, decimalPartLen - exp);
+}
+/**
+ * Minimal dicernible data precisioin according to a single pixel.
+ */
+function getPixelPrecision(dataExtent, pixelExtent) {
+ var log = Math.log;
+ var LN10 = Math.LN10;
+ var dataQuantity = Math.floor(log(dataExtent[1] - dataExtent[0]) / LN10);
+ var sizeQuantity = Math.round(log(Math.abs(pixelExtent[1] - pixelExtent[0])) / LN10);
+ // toFixed() digits argument must be between 0 and 20.
+ var precision = Math.min(Math.max(-dataQuantity + sizeQuantity, 0), 20);
+ return !isFinite(precision) ? 20 : precision;
+}
+/**
+ * Get a data of given precision, assuring the sum of percentages
+ * in valueList is 1.
+ * The largest remainder method is used.
+ * https://en.wikipedia.org/wiki/Largest_remainder_method
+ *
+ * @param valueList a list of all data
+ * @param idx index of the data to be processed in valueList
+ * @param precision integer number showing digits of precision
+ * @return percent ranging from 0 to 100
+ */
+function getPercentWithPrecision(valueList, idx, precision) {
+ if (!valueList[idx]) {
+ return 0;
+ }
+ var seats = getPercentSeats(valueList, precision);
+ return seats[idx] || 0;
+}
+/**
+ * Get a data of given precision, assuring the sum of percentages
+ * in valueList is 1.
+ * The largest remainder method is used.
+ * https://en.wikipedia.org/wiki/Largest_remainder_method
+ *
+ * @param valueList a list of all data
+ * @param precision integer number showing digits of precision
+ * @return {Array<number>}
+ */
+function getPercentSeats(valueList, precision) {
+ var sum = reduce(valueList, function (acc, val) {
+ return acc + (isNaN(val) ? 0 : val);
+ }, 0);
+ if (sum === 0) {
+ return [];
+ }
+ var digits = Math.pow(10, precision);
+ var votesPerQuota = map(valueList, function (val) {
+ return (isNaN(val) ? 0 : val) / sum * digits * 100;
+ });
+ var targetSeats = digits * 100;
+ var seats = map(votesPerQuota, function (votes) {
+ // Assign automatic seats.
+ return Math.floor(votes);
+ });
+ var currentSum = reduce(seats, function (acc, val) {
+ return acc + val;
+ }, 0);
+ var remainder = map(votesPerQuota, function (votes, idx) {
+ return votes - seats[idx];
+ });
+ // Has remainding votes.
+ while (currentSum < targetSeats) {
+ // Find next largest remainder.
+ var max = Number.NEGATIVE_INFINITY;
+ var maxId = null;
+ for (var i = 0, len = remainder.length; i < len; ++i) {
+ if (remainder[i] > max) {
+ max = remainder[i];
+ maxId = i;
+ }
+ }
+ // Add a vote to max remainder.
+ ++seats[maxId];
+ remainder[maxId] = 0;
+ ++currentSum;
+ }
+ return map(seats, function (seat) {
+ return seat / digits;
+ });
+}
+/**
+ * Solve the floating point adding problem like 0.1 + 0.2 === 0.30000000000000004
+ * See <http://0.30000000000000004.com/>
+ */
+function addSafe(val0, val1) {
+ var maxPrecision = Math.max(getPrecision(val0), getPrecision(val1));
+ // const multiplier = Math.pow(10, maxPrecision);
+ // return (Math.round(val0 * multiplier) + Math.round(val1 * multiplier)) / multiplier;
+ var sum = val0 + val1;
+ // // PENDING: support more?
+ return maxPrecision > ROUND_SUPPORTED_PRECISION_MAX ? sum : round(sum, maxPrecision);
+}
+// Number.MAX_SAFE_INTEGER, ie do not support.
+var MAX_SAFE_INTEGER = 9007199254740991;
+/**
+ * To 0 - 2 * PI, considering negative radian.
+ */
+function remRadian(radian) {
+ var pi2 = Math.PI * 2;
+ return (radian % pi2 + pi2) % pi2;
+}
+/**
+ * @param {type} radian
+ * @return {boolean}
+ */
+function isRadianAroundZero(val) {
+ return val > -RADIAN_EPSILON && val < RADIAN_EPSILON;
+}
+// eslint-disable-next-line
+var TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/; // jshint ignore:line
+/**
+ * @param value valid type: number | string | Date, otherwise return `new Date(NaN)`
+ * These values can be accepted:
+ * + An instance of Date, represent a time in its own time zone.
+ * + Or string in a subset of ISO 8601, only including:
+ * + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06',
+ * + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123',
+ * + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00',
+ * all of which will be treated as local time if time zone is not specified
+ * (see <https://momentjs.com/>).
+ * + Or other string format, including (all of which will be treated as local time):
+ * '2012', '2012-3-1', '2012/3/1', '2012/03/01',
+ * '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123'
+ * + a timestamp, which represent a time in UTC.
+ * @return date Never be null/undefined. If invalid, return `new Date(NaN)`.
+ */
+function parseDate(value) {
+ if (value instanceof Date) {
+ return value;
+ } else if (isString(value)) {
+ // Different browsers parse date in different way, so we parse it manually.
+ // Some other issues:
+ // new Date('1970-01-01') is UTC,
+ // new Date('1970/01/01') and new Date('1970-1-01') is local.
+ // See issue #3623
+ var match = TIME_REG.exec(value);
+ if (!match) {
+ // return Invalid Date.
+ return new Date(NaN);
+ }
+ // Use local time when no timezone offset is specified.
+ if (!match[8]) {
+ // match[n] can only be string or undefined.
+ // But take care of '12' + 1 => '121'.
+ return new Date(+match[1], +(match[2] || 1) - 1, +match[3] || 1, +match[4] || 0, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0);
+ }
+ // Timezoneoffset of Javascript Date has considered DST (Daylight Saving Time,
+ // https://tc39.github.io/ecma262/#sec-daylight-saving-time-adjustment).
+ // For example, system timezone is set as "Time Zone: America/Toronto",
+ // then these code will get different result:
+ // `new Date(1478411999999).getTimezoneOffset(); // get 240`
+ // `new Date(1478412000000).getTimezoneOffset(); // get 300`
+ // So we should not use `new Date`, but use `Date.UTC`.
+ else {
+ var hour = +match[4] || 0;
+ if (match[8].toUpperCase() !== 'Z') {
+ hour -= +match[8].slice(0, 3);
+ }
+ return new Date(Date.UTC(+match[1], +(match[2] || 1) - 1, +match[3] || 1, hour, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0));
+ }
+ } else if (value == null) {
+ return new Date(NaN);
+ }
+ return new Date(Math.round(value));
+}
+/**
+ * Quantity of a number. e.g. 0.1, 1, 10, 100
+ *
+ * @param val
+ * @return
+ */
+function quantity(val) {
+ return Math.pow(10, quantityExponent(val));
+}
+/**
+ * Exponent of the quantity of a number
+ * e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3
+ *
+ * @param val non-negative value
+ * @return
+ */
+function quantityExponent(val) {
+ if (val === 0) {
+ return 0;
+ }
+ var exp = Math.floor(Math.log(val) / Math.LN10);
+ /**
+ * exp is expected to be the rounded-down result of the base-10 log of val.
+ * But due to the precision loss with Math.log(val), we need to restore it
+ * using 10^exp to make sure we can get val back from exp. #11249
+ */
+ if (val / Math.pow(10, exp) >= 10) {
+ exp++;
+ }
+ return exp;
+}
+/**
+ * find a “nice” number approximately equal to x. Round the number if round = true,
+ * take ceiling if round = false. The primary observation is that the “nicest”
+ * numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers.
+ *
+ * See "Nice Numbers for Graph Labels" of Graphic Gems.
+ *
+ * @param val Non-negative value.
+ * @param round
+ * @return Niced number
+ */
+function nice(val, round) {
+ var exponent = quantityExponent(val);
+ var exp10 = Math.pow(10, exponent);
+ var f = val / exp10; // 1 <= f < 10
+ var nf;
+ if (round) {
+ if (f < 1.5) {
+ nf = 1;
+ } else if (f < 2.5) {
+ nf = 2;
+ } else if (f < 4) {
+ nf = 3;
+ } else if (f < 7) {
+ nf = 5;
+ } else {
+ nf = 10;
+ }
+ } else {
+ if (f < 1) {
+ nf = 1;
+ } else if (f < 2) {
+ nf = 2;
+ } else if (f < 3) {
+ nf = 3;
+ } else if (f < 5) {
+ nf = 5;
+ } else {
+ nf = 10;
+ }
+ }
+ val = nf * exp10;
+ // Fix 3 * 0.1 === 0.30000000000000004 issue (see IEEE 754).
+ // 20 is the uppper bound of toFixed.
+ return exponent >= -20 ? +val.toFixed(exponent < 0 ? -exponent : 0) : val;
+}
+/**
+ * This code was copied from "d3.js"
+ * <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/arrays/quantile.js>.
+ * See the license statement at the head of this file.
+ * @param ascArr
+ */
+function quantile(ascArr, p) {
+ var H = (ascArr.length - 1) * p + 1;
+ var h = Math.floor(H);
+ var v = +ascArr[h - 1];
+ var e = H - h;
+ return e ? v + e * (ascArr[h] - v) : v;
+}
+/**
+ * Order intervals asc, and split them when overlap.
+ * expect(numberUtil.reformIntervals([
+ * {interval: [18, 62], close: [1, 1]},
+ * {interval: [-Infinity, -70], close: [0, 0]},
+ * {interval: [-70, -26], close: [1, 1]},
+ * {interval: [-26, 18], close: [1, 1]},
+ * {interval: [62, 150], close: [1, 1]},
+ * {interval: [106, 150], close: [1, 1]},
+ * {interval: [150, Infinity], close: [0, 0]}
+ * ])).toEqual([
+ * {interval: [-Infinity, -70], close: [0, 0]},
+ * {interval: [-70, -26], close: [1, 1]},
+ * {interval: [-26, 18], close: [0, 1]},
+ * {interval: [18, 62], close: [0, 1]},
+ * {interval: [62, 150], close: [0, 1]},
+ * {interval: [150, Infinity], close: [0, 0]}
+ * ]);
+ * @param list, where `close` mean open or close
+ * of the interval, and Infinity can be used.
+ * @return The origin list, which has been reformed.
+ */
+function reformIntervals(list) {
+ list.sort(function (a, b) {
+ return littleThan(a, b, 0) ? -1 : 1;
+ });
+ var curr = -Infinity;
+ var currClose = 1;
+ for (var i = 0; i < list.length;) {
+ var interval = list[i].interval;
+ var close_1 = list[i].close;
+ for (var lg = 0; lg < 2; lg++) {
+ if (interval[lg] <= curr) {
+ interval[lg] = curr;
+ close_1[lg] = !lg ? 1 - currClose : 1;
+ }
+ curr = interval[lg];
+ currClose = close_1[lg];
+ }
+ if (interval[0] === interval[1] && close_1[0] * close_1[1] !== 1) {
+ list.splice(i, 1);
+ } else {
+ i++;
+ }
+ }
+ return list;
+ function littleThan(a, b, lg) {
+ return a.interval[lg] < b.interval[lg] || a.interval[lg] === b.interval[lg] && (a.close[lg] - b.close[lg] === (!lg ? 1 : -1) || !lg && littleThan(a, b, 1));
+ }
+}
+/**
+ * [Numeric is defined as]:
+ * `parseFloat(val) == val`
+ * For example:
+ * numeric:
+ * typeof number except NaN, '-123', '123', '2e3', '-2e3', '011', 'Infinity', Infinity,
+ * and they rounded by white-spaces or line-terminal like ' -123 \n ' (see es spec)
+ * not-numeric:
+ * null, undefined, [], {}, true, false, 'NaN', NaN, '123ab',
+ * empty string, string with only white-spaces or line-terminal (see es spec),
+ * 0x12, '0x12', '-0x12', 012, '012', '-012',
+ * non-string, ...
+ *
+ * @test See full test cases in `test/ut/spec/util/number.js`.
+ * @return Must be a typeof number. If not numeric, return NaN.
+ */
+function numericToNumber(val) {
+ var valFloat = parseFloat(val);
+ return valFloat == val // eslint-disable-line eqeqeq
+ && (valFloat !== 0 || !isString(val) || val.indexOf('x') <= 0) // For case ' 0x0 '.
+ ? valFloat : NaN;
+}
+/**
+ * Definition of "numeric": see `numericToNumber`.
+ */
+function isNumeric(val) {
+ return !isNaN(numericToNumber(val));
+}
+/**
+ * Use random base to prevent users hard code depending on
+ * this auto generated marker id.
+ * @return An positive integer.
+ */
+function getRandomIdBase() {
+ return Math.round(Math.random() * 9);
+}
+/**
+ * Get the greatest common divisor.
+ *
+ * @param {number} a one number
+ * @param {number} b the other number
+ */
+function getGreatestCommonDividor(a, b) {
+ if (b === 0) {
+ return a;
+ }
+ return getGreatestCommonDividor(b, a % b);
+}
+/**
+ * Get the least common multiple.
+ *
+ * @param {number} a one number
+ * @param {number} b the other number
+ */
+function getLeastCommonMultiple(a, b) {
+ if (a == null) {
+ return b;
+ }
+ if (b == null) {
+ return a;
+ }
+ return a * b / getGreatestCommonDividor(a, b);
+}
+
+var ECHARTS_PREFIX = '[ECharts] ';
+var storedLogs = {};
+var hasConsole = typeof console !== 'undefined'
+// eslint-disable-next-line
+&& console.warn && console.log;
+function outputLog(type, str, onlyOnce) {
+ if (hasConsole) {
+ if (onlyOnce) {
+ if (storedLogs[str]) {
+ return;
+ }
+ storedLogs[str] = true;
+ }
+ // eslint-disable-next-line
+ console[type](ECHARTS_PREFIX + str);
+ }
+}
+function log(str, onlyOnce) {
+ outputLog('log', str, onlyOnce);
+}
+function warn(str, onlyOnce) {
+ outputLog('warn', str, onlyOnce);
+}
+function error(str, onlyOnce) {
+ outputLog('error', str, onlyOnce);
+}
+function deprecateLog(str) {
+ if ("development" !== 'production') {
+ // Not display duplicate message.
+ outputLog('warn', 'DEPRECATED: ' + str, true);
+ }
+}
+function deprecateReplaceLog(oldOpt, newOpt, scope) {
+ if ("development" !== 'production') {
+ deprecateLog((scope ? "[" + scope + "]" : '') + (oldOpt + " is deprecated, use " + newOpt + " instead."));
+ }
+}
+/**
+ * If in __DEV__ environment, get console printable message for users hint.
+ * Parameters are separated by ' '.
+ * @usage
+ * makePrintable('This is an error on', someVar, someObj);
+ *
+ * @param hintInfo anything about the current execution context to hint users.
+ * @throws Error
+ */
+function makePrintable() {
+ var hintInfo = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ hintInfo[_i] = arguments[_i];
+ }
+ var msg = '';
+ if ("development" !== 'production') {
+ // Fuzzy stringify for print.
+ // This code only exist in dev environment.
+ var makePrintableStringIfPossible_1 = function (val) {
+ return val === void 0 ? 'undefined' : val === Infinity ? 'Infinity' : val === -Infinity ? '-Infinity' : eqNaN(val) ? 'NaN' : val instanceof Date ? 'Date(' + val.toISOString() + ')' : isFunction(val) ? 'function () { ... }' : isRegExp(val) ? val + '' : null;
+ };
+ msg = map(hintInfo, function (arg) {
+ if (isString(arg)) {
+ // Print without quotation mark for some statement.
+ return arg;
+ } else {
+ var printableStr = makePrintableStringIfPossible_1(arg);
+ if (printableStr != null) {
+ return printableStr;
+ } else if (typeof JSON !== 'undefined' && JSON.stringify) {
+ try {
+ return JSON.stringify(arg, function (n, val) {
+ var printableStr = makePrintableStringIfPossible_1(val);
+ return printableStr == null ? val : printableStr;
+ });
+ // In most cases the info object is small, so do not line break.
+ } catch (err) {
+ return '?';
+ }
+ } else {
+ return '?';
+ }
+ }
+ }).join(' ');
+ }
+ return msg;
+}
+/**
+ * @throws Error
+ */
+function throwError(msg) {
+ throw new Error(msg);
+}
+
+function interpolateNumber$1(p0, p1, percent) {
+ return (p1 - p0) * percent + p0;
+}
+/**
+ * Make the name displayable. But we should
+ * make sure it is not duplicated with user
+ * specified name, so use '\0';
+ */
+var DUMMY_COMPONENT_NAME_PREFIX = 'series\0';
+var INTERNAL_COMPONENT_ID_PREFIX = '\0_ec_\0';
+/**
+ * If value is not array, then translate it to array.
+ * @param {*} value
+ * @return {Array} [value] or value
+ */
+function normalizeToArray(value) {
+ return value instanceof Array ? value : value == null ? [] : [value];
+}
+/**
+ * Sync default option between normal and emphasis like `position` and `show`
+ * In case some one will write code like
+ * label: {
+ * show: false,
+ * position: 'outside',
+ * fontSize: 18
+ * },
+ * emphasis: {
+ * label: { show: true }
+ * }
+ */
+function defaultEmphasis(opt, key, subOpts) {
+ // Caution: performance sensitive.
+ if (opt) {
+ opt[key] = opt[key] || {};
+ opt.emphasis = opt.emphasis || {};
+ opt.emphasis[key] = opt.emphasis[key] || {};
+ // Default emphasis option from normal
+ for (var i = 0, len = subOpts.length; i < len; i++) {
+ var subOptName = subOpts[i];
+ if (!opt.emphasis[key].hasOwnProperty(subOptName) && opt[key].hasOwnProperty(subOptName)) {
+ opt.emphasis[key][subOptName] = opt[key][subOptName];
+ }
+ }
+ }
+}
+var TEXT_STYLE_OPTIONS = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'rich', 'tag', 'color', 'textBorderColor', 'textBorderWidth', 'width', 'height', 'lineHeight', 'align', 'verticalAlign', 'baseline', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY', 'textShadowColor', 'textShadowBlur', 'textShadowOffsetX', 'textShadowOffsetY', 'backgroundColor', 'borderColor', 'borderWidth', 'borderRadius', 'padding'];
+// modelUtil.LABEL_OPTIONS = modelUtil.TEXT_STYLE_OPTIONS.concat([
+// 'position', 'offset', 'rotate', 'origin', 'show', 'distance', 'formatter',
+// 'fontStyle', 'fontWeight', 'fontSize', 'fontFamily',
+// // FIXME: deprecated, check and remove it.
+// 'textStyle'
+// ]);
+/**
+ * The method does not ensure performance.
+ * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]
+ * This helper method retrieves value from data.
+ */
+function getDataItemValue(dataItem) {
+ return isObject(dataItem) && !isArray(dataItem) && !(dataItem instanceof Date) ? dataItem.value : dataItem;
+}
+/**
+ * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]
+ * This helper method determine if dataItem has extra option besides value
+ */
+function isDataItemOption(dataItem) {
+ return isObject(dataItem) && !(dataItem instanceof Array);
+ // // markLine data can be array
+ // && !(dataItem[0] && isObject(dataItem[0]) && !(dataItem[0] instanceof Array));
+}
+/**
+ * Mapping to existings for merge.
+ *
+ * Mode "normalMege":
+ * The mapping result (merge result) will keep the order of the existing
+ * component, rather than the order of new option. Because we should ensure
+ * some specified index reference (like xAxisIndex) keep work.
+ * And in most cases, "merge option" is used to update partial option but not
+ * be expected to change the order.
+ *
+ * Mode "replaceMege":
+ * (1) Only the id mapped components will be merged.
+ * (2) Other existing components (except internal components) will be removed.
+ * (3) Other new options will be used to create new component.
+ * (4) The index of the existing components will not be modified.
+ * That means their might be "hole" after the removal.
+ * The new components are created first at those available index.
+ *
+ * Mode "replaceAll":
+ * This mode try to support that reproduce an echarts instance from another
+ * echarts instance (via `getOption`) in some simple cases.
+ * In this scenario, the `result` index are exactly the consistent with the `newCmptOptions`,
+ * which ensures the component index referring (like `xAxisIndex: ?`) corrent. That is,
+ * the "hole" in `newCmptOptions` will also be kept.
+ * On the contrary, other modes try best to eliminate holes.
+ * PENDING: This is an experimental mode yet.
+ *
+ * @return See the comment of <MappingResult>.
+ */
+function mappingToExists(existings, newCmptOptions, mode) {
+ var isNormalMergeMode = mode === 'normalMerge';
+ var isReplaceMergeMode = mode === 'replaceMerge';
+ var isReplaceAllMode = mode === 'replaceAll';
+ existings = existings || [];
+ newCmptOptions = (newCmptOptions || []).slice();
+ var existingIdIdxMap = createHashMap();
+ // Validate id and name on user input option.
+ each(newCmptOptions, function (cmptOption, index) {
+ if (!isObject(cmptOption)) {
+ newCmptOptions[index] = null;
+ return;
+ }
+ if ("development" !== 'production') {
+ // There is some legacy case that name is set as `false`.
+ // But should work normally rather than throw error.
+ if (cmptOption.id != null && !isValidIdOrName(cmptOption.id)) {
+ warnInvalidateIdOrName(cmptOption.id);
+ }
+ if (cmptOption.name != null && !isValidIdOrName(cmptOption.name)) {
+ warnInvalidateIdOrName(cmptOption.name);
+ }
+ }
+ });
+ var result = prepareResult(existings, existingIdIdxMap, mode);
+ if (isNormalMergeMode || isReplaceMergeMode) {
+ mappingById(result, existings, existingIdIdxMap, newCmptOptions);
+ }
+ if (isNormalMergeMode) {
+ mappingByName(result, newCmptOptions);
+ }
+ if (isNormalMergeMode || isReplaceMergeMode) {
+ mappingByIndex(result, newCmptOptions, isReplaceMergeMode);
+ } else if (isReplaceAllMode) {
+ mappingInReplaceAllMode(result, newCmptOptions);
+ }
+ makeIdAndName(result);
+ // The array `result` MUST NOT contain elided items, otherwise the
+ // forEach will omit those items and result in incorrect result.
+ return result;
+}
+function prepareResult(existings, existingIdIdxMap, mode) {
+ var result = [];
+ if (mode === 'replaceAll') {
+ return result;
+ }
+ // Do not use native `map` to in case that the array `existings`
+ // contains elided items, which will be omitted.
+ for (var index = 0; index < existings.length; index++) {
+ var existing = existings[index];
+ // Because of replaceMerge, `existing` may be null/undefined.
+ if (existing && existing.id != null) {
+ existingIdIdxMap.set(existing.id, index);
+ }
+ // For non-internal-componnets:
+ // Mode "normalMerge": all existings kept.
+ // Mode "replaceMerge": all existing removed unless mapped by id.
+ // For internal-components:
+ // go with "replaceMerge" approach in both mode.
+ result.push({
+ existing: mode === 'replaceMerge' || isComponentIdInternal(existing) ? null : existing,
+ newOption: null,
+ keyInfo: null,
+ brandNew: null
+ });
+ }
+ return result;
+}
+function mappingById(result, existings, existingIdIdxMap, newCmptOptions) {
+ // Mapping by id if specified.
+ each(newCmptOptions, function (cmptOption, index) {
+ if (!cmptOption || cmptOption.id == null) {
+ return;
+ }
+ var optionId = makeComparableKey(cmptOption.id);
+ var existingIdx = existingIdIdxMap.get(optionId);
+ if (existingIdx != null) {
+ var resultItem = result[existingIdx];
+ assert(!resultItem.newOption, 'Duplicated option on id "' + optionId + '".');
+ resultItem.newOption = cmptOption;
+ // In both mode, if id matched, new option will be merged to
+ // the existings rather than creating new component model.
+ resultItem.existing = existings[existingIdx];
+ newCmptOptions[index] = null;
+ }
+ });
+}
+function mappingByName(result, newCmptOptions) {
+ // Mapping by name if specified.
+ each(newCmptOptions, function (cmptOption, index) {
+ if (!cmptOption || cmptOption.name == null) {
+ return;
+ }
+ for (var i = 0; i < result.length; i++) {
+ var existing = result[i].existing;
+ if (!result[i].newOption // Consider name: two map to one.
+ // Can not match when both ids existing but different.
+ && existing && (existing.id == null || cmptOption.id == null) && !isComponentIdInternal(cmptOption) && !isComponentIdInternal(existing) && keyExistAndEqual('name', existing, cmptOption)) {
+ result[i].newOption = cmptOption;
+ newCmptOptions[index] = null;
+ return;
+ }
+ }
+ });
+}
+function mappingByIndex(result, newCmptOptions, brandNew) {
+ each(newCmptOptions, function (cmptOption) {
+ if (!cmptOption) {
+ return;
+ }
+ // Find the first place that not mapped by id and not internal component (consider the "hole").
+ var resultItem;
+ var nextIdx = 0;
+ while (
+ // Be `!resultItem` only when `nextIdx >= result.length`.
+ (resultItem = result[nextIdx]
+ // (1) Existing models that already have id should be able to mapped to. Because
+ // after mapping performed, model will always be assigned with an id if user not given.
+ // After that all models have id.
+ // (2) If new option has id, it can only set to a hole or append to the last. It should
+ // not be merged to the existings with different id. Because id should not be overwritten.
+ // (3) Name can be overwritten, because axis use name as 'show label text'.
+ ) && (resultItem.newOption || isComponentIdInternal(resultItem.existing) ||
+ // In mode "replaceMerge", here no not-mapped-non-internal-existing.
+ resultItem.existing && cmptOption.id != null && !keyExistAndEqual('id', cmptOption, resultItem.existing))) {
+ nextIdx++;
+ }
+ if (resultItem) {
+ resultItem.newOption = cmptOption;
+ resultItem.brandNew = brandNew;
+ } else {
+ result.push({
+ newOption: cmptOption,
+ brandNew: brandNew,
+ existing: null,
+ keyInfo: null
+ });
+ }
+ nextIdx++;
+ });
+}
+function mappingInReplaceAllMode(result, newCmptOptions) {
+ each(newCmptOptions, function (cmptOption) {
+ // The feature "reproduce" requires "hole" will also reproduced
+ // in case that component index referring are broken.
+ result.push({
+ newOption: cmptOption,
+ brandNew: true,
+ existing: null,
+ keyInfo: null
+ });
+ });
+}
+/**
+ * Make id and name for mapping result (result of mappingToExists)
+ * into `keyInfo` field.
+ */
+function makeIdAndName(mapResult) {
+ // We use this id to hash component models and view instances
+ // in echarts. id can be specified by user, or auto generated.
+ // The id generation rule ensures new view instance are able
+ // to mapped to old instance when setOption are called in
+ // no-merge mode. So we generate model id by name and plus
+ // type in view id.
+ // name can be duplicated among components, which is convenient
+ // to specify multi components (like series) by one name.
+ // Ensure that each id is distinct.
+ var idMap = createHashMap();
+ each(mapResult, function (item) {
+ var existing = item.existing;
+ existing && idMap.set(existing.id, item);
+ });
+ each(mapResult, function (item) {
+ var opt = item.newOption;
+ // Force ensure id not duplicated.
+ assert(!opt || opt.id == null || !idMap.get(opt.id) || idMap.get(opt.id) === item, 'id duplicates: ' + (opt && opt.id));
+ opt && opt.id != null && idMap.set(opt.id, item);
+ !item.keyInfo && (item.keyInfo = {});
+ });
+ // Make name and id.
+ each(mapResult, function (item, index) {
+ var existing = item.existing;
+ var opt = item.newOption;
+ var keyInfo = item.keyInfo;
+ if (!isObject(opt)) {
+ return;
+ }
+ // Name can be overwritten. Consider case: axis.name = '20km'.
+ // But id generated by name will not be changed, which affect
+ // only in that case: setOption with 'not merge mode' and view
+ // instance will be recreated, which can be accepted.
+ keyInfo.name = opt.name != null ? makeComparableKey(opt.name) : existing ? existing.name
+ // Avoid that different series has the same name,
+ // because name may be used like in color pallet.
+ : DUMMY_COMPONENT_NAME_PREFIX + index;
+ if (existing) {
+ keyInfo.id = makeComparableKey(existing.id);
+ } else if (opt.id != null) {
+ keyInfo.id = makeComparableKey(opt.id);
+ } else {
+ // Consider this situatoin:
+ // optionA: [{name: 'a'}, {name: 'a'}, {..}]
+ // optionB [{..}, {name: 'a'}, {name: 'a'}]
+ // Series with the same name between optionA and optionB
+ // should be mapped.
+ var idNum = 0;
+ do {
+ keyInfo.id = '\0' + keyInfo.name + '\0' + idNum++;
+ } while (idMap.get(keyInfo.id));
+ }
+ idMap.set(keyInfo.id, item);
+ });
+}
+function keyExistAndEqual(attr, obj1, obj2) {
+ var key1 = convertOptionIdName(obj1[attr], null);
+ var key2 = convertOptionIdName(obj2[attr], null);
+ // See `MappingExistingItem`. `id` and `name` trade string equals to number.
+ return key1 != null && key2 != null && key1 === key2;
+}
+/**
+ * @return return null if not exist.
+ */
+function makeComparableKey(val) {
+ if ("development" !== 'production') {
+ if (val == null) {
+ throw new Error();
+ }
+ }
+ return convertOptionIdName(val, '');
+}
+function convertOptionIdName(idOrName, defaultValue) {
+ if (idOrName == null) {
+ return defaultValue;
+ }
+ return isString(idOrName) ? idOrName : isNumber(idOrName) || isStringSafe(idOrName) ? idOrName + '' : defaultValue;
+}
+function warnInvalidateIdOrName(idOrName) {
+ if ("development" !== 'production') {
+ warn('`' + idOrName + '` is invalid id or name. Must be a string or number.');
+ }
+}
+function isValidIdOrName(idOrName) {
+ return isStringSafe(idOrName) || isNumeric(idOrName);
+}
+function isNameSpecified(componentModel) {
+ var name = componentModel.name;
+ // Is specified when `indexOf` get -1 or > 0.
+ return !!(name && name.indexOf(DUMMY_COMPONENT_NAME_PREFIX));
+}
+/**
+ * @public
+ * @param {Object} cmptOption
+ * @return {boolean}
+ */
+function isComponentIdInternal(cmptOption) {
+ return cmptOption && cmptOption.id != null && makeComparableKey(cmptOption.id).indexOf(INTERNAL_COMPONENT_ID_PREFIX) === 0;
+}
+function makeInternalComponentId(idSuffix) {
+ return INTERNAL_COMPONENT_ID_PREFIX + idSuffix;
+}
+function setComponentTypeToKeyInfo(mappingResult, mainType, componentModelCtor) {
+ // Set mainType and complete subType.
+ each(mappingResult, function (item) {
+ var newOption = item.newOption;
+ if (isObject(newOption)) {
+ item.keyInfo.mainType = mainType;
+ item.keyInfo.subType = determineSubType(mainType, newOption, item.existing, componentModelCtor);
+ }
+ });
+}
+function determineSubType(mainType, newCmptOption, existComponent, componentModelCtor) {
+ var subType = newCmptOption.type ? newCmptOption.type : existComponent ? existComponent.subType
+ // Use determineSubType only when there is no existComponent.
+ : componentModelCtor.determineSubType(mainType, newCmptOption);
+ // tooltip, markline, markpoint may always has no subType
+ return subType;
+}
+/**
+ * A helper for removing duplicate items between batchA and batchB,
+ * and in themselves, and categorize by series.
+ *
+ * @param batchA Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]
+ * @param batchB Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]
+ * @return result: [resultBatchA, resultBatchB]
+ */
+function compressBatches(batchA, batchB) {
+ var mapA = {};
+ var mapB = {};
+ makeMap(batchA || [], mapA);
+ makeMap(batchB || [], mapB, mapA);
+ return [mapToArray(mapA), mapToArray(mapB)];
+ function makeMap(sourceBatch, map, otherMap) {
+ for (var i = 0, len = sourceBatch.length; i < len; i++) {
+ var seriesId = convertOptionIdName(sourceBatch[i].seriesId, null);
+ if (seriesId == null) {
+ return;
+ }
+ var dataIndices = normalizeToArray(sourceBatch[i].dataIndex);
+ var otherDataIndices = otherMap && otherMap[seriesId];
+ for (var j = 0, lenj = dataIndices.length; j < lenj; j++) {
+ var dataIndex = dataIndices[j];
+ if (otherDataIndices && otherDataIndices[dataIndex]) {
+ otherDataIndices[dataIndex] = null;
+ } else {
+ (map[seriesId] || (map[seriesId] = {}))[dataIndex] = 1;
+ }
+ }
+ }
+ }
+ function mapToArray(map, isData) {
+ var result = [];
+ for (var i in map) {
+ if (map.hasOwnProperty(i) && map[i] != null) {
+ if (isData) {
+ result.push(+i);
+ } else {
+ var dataIndices = mapToArray(map[i], true);
+ dataIndices.length && result.push({
+ seriesId: i,
+ dataIndex: dataIndices
+ });
+ }
+ }
+ }
+ return result;
+ }
+}
+/**
+ * @param payload Contains dataIndex (means rawIndex) / dataIndexInside / name
+ * each of which can be Array or primary type.
+ * @return dataIndex If not found, return undefined/null.
+ */
+function queryDataIndex(data, payload) {
+ if (payload.dataIndexInside != null) {
+ return payload.dataIndexInside;
+ } else if (payload.dataIndex != null) {
+ return isArray(payload.dataIndex) ? map(payload.dataIndex, function (value) {
+ return data.indexOfRawIndex(value);
+ }) : data.indexOfRawIndex(payload.dataIndex);
+ } else if (payload.name != null) {
+ return isArray(payload.name) ? map(payload.name, function (value) {
+ return data.indexOfName(value);
+ }) : data.indexOfName(payload.name);
+ }
+}
+/**
+ * Enable property storage to any host object.
+ * Notice: Serialization is not supported.
+ *
+ * For example:
+ * let inner = zrUitl.makeInner();
+ *
+ * function some1(hostObj) {
+ * inner(hostObj).someProperty = 1212;
+ * ...
+ * }
+ * function some2() {
+ * let fields = inner(this);
+ * fields.someProperty1 = 1212;
+ * fields.someProperty2 = 'xx';
+ * ...
+ * }
+ *
+ * @return {Function}
+ */
+function makeInner() {
+ var key = '__ec_inner_' + innerUniqueIndex++;
+ return function (hostObj) {
+ return hostObj[key] || (hostObj[key] = {});
+ };
+}
+var innerUniqueIndex = getRandomIdBase();
+/**
+ * The same behavior as `component.getReferringComponents`.
+ */
+function parseFinder(ecModel, finderInput, opt) {
+ var _a = preParseFinder(finderInput, opt),
+ mainTypeSpecified = _a.mainTypeSpecified,
+ queryOptionMap = _a.queryOptionMap,
+ others = _a.others;
+ var result = others;
+ var defaultMainType = opt ? opt.defaultMainType : null;
+ if (!mainTypeSpecified && defaultMainType) {
+ queryOptionMap.set(defaultMainType, {});
+ }
+ queryOptionMap.each(function (queryOption, mainType) {
+ var queryResult = queryReferringComponents(ecModel, mainType, queryOption, {
+ useDefault: defaultMainType === mainType,
+ enableAll: opt && opt.enableAll != null ? opt.enableAll : true,
+ enableNone: opt && opt.enableNone != null ? opt.enableNone : true
+ });
+ result[mainType + 'Models'] = queryResult.models;
+ result[mainType + 'Model'] = queryResult.models[0];
+ });
+ return result;
+}
+function preParseFinder(finderInput, opt) {
+ var finder;
+ if (isString(finderInput)) {
+ var obj = {};
+ obj[finderInput + 'Index'] = 0;
+ finder = obj;
+ } else {
+ finder = finderInput;
+ }
+ var queryOptionMap = createHashMap();
+ var others = {};
+ var mainTypeSpecified = false;
+ each(finder, function (value, key) {
+ // Exclude 'dataIndex' and other illgal keys.
+ if (key === 'dataIndex' || key === 'dataIndexInside') {
+ others[key] = value;
+ return;
+ }
+ var parsedKey = key.match(/^(\w+)(Index|Id|Name)$/) || [];
+ var mainType = parsedKey[1];
+ var queryType = (parsedKey[2] || '').toLowerCase();
+ if (!mainType || !queryType || opt && opt.includeMainTypes && indexOf(opt.includeMainTypes, mainType) < 0) {
+ return;
+ }
+ mainTypeSpecified = mainTypeSpecified || !!mainType;
+ var queryOption = queryOptionMap.get(mainType) || queryOptionMap.set(mainType, {});
+ queryOption[queryType] = value;
+ });
+ return {
+ mainTypeSpecified: mainTypeSpecified,
+ queryOptionMap: queryOptionMap,
+ others: others
+ };
+}
+var SINGLE_REFERRING = {
+ useDefault: true,
+ enableAll: false,
+ enableNone: false
+};
+var MULTIPLE_REFERRING = {
+ useDefault: false,
+ enableAll: true,
+ enableNone: true
+};
+function queryReferringComponents(ecModel, mainType, userOption, opt) {
+ opt = opt || SINGLE_REFERRING;
+ var indexOption = userOption.index;
+ var idOption = userOption.id;
+ var nameOption = userOption.name;
+ var result = {
+ models: null,
+ specified: indexOption != null || idOption != null || nameOption != null
+ };
+ if (!result.specified) {
+ // Use the first as default if `useDefault`.
+ var firstCmpt = void 0;
+ result.models = opt.useDefault && (firstCmpt = ecModel.getComponent(mainType)) ? [firstCmpt] : [];
+ return result;
+ }
+ if (indexOption === 'none' || indexOption === false) {
+ assert(opt.enableNone, '`"none"` or `false` is not a valid value on index option.');
+ result.models = [];
+ return result;
+ }
+ // `queryComponents` will return all components if
+ // both all of index/id/name are null/undefined.
+ if (indexOption === 'all') {
+ assert(opt.enableAll, '`"all"` is not a valid value on index option.');
+ indexOption = idOption = nameOption = null;
+ }
+ result.models = ecModel.queryComponents({
+ mainType: mainType,
+ index: indexOption,
+ id: idOption,
+ name: nameOption
+ });
+ return result;
+}
+function setAttribute(dom, key, value) {
+ dom.setAttribute ? dom.setAttribute(key, value) : dom[key] = value;
+}
+function getAttribute(dom, key) {
+ return dom.getAttribute ? dom.getAttribute(key) : dom[key];
+}
+function getTooltipRenderMode(renderModeOption) {
+ if (renderModeOption === 'auto') {
+ // Using html when `document` exists, use richText otherwise
+ return env.domSupported ? 'html' : 'richText';
+ } else {
+ return renderModeOption || 'html';
+ }
+}
+/**
+ * Group a list by key.
+ */
+function groupData(array, getKey // return key
+) {
+ var buckets = createHashMap();
+ var keys = [];
+ each(array, function (item) {
+ var key = getKey(item);
+ (buckets.get(key) || (keys.push(key), buckets.set(key, []))).push(item);
+ });
+ return {
+ keys: keys,
+ buckets: buckets
+ };
+}
+/**
+ * Interpolate raw values of a series with percent
+ *
+ * @param data data
+ * @param labelModel label model of the text element
+ * @param sourceValue start value. May be null/undefined when init.
+ * @param targetValue end value
+ * @param percent 0~1 percentage; 0 uses start value while 1 uses end value
+ * @return interpolated values
+ * If `sourceValue` and `targetValue` are `number`, return `number`.
+ * If `sourceValue` and `targetValue` are `string`, return `string`.
+ * If `sourceValue` and `targetValue` are `(string | number)[]`, return `(string | number)[]`.
+ * Other cases do not supported.
+ */
+function interpolateRawValues(data, precision, sourceValue, targetValue, percent) {
+ var isAutoPrecision = precision == null || precision === 'auto';
+ if (targetValue == null) {
+ return targetValue;
+ }
+ if (isNumber(targetValue)) {
+ var value = interpolateNumber$1(sourceValue || 0, targetValue, percent);
+ return round(value, isAutoPrecision ? Math.max(getPrecision(sourceValue || 0), getPrecision(targetValue)) : precision);
+ } else if (isString(targetValue)) {
+ return percent < 1 ? sourceValue : targetValue;
+ } else {
+ var interpolated = [];
+ var leftArr = sourceValue;
+ var rightArr = targetValue;
+ var length_1 = Math.max(leftArr ? leftArr.length : 0, rightArr.length);
+ for (var i = 0; i < length_1; ++i) {
+ var info = data.getDimensionInfo(i);
+ // Don't interpolate ordinal dims
+ if (info && info.type === 'ordinal') {
+ // In init, there is no `sourceValue`, but should better not to get undefined result.
+ interpolated[i] = (percent < 1 && leftArr ? leftArr : rightArr)[i];
+ } else {
+ var leftVal = leftArr && leftArr[i] ? leftArr[i] : 0;
+ var rightVal = rightArr[i];
+ var value = interpolateNumber$1(leftVal, rightVal, percent);
+ interpolated[i] = round(value, isAutoPrecision ? Math.max(getPrecision(leftVal), getPrecision(rightVal)) : precision);
+ }
+ }
+ return interpolated;
+ }
+}
+
+var TYPE_DELIMITER = '.';
+var IS_CONTAINER = '___EC__COMPONENT__CONTAINER___';
+var IS_EXTENDED_CLASS = '___EC__EXTENDED_CLASS___';
+/**
+ * Notice, parseClassType('') should returns {main: '', sub: ''}
+ * @public
+ */
+function parseClassType(componentType) {
+ var ret = {
+ main: '',
+ sub: ''
+ };
+ if (componentType) {
+ var typeArr = componentType.split(TYPE_DELIMITER);
+ ret.main = typeArr[0] || '';
+ ret.sub = typeArr[1] || '';
+ }
+ return ret;
+}
+/**
+ * @public
+ */
+function checkClassType(componentType) {
+ assert(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType), 'componentType "' + componentType + '" illegal');
+}
+function isExtendedClass(clz) {
+ return !!(clz && clz[IS_EXTENDED_CLASS]);
+}
+/**
+ * Implements `ExtendableConstructor` for `rootClz`.
+ *
+ * @usage
+ * ```ts
+ * class Xxx {}
+ * type XxxConstructor = typeof Xxx & ExtendableConstructor
+ * enableClassExtend(Xxx as XxxConstructor);
+ * ```
+ */
+function enableClassExtend(rootClz, mandatoryMethods) {
+ rootClz.$constructor = rootClz; // FIXME: not necessary?
+ rootClz.extend = function (proto) {
+ if ("development" !== 'production') {
+ each(mandatoryMethods, function (method) {
+ if (!proto[method]) {
+ console.warn('Method `' + method + '` should be implemented' + (proto.type ? ' in ' + proto.type : '') + '.');
+ }
+ });
+ }
+ var superClass = this;
+ var ExtendedClass;
+ if (isESClass(superClass)) {
+ ExtendedClass = /** @class */function (_super) {
+ __extends(class_1, _super);
+ function class_1() {
+ return _super.apply(this, arguments) || this;
+ }
+ return class_1;
+ }(superClass);
+ } else {
+ // For backward compat, we both support ts class inheritance and this
+ // "extend" approach.
+ // The constructor should keep the same behavior as ts class inheritance:
+ // If this constructor/$constructor is not declared, auto invoke the super
+ // constructor.
+ // If this constructor/$constructor is declared, it is responsible for
+ // calling the super constructor.
+ ExtendedClass = function () {
+ (proto.$constructor || superClass).apply(this, arguments);
+ };
+ inherits(ExtendedClass, this);
+ }
+ extend(ExtendedClass.prototype, proto);
+ ExtendedClass[IS_EXTENDED_CLASS] = true;
+ ExtendedClass.extend = this.extend;
+ ExtendedClass.superCall = superCall;
+ ExtendedClass.superApply = superApply;
+ ExtendedClass.superClass = superClass;
+ return ExtendedClass;
+ };
+}
+function isESClass(fn) {
+ return isFunction(fn) && /^class\s/.test(Function.prototype.toString.call(fn));
+}
+/**
+ * A work around to both support ts extend and this extend mechanism.
+ * on sub-class.
+ * @usage
+ * ```ts
+ * class Component { ... }
+ * classUtil.enableClassExtend(Component);
+ * classUtil.enableClassManagement(Component, {registerWhenExtend: true});
+ *
+ * class Series extends Component { ... }
+ * // Without calling `markExtend`, `registerWhenExtend` will not work.
+ * Component.markExtend(Series);
+ * ```
+ */
+function mountExtend(SubClz, SupperClz) {
+ SubClz.extend = SupperClz.extend;
+}
+// A random offset.
+var classBase = Math.round(Math.random() * 10);
+/**
+ * Implements `CheckableConstructor` for `target`.
+ * Can not use instanceof, consider different scope by
+ * cross domain or es module import in ec extensions.
+ * Mount a method "isInstance()" to Clz.
+ *
+ * @usage
+ * ```ts
+ * class Xxx {}
+ * type XxxConstructor = typeof Xxx & CheckableConstructor;
+ * enableClassCheck(Xxx as XxxConstructor)
+ * ```
+ */
+function enableClassCheck(target) {
+ var classAttr = ['__\0is_clz', classBase++].join('_');
+ target.prototype[classAttr] = true;
+ if ("development" !== 'production') {
+ assert(!target.isInstance, 'The method "is" can not be defined.');
+ }
+ target.isInstance = function (obj) {
+ return !!(obj && obj[classAttr]);
+ };
+}
+// superCall should have class info, which can not be fetched from 'this'.
+// Consider this case:
+// class A has method f,
+// class B inherits class A, overrides method f, f call superApply('f'),
+// class C inherits class B, does not override method f,
+// then when method of class C is called, dead loop occurred.
+function superCall(context, methodName) {
+ var args = [];
+ for (var _i = 2; _i < arguments.length; _i++) {
+ args[_i - 2] = arguments[_i];
+ }
+ return this.superClass.prototype[methodName].apply(context, args);
+}
+function superApply(context, methodName, args) {
+ return this.superClass.prototype[methodName].apply(context, args);
+}
+/**
+ * Implements `ClassManager` for `target`
+ *
+ * @usage
+ * ```ts
+ * class Xxx {}
+ * type XxxConstructor = typeof Xxx & ClassManager
+ * enableClassManagement(Xxx as XxxConstructor);
+ * ```
+ */
+function enableClassManagement(target) {
+ /**
+ * Component model classes
+ * key: componentType,
+ * value:
+ * componentClass, when componentType is 'a'
+ * or Object.<subKey, componentClass>, when componentType is 'a.b'
+ */
+ var storage = {};
+ target.registerClass = function (clz) {
+ // `type` should not be a "instance member".
+ // If using TS class, should better declared as `static type = 'series.pie'`.
+ // otherwise users have to mount `type` on prototype manually.
+ // For backward compat and enable instance visit type via `this.type`,
+ // we still support fetch `type` from prototype.
+ var componentFullType = clz.type || clz.prototype.type;
+ if (componentFullType) {
+ checkClassType(componentFullType);
+ // If only static type declared, we assign it to prototype mandatorily.
+ clz.prototype.type = componentFullType;
+ var componentTypeInfo = parseClassType(componentFullType);
+ if (!componentTypeInfo.sub) {
+ if ("development" !== 'production') {
+ if (storage[componentTypeInfo.main]) {
+ console.warn(componentTypeInfo.main + ' exists.');
+ }
+ }
+ storage[componentTypeInfo.main] = clz;
+ } else if (componentTypeInfo.sub !== IS_CONTAINER) {
+ var container = makeContainer(componentTypeInfo);
+ container[componentTypeInfo.sub] = clz;
+ }
+ }
+ return clz;
+ };
+ target.getClass = function (mainType, subType, throwWhenNotFound) {
+ var clz = storage[mainType];
+ if (clz && clz[IS_CONTAINER]) {
+ clz = subType ? clz[subType] : null;
+ }
+ if (throwWhenNotFound && !clz) {
+ throw new Error(!subType ? mainType + '.' + 'type should be specified.' : 'Component ' + mainType + '.' + (subType || '') + ' is used but not imported.');
+ }
+ return clz;
+ };
+ target.getClassesByMainType = function (componentType) {
+ var componentTypeInfo = parseClassType(componentType);
+ var result = [];
+ var obj = storage[componentTypeInfo.main];
+ if (obj && obj[IS_CONTAINER]) {
+ each(obj, function (o, type) {
+ type !== IS_CONTAINER && result.push(o);
+ });
+ } else {
+ result.push(obj);
+ }
+ return result;
+ };
+ target.hasClass = function (componentType) {
+ // Just consider componentType.main.
+ var componentTypeInfo = parseClassType(componentType);
+ return !!storage[componentTypeInfo.main];
+ };
+ /**
+ * @return Like ['aa', 'bb'], but can not be ['aa.xx']
+ */
+ target.getAllClassMainTypes = function () {
+ var types = [];
+ each(storage, function (obj, type) {
+ types.push(type);
+ });
+ return types;
+ };
+ /**
+ * If a main type is container and has sub types
+ */
+ target.hasSubTypes = function (componentType) {
+ var componentTypeInfo = parseClassType(componentType);
+ var obj = storage[componentTypeInfo.main];
+ return obj && obj[IS_CONTAINER];
+ };
+ function makeContainer(componentTypeInfo) {
+ var container = storage[componentTypeInfo.main];
+ if (!container || !container[IS_CONTAINER]) {
+ container = storage[componentTypeInfo.main] = {};
+ container[IS_CONTAINER] = true;
+ }
+ return container;
+ }
+}
+// /**
+// * @param {string|Array.<string>} properties
+// */
+// export function setReadOnly(obj, properties) {
+// FIXME It seems broken in IE8 simulation of IE11
+// if (!zrUtil.isArray(properties)) {
+// properties = properties != null ? [properties] : [];
+// }
+// zrUtil.each(properties, function (prop) {
+// let value = obj[prop];
+// Object.defineProperty
+// && Object.defineProperty(obj, prop, {
+// value: value, writable: false
+// });
+// zrUtil.isArray(obj[prop])
+// && Object.freeze
+// && Object.freeze(obj[prop]);
+// });
+// }
+
+function makeStyleMapper(properties, ignoreParent) {
+ // Normalize
+ for (var i = 0; i < properties.length; i++) {
+ if (!properties[i][1]) {
+ properties[i][1] = properties[i][0];
+ }
+ }
+ ignoreParent = ignoreParent || false;
+ return function (model, excludes, includes) {
+ var style = {};
+ for (var i = 0; i < properties.length; i++) {
+ var propName = properties[i][1];
+ if (excludes && indexOf(excludes, propName) >= 0 || includes && indexOf(includes, propName) < 0) {
+ continue;
+ }
+ var val = model.getShallow(propName, ignoreParent);
+ if (val != null) {
+ style[properties[i][0]] = val;
+ }
+ }
+ // TODO Text or image?
+ return style;
+ };
+}
+
+var AREA_STYLE_KEY_MAP = [['fill', 'color'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['opacity'], ['shadowColor']
+// Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+// So do not transfer decal directly.
+];
+
+var getAreaStyle = makeStyleMapper(AREA_STYLE_KEY_MAP);
+var AreaStyleMixin = /** @class */function () {
+ function AreaStyleMixin() {}
+ AreaStyleMixin.prototype.getAreaStyle = function (excludes, includes) {
+ return getAreaStyle(this, excludes, includes);
+ };
+ return AreaStyleMixin;
+}();
+
+var globalImageCache = new LRU(50);
+function findExistImage(newImageOrSrc) {
+ if (typeof newImageOrSrc === 'string') {
+ var cachedImgObj = globalImageCache.get(newImageOrSrc);
+ return cachedImgObj && cachedImgObj.image;
+ }
+ else {
+ return newImageOrSrc;
+ }
+}
+function createOrUpdateImage(newImageOrSrc, image, hostEl, onload, cbPayload) {
+ if (!newImageOrSrc) {
+ return image;
+ }
+ else if (typeof newImageOrSrc === 'string') {
+ if ((image && image.__zrImageSrc === newImageOrSrc) || !hostEl) {
+ return image;
+ }
+ var cachedImgObj = globalImageCache.get(newImageOrSrc);
+ var pendingWrap = { hostEl: hostEl, cb: onload, cbPayload: cbPayload };
+ if (cachedImgObj) {
+ image = cachedImgObj.image;
+ !isImageReady(image) && cachedImgObj.pending.push(pendingWrap);
+ }
+ else {
+ image = platformApi.loadImage(newImageOrSrc, imageOnLoad, imageOnLoad);
+ image.__zrImageSrc = newImageOrSrc;
+ globalImageCache.put(newImageOrSrc, image.__cachedImgObj = {
+ image: image,
+ pending: [pendingWrap]
+ });
+ }
+ return image;
+ }
+ else {
+ return newImageOrSrc;
+ }
+}
+function imageOnLoad() {
+ var cachedImgObj = this.__cachedImgObj;
+ this.onload = this.onerror = this.__cachedImgObj = null;
+ for (var i = 0; i < cachedImgObj.pending.length; i++) {
+ var pendingWrap = cachedImgObj.pending[i];
+ var cb = pendingWrap.cb;
+ cb && cb(this, pendingWrap.cbPayload);
+ pendingWrap.hostEl.dirty();
+ }
+ cachedImgObj.pending.length = 0;
+}
+function isImageReady(image) {
+ return image && image.width && image.height;
+}
+
+var STYLE_REG = /\{([a-zA-Z0-9_]+)\|([^}]*)\}/g;
+function truncateText(text, containerWidth, font, ellipsis, options) {
+ if (!containerWidth) {
+ return '';
+ }
+ var textLines = (text + '').split('\n');
+ options = prepareTruncateOptions(containerWidth, font, ellipsis, options);
+ for (var i = 0, len = textLines.length; i < len; i++) {
+ textLines[i] = truncateSingleLine(textLines[i], options);
+ }
+ return textLines.join('\n');
+}
+function prepareTruncateOptions(containerWidth, font, ellipsis, options) {
+ options = options || {};
+ var preparedOpts = extend({}, options);
+ preparedOpts.font = font;
+ ellipsis = retrieve2(ellipsis, '...');
+ preparedOpts.maxIterations = retrieve2(options.maxIterations, 2);
+ var minChar = preparedOpts.minChar = retrieve2(options.minChar, 0);
+ preparedOpts.cnCharWidth = getWidth('国', font);
+ var ascCharWidth = preparedOpts.ascCharWidth = getWidth('a', font);
+ preparedOpts.placeholder = retrieve2(options.placeholder, '');
+ var contentWidth = containerWidth = Math.max(0, containerWidth - 1);
+ for (var i = 0; i < minChar && contentWidth >= ascCharWidth; i++) {
+ contentWidth -= ascCharWidth;
+ }
+ var ellipsisWidth = getWidth(ellipsis, font);
+ if (ellipsisWidth > contentWidth) {
+ ellipsis = '';
+ ellipsisWidth = 0;
+ }
+ contentWidth = containerWidth - ellipsisWidth;
+ preparedOpts.ellipsis = ellipsis;
+ preparedOpts.ellipsisWidth = ellipsisWidth;
+ preparedOpts.contentWidth = contentWidth;
+ preparedOpts.containerWidth = containerWidth;
+ return preparedOpts;
+}
+function truncateSingleLine(textLine, options) {
+ var containerWidth = options.containerWidth;
+ var font = options.font;
+ var contentWidth = options.contentWidth;
+ if (!containerWidth) {
+ return '';
+ }
+ var lineWidth = getWidth(textLine, font);
+ if (lineWidth <= containerWidth) {
+ return textLine;
+ }
+ for (var j = 0;; j++) {
+ if (lineWidth <= contentWidth || j >= options.maxIterations) {
+ textLine += options.ellipsis;
+ break;
+ }
+ var subLength = j === 0
+ ? estimateLength(textLine, contentWidth, options.ascCharWidth, options.cnCharWidth)
+ : lineWidth > 0
+ ? Math.floor(textLine.length * contentWidth / lineWidth)
+ : 0;
+ textLine = textLine.substr(0, subLength);
+ lineWidth = getWidth(textLine, font);
+ }
+ if (textLine === '') {
+ textLine = options.placeholder;
+ }
+ return textLine;
+}
+function estimateLength(text, contentWidth, ascCharWidth, cnCharWidth) {
+ var width = 0;
+ var i = 0;
+ for (var len = text.length; i < len && width < contentWidth; i++) {
+ var charCode = text.charCodeAt(i);
+ width += (0 <= charCode && charCode <= 127) ? ascCharWidth : cnCharWidth;
+ }
+ return i;
+}
+function parsePlainText(text, style) {
+ text != null && (text += '');
+ var overflow = style.overflow;
+ var padding = style.padding;
+ var font = style.font;
+ var truncate = overflow === 'truncate';
+ var calculatedLineHeight = getLineHeight(font);
+ var lineHeight = retrieve2(style.lineHeight, calculatedLineHeight);
+ var bgColorDrawn = !!(style.backgroundColor);
+ var truncateLineOverflow = style.lineOverflow === 'truncate';
+ var width = style.width;
+ var lines;
+ if (width != null && (overflow === 'break' || overflow === 'breakAll')) {
+ lines = text ? wrapText(text, style.font, width, overflow === 'breakAll', 0).lines : [];
+ }
+ else {
+ lines = text ? text.split('\n') : [];
+ }
+ var contentHeight = lines.length * lineHeight;
+ var height = retrieve2(style.height, contentHeight);
+ if (contentHeight > height && truncateLineOverflow) {
+ var lineCount = Math.floor(height / lineHeight);
+ lines = lines.slice(0, lineCount);
+ }
+ if (text && truncate && width != null) {
+ var options = prepareTruncateOptions(width, font, style.ellipsis, {
+ minChar: style.truncateMinChar,
+ placeholder: style.placeholder
+ });
+ for (var i = 0; i < lines.length; i++) {
+ lines[i] = truncateSingleLine(lines[i], options);
+ }
+ }
+ var outerHeight = height;
+ var contentWidth = 0;
+ for (var i = 0; i < lines.length; i++) {
+ contentWidth = Math.max(getWidth(lines[i], font), contentWidth);
+ }
+ if (width == null) {
+ width = contentWidth;
+ }
+ var outerWidth = contentWidth;
+ if (padding) {
+ outerHeight += padding[0] + padding[2];
+ outerWidth += padding[1] + padding[3];
+ width += padding[1] + padding[3];
+ }
+ if (bgColorDrawn) {
+ outerWidth = width;
+ }
+ return {
+ lines: lines,
+ height: height,
+ outerWidth: outerWidth,
+ outerHeight: outerHeight,
+ lineHeight: lineHeight,
+ calculatedLineHeight: calculatedLineHeight,
+ contentWidth: contentWidth,
+ contentHeight: contentHeight,
+ width: width
+ };
+}
+var RichTextToken = (function () {
+ function RichTextToken() {
+ }
+ return RichTextToken;
+}());
+var RichTextLine = (function () {
+ function RichTextLine(tokens) {
+ this.tokens = [];
+ if (tokens) {
+ this.tokens = tokens;
+ }
+ }
+ return RichTextLine;
+}());
+var RichTextContentBlock = (function () {
+ function RichTextContentBlock() {
+ this.width = 0;
+ this.height = 0;
+ this.contentWidth = 0;
+ this.contentHeight = 0;
+ this.outerWidth = 0;
+ this.outerHeight = 0;
+ this.lines = [];
+ }
+ return RichTextContentBlock;
+}());
+function parseRichText(text, style) {
+ var contentBlock = new RichTextContentBlock();
+ text != null && (text += '');
+ if (!text) {
+ return contentBlock;
+ }
+ var topWidth = style.width;
+ var topHeight = style.height;
+ var overflow = style.overflow;
+ var wrapInfo = (overflow === 'break' || overflow === 'breakAll') && topWidth != null
+ ? { width: topWidth, accumWidth: 0, breakAll: overflow === 'breakAll' }
+ : null;
+ var lastIndex = STYLE_REG.lastIndex = 0;
+ var result;
+ while ((result = STYLE_REG.exec(text)) != null) {
+ var matchedIndex = result.index;
+ if (matchedIndex > lastIndex) {
+ pushTokens(contentBlock, text.substring(lastIndex, matchedIndex), style, wrapInfo);
+ }
+ pushTokens(contentBlock, result[2], style, wrapInfo, result[1]);
+ lastIndex = STYLE_REG.lastIndex;
+ }
+ if (lastIndex < text.length) {
+ pushTokens(contentBlock, text.substring(lastIndex, text.length), style, wrapInfo);
+ }
+ var pendingList = [];
+ var calculatedHeight = 0;
+ var calculatedWidth = 0;
+ var stlPadding = style.padding;
+ var truncate = overflow === 'truncate';
+ var truncateLine = style.lineOverflow === 'truncate';
+ function finishLine(line, lineWidth, lineHeight) {
+ line.width = lineWidth;
+ line.lineHeight = lineHeight;
+ calculatedHeight += lineHeight;
+ calculatedWidth = Math.max(calculatedWidth, lineWidth);
+ }
+ outer: for (var i = 0; i < contentBlock.lines.length; i++) {
+ var line = contentBlock.lines[i];
+ var lineHeight = 0;
+ var lineWidth = 0;
+ for (var j = 0; j < line.tokens.length; j++) {
+ var token = line.tokens[j];
+ var tokenStyle = token.styleName && style.rich[token.styleName] || {};
+ var textPadding = token.textPadding = tokenStyle.padding;
+ var paddingH = textPadding ? textPadding[1] + textPadding[3] : 0;
+ var font = token.font = tokenStyle.font || style.font;
+ token.contentHeight = getLineHeight(font);
+ var tokenHeight = retrieve2(tokenStyle.height, token.contentHeight);
+ token.innerHeight = tokenHeight;
+ textPadding && (tokenHeight += textPadding[0] + textPadding[2]);
+ token.height = tokenHeight;
+ token.lineHeight = retrieve3(tokenStyle.lineHeight, style.lineHeight, tokenHeight);
+ token.align = tokenStyle && tokenStyle.align || style.align;
+ token.verticalAlign = tokenStyle && tokenStyle.verticalAlign || 'middle';
+ if (truncateLine && topHeight != null && calculatedHeight + token.lineHeight > topHeight) {
+ if (j > 0) {
+ line.tokens = line.tokens.slice(0, j);
+ finishLine(line, lineWidth, lineHeight);
+ contentBlock.lines = contentBlock.lines.slice(0, i + 1);
+ }
+ else {
+ contentBlock.lines = contentBlock.lines.slice(0, i);
+ }
+ break outer;
+ }
+ var styleTokenWidth = tokenStyle.width;
+ var tokenWidthNotSpecified = styleTokenWidth == null || styleTokenWidth === 'auto';
+ if (typeof styleTokenWidth === 'string' && styleTokenWidth.charAt(styleTokenWidth.length - 1) === '%') {
+ token.percentWidth = styleTokenWidth;
+ pendingList.push(token);
+ token.contentWidth = getWidth(token.text, font);
+ }
+ else {
+ if (tokenWidthNotSpecified) {
+ var textBackgroundColor = tokenStyle.backgroundColor;
+ var bgImg = textBackgroundColor && textBackgroundColor.image;
+ if (bgImg) {
+ bgImg = findExistImage(bgImg);
+ if (isImageReady(bgImg)) {
+ token.width = Math.max(token.width, bgImg.width * tokenHeight / bgImg.height);
+ }
+ }
+ }
+ var remainTruncWidth = truncate && topWidth != null
+ ? topWidth - lineWidth : null;
+ if (remainTruncWidth != null && remainTruncWidth < token.width) {
+ if (!tokenWidthNotSpecified || remainTruncWidth < paddingH) {
+ token.text = '';
+ token.width = token.contentWidth = 0;
+ }
+ else {
+ token.text = truncateText(token.text, remainTruncWidth - paddingH, font, style.ellipsis, { minChar: style.truncateMinChar });
+ token.width = token.contentWidth = getWidth(token.text, font);
+ }
+ }
+ else {
+ token.contentWidth = getWidth(token.text, font);
+ }
+ }
+ token.width += paddingH;
+ lineWidth += token.width;
+ tokenStyle && (lineHeight = Math.max(lineHeight, token.lineHeight));
+ }
+ finishLine(line, lineWidth, lineHeight);
+ }
+ contentBlock.outerWidth = contentBlock.width = retrieve2(topWidth, calculatedWidth);
+ contentBlock.outerHeight = contentBlock.height = retrieve2(topHeight, calculatedHeight);
+ contentBlock.contentHeight = calculatedHeight;
+ contentBlock.contentWidth = calculatedWidth;
+ if (stlPadding) {
+ contentBlock.outerWidth += stlPadding[1] + stlPadding[3];
+ contentBlock.outerHeight += stlPadding[0] + stlPadding[2];
+ }
+ for (var i = 0; i < pendingList.length; i++) {
+ var token = pendingList[i];
+ var percentWidth = token.percentWidth;
+ token.width = parseInt(percentWidth, 10) / 100 * contentBlock.width;
+ }
+ return contentBlock;
+}
+function pushTokens(block, str, style, wrapInfo, styleName) {
+ var isEmptyStr = str === '';
+ var tokenStyle = styleName && style.rich[styleName] || {};
+ var lines = block.lines;
+ var font = tokenStyle.font || style.font;
+ var newLine = false;
+ var strLines;
+ var linesWidths;
+ if (wrapInfo) {
+ var tokenPadding = tokenStyle.padding;
+ var tokenPaddingH = tokenPadding ? tokenPadding[1] + tokenPadding[3] : 0;
+ if (tokenStyle.width != null && tokenStyle.width !== 'auto') {
+ var outerWidth_1 = parsePercent(tokenStyle.width, wrapInfo.width) + tokenPaddingH;
+ if (lines.length > 0) {
+ if (outerWidth_1 + wrapInfo.accumWidth > wrapInfo.width) {
+ strLines = str.split('\n');
+ newLine = true;
+ }
+ }
+ wrapInfo.accumWidth = outerWidth_1;
+ }
+ else {
+ var res = wrapText(str, font, wrapInfo.width, wrapInfo.breakAll, wrapInfo.accumWidth);
+ wrapInfo.accumWidth = res.accumWidth + tokenPaddingH;
+ linesWidths = res.linesWidths;
+ strLines = res.lines;
+ }
+ }
+ else {
+ strLines = str.split('\n');
+ }
+ for (var i = 0; i < strLines.length; i++) {
+ var text = strLines[i];
+ var token = new RichTextToken();
+ token.styleName = styleName;
+ token.text = text;
+ token.isLineHolder = !text && !isEmptyStr;
+ if (typeof tokenStyle.width === 'number') {
+ token.width = tokenStyle.width;
+ }
+ else {
+ token.width = linesWidths
+ ? linesWidths[i]
+ : getWidth(text, font);
+ }
+ if (!i && !newLine) {
+ var tokens = (lines[lines.length - 1] || (lines[0] = new RichTextLine())).tokens;
+ var tokensLen = tokens.length;
+ (tokensLen === 1 && tokens[0].isLineHolder)
+ ? (tokens[0] = token)
+ : ((text || !tokensLen || isEmptyStr) && tokens.push(token));
+ }
+ else {
+ lines.push(new RichTextLine([token]));
+ }
+ }
+}
+function isAlphabeticLetter(ch) {
+ var code = ch.charCodeAt(0);
+ return code >= 0x20 && code <= 0x24F
+ || code >= 0x370 && code <= 0x10FF
+ || code >= 0x1200 && code <= 0x13FF
+ || code >= 0x1E00 && code <= 0x206F;
+}
+var breakCharMap = reduce(',&?/;] '.split(''), function (obj, ch) {
+ obj[ch] = true;
+ return obj;
+}, {});
+function isWordBreakChar(ch) {
+ if (isAlphabeticLetter(ch)) {
+ if (breakCharMap[ch]) {
+ return true;
+ }
+ return false;
+ }
+ return true;
+}
+function wrapText(text, font, lineWidth, isBreakAll, lastAccumWidth) {
+ var lines = [];
+ var linesWidths = [];
+ var line = '';
+ var currentWord = '';
+ var currentWordWidth = 0;
+ var accumWidth = 0;
+ for (var i = 0; i < text.length; i++) {
+ var ch = text.charAt(i);
+ if (ch === '\n') {
+ if (currentWord) {
+ line += currentWord;
+ accumWidth += currentWordWidth;
+ }
+ lines.push(line);
+ linesWidths.push(accumWidth);
+ line = '';
+ currentWord = '';
+ currentWordWidth = 0;
+ accumWidth = 0;
+ continue;
+ }
+ var chWidth = getWidth(ch, font);
+ var inWord = isBreakAll ? false : !isWordBreakChar(ch);
+ if (!lines.length
+ ? lastAccumWidth + accumWidth + chWidth > lineWidth
+ : accumWidth + chWidth > lineWidth) {
+ if (!accumWidth) {
+ if (inWord) {
+ lines.push(currentWord);
+ linesWidths.push(currentWordWidth);
+ currentWord = ch;
+ currentWordWidth = chWidth;
+ }
+ else {
+ lines.push(ch);
+ linesWidths.push(chWidth);
+ }
+ }
+ else if (line || currentWord) {
+ if (inWord) {
+ if (!line) {
+ line = currentWord;
+ currentWord = '';
+ currentWordWidth = 0;
+ accumWidth = currentWordWidth;
+ }
+ lines.push(line);
+ linesWidths.push(accumWidth - currentWordWidth);
+ currentWord += ch;
+ currentWordWidth += chWidth;
+ line = '';
+ accumWidth = currentWordWidth;
+ }
+ else {
+ if (currentWord) {
+ line += currentWord;
+ currentWord = '';
+ currentWordWidth = 0;
+ }
+ lines.push(line);
+ linesWidths.push(accumWidth);
+ line = ch;
+ accumWidth = chWidth;
+ }
+ }
+ continue;
+ }
+ accumWidth += chWidth;
+ if (inWord) {
+ currentWord += ch;
+ currentWordWidth += chWidth;
+ }
+ else {
+ if (currentWord) {
+ line += currentWord;
+ currentWord = '';
+ currentWordWidth = 0;
+ }
+ line += ch;
+ }
+ }
+ if (!lines.length && !line) {
+ line = text;
+ currentWord = '';
+ currentWordWidth = 0;
+ }
+ if (currentWord) {
+ line += currentWord;
+ }
+ if (line) {
+ lines.push(line);
+ linesWidths.push(accumWidth);
+ }
+ if (lines.length === 1) {
+ accumWidth += lastAccumWidth;
+ }
+ return {
+ accumWidth: accumWidth,
+ lines: lines,
+ linesWidths: linesWidths
+ };
+}
+
+var STYLE_MAGIC_KEY = '__zr_style_' + Math.round((Math.random() * 10));
+var DEFAULT_COMMON_STYLE = {
+ shadowBlur: 0,
+ shadowOffsetX: 0,
+ shadowOffsetY: 0,
+ shadowColor: '#000',
+ opacity: 1,
+ blend: 'source-over'
+};
+var DEFAULT_COMMON_ANIMATION_PROPS = {
+ style: {
+ shadowBlur: true,
+ shadowOffsetX: true,
+ shadowOffsetY: true,
+ shadowColor: true,
+ opacity: true
+ }
+};
+DEFAULT_COMMON_STYLE[STYLE_MAGIC_KEY] = true;
+var PRIMARY_STATES_KEYS$1 = ['z', 'z2', 'invisible'];
+var PRIMARY_STATES_KEYS_IN_HOVER_LAYER = ['invisible'];
+var Displayable = (function (_super) {
+ __extends(Displayable, _super);
+ function Displayable(props) {
+ return _super.call(this, props) || this;
+ }
+ Displayable.prototype._init = function (props) {
+ var keysArr = keys(props);
+ for (var i = 0; i < keysArr.length; i++) {
+ var key = keysArr[i];
+ if (key === 'style') {
+ this.useStyle(props[key]);
+ }
+ else {
+ _super.prototype.attrKV.call(this, key, props[key]);
+ }
+ }
+ if (!this.style) {
+ this.useStyle({});
+ }
+ };
+ Displayable.prototype.beforeBrush = function () { };
+ Displayable.prototype.afterBrush = function () { };
+ Displayable.prototype.innerBeforeBrush = function () { };
+ Displayable.prototype.innerAfterBrush = function () { };
+ Displayable.prototype.shouldBePainted = function (viewWidth, viewHeight, considerClipPath, considerAncestors) {
+ var m = this.transform;
+ if (this.ignore
+ || this.invisible
+ || this.style.opacity === 0
+ || (this.culling
+ && isDisplayableCulled(this, viewWidth, viewHeight))
+ || (m && !m[0] && !m[3])) {
+ return false;
+ }
+ if (considerClipPath && this.__clipPaths) {
+ for (var i = 0; i < this.__clipPaths.length; ++i) {
+ if (this.__clipPaths[i].isZeroArea()) {
+ return false;
+ }
+ }
+ }
+ if (considerAncestors && this.parent) {
+ var parent_1 = this.parent;
+ while (parent_1) {
+ if (parent_1.ignore) {
+ return false;
+ }
+ parent_1 = parent_1.parent;
+ }
+ }
+ return true;
+ };
+ Displayable.prototype.contain = function (x, y) {
+ return this.rectContain(x, y);
+ };
+ Displayable.prototype.traverse = function (cb, context) {
+ cb.call(context, this);
+ };
+ Displayable.prototype.rectContain = function (x, y) {
+ var coord = this.transformCoordToLocal(x, y);
+ var rect = this.getBoundingRect();
+ return rect.contain(coord[0], coord[1]);
+ };
+ Displayable.prototype.getPaintRect = function () {
+ var rect = this._paintRect;
+ if (!this._paintRect || this.__dirty) {
+ var transform = this.transform;
+ var elRect = this.getBoundingRect();
+ var style = this.style;
+ var shadowSize = style.shadowBlur || 0;
+ var shadowOffsetX = style.shadowOffsetX || 0;
+ var shadowOffsetY = style.shadowOffsetY || 0;
+ rect = this._paintRect || (this._paintRect = new BoundingRect(0, 0, 0, 0));
+ if (transform) {
+ BoundingRect.applyTransform(rect, elRect, transform);
+ }
+ else {
+ rect.copy(elRect);
+ }
+ if (shadowSize || shadowOffsetX || shadowOffsetY) {
+ rect.width += shadowSize * 2 + Math.abs(shadowOffsetX);
+ rect.height += shadowSize * 2 + Math.abs(shadowOffsetY);
+ rect.x = Math.min(rect.x, rect.x + shadowOffsetX - shadowSize);
+ rect.y = Math.min(rect.y, rect.y + shadowOffsetY - shadowSize);
+ }
+ var tolerance = this.dirtyRectTolerance;
+ if (!rect.isZero()) {
+ rect.x = Math.floor(rect.x - tolerance);
+ rect.y = Math.floor(rect.y - tolerance);
+ rect.width = Math.ceil(rect.width + 1 + tolerance * 2);
+ rect.height = Math.ceil(rect.height + 1 + tolerance * 2);
+ }
+ }
+ return rect;
+ };
+ Displayable.prototype.setPrevPaintRect = function (paintRect) {
+ if (paintRect) {
+ this._prevPaintRect = this._prevPaintRect || new BoundingRect(0, 0, 0, 0);
+ this._prevPaintRect.copy(paintRect);
+ }
+ else {
+ this._prevPaintRect = null;
+ }
+ };
+ Displayable.prototype.getPrevPaintRect = function () {
+ return this._prevPaintRect;
+ };
+ Displayable.prototype.animateStyle = function (loop) {
+ return this.animate('style', loop);
+ };
+ Displayable.prototype.updateDuringAnimation = function (targetKey) {
+ if (targetKey === 'style') {
+ this.dirtyStyle();
+ }
+ else {
+ this.markRedraw();
+ }
+ };
+ Displayable.prototype.attrKV = function (key, value) {
+ if (key !== 'style') {
+ _super.prototype.attrKV.call(this, key, value);
+ }
+ else {
+ if (!this.style) {
+ this.useStyle(value);
+ }
+ else {
+ this.setStyle(value);
+ }
+ }
+ };
+ Displayable.prototype.setStyle = function (keyOrObj, value) {
+ if (typeof keyOrObj === 'string') {
+ this.style[keyOrObj] = value;
+ }
+ else {
+ extend(this.style, keyOrObj);
+ }
+ this.dirtyStyle();
+ return this;
+ };
+ Displayable.prototype.dirtyStyle = function (notRedraw) {
+ if (!notRedraw) {
+ this.markRedraw();
+ }
+ this.__dirty |= STYLE_CHANGED_BIT;
+ if (this._rect) {
+ this._rect = null;
+ }
+ };
+ Displayable.prototype.dirty = function () {
+ this.dirtyStyle();
+ };
+ Displayable.prototype.styleChanged = function () {
+ return !!(this.__dirty & STYLE_CHANGED_BIT);
+ };
+ Displayable.prototype.styleUpdated = function () {
+ this.__dirty &= ~STYLE_CHANGED_BIT;
+ };
+ Displayable.prototype.createStyle = function (obj) {
+ return createObject(DEFAULT_COMMON_STYLE, obj);
+ };
+ Displayable.prototype.useStyle = function (obj) {
+ if (!obj[STYLE_MAGIC_KEY]) {
+ obj = this.createStyle(obj);
+ }
+ if (this.__inHover) {
+ this.__hoverStyle = obj;
+ }
+ else {
+ this.style = obj;
+ }
+ this.dirtyStyle();
+ };
+ Displayable.prototype.isStyleObject = function (obj) {
+ return obj[STYLE_MAGIC_KEY];
+ };
+ Displayable.prototype._innerSaveToNormal = function (toState) {
+ _super.prototype._innerSaveToNormal.call(this, toState);
+ var normalState = this._normalState;
+ if (toState.style && !normalState.style) {
+ normalState.style = this._mergeStyle(this.createStyle(), this.style);
+ }
+ this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS$1);
+ };
+ Displayable.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
+ _super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg);
+ var needsRestoreToNormal = !(state && keepCurrentStates);
+ var targetStyle;
+ if (state && state.style) {
+ if (transition) {
+ if (keepCurrentStates) {
+ targetStyle = state.style;
+ }
+ else {
+ targetStyle = this._mergeStyle(this.createStyle(), normalState.style);
+ this._mergeStyle(targetStyle, state.style);
+ }
+ }
+ else {
+ targetStyle = this._mergeStyle(this.createStyle(), keepCurrentStates ? this.style : normalState.style);
+ this._mergeStyle(targetStyle, state.style);
+ }
+ }
+ else if (needsRestoreToNormal) {
+ targetStyle = normalState.style;
+ }
+ if (targetStyle) {
+ if (transition) {
+ var sourceStyle = this.style;
+ this.style = this.createStyle(needsRestoreToNormal ? {} : sourceStyle);
+ if (needsRestoreToNormal) {
+ var changedKeys = keys(sourceStyle);
+ for (var i = 0; i < changedKeys.length; i++) {
+ var key = changedKeys[i];
+ if (key in targetStyle) {
+ targetStyle[key] = targetStyle[key];
+ this.style[key] = sourceStyle[key];
+ }
+ }
+ }
+ var targetKeys = keys(targetStyle);
+ for (var i = 0; i < targetKeys.length; i++) {
+ var key = targetKeys[i];
+ this.style[key] = this.style[key];
+ }
+ this._transitionState(stateName, {
+ style: targetStyle
+ }, animationCfg, this.getAnimationStyleProps());
+ }
+ else {
+ this.useStyle(targetStyle);
+ }
+ }
+ var statesKeys = this.__inHover ? PRIMARY_STATES_KEYS_IN_HOVER_LAYER : PRIMARY_STATES_KEYS$1;
+ for (var i = 0; i < statesKeys.length; i++) {
+ var key = statesKeys[i];
+ if (state && state[key] != null) {
+ this[key] = state[key];
+ }
+ else if (needsRestoreToNormal) {
+ if (normalState[key] != null) {
+ this[key] = normalState[key];
+ }
+ }
+ }
+ };
+ Displayable.prototype._mergeStates = function (states) {
+ var mergedState = _super.prototype._mergeStates.call(this, states);
+ var mergedStyle;
+ for (var i = 0; i < states.length; i++) {
+ var state = states[i];
+ if (state.style) {
+ mergedStyle = mergedStyle || {};
+ this._mergeStyle(mergedStyle, state.style);
+ }
+ }
+ if (mergedStyle) {
+ mergedState.style = mergedStyle;
+ }
+ return mergedState;
+ };
+ Displayable.prototype._mergeStyle = function (targetStyle, sourceStyle) {
+ extend(targetStyle, sourceStyle);
+ return targetStyle;
+ };
+ Displayable.prototype.getAnimationStyleProps = function () {
+ return DEFAULT_COMMON_ANIMATION_PROPS;
+ };
+ Displayable.initDefaultProps = (function () {
+ var dispProto = Displayable.prototype;
+ dispProto.type = 'displayable';
+ dispProto.invisible = false;
+ dispProto.z = 0;
+ dispProto.z2 = 0;
+ dispProto.zlevel = 0;
+ dispProto.culling = false;
+ dispProto.cursor = 'pointer';
+ dispProto.rectHover = false;
+ dispProto.incremental = false;
+ dispProto._rect = null;
+ dispProto.dirtyRectTolerance = 0;
+ dispProto.__dirty = REDRAW_BIT | STYLE_CHANGED_BIT;
+ })();
+ return Displayable;
+}(Element));
+var tmpRect$1 = new BoundingRect(0, 0, 0, 0);
+var viewRect = new BoundingRect(0, 0, 0, 0);
+function isDisplayableCulled(el, width, height) {
+ tmpRect$1.copy(el.getBoundingRect());
+ if (el.transform) {
+ tmpRect$1.applyTransform(el.transform);
+ }
+ viewRect.width = width;
+ viewRect.height = height;
+ return !tmpRect$1.intersect(viewRect);
+}
+
+var mathMin$1 = Math.min;
+var mathMax$1 = Math.max;
+var mathSin = Math.sin;
+var mathCos = Math.cos;
+var PI2 = Math.PI * 2;
+var start = create();
+var end = create();
+var extremity = create();
+function fromPoints(points, min, max) {
+ if (points.length === 0) {
+ return;
+ }
+ var p = points[0];
+ var left = p[0];
+ var right = p[0];
+ var top = p[1];
+ var bottom = p[1];
+ for (var i = 1; i < points.length; i++) {
+ p = points[i];
+ left = mathMin$1(left, p[0]);
+ right = mathMax$1(right, p[0]);
+ top = mathMin$1(top, p[1]);
+ bottom = mathMax$1(bottom, p[1]);
+ }
+ min[0] = left;
+ min[1] = top;
+ max[0] = right;
+ max[1] = bottom;
+}
+function fromLine(x0, y0, x1, y1, min, max) {
+ min[0] = mathMin$1(x0, x1);
+ min[1] = mathMin$1(y0, y1);
+ max[0] = mathMax$1(x0, x1);
+ max[1] = mathMax$1(y0, y1);
+}
+var xDim = [];
+var yDim = [];
+function fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min, max) {
+ var cubicExtrema$1 = cubicExtrema;
+ var cubicAt$1 = cubicAt;
+ var n = cubicExtrema$1(x0, x1, x2, x3, xDim);
+ min[0] = Infinity;
+ min[1] = Infinity;
+ max[0] = -Infinity;
+ max[1] = -Infinity;
+ for (var i = 0; i < n; i++) {
+ var x = cubicAt$1(x0, x1, x2, x3, xDim[i]);
+ min[0] = mathMin$1(x, min[0]);
+ max[0] = mathMax$1(x, max[0]);
+ }
+ n = cubicExtrema$1(y0, y1, y2, y3, yDim);
+ for (var i = 0; i < n; i++) {
+ var y = cubicAt$1(y0, y1, y2, y3, yDim[i]);
+ min[1] = mathMin$1(y, min[1]);
+ max[1] = mathMax$1(y, max[1]);
+ }
+ min[0] = mathMin$1(x0, min[0]);
+ max[0] = mathMax$1(x0, max[0]);
+ min[0] = mathMin$1(x3, min[0]);
+ max[0] = mathMax$1(x3, max[0]);
+ min[1] = mathMin$1(y0, min[1]);
+ max[1] = mathMax$1(y0, max[1]);
+ min[1] = mathMin$1(y3, min[1]);
+ max[1] = mathMax$1(y3, max[1]);
+}
+function fromQuadratic(x0, y0, x1, y1, x2, y2, min, max) {
+ var quadraticExtremum$1 = quadraticExtremum;
+ var quadraticAt$1 = quadraticAt;
+ var tx = mathMax$1(mathMin$1(quadraticExtremum$1(x0, x1, x2), 1), 0);
+ var ty = mathMax$1(mathMin$1(quadraticExtremum$1(y0, y1, y2), 1), 0);
+ var x = quadraticAt$1(x0, x1, x2, tx);
+ var y = quadraticAt$1(y0, y1, y2, ty);
+ min[0] = mathMin$1(x0, x2, x);
+ min[1] = mathMin$1(y0, y2, y);
+ max[0] = mathMax$1(x0, x2, x);
+ max[1] = mathMax$1(y0, y2, y);
+}
+function fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min$1, max$1) {
+ var vec2Min = min;
+ var vec2Max = max;
+ var diff = Math.abs(startAngle - endAngle);
+ if (diff % PI2 < 1e-4 && diff > 1e-4) {
+ min$1[0] = x - rx;
+ min$1[1] = y - ry;
+ max$1[0] = x + rx;
+ max$1[1] = y + ry;
+ return;
+ }
+ start[0] = mathCos(startAngle) * rx + x;
+ start[1] = mathSin(startAngle) * ry + y;
+ end[0] = mathCos(endAngle) * rx + x;
+ end[1] = mathSin(endAngle) * ry + y;
+ vec2Min(min$1, start, end);
+ vec2Max(max$1, start, end);
+ startAngle = startAngle % (PI2);
+ if (startAngle < 0) {
+ startAngle = startAngle + PI2;
+ }
+ endAngle = endAngle % (PI2);
+ if (endAngle < 0) {
+ endAngle = endAngle + PI2;
+ }
+ if (startAngle > endAngle && !anticlockwise) {
+ endAngle += PI2;
+ }
+ else if (startAngle < endAngle && anticlockwise) {
+ startAngle += PI2;
+ }
+ if (anticlockwise) {
+ var tmp = endAngle;
+ endAngle = startAngle;
+ startAngle = tmp;
+ }
+ for (var angle = 0; angle < endAngle; angle += Math.PI / 2) {
+ if (angle > startAngle) {
+ extremity[0] = mathCos(angle) * rx + x;
+ extremity[1] = mathSin(angle) * ry + y;
+ vec2Min(min$1, extremity, min$1);
+ vec2Max(max$1, extremity, max$1);
+ }
+ }
+}
+
+var CMD = {
+ M: 1,
+ L: 2,
+ C: 3,
+ Q: 4,
+ A: 5,
+ Z: 6,
+ R: 7
+};
+var tmpOutX = [];
+var tmpOutY = [];
+var min$1 = [];
+var max$1 = [];
+var min2 = [];
+var max2 = [];
+var mathMin$2 = Math.min;
+var mathMax$2 = Math.max;
+var mathCos$1 = Math.cos;
+var mathSin$1 = Math.sin;
+var mathAbs = Math.abs;
+var PI = Math.PI;
+var PI2$1 = PI * 2;
+var hasTypedArray = typeof Float32Array !== 'undefined';
+var tmpAngles = [];
+function modPI2(radian) {
+ var n = Math.round(radian / PI * 1e8) / 1e8;
+ return (n % 2) * PI;
+}
+function normalizeArcAngles(angles, anticlockwise) {
+ var newStartAngle = modPI2(angles[0]);
+ if (newStartAngle < 0) {
+ newStartAngle += PI2$1;
+ }
+ var delta = newStartAngle - angles[0];
+ var newEndAngle = angles[1];
+ newEndAngle += delta;
+ if (!anticlockwise && newEndAngle - newStartAngle >= PI2$1) {
+ newEndAngle = newStartAngle + PI2$1;
... 232355 lines suppressed ...
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@echarts.apache.org
For additional commands, e-mail: commits-help@echarts.apache.org