;(function () {
    function resolvePath(path, isPublic) {
        if (!path || path[0] !== '/') {
            path = '/' + path;
        }
        return isPublic === true
            ? '/webroot/decision/plugin/public/com.fr.plugin.enginex' + path
            : '/webroot/decision/plugin/private/com.fr.plugin.enginex' + path;
    }

    (function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["VanCharts"] = factory();
	else
		root["VanCharts"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 99);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _vMap = _interopRequireDefault(__webpack_require__(35));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _HtmlUtils = __webpack_require__(66);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/4.
 * 一些最常用的工具方法
 */
var templateRe = /\{ *([\w_\-]+) *\}/g;
var lastID = 0;
var DOUBLE_PI = 2 * Math.PI;
var decimalPlacesRegExp = /(?:\d+)(?:\.(\d+))?(?:[eE]-(\d+))?/; // ["0.111e-7", "111", "7"]

var decimalRegExp = /\.|[eE]-\d+/g; // (1.1e-7 + '').match(/\.|e-\d+/ig) -> [".", "e-7"]
//options中不需要合并起来的key

var skipKeys = {
  'minSize': true,
  'maxSize': true,
  'name': true
};
var SCALE = 1; //https://stackoverflow.com/questions/39079171/phantomjs-failing-to-parse-date-correctly

var DATE_DELIMITER = _Browser["default"].phantomjs ? "-" : "/";
var styleToCss = {
  color: 'fill',
  font: 'font',
  fontFamily: 'font-family',
  fontSize: 'font-size',
  fontStretch: 'font-stretch',
  fontStyle: 'font-style',
  fontVariant: 'font-variant',
  fontWeight: 'font-weight',
  letterSpacing: 'letter-spacing',
  lineHeight: 'line-height',
  quotes: 'quotes',
  textAlign: 'text-align',
  textDecoration: 'text-decoration',
  textIndent: 'text-indent',
  textShadow: 'text-shadow',
  textTransform: 'text-transform',
  whiteSpace: 'white-space',
  wordSpacing: 'word-spacing',
  padding: 'padding'
}; // Time related fns
// All time-related calls within our project
// should use the fns from this util.
// i.e., the following fns.
// First, get & save the prefixed original fns.

var $T = {
  setTimeout: window.setTimeout,
  clearTimeout: window.clearTimeout,
  setInterval: window.setInterval,
  clearInterval: window.clearInterval,
  requestAnimationFrame: window.requestAnimationFrame || getPrefixed('RequestAnimationFrame'),
  cancelAnimationFrame: window.cancelAnimationFrame || getPrefixed('CancelAnimationFrame') || getPrefixed('CancelRequestAnimationFrame')
};

for (var k in $T) {
  if ($T.hasOwnProperty(k) && $T[k] && $T[k].bind) {
    //IE低版本兼容
    $T[k] = $T[k].bind(window);
  }
} // 项目当中的时间相关函数都用 $T 中的
// setTimeout只影响递归调用的时候，所以setTimeout 和 clearTimeout 改不改都一样
// setInterval 使用raf 实现了，所以替换一定要成对: clearInterval
// When the chart is inside iframe, hack
//
// `requestAnimationFrame`,
// `setTimeout`,
// `setInterval`, `clearInterval`.
//
// Pause them when iframe is invisible.
// Another side effect:
// Overwrite `setInterval` by `requestAnimationFrame`
// Because we use it for animation, it's safe to pause.
//
// Caveat: assume iframes under the main top window & not cross-origin


(function () {
  var running = true; // Since the hack might confuse you,
  // All `$T.foo` here are deemed to be hacked.
  // Save the origin as `oFoo` if used.
  // save original ref

  var oSetTimeout = $T.setTimeout;
  var oRAF = $T.requestAnimationFrame; // we do not hack these two

  var oCAF = $T.cancelAnimationFrame;
  var oClearTimeout = $T.clearTimeout;
  var iframe;

  try {
    // @CHART-1933, CHART-3334
    // IE下iframe跨域时获取window.frameElement直接抛错access dined. 这里写在try..catch里面
    iframe = window.frameElement;
  } catch (e) {// window.frameElement拒绝访问
  } // Inner iframe keeps checking on parent container element <iframe>.
  // So we have to access it.
  // If not, skip.


  if (iframe) {
    var pause = function () {
      running = false;
    };

    var resume = function () {
      if (running) {
        return;
      }

      running = true;
      var i = -1;

      while (++i < rafFns.length) {
        rafFns[i].call();
      }

      rafFns = [];
      i = -1;

      while (++i < setTimeoutFns.length) {
        var fn = setTimeoutFns[i];
        $T.setTimeout(fn, fn.__$delay__);
      }

      setTimeoutFns = [];
    }; // use original raf to keep checking


    // store the handlers to resume
    var rafFns = [];
    var setTimeoutFns = []; // don't hack nonnative raf

    if (oRAF) {
      // we got prefix
      $T.requestAnimationFrame = function (fn) {
        if (running) {
          // return to get id
          return oRAF(fn);
        } else {
          // If we ask animations to stop,
          // shall we allow them to run one frame more?
          rafFns.push(fn);
        }
      };
    } // 除非递归调用，否则是一样的


    $T.setTimeout = function (fn, delay) {
      if (running) {
        // return to get id
        return oSetTimeout(fn, delay);
      } else {
        // 这里目标是那种16ms递归调用
        // 其实也可以不要delay
        fn.__$delay__ = delay;
        setTimeoutFns.push(fn);
      }
    };

    var raf = oRAF || function (callback) {
      return oSetTimeout(callback, 16);
    };

    raf(function check() {
      if ((iframe.style.display || '').toLowerCase() === 'none' // CHART-2298 cross-origin
      // || (window.top && window.top.__VAN_ANIM_STOP__) // for debug & test
      ) {
          pause();
        } else {
        resume();
      }

      raf(check);
    });
  }

  var requestAnimFrame = $T.requestAnimationFrame || function (callback) {
    return _Browser["default"].phantomjs ? window.setTimeout(callback, 16) : $T.setTimeout(callback, 16);
  }; // Implement `setInterval` by raf (or setTimeout).
  // Thus it is hacked version.


  $T.setInterval = function (fn, delay) {
    var start = new Date().getTime(),
        // id changed, make an object to keep id ref
    handle = {};

    function loop() {
      handle.value = requestAnimFrame(loop);
      var current = new Date().getTime(),
          delta = current - start;

      if (delta >= delay) {
        fn.call();
        start = new Date().getTime();
      }
    }

    handle.value = requestAnimFrame(loop);
    return handle;
  }; // additional hack for `clearInterval`


  $T.clearInterval = oCAF ? function (handle) {
    if (handle) {
      oCAF(handle.value);
    }
  } : function (handle) {
    if (handle) {
      oClearTimeout(handle.value);
    }
  };

  if (_Browser["default"].phantomjs) {
    $T.setTimeout = window.setTimeout;
  } // hack end
  // now all we need is $T.x instead of window.x

})();
/**
 * 存储间距缩放比例
 * @param scale
 * @returns {boolean} scale改变返回true
 */


function initPaddingScale(scale, wScale, hScale) {
  if (scale && scale === SCALE) {
    return false;
  }

  SCALE = scale || 1;
  return true;
}
/**
 * pick参数里第一个不为null和undefined的值
 * @returns {*}
 */


function pick() {
  var arg,
      length = arguments.length;

  for (var i = 0; i < length; i++) {
    arg = arguments[i];

    if (typeof arg !== 'undefined' && arg !== null) {
      return arg;
    }
  }

  return null;
}
/**
 * 判断指定值是否在指定数组中(ie14以下不支持array.includes())
 * @param array
 * @param target
 * @returns {boolean}
 */


function includes(array, target) {
  for (var i = 0; i < array.length; i++) {
    if (array[i] === target) {
      return true;
    }
  }

  return false;
}
/**
 * 判断对象是否是数组
 * @param value 对象
 * @returns {boolean} 是否是数组
 */


function isArray(value) {
  return Object.prototype.toString.apply(value) === '[object Array]';
}
/**
 * 将具有length属性的对象转成数组
 * @param sequence 对象
 */


function toArray(sequence) {
  return Array.prototype.slice.call(sequence);
}

function setTextStyle(textS, style) {
  style = cssNormalization(style);

  for (var attr in style) {
    textS.style(attr, style[attr]);
  }
}
/**
 * get text dimension by html, svg or canvas
 * @param {string} text
 * @param {object} style
 * @param {boolean} useHtml
 */


function getTextDimension(text, style, useHtml) {
  return (0, _EnvUtils._getTextDimension)(text, style, useHtml);
}

function getTextWrapDimension(text, style, useHTML) {
  if (false) {}

  var newStyle = extend({
    'white-space': 'normal',
    'whiteSpace': 'normal',
    'word-wrap': 'break-word',
    'wordWrap': 'break-word'
  }, style);
  return (0, _EnvUtils._getHtmlTextDim)(text, newStyle, useHTML);
}

function getTextBBoxWithRotation(domWrapper, rotation) {
  rotation = toRadian(rotation);
  var node = domWrapper.node();
  var text = domWrapper.type === 'div' ? node.innerHTML : node.textContent;
  var style = domWrapper.styles;
  var useHtml = !(0, _EnvUtils.isSupportSVG)();
  var dim = (0, _EnvUtils._getTextDimension)(text, style, useHtml);
  var cos = Math.abs(Math.cos(rotation)),
      sin = Math.abs(Math.sin(rotation));
  var width = dim.width,
      height = dim.height;
  return {
    width: width * cos + height * sin,
    height: width * sin + height * cos
  };
}

function setDomBackground(dom, opt) {
  var cssText = [];

  if (opt.backgroundColor) {
    if (typeof opt.backgroundColor == 'string') {
      if ((0, _EnvUtils.isSupportSVG)()) {
        cssText.push('background-Color:' + opt.backgroundColor);
      } else {
        var hexAlpha = _ColorUtils["default"].colorToHexAlpha(opt.backgroundColor);

        cssText.push('background-Color:' + hexAlpha.hex);
        cssText.push('filter:alpha(opacity=' + hexAlpha.alpha * 100 + ')');
      }
    } else if (typeof opt.backgroundColor == 'object') {
      var color = opt.backgroundColor;

      var startColor = _ColorUtils["default"].colorToHex(color.startColor);

      var endColor = _ColorUtils["default"].colorToHex(color.endColor);

      var start = 'left';
      var startPos = 'left top';
      var endPos = 'right top';
      var type = 1;

      if (color.x1 == color.x2) {
        start = 'top';
        startPos = 'left top';
        endPos = 'left bottom';
        type = 0;
      }

      cssText.push('background: -ms-linear-gradient(' + start + ', ' + startColor + ', ' + endColor + ')');
      cssText.push('background-image: -moz-linear-gradient(' + start + ', ' + startColor + ', ' + endColor + ')');
      cssText.push('background-image: -webkit-gradient(linear, ' + startPos + ', ' + endPos + ', color-stop(0, ' + startColor + '), color-stop(1, ' + endColor + '))');
      cssText.push('filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=' + startColor + ', endColorstr=' + endColor + ', GradientType=' + type + ')');
    }
  }

  if (opt.backgroundImage) {
    cssText.push('background-image:url(' + opt.backgroundImage + ')');
    cssText.push('background-size:100% 100%');
  }

  if (opt.borderWidth != null) {
    cssText.push('border-style:solid');
    cssText.push('border-width:' + opt.borderWidth + 'px');
  }

  if (opt.borderColor != null) {
    cssText.push('border-color:' + opt.borderColor);
  }

  if (opt.borderRadius != null) {
    cssText.push('border-radius:' + opt.borderRadius + 'px');
    cssText.push('-moz-border-radius:' + opt.borderRadius + 'px');
    cssText.push('-webkit-border-radius:' + opt.borderRadius + 'px');
    cssText.push('-o-border-radius:' + opt.borderRadius + 'px');
  }

  if (opt.shadow) {
    cssText.push('box-shadow:1px 1px 2px rgba(0,0,0,0.2)');
  }

  dom.style.cssText += cssText.join(';') + ';';
}

function stamp(obj) {
  obj._vanchart_id = obj._vanchart_id || 'vancharts' + ++lastID;
  return obj._vanchart_id;
} //properties mix in


function extend(dest) {
  var i, j, len, src;

  for (j = 1, len = arguments.length; j < len; j++) {
    src = arguments[j];

    for (i in src) {
      dest[i] = src[i];
    }
  }

  return dest;
}

function domRotate(div, rotation) {
  var cssText = [];
  cssText.push('transform:rotate(' + rotation + 'deg)');
  cssText.push('-ms-transform:rotate(' + rotation + 'deg)');
  cssText.push('-webkit-transform:rotate(' + rotation + 'deg)');
  cssText.push('-moz-transform:rotate(' + rotation + 'deg)');
  cssText.push('-o-transform:rotate(' + rotation + 'deg)');
  var costheta = Math.cos(toRadian(rotation));
  var sintheta = Math.sin(toRadian(rotation)); //ie9的时候filter和ms-transform同时生效了

  if (!(0, _EnvUtils.isSupportSVG)()) {
    var filter = rotation ? ['progid:DXImageTransform.Microsoft.Matrix(M11=', costheta, ', M12=', -sintheta, ', M21=', sintheta, ', M22=', costheta, ', sizingMethod=\'auto expand\')'].join('') : 'none';
    cssText.push('filter:' + filter);
  }

  div.style.cssText += cssText.join(';') + ';';
} //breakWord == false:英文截断时用-连接。之后可能会考虑数字


function splitText(text, style, offeredSize, padding, breakWord) {
  if (!text) {
    return [];
  }

  text += '';
  padding = padding || 0;
  offeredSize -= 2 * padding;
  var result = [];
  var startIndex = 0;
  var textCount = text.length;

  while (startIndex < textCount) {
    var i = startIndex;

    while (getTextDimension(text.substring(i, startIndex + 1), style, false).width < offeredSize) {
      startIndex++;

      if (startIndex >= textCount) {
        break;
      }
    }

    if (i == startIndex) {
      //一个字符都放不下的时候显示。。。吧
      return ['...'];
    } else {
      var substring = text.substring(i, startIndex);

      if (breakWord == false && startIndex != textCount && startIndex - 1 > i) {
        var lastChar = text.charAt(startIndex - 1);
        var nextChar = text.charAt(startIndex); //本行最后一个&&下一行第一个字符都是英文，才考虑用"-"连接

        if (/[A-Za-z]/.test(lastChar) && /[A-Za-z]/.test(nextChar)) {
          var _char = text.charAt(startIndex - 2);

          substring = text.substring(i, startIndex - 1);
          startIndex--;

          if (_char !== ' ' && _char !== '-') {
            substring += '-';
          }
        } //数字换行，没考虑负数，没考虑下一行第一个不是数字
        // else if(/[0-9]/.test(lastChar)){
        //     var lastIndex = startIndex - 1;
        //
        //     while (lastIndex > i){
        //         var char = text.charAt(lastIndex - 1);
        //         lastIndex--;
        //         if(!/[0-9]/.test(char)){
        //             break;
        //         }
        //     }
        //     if(lastIndex == i){//数字本身一行放不下
        //         lastIndex = startIndex - 1;
        //     }
        //
        //     startIndex = lastIndex + 1;
        //     substring = text.substring(i, startIndex);
        // }

      }

      result.push(substring);
    }
  }

  return result;
}
/**
 * 文本显示不下时先换行显示，如果换行(最多两行)还显示不下，再缩小字体；
 * 字体最小为minSize还显示不下，再加缩略显示
 */


function splitAndShrinkText(text, minSize, style, offeredSize, useHtml, padding, breakWord) {
  var fontStyle = clone(style);
  var content = splitText(text, fontStyle, offeredSize, padding, breakWord);
  var fontSize = parseFloat(calculateFontSizeWithScale(fontStyle).fontSize);

  while (content.length > 2) {
    fontSize = fontSize - 1;
    fontStyle.fontSize = fontSize;
    content = splitText(text, fontStyle, offeredSize, padding, breakWord);

    if (fontStyle.fontSize <= minSize && content.length > 2) {
      fontStyle.fontSize = minSize;
      var end = content[1] + content[2];
      content[1] = getEllipsisText(end, offeredSize, fontStyle, useHtml);
      content = [content[0], content[1]];
      fontSize = minSize;
      break;
    }
  }

  return {
    text: content,
    fontSize: fontSize + 'px'
  };
}
/**
 * 文本显示不下时，先缩小字体，字体最小为minSize还显示不下，再加缩略显示
 */


function shrinkText(text, minSize, fontHeight, limitWidth, style, useHtml) {
  var fontStyle = clone(style);
  fontStyle.fontSize = Math.max(fontHeight, minSize);
  var widthOrigin = getTextDimension(text, fontStyle, useHtml).width;

  if (limitWidth <= 0) {
    return {
      labelContent: '',
      fontSize: fontStyle.fontSize + 'px'
    };
  }

  while (widthOrigin >= limitWidth) {
    fontStyle.fontSize -= 1;

    if (fontStyle.fontSize <= minSize) {
      fontStyle.fontSize = minSize;
      text = getEllipsisText(text, limitWidth, fontStyle, useHtml);
      break;
    }

    widthOrigin = getTextDimension(text, fontStyle, useHtml).width;
  }

  return {
    labelContent: text,
    fontSize: fontStyle.fontSize + 'px'
  };
}

function getTextDimensionWithRotation(text, style, useHtml, rotation) {
  var dim = getTextDimension(text, style, useHtml);
  return getTextDimRotated(dim, rotation);
}

function getTextDimRotated(dim, rotation) {
  var angle = Math.abs(toRadian(rotation || 0));
  var width = dim.width * Math.cos(angle) + dim.height * Math.sin(angle);
  var height = dim.width * Math.sin(angle) + dim.height * Math.cos(angle);
  return {
    width: width,
    height: height
  };
}

function getEllipsisText(text, limit, style, useHtml) {
  var textString = text + '';
  var widthOrigin = getTextDimension(textString, style, useHtml).width;

  if (widthOrigin <= limit) {
    return text;
  }

  var len = textString.length;
  var end = 0;

  while (++end <= len) {
    var content = textString.slice(0, end);
    var width = getTextDimension(content, style, useHtml).width;

    if (width > limit) {
      var ellipsis = '',
          left = textString.slice(0, Math.max(end - 1, 0)),
          e = (limit - getTextDimension(left, style, useHtml).width) / (0, _EnvUtils.convertREMtoPX)(style.fontSize);

      if (e > 0.6) {
        ellipsis = '..';
      } else if (e > 0.3) {
        ellipsis = '.';
      } else {
        if (left) {
          left = left.slice(0, left.length - 1);
          ellipsis = '...';
        } else {
          ellipsis = '.';
        }
      }

      return left + ellipsis;
    }
  }
} //style对象的表示方法转css表示


function cssNormalization(style) {
  var result = {};

  for (var attr in style) {
    if (styleToCss[attr]) {
      result[styleToCss[attr]] = style[attr];
    }

    if (attr == 'color') {
      result.color = style[attr];
    } //转px


    if (attr == 'fontSize') {
      var fontSize = style[attr];

      if (fontSize.indexOf('pt') != -1) {
        fontSize = parseFloat(fontSize) * 4 / 3;
        result['font-size'] = fontSize + 'px';
      }
    }
  }

  return result;
}
/**
 * css类属性数组补全，如padding，margin等~
 */


function reformCssArray(p) {
  if (p instanceof Array) {
    switch (p.length + '') {
      case '4':
        return p;

      case '3':
        return [p[0], p[1], p[2], p[1]];

      case '2':
        return [p[0], p[1], p[0], p[1]];

      case '1':
        return [p[0], p[0], p[0], p[0]];

      case '0':
        return [0, 0, 0, 0];
    }
  } else {
    return [p, p, p, p];
  }
}

function lineSubPixelOpt(pos, lineWidth) {
  return lineWidth % 2 === 0 ? Math.round(pos) : Math.round(pos - 0.5) + 0.5;
}

function rectSubPixelOpt() {
  var x, y, width, height, lineWidth;

  if (arguments.length === 2) {
    x = arguments[0].x;
    y = arguments[0].y;
    width = arguments[0].width;
    height = arguments[0].height;
    lineWidth = arguments[1];
  } else {
    x = arguments[0];
    y = arguments[1];
    width = arguments[2];
    height = arguments[3];
    lineWidth = arguments[4];
  }

  lineWidth = lineWidth || 0;
  var x1, y1, x2, y2;
  x1 = lineSubPixelOpt(x, lineWidth);
  y1 = lineSubPixelOpt(y, lineWidth);
  x2 = lineSubPixelOpt(x + width, lineWidth);
  y2 = lineSubPixelOpt(y + height, lineWidth); // @CHART-1509: (y1:(20.1->20.5)+height1:(19.9->20)=40.5) !=  (y2:(20.6->20.5)+height2(19.4->19) = 39.5)

  return {
    x: x1,
    y: y1,
    width: x2 - x1,
    height: y2 - y1
  };
}

function addArray(targetArray, sourceArray) {
  var result = [];

  if (targetArray && targetArray.length) {
    for (var i = 0, len = targetArray.length; i < len; i++) {
      result.push(targetArray[i]);
    }
  }

  if (sourceArray && sourceArray.length) {
    for (var i = 0, len = sourceArray.length; i < len; i++) {
      result.push(sourceArray[i]);
    }
  }

  return result;
}

function toFront(el) {
  if (el && el.parentNode) {
    el.parentNode.appendChild(el);
  }
}

function toBack(el) {
  if (el && el.parentNode) {
    el.parentNode.insertBefore(el, el.parentNode.firstChild);
  }
}

function toFrontOfAll(el) {
  el.ownerSVGElement.appendChild(el);
}

function toBackOfAll(el) {
  el.ownerSVGElement.appendChild(el, el.ownerSVGElement.firstChild);
} // 一定是在同一个坐标原点下


function containsRect(biggerOne, smallOne) {
  return biggerOne.x <= smallOne.x && biggerOne.y <= smallOne.y && biggerOne.x + biggerOne.width >= smallOne.x + smallOne.width && biggerOne.y + biggerOne.height >= smallOne.y + smallOne.height;
}

function rectangleOverlapped(aBounds, bBounds) {
  if (!aBounds || !bBounds) {
    return false;
  }

  var minx = Math.max(aBounds.x, bBounds.x);
  var miny = Math.max(aBounds.y, bBounds.y);
  var maxx = Math.min(aBounds.x + aBounds.width, bBounds.x + bBounds.width);
  var maxy = Math.min(aBounds.y + aBounds.height, bBounds.y + bBounds.height);
  return minx <= maxx && miny <= maxy;
}
/**
 * 测试线段与线段是否相交
 * @param a1 - The start point of the first line
 * @param a2 - The end point of the first line
 * @param b1 - The start point of the second line
 * @param b2 - The end point of the second line
 * @returns {boolean}
 */


function lineLine(a1, a2, b1, b2) {
  // b1->b2向量 与 a1->b1向量的向量积
  var ua_t = (b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x); // a1->a2向量 与 a1->b1向量的向量积

  var ub_t = (a2.x - a1.x) * (a1.y - b1.y) - (a2.y - a1.y) * (a1.x - b1.x); // a1->a2向量 与 b1->b2向量的向量积

  var u_b = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y); // u_b == 0时，角度为0或者180 平行或者共线不属于相交

  if (u_b !== 0) {
    var ua = ua_t / u_b;
    var ub = ub_t / u_b;

    if (0 <= ua && ua <= 1 && 0 <= ub && ub <= 1) {
      return true;
    }
  }

  return false;
}
/**
 * !#zh 测试线段与矩形是否相交
 * @param a1 - The start point of the line
 * @param a2 - The end point of the line
 * @param b - The rect
 * @return {boolean}
 */


function lineRect(a1, a2, b) {
  var r0 = {
    x: b.x,
    y: b.y
  };
  var r1 = {
    x: b.x,
    y: b.y + b.height
  };
  var r2 = {
    x: b.x + b.width,
    y: b.y + b.height
  };
  var r3 = {
    x: b.x + b.width,
    y: b.y
  };

  if (lineLine(a1, a2, r0, r1)) {
    return true;
  }

  if (lineLine(a1, a2, r1, r2)) {
    return true;
  }

  if (lineLine(a1, a2, r2, r3)) {
    return true;
  }

  return lineLine(a1, a2, r3, r0);
}

function outsideRect(biggerOne, smallOne) {
  return !containsRect(biggerOne, smallOne) && !rectangleOverlapped(biggerOne, smallOne);
}
/*
* @param {object} rect 检测区域，包含x,y,width,height
* @param {object/array} point 检测的点
* 用于检测某点是否在某个区域中
* */


function containsPoint(rect, point) {
  if (!rect || !point) {
    return false;
  }

  var x = pick(point.x || point[0]);
  var y = pick(point.y || point[1]);
  return rect.x < x && rect.x + rect.width > x && rect.y < y && rect.y + rect.height > y;
}

function isValidRect(bounds) {
  var width = bounds.width,
      height = bounds.height;
  return width > 0 && height > 0;
}

function makeValueInRange(min, max, value) {
  var rMin = Math.min(min, max);
  var rMax = Math.max(min, max);
  var gap = rMax - rMin;
  return ((value - rMin) % gap + gap) % gap + rMin;
}

function getValueInDomain(value, domain) {
  return Math.min(Math.max(value, domain[0]), domain[1]);
}

function toRadian(degree) {
  return Math.PI * (degree / 180);
}

function toDegree(radian) {
  return radian * 180 / Math.PI;
} // 设计器那边传过来的formatter函数是字符串


function getFormatterFunction(formatter) {
  if (formatter == null || formatter === '') {
    return null;
  }

  if (typeof formatter == 'string') {
    var formatterFunc = new Function("return " + formatter)(); //浙江农信的奇葩问题

    if (typeof formatterFunc == 'string') {
      eval("var _tmpFunc = " + formatterFunc);
      return _tmpFunc;
    }

    return formatterFunc;
  }

  return formatter;
}

function format(cv, fmt) {
  if (fmt && fmt.match && fmt.match(/D/)) {
    //在fmt为时间型或日期型时，若后台传过来的cv是字符串型毫秒数，将cv转为数值
    cv = (0, _CoreUtils.isEmpty)(cv) || isNaN(cv) ? cv : +cv;
  }

  fmt = getFormatterFunction(fmt);

  try {
    return typeof fmt === 'function' ? fmt.bind(cv)(cv) : cv;
  } catch (e) {
    //这边try catch 一下。很多自定义格式，很可能会抛错
    return cv;
  }
}

function endsWith(str, search, this_len) {
  if (str == null || search == null) {
    return false;
  }

  if (this_len === undefined || this_len > str.length) {
    this_len = str.length;
  }

  return str.substring(this_len - search.length, this_len) === search;
}

function startsWith(str, search, pos) {
  pos = !pos || pos < 0 ? 0 : +pos;
  return str.substring(pos, pos + search.length) === search;
}

function clone(obj) {
  // Handle the 3 simple types, and null or undefined
  if (null == obj || "object" != typeof obj) {
    return obj;
  } // Handle Date


  if (obj instanceof Date) {
    var copy = new Date();
    copy.setTime(obj.getTime());
    return copy;
  } // Handle Array


  if (obj instanceof Array) {
    var copy = [];

    for (var i = 0, len = obj.length; i < len; ++i) {
      copy[i] = clone(obj[i]);
    }

    return copy;
  }

  if (obj instanceof String) {
    // convert String 'object' to 'string'
    // do not use String object
    return obj + '';
  } // Handle Object


  if (obj instanceof Object) {
    var copy = {};

    for (var attr in obj) {
      if (obj.hasOwnProperty(attr)) {
        copy[attr] = clone(obj[attr]);
      }
    }

    return copy;
  }
}

function makeBounds() {
  var x = 0,
      y = 0,
      width = 0,
      height = 0;

  if (arguments.length === 2) {
    var pos = arguments[0];
    var dim = arguments[1];
    x = pick(pos.x, pos[0]);
    y = pick(pos.y, pos[1]);
    width = pick(dim.width, dim[0]);
    height = pick(dim.height, dim[1]);
  } else if (arguments.length === 4) {
    x = arguments[0];
    y = arguments[1];
    width = arguments[2];
    height = arguments[3];
  }

  return {
    x: x,
    y: y,
    width: width,
    height: height
  };
}

function distance(p1, p2) {
  var x1 = pick(p1.x, p1[0]);
  var y1 = pick(p1.y, p1[1]);
  var x2 = pick(p2.x, p2[0]);
  var y2 = pick(p2.y, p2[1]);
  var detX = x1 - x2;
  var detY = y1 - y2;
  return Math.sqrt(detX * detX + detY * detY);
}

function log(logBase, value) {
  return accDiv(newMathLog(value), newMathLog(logBase));
}
/**
 * Math.pow(Math.E, Math.log(0.1)) = 0.10000000000000003
 * 而 Math.pow(Math.E, Math.log(10)) = 10
 * @param value
 * @returns {number}
 */


function newMathLog(value) {
  return value < 1 ? -Math.log(accDiv(1, value)) : Math.log(value);
}

function getOrder(value) {
  var order = 0;

  if (value > 0 && value < 1) {
    while (value < 1) {
      value = accMul(value, 10);
      order--;
    }
  } else if (value >= 10) {
    while (value >= 10) {
      value = accDiv(value, 10);
      order++;
    }
  }

  return order;
} //用百分比表示或者数字表示的值


function getPercentValue(value, total) {
  if (value) {
    value += '';

    if (value.indexOf('%') != -1) {
      value = parseFloat(value) * total / 100;
    }

    return parseFloat(value);
  }

  return 0;
} // 1.1e-7 -> 8


function getDecimalPlaces(num) {
  var m = (num + '').match(decimalPlacesRegExp);
  return m ? (m[1] ? m[1].length : 0) + (+m[2] || 0) : 0;
}

function accAdd(arg1, arg2) {
  if (arg1 % 1 === 0 && arg2 % 1 === 0) {
    return arg1 + arg2;
  }

  var r1 = getDecimalPlaces(arg1);
  var r2 = getDecimalPlaces(arg2);
  var m = Math.pow(10, Math.max(r1, r2));
  return (accMul(arg1, m) + accMul(arg2, m)) / m;
}

function accDiv(arg1, arg2) {
  if (arg1 % 1 === 0 && arg2 % 1 === 0) {
    return arg1 / arg2;
  }

  var s1 = arg1 + '',
      s2 = arg2 + '';
  var m = -getDecimalPlaces(arg1);
  m += getDecimalPlaces(arg2);
  var a = s1.replace(decimalRegExp, '');
  var b = s2.replace(decimalRegExp, '');
  return m > 0 ? a / b * Math.pow(10, m) : a / b / Math.pow(10, -m);
}

function accMul(arg1, arg2) {
  if (arg1 % 1 === 0 && arg2 % 1 === 0) {
    return arg1 * arg2;
  }

  var s1 = arg1 + '',
      s2 = arg2 + '';
  var m = getDecimalPlaces(arg1);
  m += getDecimalPlaces(arg2);
  return s1.replace(decimalRegExp, '') * s2.replace(decimalRegExp, '') / Math.pow(10, m);
}
/**
 * 将value扩展成一个比较符合人类阅读习惯的数值。
 * @param value
 * @param count {Number} 刻度数量
 * @returns {*}
 */


function niceValue(value, count) {
  value = +value; // [0, value] 或者[value, 0]之间设定有count-1个区间，也就是count个刻度。

  count = count - 1 || 4;
  var step = value / count,
      isReversed = value < 0;
  step = Math.abs(step);
  value = Math.abs(value); // 获取当前step的数量级

  var magnitude = parseInt(Math.log(step) / Math.log(10)); // value === 0的时候

  if (!isFinite(magnitude)) {
    return value;
  } // 现在获取当前数量级的第一个值


  var nextOrderMagnitude = Math.pow(10, magnitude); // 如果这个时候step正好等于nextOrderMagnitute，
  // 我们就不要获取下一个数量级的第一个值了，因为step就很完美

  if (step !== nextOrderMagnitude) {
    magnitude += 1;
    nextOrderMagnitude = Math.pow(10, magnitude);
  } // 将step转化成(0, 1]之间的数值


  var newStep = step / nextOrderMagnitude;
  var arr = [0.1, 0.2, 0.25, 0.5, 1]; // 将newStep转化成符合人类阅读习惯的数值

  arr.some(function (item) {
    if (newStep < item) {
      newStep = item;
      return true;
    }
  });
  newStep = accMul(newStep, Math.pow(10, magnitude));
  var num = newStep * count;
  return isReversed ? num * -1 : num;
}

function objectToArray(object) {
  if (object.length) {
    return [].slice.call(object);
  }

  var result = [];

  for (var key in object) {
    result.push(object[key]);
  }

  return result;
}

function date2int(date) {
  if (date == null) {
    return null;
  }

  var baseDate = new Date("1970-01-01"); // @CHART-1496(😔😔😔😔😔😔)

  date = object2date(date);
  return date.getTime() - baseDate.getTime();
}

function int2date(milliseconds) {
  var baseDate = new Date("1970-01-01");
  milliseconds = milliseconds || 0;
  return new Date(milliseconds + baseDate.getTime());
}

function object2date(obj) {
  if (!obj) {
    return new Date(undefined);
  }

  var date = obj;

  if (typeof date == 'string' && isNaN(date)) {
    // 日期型
    date = new Date(Date.parse(date.replace(/[-/|\.]/g, DATE_DELIMITER)));

    if ((date == "Invalid Date" || date == "NaN") && FR && FR.str2Date) {
      date = FR.str2Date(obj, "yyyy-MM-dd HH:mm:ss");
    }
  } else if (!isNaN(date)) {
    // 毫秒数
    date = new Date(+date);
  }

  return date;
}

function makeTranslate(pos) {
  var x = pick(pos.x, pos[0]);
  var y = pick(pos.y, pos[1]);
  return 'translate(' + x + ',' + y + ')';
}

function makeTranslate3d(pos) {
  var x = pick(pos.x, pos[0]);
  var y = pick(pos.y, pos[1]);
  var z = pick(pos.z, pos[2], 0);
  return 'translate3d(' + x + 'px,' + y + 'px,' + z + 'px)';
}

function makeTranslateWithPX(pos) {
  var x = pick(pos.x, pos[0]);
  var y = pick(pos.y, pos[1]);
  return 'translate(' + x + 'px,' + y + 'px)';
}

function isImageMarker(markerType) {
  var ALL_SYMBOLS = _Constants["default"].LOCATION + _Constants["default"].STAR + _Constants["default"].CIRCLE + _Constants["default"].SQUARE + _Constants["default"].DIAMOND + _Constants["default"].TRIANGLE + _Constants["default"].CIRCLE_HOLLOW + _Constants["default"].SQUARE_HOLLOW + _Constants["default"].DIAMOND_HOLLOW + _Constants["default"].TRIANGLE_HOLLOW + _Constants["default"].SYMBOL_AUTO;
  return ALL_SYMBOLS.indexOf(markerType) == -1 && (0, _CoreUtils.hasDefined)(markerType);
}

function isNullMarker(marker) {
  return (0, _CoreUtils.hasNotDefined)(marker.symbol);
}

function getDefaultMarkerSymbol(seriesIndex) {
  var ALL_SYMBOLS = [_Constants["default"].CIRCLE, _Constants["default"].CIRCLE_HOLLOW, _Constants["default"].SQUARE, _Constants["default"].SQUARE_HOLLOW, _Constants["default"].DIAMOND, _Constants["default"].DIAMOND_HOLLOW, _Constants["default"].TRIANGLE, _Constants["default"].TRIANGLE_HOLLOW];
  return ALL_SYMBOLS[seriesIndex % ALL_SYMBOLS.length];
}

function splitWords(str) {
  str = str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
  return str.split(/\s+/);
}

function trim(str) {
  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
}

function removeEvent(el, type, fn) {
  if (el.removeEventListener) {
    el.removeEventListener(type, fn, false);
  } else if (el.attachEvent) {
    el.detachEvent('on' + type, fn);
  }
}

function dealFloatPrecision(v) {
  return Math.abs(v) < 1e-6 ? 0 : v;
}

function getDomWidth(root) {
  if (root.getWidth) {
    return root.getWidth();
  }

  var stl = root.currentStyle || document.defaultView.getComputedStyle(root);
  return ((root.clientWidth || parseInt(stl.width, 10)) - parseInt(stl.paddingLeft, 10) - parseInt(stl.paddingRight, 10)).toFixed(0) - 0;
}

function getDomHeight(root) {
  if (root.getHeight) {
    return root.getHeight();
  }

  var stl = root.currentStyle || document.defaultView.getComputedStyle(root);
  return ((root.clientHeight || parseInt(stl.height, 10)) - parseInt(stl.paddingTop, 10) - parseInt(stl.paddingBottom, 10)).toFixed(0) - 0;
}

function hasTouch() {
  var doc = window.document;
  return doc && doc.documentElement.ontouchstart !== undefined;
}

function getArcPoint(r, radian) {
  return [r * Math.sin(radian), -r * Math.cos(radian)];
}

function getArcByPoint(x, y) {
  return (2 * Math.PI - (Math.atan2(y, x) - Math.PI / 2)) % (2 * Math.PI);
}

function calculateAutoMinMaxAndGap(minValue, maxValue, splitNumber) {
  if (maxValue < minValue) {
    minValue = 0;
    maxValue = 100;
  }

  var increment = accAdd(maxValue, -minValue);
  var order = getOrder(increment);
  var pow = Math.pow(10, order);

  if (order <= 0) {
    minValue = accMul(minValue, Math.pow(10, 1 - order));
    minValue = accDiv(Math.floor(minValue), Math.pow(10, 1 - order));
  } else {
    minValue = Math.floor(minValue / pow) * pow;
  }

  var base = accMul(accDiv(splitNumber, 10), pow);
  var gap = 0;

  while (gap < increment) {
    gap = accAdd(base, gap);
  }

  var bd = accDiv(gap, splitNumber);

  while (minValue + bd * splitNumber < maxValue) {
    gap = accAdd(base, gap);
    bd = accDiv(gap, splitNumber);
  }

  gap = accDiv(gap, splitNumber);
  maxValue = accAdd(minValue, accMul(gap, splitNumber));
  return [minValue, maxValue, gap];
} //原因：FR重写了Array.prototype.indexOf，递归所有属性
//point-points-series-point


function indexOf(array, el) {
  for (var i = 0; i < array.length; i++) {
    if (array[i] === el) {
      return i;
    }
  }

  return -1;
}

function hasChn(str) {
  return /[\u4E00-\u9FA5]/.test(str);
}
/**
 * 根据缩放统一处理图表中各种间隙
 * @param  {Number} size 默认的间隙大小
 * @return {Number}      根据缩放参数Scale和默认间隙字体大小计算后的间隙大小
 */


function paddingConvertWithScale(size) {
  return Math.round((0, _EnvUtils.convertREMtoPX)(size) * SCALE);
} // 为了移动端流式布局搞的特殊的fn
// 流式布局限定字体；字号为原0.85。
// 后台改动比较复杂，就直接前台暴力改了。
// 在setOptions里面判断flow，替换BaseUtils的calculateFontSizeWithScale引用
// 搜索了一下所有的使用都是BaseUtils.calculateFontSizeWithScale，所以可以直接替换


function _mutateMobileFlowFontStyle(style) {
  if (style) {
    style.fontFamily = 'sans-serif';
  }

  return calculateFontSizeWithScale(style);
}
/**
 * 根据Scale计算字体(px单位)
 * @param  {[Obejct]} style [转换前的样式对象]
 * @return {[Object]}       [转换后的样式对象]
 */


function calculateFontSizeWithScale(style) {
  if (style) {
    if (!style.fontSize) {
      style.fontSize = (0, _EnvUtils.getDefaultFontSize)();
    }

    var size = style.fontSize + '';
    style.FONT_SCALE = style.FONT_SCALE || 1;

    if (size.indexOf('rem') != -1) {
      size = parseFloat(size) * 16;
    } else if (size.indexOf('pt') != -1) {
      size = parseFloat(size) * 4 / 3;
    } else {
      size = parseFloat(size);
    }

    style.fontSize = Math.round(size * SCALE / style.FONT_SCALE) + 'px';
    style.FONT_SCALE = SCALE;
  }

  return style;
}

function getComputedStyle(element, attr, accessor) {
  if (element.nodeType !== 1) {
    throw new Error("element is not a DOM element.");
  }

  if (typeof accessor !== 'function') {
    accessor = function (x) {
      return x;
    };
  }

  var computedStyle = function (node, attr) {
    var style = element.currentStyle ? element.currentStyle : window.getComputedStyle(element, null);
    var val = style[attr];
    var paddingLeft = parseFloat(style['padding-left']),
        borderWidth = parseFloat(style['border-left-width']);
    paddingLeft = isNaN(paddingLeft) ? 0 : paddingLeft;
    borderWidth = isNaN(borderWidth) ? 0 : borderWidth; // 有时获取到的style属性值是auto，这些个天杀的家伙。

    if (val === 'auto' && (attr === "width" || attr === "height")) {
      var rect = node.getBoundingClientRect();
      val = attr === 'width' ? rect.right - rect.left : rect.bottom - rect.top;
      val -= (paddingLeft + borderWidth) * 2;
      val += "px";
    }

    return val;
  },
      attributes = splitWords(attr),
      obj = {};

  attributes.forEach(function (attr) {
    obj[camelCase(attr)] = accessor(computedStyle(element, attr));
  });
  return obj;
} // JQuery camelCase func


function camelCase(string) {
  var rmsPrefix = /^-ms-/,
      rdashAlpha = /-([\da-z])/gi;
  return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, function fcamelCase(all, letter) {
    return letter.toUpperCase();
  });
} //浏览器默认1em(一倍字体行高)=16px。以此为基准，对传递到前台的字体统一进行换算.如设计器中设置的10px字体则自动转化为0.625rem
//ie8以下不支持rem，仍然用px


function convertToREMUseDefault16PX(style) {
  if (style) {
    var size = style.fontSize + '';

    if ((0, _EnvUtils.isSupportSVG)() && !false) {
      size = isNaN(parseFloat(size)) ? '0.75rem' : size;

      if (size.indexOf('rem') != -1) {
        size = parseFloat(size) * 16;
      } else if (size.indexOf('pt') != -1) {
        size = parseFloat(size) * 4 / 3;
      }

      style.fontSize = parseFloat(size) / 16 + 'rem';
    } else if (size && size.indexOf('rem') != -1) {
      style.fontSize = parseFloat(size) * 16 + 'px';
    }
  }

  return style;
}

function toPng(url) {
  window.location = url;
}

function computeArc(ax, ay, bx, by, c) {
  var th = Math.asin(c),
      absX = Math.abs(ax - bx),
      absY = Math.abs(ay - by),
      l = Math.sqrt(absX * absX + absY * absY) / 2,
      direction = ax > bx ? -1 : 1,
      d = direction * l / Math.tan(th),
      al = Math.atan((ay - by) / (bx - ax)),
      w = d * Math.sin(al),
      h = d * Math.cos(al),
      mx = (ax + bx) / 2,
      my = (ay + by) / 2,
      ox = mx + w,
      oy = my + h,
      sAngX = ax - ox,
      sAngY = ay - oy,
      eAngX = bx - ox,
      eAngY = by - oy,
      sAng = normalRadian(Math.atan2(sAngY, sAngX)),
      eAng = normalRadian(Math.atan2(eAngY, eAngX));

  if (sAng > eAng) {
    eAng += DOUBLE_PI;
  }

  return [ox, oy, l / c, sAng, eAng];
}

function normalRadian(angle) {
  angle %= DOUBLE_PI;

  if (angle < 0) {
    angle += DOUBLE_PI;
  }

  return angle;
} // @function formatNum(num: Number, digits?: Number): Number
// Returns the number `num` rounded to `digits` decimals, or to 5 decimals by default.


function formatNum(num, digits) {
  var pow = Math.pow(10, digits || 5);
  return Math.round(num * pow) / pow;
}

function wrapNum(x, range, includeMax) {
  var max = range[1],
      min = range[0],
      d = max - min;
  return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
} // @function bind(fn: Function, …): Function
// Returns a new function bound to the arguments passed, like [Function.prototype.bind](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
// Has a `L.bind()` shortcut.


function bind(fn, obj) {
  var slice = Array.prototype.slice;

  if (fn.bind) {
    return fn.bind.apply(fn, slice.call(arguments, 1));
  }

  var args = slice.call(arguments, 2);
  return function () {
    return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
  };
}

function getParamString(obj, existingUrl, uppercase) {
  var params = [];

  for (var i in obj) {
    params.push(encodeURIComponent(uppercase ? i.toUpperCase() : i) + '=' + encodeURIComponent(obj[i]));
  }

  return (!existingUrl || existingUrl.indexOf('?') === -1 ? '?' : '&') + params.join('&');
}

function template(str, data) {
  return str.replace(templateRe, function (str, key) {
    var value = data[key];

    if (value === undefined) {
      throw new Error('No value provided for variable ' + str);
    } else if (typeof value === 'function') {
      value = value(data);
    }

    return value;
  });
} // @function setOptions(obj: Object, options: Object): Object
// Merges the given properties to the `options` of the `obj` object, returning the resulting options. See `Class options`. Has an `BaseUtils.setOptions` shortcut.


function setOptions(obj, options) {
  if (!obj.hasOwnProperty('options')) {
    obj.options = obj.options ? Object.create(obj.options) : {};
  }

  for (var i in options) {
    obj.options[i] = options[i];
  }

  return obj.options;
}

function createOptions(options, optArray) {
  optArray.forEach(function (opt) {
    if (opt) {
      for (var i in opt) {
        if ((0, _CoreUtils.hasNotDefined)(options[i]) && !skipKeys[i]) {
          options[i] = opt[i];
        }
      }
    }
  });
  return options;
} // inspired by http://paulirish.com/2011/requestanimationframe-for-smart-animating/


function getPrefixed(name) {
  return window['webkit' + name] || window['moz' + name] || window['ms' + name];
}

var lastTime = 0; // fallback for IE 7-8

function timeoutDefer(fn) {
  var time = +new Date(),
      timeToCall = Math.max(0, 16 - (time - lastTime));
  lastTime = time + timeToCall;
  return _Browser["default"].phantomjs ? window.setTimeout(fn, timeToCall) : $T.setTimeout(fn, timeToCall);
}

var requestFn = $T.requestAnimationFrame || timeoutDefer,
    cancelFn = $T.cancelAnimationFrame || function (id) {
  $T.clearTimeout(id);
}; // @function requestAnimFrame(fn: Function, context?: Object, immediate?: Boolean): Number
// Schedules `fn` to be executed when the browser repaints. `fn` is bound to
// `context` if given. When `immediate` is set, `fn` is called immediately if
// the browser doesn't have native support for
// [`window.requestAnimationFrame`](https://developer.mozilla.org/docs/Web/API/window/requestAnimationFrame),
// otherwise it's delayed. Returns a request ID that can be used to cancel the request.


function requestAnimFrame(fn, context, immediate) {
  if (immediate && requestFn === timeoutDefer) {
    fn.call(context);
  } else {
    return requestFn.call(window, bind(fn, context));
  }
} // @function cancelAnimFrame(id: Number): undefined
// Cancels a previous `requestAnimFrame`. See also [window.cancelAnimationFrame](https://developer.mozilla.org/docs/Web/API/window/cancelAnimationFrame).


function cancelAnimFrame(id) {
  if (id) {
    cancelFn.call(window, id);
  }
} // @function throttle(fn: Function, time: Number, context: Object): Function
// Returns a function which executes function `fn` with the given scope `context`
// (so that the `this` keyword refers to `context` inside `fn`'s code). The function
// `fn` will be called no more than one time per given amount of `time`. The arguments
// received by the bound function will be any arguments passed when binding the
// function, followed by any arguments passed when invoking the bound function.
// Has an `L.bind` shortcut.


function throttle(fn, time, context) {
  var lock, args, wrapperFn, later, timeout;

  later = function () {
    // reset lock and call if queued
    lock = false;

    if (args) {
      wrapperFn.apply(context, args);
      args = false;
    }
  };

  wrapperFn = function () {
    if (lock) {
      // called too soon, queue to call later
      args = arguments;
    } else {
      // call and lock until later
      fn.apply(context, arguments);
      timeout = setTimeout(later, time);
      lock = true;
    }
  };

  wrapperFn.cancel = function () {
    clearTimeout(timeout);
    lock = args = false;
  };

  return wrapperFn;
}

function rebind(target, source) {
  var i = 1,
      n = arguments.length,
      method;

  while (++i < n) {
    target[method = arguments[i]] = _rebind(target, source, source[method]);
  }

  return target;
}

function _rebind(target, source, method) {
  return function () {
    var value = method.apply(source, arguments);
    return value === source ? target : value;
  };
}

function bindData(layers, dataArray, keyFunction) {
  var i,
      n = layers.length,
      m = dataArray.length,
      enterFeatures = [],
      exitLayers = [],
      updateLayers = [];
  var nodeByKeyValue = {},
      keyValues = [],
      keyValue,
      layer,
      datum;

  for (i = -1; ++i < n;) {
    layer = layers[i];
    keyValue = keyFunction ? keyFunction(layer.datum()) : i;
    nodeByKeyValue[keyValue] = layer;
    keyValues[i] = keyValue;
  }

  for (i = -1; ++i < m;) {
    datum = dataArray[i];
    keyValue = keyFunction ? keyFunction(datum) : i;
    layer = nodeByKeyValue[keyValue];

    if (!layer) {
      enterFeatures.push(datum);
    } else if (layer !== true) {
      layer.datum(datum);
      updateLayers.push(layer);
    }

    nodeByKeyValue[keyValue] = true;
  }

  for (i = -1; ++i < n;) {
    if (nodeByKeyValue[keyValues[i]] !== true) {
      exitLayers.push(layers[i]);
    }
  }

  return {
    update: updateLayers,
    enter: enterFeatures,
    exit: exitLayers
  };
}

function dispatch() {
  var dispatch = new d3_dispatch(),
      i = -1,
      n = arguments.length;

  while (++i < n) {
    dispatch[arguments[i]] = d3_dispatch_event(dispatch);
  }

  return dispatch;
}

;

function d3_dispatch() {}

d3_dispatch.prototype.on = function (type, listener) {
  var i = type.indexOf("."),
      name = "";

  if (i >= 0) {
    name = type.slice(i + 1);
    type = type.slice(0, i);
  }

  if (type) {
    return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener);
  }

  if (arguments.length === 2) {
    if (listener == null) {
      for (type in this) {
        if (this.hasOwnProperty(type)) {
          this[type].on(name, null);
        }
      }
    }

    return this;
  }
};

function d3_dispatch_event(dispatch) {
  var listeners = [],
      listenerByName = new _vMap["default"]();

  function event() {
    var z = listeners,
        i = -1,
        n = z.length,
        l;

    while (++i < n) {
      if (l = z[i].on) {
        l.apply(this, arguments);
      }
    }

    return dispatch;
  }

  event.on = function (name, listener) {
    var l = listenerByName.get(name),
        i;

    if (arguments.length < 2) {
      return l && l.on;
    }

    if (l) {
      l.on = null;
      listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));
      listenerByName.remove(name);
    }

    if (listener) {
      listeners.push(listenerByName.set(name, {
        on: listener
      }));
    }

    ;
    return dispatch;
  };

  return event;
}

function falseFn() {
  return false;
}

function trueFn() {
  return true;
}

function emptyFn() {}
/**
 * 把数组形式的categoryArray转化为字符串
 * @param array
 * @returns {string}
 */


function encodeCategoryArray(categoryArray) {
  if (!isArray(categoryArray)) {
    return categoryArray;
  }

  if (window.JSON) {
    return JSON['stringify'](categoryArray);
  } else {
    var output = '[';

    for (var i = -1; ++i < categoryArray.length;) {
      output += (i > 0 ? ',' : '') + '"' + categoryArray[i] + '"';
    }

    return output + ']';
  }
}
/**
 * 把字符串化的categoryArray转换成数组
 * @param  {[string]} categoryArrayStr [description]
 * @return {[array]}                  [description]
 */


function decodeCategoryArray(categoryArrayStr) {
  if (window.JSON) {
    return JSON['parse'](categoryArrayStr);
  } else {
    return eval('(' + categoryArrayStr + ')');
  }
}

function getTargetFillArray(length, fillFun) {
  if (length == null) {
    return;
  }

  if (fillFun == null) {
    return Array.apply(null, Array(length));
  }

  var newArray = [];

  for (var i = 0; i < length; i++) {
    newArray.push('');
  }

  return newArray.map(fillFun);
}

var BaseUtils = {
  dispatch: dispatch,
  rebind: rebind,
  throttle: throttle,
  requestAnimFrame: requestAnimFrame,
  cancelAnimFrame: cancelAnimFrame,
  getParamString: getParamString,
  template: template,
  setOptions: setOptions,
  createOptions: createOptions,
  formatNum: formatNum,
  wrapNum: wrapNum,
  bind: bind,
  initPaddingScale: initPaddingScale,
  toPng: toPng,
  getDomWidth: getDomWidth,
  getDomHeight: getDomHeight,
  makeTranslate: makeTranslate,
  makeTranslateWithPX: makeTranslateWithPX,
  makeTranslate3d: makeTranslate3d,
  clone: clone,
  date2int: date2int,
  int2date: int2date,
  object2date: object2date,
  log: log,
  getPercentValue: getPercentValue,
  accAdd: accAdd,
  accDiv: accDiv,
  accMul: accMul,
  dealFloatPrecision: dealFloatPrecision,
  niceValue: niceValue,
  objectToArray: objectToArray,
  toArray: toArray,
  pick: pick,
  includes: includes,
  getTextDimension: getTextDimension,
  splitText: splitText,
  splitAndShrinkText: splitAndShrinkText,
  shrinkText: shrinkText,
  getTextDimensionWithRotation: getTextDimensionWithRotation,
  getTextDimRotated: getTextDimRotated,
  getEllipsisText: getEllipsisText,
  isArray: isArray,
  indexOf: indexOf,
  startsWith: startsWith,
  endsWith: endsWith,
  cssNormalization: cssNormalization,
  reformCssArray: reformCssArray,
  rectSubPixelOpt: rectSubPixelOpt,
  lineSubPixelOpt: lineSubPixelOpt,
  toFront: toFront,
  toBack: toBack,
  containsRect: containsRect,
  rectangleOverlapped: rectangleOverlapped,
  outsideRect: outsideRect,
  isValidRect: isValidRect,
  lineRect: lineRect,
  containsPoint: containsPoint,
  setTextStyle: setTextStyle,
  domRotate: domRotate,
  makeValueInRange: makeValueInRange,
  getValueInDomain: getValueInDomain,
  toRadian: toRadian,
  toDegree: toDegree,
  getFormatterFunction: getFormatterFunction,
  format: format,
  hasTouch: hasTouch,
  distance: distance,
  makeBounds: makeBounds,
  isImageMarker: isImageMarker,
  isNullMarker: isNullMarker,
  getDefaultMarkerSymbol: getDefaultMarkerSymbol,
  getArcPoint: getArcPoint,
  getTextWrapDimension: getTextWrapDimension,
  stamp: stamp,
  splitWords: splitWords,
  trim: trim,
  extend: extend,
  setDomBackground: setDomBackground,
  getArcByPoint: getArcByPoint,
  calculateAutoMinMaxAndGap: calculateAutoMinMaxAndGap,
  hasChn: hasChn,
  paddingConvertWithScale: paddingConvertWithScale,
  convertToREMUseDefault16PX: convertToREMUseDefault16PX,
  getComputedStyle: getComputedStyle,
  computeArc: computeArc,
  normalRadian: normalRadian,
  bindData: bindData,
  falseFn: falseFn,
  trueFn: trueFn,
  emptyFn: emptyFn,
  calculateFontSizeWithScale: calculateFontSizeWithScale,
  decodeCategoryArray: decodeCategoryArray,
  encodeCategoryArray: encodeCategoryArray,
  getTextBBoxWithRotation: getTextBBoxWithRotation,
  _mutateMobileFlowFontStyle: _mutateMobileFlowFontStyle,
  getTargetFillArray: getTargetFillArray,
  // 用extend WS 认不出来真是烦
  setTimeout: $T.setTimeout,
  clearTimeout: $T.clearTimeout,
  setInterval: $T.setInterval,
  clearInterval: $T.clearInterval,
  requestAnimationFrame: $T.requestAnimationFrame,
  cancelAnimationFrame: $T.cancelAnimationFrame
};
var _default = BaseUtils;
exports["default"] = _default;

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by eason on 15/5/4.
 */
var _default = {
  // 深浅色主题
  DARK: 'dark',
  LIGHT: 'light',
  BLANK_VALUE_PERCENTAGE: '\xa0\xa0',
  INSTANCES_KEY: 'vancharts_index_',
  SELECT_ANIMATION: 'select',
  UPDATE_EXIT_ENTER_ANIMATION: 'update_exit_enter',
  // 选中样式动画
  SELECT_STYLE_ANIMATION: 'select_style',
  CHART_HIDE: 'vancharts-chart-hide',
  EXPORT_HIDE: 'vancharts-export-hide',
  //区域类型闪烁动画类型
  SCALE_EXPAND_ANIMATION: "scale_expand",
  SCALE_MINIFY_ANIMATION: "scale_minify",
  //坐标系类型
  GEO: 'geographic_co_sys',
  PLANE: 'plane_co_sys',
  // switch style
  BUTTON: 'button',
  CAROUSEL: 'carousel',
  NO_ARROW: 'no_arrow',
  //图表类型
  BAR_CHART: 'bar',
  //条形图
  COLUMN_CHART: 'column',
  //柱形图
  LINE_CHART: 'line',
  //折线图
  AREA_CHART: 'area',
  //面积图
  PIE_CHART: 'pie',
  //饼图
  MULTIPIE_CHART: 'multiPie',
  //多层饼图
  TREEMAP_CHART: 'treeMap',
  //矩形树图
  SCATTER_CHART: 'scatter',
  //散点图
  BUBBLE_CHART: 'bubble',
  //气泡图
  FORCE_BUBBLE_CHART: 'forceBubble',
  //力学气泡图
  GANTT_CHART: 'gantt',
  // 甘特图
  GAUGE_CHART: 'gauge',
  //仪表盘
  POINTER_GAUGE: 'pointer',
  //指针仪表盘
  POINTER_SEMI_GAUGE: 'pointer_semi',
  SLOT_GAUGE: 'slot',
  //刻度槽仪表盘
  THERMOMETER_GAUGE: 'thermometer',
  //试管仪表盘
  RING_GAUGE: 'ring',
  //圆环仪表盘
  RADAR_CHART: 'radar',
  //雷达图
  COLUMN_RADAR: 'columnRadar',
  LINE_RADAR: 'lineRadar',
  POINT_MAP: 'pointMap',
  AREA_MAP: 'areaMap',
  HEAT_MAP: 'heatMap',
  LINE_MAP: 'lineMap',
  FUNNEL_CHART: 'funnel',
  //漏斗图
  WORD_CLOUD_CHART: 'wordCloud',
  //词云
  STRUCTURE_CHART: 'structure',
  //框架图
  MULTI_CHARTS: 'multiCharts',
  // 组合图
  BOX_CHART: 'box',
  // 箱型图
  // 标记点的默认大小
  MARKER_RADIUS: 3.5,
  // 所有支持大数据模式的图表类型集合
  LARGE_CHART_TYPE: {
    line: true,
    area: true,
    scatter: true,
    bubble: true,
    gantt: true,
    pointMap: true,
    areaMap: true
  },
  VANCHART: 'vanchart',
  //工具栏的icon类型
  FULL_SCREEN_ICON: 'fullScreen',
  EXPORT_ICON: 'toImage',
  SORT: 'sort',
  MENU_ICON: 'vancharts-icon-menu',
  REFRESH_ICON: 'vancharts-icon-refresh',
  TOOLBAR_ICON_SIZE: 32,
  AXIS_GROUP: 'vanchart-axis-group',
  //位置相关的常量
  BOTTOM: 'bottom',
  TOP: 'top',
  LEFT: 'left',
  RIGHT: 'right',
  RIGHT_TOP: 'right-top',
  RIGHT_BOTTOM: 'right-bottom',
  LEFT_TOP: 'left-top',
  LEFT_BOTTOM: 'left-bottom',
  //动画的方向
  LEFT_TO_RIGHT: 'left-to-right',
  RIGHT_TO_LEFT: 'right-to-left',
  BOTTOM_TO_TOP: 'bottom-to-top',
  TOP_TO_BOTTOM: 'top-to-bottom',
  //图的排序的状态
  DISORDER: 'disorder',
  DESCENDING: 'descending',
  ASCENDING: 'ascending',
  //标记点类型
  CIRCLE: 'circle',
  SQUARE: 'square',
  DIAMOND: 'diamond',
  TRIANGLE: 'triangle',
  STAR: 'star',
  LOCATION: 'location',
  SYMBOL_AUTO: 'auto',
  CIRCLE_HOLLOW: 'circle_hollow',
  SQUARE_HOLLOW: 'square_hollow',
  DIAMOND_HOLLOW: 'diamond_hollow',
  TRIANGLE_HOLLOW: 'triangle_hollow',
  //图例的另外三种类型
  NORMAL_ICON: 'normal-legend-icon',
  //一般的图例
  PIE_ICON: 'pie-legend-icon',
  DONUT_ICON: 'donut-legend-icon',
  BUBBLE_ICON: 'bubble-legend-icon',
  SCATTER_ICON: 'scatter-legend-icon',
  TREEMAP_ICON: 'treeMap-legend-icon',
  NULL_MARKER: 'null-marker-legend-icon',
  // 图例位于上下方时的排列方式
  FLOW: 'flow',
  // 流式
  // 图例默认不透明度
  DEFAULT_OPACITY: 1,
  // 鼠标悬浮，图例与图形的不透明度
  HOVER_OPACITY: 0.2,
  SOLID: 'solid',
  DASHED: 'dashed',
  DASH_ARRAY: {
    solid: 'none',
    // 0,0 bug IE9; 0 bug phantom;
    dashed: '6,6'
  },
  //玫瑰图的不同形状
  SAME_ARC: 'sameArc',
  //所有扇形弧长相同
  DIFFERENT_ARC: 'differentArc',
  //所有扇形弧长不相等
  //标签的位置
  AUTO: 'auto',
  OUTSIDE: 'outside',
  INSIDE: 'inside',
  CENTER: 'center',
  //标签竖排判断标准
  OVERLAP_RATE: 0.15,
  EXCEED_RATE: 0.15,
  FONTSIZE_RATE: 2,
  // 渐变风格的名字
  STYLE_GRADUAL: 'gradual',
  // rgb渐变
  STYLE_NORMAL: 'normal',
  STYLE_CUSTOM: 'custom',
  // 自定义渐变
  //仪表盘布局
  HORIZONTAL_LAYOUT: 'horizontal',
  VERTICAL_LAYOUT: 'vertical',
  //雷达图底边
  POLYGON_RADAR: 'polygon',
  CIRCLE_RADAR: 'circle',
  //size是通过气泡的半径还是面积表现出来
  SIZE_BY_AREA: 'area',
  SIZE_BY_WIDTH: 'width',
  GRADUAL_LIGHTER: 'lighter',
  GRADUAL_DARKER: 'darker',
  //系列的几个状态
  STATE_TO_DROP: 'to-drop',
  STATE_DROPPED: 'dropped',
  STATE_TO_SHOW: 'to-show',
  STATE_SHOW: 'show',
  // trend line
  EXPONENTIAL: 'exponential',
  LINEAR: 'linear',
  LOGARITHMIC: 'logarithmic',
  POLYNOMIAL: 'polynomial',
  // Axis arrow path map
  AXIS_ARROW_PATH: {
    // Towards the left
    left: "M-10, 0 L-2, 4 L-6, 0 L-2, -4 L-10, 0",
    // Towards the right
    right: "M2,-4 L10,0 L2,4 L6,0 L2,-4",
    // upwards
    up: "M-4,-2 L0,-10 L4,-2 L0,-6 L-4,-2",
    // downwards
    down: "M-4, 2 L0, 10, L4, 2 L0, 6 L-4, 2"
  },
  DIRECTION_LEFT: 2,
  DIRECTION_RIGHT: 4,
  DIRECTION_UP: 8,
  DIRECTION_DOWN: 16,
  STAGES: {
    NORMAL: 0,
    // init or canceled
    SELECT: 1,
    // touchMove to find target
    KEEP: 2,
    // no auto hide, keep showing specific target
    ZOOM: 3
  },
  EFFECT_KEY: "__effect__",
  AUTO_REFRESH: "auto_refresh",
  EMPTY_DATA_DOMAIN: [0, 100],
  DEFAULT_PERCENT_INTERVAL: 0.25,
  DEFAULT_LOG_INTERVAL: 1,
  MIN_TIME_AXIS_INTERVAL: 1000,
  // min date step = 1 second
  MAX_TICKS_NUM: 1000,
  GANTT_CANVAS_WIDTH: 4000,
  GANTT_MAX_CANVAS_NUM: 15,
  //新数据过来的时候刷新的类型
  INCREMENT_REFRESH: 'increment',
  INCREMENT_TIP_REFRESH: 'tip_increment',
  OVERALL_REFRESH: 'overall'
};
exports["default"] = _default;

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports._getSvgTextDim = _getSvgTextDim;
exports._getCanvasTextDim = _getCanvasTextDim;
exports.getTitleText = getTitleText;
exports._getTextDimension = _getTextDimension;
exports.isSupportSVG = isSupportSVG;
exports.supportFillFilter = supportFillFilter;
exports.convertREMtoPX = convertREMtoPX;
exports.getTextHeight = getTextHeight;
exports.getDefaultFontSize = getDefaultFontSize;
exports._getHtmlTextDim = _getHtmlTextDim;
exports.createCanvas = createCanvas;
exports.svg2zr = svg2zr;
exports.getTransPrefix = void 0;

var _CoreUtils = __webpack_require__(3);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _HtmlUtils = __webpack_require__(66);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var getTransPrefix = function () {
  return "-webkit-transform" in document.body.style ? "-webkit-" : "-moz-transform" in document.body.style ? "-moz-" : "-ms-transform" in document.body.style ? "-ms-" : "";
};

exports.getTransPrefix = getTransPrefix;
var CANVAS_CTX, SVG_CONTAINER, DIV_CONTAINER;
var defaultFontSize;

function _getSvgTextDim(text, style) {
  SVG_CONTAINER.style.display = "";
  var node = SVG_CONTAINER._textNode;
  node.textContent = text;
  node.style.cssText = '';

  for (var property in style) {
    if (typeof style[property] != "function" && property != 'color') {
      node.style[property] = style[property];
    }
  }

  var box = node.getBBox();
  var size = {
    width: box.width,
    height: box.height
  };
  SVG_CONTAINER.style.display = "none";
  return size;
}

function _getCanvasTextDim(text, style) {
  _init();

  var fontSize = convertREMtoPX(style.fontSize) + 'px';
  var fontStyle = style['fontStyle'] || '';
  var fontWeight = style['fontWeight'] || '';
  var fontFamily = style['fontFamily'] || '';
  var det = fontStyle === 'italic' ? 5 : 0; // @CHART-9301: .SF这样的特殊字体导致样式解析失败从而使用默认样式, 这边给fontFamily外包裹一层"", 保证可以正常解析

  if (fontFamily.indexOf(",") === -1) {
    fontFamily = '"' + fontFamily + '"';
  }

  CANVAS_CTX.font = fontStyle + ' ' + fontWeight + ' ' + fontSize + ' ' + fontFamily;
  var width = CANVAS_CTX.measureText(text).width + det || 0;
  var height = getTextHeight(style);
  var dims = {
    width: width,
    height: height
  };

  if (style['writing-mode'] && false) {
    dims = getTextDimRotated(dims, 90);
  }

  return dims;
} // todo 重复代码


function toRadian(degree) {
  return Math.PI * (degree / 180);
} // todo 重复代码


function getTextDimRotated(dim, rotation) {
  var angle = Math.abs(toRadian(rotation || 0));
  var width = dim.width * Math.cos(angle) + dim.height * Math.sin(angle);
  var height = dim.width * Math.sin(angle) + dim.height * Math.cos(angle);
  return {
    width: width,
    height: height
  };
}

function getPlainText(val) {
  _init();

  DIV_CONTAINER.style.cssText = 'visibility: hidden;';
  DIV_CONTAINER.innerHTML = val;

  if (DIV_CONTAINER.textContent) {
    return DIV_CONTAINER.textContent;
  }

  return DIV_CONTAINER.innerText;
}

function getTitleText(option) {
  var title = option.title;

  if (title.text && title.useHtml) {
    return getPlainText(title.text);
  }

  return title.text || '';
}

function _getTextDimension(text, style, useHtml) {
  _init();

  if ((0, _CoreUtils.isEmpty)(text)) {
    return {
      width: 0,
      height: 0
    };
  }

  if (false) {}

  if (useHtml || !isSupportSVG()) {
    return _getHtmlTextDim(text, style, useHtml);
  } // fixME: MOBILE-22247 IOS下默认字体, 使用canvas或者html计算得到的文字尺寸都比svg的偏小
  // FR-APP 中webview的ua没有safari, 这边改为判断设备


  return style['writing-mode'] ? _getSvgTextDim(text, style) : _getCanvasTextDim(text, style);
}

function isSupportSVG() {
  return !!window.SVGSVGElement;
}

function supportFillFilter() {
  return isSupportSVG() || false;
} //组件间距代码里写rem，然后根据浏览器的一倍字体行高转化成px，之后参与布局计算
//计算字体高度
//字体不需要计算缩放比例，前台拿到的就是缩放后的字体大小


function convertREMtoPX(size) {
  size += '';

  if (size.indexOf('rem') != -1) {
    size = parseFloat(size);
    size = size * getDefaultFontSize();
  } else if (size.indexOf('pt') != -1) {
    size = parseFloat(size) * 4 / 3;
  } else {
    size = parseFloat(size);
  }

  return size;
}

function getTextHeight(style) {
  var fontSize = style.fontSize || '0.75rem';
  return convertREMtoPX(fontSize);
}

function getDefaultFontSize() {
  if (false) {}

  if ((0, _CoreUtils.hasNotDefined)(defaultFontSize)) {
    var style = document.documentElement.currentStyle || document.defaultView.getComputedStyle(document.documentElement);
    defaultFontSize = _getDefaultFontSizeToPX(style.fontSize);
  }

  return defaultFontSize;
}

function _getDefaultFontSizeToPX(size) {
  if (size.indexOf('px') != -1) {
    return parseFloat(size);
  }

  if (size.indexOf('pt') != -1) {
    return parseFloat(size) * 4 / 3;
  }

  return 16;
}

function _getHtmlTextDim(text, style, useHtml) {
  _init(); // todo CHART-15855，div标签会格式化空格，多值提示会有空格计算
  // todo init中标签改成pre空格计算时也会被格式化，需要进一步研究原因，暂时定位到whiteSpace为nowrap和pre标签冲突，但这里不设置whiteSpace也无法生效


  if (isSupportSVG()) {
    DIV_CONTAINER.style.cssText = '';
    DIV_CONTAINER.style.visibility = "hidden";
    DIV_CONTAINER.style.display = '';
  } else {
    if (!DIV_CONTAINER._hide) {
      // CHART-1923:IE8下频繁修改DIV_CONTAINER的样式，导致渲染卡顿
      DIV_CONTAINER.style.cssText = 'visibility:hidden;';
      DIV_CONTAINER._hide = true;
    } // CHART-2111，CHART-3350
    // IE8下面由于重复设置visibility会导致重绘影响性能，再判断_hide后不设置visibility的同时，每次还要把旧的影响计算结果的属性去掉


    DIV_CONTAINER.style.writingMode = "";
    DIV_CONTAINER.style.width = "";
    DIV_CONTAINER.style.height = "";
  } // @CHART-1966 标题使用html渲染后，图表切换从第二个图表开始渲染错位，结合上面的1923来看：
  // 既要保证低版本下不频繁触发重绘，又要保证每次计算时的position为absolute让其脱离文档流(因为之前的某个ele的style:position会将其覆盖)，不然再算出的宽度就不对了


  DIV_CONTAINER.style.whiteSpace = "nowrap";
  DIV_CONTAINER.style.position = 'absolute';

  for (var property in style) {
    if (typeof style[property] != "function" && property != 'color') {
      DIV_CONTAINER.style[property] = style[property];
    }
  }

  if (useHtml === false) {
    DIV_CONTAINER.textContent ? DIV_CONTAINER.textContent = text : DIV_CONTAINER.innerText = text;
  } else {
    DIV_CONTAINER.innerHTML = text;
  } // offsetWidth和offsetHeight获取的是四舍五入后的元素宽高，
  // getBoundingClientRect返回的DomRect对象中width和offsetWidth内容一致，而且是更精确的小数值
  // 但是IE8浏览器中不支持width和height，因此使用Rect中的right、left来计算代替


  var rect = DIV_CONTAINER.getBoundingClientRect();
  var width = Math.ceil(rect.right - rect.left);
  var height = Math.ceil(rect.bottom - rect.top);
  var size = {
    width: width,
    height: height
  };

  if (isSupportSVG()) {
    DIV_CONTAINER.style.display = 'none';
  }

  return size;
}

function createCanvas() {
  if (false) {} else {
    var canvas = document.createElement(window.VAN_CANVAS || 'canvas');
    window.VanCanvasManager && VanCanvasManager.initElement(canvas);
    return canvas;
  }
}

var _inited = false;

function _init() {
  if (_inited) {
    return;
  }

  _inited = true;

  if (false) { var c; } else {
    DIV_CONTAINER = document.createElement("div");
    document.body.appendChild(DIV_CONTAINER);

    if (isSupportSVG()) {
      var _c = createCanvas();

      _c.style.cssText = 'position: absolute; top: -10000px; left: 0; visibility: hidden;';
      document.body.appendChild(_c);
      CANVAS_CTX = _c.getContext('2d');
      SVG_CONTAINER = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
      SVG_CONTAINER.style.width = 0;
      SVG_CONTAINER.style.height = 0;
      document.body.appendChild(SVG_CONTAINER);
      var node = document.createElementNS('http://www.w3.org/2000/svg', 'text');
      SVG_CONTAINER.appendChild(node);
      SVG_CONTAINER._textNode = node;
      SVG_CONTAINER.style.visibility = "hidden";
    }
  }
}

function svg2zr(svgStyle) {
  var style = {};

  var fillOpacity = _BaseUtils["default"].pick(svgStyle['fill-opacity'], 1);

  style.fill = svgStyle.fill && svgStyle.fill != 'none' ? _ColorUtils["default"].mixColorWithAlpha(svgStyle.fill, fillOpacity) : null;

  var strokeOpacity = _BaseUtils["default"].pick(svgStyle['stroke-opacity'], 1);

  style.stroke = svgStyle.stroke && svgStyle.stroke != 'none' ? _ColorUtils["default"].mixColorWithAlpha(svgStyle.stroke, strokeOpacity) : null;
  style.lineWidth = _BaseUtils["default"].pick(svgStyle['stroke-width'], 0);
  return style;
}

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isNumberValue = isNumberValue;
exports.isEmpty = isEmpty;
exports.isNull = isNull;
exports.isNumber = isNumber;
exports.hasNotDefined = hasNotDefined;
exports.hasDefined = hasDefined;
exports.isEmptyObj = isEmptyObj;
exports.fixDivisor = fixDivisor;

function isNumberValue(value) {
  return !isEmpty(value) && !isNaN(value);
}

function isEmpty(value) {
  var result = value === "" || value === null || value === undefined;
  return result;
}

function isNull(v) {
  return v == undefined || v == null;
}

function isNumber(val) {
  return typeof val === 'number' && !isNaN(val);
} // null == undefined 为 true


function hasNotDefined(value) {
  return value === null || value === undefined;
}

function hasDefined(value) {
  return !hasNotDefined(value);
}

function isEmptyObj(obj) {
  return Object.keys(obj).length === 0;
}

function fixDivisor(value) {
  return isNumber(value) && value !== 0 ? value : 1;
}

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getComponent = exports.getComponents = exports.register = exports.ComponentCst = exports.ComponentsOrder = void 0;
var ComponentsOrder = ['tooltip', 'tools', 'title', 'dTools', 'geo', 'rangeLegend', 'legend', 'zoom', 'dataSheet', 'xAxis', 'yAxis', 'polar', 'angleAxis', 'radiusAxis', 'gaugeAxis', 'value', 'category', 'multiCategory', 'datetime', 'levelBar', 'processes', 'timeAxis', 'moreLabel', 'crossLine', 'plotScroll', 'pieIndicator'];
exports.ComponentsOrder = ComponentsOrder;
var ComponentCst = {
  TOOLTIP_COMPONENT: 'tooltip',
  TOOLBAR_COMPONENT: 'tools',
  GEO_COMPONENT: 'geo',
  DRILL_TOOLS: 'dTools',
  TITLE_COMPONENT: 'title',
  RANGE_LEGEND_COMPONENT: 'rangeLegend',
  INTERVAL_RANGE_LEGEND: 'intervalRangeLegend',
  GradientRangeLegend: 'gradientRangeLegend',
  LEGEND_COMPONENT: 'legend',
  DATA_SHEET_COMPONENT: 'dataSheet',
  ZOOM_COMPONENT: 'zoom',
  X_AXIS_COMPONENT: 'xAxis',
  Y_AXIS_COMPONENT: 'yAxis',
  POLAR_COMPONENT: 'polar',
  RADIUS_AXIS_COMPONENT: 'radiusAxis',
  ANGLE_AXIS_COMPONENT: 'angleAxis',
  GAUGE_AXIS_COMPONENT: 'gaugeAxis',
  VALUE_AXIS_COMPONENT: 'value',
  CATEGORY_AXIS_COMPONENT: 'category',
  DATE_AXIS_COMPONENT: 'datetime',
  LEVELBAR: 'levelBar',
  PROCESSES: 'processes',
  TIMEAXIS: 'timeAxis',
  MORELABEL_COMPONENT: 'moreLabel',
  MULTI_CATEGORY_AXIS_COMPONENT: 'multiCategory',
  CROSS_LINE: 'crossLine',
  PLOT_SCROLL: 'plotScroll',
  PIE_INDICATOR: 'pieIndicator'
};
exports.ComponentCst = ComponentCst;

var _registeredComponents = Object.create(null);

var register = function (name, Compo) {
  return _registeredComponents[name] = Compo;
};

exports.register = register;

var getComponents = function () {
  return _registeredComponents;
};

exports.getComponents = getComponents;

var getComponent = function (name) {
  return _registeredComponents[name];
};

exports.getComponent = getComponent;

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by eason on 15/6/30.
 * some of the following methods are borrowed from zrender
 */
//Copyright (c) 2013, Baidu Inc.
//    All rights reserved.
//
//    Redistribution and use of this software in source and binary forms, with or
//    without modification, are permitted provided that the following conditions
//are met:
//
//    Redistributions of source code must retain the above copyright notice, this
//list of conditions and the following disclaimer.
//
//    Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//and/or other materials provided with the distribution.
//
//    Neither the name of Baidu Inc. nor the names of its contributors may be used
//to endorse or promote products derived from this software without specific
//prior written permission of Baidu Inc.
//
//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
//ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
//ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
var _nameColors = {
  aliceblue: '#f0f8ff',
  antiquewhite: '#faebd7',
  aqua: '#0ff',
  aquamarine: '#7fffd4',
  azure: '#f0ffff',
  beige: '#f5f5dc',
  bisque: '#ffe4c4',
  black: '#000',
  blanchedalmond: '#ffebcd',
  blue: '#00f',
  blueviolet: '#8a2be2',
  brown: '#a52a2a',
  burlywood: '#deb887',
  cadetblue: '#5f9ea0',
  chartreuse: '#7fff00',
  chocolate: '#d2691e',
  coral: '#ff7f50',
  cornflowerblue: '#6495ed',
  cornsilk: '#fff8dc',
  crimson: '#dc143c',
  cyan: '#0ff',
  darkblue: '#00008b',
  darkcyan: '#008b8b',
  darkgoldenrod: '#b8860b',
  darkgray: '#a9a9a9',
  darkgrey: '#a9a9a9',
  darkgreen: '#006400',
  darkkhaki: '#bdb76b',
  darkmagenta: '#8b008b',
  darkolivegreen: '#556b2f',
  darkorange: '#ff8c00',
  darkorchid: '#9932cc',
  darkred: '#8b0000',
  darksalmon: '#e9967a',
  darkseagreen: '#8fbc8f',
  darkslateblue: '#483d8b',
  darkslategray: '#2f4f4f',
  darkslategrey: '#2f4f4f',
  darkturquoise: '#00ced1',
  darkviolet: '#9400d3',
  deeppink: '#ff1493',
  deepskyblue: '#00bfff',
  dimgray: '#696969',
  dimgrey: '#696969',
  dodgerblue: '#1e90ff',
  firebrick: '#b22222',
  floralwhite: '#fffaf0',
  forestgreen: '#228b22',
  fuchsia: '#f0f',
  gainsboro: '#dcdcdc',
  ghostwhite: '#f8f8ff',
  gold: '#ffd700',
  goldenrod: '#daa520',
  gray: '#808080',
  grey: '#808080',
  green: '#008000',
  greenyellow: '#adff2f',
  honeydew: '#f0fff0',
  hotpink: '#ff69b4',
  indianred: '#cd5c5c',
  indigo: '#4b0082',
  ivory: '#fffff0',
  khaki: '#f0e68c',
  lavender: '#e6e6fa',
  lavenderblush: '#fff0f5',
  lawngreen: '#7cfc00',
  lemonchiffon: '#fffacd',
  lightblue: '#add8e6',
  lightcoral: '#f08080',
  lightcyan: '#e0ffff',
  lightgoldenrodyellow: '#fafad2',
  lightgray: '#d3d3d3',
  lightgrey: '#d3d3d3',
  lightgreen: '#90ee90',
  lightpink: '#ffb6c1',
  lightsalmon: '#ffa07a',
  lightseagreen: '#20b2aa',
  lightskyblue: '#87cefa',
  lightslategray: '#789',
  lightslategrey: '#789',
  lightsteelblue: '#b0c4de',
  lightyellow: '#ffffe0',
  lime: '#0f0',
  limegreen: '#32cd32',
  linen: '#faf0e6',
  magenta: '#f0f',
  maroon: '#800000',
  mediumaquamarine: '#66cdaa',
  mediumblue: '#0000cd',
  mediumorchid: '#ba55d3',
  mediumpurple: '#9370d8',
  mediumseagreen: '#3cb371',
  mediumslateblue: '#7b68ee',
  mediumspringgreen: '#00fa9a',
  mediumturquoise: '#48d1cc',
  mediumvioletred: '#c71585',
  midnightblue: '#191970',
  mintcream: '#f5fffa',
  mistyrose: '#ffe4e1',
  moccasin: '#ffe4b5',
  navajowhite: '#ffdead',
  navy: '#000080',
  oldlace: '#fdf5e6',
  olive: '#808000',
  olivedrab: '#6b8e23',
  orange: '#ffa500',
  orangered: '#ff4500',
  orchid: '#da70d6',
  palegoldenrod: '#eee8aa',
  palegreen: '#98fb98',
  paleturquoise: '#afeeee',
  palevioletred: '#d87093',
  papayawhip: '#ffefd5',
  peachpuff: '#ffdab9',
  peru: '#cd853f',
  pink: '#ffc0cb',
  plum: '#dda0dd',
  powderblue: '#b0e0e6',
  purple: '#800080',
  red: '#f00',
  rosybrown: '#bc8f8f',
  royalblue: '#4169e1',
  saddlebrown: '#8b4513',
  salmon: '#fa8072',
  sandybrown: '#f4a460',
  seagreen: '#2e8b57',
  seashell: '#fff5ee',
  sienna: '#a0522d',
  silver: '#c0c0c0',
  skyblue: '#87ceeb',
  slateblue: '#6a5acd',
  slategray: '#708090',
  slategrey: '#708090',
  snow: '#fffafa',
  springgreen: '#00ff7f',
  steelblue: '#4682b4',
  tan: '#d2b48c',
  teal: '#008080',
  thistle: '#d8bfd8',
  tomato: '#ff6347',
  turquoise: '#40e0d0',
  violet: '#ee82ee',
  wheat: '#f5deb3',
  white: '#fff',
  whitesmoke: '#f5f5f5',
  yellow: '#ff0',
  yellowgreen: '#9acd32'
};
var _cache = {};
var _emptyDefault = [0, 0, 0, 1];
var colorRegExp = /^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+)?)%?\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+)?)%?\s*\))\s*$/i;

function trim(color) {
  return String(color).replace(/\s+/g, '');
} // 调整值区间


function adjust(value, region) {
  if (value <= region[0]) {
    value = region[0];
  } else if (value >= region[1]) {
    value = region[1];
  }

  return value;
} // 数组映射


function map(array, fun) {
  if (typeof fun !== 'function') {
    throw new TypeError();
  }

  var len = array ? array.length : 0;

  for (var i = 0; i < len; i++) {
    array[i] = fun(array[i]);
  }

  return array;
}
/**
 * 把颜色转化成数组数据，用于计算
 * @param color 颜色
 */


function getRGBAColorArray(color) {
  if (_nameColors[color]) {
    color = _nameColors[color];
  }

  if (_cache[color]) {
    return _cache[color].slice();
  }

  color = trim(color);

  if (/^#[\da-f]{3}$/i.test(color)) {
    color = parseInt(color.slice(1), 16);
    var r = (color & 0xf00) << 8;
    var g = (color & 0xf0) << 4;
    var b = color & 0xf;
    color = '#' + ((1 << 24) + (r << 4) + r + (g << 4) + g + (b << 4) + b).toString(16).slice(1);
  }

  var r = color.match(colorRegExp); // 2017.05.05 Jeffrey
  // to avoid "Cannot read property '2' of null" exception
  // default is black [0,0,0,1]
  // if anywhere's color is strangely black,
  // comment here, then you can trace the bug

  if (!r) {
    _cache[color] = _emptyDefault;
    return _emptyDefault.slice();
  }

  var d;
  var a;
  var data = [];
  var rgb;

  if (r[2]) {
    // #rrggbb
    d = r[2].replace('#', '').split('');
    rgb = [d[0] + d[1], d[2] + d[3], d[4] + d[5]];
    data = map(rgb, function (c) {
      return adjust(parseInt(c, 16), [0, 255]);
    });
  } else if (r[4]) {
    // rgb rgba
    var rgba = r[4].split(',');
    a = rgba[3];
    rgb = rgba.slice(0, 3);
    data = map(rgb, function (c) {
      c = Math.floor(c.indexOf('%') > 0 ? parseInt(c, 0) * 2.55 : c);
      return adjust(c, [0, 255]);
    });

    if (typeof a !== 'undefined') {
      data.push(adjust(parseFloat(a), [0, 1]));
    }
  } //统一rgba的格式


  if (data.length === 3) {
    data.push(1);
  }

  _cache[color] = data.slice();
  return data;
}

function toColor(data, format) {
  format = format || 'rgb';

  if (data && (data.length === 3 || data.length === 4)) {
    data = map(data, function (c) {
      return c > 1 ? Math.ceil(c) : c;
    });

    if (format.indexOf('hex') > -1) {
      return '#' + ((1 << 24) + (data[0] << 16) + (data[1] << 8) + +data[2]).toString(16).slice(1);
    } else if (format.indexOf('hs') > -1) {
      var sx = map(data.slice(1, 3), function (c) {
        return c + '%';
      });
      data[1] = sx[0];
      data[2] = sx[1];
    }

    if (format.indexOf('a') > -1) {
      if (data.length === 3) {
        data.push(1);
      }

      data[3] = adjust(data[3], [0, 1]);
      return format + '(' + data.slice(0, 4).join(', ') + ')';
    }

    return format + '(' + data.slice(0, 3).join(', ') + ')';
  }
}

function getHighLightColor(color) {
  var rgba = getRGBAColorArray(color);
  var tmp = [];

  for (var i = 0; i < 3; i++) {
    var x = rgba[i];

    if (x <= 128) {
      tmp.push(adjust(x - (255 - x) * (255 - 2 * x) / (2 * x), [0, 255]));
    } else {
      tmp.push(adjust(x + x * (2 * x - 255) / (2 * (255 - x)), [0, 255]));
    }
  }

  var result = [];

  for (i = 0; i < 3; i++) {
    result.push(Math.round(0.65 * rgba[i] + 0.35 * tmp[i]));
  }

  return toColor(result, 'rgb');
}

function getColorWithDivider(color, divider) {
  var rgba = getRGBAColorArray(color);
  rgba.length = 3;

  for (var i = 0; i < 3; i++) {
    rgba[i] = parseInt(rgba[i] / divider, 10);
  }

  return toColor(rgba, 'rgb');
}

function getClickColor(color) {
  var rgba = getRGBAColorArray(color);
  rgba.length = 3;

  for (var i = 0; i < 2; i++) {
    rgba[i] = parseInt(rgba[i] * 0.95, 10);
  }

  return toColor(rgba, 'rgb');
}

function mixColorWithAlpha(color, alpha) {
  var rgba = getRGBAColorArray(color);
  rgba[3] = alpha;
  return toColor(rgba, 'rgba');
}

function mixColorWithHSB(color, detH, detS, detB) {
  var rgba = getRGBAColorArray(color);
  var hsb = rgb2hsb(rgba[0], rgba[1], rgba[2]);
  hsb[0] += detH;
  hsb[1] += detS;
  hsb[2] += detB;
  var rgb = hsb2rgb(hsb[0], hsb[1], hsb[2]);
  return toColor(rgb, 'rgb');
}

function hsb2rgb(hue, saturation, brightness) {
  saturation = Math.min(1, Math.max(0, saturation));
  brightness = Math.min(1, Math.max(0, brightness));
  var r = 0,
      g = 0,
      b = 0;

  if (saturation === 0) {
    r = g = b = brightness * 255.0 + 0.5;
  } else {
    var h = (hue - Math.floor(hue)) * 6.0;
    var f = h - Math.floor(h);
    var p = brightness * (1.0 - saturation);
    var q = brightness * (1.0 - saturation * f);
    var t = brightness * (1.0 - saturation * (1.0 - f));

    switch (Math.floor(h)) {
      case 0:
        r = brightness * 255.0 + 0.5;
        g = t * 255.0 + 0.5;
        b = p * 255.0 + 0.5;
        break;

      case 1:
        r = q * 255.0 + 0.5;
        g = brightness * 255.0 + 0.5;
        b = p * 255.0 + 0.5;
        break;

      case 2:
        r = p * 255.0 + 0.5;
        g = brightness * 255.0 + 0.5;
        b = t * 255.0 + 0.5;
        break;

      case 3:
        r = p * 255.0 + 0.5;
        g = q * 255.0 + 0.5;
        b = brightness * 255.0 + 0.5;
        break;

      case 4:
        r = t * 255.0 + 0.5;
        g = p * 255.0 + 0.5;
        b = brightness * 255.0 + 0.5;
        break;

      case 5:
        r = brightness * 255.0 + 0.5;
        g = p * 255.0 + 0.5;
        b = q * 255.0 + 0.5;
        break;
    }
  }

  var rgb = [];
  rgb.push(Math.floor(r));
  rgb.push(Math.floor(g));
  rgb.push(Math.floor(b));
  return rgb;
}

function createColorsWithHsb(color, count) {
  color = color || 'blue';
  count = count || 1;
  var rgba = getRGBAColorArray(color);
  var hsb = rgb2hsb(rgba[0], rgba[1], rgba[2]);
  var result = [],
      h = hsb[0],
      s = hsb[1],
      b = hsb[2];

  for (var i = 0; i < count; i++) {
    var tmpS = s * (1 - i / count);
    var tmpB = b + i * (1 - b) / count;
    result.push(toColor(hsb2rgb(h, tmpS, tmpB)));
  }

  return result;
}

function rgb2hsb(r, g, b) {
  var hue, saturation, brightness;
  var hsbvals = [3];
  var cmax = r > g ? r : g;

  if (b > cmax) {
    cmax = b;
  }

  var cmin = r < g ? r : g;

  if (b < cmin) {
    cmin = b;
  }

  brightness = cmax / 255.0;

  if (cmax !== 0) {
    saturation = (cmax - cmin) / cmax;
  } else {
    saturation = 0;
  }

  if (saturation === 0) {
    hue = 0;
  } else {
    var redc = (cmax - r) / (cmax - cmin);
    var greenc = (cmax - g) / (cmax - cmin);
    var bluec = (cmax - b) / (cmax - cmin);

    if (r == cmax) {
      hue = bluec - greenc;
    } else if (g == cmax) {
      hue = 2.0 + redc - bluec;
    } else {
      hue = 4.0 + greenc - redc;
    }

    hue = hue / 6.0;

    if (hue < 0) {
      hue = hue + 1.0;
    }
  }

  hsbvals[0] = hue;
  hsbvals[1] = saturation;
  hsbvals[2] = brightness;
  return hsbvals;
}

function getColorOpacity(color) {
  return color && typeof color == 'string' && color.indexOf('rgba') != -1 ? getRGBAColorArray(color)[3] : 1;
} //没有a定义的话返回空


function getColorOpacityWithoutDefault(color) {
  return color && typeof color == 'string' && color.indexOf('rgba') != -1 ? getColorOpacity(color) : undefined;
}

function colorToHex(color) {
  return colorToHexAlpha(color).hex;
}

function colorToHexAlpha(color) {
  var rgb = toColor(getRGBAColorArray(color), 'rgba');
  var rRgba = /rgba?\((\d{1,3}),(\d{1,3}),(\d{1,3})(,([.\d]+))?\)/,
      r,
      g,
      b,
      a,
      rsa = rgb.replace(/\s+/g, "").match(rRgba);
  r = (+rsa[1]).toString(16);
  r = r.length === 1 ? "0" + r : r;
  g = (+rsa[2]).toString(16);
  g = g.length === 1 ? "0" + g : g;
  b = (+rsa[3]).toString(16);
  b = b.length === 1 ? "0" + b : b;
  a = +(rsa[5] ? rsa[5] : 1);
  return {
    hex: "#" + r + g + b,
    alpha: a
  };
}
/**
 * 返回十六进制颜色和透明度
 * @param color 各种形式color，rgb、gdba、red、#ffffff
 * @param alpha 透明度
 */


function getStandardColorAndOpacity(color, alpha) {
  if (color == null) {
    return {
      hex: color,
      alpha: alpha
    };
  }

  if (alpha == null) {
    alpha = 1;
  }

  alpha = adjust(parseFloat(alpha), [0, 1]);
  var hexAlpha = colorToHexAlpha(color);

  if (hexAlpha.alpha != null) {
    alpha *= hexAlpha.alpha;
  }

  return {
    hex: hexAlpha.hex,
    alpha: alpha
  };
}

function hasColorName(name) {
  return _nameColors[name];
}

var _default = {
  hasColorName: hasColorName,
  toColor: toColor,
  hsb2rgb: hsb2rgb,
  rgb2hsb: rgb2hsb,
  createColorsWithHsb: createColorsWithHsb,
  getRGBAColorArray: getRGBAColorArray,
  mixColorWithHSB: mixColorWithHSB,
  getHighLightColor: getHighLightColor,
  getColorWithDivider: getColorWithDivider,
  mixColorWithAlpha: mixColorWithAlpha,
  getColorOpacity: getColorOpacity,
  getColorOpacityWithoutDefault: getColorOpacityWithoutDefault,
  colorToHex: colorToHex,
  colorToHexAlpha: colorToHexAlpha,
  getClickColor: getClickColor,
  getStandardColorAndOpacity: getStandardColorAndOpacity
};
exports["default"] = _default;

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/6/1.
 */
var DomUtils = {
  // @function get(id: String|HTMLElement): HTMLElement
  // Returns an element given its DOM id, or returns the element itself
  // if it was passed directly.
  get: function (id) {
    return typeof id === 'string' ? document.getElementById(id) : id;
  },
  // @function getStyle(el: HTMLElement, styleAttrib: String): String
  // Returns the value for a certain style attribute on an element,
  // including computed values or values set through CSS.
  getStyle: function (el, style) {
    var value = el.style[style] || el.currentStyle && el.currentStyle[style];

    if ((!value || value === 'auto') && document.defaultView) {
      var css = document.defaultView.getComputedStyle(el, null);
      value = css ? css[style] : null;
    }

    return value === 'auto' ? null : value;
  },
  // @function create(tagName: String, className?: String, container?: HTMLElement): HTMLElement
  // Creates an HTML element with `tagName`, sets its class to `className`, and optionally appends it to `container` element.
  create: function (tagName, className, container) {
    var el = document.createElement(tagName);
    el.className = className || '';

    if (container) {
      container.appendChild(el);
    }

    return el;
  },
  // @function remove(el: HTMLElement)
  // Removes `el` from its parent element
  remove: function (el) {
    if (el && el.parentNode) {
      el.parentNode.removeChild(el);
    }
  },
  // @function empty(el: HTMLElement)
  // Removes all of `el`'s children elements from `el`
  empty: function (el) {
    while (el.firstChild) {
      el.removeChild(el.firstChild);
    }
  },
  // @function toFront(el: HTMLElement)
  // Makes `el` the last children of its parent, so it renders in front of the other children.
  toFront: function (el) {
    if (el && el.parentNode) {
      el.parentNode.appendChild(el);
    }
  },
  // @function toBack(el: HTMLElement)
  // Makes `el` the first children of its parent, so it renders back from the other children.
  toBack: function (el) {
    if (el && el.parentNode) {
      var parent = el.parentNode;
      parent.insertBefore(el, parent.firstChild);
    }
  },
  // @function hasClass(el: HTMLElement, name: String): Boolean
  // Returns `true` if the element's class attribute contains `name`.
  hasClass: function (el, name) {
    if (el.classList !== undefined) {
      return el.classList.contains(name);
    }

    var className = DomUtils.getClass(el);
    return className.length > 0 && new RegExp('(^|\\s)' + name + '(\\s|$)').test(className);
  },
  // @function addClass(el: HTMLElement, name: String)
  // Adds `name` to the element's class attribute.
  addClass: function (el, name) {
    if (el.classList !== undefined) {
      var classes = _BaseUtils["default"].splitWords(name);

      for (var i = 0, len = classes.length; i < len; i++) {
        el.classList.add(classes[i]);
      }
    } else if (!DomUtils.hasClass(el, name)) {
      var className = DomUtils.getClass(el);
      DomUtils.setClass(el, (className ? className + ' ' : '') + name);
    }
  },
  // @function removeClass(el: HTMLElement, name: String)
  // Removes `name` from the element's class attribute.
  removeClass: function (el, name) {
    if (el.classList !== undefined) {
      el.classList.remove(name);
    } else {
      DomUtils.setClass(el, _BaseUtils["default"].trim((' ' + DomUtils.getClass(el) + ' ').replace(' ' + name + ' ', ' ')));
    }
  },
  // @function setClass(el: HTMLElement, name: String)
  // Sets the element's class.
  setClass: function (el, name) {
    if (el.className.baseVal === undefined) {
      el.className = name;
    } else {
      // in case of SVG element
      el.className.baseVal = name;
    }
  },
  // @function getClass(el: HTMLElement): String
  // Returns the element's class.
  getClass: function (el) {
    return el.className.baseVal === undefined ? el.className : el.className.baseVal;
  },
  // @function setOpacity(el: HTMLElement, opacity: Number)
  // Set the opacity of an element (including old IE support).
  // `opacity` must be a number from `0` to `1`.
  setOpacity: function (el, value) {
    if ('opacity' in el.style) {
      el.style.opacity = value;
    } else if ('filter' in el.style) {
      DomUtils._setOpacityIE(el, value);
    }
  },
  _setOpacityIE: function (el, value) {
    var filter = false,
        filterName = 'DXImageTransform.Microsoft.Alpha'; // filters collection throws an error if we try to retrieve a filter that doesn't exist

    try {
      filter = el.filters.item(filterName);
    } catch (e) {
      // don't set opacity to 1 if we haven't already set an opacity,
      // it isn't needed and breaks transparent pngs.
      if (value === 1) {
        return;
      }
    }

    value = Math.round(value * 100);

    if (filter) {
      filter.Enabled = value !== 100;
      filter.Opacity = value;
    } else {
      el.style.filter += ' progid:' + filterName + '(opacity=' + value + ')';
    }
  },
  // @function testProp(props: String[]): String|false
  // Goes through the array of style names and returns the first name
  // that is a valid style name for an element. If no such name is found,
  // it returns false. Useful for vendor-prefixed styles like `transform`.
  testProp: function (props) {
    var style = document.documentElement.style;

    for (var i = 0; i < props.length; i++) {
      if (props[i] in style) {
        return props[i];
      }
    }

    return false;
  },
  // @function setTransform(el: HTMLElement, offset: Point, scale?: Number)
  // Resets the 3D CSS transform of `el` so it is translated by `offset` pixels
  // and optionally scaled by `scale`. Does not have an effect if the
  // browser doesn't support 3D CSS transforms.
  setTransform: function (el, offset, scale) {
    var pos = offset || {
      x: 0,
      y: 0
    };
    el.style[DomUtils.TRANSFORM] = (_Browser["default"].ie3d ? 'translate(' + pos.x + 'px,' + pos.y + 'px)' : 'translate3d(' + pos.x + 'px,' + pos.y + 'px,0)') + (scale ? ' scale(' + scale + ')' : '');
  },
  // @function setPosition(el: HTMLElement, position: Point)
  // Sets the position of `el` to coordinates specified by `position`,
  // using CSS translate or top/left positioning depending on the browser
  // (used by Leaflet internally to position its layers).
  setPosition: function (el, point) {
    // (HTMLElement, Point[, Boolean])

    /*eslint-disable */
    el._leaflet_pos = point;
    /*eslint-enable */

    if (_Browser["default"].any3d) {
      DomUtils.setTransform(el, point);
    } else {
      el.style.left = point.x + 'px';
      el.style.top = point.y + 'px';
    }
  },
  // @function getPosition(el: HTMLElement): Point
  // Returns the coordinates of an element previously positioned with setPosition.
  getPosition: function (el) {
    // this method is only used for elements previously positioned using setPosition,
    // so it's safe to cache the position for performance
    return el._leaflet_pos || _Point2D["default"].create({
      x: 0,
      y: 0
    });
  },
  getMousePos: function (ev, el) {
    var event = ev.touches ? ev.touches.length ? ev.touches[0] : ev.changedTouches[0] : ev;
    var box = el.getBoundingClientRect(); // MOBILE-23926, CHART-12188
    // 处理 scale 后的位置

    var chartX, chartY;

    if (box.width == null) {
      // 如果没有 box.width，也没有translate scale
      // 不处理
      chartX = Math.round(event.clientX - box.left);
      chartY = Math.round(event.clientY - box.top);
    } else {
      // for scaled element
      // https://github.com/jquery/PEP/pull/233#issuecomment-364641197
      chartX = Math.round((event.clientX - box.left) * (el.offsetWidth / box.width));
      chartY = Math.round((event.clientY - box.top) * (el.offsetHeight / box.height));
    }

    return _Point2D["default"].create(chartX, chartY);
  },
  // Chrome on Win scrolls double the pixels as in other platforms (see #4538),
  // and Firefox scrolls device pixels, not CSS pixels
  _wheelPxFactor: _Browser["default"].win && _Browser["default"].chrome ? 2 : _Browser["default"].gecko ? window.devicePixelRatio : 1,
  // @function getWheelDelta(ev: DOMEvent): Number
  // Gets normalized wheel delta from a mousewheel DOM event, in vertical
  // pixels scrolled (negative if scrolling down).
  // Events from pointing devices without precise scrolling are mapped to
  // a best guess of 60 pixels.
  getWheelDelta: function (e) {
    return _Browser["default"].edge ? e.wheelDeltaY / 2 : // Don't trust window-geometry-based delta
    e.deltaY && e.deltaMode === 0 ? -e.deltaY / DomUtils._wheelPxFactor : // Pixels
    e.deltaY && e.deltaMode === 1 ? -e.deltaY * 20 : // Lines
    e.deltaY && e.deltaMode === 2 ? -e.deltaY * 60 : // Pages
    e.deltaX || e.deltaZ ? 0 : // Skip horizontal/depth wheel events
    e.wheelDelta ? (e.wheelDeltaY || e.wheelDelta) / 2 : // Legacy IE pixels
    e.detail && Math.abs(e.detail) < 32765 ? -e.detail * 20 : // Legacy Moz lines
    e.detail ? e.detail / -32765 * 60 : // Legacy Moz pages
    0;
  },
  preventDefault: function (e) {
    if (e.preventDefault) {
      e.preventDefault();
    } else {
      e.returnValue = false;
    }

    return this;
  },
  stopPropagation: function (e) {
    if (e.stopPropagation) {
      e.stopPropagation();
    } else {
      e.cancelBubble = true;
    }

    return this;
  },
  stop: function (e) {
    return DomUtils.preventDefault(e).stopPropagation(e);
  },
  attr: function () {
    if (arguments.length < 2) {
      return;
    }

    var elem = arguments[0],
        prop = arguments[1],
        value = arguments[2];
    var key, ret;

    if (typeof prop == 'string') {
      // set the value
      if ((0, _CoreUtils.hasDefined)(value)) {
        elem.setAttribute(prop, value); // get the value
      } else if (elem && elem.getAttribute) {
        // elem not defined when printing pie demo...
        ret = elem.getAttribute(prop);
      } // else if prop is defined, it is a hash of key/value pairs

    } else if ((0, _CoreUtils.hasDefined)(prop) && typeof prop == 'object') {
      for (key in prop) {
        elem.setAttribute(key, prop[key]);
      }
    }

    return ret;
  }
};

(function () {
  // prefix style property names
  // @property TRANSFORM: String
  // Vendor-prefixed fransform style name (e.g. `'webkitTransform'` for WebKit).
  DomUtils.TRANSFORM = DomUtils.testProp(['transform', 'WebkitTransform', 'OTransform', 'MozTransform', 'msTransform']);
  DomUtils.TRANSFORM_ORIGIN = DomUtils.testProp(['transformOrigin', 'WebkitTransformOrigin', 'OTransformOrigin', 'MozTransformOrigin', 'msTransformOrigin']); // webkitTransition comes first because some browser versions that drop vendor prefix don't do
  // the same for the transitionend event, in particular the Android 4.1 stock browser
  // @property TRANSITION: String
  // Vendor-prefixed transform style name.

  var transition = DomUtils.TRANSITION = DomUtils.testProp(['webkitTransition', 'transition', 'OTransition', 'MozTransition', 'msTransition']);
  DomUtils.TRANSITION_END = transition === 'webkitTransition' || transition === 'OTransition' ? transition + 'End' : 'transitionend';
})();

var _default = DomUtils;
exports["default"] = _default;

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _vMap = _interopRequireDefault(__webpack_require__(35));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/6/24.
 */
//
//Copyright (c) 2014 Ga?tan Renaudeau
//
//Permission is hereby granted, free of charge, to any person
//obtaining a copy of this software and associated documentation
//files (the "Software"), to deal in the Software without
//restriction, including without limitation the rights to use,
//    copy, modify, merge, publish, distribute, sublicense, and/or sell
//copies of the Software, and to permit persons to whom the
//Software is furnished to do so, subject to the following
//conditions:
//
//    The above copyright notice and this permission notice shall be
//included in all copies or substantial portions of the Software.
//
//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
//OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
//NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
//HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
//    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
//OTHER DEALINGS IN THE SOFTWARE.
var HALF_PI = Math.PI / 2;
var global = typeof window === 'object' ? window : global; // These values are established by empiricism with tests (tradeoff: performance VS precision)

var NEWTON_ITERATIONS = 4;
var NEWTON_MIN_SLOPE = 0.001;
var SUBDIVISION_PRECISION = 0.0000001;
var SUBDIVISION_MAX_ITERATIONS = 10;
var kSplineTableSize = 11;
var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
var float32ArraySupported = ('Float32Array' in global);

function A(aA1, aA2) {
  return 1.0 - 3.0 * aA2 + 3.0 * aA1;
}

function B(aA1, aA2) {
  return 3.0 * aA2 - 6.0 * aA1;
}

function C(aA1) {
  return 3.0 * aA1;
} // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.


function calcBezier(aT, aA1, aA2) {
  return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
} // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.


function getSlope(aT, aA1, aA2) {
  return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
}

function binarySubdivide(aX, aA, aB, mX1, mX2) {
  var currentX,
      currentT,
      i = 0;

  do {
    currentT = aA + (aB - aA) / 2.0;
    currentX = calcBezier(currentT, mX1, mX2) - aX;

    if (currentX > 0.0) {
      aB = currentT;
    } else {
      aA = currentT;
    }
  } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);

  return currentT;
}

function BezierEasing(mX1, mY1, mX2, mY2) {
  // Validate arguments
  if (arguments.length !== 4) {
    throw new Error("BezierEasing requires 4 arguments.");
  }

  for (var i = 0; i < 4; ++i) {
    if (typeof arguments[i] !== "number" || isNaN(arguments[i]) || !isFinite(arguments[i])) {
      throw new Error("BezierEasing arguments should be integers.");
    }
  }

  if (mX1 < 0 || mX1 > 1 || mX2 < 0 || mX2 > 1) {
    throw new Error("BezierEasing x values must be in [0, 1] range.");
  }

  var mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : [];

  function newtonRaphsonIterate(aX, aGuessT) {
    for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
      var currentSlope = getSlope(aGuessT, mX1, mX2);

      if (currentSlope === 0.0) {
        return aGuessT;
      }

      var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
      aGuessT -= currentX / currentSlope;
    }

    return aGuessT;
  }

  function calcSampleValues() {
    for (var i = 0; i < kSplineTableSize; ++i) {
      mSampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
    }
  }

  function getTForX(aX) {
    var intervalStart = 0.0;
    var currentSample = 1;
    var lastSample = kSplineTableSize - 1;

    for (; currentSample != lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {
      intervalStart += kSampleStepSize;
    }

    --currentSample; // Interpolate to provide an initial guess for t

    var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]);
    var guessForT = intervalStart + dist * kSampleStepSize;
    var initialSlope = getSlope(guessForT, mX1, mX2);

    if (initialSlope >= NEWTON_MIN_SLOPE) {
      return newtonRaphsonIterate(aX, guessForT);
    } else if (initialSlope === 0.0) {
      return guessForT;
    } else {
      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
    }
  }

  var _precomputed = false;

  function precompute() {
    _precomputed = true;

    if (mX1 != mY1 || mX2 != mY2) {
      calcSampleValues();
    }
  }

  var f = function (aX) {
    if (!_precomputed) {
      precompute();
    }

    if (mX1 === mY1 && mX2 === mY2) {
      return aX;
    } // linear
    // Because JavaScript number are imprecise, we should guarantee the extremes are right.


    if (aX === 0) {
      return 0;
    }

    if (1 - aX < 0.001) {
      return 1;
    }

    return calcBezier(getTForX(aX), mY1, mY2);
  };

  f.getControlPoints = function () {
    return [{
      x: mX1,
      y: mY1
    }, {
      x: mX2,
      y: mY2
    }];
  };

  var args = [mX1, mY1, mX2, mY2];
  var str = "BezierEasing(" + args + ")";

  f.toString = function () {
    return str;
  }; //var css = "cubic-bezier("+args+")";
  //f.toCSS = function () {?return css; };


  return f;
} // CSS mapping


BezierEasing.css = {
  "ease": BezierEasing(0.25, 0.1, 0.25, 1.0),
  "linear": BezierEasing(0.00, 0.0, 1.00, 1.0),
  "ease-in": BezierEasing(0.42, 0.0, 1.00, 1.0),
  "ease-out": BezierEasing(0.00, 0.0, 0.58, 1.0),
  "ease-in-out": BezierEasing(0.42, 0.0, 0.58, 1.0),
  "swing": BezierEasing(0.02, 0.01, 0.47, 1.0),
  "ease-in-back": BezierEasing(0.6, -0.28, 0.735, 0.045),
  "ease-out-back": BezierEasing(0.175, 0.885, 0.32, 1.275),
  "ease-in-quart": BezierEasing(0.895, 0.03, 0.685, 0.22),
  "ease-out-quart": BezierEasing(0.165, 0.84, 0.44, 1),
  "ease-in-quint": BezierEasing(0.755, 0.05, 0.855, 0.06),
  "ease-out-quint": BezierEasing(0.23, 1, 0.32, 1),
  "ease-in-quad": BezierEasing(0.55, 0.085, 0.68, 0.53),
  "ease-out-quad": BezierEasing(0.25, 0.46, 0.45, 0.94),
  "ease-in-out-quad": BezierEasing(0.455, 0.03, 0.515, 0.955),
  "ease-out-cubic": BezierEasing(0.215, 0.61, 0.355, 1)
};
BezierEasing.custom = {
  "ease-out": BezierEasing(0.00, 0.0, 0.16, 1.03),
  "ease-out-quint": BezierEasing(0.19, 1, 0.22, 1),
  "ease-out-back": BezierEasing(0.18, 0.89, 0.32, 1.6)
};

BezierEasing.calculateCubicOutT = function (det) {
  return 1 - Math.pow(1 - det, 1 / 3);
};

BezierEasing.calculateQuadInT = function (det) {
  return Math.sqrt(det);
};

var DOUBLE_PI = 2 * Math.PI;

var d3_identity = function (d) {
  return d;
};

var d3_ease_default = function () {
  return d3_identity;
};

var d3_ease = new _vMap["default"]({
  linear: d3_ease_default,
  poly: d3_ease_poly,
  quad: function () {
    return d3_ease_quad;
  },
  cubic: function () {
    return d3_ease_cubic;
  },
  sin: function () {
    return d3_ease_sin;
  },
  exp: function () {
    return d3_ease_exp;
  },
  circle: function () {
    return d3_ease_circle;
  },
  elastic: d3_ease_elastic,
  back: d3_ease_back,
  bounce: function () {
    return d3_ease_bounce;
  }
});
var d3_ease_mode = new _vMap["default"]({
  "in": d3_identity,
  out: d3_ease_reverse,
  "in-out": d3_ease_reflect,
  "out-in": function (f) {
    return d3_ease_reflect(d3_ease_reverse(f));
  }
});

BezierEasing.ease = function (name) {
  var i = name.indexOf("-"),
      t = i >= 0 ? name.slice(0, i) : name,
      m = i >= 0 ? name.slice(i + 1) : "in";
  t = d3_ease.get(t) || d3_ease_default;
  m = d3_ease_mode.get(m) || d3_identity;
  return d3_ease_clamp(m(t.apply(null, Array.prototype.slice.call(arguments, 1))));
};

function d3_ease_clamp(f) {
  return function (t) {
    return t <= 0 ? 0 : t >= 1 ? 1 : f(t);
  };
}

function d3_ease_reverse(f) {
  return function (t) {
    return 1 - f(1 - t);
  };
}

function d3_ease_reflect(f) {
  return function (t) {
    return .5 * (t < .5 ? f(2 * t) : 2 - f(2 - 2 * t));
  };
}

function d3_ease_quad(t) {
  return t * t;
}

function d3_ease_cubic(t) {
  return t * t * t;
}

function d3_ease_cubicInOut(t) {
  if (t <= 0) {
    return 0;
  }

  if (t >= 1) {
    return 1;
  }

  var t2 = t * t,
      t3 = t2 * t;
  return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75);
}

function d3_ease_poly(e) {
  return function (t) {
    return Math.pow(t, e);
  };
}

function d3_ease_sin(t) {
  return 1 - Math.cos(t * HALF_PI);
}

function d3_ease_exp(t) {
  return Math.pow(2, 10 * (t - 1));
}

function d3_ease_circle(t) {
  return 1 - Math.sqrt(1 - t * t);
}

function d3_ease_elastic(a, p) {
  var s;

  if (arguments.length < 2) {
    p = .45;
  }

  if (arguments.length) {
    s = p / DOUBLE_PI * Math.asin(1 / a);
  } else {
    a = 1, s = p / 4;
  }

  return function (t) {
    return 1 + a * Math.pow(2, -10 * t) * Math.sin((t - s) * DOUBLE_PI / p);
  };
}

function d3_ease_back(s) {
  if (!s) {
    s = 1.70158;
  }

  return function (t) {
    return t * t * ((s + 1) * t - s);
  };
}

function d3_ease_bounce(t) {
  return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
}

var _default = BezierEasing;
exports["default"] = _default;

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by eason on 16/5/26.
 */
var ua = navigator.userAgent.toLowerCase(),
    doc = document.documentElement,
    ie = ('ActiveXObject' in window),
    webkit = ua.indexOf('webkit') !== -1,
    phantomjs = ua.indexOf('phantom') !== -1,
    android23 = ua.search('android [23]') !== -1,
    chrome = ua.indexOf('chrome') !== -1,
    gecko = ua.indexOf('gecko') !== -1 && !webkit && !window.opera && !ie,
    win = navigator.platform.indexOf('Win') === 0,
    mobile = typeof orientation !== 'undefined' || ua.indexOf('mobile') !== -1,
    msPointer = !window.PointerEvent && window.MSPointerEvent,
    pointer = window.PointerEvent || msPointer,
    ie3d = ie && 'transition' in doc.style,
    webkit3d = 'WebKitCSSMatrix' in window && 'm11' in new window.WebKitCSSMatrix() && !android23,
    gecko3d = ('MozPerspective' in doc.style),
    opera12 = ('OTransition' in doc.style),
    iPhone = /iphone/i.test(ua),
    iPad = /ipad/i.test(ua),
    iPod = /ipod/i.test(ua);
var touch = !window.L_NO_TOUCH && (pointer || 'ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch);
var _default = {
  // @property ie: Boolean
  // `true` for all Internet Explorer versions (not Edge).
  ie: ie,
  // @property ielt9: Boolean
  // `true` for Internet Explorer versions less than 9.
  ielt9: ie && !document.addEventListener,
  // @property edge: Boolean
  // `true` for the Edge web browser.
  edge: 'msLaunchUri' in navigator && !('documentMode' in document),
  // @property webkit: Boolean
  // `true` for webkit-based browsers like Chrome and Safari (including mobile versions).
  webkit: webkit,
  // @property gecko: Boolean
  // `true` for gecko-based browsers like Firefox.
  gecko: gecko,
  // @property android: Boolean
  // `true` for any browser running on an Android platform.
  android: ua.indexOf('android') !== -1,
  // @property android23: Boolean
  // `true` for browsers running on Android 2 or Android 3.
  android23: android23,
  // @property chrome: Boolean
  // `true` for the Chrome browser.
  chrome: chrome,
  // @property safari: Boolean
  // `true` for the Safari browser.
  safari: !chrome && ua.indexOf('safari') !== -1,
  // @property win: Boolean
  // `true` when the browser is running in a Windows platform
  win: win,
  // @property ie3d: Boolean
  // `true` for all Internet Explorer versions supporting CSS transforms.
  ie3d: ie3d,
  // @property webkit3d: Boolean
  // `true` for webkit-based browsers supporting CSS transforms.
  webkit3d: webkit3d,
  // @property gecko3d: Boolean
  // `true` for gecko-based browsers supporting CSS transforms.
  gecko3d: gecko3d,
  // @property opera12: Boolean
  // `true` for the Opera browser supporting CSS transforms (version 12 or later).
  opera12: opera12,
  // @property any3d: Boolean
  // `true` for all browsers supporting CSS transforms.
  any3d: (ie3d || webkit3d || gecko3d) && !opera12 && !phantomjs,
  // @property mobile: Boolean
  // `true` for all browsers running in a mobile device.
  mobile: mobile,
  // @property mobileWebkit: Boolean
  // `true` for all webkit-based browsers in a mobile device.
  mobileWebkit: mobile && webkit,
  // @property mobileWebkit3d: Boolean
  // `true` for all webkit-based browsers in a mobile device supporting CSS transforms.
  mobileWebkit3d: mobile && webkit3d,
  // @property mobileOpera: Boolean
  // `true` for the Opera browser in a mobile device.
  mobileOpera: mobile && window.opera,
  // @property mobileGecko: Boolean
  // `true` for gecko-based browsers running in a mobile device.
  mobileGecko: mobile && gecko,
  // @property touch: Boolean
  // `true` for all browsers supporting [touch events](https://developer.mozilla.org/docs/Web/API/Touch_events).
  touch: !!touch,
  // @property msPointer: Boolean
  // `true` for browsers implementing the Microsoft touch events model (notably IE10).
  msPointer: !!msPointer,
  // @property pointer: Boolean
  // `true` for all browsers supporting [pointer events](https://msdn.microsoft.com/en-us/library/dn433244%28v=vs.85%29.aspx).
  pointer: !!pointer,
  // @property retina: Boolean
  // `true` for browsers on a high-resolution "retina" screen.
  retina: (window.devicePixelRatio || window.screen.deviceXDPI / window.screen.logicalXDPI) > 1,
  // @property phantomjs: Boolean
  // `true` when the browser is running on phantomjs
  phantomjs: phantomjs,
  iPhone: iPhone,
  iPad: iPad,
  iPod: iPod,
  ios: iPhone || iPad || iPod
};
exports["default"] = _default;

/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _vMap = _interopRequireDefault(__webpack_require__(35));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/14.
 */
var EPSILON = 1e-6,
    EPSILON2 = EPSILON * EPSILON,
    PI = Math.PI,
    DOUBLE_PI = 2 * PI,
    DOUBLE_PI_EPSILON = DOUBLE_PI - EPSILON,
    HALF_PI = PI / 2,
    d3_radians = PI / 180,
    d3_degrees = 180 / PI;
var abs = Math.abs;
var inverted;

function d3_asin(x) {
  return x > 1 ? HALF_PI : x < -1 ? -HALF_PI : Math.asin(x);
}

function d3_geom_pointX(d) {
  return d[0];
}

function d3_geom_pointY(d) {
  return d[1];
}

function d3_identity(d) {
  return d;
}

function d3_true() {
  return true;
}

var PathGenerator = {};

function d3_zero() {
  return 0;
}

PathGenerator.arc = function () {
  var toCenter = true;
  var closePath = true;
  var innerRadius = d3_svg_arcInnerRadius,
      outerRadius = d3_svg_arcOuterRadius,
      cornerRadius = d3_zero,
      padRadius = d3_svg_arcAuto,
      startAngle = d3_svg_arcStartAngle,
      endAngle = d3_svg_arcEndAngle,
      padAngle = d3_svg_arcPadAngle;

  function arc() {
    var r0 = Math.max(0, +innerRadius.apply(this, arguments)),
        r1 = Math.max(0, +outerRadius.apply(this, arguments)),
        a0 = startAngle.apply(this, arguments) - HALF_PI,
        a1 = endAngle.apply(this, arguments) - HALF_PI,
        da = Math.abs(a1 - a0),
        cw = a0 > a1 ? 0 : 1;

    if (r1 < r0) {
      rc = r1, r1 = r0, r0 = rc;
    }

    if (da >= DOUBLE_PI_EPSILON) {
      return circleSegment(r1, cw) + (r0 ? circleSegment(r0, 1 - cw) : "") + "Z";
    }

    var rc,
        cr,
        rp,
        ap,
        p0 = 0,
        p1 = 0,
        x0,
        y0,
        x1,
        y1,
        x2,
        y2,
        x3,
        y3,
        path = [];

    if (ap = (+padAngle.apply(this, arguments) || 0) / 2) {
      rp = padRadius === d3_svg_arcAuto ? Math.sqrt(r0 * r0 + r1 * r1) : +padRadius.apply(this, arguments);

      if (!cw) {
        p1 *= -1;
      }

      if (r1) {
        p1 = d3_asin(rp / r1 * Math.sin(ap));
      }

      if (r0) {
        p0 = d3_asin(rp / r0 * Math.sin(ap));
      }
    }

    if (r1) {
      x0 = r1 * Math.cos(a0 + p1);
      y0 = r1 * Math.sin(a0 + p1);
      x1 = r1 * Math.cos(a1 - p1);
      y1 = r1 * Math.sin(a1 - p1);
      var l1 = Math.abs(a1 - a0 - 2 * p1) <= PI ? 0 : 1;

      if (p1 && d3_svg_arcSweep(x0, y0, x1, y1) === cw ^ l1) {
        var h1 = (a0 + a1) / 2;
        x0 = r1 * Math.cos(h1);
        y0 = r1 * Math.sin(h1);
        x1 = y1 = null;
      }
    } else {
      x0 = y0 = 0;
    }

    if (r0) {
      x2 = r0 * Math.cos(a1 - p0);
      y2 = r0 * Math.sin(a1 - p0);
      x3 = r0 * Math.cos(a0 + p0);
      y3 = r0 * Math.sin(a0 + p0);
      var l0 = Math.abs(a0 - a1 + 2 * p0) <= PI ? 0 : 1;

      if (p0 && d3_svg_arcSweep(x2, y2, x3, y3) === 1 - cw ^ l0) {
        var h0 = (a0 + a1) / 2;
        x2 = r0 * Math.cos(h0);
        y2 = r0 * Math.sin(h0);
        x3 = y3 = null;
      }
    } else {
      x2 = y2 = 0;
    }

    if ((rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments))) > .001) {
      cr = r0 < r1 ^ cw ? 0 : 1;
      var oc = x3 == null ? [x2, y2] : x1 == null ? [x0, y0] : d3_geom_polygonIntersect([x0, y0], [x3, y3], [x1, y1], [x2, y2]),
          ax = x0 - oc[0],
          ay = y0 - oc[1],
          bx = x1 - oc[0],
          by = y1 - oc[1],
          kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2),
          lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);

      if (x1 != null) {
        var rc1 = Math.min(rc, (r1 - lc) / (kc + 1)),
            t30 = d3_svg_arcCornerTangents(x3 == null ? [x2, y2] : [x3, y3], [x0, y0], r1, rc1, cw),
            t12 = d3_svg_arcCornerTangents([x1, y1], [x2, y2], r1, rc1, cw);

        if (rc === rc1) {
          path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d3_svg_arcSweep(t30[1][0], t30[1][1], t12[1][0], t12[1][1]), ",", cw, " ", t12[1], "A", rc1, ",", rc1, " 0 0,", cr, " ", t12[0]);
        } else {
          path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]);
        }
      } else {
        path.push("M", x0, ",", y0);
      }

      if (x3 != null) {
        var rc0 = Math.min(rc, (r0 - lc) / (kc - 1)),
            t03 = d3_svg_arcCornerTangents([x0, y0], [x3, y3], r0, -rc0, cw),
            t21 = d3_svg_arcCornerTangents([x2, y2], x1 == null ? [x0, y0] : [x1, y1], r0, -rc0, cw);

        if (rc === rc0) {
          path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_svg_arcSweep(t21[1][0], t21[1][1], t03[1][0], t03[1][1]), ",", 1 - cw, " ", t03[1], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
        } else {
          path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
        }
      } else if (toCenter) {
        path.push("L", x2, ",", y2);
      }
    } else {
      path.push("M", x0, ",", y0);

      if (x1 != null) {
        path.push("A", r1, ",", r1, " 0 ", l1, ",", cw, " ", x1, ",", y1);
      }

      if (toCenter) {
        path.push("L", x2, ",", y2);
      }

      if (x3 != null) {
        path.push("A", r0, ",", r0, " 0 ", l0, ",", 1 - cw, " ", x3, ",", y3);
      }
    }

    if (closePath) {
      path.push("Z");
    }

    return path.join("");
  }

  function circleSegment(r1, cw) {
    return "M0," + r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + -r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + r1;
  }

  arc.toCenter = function (v) {
    if (!arguments.length) {
      return toCenter;
    }

    toCenter = !!v;
    return arc;
  };

  arc.closePath = function (v) {
    if (!arguments.length) {
      return closePath;
    }

    closePath = !!v;
    return arc;
  };

  arc.innerRadius = function (v) {
    if (!arguments.length) {
      return innerRadius;
    }

    innerRadius = d3_functor(v);
    return arc;
  };

  arc.outerRadius = function (v) {
    if (!arguments.length) {
      return outerRadius;
    }

    outerRadius = d3_functor(v);
    return arc;
  };

  arc.cornerRadius = function (v) {
    if (!arguments.length) {
      return cornerRadius;
    }

    cornerRadius = d3_functor(v);
    return arc;
  };

  arc.padRadius = function (v) {
    if (!arguments.length) {
      return padRadius;
    }

    padRadius = v == d3_svg_arcAuto ? d3_svg_arcAuto : d3_functor(v);
    return arc;
  };

  arc.startAngle = function (v) {
    if (!arguments.length) {
      return startAngle;
    }

    startAngle = d3_functor(v);
    return arc;
  };

  arc.endAngle = function (v) {
    if (!arguments.length) {
      return endAngle;
    }

    endAngle = d3_functor(v);
    return arc;
  };

  arc.padAngle = function (v) {
    if (!arguments.length) {
      return padAngle;
    }

    padAngle = d3_functor(v);
    return arc;
  };

  arc.centroid = function () {
    var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2,
        a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - HALF_PI;
    return [Math.cos(a) * r, Math.sin(a) * r];
  };

  return arc;
};

var d3_svg_arcAuto = "auto";

function d3_svg_arcInnerRadius(d) {
  return d.innerRadius;
}

function d3_svg_arcOuterRadius(d) {
  return d.outerRadius;
}

function d3_svg_arcStartAngle(d) {
  return d.startAngle;
}

function d3_svg_arcEndAngle(d) {
  return d.endAngle;
}

function d3_svg_arcPadAngle(d) {
  return d && d.padAngle;
}

function d3_svg_arcSweep(x0, y0, x1, y1) {
  return (x0 - x1) * y0 - (y0 - y1) * x0 > 0 ? 0 : 1;
}

function d3_svg_arcCornerTangents(p0, p1, r1, rc, cw) {
  var x01 = p0[0] - p1[0],
      y01 = p0[1] - p1[1],
      lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01),
      ox = lo * y01,
      oy = -lo * x01,
      x1 = p0[0] + ox,
      y1 = p0[1] + oy,
      x2 = p1[0] + ox,
      y2 = p1[1] + oy,
      x3 = (x1 + x2) / 2,
      y3 = (y1 + y2) / 2,
      dx = x2 - x1,
      dy = y2 - y1,
      d2 = dx * dx + dy * dy,
      r = r1 - rc,
      D = x1 * y2 - x2 * y1,
      d = (dy < 0 ? -1 : 1) * Math.sqrt(r * r * d2 - D * D),
      cx0 = (D * dy - dx * d) / d2,
      cy0 = (-D * dx - dy * d) / d2,
      cx1 = (D * dy + dx * d) / d2,
      cy1 = (-D * dx + dy * d) / d2,
      dx0 = cx0 - x3,
      dy0 = cy0 - y3,
      dx1 = cx1 - x3,
      dy1 = cy1 - y3;

  if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) {
    cx0 = cx1, cy0 = cy1;
  }

  return [[cx0 - ox, cy0 - oy], [cx0 * r1 / r, cy0 * r1 / r]];
}

function d3_geom_polygonIntersect(c, d, a, b) {
  var x1 = c[0],
      x3 = a[0],
      x21 = d[0] - x1,
      x43 = b[0] - x3,
      y1 = c[1],
      y3 = a[1],
      y21 = d[1] - y1,
      y43 = b[1] - y3,
      ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21);
  return [x1 + ua * x21, y1 + ua * y21];
}

function d3_functor(v) {
  return typeof v === "function" ? v : function () {
    return v;
  };
}

function d3_svg_line(projection) {
  var x = d3_geom_pointX,
      y = d3_geom_pointY,
      defined = d3_true,
      interpolate = d3_svg_lineLinear,
      interpolateKey = interpolate.key,
      tension = .7;

  function line(data, invert) {
    var segments = [],
        points = [],
        i = -1,
        n = data.length,
        d,
        fx = d3_functor(x),
        fy = d3_functor(y);

    function segment() {
      segments.push("M", interpolate(projection(points), tension));
    }

    while (++i < n) {
      if (defined.call(this, d = data[i], i)) {
        points.push([+fx.call(this, d, i), +fy.call(this, d, i)]);
      } else if (points.length) {
        segment();
        points = [];
      }
    }

    if (points.length) {
      segment();
    }

    return segments.length ? segments.join("") : null;
  }

  line.x = function (_) {
    if (!arguments.length) {
      return x;
    }

    x = _;
    return line;
  };

  line.y = function (_) {
    if (!arguments.length) {
      return y;
    }

    y = _;
    return line;
  };

  line.defined = function (_) {
    if (!arguments.length) {
      return defined;
    }

    defined = _;
    return line;
  };

  line.interpolate = function (_) {
    if (!arguments.length) {
      return interpolateKey;
    }

    if (typeof _ === "function") {
      interpolateKey = interpolate = _;
    } else {
      interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
    }

    return line;
  };

  line.tension = function (_) {
    if (!arguments.length) {
      return tension;
    }

    tension = _;
    return line;
  };

  return line;
}

PathGenerator.line = function (invert) {
  inverted = invert;
  return d3_svg_line(d3_identity);
};

var d3_svg_lineInterpolators = new _vMap["default"]({
  linear: d3_svg_lineLinear,
  "linear-closed": d3_svg_lineLinearClosed,
  step: d3_svg_lineStep,
  "step-before": d3_svg_lineStepBefore,
  "step-after": d3_svg_lineStepAfter,
  basis: d3_svg_lineBasis,
  "basis-open": d3_svg_lineBasisOpen,
  "basis-closed": d3_svg_lineBasisClosed,
  bundle: d3_svg_lineBundle,
  cardinal: d3_svg_lineCardinal,
  "cardinal-open": d3_svg_lineCardinalOpen,
  "cardinal-closed": d3_svg_lineCardinalClosed,
  monotone: d3_svg_lineMonotone
});
d3_svg_lineInterpolators.forEach(function (key, value) {
  value.key = key;
  value.closed = /-closed$/.test(key);
});

function d3_svg_lineLinear(points) {
  return points.join("L");
}

function d3_svg_lineLinearClosed(points) {
  return d3_svg_lineLinear(points) + "Z";
}

function d3_svg_lineStep(points) {
  var i = 0,
      n = points.length,
      p = points[0],
      path = [p[0], ",", p[1]];

  while (++i < n) {
    path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]);
  }

  if (n > 1) {
    path.push("H", p[0]);
  }

  return path.join("");
}

function d3_svg_lineStepBefore(points) {
  var i = 0,
      n = points.length,
      p = points[0],
      path = [p[0], ",", p[1]];

  while (++i < n) {
    path.push("V", (p = points[i])[1], "H", p[0]);
  }

  return path.join("");
}

function d3_svg_lineStepAfter(points) {
  var i = 0,
      n = points.length,
      p = points[0],
      path = [p[0], ",", p[1]];

  while (++i < n) {
    path.push("H", (p = points[i])[0], "V", p[1]);
  }

  return path.join("");
}

function d3_svg_lineCardinalOpen(points, tension) {
  return points.length < 4 ? d3_svg_lineLinear(points) : points[1] + d3_svg_lineHermite(points.slice(1, -1), d3_svg_lineCardinalTangents(points, tension));
}

function d3_svg_lineCardinalClosed(points, tension) {
  return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite((points.push(points[0]), points), d3_svg_lineCardinalTangents([points[points.length - 2]].concat(points, [points[1]]), tension));
}

function d3_svg_lineCardinal(points, tension) {
  return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineCardinalHighCharts(points); // return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineCardinalTangents(points, tension));
}

PathGenerator.d3_svg_lineCardinalHighCharts = d3_svg_lineCardinalHighCharts;

function d3_svg_lineCardinalHighCharts(points) {
  if (points.length < 3) {
    return d3_svg_lineLinear(points);
  }

  var smoothing = 1.5,
      denom = smoothing + 1;

  var correction = 0,
      lastPoint,
      currPoint,
      nextPoint,
      lastX,
      lastY,
      currX,
      currY,
      nextX,
      nextY,
      leftContX,
      leftContY,
      rightContX,
      rightContY,
      _rightContX,
      _rightContY;

  var i = 0,
      len = points.length - 1,
      path = '';

  while (i++ < len) {
    lastPoint = points[i - 1];
    currPoint = points[i];

    if (i == len) {
      nextPoint = points[i];
    } else {
      nextPoint = points[i + 1];
    }

    if (inverted) {
      lastX = lastPoint[1] || 0;
      lastY = lastPoint[0] || 0;
      currX = currPoint[1] || 0;
      currY = currPoint[0] || 0;
      nextX = nextPoint[1] || 0;
      nextY = nextPoint[0] || 0;
    } else {
      lastX = lastPoint[0] || 0;
      lastY = lastPoint[1] || 0;
      currX = currPoint[0] || 0;
      currY = currPoint[1] || 0;
      nextX = nextPoint[0] || 0;
      nextY = nextPoint[1] || 0;
    }

    leftContX = (smoothing * currX + lastX) / denom;
    leftContY = (smoothing * currY + lastY) / denom;
    rightContX = (smoothing * currX + nextX) / denom;
    rightContY = (smoothing * currY + nextY) / denom;

    if (rightContX != leftContX) {
      correction = (rightContY - leftContY) * (rightContX - currX) / (rightContX - leftContX) + currY - rightContY;
    }

    leftContY += correction;
    rightContY += correction;

    if (leftContY > lastY && leftContY > currY) {
      leftContY = Math.max(lastY, currY);
      rightContY = 2 * currY - leftContY;
    } else if (leftContY < lastY && leftContY < currY) {
      leftContY = Math.min(lastY, currY);
      rightContY = 2 * currY - leftContY;
    }

    if (rightContY > nextY && rightContY > currY) {
      rightContY = Math.max(nextY, currY);
      leftContY = 2 * currY - rightContY;
    } else if (rightContY < nextY && rightContY < currY) {
      rightContY = Math.min(nextY, currY);
      leftContY = 2 * currY - rightContY;
    }

    if (inverted) {
      path += "C" + (_rightContY || lastY || 0) + "," + ((_rightContX || lastX || 0) + ",") + ((leftContY || currY || 0) + ",") + ((leftContX || currX || 0) + ",") + (currY + ",") + ("" + currX);
    } else {
      path += "C" + (_rightContX || lastX || 0) + "," + ((_rightContY || lastY || 0) + ",") + ((leftContX || currX || 0) + ",") + ((leftContY || currY || 0) + ",") + (currX + ",") + ("" + currY);
    }

    _rightContX = rightContX;
    _rightContY = rightContY;
  }

  return path;
}

function d3_svg_lineHermite(points, tangents) {
  if (tangents.length < 1 || points.length != tangents.length && points.length != tangents.length + 2) {
    return d3_svg_lineLinear(points);
  }

  var quad = points.length != tangents.length,
      path = "",
      p0 = points[0],
      p = points[1],
      t0 = tangents[0],
      t = t0,
      pi = 1;

  if (quad) {
    path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
    p0 = points[1];
    pi = 2;
  }

  if (tangents.length > 1) {
    t = tangents[1];
    p = points[pi];
    pi++;
    path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];

    for (var i = 2; i < tangents.length; i++, pi++) {
      p = points[pi];
      t = tangents[i];
      path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
    }
  }

  if (quad) {
    var lp = points[pi];
    path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
  }

  return path;
}

function d3_svg_lineCardinalTangents(points, tension) {
  var tangents = [],
      a = (1 - tension) / 2,
      p0,
      p1 = points[0],
      p2 = points[1],
      i = 1,
      n = points.length;

  while (++i < n) {
    p0 = p1;
    p1 = p2;
    p2 = points[i];
    tangents.push([a * (p2[0] - p0[0]), a * (p2[1] - p0[1])]);
  }

  return tangents;
}

function d3_svg_lineBasis(points) {
  if (points.length < 3) {
    return d3_svg_lineLinear(points);
  }

  var i = 1,
      n = points.length,
      pi = points[0],
      x0 = pi[0],
      y0 = pi[1],
      px = [x0, x0, x0, (pi = points[1])[0]],
      py = [y0, y0, y0, pi[1]],
      path = [x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)];
  points.push(points[n - 1]);

  while (++i <= n) {
    pi = points[i];
    px.shift();
    px.push(pi[0]);
    py.shift();
    py.push(pi[1]);
    d3_svg_lineBasisBezier(path, px, py);
  }

  points.pop();
  path.push("L", pi);
  return path.join("");
}

function d3_svg_lineBasisOpen(points) {
  if (points.length < 4) {
    return d3_svg_lineLinear(points);
  }

  var path = [],
      i = -1,
      n = points.length,
      pi,
      px = [0],
      py = [0];

  while (++i < 3) {
    pi = points[i];
    px.push(pi[0]);
    py.push(pi[1]);
  }

  path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py));
  --i;

  while (++i < n) {
    pi = points[i];
    px.shift();
    px.push(pi[0]);
    py.shift();
    py.push(pi[1]);
    d3_svg_lineBasisBezier(path, px, py);
  }

  return path.join("");
}

function d3_svg_lineBasisClosed(points) {
  var path,
      i = -1,
      n = points.length,
      m = n + 4,
      pi,
      px = [],
      py = [];

  while (++i < 4) {
    pi = points[i % n];
    px.push(pi[0]);
    py.push(pi[1]);
  }

  path = [d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)];
  --i;

  while (++i < m) {
    pi = points[i % n];
    px.shift();
    px.push(pi[0]);
    py.shift();
    py.push(pi[1]);
    d3_svg_lineBasisBezier(path, px, py);
  }

  return path.join("");
}

function d3_svg_lineBundle(points, tension) {
  var n = points.length - 1;

  if (n) {
    var x0 = points[0][0],
        y0 = points[0][1],
        dx = points[n][0] - x0,
        dy = points[n][1] - y0,
        i = -1,
        p,
        t;

    while (++i <= n) {
      p = points[i];
      t = i / n;
      p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx);
      p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy);
    }
  }

  return d3_svg_lineBasis(points);
}

function d3_svg_lineDot4(a, b) {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
}

var d3_svg_lineBasisBezier1 = [0, 2 / 3, 1 / 3, 0],
    d3_svg_lineBasisBezier2 = [0, 1 / 3, 2 / 3, 0],
    d3_svg_lineBasisBezier3 = [0, 1 / 6, 2 / 3, 1 / 6];

function d3_svg_lineBasisBezier(path, x, y) {
  path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y));
}

function d3_svg_lineSlope(p0, p1) {
  return (p1[1] - p0[1]) / (p1[0] - p0[0]);
}

function d3_svg_lineFiniteDifferences(points) {
  var i = 0,
      j = points.length - 1,
      m = [],
      p0 = points[0],
      p1 = points[1],
      d = m[0] = d3_svg_lineSlope(p0, p1);

  while (++i < j) {
    m[i] = (d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1]))) / 2;
  }

  m[i] = d;
  return m;
}

function d3_svg_lineMonotoneTangents(points) {
  var tangents = [],
      d,
      a,
      b,
      s,
      m = d3_svg_lineFiniteDifferences(points),
      i = -1,
      j = points.length - 1;

  while (++i < j) {
    d = d3_svg_lineSlope(points[i], points[i + 1]);

    if (abs(d) < EPSILON) {
      m[i] = m[i + 1] = 0;
    } else {
      a = m[i] / d;
      b = m[i + 1] / d;
      s = a * a + b * b;

      if (s > 9) {
        s = d * 3 / Math.sqrt(s);
        m[i] = s * a;
        m[i + 1] = s * b;
      }
    }
  }

  i = -1;

  while (++i <= j) {
    s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0]) / (6 * (1 + m[i] * m[i]));
    tangents.push([s || 0, m[i] * s || 0]);
  }

  return tangents;
}

function d3_svg_lineMonotone(points) {
  return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points));
}

PathGenerator.line.radial = function () {
  var line = d3_svg_line(d3_svg_lineRadial);
  line.radius = line.x, delete line.x;
  line.angle = line.y, delete line.y;
  return line;
};

function d3_svg_lineRadial(points) {
  var point,
      i = -1,
      n = points.length,
      r,
      a;

  while (++i < n) {
    point = points[i];
    r = point[0];
    a = point[1] - HALF_PI;
    point[0] = r * Math.cos(a);
    point[1] = r * Math.sin(a);
  }

  return points;
}

function d3_svg_area(projection) {
  var x0 = d3_geom_pointX,
      x1 = d3_geom_pointX,
      y0 = 0,
      y1 = d3_geom_pointY,
      defined = d3_true,
      interpolate = d3_svg_lineLinear,
      interpolateKey = interpolate.key,
      interpolateReverse = interpolate,
      L = "L",
      tension = .7;

  function area(data) {
    var segments = [],
        points0 = [],
        points1 = [],
        i = -1,
        n = data.length,
        d,
        fx0 = d3_functor(x0),
        fy0 = d3_functor(y0),
        fx1 = x0 === x1 ? function () {
      return x;
    } : d3_functor(x1),
        fy1 = y0 === y1 ? function () {
      return y;
    } : d3_functor(y1),
        x,
        y;

    function segment() {
      segments.push("M", interpolate(projection(points1), tension), L, interpolateReverse(projection(points0.reverse()), tension), "Z");
    }

    while (++i < n) {
      if (defined.call(this, d = data[i], i)) {
        points0.push([x = +fx0.call(this, d, i), y = +fy0.call(this, d, i)]);
        points1.push([+fx1.call(this, d, i), +fy1.call(this, d, i)]);
      } else if (points0.length) {
        segment();
        points0 = [];
        points1 = [];
      }
    }

    if (points0.length) {
      segment();
    }

    return segments.length ? segments.join("") : null;
  }

  area.x = function (_) {
    if (!arguments.length) {
      return x1;
    }

    x0 = x1 = _;
    return area;
  };

  area.x0 = function (_) {
    if (!arguments.length) {
      return x0;
    }

    x0 = _;
    return area;
  };

  area.x1 = function (_) {
    if (!arguments.length) {
      return x1;
    }

    x1 = _;
    return area;
  };

  area.y = function (_) {
    if (!arguments.length) {
      return y1;
    }

    y0 = y1 = _;
    return area;
  };

  area.y0 = function (_) {
    if (!arguments.length) {
      return y0;
    }

    y0 = _;
    return area;
  };

  area.y1 = function (_) {
    if (!arguments.length) {
      return y1;
    }

    y1 = _;
    return area;
  };

  area.defined = function (_) {
    if (!arguments.length) {
      return defined;
    }

    defined = _;
    return area;
  };

  area.interpolate = function (_) {
    if (!arguments.length) {
      return interpolateKey;
    }

    if (typeof _ === "function") {
      interpolateKey = interpolate = _;
    } else {
      interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
    }

    interpolateReverse = interpolate.reverse || interpolate;
    L = interpolate.closed ? "M" : "L";
    return area;
  };

  area.tension = function (_) {
    if (!arguments.length) {
      return tension;
    }

    tension = _;
    return area;
  };

  return area;
}

d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter;
d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore;

PathGenerator.area = function () {
  return d3_svg_area(d3_identity);
};

PathGenerator.area.radial = function () {
  var area = d3_svg_area(d3_svg_lineRadial);
  area.radius = area.x, delete area.x;
  area.innerRadius = area.x0, delete area.x0;
  area.outerRadius = area.x1, delete area.x1;
  area.angle = area.y, delete area.y;
  area.startAngle = area.y0, delete area.y0;
  area.endAngle = area.y1, delete area.y1;
  return area;
};

PathGenerator.diagonal = function () {
  var source = d3_source,
      target = d3_target,
      projection = d3_svg_diagonalProjection;

  function diagonal(d, i) {
    var p0 = source.call(this, d, i),
        p3 = target.call(this, d, i),
        m = (p0.y + p3.y) / 2,
        p = [p0, {
      x: p0.x,
      y: m
    }, {
      x: p3.x,
      y: m
    }, p3];
    p = p.map(projection);
    return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3];
  }

  diagonal.source = function (x) {
    if (!arguments.length) {
      return source;
    }

    source = d3_functor(x);
    return diagonal;
  };

  diagonal.target = function (x) {
    if (!arguments.length) {
      return target;
    }

    target = d3_functor(x);
    return diagonal;
  };

  diagonal.projection = function (x) {
    if (!arguments.length) {
      return projection;
    }

    projection = x;
    return diagonal;
  };

  return diagonal;
};

function d3_source(d) {
  return d.source;
}

function d3_target(d) {
  return d.target;
}

function d3_svg_diagonalProjection(d) {
  return [d.x, d.y];
}

PathGenerator.getMarkerPath = function (markerType, radius) {
  switch (markerType) {
    case _Constants["default"].SYMBOL_AUTO:
    case _Constants["default"].CIRCLE:
    case _Constants["default"].CIRCLE_HOLLOW:
      return PathGenerator.arc().outerRadius(radius)({
        startAngle: 0,
        endAngle: 2 * Math.PI
      });

    case _Constants["default"].SQUARE:
    case _Constants["default"].SQUARE_HOLLOW:
      var leftTop = -radius + ',' + -radius;
      var rightTop = radius + ',' + -radius;
      var rightBottom = radius + ',' + radius;
      var leftBottom = -radius + ',' + radius;
      return 'M' + leftTop + 'L' + rightTop + 'L' + rightBottom + 'L' + leftBottom + 'Z';

    case _Constants["default"].DIAMOND:
    case _Constants["default"].DIAMOND_HOLLOW:
      var left = -radius + ',' + 0;
      var top = 0 + ',' + -radius;
      var right = radius + ',' + 0;
      var bottom = 0 + ',' + radius;
      return 'M' + left + 'L' + top + 'L' + right + 'L' + bottom + 'Z';

    case _Constants["default"].TRIANGLE:
    case _Constants["default"].TRIANGLE_HOLLOW:
      var sqrt3 = Math.sqrt(3);
      var left = -2 * radius / sqrt3 + ',' + radius;
      var top = 0 + ',' + -radius;
      var right = 2 * radius / sqrt3 + ',' + radius;
      return 'M' + left + 'L' + top + 'L' + right + 'Z';

    case _Constants["default"].STAR:
      radius *= 1.105; // magic num

      var r = getr(radius);
      var d = '';
      var i = -1;

      while (++i < 5) {
        var th = i * deg2rad(72),
            al = th + deg2rad(36);
        var a = getPos(th, radius, 3);
        var b = getPos(al, r, 3);
        var cmd = i ? 'L' : 'M';
        d += cmd + a[0] + ',' + a[1];
        d += 'L' + b[0] + ',' + b[1];
      }

      d += 'z';
      return d;

    case _Constants["default"].LOCATION:
      // todo,
      // (40 x 40)
      return 'M34.75,15.75A14.75,14.75,0,1,0,8.19,24.51L20,40,31.82,24.51h0A14.62,14.62,0,0,0,34.75,15.75ZM20,21.91a5.77,5.77,0,1,1,5.77-5.77A5.77,5.77,0,0,1,20,21.91Z';

    default:
      return '';
  }
};

function deg2rad(deg) {
  return deg / 180 * Math.PI;
}

function getr(R) {
  return R * Math.sin(deg2rad(18)) / (Math.sin(deg2rad(36)) + Math.sin(deg2rad(18)) * Math.cos(deg2rad(36)));
}

function getPos(th, r, l) {
  return [(Math.sin(th) * r).toFixed(l), (-Math.cos(th) * r).toFixed(l)];
}

var _default = PathGenerator;
exports["default"] = _default;

/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _vMap = _interopRequireDefault(__webpack_require__(35));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/14.
 */
function scaleExtent(domain) {
  var start = domain[0],
      stop = domain[domain.length - 1];
  return start < stop ? [start, stop] : [stop, start];
}

function d3_scale_bilinear(domain, range, uninterpolate, interpolate, minMax) {
  var u = uninterpolate(domain[0], domain[1]),
      i = interpolate(range[0], range[1]);
  return function (x) {
    var result = i(u(x));

    if (minMax && (0, _CoreUtils.hasDefined)(minMax[0])) {
      result = Math.max(result, minMax[0]);
    }

    if (minMax && (0, _CoreUtils.hasDefined)(minMax[1])) {
      result = Math.min(result, minMax[1]);
    }

    return result;
  };
}

function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
  var u = [],
      i = [],
      j = 0,
      k = Math.min(domain.length, range.length) - 1;

  if (domain[k] < domain[0]) {
    domain = domain.slice().reverse();
    range = range.slice().reverse();
  }

  while (++j <= k) {
    u.push(uninterpolate(domain[j - 1], domain[j]));
    i.push(interpolate(range[j - 1], range[j]));
  }

  return function (x) {
    var j = bisect(domain, x, 1, k) - 1;
    return i[j](u[j](x));
  };
}

function bisect(a, x, lo, hi) {
  if (arguments.length < 3) {
    lo = 0;
  }

  if (arguments.length < 4) {
    hi = a.length;
  }

  while (lo < hi) {
    var mid = lo + hi >>> 1;

    if (d3_ascending(a[mid], x) > 0) {
      hi = mid;
    } else {
      lo = mid + 1;
    }
  }

  return lo;
}

function d3_ascending(a, b) {
  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}

function d3_scale_linearRebind(scale, linear) {
  return _BaseUtils["default"].rebind(scale, linear, "range", "rangeRound", "interpolate");
}

function d3_scale_linear(domain, range, interpolate, uninterpolate, minMax) {
  var output, input;

  function rescale() {
    var linear = Math.min(domain.length, range.length) > 2 ? d3_scale_polylinear : d3_scale_bilinear;
    output = linear(domain, range, uninterpolate, interpolate, minMax);
    input = linear(range, domain, uninterpolate, interpolate, minMax);
    return scale;
  }

  function scale(x) {
    return output(x);
  }

  scale.invert = function (y) {
    return input(y);
  };

  scale.domain = function (x) {
    if (!arguments.length) {
      return domain;
    }

    domain = x.map(Number);
    return rescale();
  };

  scale.range = function (x) {
    if (!arguments.length) {
      return range;
    }

    range = x;
    return rescale();
  };

  scale.minMax = function (x) {
    if (!arguments.length) {
      return minMax;
    }

    minMax = x;
    return rescale();
  };

  scale.rangeRound = function (x) {
    return scale.range(x).interpolate(_interpolator["default"].interpolateRound);
  };

  scale.interpolate = function (x) {
    if (!arguments.length) {
      return interpolate;
    }

    interpolate = x;
    return rescale();
  };

  scale.uninterpolate = function (x) {
    if (!arguments.length) {
      return uninterpolate;
    }

    uninterpolate = x;
    return rescale();
  };

  scale.copy = function () {
    return d3_scale_linear(domain, range, interpolate, uninterpolate, minMax);
  };

  return rescale();
}

function d3_scale_log(linear, base, positive, domain) {
  function log(x) {
    return (positive ? Math.log(x < 0 ? 0 : x) : -Math.log(x > 0 ? 0 : -x)) / Math.log(base);
  }

  function pow(x) {
    return positive ? Math.pow(base, x) : -Math.pow(base, -x);
  }

  function scale(x) {
    return linear(log(x));
  }

  scale.invert = function (x) {
    return pow(linear.invert(x));
  };

  scale.domain = function (x) {
    if (!arguments.length) {
      return domain;
    }

    positive = x[0] >= 0;
    linear.domain((domain = x.map(Number)).map(log));
    return scale;
  };

  scale.base = function (_) {
    if (!arguments.length) {
      return base;
    }

    base = +_;
    linear.domain(domain.map(log));
    return scale;
  };

  scale.copy = function () {
    return d3_scale_log(linear.copy(), base, positive, domain);
  };

  return d3_scale_linearRebind(scale, linear);
}

function d3_scale_ordinal(domain, ranger) {
  var index, range, rangeBand;

  function scale(x) {
    return range[((index.get(x) || (ranger.t === "range" ? index.set(x, domain.push(x)) : NaN)) - 1) % range.length];
  }

  function steps(start, step) {
    var range = [],
        length = domain.length;

    for (var i = 0; i < length; i++) {
      range.push(start + step * i);
    }

    return range;
  }

  scale.domain = function (x) {
    if (!arguments.length) {
      return domain;
    }

    domain = [];
    index = new _vMap["default"]();
    var i = -1,
        n = x.length,
        xi;

    while (++i < n) {
      if (!index.has(xi = x[i])) {
        index.set(xi, domain.push(xi));
      }
    }

    return scale[ranger.t].apply(scale, ranger.a);
  };

  scale.range = function (x) {
    if (!arguments.length) {
      return range;
    }

    range = x;
    rangeBand = 0;
    ranger = {
      t: "range",
      a: arguments
    };
    return scale;
  };

  scale.rangePoints = function (x, padding) {
    if (arguments.length < 2) {
      padding = 0;
    }

    var start = x[0],
        stop = x[1],
        step = domain.length < 2 ? (start = (start + stop) / 2, 0) : (stop - start) / (domain.length - 1 + padding);
    range = steps(start + step * padding / 2, step);
    rangeBand = 0;
    ranger = {
      t: "rangePoints",
      a: arguments
    };
    return scale;
  };

  scale.rangeRoundPoints = function (x, padding) {
    if (arguments.length < 2) {
      padding = 0;
    }

    var start = x[0],
        stop = x[1],
        step = domain.length < 2 ? (start = stop = Math.round((start + stop) / 2), 0) : (stop - start) / (domain.length - 1 + padding) | 0;
    range = steps(start + Math.round(step * padding / 2 + (stop - start - (domain.length - 1 + padding) * step) / 2), step);
    rangeBand = 0;
    ranger = {
      t: "rangeRoundPoints",
      a: arguments
    };
    return scale;
  };

  scale.rangeBands = function (x, padding, outerPadding) {
    if (arguments.length < 2) {
      padding = 0;
    }

    if (arguments.length < 3) {
      outerPadding = padding;
    }

    var reverse = x[1] < x[0],
        start = x[reverse - 0],
        stop = x[1 - reverse],
        step = (stop - start) / (domain.length - padding + 2 * outerPadding);
    range = steps(start + step * outerPadding, step);

    if (reverse) {
      range.reverse();
    }

    rangeBand = step * (1 - padding);
    ranger = {
      t: "rangeBands",
      a: arguments
    };
    return scale;
  };

  scale.rangeRoundBands = function (x, padding, outerPadding) {
    if (arguments.length < 2) {
      padding = 0;
    }

    if (arguments.length < 3) {
      outerPadding = padding;
    }

    var reverse = x[1] < x[0],
        start = x[reverse - 0],
        stop = x[1 - reverse],
        step = Math.floor((stop - start) / (domain.length - padding + 2 * outerPadding));
    range = steps(start + Math.round((stop - start - (domain.length - padding) * step) / 2), step);

    if (reverse) {
      range.reverse();
    }

    rangeBand = Math.round(step * (1 - padding));
    ranger = {
      t: "rangeRoundBands",
      a: arguments
    };
    return scale;
  };

  scale.rangeBand = function () {
    return rangeBand;
  };

  scale.rangeExtent = function () {
    return scaleExtent(ranger.a[0]);
  };

  scale.copy = function () {
    return d3_scale_ordinal(domain, ranger);
  };

  return scale.domain(domain);
}

function d3_scale_quantize(x0, x1, range) {
  var kx, i;

  function scale(x) {
    return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
  }

  function rescale() {
    kx = range.length / (x1 - x0);
    i = range.length - 1;
    return scale;
  }

  scale.domain = function (x) {
    if (!arguments.length) {
      return [x0, x1];
    }

    x0 = +x[0];
    x1 = +x[x.length - 1];
    return rescale();
  };

  scale.range = function (x) {
    if (!arguments.length) {
      return range;
    }

    range = x;
    return rescale();
  };

  scale.invertExtent = function (y) {
    y = range.indexOf(y);
    y = y < 0 ? NaN : y / kx + x0;
    return [y, y + 1 / kx];
  };

  scale.copy = function () {
    return d3_scale_quantize(x0, x1, range);
  };

  return rescale();
}

function linear() {
  return d3_scale_linear([0, 1], [0, 1], _interpolator["default"].interpolateNumber, _interpolator["default"].uninterpolateNumber);
}

function log() {
  return d3_scale_log(linear().domain([0, 1]), 10, true, [1, 10]);
}

function quantize() {
  return d3_scale_quantize(0, 1, [0, 1]);
}

function ordinal() {
  return d3_scale_ordinal([], {
    t: "range",
    a: [[]]
  });
}

var _default = {
  linear: linear,
  quantize: quantize,
  log: log,
  ordinal: ordinal
};
exports["default"] = _default;

/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _index = __webpack_require__(4);

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/4.
 * 图表中所有可以显现的内容都作为一个组件
 */
var DEFAULT_LEGEND_REGION = 0.3; // 图例区域自动时占整个图表高度或宽度的比例

var PADDING = 8;

var PADDING_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING);
};

var Base = _Evented["default"].extend({
  initialize: function (options, componentType, vanchart) {
    this.componentType = componentType;
    this.vanchart = vanchart;
    this.refresh(options);
  },
  refresh: function (options) {
    this.options = options || this.options;
    options = this.options;

    _BaseUtils["default"].extend(this, {
      isFloat: options.floating,
      _floatX: this._getPercentValue(options.x, this.vanchart.width),
      _floatY: this._getPercentValue(options.y, this.vanchart.height)
    });

    _BaseUtils["default"].calculateFontSizeWithScale(options.style);

    this._refresh && this._refresh(options);
  },
  createComponentGroup: function () {
    return this.vanchart.renderer.group().addTo(this.getComponentParentGroup());
  },
  getComponentParentGroup: function () {
    var isMapExport = this.vanchart.isMap() && false;

    return this.isFloat || isMapExport ? this.vanchart.frontGroup : this.vanchart.backGroup;
  },
  useHtmlLabel: function () {
    if (false) {}

    return this.options.useHtml || !(0, _EnvUtils.isSupportSVG)();
  },
  _getLegendType: function (sery) {
    var marker = sery.options.marker;
    var icon = '';

    switch (sery.type) {
      case _Constants["default"].MULTIPIE_CHART:
      case _Constants["default"].PIE_CHART:
        var innerRadius = sery.options.innerRadius;

        if (innerRadius && parseFloat(innerRadius) > 0) {
          return _Constants["default"].DONUT_ICON;
        } else {
          return _Constants["default"].PIE_ICON;
        }

      case _Constants["default"].RADAR_CHART:
        if (sery.options.columnType) {
          return _Constants["default"].NORMAL_ICON;
        }

        break;

      case _Constants["default"].FORCE_BUBBLE_CHART:
      case _Constants["default"].BUBBLE_CHART:
        return _Constants["default"].BUBBLE_ICON;

      case _Constants["default"].TREEMAP_CHART:
        return _Constants["default"].TREEMAP_ICON;

      case _Constants["default"].LINE_MAP:
        return _Constants["default"].NULL_MARKER;

      default:
        icon = _Constants["default"].NORMAL_ICON;
    }

    if (sery.type == _Constants["default"].POINT_MAP && sery.options.icon) {
      return sery.options.icon.iconUrl;
    } //有marker的图例,跟marker的类型一致,跟具体的图表类型无关
    //优先读取image属性


    if (sery.options.image && (0, _EnvUtils.supportFillFilter)()) {
      //图片类型的填充系列用图片作为图例标记
      icon = sery.options.image;
    } else if (marker) {
      icon = marker.symbol ? marker.symbol : _Constants["default"].NULL_MARKER;

      if (icon === _Constants["default"].SYMBOL_AUTO) {
        icon = sery.isMarkerDisplayable ? _Constants["default"].CIRCLE : _Constants["default"].NULL_MARKER;
      }

      if (sery.type == _Constants["default"].SCATTER_CHART && !_BaseUtils["default"].isImageMarker(icon)) {
        icon = _Constants["default"].SCATTER_ICON + icon;
      }
    }

    return icon;
  },
  //用百分比表示或者数字表示的值
  _getPercentValue: function (value, total) {
    if (value) {
      value += '';

      if (value.indexOf('%') != -1) {
        value = parseFloat(value) * total / 100;
      }

      return parseFloat(value);
    }

    return 0;
  },
  _setComponentBounds: function (position, usedSize) {
    if (this.isFloat || this.options && this.options.onZero) {
      this._updateFloatBounds(position, usedSize);
    } else {
      this._updateComponentBounds(position, usedSize);
    }
  },
  isHorizontal: function () {
    var position = this.getPosition();
    return position == _Constants["default"].TOP || position == _Constants["default"].BOTTOM;
  },
  isVertical: function () {
    return !this.isHorizontal();
  },
  getPosition: function () {
    return this.options.position;
  },
  _updateFloatBounds: function (position, usedSize) {
    usedSize = Math.ceil(usedSize);
    var originBounds = this.vanchart.bounds;
    var x = this._floatX;
    var y = this._floatY;
    var width = originBounds.x + originBounds.width - x;
    var height = originBounds.y + originBounds.height - y;

    switch (position) {
      case _Constants["default"].TOP:
        this.bounds = {
          x: x,
          y: y,
          width: width,
          height: usedSize
        };
        break;

      case _Constants["default"].BOTTOM:
        this.bounds = {
          x: x,
          y: y,
          width: width,
          height: usedSize
        };
        break;

      case _Constants["default"].LEFT:
        this.bounds = {
          x: x,
          y: y,
          width: usedSize,
          height: height
        };
        break;

      case _Constants["default"].RIGHT_TOP:
      case _Constants["default"].RIGHT_BOTTOM:
      case _Constants["default"].RIGHT:
        this.bounds = {
          x: x,
          y: y,
          width: usedSize,
          height: height
        };
        break;
    }
    /**
     * CHART-1543
     * 坐标轴设置了0值对齐，就有点儿像CSS布局中设置了position为fixed，它就不会挤占绘图区的空间了，
     * 所以如果this对应的坐标轴设置了0值对齐，那么就不去更新vanchart的plotBounds了。
     * 但是有一种情况比较特殊：this对应的坐标轴设置了0值对齐，而且它对齐的坐标轴的刻度值是从0开始计数的，
     * 那么就得在绘图区里显示this对应的坐标轴，就得去更新vanchart的plotBounds。
     */


    if (this.options.onZero) {
      var relyOn = this.getStandardAxis(); //判断relyOnAxis的刻度值是不是从0开始的

      if (relyOn && Math.abs(relyOn._domain[0]) < 1e-6) {
        this._clipPlotBounds(position, usedSize);
      } else {
        this._clipPlotBoundsWhileFloat(position);
      }
    }
  },

  /**
   * 获取当前值轴设置0值对齐对应的标准值轴。
   * @returns {*}
   */
  getStandardAxis: function () {
    var relyOn = this.componentType === _index.ComponentCst.X_AXIS_COMPONENT ? _index.ComponentCst.Y_AXIS_COMPONENT : _index.ComponentCst.X_AXIS_COMPONENT; //CHART-2130 axisIndex是undefined

    var axisIndex = 0;
    relyOn = this.vanchart.getComponent(relyOn);

    if (this.options.onZero === true) {
      var i = relyOn.getAxisCount();

      while (i--) {
        if (/^standard/.test(relyOn.getAxis(i).alignAxisId)) {
          axisIndex = i;
          break;
        }
      }
    } else {
      axisIndex = this.options.onZero;
    }

    return relyOn.getAxis(axisIndex);
  },

  /**
   * 从原始区域裁减出一块区域以后作为组件区域，并且更新原始区域
   * @param position{string} 位置
   * @para usedSize 占据的大小
   * @private
   */
  _updateComponentBounds: function (position, usedSize) {
    usedSize = Math.ceil(usedSize);
    var originBounds = this.vanchart.bounds;
    var x = originBounds.x;
    var y = originBounds.y;
    var width = originBounds.width;
    var height = originBounds.height;

    switch (position) {
      case _Constants["default"].TOP:
        this.bounds = {
          x: x,
          y: y,
          width: width,
          height: usedSize
        };
        break;

      case _Constants["default"].BOTTOM:
        this.bounds = {
          x: x,
          y: y + height - usedSize,
          width: width,
          height: usedSize
        };
        break;

      case _Constants["default"].LEFT:
        this.bounds = {
          x: x,
          y: y,
          width: usedSize,
          height: height
        };
        break;

      case _Constants["default"].RIGHT_TOP:
      case _Constants["default"].RIGHT_BOTTOM:
      case _Constants["default"].RIGHT:
        this.bounds = {
          x: x + width - usedSize,
          y: y,
          width: usedSize,
          height: height
        };
        break;
    }

    this.vanchart.setPlotBounds(originBounds);

    this._clipPlotBounds(position, usedSize);
  },
  _clipPlotBounds: function (position, usedSize) {
    usedSize = Math.ceil(usedSize);
    var originBounds = this.vanchart.bounds;
    var x = originBounds.x;
    var y = originBounds.y;
    var width = originBounds.width;
    var height = originBounds.height;

    switch (position) {
      case _Constants["default"].TOP:
        originBounds = {
          x: x,
          y: y + usedSize,
          width: width,
          height: height - usedSize
        };
        break;

      case _Constants["default"].BOTTOM:
        originBounds = {
          x: x,
          y: y,
          width: width,
          height: height - usedSize
        };
        break;

      case _Constants["default"].LEFT:
        originBounds = {
          x: x + usedSize,
          y: y,
          width: width - usedSize,
          height: height
        };
        break;

      case _Constants["default"].RIGHT_TOP:
      case _Constants["default"].RIGHT_BOTTOM:
      case _Constants["default"].RIGHT:
        originBounds = {
          x: x,
          y: y,
          width: width - usedSize,
          height: height
        };
        break;
    }

    this.vanchart.setPlotBounds(originBounds);
  },
  // 当坐标轴像CSS中的绝对定位那样不占据绘图区的实际空间的时候，
  // 将vanchart.bounds扩充成最初的大小。
  _clipPlotBoundsWhileFloat: function (position) {
    var originBounds = this.vanchart.bounds;
    var x = originBounds.x;
    var y = originBounds.y;
    var width = originBounds.width;
    var height = originBounds.height;

    switch (position) {
      case _Constants["default"].TOP:
        originBounds = {
          x: x,
          y: y,
          width: width,
          height: height
        };
        break;

      case _Constants["default"].BOTTOM:
        originBounds = {
          x: x,
          y: y,
          width: width,
          height: height - PADDING_FUN()
        };
        break;

      case _Constants["default"].LEFT:
        originBounds = {
          x: x + PADDING_FUN(),
          y: y,
          width: width - PADDING_FUN(),
          height: height
        };
        break;

      case _Constants["default"].RIGHT_TOP:
      case _Constants["default"].RIGHT_BOTTOM:
      case _Constants["default"].RIGHT:
        originBounds = {
          x: x + PADDING_FUN(),
          y: y,
          width: width - PADDING_FUN(),
          height: height
        };
        break;
    }

    this.vanchart.setPlotBounds(originBounds);
  },
  // cannot decide how to clip now
  // clip them in the end
  _recordForPlotBounds: function (position, usedSize) {
    usedSize = Math.ceil(usedSize);
    position === _Constants["default"].RIGHT_TOP && (position = _Constants["default"].RIGHT);
    position === _Constants["default"].RIGHT_BOTTOM && (position = _Constants["default"].RIGHT);
    this.vanchart.clipPool[position] = Math.max(this.vanchart.clipPool[position] || 0, usedSize);
  },
  _getBackgroundColor: function () {
    var opt = this.option;
    var plotColor = typeof opt.plotBackgroundColor == 'string';
    var chartColor = typeof opt.backgroundColor == 'string';
    var color = plotColor ? opt.plotBackgroundColor : chartColor ? opt.backgroundColor : 'white';
    return _ColorUtils["default"].colorToHex(color);
  },
  _maxHeight: function (max) {
    var maxHeight = this.vanchart.height;

    if (max || this.options.maxHeight) {
      return this._getPercentValue(max || this.options.maxHeight, maxHeight);
    }

    return maxHeight;
  },
  _maxLegendHeight: function () {
    return this.options.maxHeight ? this._maxHeight() : this._maxHeight() * DEFAULT_LEGEND_REGION;
  },
  _maxWidth: function (max) {
    var maxWidth = this.vanchart.width;

    if (max || this.options.maxWidth) {
      return this._getPercentValue(max || this.options.maxWidth, maxWidth);
    }

    return maxWidth;
  },
  _maxLegendWidth: function () {
    return this.options.maxWidth ? this._maxWidth() : this._maxWidth() * DEFAULT_LEGEND_REGION;
  },
  _getTickContent: function (tick, formatter) {
    if (!formatter) {
      return tick;
    }

    return _BaseUtils["default"].format(tick, formatter);
  },
  getPlotBounds: function () {
    return this.vanchart.bounds;
  },
  getChartBounds: function () {
    return this.vanchart.getChartBounds();
  },
  getParentDom: function () {
    return this.vanchart.getParentDom();
  },
  getDivParentDom: function () {
    return this.vanchart.getDivParentDom();
  },
  getTooltipComponent: function () {
    return this.vanchart.components.tooltip;
  },
  remove: function () {},
  _bindData: _BaseUtils["default"].bindData,
  invisible: function () {
    return (0, _CoreUtils.hasDefined)(this.options.visible) && this.options.visible === false;
  },
  _innerClip: function (group, bounds) {
    var comp = this,
        vanchart = comp.vanchart,
        renderer = vanchart.renderer;
    bounds = bounds || comp.bounds;

    var innerBounds = _BaseUtils["default"].makeBounds(0, 0, bounds.width, bounds.height);

    if (!this._clip) {
      this._clip = renderer.createClip(innerBounds);
    } else {
      renderer.updateClip(this._clip, innerBounds);
    }

    if (group.type === 'vgroup') {
      var top = 0,
          left = 0,
          right = left + innerBounds.width,
          bottom = top + innerBounds.height;
      group.divG.style({
        'clip': 'rect(' + top + 'px ' + right + 'px ' + bottom + 'px ' + left + 'px)'
      });
      renderer.clip(group.renderG, this._clip);
    } else {
      renderer.clip(group, this._clip);
    }
  }
});

var _default = Base;
exports["default"] = _default;

/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Class = _interopRequireDefault(__webpack_require__(27));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/5/26.
 */
var Evented = _Class["default"].extend({
  /* @method on(type: String, fn: Function, context?: Object): this
   * Adds a listener function (`fn`) to a particular event type of the object. You can optionally specify the context of the listener (object the this keyword will point to). You can also pass several space-separated types (e.g. `'click dblclick'`).
   *
   * @alternative
   * @method on(eventMap: Object): this
   * Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
   */
  on: function (types, fn, context) {
    // types can be a map of types/handlers
    if (typeof types === 'object') {
      for (var type in types) {
        // we don't process space-separated events here for performance;
        // it's a hot path since Layer uses the on(obj) syntax
        this._on(type, types[type], fn);
      }
    } else {
      // types can be a string of space-separated words
      types = _BaseUtils["default"].splitWords(types);

      for (var i = 0, len = types.length; i < len; i++) {
        this._on(types[i], fn, context);
      }
    }

    return this;
  },

  /* @method off(type: String, fn?: Function, context?: Object): this
   * Removes a previously added listener function. If no function is specified, it will remove all the listeners of that particular event from the object. Note that if you passed a custom context to `on`, you must pass the same context to `off` in order to remove the listener.
   *
   * @alternative
   * @method off(eventMap: Object): this
   * Removes a set of type/listener pairs.
   *
   * @alternative
   * @method off: this
   * Removes all listeners to all events on the object.
   */
  off: function (types, fn, context) {
    if (!types) {
      // clear all listeners if called without arguments
      delete this._events;
    } else if (typeof types === 'object') {
      for (var type in types) {
        this._off(type, types[type], fn);
      }
    } else {
      types = _BaseUtils["default"].splitWords(types);

      for (var i = 0, len = types.length; i < len; i++) {
        this._off(types[i], fn, context);
      }
    }

    return this;
  },
  // attach listener (without syntactic sugar now)
  _on: function (type, fn, context) {
    if (!type || !fn) {
      //跳过未定义的listener
      return;
    }

    this._events = this._events || {};
    /* get/init listeners for type */

    var typeListeners = this._events[type];

    if (!typeListeners) {
      typeListeners = [];
      this._events[type] = typeListeners;
    }

    if (context === this) {
      // Less memory footprint.
      context = undefined;
    }

    var newListener = {
      fn: fn,
      ctx: context
    },
        listeners = typeListeners; // check if fn already there

    for (var i = 0, len = listeners.length; i < len; i++) {
      if (listeners[i].fn === fn && listeners[i].ctx === context) {
        return;
      }
    }

    listeners.push(newListener);
    typeListeners.count++;
  },
  _off: function (type, fn, context) {
    var listeners, i, len;

    if (!this._events) {
      return;
    }

    listeners = this._events[type];

    if (!listeners) {
      return;
    }

    if (!fn) {
      // Set all removed listeners to noop so they are not called if remove happens in fire
      for (i = 0, len = listeners.length; i < len; i++) {
        listeners[i].fn = _BaseUtils["default"].falseFn;
      } // clear all listeners for a type if function isn't specified


      delete this._events[type];
      return;
    }

    if (context === this) {
      context = undefined;
    }

    if (listeners) {
      // find fn and remove it
      for (i = 0, len = listeners.length; i < len; i++) {
        var l = listeners[i];

        if (l.ctx !== context) {
          continue;
        }

        if (l.fn === fn) {
          // set the removed listener to noop so that's not called if remove happens in fire
          l.fn = _BaseUtils["default"].falseFn;

          if (this._firingCount) {
            /* copy array in case events are being fired */
            this._events[type] = listeners = listeners.slice();
          }

          listeners.splice(i, 1);
          return;
        }
      }
    }
  },
  // @method fire(type: String, data?: Object, propagate?: Boolean): this
  // Fires an event of the specified type. You can optionally provide an data
  // object — the first argument of the listener function will contain its
  // properties. The event can optionally be propagated to event parents.
  fire: function (type, data, propagate) {
    if (!this.listens(type, propagate)) {
      return this;
    } //todo 这个extend非常浪费性能，暂时屏蔽掉，应该不会有问题才对


    var event = data;

    if (this._events) {
      var listeners = this._events[type];

      if (listeners) {
        this._firingCount = this._firingCount + 1 || 1;

        for (var i = 0, len = listeners.length; i < len; i++) {
          var l = listeners[i];
          l.fn.call(l.ctx || this, event);
        }

        this._firingCount--;
      }
    }

    if (propagate) {
      // propagate the event to parents (set with addEventParent)
      this._propagateEvent(event);
    }

    return this;
  },
  // @method listens(type: String): Boolean
  // Returns `true` if a particular event type has any listeners attached to it.
  listens: function (type, propagate) {
    var listeners = this._events && this._events[type];

    if (listeners && listeners.length) {
      return true;
    }

    if (propagate) {
      // also check parents for listeners if event propagates
      for (var id in this._eventParents) {
        if (this._eventParents[id].listens(type, propagate)) {
          return true;
        }
      }
    }

    return false;
  },
  // @method once(…): this
  // Behaves as [`on(…)`](#evented-on), except the listener will only get fired once and then removed.
  once: function (types, fn, context) {
    if (typeof types === 'object') {
      for (var type in types) {
        this.once(type, types[type], fn);
      }

      return this;
    }

    var handler = _BaseUtils["default"].bind(function () {
      this.off(types, fn, context).off(types, handler, context);
    }, this); // add a listener that's executed once and removed after that


    return this.on(types, fn, context).on(types, handler, context);
  },
  // @method addEventParent(obj: Evented): this
  // Adds an event parent - an `Evented` that will receive propagated events
  addEventParent: function (obj) {
    this._eventParents = this._eventParents || {};
    this._eventParents[_BaseUtils["default"].stamp(obj)] = obj;
    return this;
  },
  // @method removeEventParent(obj: Evented): this
  // Removes an event parent, so it will stop receiving propagated events
  removeEventParent: function (obj) {
    if (this._eventParents) {
      delete this._eventParents[_BaseUtils["default"].stamp(obj)];
    }

    return this;
  },
  _propagateEvent: function (e) {
    for (var id in this._eventParents) {
      this._eventParents[id].fire(e.srcEvent.type, e, true);
    }
  }
});

var _default = Evented;
exports["default"] = _default;

/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Point = _interopRequireDefault(__webpack_require__(46));

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _component = __webpack_require__(4);

var _dataLabelFormatter = _interopRequireDefault(__webpack_require__(24));

var _renderer = __webpack_require__(22);

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _VanChartAutoLabel = __webpack_require__(76);

var _richTextMount = __webpack_require__(54);

var _VanChartLabelBorder = __webpack_require__(36);

var _ThemeConfig = __webpack_require__(17);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/2/19.
 * 系列的抽象
 */
var OUTER_LINE_WIDTH = 1;
var ANIMATION_TIME = 600;
var EASE_TYPE = 'quad-out';
var DEFAULT_STROKE_WIDTH = 2;
var DEFAULT_LABEL_STROKE = 'rgba(255,255,255,0)';

var Series = _Evented["default"].extend({
  vanChartType: "series",
  initialize: function (options, vanchart, index) {
    this.vanchart = vanchart;
    this.points = [];
    this.refresh(options, index);
  },
  refresh: function (options, index) {
    var vanchart = this.vanchart,
        type = options.type || vanchart.options.chartType;
    var plotOptions = vanchart.options.plotOptions;
    var queryList = [options, plotOptions[type], plotOptions];
    this.minSize = _QueryUtils["default"].queryList(queryList, 'minSize');
    this.maxSize = _QueryUtils["default"].queryList(queryList, 'maxSize'); //标记点颜色确认需要

    this.originalColor = options.color;
    this.originalMarkerFillColor = options.marker && options.marker.fillColor;
    this.interpolate = this._getSeriesInterpolate(queryList);
    options = this.options = _BaseUtils["default"].createOptions(options, [plotOptions[type], plotOptions]);
    this.type = type; //不能写在prototype里，pointMap，heatMap，areaMap用的一个series

    this.stack = options.stack;
    this.index = index;
    this.className = 'vancharts-series-' + index;
    this.name = _BaseUtils["default"].pick(options.name, _Constants["default"].BLANK_VALUE_PERCENTAGE);
    this.visible = _BaseUtils["default"].pick(options.visible, true); // 理解有误，应该是默认就为true的，不应该使用之前的visible

    this.state = this.visible ? _Constants["default"].STATE_SHOW : _Constants["default"].STATE_DROPPED;
    this.isMarkerDisplayable = true; // 默认标记点是可见的

    var hexAlpha;

    if (!this.isSeriesAccumulated() && this.type !== _Constants["default"].STRUCTURE_CHART) {
      var color = this.options.color || vanchart.getDefaultSeriesColor(this.name);
      var opacity = options.opacity;
      hexAlpha = _ColorUtils["default"].getStandardColorAndOpacity(color, opacity);
      color = hexAlpha.hex;
      opacity = this.isGradualStyle() ? this._getGradualStyleOpacity() : hexAlpha.alpha;
      var fillColor = this.options.fillColor;
      fillColor = fillColor === true ? color : fillColor;
      var fillColorOpacity = +options.fillColorOpacity;
      fillColorOpacity = isNaN(fillColorOpacity) ? this._getDefaultFillColorOpacity() : fillColorOpacity;
      hexAlpha = _ColorUtils["default"].getStandardColorAndOpacity(fillColor, fillColorOpacity);
      fillColor = hexAlpha.hex;
      fillColorOpacity = hexAlpha.alpha; //shine:clone原因：
      // 1.散点图标记点类型为自动时，各个系列循环不同标记点，需要clone一份，再改symbol。
      // 2.marker的color和alpha都会改变

      var marker = options.marker = _BaseUtils["default"].clone(options.marker);

      if ((0, _CoreUtils.hasDefined)(marker)) {
        var colorAlpha = this._getMarkerColorAlpha();

        marker.fillColor = colorAlpha.markerColor;
        marker.fillColorOpacity = colorAlpha.markerOpacity;

        if (this.type === _Constants["default"].SCATTER_CHART && marker.symbol === _Constants["default"].SYMBOL_AUTO) {
          options.marker.symbol = _BaseUtils["default"].getDefaultMarkerSymbol(index);
        }
      }

      this.color = color;
      this.opacity = opacity;
      this.fillColor = fillColor;
      this.fillColorOpacity = fillColorOpacity;
      this.marker = marker;
    }

    if ((0, _CoreUtils.hasDefined)(this.options.startAngle)) {
      var startAngle = this.options.startAngle,
          endAngle = this.options.endAngle;

      if (startAngle > endAngle) {
        startAngle -= 360;
      } // CHART-1207
      // if-else的用法在解决startAngle=360， endAngle=0的情况出现一些问题
      // 现在把if-else改成两个if


      if (startAngle === endAngle) {
        endAngle = startAngle + 360;
      }

      this.startAngle = _BaseUtils["default"].toRadian(startAngle);
      this.endAngle = _BaseUtils["default"].toRadian(endAngle);
    } // bind Axis


    this._bindAxis();

    var data = this._loadData ? this._loadData(options.data) : options.data || []; // so dirty...

    if (!this.isTreeSeries()) {
      this._dealData(data);
    }

    return this;
  },
  _getGradualStyleOpacity: function () {
    return this.options.opacity || 1;
  },
  isGradualStyle: function () {
    return this.options.gradualStyle === _Constants["default"].STYLE_CUSTOM;
  },

  /**
   * 处理系列下的数据点
   * @param data
   * @private
   */
  _dealData: function (data) {
    var newPoints = [],
        series = this,
        pointsMap = {};
    var vanchart = this.vanchart,
        type = this.type;
    this.points.forEach(function (point) {
      // todo
      // _getPointKey: point here, data[i] below?
      var key = series._getPointKey(point);

      pointsMap[key] = pointsMap[key] || [];
      pointsMap[key].push(point);
    });
    var i, len, key, pointArray;

    for (i = 0, len = data.length; i < len; i++) {
      key = series._getPointKey(data[i]), pointArray = pointsMap[key];
      var point = null;

      if (pointArray) {
        for (var j = 0, count = pointArray.length; j < count; j++) {
          if (point = pointArray[j]) {
            pointArray[j] = null;
            break;
          }
        }

        if (point) {
          //clear states
          point._lastValue = point.options[series.getTargetKey()];
          point._lastPercent = point.percentage;
          point._lastArrivalRate = point.arrivalRate;
          point.childSeries = null;
          point.geo = null; //set new data

          point.refresh(data[i]);
        }
      }

      if (!point) {
        point = new _Point["default"](data[i], this);
      }

      newPoints.push(point);
    }

    for (key in pointsMap) {
      pointsMap[key] && pointsMap[key].forEach(function (p) {
        vanchart.removePointGraphics(p, type);
      });
    }

    if (this.options.sort) {
      //漏斗图的数据是有序的
      //去掉filternullvalue原因：fr那边过滤条件可以设置显示系列为空数据，图例里面得有
      newPoints = newPoints.sort(function (pointA, pointB) {
        return Math.abs(pointB.getTargetValue()) - Math.abs(pointA.getTargetValue());
      });
    }

    var points = this.points = newPoints; // @CHART-1554  accumulatedSeries下的point.points应该在这里设置

    if (this.isSeriesAccumulated()) {
      for (i = -1, len = points.length; ++i < len;) {
        points[i].points = points;
      }
    }
  },
  _getPointKey: function (point) {
    // 系列基于多分类轴时，使用字符串格式的categoryArray
    if (this.isMultiCategoryAxisBased()) {
      return _BaseUtils["default"].encodeCategoryArray(point.categoryArray);
    }

    return point.x;
  },

  /**
   * @Cmen:判断系列是否基于多分类轴:
   * @returns {boolean}
   */
  isMultiCategoryAxisBased: function () {
    var axis = this[this.getBaseAxisType()]; //当前系列对应的基础轴

    return axis && axis.isMultiCateAxis && axis.isMultiCateAxis();
  },
  //不在options的原因：radar和columnRadar不同
  _getDefaultFillColorOpacity: function () {
    return 1;
  },
  getStackAxis: function () {
    return this[this.getTargetKey() + 'Axis'];
  },
  isNullValue: function (point) {
    var originValue = point.options[point.series.getTargetKey()];
    return originValue == '-' || (0, _CoreUtils.hasNotDefined)(originValue);
  },
  _getMarkerColorAlpha: function () {
    var vanchart = this.vanchart,
        options = this.options;
    var plotOptions = vanchart.options.plotOptions,
        _options = plotOptions[this.type];
    var plotOptionsMarker = _options && _options.marker || plotOptions.marker;
    var opacity = options.opacity,
        seriesMarker = options.marker;

    var _markerColor = seriesMarker && seriesMarker.fillColor || this.options.color || plotOptionsMarker && plotOptionsMarker.fillColor || vanchart.getDefaultSeriesColor(this.name);

    var _markerOpacity = opacity;

    if ((0, _CoreUtils.hasDefined)(_markerColor)) {
      var hexAlpha = _ColorUtils["default"].getStandardColorAndOpacity(_markerColor, opacity);

      _markerColor = hexAlpha.hex;
      _markerOpacity = hexAlpha.alpha;
    }

    return {
      markerColor: _markerColor,
      markerOpacity: _markerOpacity
    };
  },
  _bindAxis: function () {
    var series = this,
        seriesOptions = series.options,
        vanchart = series.vanchart;

    series._getAxisTypes().forEach(function (axisType) {
      if (vanchart[axisType]) {
        var targetAxis = vanchart[axisType](seriesOptions[axisType]);

        if (targetAxis) {
          targetAxis.series.push(series);
          series[axisType] = targetAxis;
        }
      }
    });
  },
  supportTooltipShared: function () {
    return this.xAxis || this.yAxis || this.angleAxis;
  },
  _getAxisTypes: function () {
    return ['xAxis', 'yAxis'];
  },
  //用来计算百分比的指标的名字,相当于value的含义
  getTargetKey: function () {
    return 'y';
  },
  //图形坐在的那个坐标轴的key
  getBaseAxisType: function () {
    return 'xAxis';
  },
  _calculateAutoLabelPos: function (point, pos, isVertical, manager, rightBottom, hide) {
    if (hide === void 0) {
      hide = false;
    }

    var step = 3; // 自动调整的时候每次3px
    // 先测试一下从上往下的效果

    var labelDim = point.labelDim,
        plotBounds = this.vanchart.bounds;
    var testPos;

    if (isVertical) {
      var startY, endY;

      if ((0, _CoreUtils.hasDefined)(rightBottom)) {
        if (rightBottom) {
          // 往下
          startY = Math.max(0, pos.y);
          endY = plotBounds.height - labelDim.height;
          testPos = (0, _VanChartAutoLabel.verticalPosFix)(startY, endY, step, labelDim, pos, manager);
        } else {
          endY = 0;
          startY = Math.min(pos.y, plotBounds.height - labelDim.height);
          testPos = (0, _VanChartAutoLabel.verticalPosFix)(startY, endY, -step, labelDim, pos, manager);
        }
      } else {
        // 往下
        startY = Math.max(0, pos.y);
        endY = plotBounds.height - labelDim.height;
        testPos = (0, _VanChartAutoLabel.verticalPosFix)(startY, endY, step, labelDim, pos, manager); // 往上

        if (!testPos) {
          endY = 0;
          startY = Math.min(pos.y, plotBounds.height - labelDim.height);
          testPos = (0, _VanChartAutoLabel.verticalPosFix)(startY, endY, -step, labelDim, pos, manager);
        }
      }
    } else {
      var startX, endX;

      if ((0, _CoreUtils.hasDefined)(rightBottom)) {
        if (rightBottom) {
          // 往右
          startX = Math.max(0, pos.x);
          endX = plotBounds.width - labelDim.width;
          testPos = (0, _VanChartAutoLabel.horizontalPosFix)(startX, endX, step, labelDim, pos, manager);
        } else {
          endX = 0;
          startX = Math.min(pos.x, plotBounds.width - labelDim.width);
          testPos = (0, _VanChartAutoLabel.horizontalPosFix)(startX, endX, -step, labelDim, pos, manager);
        }
      } else {
        // 往右
        startX = Math.max(0, pos.x);
        endX = plotBounds.width - labelDim.width;
        testPos = (0, _VanChartAutoLabel.horizontalPosFix)(startX, endX, step, labelDim, pos, manager); // 往左

        if (!testPos) {
          endX = 0;
          startX = Math.min(pos.x, plotBounds.width - labelDim.width);
          testPos = (0, _VanChartAutoLabel.horizontalPosFix)(startX, endX, -step, labelDim, pos, manager);
        }
      }
    }

    return testPos || (hide ? {} : pos);
  },
  _getArcPoint: function (r, radian) {
    return [this._dealWithFloat(r * Math.sin(radian)), this._dealWithFloat(-r * Math.cos(radian))];
  },
  _getNormalTrendLineXYValues: function (sery) {
    var xValues = [];
    var yValues = [];
    var key = this.vanchart.isInverted() ? 'posY' : 'posX';
    var location = this.vanchart.isInverted() ? _Constants["default"].LEFT : _Constants["default"].BOTTOM;
    sery.points.sort(function (p1, p2) {
      return p1[key] - p2[key];
    });
    sery.points.forEach(function (point) {
      if (!point.isNull) {
        xValues.push(point.posX);
        yValues.push(point.posY);
      }
    });
    return [xValues, yValues, location, sery.xAxis && sery.xAxis.isAxisReversed()];
  },
  _getSeriesInterpolate: function (queryList) {
    var step = _QueryUtils["default"].queryList(queryList, 'step');

    var curve = _QueryUtils["default"].queryList(queryList, 'curve');

    var options = queryList[0];
    var interpolate = 'linear';

    if (options.step || step && !options.curve) {
      interpolate = 'step-after';
    } else if (options.curve || curve && !options.step) {
      interpolate = 'cardinal';
    }

    return interpolate;
  },
  _getAngle: function (current, center) {
    center = center || {
      x: 0,
      y: 0
    };
    return Math.atan2(current.y - center.y, current.x - center.x) / (Math.PI / 180);
  },
  _getBackgroundColor: function () {
    var opt = this.vanchart.options;
    var plotColor = typeof opt.plotBackgroundColor === 'string';
    var chartColor = typeof opt.backgroundColor === 'string';
    var color = plotColor ? opt.plotBackgroundColor : chartColor ? opt.backgroundColor : 'white';
    return _ColorUtils["default"].colorToHex(color);
  },
  _getBackgroundColorWithAlpha: function () {
    var opt = this.vanchart.options;

    if (typeof opt.plotBackgroundColor === 'string') {
      return opt.plotBackgroundColor;
    }

    if (typeof opt.backgroundColor === 'string') {
      return opt.backgroundColor;
    }
  },
  getSeryTotalValue: function () {
    var total = 0;
    this.points.forEach(function (point) {
      total += point.getTargetValue();
    });
    return total;
  },
  getLegendKey: function (point) {
    return this.isSeriesAccumulated() ? point.name : this.name;
  },
  calculateLabelInfo: function (point) {
    (0, _dataLabelFormatter["default"])(point);
  },
  _getPercentValue: function (value, total) {
    if (value) {
      value += '';

      if (value.indexOf('%') !== -1) {
        value = parseFloat(value) * total / 100;
      }

      return parseFloat(value);
    }

    return 0;
  },
  isSupportLegendHighlight: function () {
    return true;
  },
  isSeriesAccumulated: function () {
    return false;
  },
  isTreeSeries: function () {
    return false;
  },

  /**
   * 增加新的point
   * @param {[type]} options [description]
   * @param {[type]} redraw  [description]
   */
  addPoint: function (options, redraw) {
    var data = this._getOriginSerData();

    var vanchart = this.vanchart; // todo 多分类轴下等情况下，需要重新计算dataDomain

    data.push(options);
    redraw && vanchart.update();
  },

  /**
   * 移除单个point
   * @param  {[type]} index  [description]
   * @param  {[type]} redraw [description]
   * @return {[type]}        [description]
   */
  removePoint: function (index, redraw) {
    if (index < 0) {
      return;
    }

    var series = this,
        vanchart = this.vanchart,
        data = this._getOriginSerData();

    var serIndex = vanchart.series.indexOf(series);
    data.splice(index, 1);
    series.options.data.splice(index, 1);

    if (vanchart._removeAllAndHasNoAdd(series.options, serIndex)) {
      series.remove();
      vanchart.series.splice(serIndex, 1);
      vanchart.options.series.splice(serIndex, 1);
    }

    redraw && vanchart.update();
  },

  /**
   * 更新单个point的数据信息
   * @param  {[type]} index  [description]
   * @param  {[type]} option [description]
   * @param  {[type]} redraw [description]
   * @return {[type]}        [description]
   */
  updatePoint: function (index, option, redraw) {
    if (index < 0) {
      return;
    }

    var vanchart = this.vanchart,
        data = this._getOriginSerData();

    data[index] = option;
    redraw && vanchart.update();
  },

  /**
   * 更新系列配置项
   * @param {Object} serData
   * */
  updateSeries: function (serData) {
    var series = this,
        vanchart = this.vanchart,
        originSeriesData = vanchart.options.series;
    var serIndex = vanchart.series.indexOf(series);
    serData = _BaseUtils["default"].clone(serData);
    serData.data = originSeriesData[serIndex].data;
    originSeriesData[serIndex] = serData;
  },

  /**
   * 计算数据点的option在对应的vanchart.series中具体series中的索引
   * 更具该索引，便可以更新和删除该数据点
   * @param option
   * @returns {number}
   */
  calculatePointIndex: function (option) {
    var series = this,
        vanchart = this.vanchart,
        pos = -1,
        index = 0;

    var data = this._getOriginSerData();

    var clone = _BaseUtils["default"].clone; // 计算坐标点

    var toLnglatPoint = function (option) {
      if (option.lnglat) {
        return option;
      }

      var geo = vanchart.getCurrentGeo();
      var features = geo.getFeaturesByName(option.name, series.type);
      var lnglat = geo.getDataPointLngLat({
        options: option,
        series: series
      }, features && features[0]);
      var newOption = clone(option); // 只用作判断依据，不修改原始数据

      newOption.lnglat = lnglat;
      return lnglat && newOption;
    };

    var isLineMap = series.type === _Constants["default"].LINE_MAP; // 这种坐标数据中不存在name的直接返回，不继续算了

    if (isLineMap && (!toLnglatPoint(option.from) || !toLnglatPoint(option.to))) {
      return -1;
    } // 重新构建一个新的option，用于_getPointKey


    var reBuildOption = function (option) {
      if (isLineMap) {
        var newOption = clone(option);
        newOption.from = toLnglatPoint(option.from);
        newOption.to = toLnglatPoint(option.to);
        return newOption.from && newOption.to && newOption;
      }

      return option;
    };

    var op1, op2;

    while (index < data.length) {
      op1 = reBuildOption(option);
      op2 = reBuildOption(data[index]);

      if (!op1 || !op2) {
        index++; // 这里不应该跳出，而是继续下一个while

        continue;
      }

      var key = series._getPointKey(op1);

      var pointKey = series._getPointKey(op2);

      if (key === pointKey) {
        pos = index;
        break;
      }

      index++;
    }

    return pos;
  },

  /**
   * @Cmen:监控刷新时，有个比较尴尬的问题：
   * 现在的图表绘制，都是直接使用初始的OriginOption，直接使用，这就导致第一次绘制结束，OriginOption里面的series已经被修改(扩展)了，
   * 而监控刷新时那些未发生值变化的数据，却依旧使用OriginOption.series，而此时的这个series已经被扩展了一些方法和属性，
   * 这就导致某些属性诸如markerFillColor等不能被更新,因此在监控刷新时，应该修改原始数据，
   * 而绘图的时候，使用原始数据的拷贝，不对原始的series进行属性和方法扩展
   */
  _getOriginSerData: function () {
    var series = this,
        vanchart = this.vanchart,
        originSeriesData = vanchart.options.series;
    var serIndex = vanchart.series.indexOf(series);
    return serIndex < 0 ? [] : originSeriesData[serIndex].data;
  }
}); //view related


Series.include({
  getClosestPoint: function () {
    return null;
  },
  getDefaultTooltipFormatter: function () {
    return {
      categoryFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{CATEGORY}{SERIES}{VALUE}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  },
  isToolTipFollow: function (point) {
    return !this.vanchart.isMobile() && point.options.tooltip.follow;
  },
  getTooltipPos: function (point, divDim, event) {
    var leftTopPos;

    if (this.isToolTipFollow(point)) {
      var pos = event.containerPoint;
      leftTopPos = [pos.x + 10, pos.y + 10];
    } else {
      leftTopPos = this._getFixedPos(point, divDim);
    }

    if (!leftTopPos) {
      return;
    } //调整位置


    var chartBounds = this.vanchart.getChartBounds();
    var top = chartBounds.y,
        left = chartBounds.x;
    var bottom = chartBounds.y + chartBounds.height;
    var right = chartBounds.x + chartBounds.width;
    var x = leftTopPos[0],
        y = leftTopPos[1];

    if (x < left) {
      x += left - x;
    } else if (x + divDim.width > right) {
      x -= x + divDim.width - right;
    }

    if (y < top) {
      y += top - y;
    } else if (y + divDim.height > bottom) {
      y -= y + divDim.height - bottom;
    }

    return [x, y];
  },
  //统一处理渐变色,图片填充,阴影等情况,默认就返回颜色
  getFillFilter: function (color) {
    return color;
  },
  filterRender: function () {
    this.useCanvas() ? this._canvasRender() : this._svgFilterRender();
  },
  render: function () {
    this.useCanvas() ? this._canvasRender() : this._svgRender();
  },
  useCanvas: _BaseUtils["default"].falseFn,
  _createGroup: function (renderer, vanchart) {
    return renderer.group().addTo(vanchart.clipSeriesGroup);
  },
  _svgRender: function () {
    //todo 这个临时变量应该可以规避
    this.initialAnimationMoving = !this.group;
    this.drawPolarAxis && this.drawPolarAxis();
    var vanchart = this.vanchart,
        renderer = vanchart.renderer;

    if (!this.group) {
      this.group = this._createGroup(renderer, vanchart).attr('transform', _BaseUtils["default"].makeTranslate(this._getTranslate())); // MOBILE-10912

      if (!vanchart.isMobile()) {
        this.group.style('cursor', this._pointerStyle());
      }
    }

    this.group.attr('class', this.className + ' ' + this.type); //对于可以自定义位置的如雷达图,仪表盘这边的translate不是绘图取

    if (this.type === _Constants["default"].GAUGE_CHART) {
      this.group.animate({
        duration: ANIMATION_TIME,
        ease: EASE_TYPE,
        attr: {
          transform: _BaseUtils["default"].makeTranslate(this._getTranslate())
        }
      });
    } else {
      this.group.attr('transform', _BaseUtils["default"].makeTranslate(this._getTranslate()));
    }

    this.drawSeries && this.drawSeries();
    this.drawPoints();
  },
  _svgFilterRender: function () {
    var series = this; //todo：@eason 拖拽范围图例filter一部分点后，缩放的时候visible==false的点会被remove掉

    series.getDataToDraw().forEach(function (point) {
      if (point.isVisible()) {
        point.graphic && point.graphic.style({
          'display': 'inline'
        });

        if (!point.textGraphic) {
          series._createTextGraphic(point);
        }

        if (!point.effectGraphic) {
          series.drawPointEffect(point);
        }
      } else {
        point.graphic && point.graphic.style({
          'display': 'none'
        });
        point.textGraphic && point.textGraphic.remove();
        point.textGraphic = null;
        series.clearPointEffect(point);
      }
    });
  },
  _canvasRender: function () {
    if (!this._canvas) {
      this._canvas = (0, _renderer.createCanvasRenderer)(this.vanchart.dom, this.vanchart);

      this._canvas.onAdd();
    }

    this._canvas.clearAll();

    this._canvas.addSeries(this);
  },
  _pointerStyle: function () {
    // point为null时，设计器导出时是没有hyperlink和onClick属性的，这里过滤一下
    var validPoints = this.points.filter(function (p) {
      return !p.isNull;
    });
    return validPoints[0] && (validPoints[0].options.onClick || this.vanchart.options.hyperLink) ? 'pointer' : '';
  },
  getDataToDraw: function () {
    return this.points;
  },
  getTextDataToDraw: function () {
    return this.getDataToDraw();
  },
  // updatePointGraphic:function(point){
  updatePointGraphic: function () {},
  // 标记点刷新直接删除重新画会导致移动端滚动至边缘后无法停止滚动
  _updateMarkerPointGraphic: function (point) {
    var group = point.graphic,
        options = point.options;

    if (!group) {
      return;
    }

    var marker = options.marker;
    var markerType = marker && marker.symbol;

    if (_BaseUtils["default"].isImageMarker(markerType)) {
      group.markerPath && group.markerPath.remove();
      group.markerPath = null;
    } else {
      group.image && group.image.remove();
      group.image = null;
    }
  },
  // 现在的处理方式是全部重新写一遍
  drawPoints: function () {
    var series = this,
        vanchart = series.vanchart;

    var graphicGroup = this._getPointGraphicGroup();

    graphicGroup && vanchart.registerInteractiveTarget(this, graphicGroup);

    if (this.initialAnimationMoving && this.initialAnimation) {
      this.initialAnimation();
    }

    var delay = this._calculateAnimationDelay();

    var points = series.getDataToDraw();

    for (var i = 0, len = points.length; i < len; i++) {
      series.drawPoint(points[i], delay);
    }
  },
  _drawEffectPoints: function () {
    var series = this;
    series.getTextDataToDraw().forEach(function (point) {
      series.drawPointEffect(point);
    });
  },
  drawPointEffect: function (point) {
    var series = point.series;
    series.clearPointEffect(point);
    var time = point.getEffectTime();

    if (time) {
      //shine:0秒没有effect动画
      series.effectAnimation(point);
      point.effectInterval = _BaseUtils["default"].setInterval(function () {
        series.effectAnimation(point);
      }, time);
    }
  },
  clearPointEffect: function (point) {
    point.clearPointEffect();
  },
  effectAnimation: function () {},
  _drawUpdatePoints: function (point, delay) {
    this._updatePointGraphicStyle(point); // 更新颜色
    // 大量数据情形下缩放，直接更新attr，不加动画了


    if (this.vanchart.isZoomingWithLargeModel()) {
      point.graphic.attr(this.getPointUpdateAnimationAttr(point, delay).attr);
    } else {
      point.graphic.animate(this.getPointUpdateAnimationAttr(point, delay));
    }

    this.vanchart.registerInteractiveTarget(point, point.graphic); // 更新映射关系
  },
  _drawEnterPoints: function (point) {
    var series = this,
        group = series._getPointGraphicGroup();

    var graphic = point.graphic = this._createPointGraphic(point);

    series._updatePointGraphicStyle(point);

    var reShow = series.reShowPoint(point);
    var attrFun = reShow && series.getPointReShowAttr ? series.getPointReShowAttr : series.getPointInitAttr;
    var styleFun = reShow && series.getPointReShowStyle ? series.getPointReShowStyle : series.getPointInitStyle;
    var animateFun = reShow && series.getPointReShowAnimationAttr ? series.getPointReShowAnimationAttr : series.getPointInitAnimationAttr; // todo 折线图这里会导致标记点在折线的前面

    point.hasEffect() ? graphic.addTo(group) : graphic.addToBack(group);
    graphic.attr(attrFun ? attrFun.call(series, point) : {}).style(styleFun ? styleFun.call(series, point) : {}).animate(animateFun ? animateFun.call(series, point) : {});
    series.vanchart.registerInteractiveTarget(point, graphic);
  },
  _drawExitPoints: function (point) {
    var series = point.series;

    if (series.getPointDropAnimationAttr) {
      point.graphic.animate(series.getPointDropAnimationAttr(point)).remove();
    } else {
      point.graphic.remove();
    }
  },
  // todo
  // 范围图例导致复杂判断
  // TreeSeries 目前覆盖了这个方法
  // 理清逻辑 或者 加测试
  drawPoint: function (point, delay) {
    delay = delay || 0;
    var shouldBeVisible = point.isVisible();
    var currentVisibleState = point.graphic && point.graphic.isVisible(); // 清除闪烁动画, 绘制之后再重新绘制

    this.clearPointEffect(point);

    if (shouldBeVisible === currentVisibleState) {
      point.graphic && this._drawUpdatePoints(point, delay);
    } else if (shouldBeVisible && !currentVisibleState) {
      if (point.graphic && !point.graphic.removed()) {
        point.graphic.style('display', 'inline');

        this._drawUpdatePoints(point, delay);
      } else {
        this._drawEnterPoints(point);
      }
    } else if (!shouldBeVisible && currentVisibleState) {
      this._drawExitPoints(point);
    }
  },
  _getEffectTime: function (point) {
    // point.options.effect=undefined依然会走到这边的场景：
    // 一个没有闪烁动画的点刷新有闪烁动画的点。options更新之后，_drawEffectPoints(clear && create effect)之前，effectInterval还没被clear
    return (0, _CoreUtils.hasNotDefined)(point.options.effect) || isNaN(point.options.effect.period) ? point.series.getDefaultEffectTime() : point.options.effect.period;
  },
  _getPointEffectGroup: function (point) {
    var series = point.series,
        renderer = series.vanchart.renderer;
    return point.effectGraphic = point.effectGraphic || renderer.group().addTo(series._getPointGraphicGroup()).style('pointer-events', 'none');
  },
  _createPointGraphic: function (point) {
    var graphicKey = this.getPointGraphicKey(point),
        renderer = this.vanchart.renderer;
    return renderer[graphicKey]();
  },
  getStyle: function (p) {
    var options = p.options,
        series = p.series;
    var borderColor = p.getPointBorderColor(p.borderColor);
    return {
      'fill': series.getFillFilter(p.color, p),
      'fill-opacity': options.image ? 1 : p.opacity,
      'stroke': borderColor,
      'stroke-opacity': p.borderOpacity,
      'stroke-width': options.borderWidth,
      'filter': 'none'
    };
  },
  _updateHighLightOpacity: function (point, style) {
    var target = this.vanchart.highlightTarget;

    if (target != null && this.isSupportLegendHighlight()) {
      // 理论上系列值为""也可以触发高亮
      var key = this.getLegendKey(point);
      var opacity = key == target || point._rangeItem == target ? 1 : _Constants["default"].HOVER_OPACITY;
      style['fill-opacity'] = style['stroke-opacity'] = opacity;
    }
  },
  _getDynamicStyle: function (point) {
    var style = this.getStyle(point);

    this._updateHighLightOpacity(point, style);

    style['pointer-events'] = "auto";
    return style;
  },
  _updatePointGraphicStyle: function (point, style) {
    style = style || point.series._getDynamicStyle(point);
    point.graphic && point.graphic.style(style);
  },
  _updatePointLabelStyle: function (point) {
    var style = {
      'fill-opacity': _Constants["default"].DEFAULT_OPACITY,
      'stroke-opacity': point.borderOpacity
    };

    this._updateHighLightOpacity(point, style);

    point.textGraphic && point.textGraphic.style(style);
    point.leadLine && point.leadLine.style(style);
    point.textBorderPath && point.textBorderPath.style(style);
  },
  _createMarker: function (marker, group) {
    var markerType = marker.symbol,
        renderer = this.vanchart.renderer;
    group = group || renderer.group();

    if (_BaseUtils["default"].isImageMarker(markerType)) {
      var w = marker.width,
          h = marker.height;
      group.image = renderer.image({
        'preserveAspectRatio': 'none',
        'x': -w / 2,
        'y': -h / 2,
        'width': w,
        'height': h
      }).imageContent(markerType).addTo(group);
    } else {
      group.markerPath = renderer.path().addTo(group);
    }

    return group;
  },
  _updateImageMarker: function (marker, group) {
    var renderer = this.vanchart.renderer;
    var width = marker.width,
        height = marker.height,
        markerType = marker.symbol;
    group.image = group.image || renderer.image({
      'preserveAspectRatio': 'none'
    }).addTo(group);
    group.image.imageContent(markerType).attr({
      x: -width / 2,
      y: -height / 2,
      width: width,
      height: height
    });
  },
  _updateMarker: function (point, group, marker) {
    group = group || point.graphic;
    marker = marker || point.options.marker;
    var markerType = marker.symbol,
        vanchart = this.vanchart,
        backgroundColor = this._getBackgroundColorWithAlpha() || (0, _ThemeConfig.getThemeAutoValue)(_Constants["default"].AUTO, 'markerStrokeColor', vanchart.isDarkTheme());

    if (_BaseUtils["default"].isImageMarker(markerType)) {
      this._updateImageMarker(marker, group);

      return;
    } // CHART-16207 自定义标记点图片遗留，如果不满足要删掉image dom


    group.image && group.image.remove();
    var opacity = marker.fillColorOpacity;
    var target = this.vanchart.highlightTarget;

    if ((0, _CoreUtils.hasDefined)(target)) {
      var key = this.getLegendKey(point);
      opacity = key == target || point._rangeItem == target ? 1 : _Constants["default"].HOVER_OPACITY;
    }

    var isLine = this.type === _Constants["default"].LINE_CHART,
        isHollow = this._isHollowMarker(markerType),
        fillColor = marker.fillColor;

    var radius = this._getMarkerRadius(point, marker, false);

    var strokeWidth = radius > 0 ? DEFAULT_STROKE_WIDTH : 0;
    group.markerPath = group.markerPath || this.vanchart.renderer.path().addTo(group);

    if (isHollow) {
      group.markerPath.attr({
        'd': _PathGenerator["default"].getMarkerPath(markerType, radius)
      }).style({
        'stroke': fillColor,
        'stroke-width': strokeWidth,
        'stroke-opacity': opacity,
        'fill': backgroundColor
      });
    } else if (isLine) {
      // 折线图的实心标记点有2px颜色为背景色的外描边
      group.markerPath.attr({
        'd': _PathGenerator["default"].getMarkerPath(markerType, radius)
      }).style({
        'fill': fillColor,
        'fill-opacity': opacity,
        'stroke': backgroundColor,
        'stroke-width': strokeWidth
      });
    } else {
      group.markerPath.attr({
        'd': _PathGenerator["default"].getMarkerPath(markerType, radius)
      }).style({
        'fill': fillColor,
        'fill-opacity': opacity
      });
    }
  },
  _getMarkerRadius: function (point, marker, isChosen) {
    var markerType = marker.symbol;
    var isMarkerDisplayable = point.series.isMarkerDisplayable;

    var isHollow = this._isHollowMarker(markerType);

    var isLine = this.type === _Constants["default"].LINE_CHART;
    var radius = (0, _CoreUtils.hasDefined)(marker.radius) ? marker.radius : _Constants["default"].MARKER_RADIUS;
    radius = isMarkerDisplayable || isChosen ? radius : 0; // 标记点为无时鼠标悬浮时标记点也会显示

    if (radius <= 0) {
      return radius;
    } // 空心标记点为居中描边，折线实心标记点为外描边


    radius = isHollow ? radius - DEFAULT_STROKE_WIDTH / 2 : isLine ? radius + DEFAULT_STROKE_WIDTH / 2 : radius;
    return radius + (isChosen ? 2 : 0);
  },
  _onMarkerPressed: function (point) {
    var marker = point.options && point.options.marker,
        markerType = marker.symbol;

    if (!point.graphic || _BaseUtils["default"].isImageMarker(markerType)) {
      return;
    }

    var isHollow = this._isHollowMarker(markerType),
        clickColor = point.clickColor,
        clickOpacity = point.clickOpacity;

    var style = isHollow ? {
      'stroke': clickColor,
      'stroke-opacity': clickOpacity
    } : {
      'fill': clickColor,
      'fill-opacity': clickOpacity
    };
    point.graphic.markerPath.style(style);
  },
  _onMarkerState: function (point, isChosen) {
    var marker = point.options.marker,
        markerType = marker.symbol,
        gap = 5;

    if (point.graphic) {
      gap = 2;

      if (_BaseUtils["default"].isImageMarker(markerType)) {
        var w = marker.width + (isChosen ? 4 : 0),
            h = marker.height + (isChosen ? 4 : 0);
        point.graphic.image.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
          duration: 300,
          ease: _BezierEasing["default"].custom["ease-out-back"],
          attr: {
            'x': -w / 2,
            'y': -h / 2,
            'width': w,
            'height': h
          }
        });
      } else {
        var pathAnimate = function (path, r, isLine) {
          // CHART-15766 报错interrupt of null
          if ((0, _CoreUtils.hasNotDefined)(path)) {
            return;
          }

          var animate = {
            duration: 300,
            ease: _BezierEasing["default"].custom["ease-out-back"],
            attr: {
              'd': _PathGenerator["default"].getMarkerPath(markerType, r)
            }
          }; // 折线图标记点自动显示为无时，鼠标悬浮会有带描边的实心标记点

          if (r > 0 && isLine) {
            animate.style = {
              "stroke-width": DEFAULT_STROKE_WIDTH
            };
          }

          path.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate(animate);
        };

        var radius = this._getMarkerRadius(point, marker, isChosen);

        var isLine = this.type === _Constants["default"].LINE_CHART;
        pathAnimate(point.graphic.markerPath, radius, isLine);
      }
    }

    var series = point.series,
        diffX = 0,
        diffY = 0;

    if (series.type === _Constants["default"].RADAR_CHART) {
      var pos = series._getArcPoint(gap, point.radian);

      diffX = pos[0];
      diffY = pos[1];
    } else {
      diffY = -gap;
      var options = point.options,
          dataLabels = options.dataLabels,
          align = point.labelAlign || dataLabels.align;

      if (align === _Constants["default"].BOTTOM) {
        diffY = gap;
      }
    }

    series._labelTransformState(point, diffX, diffY, isChosen, 300, _BezierEasing["default"].custom["ease-out-back"]);
  },
  removeDefaultMarker: function () {
    var series = this;
    series.defaultMarker && series.defaultMarker.remove();
    series.defaultMarker = null;
  },
  _onMarkerMouseOver: function (point) {
    var series = point.series;

    series._onMarkerState(point, true);

    if (!point.graphic) {
      var marker = this._getDefaultMarker(point);

      series.defaultMarker = series.defaultMarker || this._createMarker(marker).addTo(this.group);
      series.defaultMarker.attr('transform', 'translate(' + point.posX + ',' + point.posY + ') scale(0.01)');

      this._updateMarker(point, series.defaultMarker, marker);

      series.defaultMarker.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
        duration: 300,
        ease: 'ease',
        attr: {
          'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(1.5)'
        }
      });
    }
  },
  _onMarkerMouseOut: function (point) {
    var series = point.series;

    series._onMarkerState(point, false);

    if (!point.graphic && series.defaultMarker) {
      series.defaultMarker.animate({
        duration: 300,
        ease: 'ease',
        attr: {
          'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(0.01)'
        }
      }).remove();
      series.defaultMarker = null;
    }
  },
  //当没有marker的时候默认加一个marker
  _getDefaultMarker: function (point) {
    return {
      'symbol': _Constants["default"].CIRCLE,
      'fillColor': point.options.marker.fillColor,
      'fillColorOpacity': point.options.marker.fillColorOpacity,
      "radius": _Constants["default"].MARKER_RADIUS,
      "enabled": true
    };
  },
  _calculateAnimationDelay: function () {
    return 0;
  },
  _isHollowMarker: function (markerType) {
    return markerType && markerType.indexOf('hollow') !== -1;
  },
  _animateEnd: function () {
    this._showLabels();

    this._drawEffectPoints();
  },
  _showLabels: function () {
    var series = this,
        vanchart = series.vanchart;

    series._updateDataLabels(); // 图表绘制结束就绘制标签，没有必要等MoreLabel了


    if (vanchart._needShowMoreLabel()) {
      series.getTextDataToDraw().forEach(function (point) {
        if (point.visible && series.visible) {
          series._showMoreLabel(point);
        }
      });
    }

    vanchart._removeChangeDataState(series);
  },

  /**
   * 统一显示MoreLabel:值变化提示
   * @param  {[type]} point           [point]
   * @param  {[type]} startX     [moreLabel缩放起始点X](非必填, 未传值的则使用series.calcMoreLabelPosition计算)
   * @param  {[type]} startY     [moreLabel缩放起始点Y](同上)
   */
  _showMoreLabel: function (point, startX, startY) {
    if (point.depth === 0 && this.type === _Constants["default"].MULTIPIE_CHART) {
      //框架图的根节点也需要有moreLabel
      //多层饼图
      return;
    }

    var series = this,
        vanchart = series.vanchart,
        points = point.points;
    var moreLabel = vanchart.getComponent(_component.ComponentCst.MORELABEL_COMPONENT);

    if (vanchart.isMobileFlow()) {
      return;
    }

    if (series.type === _Constants["default"].GANTT_CHART) {
      return; // 甘特图暂不支持MoreLabel
    }

    var lastValue = point._lastValue || 0,
        lastArrivalRate = point._lastArrivalRate || 0; // 判断是否需要一框对多点

    var morePointsOneTip = function (series) {
      var gaugeType = series.gaugeType;
      return gaugeType === _Constants["default"].POINTER_SEMI_GAUGE || gaugeType === _Constants["default"].POINTER_GAUGE || vanchart.isPointOrAreaOrHeatMap();
    }; // 计算变化值,用作判断是否需要显示moreLabel


    var changedValue = _BaseUtils["default"].accAdd(+point.options[series.getTargetKey()], -lastValue); // 最后一个点如果是未变化的且需要一框多点的时候，在这里触发渲染
    // 框架图points为undefined


    if (changedValue === 0 || isNaN(changedValue)) {
      if (points && point === points[points.length - 1] && morePointsOneTip(series)) {
        moreLabel.showWithPoint(point, startX, startY);
      }

      return;
    }

    point.changedValue = changedValue;
    var changedPercent = changedValue / lastValue;
    point.changedPercent = isFinite(changedPercent) ? changedPercent : changedPercent < 0 ? "-∞" : "∞"; // 漏斗图-转换率

    if (series.type === _Constants["default"].FUNNEL_CHART) {
      point.changedArrivalRate = _BaseUtils["default"].accAdd(point.arrivalRate, lastArrivalRate);
    } // 指针仪表盘这样的，需要一框多点显示，要特殊处理：
    // 先MoreLabelHelper.collectPoint(point)把点相关的提示保存起来，等到遍历到最后一个点的时候，再统一布局绘制
    // 注意：如果最后一个点未发生值变化，那么在判断changedValue的时候，就该触发渲染操作了。


    if (morePointsOneTip(series)) {
      moreLabel.collectPoint(point);

      if (point === points[points.length - 1]) {
        moreLabel.showWithPoint(point, startX, startY);
      }

      return;
    } // 普通的一框对一点的渲染方式


    moreLabel.collectPoint(point);
    moreLabel.showWithPoint(point, startX, startY);
  },

  /**
   * 计算MoreLabel的起始位置和缩放方向:具体图表要重写这个方法。
   * @param  {[type]} point        [description]
   * @param  {[type]} moreLabelDim [moreLabel尺寸大小]
   * @return {[type]}              [moreLabelPosition]
   */
  calcMoreLabelPosition: function (point, moreLabelDim) {
    return {
      startX: point.x + point.width / 2,
      centerY: point.y - moreLabelDim.height / 2,
      direction: "top"
    };
  },

  /**
   * 判断监控刷新状态下是否有数据点发生值变化：多用于渲染时，针对值变化的情况特殊处理。
   * @return {Boolean} [description]
   */
  hasChangedPointWithChangeDataState: function () {
    var validPoints = this.points.filter(function (point) {
      return !point.isNull;
    });
    var pointChanged = false,
        index = 0;

    while (index < validPoints.length) {
      var point = validPoints[index];

      if (point.value != point._lastValue) {
        pointChanged = true;
        break;
      }

      index++;
    } // 有值变化且 _changeDataState才算hasChangedPoint，诸如resize之类的不会更新point的value和_lastValue，因此，计算出的pointChanged为true，但是不算发生值变化


    return pointChanged && this.vanchart._changeDataState;
  },
  _updateDataLabels: function () {
    var series = this;
    series.getTextDataToDraw().forEach(function (point) {
      series._createTextGraphic(point);
    });
  },
  _removeDataLabels: function () {
    var series = this;
    series.getTextDataToDraw().forEach(function (point) {
      point.removeTextGraphic();
      point.newMoreLabelG && point.newMoreLabelG.remove();
      point.newMoreLabelG = null;
    });
  },
  // labelPos是整个标签左上角，不使用垂直居中效果 writingMode: tb-rl 时，
  // text.tans(x+width/2, y+height/2).dx(dx-width/2).dy(dy-height/2),
  // 使用垂直居中效果时，text.tans(x+width/2, y+height/2).dx(dx).dy(dy-height/2),
  // 这样做的原因：选中放大，要trans到缩放中心
  _createTextGraphic: function (point) {
    if (point.hasValidDataLabel()) {
      point.removeTextGraphic(); // @CHART-1982  饼图旋转加监控刷新标签重叠问题

      (0, _VanChartLabelBorder.createTextBorderPath)(point);

      if (point.options.dataLabels.useRichText) {
        (0, _richTextMount.createRichTextLabel)(point);
      } else {
        this.createCommonTextLabel(point);
      }

      if (point.labelPos.startPos) {
        // leadLine
        point.leadLine = this._getPointTextLabelGroup().append(this._getLeadLine(point));
      }
    }
  },
  createCommonTextLabel: function (point) {
    var series = this,
        vanchart = series.vanchart,
        renderer = vanchart.renderer,
        labelContent = point.labelContent,
        dataLabels = point.options.dataLabels,
        useHtml = dataLabels.useHtml;

    var textLabelGroup = this._getPointTextLabelGroup();

    var text = renderer.vtext(useHtml).attr('transform', _BaseUtils["default"].makeTranslate(series._labelTrans(point))).style({
      'pointer-events': 'none'
    });

    if (this._hasOuterLineFilter(dataLabels, point.labelAlign)) {
      text.attr('filter', this._getOuterLineFilter());
    }

    var startY = 0;
    var halfHeight = point.labelDim.height / 2;
    var halfWidth = point.labelDim.width / 2; // ie兼容：垂直居中效果 writingMode: tb-rl，应添加到text元素，添加到tspans时ie下排列显示有问题，
    // 添加到text上后，按照计算的居中位置（x, y）左对齐显示，因此实际中心会有0.5个宽度的右偏移，需要在dx中矫正回来

    if (labelContent && labelContent.length === 1 && this._isVerticalLabel(labelContent[0].style)) {
      var label = labelContent[0],
          labelText = label.text,
          labelStyle = label.style;
      text.style({
        'margin-top': -halfHeight + 'px',
        'text-align': "center",
        'overflow': "hidden"
      }).attr('dx', _Browser["default"].ie || useHtml ? -halfWidth * 0.5 : 0).attr('dy', -halfHeight).style(labelStyle).textContent(labelText);
    } else {
      text.tspans = [];

      for (var i = 0, count = labelContent.length; i < count; i++) {
        var _label = labelContent[i],
            labelDim = _label.dim,
            _labelText = _label.text,
            _labelStyle = _label.style; // 在translate导致的坐标系原点偏移后，原始的label也需要相应的位置调整

        var xShift = -point.labelDim.width / 2,
            yShift = -point.labelDim.height / 2 + labelDim.height * 0.85; // todo 原始的dataLabels没有_align属性，只有多层饼图和矩形树图会生成这个属性，将来可以考虑放到point上，和labelAlign保持一致

        var alignShift = this._calculateLabelAlignShift(point.options.dataLabels._align, point.labelDim, labelDim);

        text.tspans.push(renderer.vtspan(useHtml).style({
          'width': dataLabels.labelWidth + 'px',
          'height': dataLabels.labelHeight + 'px',
          'margin-top': -halfHeight + 'px',
          'text-align': "center",
          'overflow': "hidden"
        }).attr('y', startY).attr('x', 0).attr('dy', yShift).attr('dx', alignShift + xShift).style(_labelStyle).textContent(_labelText).addTo(text));
        startY += labelDim.height + 2;
      }
    }

    point.textGraphic = textLabelGroup.append(text);
  },
  _calculateLabelAlignShift: function (align, pointLabelDim, contentLabelDim) {
    switch (align) {
      case _Constants["default"].LEFT:
        return 0;

      case _Constants["default"].RIGHT:
        return pointLabelDim.width - contentLabelDim.width;

      case _Constants["default"].CENTER:
      default:
        return (pointLabelDim.width - contentLabelDim.width) / 2;
    }
  },
  _isVerticalLabel: function (style) {
    if (!style) {
      return false;
    }

    return style['writingMode'] === 'tb-rl' || style['writing-mode'] === 'tb-rl' || style['-webkit-writing-mode'] === 'vertical-rl';
  },

  /**
   * 标签优化后的图形的point会有labelAlign，目前柱形图、条形图、折线图、面积图具有该属性；
   * 字符样式为自定义样式无外描边，折线图、标签居外的柱形图和条形图标签有外描边
   * @param dataLabels
   * @param labelAlign
   * @returns {boolean|boolean}
   * @private
   */
  _hasOuterLineFilter: function (dataLabels, labelAlign) {
    if (!(0, _EnvUtils.isSupportSVG)() || dataLabels.style) {
      return false;
    }

    var chartType = this.type;
    return chartType === _Constants["default"].LINE_CHART || chartType === _Constants["default"].COLUMN_CHART && labelAlign === _Constants["default"].OUTSIDE || chartType === _Constants["default"].BAR_CHART && labelAlign === _Constants["default"].OUTSIDE;
  },
  _getOuterLineFilter: function () {
    var series = this,
        vanchart = series.vanchart,
        renderer = vanchart.renderer,
        color = this._getBackgroundColorWithAlpha() || DEFAULT_LABEL_STROKE;

    if (!vanchart.outerLineFilter) {
      vanchart.outerLineFilter = renderer.createOuterLineFilter(color, OUTER_LINE_WIDTH);
    } else {
      renderer.updateOuterLineFilter(vanchart.outerLineFilter, color, OUTER_LINE_WIDTH);
    }

    return renderer.toPatternProperty(vanchart.outerLineFilter);
  },
  _labelTrans: function (point) {
    if ((0, _VanChartLabelBorder.isNeedBorder)(point)) {
      return (0, _VanChartLabelBorder.labelTransWithBorder)(point);
    }

    return {
      x: point.labelPos.x + point.labelDim.width / 2,
      y: point.labelPos.y + point.labelDim.height / 2
    };
  },
  _labelFontSizeState: function (point, isChosen, duration, ease) {
    if (point.labelPos) {
      var pos = point.series._labelTrans(point),
          scale = isChosen ? 1.1 : 1;

      if (point.textGraphic) {
        var paras = point.textGraphic.type === 'div' ? {
          duration: duration,
          ease: ease,
          style: {
            'transform': 'translate(' + pos.x + 'px,' + pos.y + 'px)scale(' + scale + ')'
          }
        } : {
          duration: duration,
          ease: ease,
          attr: {
            'transform': 'translate(' + pos.x + ',' + pos.y + ')scale(' + scale + ')'
          }
        };
        point.textGraphic && point.textGraphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate(paras);
      }
    }
  },
  _labelTransformState: function (point, diffX, diffY, isChosen, duration, ease) {
    if (this.vanchart.onSeriesRendering()) {
      return;
    }

    if (point.labelPos) {
      var trans = point.series._labelTrans(point);

      if (isChosen) {
        trans = {
          x: trans.x + diffX,
          y: trans.y + diffY
        };
      }

      point.textGraphic && point.textGraphic.animate({
        duration: duration,
        ease: ease,
        attr: {
          'transform': _BaseUtils["default"].makeTranslate(trans)
        },
        style: {
          'transform': 'translate(' + trans.x + 'px,' + trans.y + 'px)'
        }
      });
      this.labelBorderTransformState(point, diffX, diffY, isChosen, duration, ease);
    }
  },
  labelBorderTransformState: function (point, diffX, diffY, isChosen, duration, ease) {
    if (!point.textBorderPath) {
      return;
    }

    var borderBounds = (0, _VanChartLabelBorder.getBorderBounds)(point);
    var textBorderPathTrans = {
      x: borderBounds.x,
      y: borderBounds.y
    };

    if (isChosen) {
      textBorderPathTrans = {
        x: textBorderPathTrans.x + diffX,
        y: textBorderPathTrans.y + diffY
      };
    }

    point.textBorderPath.animate({
      duration: duration,
      ease: ease,
      attr: {
        transform: _BaseUtils["default"].makeTranslate(textBorderPathTrans)
      }
    });
  },
  _outSideLabelColorState: function (point, isChosen, duration, ease) {
    var labelContent = point.labelContent,
        len = labelContent.length;

    if (point.textGraphic && point.textGraphic.tspans) {
      point.textGraphic.tspans.forEach(function (span, i) {
        if (i < len) {
          var style = span.styles;
          span.transition(_Constants["default"].SELECT_STYLE_ANIMATION).animate({
            duration: duration,
            ease: ease,
            style: {
              'color': style.color,
              'fill': style.color
            }
          });
        }
      });
    }
  },

  /**
   * 选中状态下的连接线path计算
   * @param point
   * @param diffX
   * @param diffY
   * @returns {*}
   * @private
   */
  _getChosenPointLeadLinePath: function (point, diffX, diffY) {
    function addDiff(pos) {
      return {
        x: pos.x + diffX,
        y: pos.y + diffY
      };
    }

    var labelPos = point.labelPos;
    var newLabelPos = {
      startPos: addDiff(labelPos.startPos),
      midPos: addDiff(labelPos.midPos),
      endPos: addDiff(labelPos.endPos)
    };
    return this._getLeadLinePathWithPos(newLabelPos);
  },
  _leadLineState: function (point, diffX, diffY, isChosen, duration, ease) {
    var series = point.series,
        labelPos = point.labelPos,
        options = point.options,
        dataLabels = options.dataLabels;

    if (!labelPos || !labelPos.startPos) {
      return;
    }

    var leadLinePos = labelPos,
        leadLineColor = dataLabels.connectorColor || point.color;

    if (isChosen) {
      leadLineColor = point.mouseOverColor;
    }

    if (point.leadLine) {
      point.leadLine.transition(_Constants["default"].SELECT_ANIMATION).animate({
        duration: duration || 100,
        ease: ease || 'ease',
        attr: {
          'd': isChosen ? this._getChosenPointLeadLinePath(point, diffX, diffY) : series._getLeadLinePathWithPos(leadLinePos)
        }
      });
      point.leadLine.transition(_Constants["default"].SELECT_STYLE_ANIMATION).animate({
        duration: duration || 100,
        ease: ease || 'ease',
        style: {
          'stroke': leadLineColor
        }
      });
    }
  },
  _getLeadLine: function (point) {
    return this.vanchart.renderer.path().attr('d', this._getLeadLinePath(point)).style({
      'fill': 'none',
      'stroke': point.options.dataLabels.connectorColor || point.color,
      'stroke-width': point.options.dataLabels.connectorWidth || 0
    });
  },
  _getLeadLinePath: function (point) {
    return this._getLeadLinePathWithPos(point.labelPos);
  },
  _getLeadLinePathWithPos: function (labelPos) {
    var startPos = labelPos.startPos,
        midPos = labelPos.midPos,
        endPos = labelPos.endPos;
    var F = this._dealWithFloat;
    return 'M' + F(startPos.x) + ',' + F(startPos.y) + 'L' + F(midPos.x) + ',' + F(midPos.y) + 'L' + F(endPos.x) + ',' + F(endPos.y);
  },
  _dealWithFloat: function (v) {
    return Math.abs(v) < 1e-6 ? 0 : v;
  },
  _getPointGraphicGroup: function () {
    return this.group;
  },
  _getPointTextLabelGroup: function () {
    if (!this.textGraphicGroup) {
      var vanchart = this.vanchart,
          textRenderGroup = vanchart.seriesTextRenderGroup,
          textDivGroup = vanchart.seriesTextDivGroup;
      this.textGraphicGroup = vanchart.renderer.vgroup();
      textRenderGroup.append(this.textGraphicGroup.renderG);
      textDivGroup.append(this.textGraphicGroup.divG);
      this.textGraphicGroup.attr('transform', _BaseUtils["default"].makeTranslate(this._getTranslate()));
    } else {
      this.textGraphicGroup.attr('transform', _BaseUtils["default"].makeTranslate(this._getTranslate()));
    }

    return this.textGraphicGroup;
  },
  _getTranslate: function () {
    return this.vanchart.bounds;
  },
  //seriesUnChosen:series.fire; mouseout:dom event。
  //原因：折线图鼠标移出线，线依然选中因为有选中点。折线图的mouseout不做任何事情，seriesUnChosen取消线的选中状态。
  getEvents: function () {
    return {
      'mouseover': this._onSeriesMouseOver,
      'mouseout': this._onSeriesMouseOut,
      'seriesUnChosen': this._seriesUnChosen,
      'pointMouseOver': this._onPointMouseOver,
      'pointMouseOut': this._onPointMouseOut,
      'tap': this._onSeriesTap
    };
  },
  // 对于词云框架图的超链鼠标悬浮变手统一处理
  _onPointMouseOver: function (point) {
    if (point.graphic) {
      point.graphic.style('cursor', point.onClick ? 'pointer' : '');
    }
  },
  _seriesUnChosen: function (ev) {
    this._onSeriesMouseOut && this._onSeriesMouseOut(ev);
  },
  _onSeriesMouseOver: function (ev) {
    var series = this,
        vanchart = series.vanchart,
        hoverSeries = vanchart.hoverSeries;
    var hoverPoint = vanchart.hoverPoint;

    if (hoverSeries != series) {
      hoverSeries && hoverSeries.fire('seriesUnChosen', ev);
      vanchart.hoverSeries = series;
    }

    var closestPoint = series.getClosestPoint(ev.containerPoint);

    if (closestPoint && closestPoint != hoverPoint) {
      hoverPoint && hoverPoint.fire('mouseout', ev);
      vanchart.registerInteractiveTarget(closestPoint, closestPoint.series.defaultMarker);
      closestPoint.fire('mouseover', ev);
      vanchart.registerInteractiveTarget(closestPoint, closestPoint.series.defaultMarker);
    }
  },
  // 只对移动端的tap事件做单独处理
  _onSeriesTap: function (ev) {
    this.vanchart && this.vanchart.isMobile() && this.fire('mouseover', ev);
  },
  getPressedStyle: function () {
    return null;
  },
  onPointPress: function () {
    var point = this,
        series = point.series,
        style = series.getPressedStyle(point);

    if (style && point.graphic) {
      point.graphic.style(style);
    }
  },
  onPointPressUp: function () {
    var point = this,
        series = point.series,
        style = series.getHighLightStyle && series.getHighLightStyle(point);

    if (style && point.graphic) {
      point.graphic.style(style);
    }
  },
  remove: function () {
    var series = this,
        vanchart = series.vanchart;
    this.points.forEach(function (point) {
      vanchart.removePointGraphics(point, series.type, false);
    });
    this._canvas && this._canvas.remove();
    this.textGraphicGroup && this.textGraphicGroup.remove();
    this.group && this.group.remove();
    this.textGraphicGroup = this._canvas = this.group = null;
  },
  reShowPoint: function (point) {
    var series = point.series,
        vanchart = series.vanchart,
        legend = vanchart.getComponent(_component.ComponentCst.LEGEND_COMPONENT);
    return legend && legend.items && legend.reShowPoint(point);
  },
  //等其他系列消失，此系列再动画
  updateDelay: function (delay) {
    var series = this,
        vanchart = series.vanchart,
        legend = vanchart.getComponent(_component.ComponentCst.LEGEND_COMPONENT);

    if (legend && legend.showSeries(series)) {
      var chartSeries = vanchart.seriesOfType(series.type);

      for (var i = 0, len = chartSeries.length; i < len; i++) {
        if (legend.toDropSeries(chartSeries[i])) {
          return delay || 150;
        }
      }
    }

    return 0;
  }
}); // @CHART-9054: 面积图选中效果优化

Series.include({
  toFrontPosition: function () {
    var node = this.group.node();

    if (node && !this._toFront) {
      this._nextSibling = node.nextSibling;
      this._toFront = true;

      _BaseUtils["default"].toFront(node);
    }
  },
  resetPosition: function () {
    var node = this.group.node();

    if (node && this._nextSibling && this._toFront) {
      this._toFront = false; // CHART-15766 Failed to execute 'insertBefore' on 'Node
      // 这里用来置顶，在置顶过程中，nextSibling可能没数据被移除了，就会报错，得判断一下

      if (this._nextSibling && this._nextSibling.parentNode && this._nextSibling.parentNode == node.parentNode) {
        node.parentNode.insertBefore(node, this._nextSibling);
      }
    }
  },
  getGroupTrans: function () {
    return [0, 0];
  },
  getAbsoluteLabelPos: function (labelPos) {
    var lx = labelPos.x,
        ly = labelPos.y;
    var serTrans = this.getGroupTrans();
    return {
      x: lx + serTrans[0],
      y: ly + serTrans[1]
    };
  },
  isSupportVerticalLabel: function () {
    return false;
  }
});
var _default = Series;
exports["default"] = _default;

/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by eason on 15/6/16.
 */
//从可能的属性列表里读optLocation的属性，前面的优先级高
function queryList(optList, optLocation) {
  if (!optList || !optList.length || !optLocation) {
    return undefined;
  }

  for (var i = 0; i < optList.length; i++) {
    var result = optList[i] && optList[i][optLocation];

    if (result != undefined) {
      return result;
    }
  }
}

function merge(target, source, overwrite) {
  for (var key in source) {
    if (source.hasOwnProperty(key)) {
      var targetProp = target[key];

      if (typeof targetProp == 'object') {
        //target[key]不为对象时？
        merge(target[key], source[key], overwrite);

        if (targetProp && targetProp.FONT_SCALE) {
          targetProp.FONT_SCALE = null;
        }
      } else if (overwrite || !(key in target) || targetProp == undefined) {
        target[key] = source[key];
      }
    }
  }

  return target;
}

var _default = {
  queryList: queryList,
  merge: merge
};
exports["default"] = _default;

/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/19.
 */
var Point2D = function (x, y, round) {
  // @property x: Number; The `x` coordinate of the point
  this.x = round ? Math.round(x) : x; // @property y: Number; The `y` coordinate of the point

  this.y = round ? Math.round(y) : y;
};

Point2D.prototype = {
  // @method clone(): Point
  // Returns a copy of the current point.
  clone: function () {
    return new Point2D(this.x, this.y);
  },
  // @method add(otherPoint: Point): Point
  // Returns the result of addition of the current and the given points.
  add: function (point) {
    // non-destructive, returns a new point
    return this.clone()._add(Point2D.create(point));
  },
  _add: function (point) {
    // destructive, used directly for performance in situations where it's safe to modify existing point
    this.x += point.x;
    this.y += point.y;
    return this;
  },
  // @method subtract(otherPoint: Point): Point
  // Returns the result of subtraction of the given point from the current.
  subtract: function (point) {
    return this.clone()._subtract(Point2D.create(point));
  },
  _subtract: function (point) {
    this.x -= point.x;
    this.y -= point.y;
    return this;
  },
  // @method divideBy(num: Number): Point
  // Returns the result of division of the current point by the given number.
  divideBy: function (num) {
    return this.clone()._divideBy(num);
  },
  _divideBy: function (num) {
    this.x /= num;
    this.y /= num;
    return this;
  },
  // @method multiplyBy(num: Number): Point
  // Returns the result of multiplication of the current point by the given number.
  multiplyBy: function (num) {
    return this.clone()._multiplyBy(num);
  },
  _multiplyBy: function (num) {
    this.x *= num;
    this.y *= num;
    return this;
  },
  // @method scaleBy(scale: Point): Point
  // Multiply each coordinate of the current point by each coordinate of
  // `scale`. In linear algebra terms, multiply the point by the
  // [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
  // defined by `scale`.
  scaleBy: function (point) {
    return new Point2D(this.x * point.x, this.y * point.y);
  },
  // @method unscaleBy(scale: Point): Point
  // Inverse of `scaleBy`. Divide each coordinate of the current point by
  // each coordinate of `scale`.
  unscaleBy: function (point) {
    return new Point2D(this.x / point.x, this.y / point.y);
  },
  // @method round(): Point
  // Returns a copy of the current point with rounded coordinates.
  round: function () {
    return this.clone()._round();
  },
  _round: function () {
    this.x = Math.round(this.x);
    this.y = Math.round(this.y);
    return this;
  },
  // @method floor(): Point
  // Returns a copy of the current point with floored coordinates (rounded down).
  floor: function () {
    return this.clone()._floor();
  },
  _floor: function () {
    this.x = Math.floor(this.x);
    this.y = Math.floor(this.y);
    return this;
  },
  // @method ceil(): Point
  // Returns a copy of the current point with ceiled coordinates (rounded up).
  ceil: function () {
    return this.clone()._ceil();
  },
  _ceil: function () {
    this.x = Math.ceil(this.x);
    this.y = Math.ceil(this.y);
    return this;
  },
  // @method distanceTo(otherPoint: Point): Number
  // Returns the cartesian distance between the current and the given points.
  distanceTo: function (point) {
    point = Point2D.create(point);
    var x = point.x - this.x,
        y = point.y - this.y;
    return Math.sqrt(x * x + y * y);
  },
  // @method equals(otherPoint: Point): Boolean
  // Returns `true` if the given point has the same coordinates.
  equals: function (point) {
    point = Point2D.create(point);
    return point.x === this.x && point.y === this.y;
  },
  // @method contains(otherPoint: Point): Boolean
  // Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
  contains: function (point) {
    point = Point2D.create(point);
    return Math.abs(point.x) <= Math.abs(this.x) && Math.abs(point.y) <= Math.abs(this.y);
  },
  // @method toString(): String
  // Returns a string representation of the point for debugging purposes.
  toString: function () {
    return 'Point(' + _BaseUtils["default"].formatNum(this.x) + ', ' + _BaseUtils["default"].formatNum(this.y) + ')';
  }
};

Point2D.create = function (x, y, round) {
  if (x instanceof Point2D) {
    return x;
  }

  if (_BaseUtils["default"].isArray(x)) {
    return new Point2D(x[0], x[1]);
  }

  if (x === undefined || x === null) {
    return x;
  }

  if (typeof x === 'object' && 'x' in x && 'y' in x) {
    return new Point2D(x.x, x.y);
  }

  return new Point2D(x, y, round);
};

var _default = Point2D;
exports["default"] = _default;

/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/14.
 */
var d3_interpolate_numberA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,
    d3_interpolate_numberB = new RegExp(d3_interpolate_numberA.source, "g");

function interpolator(a, b) {
  var t = typeof b;

  if (isDifferentColorType(a, b)) {
    return function () {
      return b;
    };
  }

  return (t === "string" ? _ColorUtils["default"].hasColorName(b) || /^(#|rgb\(|hsl\()/.test(b) ? d3_interpolateRgb : d3_interpolateString : Array.isArray(b) ? d3_interpolateArray : t === "object" && isNaN(b) ? d3_interpolateObject : d3_interpolateNumber)(a, b);
}

function isDifferentColorType(a, b) {
  if (typeof a !== 'string' || typeof b !== 'string') {
    return false;
  }

  return b.indexOf('url') > -1 && a.indexOf('url') < 0 || a.indexOf('url') > -1 && b.indexOf('url') < 0;
}

function d3_rgb_hex(v) {
  return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16);
}

function d3_interpolateRgb(a, b) {
  a = a == 'none' || a == '' ? b : a;
  a = _ColorUtils["default"].getRGBAColorArray(a);
  b = _ColorUtils["default"].getRGBAColorArray(b);
  var ar = a[0],
      ag = a[1],
      ab = a[2],
      br = b[0] - ar,
      bg = b[1] - ag,
      bb = b[2] - ab;
  return function (t) {
    return "#" + d3_rgb_hex(Math.round(ar + br * t)) + d3_rgb_hex(Math.round(ag + bg * t)) + d3_rgb_hex(Math.round(ab + bb * t));
  };
}

function checkMatrixTransform(string) {
  var trans = string.match(/matrix\((\d+\.?\d*|\.?\d+), 0, 0, (\d+\.?\d*|\.?\d+), ([-+]?\d+\.?\d*|\.?\d+), ([-+]?\d+\.?\d*|\.?\d+)\)/);
  return trans ? "translate(" + trans[3] + "px," + trans[4] + "px)scale(" + trans[1] + ")" : string;
}

function d3_interpolateString(a, b) {
  var bi = d3_interpolate_numberA.lastIndex = d3_interpolate_numberB.lastIndex = 0,
      am,
      bm,
      bs,
      i = -1,
      s = [],
      q = [];
  a = a + "";
  b = b + "";
  a = checkMatrixTransform(a);
  b = checkMatrixTransform(b);

  while ((am = d3_interpolate_numberA.exec(a)) && (bm = d3_interpolate_numberB.exec(b))) {
    if ((bs = bm.index) > bi) {
      bs = b.slice(bi, bs);

      if (s[i]) {
        s[i] += bs;
      } else {
        s[++i] = bs;
      }
    }

    if ((am = am[0]) === (bm = bm[0])) {
      if (s[i]) {
        s[i] += bm;
      } else {
        s[++i] = bm;
      }
    } else {
      s[++i] = null;
      q.push({
        i: i,
        x: d3_interpolateNumber(am, bm)
      });
    }

    bi = d3_interpolate_numberB.lastIndex;
  }

  if (bi < b.length) {
    bs = b.slice(bi);

    if (s[i]) {
      s[i] += bs;
    } else {
      s[++i] = bs;
    }
  }

  return s.length < 2 ? q[0] ? (b = q[0].x, function (t) {
    return b(t) + "";
  }) : function () {
    return b;
  } : (b = q.length, function (t) {
    for (var i = 0, o; i < b; ++i) {
      s[(o = q[i]).i] = o.x(t);
    }

    return s.join("");
  });
}

function d3_interpolateObject(a, b) {
  var i = {},
      c = {},
      k;

  for (k in a) {
    if (k in b) {
      i[k] = interpolator(a[k], b[k]);
    } else {
      c[k] = a[k];
    }
  }

  for (k in b) {
    if (!(k in a)) {
      c[k] = b[k];
    }
  }

  return function (t) {
    for (k in i) {
      c[k] = i[k](t);
    }

    return c;
  };
}

function d3_interpolateNumber(a, b) {
  a = +a, b = +b;
  return function (t) {
    return a * (1 - t) + b * t;
  };
}

function d3_interpolateArray(a, b) {
  var x = [],
      c = [],
      na = a.length,
      nb = b.length,
      n0 = Math.min(a.length, b.length),
      i;

  for (i = 0; i < n0; ++i) {
    x.push(interpolator(a[i], b[i]));
  }

  for (; i < na; ++i) {
    c[i] = a[i];
  }

  for (; i < nb; ++i) {
    c[i] = b[i];
  }

  return function (t) {
    for (i = 0; i < n0; ++i) {
      c[i] = x[i](t);
    }

    return c;
  };
}

function transform(string) {
  var g = document.createElementNS("http://www.w3.org/2000/svg", "g");
  return (transform = function (string) {
    if (string != null) {
      g.setAttribute("transform", string);
      var t = g.transform.baseVal.consolidate();
    }

    return new d3_transform(t ? t.matrix : d3_transformIdentity);
  })(string);
}

function d3_transform(m) {
  var r0 = [m.a, m.b],
      r1 = [m.c, m.d],
      kx = d3_transformNormalize(r0),
      kz = d3_transformDot(r0, r1),
      ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0;

  if (r0[0] * r1[1] < r1[0] * r0[1]) {
    r0[0] *= -1;
    r0[1] *= -1;
    kx *= -1;
    kz *= -1;
  }

  this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * 180 / Math.PI;
  this.translate = [m.e, m.f];
  this.scale = [kx, ky];
  this.skew = ky ? Math.atan2(kz, ky) * 180 / Math.PI : 0;
}

d3_transform.prototype.toString = function () {
  return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")";
};

function d3_transformDot(a, b) {
  return a[0] * b[0] + a[1] * b[1];
}

function d3_transformNormalize(a) {
  var k = Math.sqrt(d3_transformDot(a, a));

  if (k) {
    a[0] /= k;
    a[1] /= k;
  }

  return k;
}

function d3_transformCombine(a, b, k) {
  a[0] += k * b[0];
  a[1] += k * b[1];
  return a;
}

var d3_transformIdentity = {
  a: 1,
  b: 0,
  c: 0,
  d: 1,
  e: 0,
  f: 0
};

function d3_interpolateTransform(a, b) {
  var s = [],
      q = [],
      n,
      A = transform(a),
      B = transform(b),
      ta = A.translate,
      tb = B.translate,
      ra = A.rotate,
      rb = B.rotate,
      wa = A.skew,
      wb = B.skew,
      ka = A.scale,
      kb = B.scale;

  if (ta[0] != tb[0] || ta[1] != tb[1]) {
    s.push("translate(", null, ",", null, ")");
    q.push({
      i: 1,
      x: d3_interpolateNumber(ta[0], tb[0])
    }, {
      i: 3,
      x: d3_interpolateNumber(ta[1], tb[1])
    });
  } else if (tb[0] || tb[1]) {
    s.push("translate(" + tb + ")");
  } else {
    s.push("");
  }

  if (ra != rb) {
    if (ra - rb > 180) {
      rb += 360;
    } else if (rb - ra > 180) {
      ra += 360;
    }

    q.push({
      i: s.push(s.pop() + "rotate(", null, ")") - 2,
      x: d3_interpolateNumber(ra, rb)
    });
  } else if (rb) {
    s.push(s.pop() + "rotate(" + rb + ")");
  }

  if (wa != wb) {
    q.push({
      i: s.push(s.pop() + "skewX(", null, ")") - 2,
      x: d3_interpolateNumber(wa, wb)
    });
  } else if (wb) {
    s.push(s.pop() + "skewX(" + wb + ")");
  }

  if (ka[0] != kb[0] || ka[1] != kb[1]) {
    n = s.push(s.pop() + "scale(", null, ",", null, ")");
    q.push({
      i: n - 4,
      x: d3_interpolateNumber(ka[0], kb[0])
    }, {
      i: n - 2,
      x: d3_interpolateNumber(ka[1], kb[1])
    });
  } else if (kb[0] !== 1 || kb[1] !== 1) {
    s.push(s.pop() + "scale(" + kb + ")");
  }

  n = q.length;
  return function (t) {
    var i = -1,
        o;

    while (++i < n) {
      s[(o = q[i]).i] = o.x(t);
    }

    return s.join("");
  };
}

interpolator.identity = function (d) {
  return d;
};

interpolator.interpolateRound = function (a, b) {
  b -= a;
  return function (t) {
    return Math.round(a + b * t);
  };
};

interpolator.uninterpolateNumber = function (a, b) {
  b = (b -= a = +a) || 1 / b;
  return function (x) {
    return (x - a) / b;
  };
};

interpolator.interpolateNumber = function (a, b) {
  a = +a, b = +b;
  return function (t) {
    return a * (1 - t) + b * t;
  };
};

interpolator.interpolate = interpolator;
interpolator.interpolateRgb = d3_interpolateRgb;
interpolator.interpolateTransform = d3_interpolateTransform;
interpolator.interpolateArray = d3_interpolateArray;
var _default = interpolator;
exports["default"] = _default;

/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getThemeAutoValue = getThemeAutoValue;

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var THEME_CONFIG = {
  // 地图
  mapTileLayer: {
    light: 'http://webrd01.is.autonavi.com/appmaptile?lang=zh_cn&size=1&scale=1&style=8&x={x}&y={y}&z={z}',
    dark: 'http://map.geoq.cn/ArcGIS/rest/services/ChinaOnlineStreetPurplishBlue/MapServer/tile/{z}/{y}/{x}'
  },
  nullColor: {
    light: '#E8E9F0',
    dark: '#828891'
  },
  mapBorderColor: {
    light: '#FFFFFF',
    dark: '#000000'
  },
  mapLegendBackgroundColor: {
    light: '#FFFFFF',
    dark: '#000000'
  },
  // 仪表盘
  hinge: {
    light: '#656B6D',
    dark: 'rgba(255,255,255,0)'
  },
  pointerPaneBackgroundColor: {
    light: '#FFFFFF',
    dark: 'rgba(255,255,255,0)'
  },
  paneBackgroundColor: {
    light: '#ECECEC',
    dark: '#48494F'
  },
  gaugeLabelColor: {
    light: '#444444',
    dark: '#E8E8E8'
  },
  pointBorderColor: {
    light: '#FFFFFF',
    dark: '#000000'
  },
  dToolItemBackground: {
    light: '#FFFFFF',
    dark: 'rgba(0,0,0,0.8)'
  },
  markerStrokeColor: {
    light: '#FFFFFF',
    dark: '#000000'
  }
};

function getThemeAutoValue(opt, name, isDarkTheme) {
  if (opt !== _Constants["default"].AUTO) {
    return opt;
  }

  return isDarkTheme ? THEME_CONFIG[name].dark : THEME_CONFIG[name].light;
}

/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _Transition = _interopRequireDefault(__webpack_require__(44));

var _Path = _interopRequireDefault(__webpack_require__(48));

var _LayerGroup = _interopRequireDefault(__webpack_require__(49));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by shine on 2016/12/19.
 */
var PATH = 'M-56,0a56,16 0 1,0 112,0a56,16 0 1,0 -112,0';

function pointMapEffectAnimation(layer, d) {
  var series = d.series,
      vanchart = series.vanchart;

  var period = series._getEffectTime(d);

  var getPosition = function () {
    var latlng = d.getLatLng(),
        pixels = latlng && vanchart.latLngToLayerPoint(latlng) || {
      x: 0,
      y: 0
    };
    return {
      x: pixels.x,
      y: pixels.y
    };
  };

  function bottom_to_top() {
    return function (t) {
      var pos = getPosition(); // 这边动画的位置，每次都重新算吧，不然缩放的时候，动画用的位置还是上次的，就可能导致闪烁

      return _BaseUtils["default"].makeTranslate3d({
        x: pos.x,
        y: pos.y - 25 * t
      });
    };
  }

  function top_to_bottom() {
    // @CHART-12762: 地图缩放过程中, 点闪烁动画不好被暂停, 闪烁偏移根据当前缩放层级实时计算
    return function (t) {
      var pos = getPosition();
      return _BaseUtils["default"].makeTranslate3d({
        x: pos.x,
        y: pos.y - 25 * (1 - t)
      });
    };
  } //todo:node element ?


  new _Transition["default"]({
    node: function () {
      return layer._icon;
    }
  }, _Constants["default"].EFFECT_KEY) // .interrupt("point-map-effect")
  .ease(_BezierEasing["default"].css["ease-out-quint"]).duration(0.25 * period).styleTween('transform', bottom_to_top).transition().ease(_BezierEasing["default"].css["ease-in-quint"]).duration(0.25 * period).styleTween('transform', top_to_bottom).transition().ease(_BezierEasing["default"].css["ease-out-quint"]).duration(0.25 * period).styleTween('transform', bottom_to_top).transition().ease(_BezierEasing["default"].css["ease-in-quint"]).duration(0.25 * period).styleTween('transform', top_to_bottom);
  var initStyle = {
    'fill-opacity': 0,
    'fill': d.color
  };
  var layerGroup = d.effectGraphic = d.effectGraphic || new _LayerGroup["default"]().addTo(vanchart.getEffectLayer());

  function createEffectG() {
    return new _Path["default"]().addTo(layerGroup)._path.style(initStyle).attr('d', PATH);
  }

  var iconSize = d.options.icon.iconSize,
      initScale = iconSize[0] / 90; //90的原因，path是根据宽为90的图标画的

  var pos = getPosition();

  var trans = _BaseUtils["default"].makeTranslate({
    x: pos.x,
    y: pos.y
  }),
      initTrans = trans + ' scale(' + initScale + ')';

  function ani(graphic, delay, time) {
    graphic.style(initStyle).attr('transform', initTrans);
    graphic.effectTransition().delay(delay).ease('linear').duration(time).attrTween('transform', function () {
      return function (t) {
        return trans + 'scale(' + (initScale + initScale * 1.4 * t) + ')';
      };
    }).styleTween('fill-opacity', function () {
      return function (t) {
        return 0.6 * (1 - t);
      };
    });
  }

  var firstG = layerGroup.firstG = layerGroup.firstG || createEffectG(),
      secondG = layerGroup.secondG = layerGroup.secondG || createEffectG(),
      thirdG = layerGroup.thirdG = layerGroup.thirdG || createEffectG();
  var scale = period / series.getDefaultEffectTime();
  ani(firstG, 0, 2000 * scale);
  ani(secondG, 600 * scale, 2000 * scale);
  ani(thirdG, 1200 * scale, 2000 * scale);
} //区域类型的，漏斗、饼、矩形树图


function areaStyleEffectAnimation(d, transX, transY) {
  var paras = _calculateParas(d, transX, transY);

  d.graphic //先注释掉,2017.2的代码一样的问题，应该和代码无关.
  //  .attr('transform-origin', 'center')
  .interrupt(_Constants["default"].SCALE_EXPAND_ANIMATION).interrupt(_Constants["default"].SCALE_MINIFY_ANIMATION);
  new _Transition["default"](d.graphic, _Constants["default"].SCALE_EXPAND_ANIMATION).ease(_BezierEasing["default"].css["ease-out-quad"]).duration(0.5 * paras.period).attrTween('filter', paras.firstTweenFun).attr('transform', paras.translate + 'scale(1.05)');
  new _Transition["default"](d.graphic, _Constants["default"].SCALE_MINIFY_ANIMATION).ease(_BezierEasing["default"].css["ease-in-quad"]).delay(0.5 * paras.period).duration(0.5 * paras.period).attrTween('filter', paras.secondTweenFun).attr('transform', paras.translate + 'scale(1)');
}

function areaMapEffectAnimation(layer, d) {
  var paras = _calculateParas(d);

  layer._path.style("filter", null) // 默认的style['filter']= "none"会导致阴影显示不出
  .effectTransition().ease(_BezierEasing["default"].css["ease-out-quad"]).duration(0.5 * paras.period).attrTween('filter', paras.firstTweenFun).style("fill-opacity", 0.5) // 也不是webkit才支持attr:,而是只有chrome和opera支持，见https://developer.mozilla.org/en-US/docs/Web/CSS/transform-origin
  .transition().ease(_BezierEasing["default"].css["ease-in-quad"]).duration(0.5 * paras.period).attrTween('filter', paras.secondTweenFun).style("fill-opacity", 1);
}

function _calculateParas(d, transX, transY) {
  var series = d.series,
      vanchart = series.vanchart,
      renderer = vanchart.renderer; // 排序的时候，直接更换的graphic，故这里的effectShadowFilter应该绑定在graphic上
  // 区域地图还是绑在d上

  var filterBind = d.graphic || d;
  filterBind.effectShadowFilter = filterBind.effectShadowFilter || renderer.createDropShadowFilter(3, 3, 0.75, 5, 91 / 255, 91 / 255, 91 / 255);
  var filterID = renderer.toPatternProperty(filterBind.effectShadowFilter);

  var period = series._getEffectTime(d);

  var translate = isNaN(transX) || isNaN(transY) ? '' : _BaseUtils["default"].makeTranslate({
    x: transX,
    y: transY
  });

  function firstTweenFun() {
    return function (t) {
      renderer && renderer.updateDropShadowFilter && renderer.updateDropShadowFilter(filterBind.effectShadowFilter, 3 * t, 3 * t, t * 0.75, t * 5, 91 / 255, 91 / 255, 91 / 255);
      return filterID;
    };
  }

  function secondTweenFun() {
    return function (t) {
      renderer && renderer.updateDropShadowFilter && renderer.updateDropShadowFilter(filterBind.effectShadowFilter, 3 * (1 - t), 3 * (1 - t), (1 - t) * 0.75, (1 - t) * 5, 91 / 255, 91 / 255, 91 / 255);
      return filterID;
    };
  }

  return {
    period: period,
    translate: translate,
    firstTweenFun: firstTweenFun,
    secondTweenFun: secondTweenFun
  };
}

function bubbleEffectAnimation(d, isMap) {
  forceBubbleEffectAnimation(d, null, isMap);
}

function forceBubbleEffectAnimation(d, trans, isMap) {
  var style = {
    'fill-opacity': 0,
    'stroke': 'none',
    'fill': d.color
  };

  var arc = _PathGenerator["default"].arc().innerRadius(d.radius).startAngle(0).endAngle(360);

  function path(t) {
    return arc({
      outerRadius: d.radius + t * d.radius * 1.5
    });
  }

  _markerStyleAnimation(d, {
    'isMap': isMap,
    'initStyle': style,
    'pathFun': path,
    'trans': trans
  });
}

function markerEffectAnimation(d, isMap) {
  var marker = d.options.marker;

  if (marker && marker.symbol) {
    var borderWidth = function (t) {
      return t * radius * 2.5;
    };

    var path = function (t) {
      return _PathGenerator["default"].getMarkerPath(markerType, radius + borderWidth(t) / 2 - 1);
    };

    var markerType = marker.symbol,
        radius = marker.radius;

    if (_BaseUtils["default"].isImageMarker(markerType)) {
      return;
    }

    var style = {
      'fill': 'none',
      'stroke': marker.fillColor,
      'stroke-width': 0,
      'stroke-opacity': 0
    };

    _markerStyleAnimation(d, {
      'isMap': isMap,
      'initStyle': style,
      'opacityKey': 'stroke-opacity',
      'pathFun': path,
      'borderFun': borderWidth
    });
  } else {
    _nullMarkerEffectAnimation(d, isMap);
  }
}

function _nullMarkerEffectAnimation(d, isMap) {
  var marker = d.options.marker,
      radius = marker.radius;
  var style = {
    'fill-opacity': 0,
    'stroke': 'none',
    'fill': marker.fillColor
  };

  var arc = _PathGenerator["default"].arc().innerRadius(0).startAngle(0).endAngle(360);

  function path(t) {
    return arc({
      outerRadius: t * radius * 3.5
    });
  }

  _markerStyleAnimation(d, {
    'isMap': isMap,
    'initStyle': style,
    'pathFun': path
  });
} //折线、气泡、散点等


function _markerStyleAnimation(d, options) {
  var series = d.series,
      vanchart = series.vanchart,
      renderer = vanchart.renderer;
  var initStyle = options.initStyle,
      trans = options.trans || {
    x: d.posX,
    y: d.posY
  };
  var group, createEffectGFun;

  if (options.isMap) {
    var latlng = d.getLatLng();
    trans = latlng && vanchart.latLngToLayerPoint(latlng) || {
      x: 0,
      y: 0
    };
    group = d.effectGraphic = d.effectGraphic || new _LayerGroup["default"]().addTo(vanchart.getEffectLayer());

    createEffectGFun = function createEffectG() {
      return new _Path["default"]().addTo(group)._path.style(initStyle).attr('transform', _BaseUtils["default"].makeTranslate(trans)).style('pointer-events', 'none');
    };
  } else {
    group = series._getPointEffectGroup(d).attr('transform', _BaseUtils["default"].makeTranslate(trans));

    createEffectGFun = function createEffectG() {
      return renderer.path().addTo(group).style(initStyle);
    };
  }

  function ani(graphic, delay, time) {
    graphic.style(initStyle).effectTransition().delay(delay).ease('linear').duration(time).styleTween('stroke-width', function () {
      return options.borderFun;
    }).styleTween(options.opacityKey || 'fill-opacity', function () {
      return function (t) {
        return 0.3 * (1 - t);
      };
    }).attrTween('d', function () {
      return options.pathFun;
    });
  }

  var firstG = group.firstG = group.firstG || createEffectGFun(),
      secondG = group.secondG = group.secondG || createEffectGFun(),
      thirdG = group.thirdG = group.thirdG || createEffectGFun();

  var period = series._getEffectTime(d),
      scale = period / series.getDefaultEffectTime();

  ani(firstG, 0, 1600 * scale);
  ani(secondG, 440 * scale, 1600 * scale);
  ani(thirdG, 880 * scale, 1600 * scale);
}

var _default = {
  MARKER_EFFECT_TIME: 2560,
  markerEffectAnimation: markerEffectAnimation,
  bubbleEffectAnimation: bubbleEffectAnimation,
  AREA_STYLE_EFFECT_TIME: 2000,
  areaStyleEffectAnimation: areaStyleEffectAnimation,
  areaMapEffectAnimation: areaMapEffectAnimation,
  POINT_MAP_EFFECT_TIME: 3200,
  pointMapEffectAnimation: pointMapEffectAnimation,
  forceBubbleEffectAnimation: forceBubbleEffectAnimation
};
exports["default"] = _default;

/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/19.
 */
var LatLng = function (lat, lng, alt) {
  if (isNaN(lat) || isNaN(lng)) {
    throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')');
  }

  this.lat = +lat;
  this.lng = +lng;

  if (alt !== undefined) {
    this.alt = +alt;
  }
};

LatLng.prototype = {
  equals: function (obj, maxMargin) {
    if (!obj) {
      return false;
    }

    obj = LatLng.create(obj);
    var margin = Math.max(Math.abs(this.lat - obj.lat), Math.abs(this.lng - obj.lng));
    return margin <= (maxMargin === undefined ? 1.0E-9 : maxMargin);
  },
  toString: function (precision) {
    return 'LatLng(' + _BaseUtils["default"].formatNum(this.lat, precision) + ', ' + _BaseUtils["default"].formatNum(this.lng, precision) + ')';
  },
  distanceTo: function (other) {
    return L.CRS.Earth.distance(this, LatLng.create(other));
  },
  wrap: function () {
    return L.CRS.Earth.wrapLatLng(this);
  },
  clone: function () {
    return new LatLng(this.lat, this.lng, this.alt);
  }
};

LatLng.create = function (a, b, c) {
  if (a instanceof LatLng) {
    return a;
  }

  if (_BaseUtils["default"].isArray(a) && typeof a[0] !== 'object') {
    if (a.length === 3) {
      return new LatLng(a[0], a[1], a[2]);
    }

    if (a.length === 2) {
      return new LatLng(a[0], a[1]);
    }

    return null;
  }

  if (a === undefined || a === null) {
    return a;
  }

  if (typeof a === 'object' && 'lat' in a) {
    return new LatLng(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);
  }

  if (b === undefined) {
    return null;
  }

  return new LatLng(a, b, c);
};

var _default = LatLng;
exports["default"] = _default;

/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/20.
 */
var Layer = _Evented["default"].extend({
  options: {
    pane: 'overlayPane',
    nonBubblingEvents: []
  },
  addTo: function (map) {
    map.addLayer(this);
    return this;
  },
  remove: function () {
    return this.removeFrom(this._map || this._mapToAdd);
  },
  // @method removeFrom(map: Map): this
  // Removes the layer from the given map
  removeFrom: function (obj) {
    if (obj) {
      obj.removeLayer(this);
    }

    return this;
  },
  // 默认的移除layer的方法，需要移除动画的可以重写改方法
  exitAnimate: function (vanchart) {
    var layer = this,
        group = vanchart._pointLayer;
    group.remove(layer);
  },
  // @method getPane(name? : String): HTMLElement
  // Returns the `HTMLElement` representing the named pane on the map. If `name` is omitted, returns the pane for this layer.
  getPane: function (name) {
    return this._map.getPane(name ? this.options[name] || name : this.options.pane);
  },
  beforeAdd: function (map) {
    // Renderer is set here because we need to call renderer.getEvents
    // before this.getEvents.
    this._renderer = map.getMapRenderer(this);
  },
  _layerAdd: function (e) {
    var map = e.target; // check in case layer gets added and then removed before the map is ready

    if (!map.hasLayer(this)) {
      return;
    }

    this._map = map;
    this._zoomAnimated = map._zoomAnimated;

    if (this.getEvents) {
      var events = this.getEvents();
      map.on(events, this);
      this.once('remove', function () {
        map.off(events, this);
      }, this);
    }

    this.onAdd(map);
  },
  _reset: _BaseUtils["default"].falseFn,
  _project: _BaseUtils["default"].falseFn,
  _update: _BaseUtils["default"].falseFn,
  setAttr: _BaseUtils["default"].falseFn
});

var _default = Layer;
exports["default"] = _default;

/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Point2D = _interopRequireDefault(__webpack_require__(15));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/19.
 */
var Bounds = function (a, b) {
  if (!a) {
    return;
  }

  var points = b ? [a, b] : a;

  for (var i = 0, len = points.length; i < len; i++) {
    this.extend(points[i]);
  }
};

Bounds.prototype = {
  // @method extend(point: Point): this
  // Extends the bounds to contain the given point.
  extend: function (point) {
    // (Point)
    point = _Point2D["default"].create(point); // @property min: Point
    // The top left corner of the rectangle.
    // @property max: Point
    // The bottom right corner of the rectangle.

    if (!this.min && !this.max) {
      this.min = point.clone();
      this.max = point.clone();
    } else {
      this.min.x = Math.min(point.x, this.min.x);
      this.max.x = Math.max(point.x, this.max.x);
      this.min.y = Math.min(point.y, this.min.y);
      this.max.y = Math.max(point.y, this.max.y);
    }

    return this;
  },
  // @method getCenter(round?: Boolean): Point
  // Returns the center point of the bounds.
  getCenter: function (round) {
    return new _Point2D["default"]((this.min.x + this.max.x) / 2, (this.min.y + this.max.y) / 2, round);
  },
  // @method getBottomLeft(): Point
  // Returns the bottom-left point of the bounds.
  getBottomLeft: function () {
    return new _Point2D["default"](this.min.x, this.max.y);
  },
  // @method getTopRight(): Point
  // Returns the top-right point of the bounds.
  getTopRight: function () {
    // -> Point
    return new _Point2D["default"](this.max.x, this.min.y);
  },
  // @method getSize(): Point
  // Returns the size of the given bounds
  getSize: function () {
    return this.max.subtract(this.min);
  },
  // @method contains(otherBounds: Bounds): Boolean
  // Returns `true` if the rectangle contains the given one.
  // @alternative
  // @method contains(point: Point): Boolean
  // Returns `true` if the rectangle contains the given point.
  contains: function (obj) {
    var min, max;

    if (typeof obj[0] === 'number' || obj instanceof _Point2D["default"]) {
      obj = _Point2D["default"].create(obj);
    } else {
      obj = Bounds.create(obj);
    }

    if (obj instanceof Bounds) {
      min = obj.min;
      max = obj.max;
    } else {
      min = max = obj;
    }

    return min.x >= this.min.x && max.x <= this.max.x && min.y >= this.min.y && max.y <= this.max.y;
  },
  // @method intersects(otherBounds: Bounds): Boolean
  // Returns `true` if the rectangle intersects the given bounds. Two bounds
  // intersect if they have at least one point in common.
  intersects: function (bounds) {
    // (Bounds) -> Boolean
    bounds = Bounds.create(bounds);
    var min = this.min,
        max = this.max,
        min2 = bounds.min,
        max2 = bounds.max,
        xIntersects = max2.x >= min.x && min2.x <= max.x,
        yIntersects = max2.y >= min.y && min2.y <= max.y;
    return xIntersects && yIntersects;
  },
  // @method overlaps(otherBounds: Bounds): Boolean
  // Returns `true` if the rectangle overlaps the given bounds. Two bounds
  // overlap if their intersection is an area.
  overlaps: function (bounds) {
    // (Bounds) -> Boolean
    bounds = Bounds.create(bounds);
    var min = this.min,
        max = this.max,
        min2 = bounds.min,
        max2 = bounds.max,
        xOverlaps = max2.x > min.x && min2.x < max.x,
        yOverlaps = max2.y > min.y && min2.y < max.y;
    return xOverlaps && yOverlaps;
  },
  isValid: function () {
    return !!(this.min && this.max);
  }
};

Bounds.create = function (a, b) {
  if (!a || a instanceof Bounds) {
    return a;
  }

  return new Bounds(a, b);
};

var _default = Bounds;
exports["default"] = _default;

/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.createCanvasRenderer = void 0;

var _SvgRenderer = _interopRequireDefault(__webpack_require__(114));

var _VmlRenderer = _interopRequireDefault(__webpack_require__(69));

var _CanvasRenderer = _interopRequireDefault(__webpack_require__(115));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

// import FineCanvasRenderer from "./FineCanvasRenderer";
var createRenderer = function (dom, chart) {
  // if(__export__) {
  //     return new FineCanvasRenderer(dom, chart);
  // }
  return (0, _EnvUtils.isSupportSVG)() ? new _SvgRenderer["default"](dom, chart) : new _VmlRenderer["default"](dom, chart);
};

var createCanvasRenderer = function (dom, chart, config) {
  return new _CanvasRenderer["default"](dom, chart, config);
};

exports.createCanvasRenderer = createCanvasRenderer;
var _default = createRenderer;
exports["default"] = _default;

/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Class = _interopRequireDefault(__webpack_require__(27));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/7/12.
 */
var _default = _Class["default"].extend({
  initialize: function (renderer) {
    this.renderer = renderer;
    this.ctx = renderer.ctx;
    this.cut = null;

    this._initialize(renderer);
  },
  setStyle: function (style) {
    for (var prop in this.style) {
      if (style.hasOwnProperty(prop)) {
        this.style[prop] = style[prop];
      }
    }

    return this;
  },
  drawStyle: function () {
    var s = this.style;
    this.renderer.lineWidth(s.lineWidth);
    this.renderer.strokeStyle(s.strokeStyle);
    this.renderer.fillStyle(s.fillStyle);
    this.renderer.beginNewPath();
    return this;
  },
  contain: function () {},
  animate: function () {
    if (!this.cut) {
      this.cut = this.renderer.animation.animate(this.style);
    }

    return this;
  },
  // mixin ?
  delay: function (time) {
    this.cut.delay(time);
    return this;
  },
  duration: function (time) {
    this.cut.duration(time);
    return this;
  },
  tween: function (key, v) {
    this.cut.tween(key, v);
    return this;
  },
  end: function (f) {
    this.cut.end(f);
    return this;
  },
  stop: function () {
    this.cut.stop();
    return this;
  },
  ease: function (easing) {
    this.cut.ease(easing);
    return this;
  },
  remove: function () {
    this.cut && this.cut.stop();
    this.needToRemove = true;
  }
});

exports["default"] = _default;

/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.calculateCustomLabel = calculateCustomLabel;
exports.defaultLabelContent = defaultLabelContent;
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _FormattedText = __webpack_require__(41);

var _dateLabelStyle = __webpack_require__(130);

var _richTextDetail = __webpack_require__(55);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function valid(point, dataLabels) {
  dataLabels = dataLabels || point && point.options && point.options.dataLabels;
  var hasDataLabels = dataLabels && dataLabels.enabled && dataLabels.formatter;
  return point.series.vanchart.isMap() ? hasDataLabels : hasDataLabels && point.isVisible();
}

function calculateDataLabel(point, dataLabels) {
  // 如果判断不通过直接return的话，那么图表里再计算的时候，都要判断过滤一下points，找了一下发现有点多，没敢那么改，怕出岔子
  if (!valid(point, dataLabels)) {
    point.labelDim = {
      width: 0,
      height: 0
    };
    point.labelContent = [];
    return;
  }

  dataLabels = dataLabels || point.options.dataLabels;
  var formatter = dataLabels.formatter;
  point.labelContent = typeof formatter == 'object' ? calculateNormalLabel(point, dataLabels) : calculateCustomLabel(point, dataLabels);
  var textDim = dataLabels.useRichText ? (0, _richTextDetail.getRichTextDim)(point.labelContent) : (0, _FormattedText.calculateTextDim)(point.labelContent, point);
  var width = textDim.width,
      height = textDim.height,
      _textDim$nameValueGap = textDim.nameValueGap,
      nameValueGap = _textDim$nameValueGap === void 0 ? 0 : _textDim$nameValueGap;
  point.labelDim = {
    width: width,
    height: height,
    nameValueGap: nameValueGap,
    innerTextDim: textDim
  };
}

function calculateCustomLabel(point, dataLabels) {
  dataLabels = dataLabels || point.options.dataLabels;
  var formatter = dataLabels.formatter;
  var text = "";

  try {
    // 用户自定义的，里面极有可能有抛错，如window.FR.contentFormat
    text = _BaseUtils["default"].getFormatterFunction(formatter).call(point);
  } catch (e) {}

  var style = fixCustomLabelsStyle(point, dataLabels);
  var useHtml = point.series.vanchart.isMap() ? true : dataLabels.useHtml;

  var dim = _BaseUtils["default"].getTextDimension(text, style, useHtml);

  if (dataLabels.useHtml) {
    dim.width = isNaN(parseFloat(dataLabels.labelWidth)) ? dim.width : parseFloat(dataLabels.labelWidth);
    dim.height = isNaN(parseFloat(dataLabels.labelHeight)) ? dim.height : parseFloat(dataLabels.labelHeight);
  }

  return [{
    text: text,
    style: style,
    dim: dim
  }];
}

function fixCustomLabelsStyle(point, dataLabels) {
  var style = dataLabels.style || (0, _dateLabelStyle.defaultValueStyle)(point);

  if (point.series.isSupportVerticalLabel() && dataLabels.orientation && dataLabels.orientation === _Constants["default"].VERTICAL_LAYOUT) {
    style = _BaseUtils["default"].extend({}, style, {
      'writingMode': 'tb-rl',
      'writing-mode': 'tb-rl',
      '-webkit-writing-mode': 'vertical-rl'
    });
  }

  return style;
}

function calculateNormalLabel(point, dataLabels) {
  var series = point.series,
      type = series.type;

  if (dataLabels && dataLabels.useRichText) {
    return (0, _richTextDetail.getLabelRichTextDetail)(point, dataLabels.richText, dataLabels.autoStyle, dataLabels.formatter);
  }

  if (series.vanchart.isMap()) {
    return calculateMapLabel(point, dataLabels);
  }

  if (type === _Constants["default"].BUBBLE_CHART || type === _Constants["default"].SCATTER_CHART) {
    return bubbleLabelContent(point);
  } else if (type === _Constants["default"].FUNNEL_CHART) {
    return funnelLabelContent(point);
  } else if (type === _Constants["default"].COLUMN_CHART) {
    return columnLabelContent(point);
  } else {
    return defaultLabelContent(point, dataLabels);
  }
}

function columnLabelContent(point) {
  var dataLabels = point.options.dataLabels;
  var formatter = dataLabels.formatter;
  var orientation = dataLabels.orientation;
  var identifier = formatter.identifier;

  if (orientation && orientation === _Constants["default"].VERTICAL_LAYOUT) {
    var style = _BaseUtils["default"].extend({
      'writingMode': 'tb-rl',
      'writing-mode': 'tb-rl',
      '-webkit-writing-mode': 'vertical-rl'
    }, (0, _dateLabelStyle.defaultValueStyle)(point, dataLabels));

    var fields = [];
    [_FormattedText.CATEGORY, _FormattedText.SERIES, _FormattedText.VALUE, _FormattedText.PERCENT].forEach(function (id) {
      if (identifier.indexOf(id) !== -1) {
        var prop = _FormattedText.propMap[id];

        if (prop && prop.length === 2) {
          var propKey = prop[0],
              fmtKey = prop[1];
          fields.push(_BaseUtils["default"].format(point[propKey], formatter[fmtKey]));
        }
      }
    });
    var text = fields.join(_Constants["default"].BLANK_VALUE_PERCENTAGE);

    var dim = _BaseUtils["default"].getTextDimension(text, style, false);

    return [{
      text: text,
      style: style,
      dim: dim
    }];
  }

  return defaultLabelContent(point, dataLabels);
}

function bubbleLabelContent(point) {
  var dataLabels = point.options.dataLabels,
      formatter = dataLabels.formatter,
      identifier = formatter.identifier;
  var content = [];

  if (identifier.indexOf(_FormattedText.DESCRIPTION) != -1) {
    var descriptionStyle = dataLabels.style || (0, _dateLabelStyle.defaultCategoryStyle)(point);

    var descriptionDim = _BaseUtils["default"].getTextDimension(point.options.description, descriptionStyle, dataLabels.useHtml);

    content.push({
      text: point.options.description,
      style: descriptionStyle,
      dim: descriptionDim
    });
  }

  if (identifier.indexOf(_FormattedText.SERIES) != -1) {
    var seriesString = _BaseUtils["default"].format(point.seriesName, formatter.seriesFormat);

    var seriesStyle = dataLabels.style || (0, _dateLabelStyle.defaultCategoryStyle)(point);

    var seriesDim = _BaseUtils["default"].getTextDimension(seriesString, seriesStyle, dataLabels.useHtml);

    content.push({
      text: seriesString,
      style: seriesStyle,
      dim: seriesDim
    });
  }

  if (identifier.indexOf(_FormattedText.X) != -1 || identifier.indexOf(_FormattedText.Y) != -1 || identifier.indexOf(_FormattedText.SIZE) != -1) {
    var text = (0, _FormattedText.getXYSizeString)(point, formatter, identifier);
    var style = dataLabels.style || (0, _dateLabelStyle.defaultValueStyle)(point);

    var dim = _BaseUtils["default"].getTextDimension(text, style, dataLabels.useHtml);

    content.push({
      text: text,
      style: style,
      dim: dim
    });
  }

  return content;
}

function funnelLabelContent(point) {
  var dataLabels = point.options.dataLabels,
      formatter = dataLabels.formatter,
      identifier = formatter.identifier;

  if (dataLabels.align == _Constants["default"].INSIDE) {
    return defaultLabelContent(point);
  }

  var funnel = point.series,
      content = [];

  if (identifier.indexOf(_FormattedText.NAME) != -1) {
    var nameString = _BaseUtils["default"].format(point.name, formatter.nameFormat);

    var nameStyle = (0, _dateLabelStyle.defaultCategoryStyle)(point);

    var nameDim = _BaseUtils["default"].getTextDimension(nameString, nameStyle, dataLabels.useHtml);

    content.nameLabelContent = {
      text: nameString,
      style: nameStyle,
      dim: nameDim
    };

    if (!funnel.maxNameLabelWidth) {
      funnel.maxNameLabelWidth = 0;
    }

    funnel.maxNameLabelWidth = Math.max(funnel.maxNameLabelWidth, nameDim.width);
  }

  if (identifier.indexOf(_FormattedText.VALUE) != -1 || identifier.indexOf(_FormattedText.PERCENT) != -1 || identifier.indexOf(_FormattedText.ARRIVALRATE) != -1) {
    var items = [];

    if (identifier.indexOf(_FormattedText.VALUE) != -1) {
      items.push(_BaseUtils["default"].format(point.originalValue, formatter.valueFormat));
    }

    if (identifier.indexOf(_FormattedText.PERCENT) != -1) {
      items.push(_BaseUtils["default"].format(point.percentage, formatter.percentFormat));
    }

    if (identifier.indexOf(_FormattedText.ARRIVALRATE) != -1) {
      items.push(_BaseUtils["default"].format(point.arrivalRate, formatter.arrivalRateFormat));
    }

    var text = items.join(_Constants["default"].BLANK_VALUE_PERCENTAGE);
    var style = (0, _dateLabelStyle.defaultValueStyle)(point);

    var dim = _BaseUtils["default"].getTextDimension(text, style, dataLabels.useHtml);

    content.valueLabelContent = {
      text: text,
      style: style,
      dim: dim
    };

    if (!funnel.maxValueLabelWidth) {
      funnel.maxValueLabelWidth = 0;
    }

    funnel.maxValueLabelWidth = Math.max(funnel.maxValueLabelWidth, dim.width);
  }

  return content;
}

function defaultLabelContent(point, dataLabels) {
  dataLabels = dataLabels || point.options.dataLabels;
  var series = point.series,
      formatter = dataLabels.formatter,
      identifier = formatter.identifier;
  var names = [_FormattedText.NAME, _FormattedText.CATEGORY, _FormattedText.SERIES],
      values = [_FormattedText.VALUE, _FormattedText.PERCENT, _FormattedText.ARRIVALRATE, _FormattedText.LEVEL];
  var cateStyleFun = _dateLabelStyle.defaultCategoryStyle,
      valueStyleFun = _dateLabelStyle.defaultValueStyle; // adjust the sequence and style here

  if (series.type === _Constants["default"].TREEMAP_CHART) {
    values.unshift(names.shift());
    valueStyleFun = cateStyleFun;
  } else if (series.type === _Constants["default"].GANTT_CHART) {
    names = [];
    values = [_FormattedText.PROCESSES, _FormattedText.SERIES, _FormattedText.STARTTIME, _FormattedText.FINISHTIME, _FormattedText.DURATION, _FormattedText.PROGRESS];
  } else if (series.type === _Constants["default"].BAR_CHART && dataLabels.align === _Constants["default"].AUTO) {
    names = names.filter(function (name) {
      return identifier.indexOf(name) !== -1;
    });
    values = values.filter(function (value) {
      return identifier.indexOf(value) !== -1;
    });

    if (names.length === 1 && values.length === 1) {
      names = [];
      values = [_FormattedText.CATEGORY, _FormattedText.SERIES, _FormattedText.VALUE, _FormattedText.PERCENT];
    }
  }

  var content = [];
  addContent(content, getContentItems(names), cateStyleFun);
  addContent(content, getContentItems(values), valueStyleFun);

  function getContentItems(items) {
    return items.map(fmtStr).filter(clean);
  }

  function fmtStr(item) {
    if (identifier.indexOf(item) !== -1) {
      var propKey = _FormattedText.propMap[item][0];
      var fmtKey = _FormattedText.propMap[item][1];
      var value = series._formatValue ? series._formatValue(point, propKey) : point[propKey];

      var fmt = formatter[fmtKey] || series._getLabelFormatFn && series._getLabelFormatFn(propKey);

      var str = _BaseUtils["default"].format(value, fmt);

      return series._postLabel ? series._postLabel(str, propKey) : str;
    }

    return null;
  }

  function clean(item) {
    return item !== null;
  }

  function addContent(content, items, styleFun) {
    if (!items.length) {
      return;
    }

    var text = items.join(_Constants["default"].BLANK_VALUE_PERCENTAGE);
    var style = styleFun(point, dataLabels);

    var dim = _BaseUtils["default"].getTextDimension(text, style, dataLabels.useHtml);

    content.push({
      text: text,
      style: style,
      dim: dim
    });
  }

  return content;
}

function calculateMapLabel(point, dataLabels) {
  if (!point || !dataLabels || !dataLabels.enabled) {
    return {};
  } // CHART-14818 地图的TextLayer默认为Html标签显示，为了统一计算与渲染时标签尺寸一致，所以在计算标签尺寸时useHtml也默认为true


  var formatter = dataLabels.formatter,
      useHtml = true;
  var content = [];

  if (typeof formatter == 'object') {
    var label = formatter.identifier;

    if (label.indexOf(_FormattedText.NAME) != -1) {
      var text = _BaseUtils["default"].format(point.name, formatter.areaNameFormat);

      var style = (0, _dateLabelStyle.defaultCategoryStyle)(point, dataLabels);

      var dim = _BaseUtils["default"].getTextDimension(text, style, useHtml);

      content.push({
        text: text,
        style: style,
        dim: dim
      });
    }

    var line = '';
    var hasSeries = label.indexOf(_FormattedText.SERIES) != -1,
        hasValue = label.indexOf(_FormattedText.VALUE) != -1 || label.indexOf(_FormattedText.SIZE) != -1,
        hasPercent = label.indexOf(_FormattedText.PERCENT) != -1;

    var seriesLabel = _BaseUtils["default"].format(point.seriesName, formatter.seriesFormat);

    var valueLabel = _BaseUtils["default"].format(point.originalValue, formatter.valueFormat);

    var percentLabel = _BaseUtils["default"].format(point.percentage, formatter.percentFormat);

    if (hasSeries) {
      line += seriesLabel;

      if (hasValue || hasPercent) {
        line += ':';
      }
    }

    if (hasValue) {
      line += valueLabel;

      if (hasPercent) {
        line += ' ';
      }
    }

    if (hasPercent) {
      line += percentLabel;
    }

    if (line) {
      var style = (0, _dateLabelStyle.defaultValueStyle)(point, dataLabels);

      var dim = _BaseUtils["default"].getTextDimension(line, style, useHtml);

      content.push({
        text: line,
        style: style,
        dim: dim
      });
    }
  }

  return content;
}

var _default = calculateDataLabel;
exports["default"] = _default;

/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/8/7.
 */
//管理标签位置
function BoundsManager() {
  this.addedBounds = [];
}

BoundsManager.prototype = {
  constructor: BoundsManager,
  addBounds: function (bounds) {
    this.addedBounds.push(bounds);
  },
  isValidBounds: function (bounds) {
    return bounds.width > 0 && bounds.height > 0;
  },
  isOverlapped: function (bounds) {
    for (var i = 0, len = this.addedBounds.length; i < len; i++) {
      if (_BaseUtils["default"].rectangleOverlapped(bounds, this.addedBounds[i])) {
        return true;
      }
    }

    return false;
  },
  calculateOverlapRate: function () {
    var remaining = _BaseUtils["default"].clone(this.addedBounds),
        total = remaining.length,
        indexMap = {},
        i,
        j,
        len,
        max = 0,
        index = -1,
        remove = 0,
        target;

    for (i = 0, len = remaining.length; i < len; i++) {
      for (j = i + 1; j < len; j++) {
        if (_BaseUtils["default"].rectangleOverlapped(remaining[i], remaining[j])) {
          indexMap[i] = indexMap[i] || [];
          indexMap[j] = indexMap[j] || [];
          indexMap[i].push(j);
          indexMap[j].push(i);

          if (indexMap[i].length > max) {
            max = indexMap[i].length;
            index = i;
          }

          if (indexMap[j].length > max) {
            max = indexMap[j].length;
            index = j;
          }
        }
      }
    }

    while (max) {
      remove++;

      for (i = 0, len = indexMap[index].length; i < len; i++) {
        target = indexMap[indexMap[index][i]];
        target.splice(target.indexOf(index), 1);
      }

      indexMap[index] = [];
      max = 0;

      for (i in indexMap) {
        if (indexMap[i].length > max) {
          max = indexMap[i].length;
          index = i;
        }
      }
    }

    return total === 0 ? 0 : remove / total;
  },
  isEmpty: function () {
    return this.addedBounds.length === 0;
  }
};
var _default = BoundsManager;
exports["default"] = _default;

/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Class = _interopRequireDefault(__webpack_require__(27));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/7/5.
 */
var _default = _Class["default"].extend({
  z: 0,
  initialize: function (handler) {
    this.init(handler);
  },
  init: function (handler) {
    this.vanchart = handler.vanchart;
    this.handler = handler;
    this.parent = handler;
  },
  contain: function (p) {
    return _BaseUtils["default"].containsPoint(this.getBoundingRect(), p);
  },
  getBoundingRect: function () {},
  getActions: function () {
    return {};
  }
});

exports["default"] = _default;

/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/5/26.
 *
 * try to use Behavior Delegation
 */
function Class() {}

;

Class.extend = function (props) {
  // @function extend(props: Object): Function
  // [Extends the current class](#class-inheritance) given the properties to be included.
  // Returns a Javascript function that is a class constructor (to be called with `new`).
  var NewClass = function () {
    // call the constructor
    if (this.initialize) {
      this.initialize.apply(this, arguments);
    } // call all constructor hooks


    this.callInitHooks();
  };

  var parentProto = NewClass.__super__ = this.prototype;
  var proto = Object.create(parentProto);
  proto.constructor = NewClass;
  NewClass.prototype = proto; // inherit parent's statics

  for (var i in this) {
    if (this.hasOwnProperty(i) && i !== 'prototype') {
      NewClass[i] = this[i];
    }
  } // // merge options


  if (proto.options) {
    props.options = _BaseUtils["default"].extend(Object.create(proto.options), props.options);
  } // mix given properties into the prototype


  _BaseUtils["default"].extend(proto, props);

  proto._initHooks = []; // add method for calling all hooks

  proto.callInitHooks = function () {
    if (this._initHooksCalled) {
      return;
    }

    if (parentProto.callInitHooks) {
      parentProto.callInitHooks.call(this);
    }

    this._initHooksCalled = true;

    for (var i = 0, len = proto._initHooks.length; i < len; i++) {
      proto._initHooks[i].call(this);
    }
  };

  return NewClass;
};

Class.include = function (props) {
  _BaseUtils["default"].extend(this.prototype, props);

  return this;
}; // @function addInitHook(fn: Function)
// Adds a [constructor hook](#class-constructor-hooks) to the class.


Class.addInitHook = function (fn) {
  // (Function) || (String, args...)
  var args = Array.prototype.slice.call(arguments, 1);
  var init = typeof fn === 'function' ? fn : function () {
    this[fn].apply(this, args);
  };
  this.prototype._initHooks = this.prototype._initHooks || [];

  this.prototype._initHooks.push(init);

  return this;
};

var _default = Class;
exports["default"] = _default;

/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getAllMapPoints = getAllMapPoints;
exports.areaPointMapValidPoints = areaPointMapValidPoints;
exports.mapPointsWithRangeLegend = mapPointsWithRangeLegend;
exports.areaPointMapPointsWithRangeLegend = areaPointMapPointsWithRangeLegend;
exports.getHeatMapPoints = getHeatMapPoints;
exports.getLineMapPoints = getLineMapPoints;
exports.areaMapPointsWithNormalLegend = areaMapPointsWithNormalLegend;
exports.pointMapPointsWithNormalLegend = pointMapPointsWithNormalLegend;
exports.areaPointMapPointsWithNormalLegend = areaPointMapPointsWithNormalLegend;
exports.pointMapLargeModePoints = pointMapLargeModePoints;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _mapUtils = __webpack_require__(129);

var _util = __webpack_require__(75);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function getAllMapPoints(vanchart) {
  var areaPointMapPoints = areaPointMapValidPoints(vanchart);
  var heatMapPoints = getHeatMapPoints(vanchart);
  var lineMapPoints = getLineMapPoints(vanchart);
  return areaPointMapPoints.concat(heatMapPoints).concat(lineMapPoints);
}

function areaPointMapValidPoints(vanchart) {
  var isNormalLegend = vanchart.getComponent(_component.ComponentCst.LEGEND_COMPONENT);
  return isNormalLegend ? areaPointMapPointsWithNormalLegend(vanchart) : areaPointMapPointsWithRangeLegend(vanchart).filter(function (point) {
    return point.visible;
  });
}
/**
 * 计算地图范围图例的最大最小值时需要的points:
 * 1、区域地图每个区域名的第一个系列中的点
 * 2、点地图、热力地图每个经纬度下的第一个系列中的点
 * 3、流向地图所有系列的点
 */


function mapPointsWithRangeLegend(geo, series) {
  var mapPoints = [],
      areaKeyMap = {},
      lngLatKeyMap = {};
  series.forEach(function (ser) {
    var type = ser.type;
    var isAreaMap = type === _Constants["default"].AREA_MAP;
    var isLineMap = type === _Constants["default"].LINE_MAP;
    ser.points.forEach(function (point) {
      var name = point.name;
      var features = geo.getFeaturesByName(name, type);

      if (isLineMap) {
        mapPoints.push(point);
      } else if (isAreaMap) {
        if (!areaKeyMap[name] && features) {
          mapPoints.push(point);
        }

        areaKeyMap[name] = true;
      } else {
        var lngLatArr = geo.getDataPointLngLat(point, features && features[0]);
        var lngLat = lngLatArr && lngLatArr.join('-');

        if (!lngLatKeyMap[lngLat] && lngLat) {
          mapPoints.push(point);
        }

        lngLatKeyMap[lngLat] = true;
      }
    });
  });
  return mapPoints;
}
/**
 * 范围图例：区域地图、点地图
 * @param vanchart
 * @returns {*[]}
 */


function areaPointMapPointsWithRangeLegend(vanchart) {
  var geo = vanchart.getCurrentGeo();
  var series = vanchart.series;
  return mapPointsWithRangeLegend(geo, series).filter(function (point) {
    var type = point.series.type;
    return type !== _Constants["default"].LINE_MAP && type !== _Constants["default"].HEAT_MAP;
  }).reverse();
}
/**
 * 热力地图
 * @param vanchart
 * @returns {*[]}
 */


function getHeatMapPoints(vanchart) {
  var geo = vanchart.getCurrentGeo();
  var series = vanchart.series;
  var heatMapPoints = mapPointsWithRangeLegend(geo, (0, _util.seriesOfType)(series, _Constants["default"].HEAT_MAP));
  heatMapPoints.forEach(function (point) {
    return point.options.lnglat = fixPointLnglat(geo, point, _Constants["default"].HEAT_MAP);
  });
  return heatMapPoints;
}
/**
 * 流向地图
 * @param vanchart
 * @returns {*[]}
 */


function getLineMapPoints(vanchart) {
  var lineMapSeries = vanchart.seriesOfType(_Constants["default"].LINE_MAP);
  return lineMapSeries.reduce(function (accum, seriesItems) {
    return accum.concat(seriesItems.points);
  }, []);
}

function fixPointLnglat(geo, point, mapType) {
  var options = point.options,
      name = point.name;

  if (options.lnglat) {
    return options.lnglat;
  }

  var feature = geo.getFeaturesByName(name, mapType);
  return geo.getDataPointLngLat(point, feature && feature[0]);
}
/**
 * 普通图例：区域地图
 */


function areaMapPointsWithNormalLegend(geo, series) {
  var mapPoints = [],
      areaKeyMap = {};
  var showSeries = series.filter(function (ser) {
    return ser.type === _Constants["default"].AREA_MAP && ser.visible;
  });
  showSeries.forEach(function (ser) {
    var type = ser.type,
        points = ser.points;

    for (var i = 0; i < points.length; i++) {
      var point = points[i];
      var name = point.name;
      var features = geo.getFeaturesByName(name, type);

      if (point.isNull && !point.options.drilldown) {
        continue;
      }

      if (!areaKeyMap[name] && features) {
        mapPoints.push(point);
      }

      areaKeyMap[name] = true;
    }
  });
  return mapPoints.reverse();
}
/**
 * 普通图例：点地图
 */


function pointMapPointsWithNormalLegend(geo, series) {
  var mapPoints = [],
      lngLatKeyMap = {};
  var showPointSeries = series.filter(function (ser) {
    return (0, _mapUtils.isPointMap)(ser.type) && ser.visible;
  });
  showPointSeries.forEach(function (ser) {
    var type = ser.type,
        points = ser.points;

    for (var i = 0; i < points.length; i++) {
      var point = points[i];
      var name = point.name;
      var features = geo.getFeaturesByName(name, type);
      var lngLatArr = geo.getDataPointLngLat(point, features && features[0]);
      var lngLat = lngLatArr && lngLatArr.join('-');

      if (!lngLat) {
        continue;
      }

      if (type === _Constants["default"].BUBBLE_CHART) {
        !isNaN(point.radius) && mapPoints.push(point);
        continue;
      }

      if (!lngLatKeyMap[lngLat]) {
        mapPoints.push(point);
      }

      lngLatKeyMap[lngLat] = true;
    }
  }); // 加reverse()的原因是：气泡地图第一个系列的点应该在最上层

  return mapPoints.reverse();
}

function areaPointMapPointsWithNormalLegend(vanchart) {
  var series = vanchart.series;
  var geo = vanchart.getCurrentGeo();
  return areaMapPointsWithNormalLegend(geo, series).concat(pointMapPointsWithNormalLegend(geo, series));
}
/**
 * 获取大数据模式下散点、气泡类型地图的数据点
 * @param vanchart
 */


function pointMapLargeModePoints(vanchart) {
  var largeSeries = vanchart.largeSeries;
  areaPointMapValidPoints(vanchart).forEach(function (point) {
    var _point$series = point.series,
        options = _point$series.options,
        type = _point$series.type;

    if (options.large && largeSeries[type]) {
      largeSeries[type].points.push(point);
    }
  });
  return largeSeries;
}

/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getLineStyle = getLineStyle;

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function getLineStyle(config) {
  var color = config.color,
      lineWidth = config.lineWidth,
      _config$lineType = config.lineType,
      lineType = _config$lineType === void 0 ? _Constants["default"].SOLID : _config$lineType,
      _config$opacity = config.opacity,
      opacity = _config$opacity === void 0 ? 1 : _config$opacity;
  lineWidth = _Constants["default"].DASH_ARRAY[lineType] == null ? 0 : lineWidth;
  return {
    'fill': 'none',
    'stroke': color,
    'stroke-width': lineWidth,
    'stroke-opacity': opacity,
    'stroke-dasharray': _Constants["default"].DASH_ARRAY[lineType]
  };
}

/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by Yuqian on 2017/1/22.
 */
function lineH(R, G, styles, x1, x2, y, old) {
  if (!old) {
    old = G.append(R.line().style(styles));
  }

  return old.attr({
    x1: x1,
    y1: y,
    x2: x2,
    y2: y
  });
}

function lineV(R, G, styles, y1, y2, x, old) {
  if (!old) {
    old = G.append(R.line().style(styles));
  }

  return old.attr({
    x1: x,
    y1: y1,
    x2: x,
    y2: y2
  });
}

function rect(R, G, styles, x, y, width, height, old) {
  if (!old) {
    old = G.append(R.rect().style(styles));
  }

  return old.attr({
    x: x,
    y: y,
    width: width,
    height: height
  });
}

function traverse(root, childName, before, after) {
  function dfs(node, depth, len, i, parent) {
    before && before(node, depth, len, i, parent);
    var c = node[childName],
        n;

    if (c && (n = c.length)) {
      c.map(function (d, i) {
        dfs(d, depth + 1, n, i, node);
      });
    }

    after && after(node, depth, len, i, parent);
  }

  dfs(root, 0, 0, 0, null);
}

function sum(arr) {
  return arr.reduce(function (a, b) {
    return a + b;
  }, 0);
} // calc new values according to old proportions


function distribValues(oldValues, newValue) {
  var old = sum(oldValues);
  return oldValues.map(function (v) {
    return v / old * newValue;
  });
}

function getValidProgress(v) {
  v = +v; // #CHART-2504
  // 限制在 0 - 1

  if (isNaN(v)) {
    return 0;
  } else if (v < 0) {
    return 0;
  } else if (v > 1) {
    return 1;
  }

  return v;
}

var _default = {
  lineH: lineH,
  lineV: lineV,
  rect: rect,
  traverse: traverse,
  sum: sum,
  distribValues: distribValues,
  getValidProgress: getValidProgress
};
exports["default"] = _default;

/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getSeriesFillFilter = getSeriesFillFilter;
exports.notSupportGradualColor = notSupportGradualColor;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _GradualColorUtils = __webpack_require__(42);

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function columnAxisGradientLocation(ser) {
  var options = ser.options,
      yAxis = ser.yAxis;
  var isInverted = options.inverted;
  var isAxisReversed = yAxis.options.reversed;

  if (isInverted) {
    return isAxisReversed ? _Constants["default"].RIGHT_TO_LEFT : _Constants["default"].LEFT_TO_RIGHT;
  }

  return isAxisReversed ? _Constants["default"].TOP_TO_BOTTOM : _Constants["default"].BOTTOM_TO_TOP;
}

function barAxisGradientLocation(ser) {
  var options = ser.options,
      xAxis = ser.xAxis;
  var isInverted = options.inverted;
  var isAxisReversed = xAxis.options.reversed;

  if (isInverted) {
    return isAxisReversed ? _Constants["default"].BOTTOM_TO_TOP : _Constants["default"].TOP_TO_BOTTOM;
  }

  return isAxisReversed ? _Constants["default"].RIGHT_TO_LEFT : _Constants["default"].LEFT_TO_RIGHT;
}

function getAxisGradientLocation(ser) {
  var options = ser.options;
  var type = options.type;
  return type === _Constants["default"].COLUMN_CHART ? columnAxisGradientLocation(ser) : barAxisGradientLocation(ser);
}

function isNotSupportGradual(type) {
  return !(0, _EnvUtils.supportFillFilter)() || type !== _Constants["default"].COLUMN_CHART && type !== _Constants["default"].BAR_CHART;
}

function getSeriesFillFilter(color, ser) {
  var options = ser.options,
      vanchart = ser.vanchart;
  var gradualStyle = options.gradualStyle,
      gradualColorsOpt = options.gradualColors,
      type = options.type;

  if (gradualStyle === _Constants["default"].STYLE_NORMAL) {
    return color;
  }

  if (isNotSupportGradual(type)) {
    return notSupportGradualColor(options, color);
  }

  var renderer = vanchart.renderer;
  var location = getAxisGradientLocation(ser);
  var attrs = (0, _GradualColorUtils.gradualLocation)(location);
  var gradualColors = gradualStyle === _Constants["default"].STYLE_CUSTOM ? gradualColorsOpt : [color, _ColorUtils["default"].getColorWithDivider(color, 0.9)];
  var stop1 = {
    'offset': '0%',
    'stop-color': gradualColors[0]
  };
  var stop2 = {
    'offset': '100%',
    'stop-color': gradualColors[1]
  };

  if (ser.colorGradient) {
    renderer.updateColorGradient(ser.colorGradient, attrs, [stop1, stop2]);
  } else {
    ser.colorGradient = renderer.colorGradient(attrs, [stop1, stop2]);
  }

  return renderer.toPatternProperty(ser.colorGradient);
}

function notSupportGradualColor(options, color) {
  var gradualStyle = options.gradualStyle,
      gradualColors = options.gradualColors;
  return gradualStyle === _Constants["default"].STYLE_CUSTOM ? gradualColors[1] : color;
}

/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _index = _interopRequireDefault(__webpack_require__(108));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/3/28.
 */
var _textMap = {}; // 默认使用英文

var _locale = '';

function localeText(key) {
  return _textMap[key] != null ? _textMap[key] : key;
}
/**
 * set locale by inner setting
 * @param {string} language - like 'zh-cn'
 */


localeText.setLocale = function (language) {
  var lan = localeText.normalizeLocale(language);
  localeText.setCustomLocale((0, _index["default"])(lan));
};
/**
 * extend textMap by another Map
 * @param {Object} map - Key-Value object
 *
 * a problem: may conflict if set again
 */


localeText.setCustomLocale = function (map) {
  if ((0, _CoreUtils.hasDefined)(map)) {
    _BaseUtils["default"].extend(_textMap, map);

    _locale = map._locale;
  }
};

localeText.getLocale = function () {
  return _locale;
};

localeText.getTextMap = function () {
  return _textMap;
};

localeText.i18nText = function (key) {
  return _textMap[key];
};

localeText.normalizeLocale = function (key) {
  return key ? key.toLowerCase().replace('_', '-') : key;
};

var _default = localeText;
exports["default"] = _default;

/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _chart = _interopRequireDefault(__webpack_require__(74));

var _VanChartLayout = _interopRequireDefault(__webpack_require__(52));

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _localeText = _interopRequireDefault(__webpack_require__(32));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _MobileHandler = _interopRequireDefault(__webpack_require__(197));

var _HammerHandler = _interopRequireDefault(__webpack_require__(94));

var _config = _interopRequireWildcard(__webpack_require__(205));

var _showEmptyDataTip = _interopRequireDefault(__webpack_require__(72));

var _renderer = _interopRequireDefault(__webpack_require__(22));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _validMapPoints = __webpack_require__(28);

var _util = __webpack_require__(75);

var _VanRefresh = _interopRequireDefault(__webpack_require__(206));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _ThemeConfig = __webpack_require__(17);

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

var MOBILE_HOVER_HIDE_DELAY = 4000; // Cmen: 所有的默认间隙都是基于16px字体大小的,后期如果需要更改默认间隙,可以在BaseUtils里面设置DEFAULT_PADDING_FONTSIZE来调整
// 考虑到缩放的影响,所有关于间隙的尺寸计算,都从对应的_FUN函数中获取根据缩放SCALE计算后的值。

var PADDING = 8;

var PADDING_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING);
};

var INTERACTIVE_COMPONENTS = [_component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.ANGLE_AXIS_COMPONENT];

var VanChart = _Evented["default"].extend({
  vanChartType: 'vanChart',
  initialize: function (option, dom, vancharts) {
    this.wrapDom = dom;
    this.width = _BaseUtils["default"].pick(option.width, _BaseUtils["default"].getDomWidth(dom));
    this.height = _BaseUtils["default"].pick(option.height, _BaseUtils["default"].getDomHeight(dom)); // touch pan & pinch zoom

    this._plotZoom = {
      x: 1,
      y: 1
    };
    this._plotOffset = {
      x: 0,
      y: 0
    };
    this._eventsConfig = {
      pinch: true,
      pan: true
    };
    this.vancharts = vancharts;
    this.series = [];
    this.components = {};
    this._targets = {};
    this.animationCount = 0;
    this._changeDataState = false;
    this.fullScreenChart = null; //关联全屏以后的图表

    this.setOptions(option); // @Cmen：CHART-1130: 开启自适应插件时，resize的时候，会移除旧的dom，并生成新dom用于initChart
    // 而这时如果resize的频率比较高，就导致前面的initialize的dom已经不存在了，同样的resize方法也存在这个问题

    if (!this._checkValidSize()) {
      return;
    } // MOBILE-21081
    // constructor _checkValidSize return 跳过初始步骤导致refresh失败
    // 考虑总要size valid才行，在resize里面判断初始化
    // 总在崩溃的边缘……


    this._init();
  },
  _init: function () {
    if (this.__inited) {
      return;
    }

    this.__inited = true;
    var dom = this.wrapDom;

    if (true) {
      // ---------------------------------- 10.0 mobile magic...
      if (this.isMobile()) {
        if (this.isMobileFlow()) {
          this.handler = new _MobileHandler["default"](this, dom);
          this.showTooltip = this.showTooltipMobileFlow;
        } else {
          this.handler = new _HammerHandler["default"](this, dom); // legacy mobile tooltip

          this.showTooltip = this.showTooltipMobile;
        }
      } else {
        this.handler = new _HammerHandler["default"](this, dom);
      } // ----------------------------------------------------

    }

    this._initDomLayout(this.wrapDom);

    this.update();
  },
  setOptions: function (option) {
    _localeText["default"].setLocale(option.language); // add and adjust components for mobile flow


    if (this.isMobileFlow()) {
      this._mutateOptions(option);
    }

    option.series = option.series || []; //保证series不为空

    option.series.forEach(function (sery) {
      sery.data = sery.data || [];
    }); //坐标轴可能是数组

    this._mergeThemeConfig(option);

    var plotOptions = option.plotOptions;

    if (plotOptions.inverted && option.dataSheet) {
      option.dataSheet.enabled = false;
    }

    this.options = option; // 当前图表不是组合图，且设置了大数据模式，所有系列的动画都取消掉

    this.isLargeMode() && _Constants["default"].LARGE_CHART_TYPE[this.chartType()] && (plotOptions.animation = false); // CHART-1378
    // 组合图中任意一个子图表设置大数据模式并且该子图表类型也支持大数据模式的情况下，
    // 将图表的初始动画去掉，如果原本animation设置的就是false，那就不要执行了，节省点儿时间。

    if (plotOptions.animation && this.chartType() === _Constants["default"].MULTI_CHARTS) {
      Object.keys(_Constants["default"].LARGE_CHART_TYPE).forEach(function (type) {
        if (plotOptions[type] && plotOptions[type].large) {
          plotOptions.animation = false;
        }
      });
    }

    if (this.fullScreenChart) {
      this.fullScreenChart.setData(option);
    }
  },
  _initDomLayout: function (dom) {
    this.dom = dom;
    this.renderer = (0, _renderer["default"])(dom, this);
    this.renderer.onAdd();
    this.on({
      'animationStart': this._animationStart,
      'animationEnd': this._animationEnd
    });
  },
  _animationStart: function () {
    // console.log('series ani start, count reset to 0');
    //锁住fire的'animationEnd'
    this._animationStarted = true;
    this.animationCount = 0;
    this.removeMoreLabel();
    this.series.forEach(function (ser) {
      ser._removeDataLabels();

      ser.render();
    });

    if (!this.animationCount) {
      this.fire('animationEnd');
    }

    if (false) {}
  },

  /**
   * 当前图表是否正在执行系列渲染操作
   * @returns {boolean}
   */
  onSeriesRendering: function () {
    return this._animationStarted;
  },

  /**
   * 移除所有的MoreLabel
   * @return {[type]} [description]
   */
  removeMoreLabel: function () {
    var moreLabel = this.getComponent(_component.ComponentCst.MORELABEL_COMPONENT);
    moreLabel && moreLabel.removeAllMoreLabels();
  },
  _animationEnd: function () {
    if (!this.renderer) {
      return; //has been removed
    }

    this._animationStarted = false;
    this.series.forEach(function (ser) {
      ser._animateEnd();
    });
  },
  _removeChangeDataState: function (series) {
    if (this._changeDataState) {
      this._changeDataSeries = this._changeDataSeries || [];

      this._changeDataSeries.push(series);

      if (this._changeDataSeries.length >= this.series.length) {
        // 所有系列的动画完成,changeData的状态给改回来
        this._changeDataState = false;
        this._changeDataSeries = [];
      }
    }
  },
  _needShowMoreLabel: function () {
    var moreLabel = this.options.moreLabel;
    return this._changeDataState && moreLabel && moreLabel.enabled && !this.isLargeMode();
  },
  _clearMoreLabels: function () {
    this.series.forEach(function (ser) {
      ser._clearMoreLabels();
    });
  },
  _initIntermediateState: function () {
    this.colorMap = {};
    this.orderMap = {};
    this.cateMap = {};
    this.scale = 1;
    this.timeQueue = this.clearTimeQueue();
    this.clipPool = {};
    this.axisSize = {
      'left': 0,
      'right': 0,
      'bottom': 0,
      'top': 0
    };
    this.layerMap = this.layerIndex = null;
    this.__contentBoundsInited = false;
  },
  // 外部调用接口，传入新的配置
  refresh: function (options) {
    if ((0, _util.isAutoRefreshChart)(options)) {
      this.autoRefresh(options);
    } else {
      this.setOptions(options);

      if (!this._checkValidSize()) {
        return;
      }

      this.update();
    }
  },
  // 刷新按钮在两个情况下会出现,1.排序以后 2.坐标轴缩放的时候
  // 所以刷新要做的是两件事,1.重新按照原来的顺序排布 2.使所有系列可见,并且刷新坐标轴
  refreshRestore: function () {
    var vanchart = this,
        components = vanchart.components;
    INTERACTIVE_COMPONENTS.forEach(function (cName) {
      components[cName] && vanchart._restoreCategoryAxisBasedSeries(components[cName]);
    }); //仪表盘恢复

    var gaugeSeries = this.seriesOfType(_Constants["default"].GAUGE_CHART);

    if (gaugeSeries.length == this.series.length) {
      this.series.sort(function (a, b) {
        return a.index - b.index;
      });
    } //饼图的排序恢复


    this.seriesOfType(_Constants["default"].PIE_CHART).forEach(function (sery) {
      var map = sery.points.map(function (point) {
        return point.graphic;
      });
      var orderMap = {};
      sery.options.data.forEach(function (datum, i) {
        orderMap[datum.x] = i;
      });
      sery.points.sort(function (sliceA, sliceB) {
        return orderMap[sliceA.x] - orderMap[sliceB.x];
      });
      sery.points.forEach(function (point, index) {
        point.graphic = map[index];
      });
    }); //多层饼图恢复

    var multipie = this.seriesOfType(_Constants["default"].MULTIPIE_CHART);

    if (multipie.length) {
      multipie[0].orderData(null);
    } //理论上来讲不用全部属性都刷新一遍，但是涉及到图例的交互，分别刷新就比较复杂
    //先保证效果对


    this.update();
  },
  //实现的思路应该是point的graphic的排序,而不应该去刷新属性
  orderData: function () {
    var vanchart = this,
        components = vanchart.components;

    if (vanchart.chartType() === _Constants["default"].BOX_CHART) {
      return;
    }

    INTERACTIVE_COMPONENTS.forEach(function (cName) {
      components[cName] && vanchart._orderCategoryAxisBasedSeries(components[cName]);
    });
    var increaseOrder = this.orderType == _Constants["default"].ASCENDING;
    var para = increaseOrder ? 1 : -1; //仪表盘排序

    var gaugeSeries = this.seriesOfType(_Constants["default"].GAUGE_CHART);

    if (gaugeSeries.length == this.series.length) {
      this.series.sort(function (serA, serB) {
        var totalA = serA.getSeryTotalValue();
        var totalB = serB.getSeryTotalValue();
        return (totalA - totalB) * para;
      });
    } //饼图的排序


    this.seriesOfType(_Constants["default"].PIE_CHART).forEach(function (sery) {
      var map = sery.points.filter(function (point) {
        return point.visible;
      }).map(function (point) {
        return point.graphic;
      });
      sery.points.sort(function (sliceA, sliceB) {
        return increaseOrder ? sliceA.y - sliceB.y : sliceB.y - sliceA.y;
      });
      var index = 0;
      sery.points.forEach(function (point) {
        if (point.visible) {
          point.graphic = map[index];
          ++index;
        }
      });
    }); //多层饼图排序

    var multipie = this.seriesOfType(_Constants["default"].MULTIPIE_CHART);

    if (multipie && multipie.length) {
      multipie[0].orderData(increaseOrder);
    }

    this.reRenderSeries(); //这里的顺序不能换，zoom那边用了_sortedPoints

    INTERACTIVE_COMPONENTS.concat([_component.ComponentCst.ZOOM_COMPONENT, _component.ComponentCst.DATA_SHEET_COMPONENT, _component.ComponentCst.POLAR_COMPONENT]).forEach(function (cName) {
      components[cName] && components[cName].render();
    });
  },

  /**
   * 分类轴刷新
   * @param  {[type]} axisComponent [description]
   * @return {[type]}               [description]
   */
  _restoreCategoryAxisBasedSeries: function (axisComponent) {
    for (var axisIndex = 0, count = axisComponent.getAxisCount(); axisIndex < count; axisIndex++) {
      var axis = axisComponent.getAxis(axisIndex),
          series = axis.series; //缩放之后刷新，没有orderMap

      if (axis._isBaseAxis() && axis.isCategory() && this.orderMap && Object.keys(this.orderMap).length) {
        var order = this.orderMap[axis.componentType][axisIndex];
        var keyIndexMap = {};
        order.forEach(function (p, i) {
          keyIndexMap[p] = i;
        });
        var lastOrder = axis._dataDomain;

        for (var i = 0, len = series.length; i < len; i++) {
          var lastOrderMap = [],
              sery = series[i],
              normalData = true;
          sery.points.forEach(function (point) {
            lastOrderMap[_BaseUtils["default"].indexOf(lastOrder, point.getCategory())] = point.graphic;

            if (!point.graphic) {
              normalData = false;
            }
          });
          sery.points.forEach(function (point) {
            point.graphic = normalData ? lastOrderMap[keyIndexMap[point.getCategory()]] : point.graphic; //折线图,雷达图，排序以后，图片标记点和形状的标记点不能兼容

            sery.updatePointGraphic(point);
          });
        }
      }
    }
  },

  /**
   * 分类轴排序
   * @param  {[type]} axisComponent [description]
   * @return {[type]}               [description]
   */
  _orderCategoryAxisBasedSeries: function (axisComponent) {
    var para = this.orderType == _Constants["default"].ASCENDING ? 1 : -1;

    for (var axisIndex = 0, count = axisComponent.getAxisCount(); axisIndex < count; axisIndex++) {
      //普通的单层轴排序
      var sortNormalCategoryAxis = function () {
        for (var i = 0, len = points.length; i < len; i++) {
          var point = points[i];
          var total = 0;
          point.points.forEach(function (point) {
            if (point.visible && point.series.visible) {
              total += point.getTargetValue();
            }
          });
          valueMap.push({
            key: point.category,
            value: total
          });
        }

        valueMap.sort(function (a, b) {
          return (a.value - b.value) * para;
        });
        valueMap.forEach(function (p, i) {
          keyIndexMap[p.key] = i;
          newCategories.push(p.key);
        });
      }; // 多分类轴排序，保证倒数第二层分类顺序不变，对倒数第一层进行排序


      var sortMultiCategoryAxis = function () {
        var valueArr = [];

        for (var i = -1; ++i < points.length;) {
          var point = points[i];
          var total = 0;
          point.points.forEach(function (p) {
            if (p.visible && p.series.visible) {
              total += p.getTargetValue();
            }
          });

          var categoryArray = point.options.categoryArray,
              keyString = _BaseUtils["default"].encodeCategoryArray(categoryArray.slice(0, categoryArray.length - 1)),
              cateString = _BaseUtils["default"].encodeCategoryArray(categoryArray);

          var datum = {
            key: keyString,
            cate: cateString,
            value: total
          };

          if (valueMap[keyString] == null) {
            valueMap[keyString] = valueArr.push([datum]) - 1;
          } else {
            valueArr[valueMap[keyString]].push(datum);
          }
        }

        valueArr.forEach(function (cateArr) {
          cateArr.sort(function (a, b) {
            return (a.value - b.value) * para;
          });
        });
        var keyIndex = 0;
        valueArr.forEach(function (cateArr) {
          cateArr.forEach(function (cate) {
            keyIndexMap[cate.cate] = keyIndex;
            newCategories.push(cate.cate);
            keyIndex++;
          });
        });
      };

      var axis = axisComponent.getAxis(axisIndex);
      this.orderMap[axis.componentType] = this.orderMap[axis.componentType] || [];

      if (!this.orderMap[axis.componentType][axisIndex]) {
        this.orderMap[axis.componentType][axisIndex] = axis._dataDomain;
      }

      var series,
          valueMap = [],
          points,
          keyIndexMap = {},
          newCategories = [];

      if (axis._isBaseAxis() && axis.isCategory()) {
        series = axis.series;
        points = series[0].points;
        var isMultiCateAxis = axis.isMultiCateAxis && axis.isMultiCateAxis();
        isMultiCateAxis ? sortMultiCategoryAxis() : sortNormalCategoryAxis();
        var lastOrder = axis.getOriginalCategories();

        for (var i = 0, len = series.length; i < len; i++) {
          var lastOrderMap = [],
              sery = series[i],
              normalData = true;
          sery.points.forEach(function (point) {
            lastOrderMap[_BaseUtils["default"].indexOf(lastOrder, point.getCategory())] = point.graphic;

            if (!point.graphic) {
              normalData = false;
            }
          });
          sery.points.forEach(function (point) {
            point.graphic = normalData ? lastOrderMap[keyIndexMap[point.getCategory()]] : point.graphic; //折线图,雷达图，排序以后，图片标记点和形状的标记点不能兼容

            sery.updatePointGraphic(point);
          });
        }

        axis.setCategories(newCategories); // 排序完成后更新坐标轴的domain
      }
    }
  },

  /**
   * 添加新系列
   * @param options
   */
  addSeries: function (serData) {
    // todo 某些情况下，肯定需要判断添加到中间的位置
    // 对于新增的Seres，还需要将其默认的PlotOptions与vanchart.options.plotOptions合并一下
    var type = serData.type,
        option = this.options;
    var config = (0, _config["default"])();
    var defaultPlotOptions = config[type].plotOptions;

    _QueryUtils["default"].merge(option, config[type].options, false);

    if (option.plotOptions[type]) {
      option.plotOptions[type] = _QueryUtils["default"].merge(option.plotOptions[type], defaultPlotOptions, false);
    } else {
      option.plotOptions = _QueryUtils["default"].merge(option.plotOptions, defaultPlotOptions, false);
    }

    option.series.push(serData);
  },
  _checkValidSize: function () {
    return this.width && this.height;
  },
  // /**
  //  * 监控刷新返回的变化数据处理：
  //  * 针对add, update, delete三个操作分别处理， 其中：
  //  *     1. add操作要分为vanChart.addSeries和series.addPoint
  //  *     2. delete和update，要先计算出其对应的索引，然后根据索引更新
  //  * @param  {[type]} options [变化的数据] example:{add:{...}, update:{...}, delete:{...}}
  //  * @return {[type]}         [description]
  //  */
  autoRefresh: function (options) {
    // add and adjust components for mobile flow
    if (this.isMobileFlow()) {
      this._mutateOptions(options);
    }

    var result = (0, _VanRefresh["default"])(this.options, options); // resize + autoRefresh REPORT-12107

    if (!this._checkValidSize()) {
      return;
    }

    var addData = result.add || [],
        removeData = result.remove || [],
        updateData = result.update || [],
        additionalOption = result.option || {};
    var vanchart = this,
        option = vanchart.options,
        chartType = option.chartType;

    if (removeData.length === 0 && addData.length === 0 && updateData.length === 0) {
      this._changeDataState = false;
      return;
    } //未发生数据变化时，不重绘


    this._addData = addData;
    this._removeData = removeData;
    this._updateData = updateData;
    var seriesMap = {};
    this.series.forEach(function (ser) {
      var key = vanchart._createSeriesKey(chartType, ser.options);

      var sameNameArray = seriesMap[key];

      if (sameNameArray) {
        sameNameArray.push(ser);
      } else {
        sameNameArray = [ser];
        seriesMap[key] = sameNameArray;
      }
    }); // 移除数据

    removeData.forEach(function (serData, index) {
      var key = vanchart._createSeriesKey(chartType, serData, index);

      var sameNameArray = seriesMap[key];
      var ser = sameNameArray && sameNameArray.length ? sameNameArray[0] : null;

      if (ser) {
        if (serData.data) {
          serData.data.forEach(function (datum) {
            var pos = ser.calculatePointIndex(datum);
            (0, _CoreUtils.hasDefined)(pos) && ser.removePoint(pos, false);
          });
        } // 当已有系列的data的length为0时，series已移除，对应的sameNameArray也减1
        // 改正：data的length为0，且没有新增的，才删除。


        if (vanchart._removeAllAndHasNoAdd(ser.options, index)) {
          sameNameArray && sameNameArray.splice(0, 1);
        }
      }
    }); // 新增数据

    addData.forEach(function (serData, index) {
      var key = vanchart._createSeriesKey(chartType, serData, index);

      var sameNameArray = seriesMap[key];
      var ser = sameNameArray && sameNameArray.length ? sameNameArray[0] : null;

      if (ser) {
        serData.data.forEach(function (datum) {
          ser.addPoint(datum);
        });
      } else {
        vanchart.addSeries(serData);
      }
    }); // 更新数据

    updateData.forEach(function (serData, index) {
      var key = vanchart._createSeriesKey(chartType, serData, index);

      var sameNameArray = seriesMap[key];
      var ser = sameNameArray && sameNameArray.length ? sameNameArray[0] : null;

      if (ser) {
        ser.updateSeries(serData);
        serData.data.forEach(function (datum) {
          var pos = ser.calculatePointIndex(datum);
          (0, _CoreUtils.hasDefined)(pos) && ser.updatePoint(pos, datum, false);
        });
      }
    });
    var changeSeriesKeyOrder = result.changeSeriesKeyOrder || [];

    if (changeSeriesKeyOrder.length > 0) {
      //大于0代表系列顺序变了
      option.series.sort(function (ser1, ser2) {
        return _BaseUtils["default"].indexOf(changeSeriesKeyOrder, vanchart._createSeriesKey(chartType, ser1)) - _BaseUtils["default"].indexOf(changeSeriesKeyOrder, vanchart._createSeriesKey(chartType, ser2));
      });
    }

    var changeCategoryKeyOrder = result.changeCategoryKeyOrder || [];
    option.series.forEach(function (ser, i) {
      var type = ser.type || chartType; //适配改变后的系列顺序

      var serCateKeyOrder = changeCategoryKeyOrder[i] || [];
      var originalData = ser.data || [];

      if (serCateKeyOrder.length > 0) {
        //大于0代表分类顺序变了
        originalData.sort(function (p1, p2) {
          return _BaseUtils["default"].indexOf(serCateKeyOrder, vanchart._createPointKey(p1, type)) - _BaseUtils["default"].indexOf(serCateKeyOrder, vanchart._createPointKey(p2, type));
        });
      }
    }); // 监控刷新中，标题等数据可以会发生更新

    _QueryUtils["default"].merge(this.options, additionalOption, true); // CHART-16138 仪表盘刷新目标值


    if (this.isGauge()) {
      this._dealGaugeAxisOpt(options);

      this.options.gaugeAxis = options.gaugeAxis;
    }

    if (this.isMap()) {
      this.options.xAxis = this.options.yAxis = this.options.zoom = undefined;
    } // 变化的数据更新到options之后，update统一刷新图表


    this.autoRefreshRender();

    if (this.fullScreenChart) {
      // @CHART-9165  fullScreenChart has only one chart
      this.fullScreenChart.charts[0].autoRefreshRender();
    }

    this.fire(_Constants["default"].AUTO_REFRESH);
  },
  //该系列的数据都被删除，且没有添加，则删除。
  //CHART-4081 整个系列的值被删掉 且有添加 系列顺序不应该改变。如果这边被删除了，再新建，这个系列就在最后了，顺序就改变了。
  _removeAllAndHasNoAdd: function (serData, index) {
    if (serData.data.length === 0) {
      //全被删掉再看看有没有加的
      var vanchart = this,
          option = vanchart.options,
          chartType = option.chartType;

      var serKey = vanchart._createSeriesKey(chartType, serData, index);

      var addData = vanchart._addData;

      for (var i = 0, len = addData.length; i < len; i++) {
        var addSerData = addData[i],
            addSerKey = vanchart._createSeriesKey(chartType, addSerData, i);

        if (addSerKey === serKey) {
          //有加的
          return false;
        }
      }

      return true; //没有加的
    }

    return false; //没有全部删掉
  },
  // 创建独有的series的key
  _createSeriesKey: function (chartType, serData, index) {
    var type = serData.type || chartType;
    var option = this.options;

    var seriesName = _BaseUtils["default"].pick(serData.name, 'Series' + index);

    var key = seriesName + type;

    if (type === _Constants["default"].GAUGE_CHART) {
      var style = serData.style || option.plotOptions.style;
      var layout = serData.thermometerLayout || option.plotOptions.thermometerLayout || '';
      key = seriesName + type + style + layout;
    } else if (type === _Constants["default"].RADAR_CHART) {
      var columnType = serData.columnType || option.plotOptions.columnType;
      columnType = columnType ? _Constants["default"].COLUMN_RADAR : _Constants["default"].LINE_RADAR;
      key = seriesName + columnType;
    } else if (type === _Constants["default"].PIE_CHART) {
      var roseType = serData.roseType || option.plotOptions.roseType || '';
      key = seriesName + roseType;
    }

    return key;
  },
  // 创建独有的point的key
  _createPointKey: function (pointData, type) {
    var key = pointData.categoryArray ? pointData.x + "-" + _BaseUtils["default"].encodeCategoryArray(pointData.categoryArray) : pointData.x;

    switch (type) {
      case _Constants["default"].BAR_CHART:
        key = pointData.categoryArray ? pointData.y + "-" + _BaseUtils["default"].encodeCategoryArray(pointData.categoryArray) : pointData.y;
        break;

      case _Constants["default"].WORD_CLOUD_CHART:
      case _Constants["default"].FUNNEL_CHART:
        key = pointData.name;
        break;

      case _Constants["default"].SCATTER_CHART:
      case _Constants["default"].BUBBLE_CHART:
        key = pointData.x + "-" + pointData.y;
        break;

      case _Constants["default"].AREA_MAP:
      case _Constants["default"].POINT_MAP:
      case _Constants["default"].HEAT_MAP:
        key = pointData.lnglat ? pointData.name + "-" + _BaseUtils["default"].encodeCategoryArray(pointData.lnglat) : pointData.name;
        break;

      case _Constants["default"].LINE_MAP:
        break;
    }

    return key;
  },

  /**
   * 监控刷新视图更新，为什么这么写：
   * 当chart和fullScreenChart关联起来之后，二者共用一个options，因此数据处理只需要在chart的autoRefresh里面进行
   * 而渲染则需要分开来，由于MoreLabel的渲染需要一些判断因此把这部分拿出来
   * @return {[type]} [description]
   */
  autoRefreshRender: function () {
    // 这里需要手动把这个属性设置成true
    if (this._changeDataState) {
      this._changeDataSeries = []; //对于刷新间隔小于或等于持续时间的值变化提示,再次刷新的时候,需要手动把_changeDataSeries置空
    }

    this._changeDataState = true;
    this.update();
  },
  //图表整个的属性有改变的时候,至上而下的刷新所有组件.图表的属性.
  update: function () {
    this.fire('update');

    this._initIntermediateState();

    var option = this.options,
        vanchart = this,
        seriesData = option.series,
        chartType = option.chartType;
    var name, Class; //构建坐标轴,范围图例等组件

    var Components = (0, _component.getComponents)();

    for (var index = 0, cCount = _component.ComponentsOrder.length; index < cCount; index++) {
      name = _component.ComponentsOrder[index];
      Class = Components[name];

      if (name == _component.ComponentCst.RANGE_LEGEND_COMPONENT && option[name]) {
        var rangeType = option[name].continuous ? _component.ComponentCst.GradientRangeLegend : _component.ComponentCst.INTERVAL_RANGE_LEGEND;

        if (this.components[name] && this.components[name].type != rangeType) {
          this.components[name].remove();
          this.components[name] = null;
        }

        Class = (0, _component.getComponent)(rangeType);
      }

      if (Class) {
        var enabled = option[name] && ((0, _CoreUtils.hasNotDefined)(option[name].enabled) || option[name].enabled);

        if (!enabled && name == _component.ComponentCst.TOOLBAR_COMPONENT && !false) {
          enabled = true;
          option[name] = {
            'enabled': true,
            'hidden': false
          };
        }

        if (option[name] && enabled) {
          if (this.components[name]) {
            this.components[name].refresh(option[name], vanchart);
          } else {
            this.components[name] = new Class(option[name], name, vanchart);
          }
        } else if (this.components[name]) {
          this.components[name].remove();
          this.components[name] = null;
          delete this.components[name];
        }
      }
    }

    var seriesMap = {},
        type,
        series = [];
    vanchart.series.forEach(function (ser) {
      type = ser.type;

      if (type == _Constants["default"].GAUGE_CHART) {
        type += ser.gaugeType + (ser.options.thermometerLayout || '');
      }

      if (type == _Constants["default"].RADAR_CHART) {
        type = ser.columnType ? _Constants["default"].COLUMN_RADAR : _Constants["default"].LINE_RADAR;
      }

      var sameNameArray = seriesMap[ser.name + type];

      if (sameNameArray) {
        sameNameArray.push(ser);
      } else {
        sameNameArray = [ser];
        seriesMap[ser.name + type] = sameNameArray;
      }
    });
    seriesData.forEach(function (serData, index) {
      // @Cmen 这里注明为什么使用克隆的SerData， 之前直接使用serData的时候，refresh的时候，会对series.option和point.option进行扩展，
      // 这些扩展就会被映射到初始的SerData上面， 而在数据更新的时候，第二次refreshOption的时候，处理一些诸如markerColor的属性的时候，
      // 则不好判断该属性是后期扩展的还是在最开始的数据里就有的，因此就导致了某些属性无法更新
      // 理论上，绘图的时候，不应该修改原始的series数据，因此这里使用serData的拷贝，而更新数据则是基于原始的series.data进行的
      serData = _BaseUtils["default"].clone(serData);
      type = serData.type || chartType;

      var seriesName = _BaseUtils["default"].pick(serData.name, 'Series' + index);

      var Class = (0, _chart["default"])(type),
          key = seriesName + type;

      if (type == _Constants["default"].GAUGE_CHART) {
        var style = serData.style || option.plotOptions.style;
        var layout = serData.thermometerLayout || option.plotOptions.thermometerLayout || '';
        Class = (0, _chart["default"])(style);
        key = seriesName + type + style + layout;
      } else if (type == _Constants["default"].RADAR_CHART) {
        var columnType = serData.columnType || option.plotOptions.columnType;
        columnType = columnType ? _Constants["default"].COLUMN_RADAR : _Constants["default"].LINE_RADAR;
        Class = (0, _chart["default"])(columnType);
        key = seriesName + columnType;
      }

      var sameNameArray = seriesMap[key];
      var ser = sameNameArray && sameNameArray.length ? sameNameArray[0] : null;
      ser = ser ? ser.refresh(serData, index) : new Class(serData, vanchart, index);
      series.push(ser);
      sameNameArray && sameNameArray.splice(0, 1);
    });

    for (var serKey in seriesMap) {
      var sameNameArray = seriesMap[serKey];
      sameNameArray && sameNameArray.forEach(function (ser) {
        ser && ser.remove();
      });
    }

    vanchart.series = series;
    var gaugeAxis = this.components[_component.ComponentCst.GAUGE_AXIS_COMPONENT];

    if (gaugeAxis) {
      gaugeAxis.initAttributesWithSeries();
    }

    var rangeLegend = this.components[_component.ComponentCst.RANGE_LEGEND_COMPONENT];

    if (rangeLegend) {
      rangeLegend.initAttributesWithSeries();
    }

    series.forEach(function (ser) {
      // try in large mode
      if (ser.type === _Constants["default"].LINE_MAP && ser.options.large) {
        return;
      }

      for (var i = 0, len = ser.points.length; i < len; i++) {
        ser.points[i].refreshPointColor();
      }
    });
    vanchart.layoutComponentsAndCharts(); // doc flow: may have to show cross line

    if (this.isMobileFlow()) {
      this.checkCrossLineFlag();
    }
  },
  layoutComponentsAndCharts: function () {
    //计算百分比和标签，百分比会因为系列是否可见而每次都变化，从而导致标签的变化
    //还有像气泡图的半径也能在具体布局之前就推算出来
    this.hoverPoint = this.hoverSeries = null;

    _VanChartLayout["default"].PLANE_SYSTEM_LAYOUT(this);

    this.render();
  },
  //考虑padding的影响
  _getDefaultBounds: function () {
    // CHART-1452
    // 简单点儿，只要是矩形树图，如果用户没有主动设置padding，
    // 就让矩形树图占满图表区，甭管它有没有标题和图例。
    var padding = this.options && this.options.padding || this.chartType() === _Constants["default"].TREEMAP_CHART ? 0 : PADDING_FUN();
    var borderWidth = this.options && this.options.borderWidth || 0;
    padding = borderWidth + padding;
    return _BaseUtils["default"].makeBounds(padding, padding, Math.max(this.width - 2 * padding, 0), Math.max(this.height - 2 * padding, 0));
  },
  reRenderWholePlot: function () {
    _VanChartLayout["default"].reLayoutPlotBounds(this);

    _VanChartLayout["default"].calculateSeries(this);

    _VanChartLayout["default"].calculateSeriesShapes(this);

    this.render();
  },
  dealAxisZoom: function (downPos, upPos) {
    var zoomType = this.options.zoom.zoomType,
        xAxis = this.components.xAxis,
        yAxis = this.components.yAxis;

    if (xAxis && zoomType.indexOf('x') !== -1) {
      xAxis.axisZoom(downPos, upPos);
    }

    if (yAxis && zoomType.indexOf('y') !== -1) {
      yAxis.axisZoom(downPos, upPos);
    }

    this.reRenderWholePlot();
  },

  /**
   * 当图表开启缩放且缩放方向仅限于基础轴上时：
   * 重新计算值轴的值域，这里有效的数据点应该为在基础轴domain内的点
   * @param baseAxisType
   */
  reCalcValueAxisDataDomain: function (baseAxisType) {
    var valueAxisType = baseAxisType === _component.ComponentCst.X_AXIS_COMPONENT ? _component.ComponentCst.Y_AXIS_COMPONENT : _component.ComponentCst.X_AXIS_COMPONENT;
    var valueAxisGroup = this.components[valueAxisType]._axisList;

    for (var i = -1; ++i < valueAxisGroup.length;) {
      valueAxisGroup[i].calculateDomainFromData(undefined, true);
    }
  },
  //缩放等交互，闪烁动画中断
  clearAllEffects: function () {
    this.series.forEach(function (ser) {
      ser.points.forEach(function (point) {
        ser.clearPointEffect(point);
      });
    });
  },
  drawAllEffects: function () {
    this.series.forEach(function (ser) {
      ser._drawEffectPoints();
    });
  },
  _calculateZoomParas: function (downPos, upPos) {
    var plotBounds = this.bounds;
    var minX = Math.min(downPos.x, upPos.x) - plotBounds.x;
    var minY = Math.min(downPos.y, upPos.y) - plotBounds.y;
    var detX = Math.abs(downPos.x - upPos.x);
    var detY = Math.abs(downPos.y - upPos.y);
    var scale = Math.min(plotBounds.width / detX, plotBounds.height / detY);
    var wWidth = plotBounds.width / scale;
    var wHeight = plotBounds.height / scale;
    var shiftX = (plotBounds.width - wWidth) / 2 - minX;
    var shiftY = (plotBounds.height - wHeight) / 2 - minY;
    return {
      bounds: plotBounds,
      shiftX: shiftX,
      shiftY: shiftY,
      scale: scale
    };
  },
  _dealGaugeAxisOpt: function (option) {
    if (option.chartType === _Constants["default"].GAUGE_CHART) {
      return this._expandGaugeAxisOpt(option);
    }

    var axisOptions = [];
    var series = option.series,
        originAxisOpt = option.gaugeAxis;

    for (var i = 0; i < series.length; i++) {
      var ser = series[i];

      if (ser.type !== _Constants["default"].GAUGE_CHART) {
        continue;
      }

      var axisIndex = ser.gaugeAxis;
      var axisOption = _BaseUtils["default"].isArray(originAxisOpt) ? _extends({}, originAxisOpt[axisIndex]) : _extends({}, originAxisOpt);

      if (ser.style.indexOf('pointer') !== -1) {
        axisOptions[axisIndex] = axisOption;
        continue;
      }

      var target = ser.data[0].target;

      if ((0, _CoreUtils.hasDefined)(target) && target !== '-') {
        axisOption.max = +target;
      }

      axisOptions[axisIndex] = axisOption;
    }

    option.gaugeAxis = axisOptions;
  },
  // 处理非组合图的仪表盘的option
  _expandGaugeAxisOpt: function (option) {
    var series = option.series,
        originAxisOpt = option.gaugeAxis;
    var axisOptions = [];

    if (option.plotOptions.style.indexOf('pointer') !== -1) {
      return;
    }

    series.forEach(function (ser, index) {
      var target = ser.data[0].target;
      var axisOption = _BaseUtils["default"].isArray(originAxisOpt) ? _extends({}, originAxisOpt[0]) : _extends({}, originAxisOpt);

      if ((0, _CoreUtils.hasDefined)(target) && target !== '-') {
        axisOption.max = +target;
      }

      ser.gaugeAxis = index;
      axisOptions.push(axisOption);
    });
    option.gaugeAxis = axisOptions;
  },
  //默认配置，主题配置的组合
  _mergeThemeConfig: function (option) {
    var config = (0, _config["default"])();
    var merged = {},
        vanchart = this;
    option.series.forEach(function (ser) {
      var type = ser.type || option.chartType;
      var defaultPlotOptions = config[type].plotOptions;

      if (type == _Constants["default"].GAUGE_CHART) {
        var style = ser.style || option.plotOptions.gauge && option.plotOptions.gauge.style || option.plotOptions.style;
        style = style == 'pointer_semi' ? 'pointer' : style;
        defaultPlotOptions = config.gauge[style];
        var gaugeLabelKey = ['seriesLabel', 'valueLabel', 'percentageLabel'];
        gaugeLabelKey.forEach(function (key) {
          if ((0, _CoreUtils.hasDefined)(ser[key])) {
            _QueryUtils["default"].merge(ser[key], defaultPlotOptions[key], false);
          }
        });
      }

      if (!merged[type]) {
        merged[type] = true;

        _QueryUtils["default"].merge(option, config[type].options, false);

        if (option.plotOptions[type]) {
          option.plotOptions[type] = _QueryUtils["default"].merge(option.plotOptions[type], defaultPlotOptions, false);
        } else {
          option.plotOptions = _QueryUtils["default"].merge(option.plotOptions, defaultPlotOptions, false);
        }
      }
    });

    if (option.gaugeAxis) {
      this._dealGaugeAxisOpt(option);
    }

    if (this.isMap()) {
      option.xAxis = option.yAxis = option.zoom = undefined;

      _BaseUtils["default"].extend(option, config.MAP_CONFIG);
    }

    if (option.chartType == _Constants["default"].RADAR_CHART) {
      option.polar = option.polar || {};
    }

    option.tooltip = option.tooltip || {};

    if (option.colors && option.colors.length == 0) {
      option.colors = (0, _config.DEFAULT_COLORS)();
    }
  },
  getChartMinMaxValue: function () {
    var min = Number.MAX_VALUE,
        max = -min;
    var allPoints = [];
    this.series.forEach(function (ser) {
      return allPoints = allPoints.concat(ser.points);
    });
    var hasMap = this.isMap();
    var points = hasMap ? (0, _validMapPoints.mapPointsWithRangeLegend)(this.getCurrentGeo(), this.series) : allPoints;
    points.filter(function (point) {
      var filterNegative = (point.series.type === _Constants["default"].BUBBLE_CHART || point.series.type === _Constants["default"].FORCE_BUBBLE_CHART) && !point.series.options.displayNegative;
      var value = point.getTargetValue();
      return !point.isNull && !isNaN(value) && !(filterNegative && value < 0);
    }).forEach(function (point) {
      var value = point.getTargetValue();
      max = Math.max(max, value);
      min = Math.min(min, value);
    });

    if (min > max) {
      min = 0;
      max = 100;
    }

    return [min, max];
  },
  getParentDom: function () {
    return this.dom;
  },
  getDivParentDom: function () {
    return this.wrapDom;
  },
  isInverted: function () {
    return !!this.options.plotOptions.inverted;
  },
  setPlotBounds: function (newBounds) {
    this.bounds = newBounds;
  },
  getPlotClipBounds: function () {
    var x = 0,
        y = 0,
        width = this.bounds.width,
        height = this.bounds.height;
    var locationMap = {},
        all = [],
        padding = 0;

    if (this.components.xAxis) {
      all = all.concat(this.components.xAxis._axisList);
    }

    if (this.components.yAxis) {
      all = all.concat(this.components.yAxis._axisList);
    }

    all.forEach(function (axis) {
      var position = axis.getPosition();

      if (axis.isPlotRangeWithMarker()) {
        padding = axis.getPlotRangePadding();
      }

      if (!axis.isOnZero() && !locationMap[position]) {
        locationMap[position] = axis.getLineWidth();
      }
    });
    y = locationMap[_Constants["default"].TOP] ? Math.ceil(locationMap[_Constants["default"].TOP] / 2) : 0;
    height -= y;
    height = locationMap[_Constants["default"].BOTTOM] ? height - Math.ceil(locationMap[_Constants["default"].BOTTOM] / 2 - 0.5) : height;
    x = locationMap[_Constants["default"].LEFT] ? Math.ceil(locationMap[_Constants["default"].LEFT] / 2) : 0;
    width -= x;
    width = locationMap[_Constants["default"].RIGHT] ? width - Math.ceil(locationMap[_Constants["default"].RIGHT] / 2) : width;

    if (this.isInverted()) {
      y -= padding;
      height += 2 * padding;
    } else {
      x -= padding;
      width += 2 * padding;
    } //加1的原因，最后一根网格线


    return {
      x: x + this.bounds.x,
      y: y + this.bounds.y,
      width: Math.max(width + 1, 0),
      height: Math.max(height + 1, 0)
    };
  },
  getChartBounds: function () {
    return _BaseUtils["default"].makeBounds(0, 0, this.width, this.height);
  },
  xAxis: function (axisIndex) {
    if (!axisIndex) {
      axisIndex = 0;
    }

    var axis = this.components.xAxis;
    return axis ? axis.getAxis(axisIndex) : null;
  },
  yAxis: function (axisIndex) {
    if (!axisIndex) {
      axisIndex = 0;
    }

    var axis = this.components.yAxis;
    return axis ? axis.getAxis(axisIndex) : null;
  },
  baseAxis: function () {
    return this.chartType() === _Constants["default"].BAR_CHART ? this.yAxis() : this.xAxis();
  },
  polar: function (axisIndex) {
    if (!axisIndex) {
      axisIndex = 0;
    }

    var axis = this.components.polar;
    return axis ? axis.getAxis(axisIndex) : null;
  },
  angleAxis: function (axisIndex) {
    if (!axisIndex) {
      axisIndex = 0;
    }

    var axis = this.components.angleAxis;
    return axis ? axis.getAxis(axisIndex) : null;
  },
  radiusAxis: function (axisIndex) {
    if (!axisIndex) {
      axisIndex = 0;
    }

    var axis = this.components.radiusAxis;
    return axis ? axis.getAxis(axisIndex) : null;
  },
  gaugeAxis: function (axisIndex) {
    if (!axisIndex) {
      axisIndex = 0;
    }

    var axis = this.components.gaugeAxis;
    return axis ? axis.getAxis(axisIndex) : null;
  },
  getSharedAxis: function () {
    var axes = [this.xAxis(), this.yAxis(), this.angleAxis()];

    for (var i = 0; i < axes.length; i++) {
      var axis = axes[i];

      if (axis && axis.isCategory()) {
        return axis;
      }
    }

    return null;
  },
  getComponent: function (type) {
    return this.components[type];
  },
  setComponent: function (component, type) {
    this.components[type] = component;
  },

  /**
   * return color of previous name
   * or set new color and return
   * @param {string} [name] series item (or pie point) name
   * @returns {*}
   */
  getDefaultSeriesColor: function (name) {
    name += '';

    if (!this.colorMap[name]) {
      var colors = this.options.colors;
      var length = 0;

      for (var item in this.colorMap) {
        ++length;
      } // return next color


      this.colorMap[name] = colors[length % colors.length];
    }

    return this.colorMap[name];
  },
  registerPointsPara: function (point) {
    if ((0, _CoreUtils.hasDefined)(point.category)) {
      var cateMap = this.cateMap;
      var cateString = point.getCategory();
      cateMap[cateString] = cateMap[cateString] || [];
      cateMap[cateString].push(point);
      return cateMap[cateString];
    }
  },
  getValidPointsPara: function (category) {
    var points = this.cateMap[category] || [];
    return points.filter(function (p) {
      return p.isVisible() && p.options.tooltip && p.options.tooltip.shared;
    });
  },
  getSharedPoints: function (category) {
    var points = this.cateMap[category] || [];

    if (points && points.length) {
      return points.filter(function (p) {
        return p.options.tooltip && p.options.tooltip.shared;
      });
    }

    return [];
  },
  showSharedTooltip: function (point, event) {
    if (!point) {
      return;
    }

    var vanchart = this,
        valid = vanchart.getValidPointsPara(point.getCategory());
    var max = valid.reduce(function (prev, curr) {
      if (!prev) {
        return curr;
      }

      return curr.getTargetValue() > prev.getTargetValue() ? curr : prev;
    }, 0); // CHART-823
    // get first point(include invisible) among shared points

    vanchart.showTooltip(max, event, vanchart.getSharedPoints(point.getCategory())[0]);
  },
  // set to default showTooltip or showTooltipMobile after loaded
  // 很混的tooltip...
  // 总之 pc = _showTooltip;
  // legacy mobile = showTooltipMobile;
  // 10.0 mobile flow = showTooltipMobileFlow;
  showTooltip: _BaseUtils["default"].emptyFn,
  _showTooltip: function (point, event, fmtPoint) {
    //缩放的时候不显示数据点提示
    if (this.handler.selectRect) {
      return;
    }

    var tooltip = this.components[_component.ComponentCst.TOOLTIP_COMPONENT];
    tooltip && tooltip.showWithPoint(point, event, fmtPoint);
  },
  // 移动端4s自动消失
  showTooltipMobile: function () {
    this._showTooltip.apply(this, arguments);

    var self = this;
    var ev = arguments[1];
    this.setTimeout('mobileTooltip', function () {
      self.handler.removeAllChosen(ev);
    }, MOBILE_HOVER_HIDE_DELAY);
  },
  // 10.0 mobile flow...
  showTooltipMobileFlow: function (point, event, fmtPoint) {
    var tooltip = this.components[_component.ComponentCst.TOOLTIP_COMPONENT];
    var text = tooltip && tooltip.getMobileTextArray(point, event, fmtPoint); // 移动端直接在point.onClick调用pointOptions.click，
    // 陈旧的逻辑很难修改了
    // 在这里存下要显示的文字，塞到pointOptions.click param里

    this.__tooltipText = text;
  },
  hideTooltip: function () {
    this.hoverPoint = null;
    var tooltip = this.components[_component.ComponentCst.TOOLTIP_COMPONENT];
    tooltip && tooltip.hide();
  },

  /**
   * 工具栏提示
   * @param  {Object} icon    计算tooltip位置时做参考的toolbarIcon
   * @param  {String} content 提示文字内容
   */
  showToolbarTooltip: function (icon, content) {
    var tooltip = this.components[_component.ComponentCst.TOOLTIP_COMPONENT];
    tooltip && tooltip.showWithToolbarIcon(icon, content);
  },
  // set this chart's state, like enable/disable dom event
  set: function (opt) {
    if ('enable' in opt && this.handler) {
      if (opt['enable']) {
        this.handler.hammer.set({
          enable: true
        });
      } else {
        this.handler.hammer.set({
          enable: false
        });
        this.handler.removeAllChosen({});
      }
    }
  },
  isGauge: function () {
    return this.options.chartType === _Constants["default"].GAUGE_CHART || this.options.chartType === _Constants["default"].MULTI_CHARTS && this.options.series.some(function (series) {
      return series.type === _Constants["default"].GAUGE_CHART;
    });
  },
  isMap: function () {
    return this.vanChartType == 'vanChartMap';
  },
  chartType: function () {
    return this.options.chartType;
  },
  //考虑到 散点地图 所以判断是否是点地图应该用chart.type 而不是 series.type
  isPointOrAreaOrHeatMap: function () {
    return this.options.chartType === _Constants["default"].AREA_MAP || this.options.chartType === _Constants["default"].POINT_MAP || this.options.chartType === _Constants["default"].HEAT_MAP;
  },
  isHeatMap: function () {
    return this.options.chartType == _Constants["default"].HEAT_MAP;
  },
  isAreaMap: function () {
    return this.options.chartType == _Constants["default"].AREA_MAP;
  },
  isForceBubble: function () {
    return this.vanChartType == 'vanChartForceBubble';
  },
  isLargeMode: function () {
    var isLarge = false; // 调用isLargeMode函数的时候有可能就没有给系列赋值

    this.series && this.series.length && this.series.forEach(function (series) {
      isLarge = !!series.options.large || isLarge;
    });
    isLarge = !!this.options.plotOptions.large || isLarge;
    return isLarge;
  },
  hasRangeLegend: function () {
    return !!this.components[_component.ComponentCst.RANGE_LEGEND_COMPONENT];
  },
  seriesOfType: function (type) {
    return (0, _util.seriesOfType)(this.series, type);
  },
  pointsOfType: function (type) {
    var allPoints = [];
    this.series.forEach(function (ser) {
      if (ser.type == type) {
        allPoints = allPoints.concat(ser.points);
      }
    });
    return allPoints;
  },
  // ussage:
  // vanchart.setTimeout('foo', bar, 100);
  // setting new func for the same key will flush the previous func
  // vanchart.setTimeout('foo'); cancel the func
  //
  // attention: this function fire the delay=0 immediately, no setTimeout(fun, 0)
  //
  setTimeout: function (key, func, delay) {
    if (this.timeQueue[key]) {
      window.clearTimeout(this.timeQueue[key]);
    }

    if (delay) {
      this.timeQueue[key] = window.setTimeout(func, delay);
    } else {
      func && func();
      this.timeQueue[key] = null;
    }
  },
  // should remove all in the end
  clearTimeQueue: function () {
    var timeQueue = this.timeQueue || {};
    Object.keys(timeQueue).map(function (key) {
      window.clearTimeout(timeQueue[key]);
    });
    return {};
  },
  getSize: function () {
    if (!this._size || this._sizeChanged) {
      this._size = new _Point2D["default"](this.width, this.height);
      this._sizeChanged = false;
    }

    return this._size.clone();
  },

  /**
   * 判断是否在大数据的情况下进行缩放
   * @returns {boolean}
   */
  isZoomingWithLargeModel: function () {
    var totalDataLen = 0,
        series = this.options.series,
        i,
        data;

    for (i = -1; ++i < series.length;) {
      data = series[i].data;
      totalDataLen += data.length;
    }

    return totalDataLen > 100 && this._zooming;
  }
}); //view


VanChart.include({
  render: function () {
    this.vancharts.endLoading();
    var vanchart = this,
        renderer = this.renderer;
    var clipBounds = this.getPlotClipBounds();

    if (!this.plotClip) {
      this.plotClip = renderer.createClip(clipBounds);
    } else {
      renderer.updateClip(this.plotClip, clipBounds);
    }

    function createGroup(groupName) {
      if (!vanchart[groupName]) {
        vanchart[groupName] = renderer.group().addClass(groupName).add();

        if (vanchart.isMap()) {
          vanchart[groupName].addClass('map-component');
        }
      }
    }

    ['backGroup', 'clipSeriesGroup', 'seriesGroup', 'seriesTextRenderGroup', 'frontGroup'].forEach(createGroup);

    if (this.isMobileFlow()) {
      createGroup('crossLineGroup');
      vanchart.seriesTextRenderGroup.attr({
        'pointer-events': 'none',
        'touch-action': 'none'
      });
      vanchart.frontGroup.attr({
        'pointer-events': 'none',
        'touch-action': 'none'
      });
      vanchart.crossLineGroup.attr({
        'pointer-events': 'none',
        'touch-action': 'none'
      });
      createGroup('crossLineGroup');

      if (!this.isMap()) {
        renderer.clip(vanchart.crossLineGroup, vanchart.plotClip);
      }
    }

    renderer.clip(vanchart.clipSeriesGroup, vanchart.plotClip);
    renderer.clip(vanchart.seriesTextRenderGroup, vanchart.plotClip);

    this._addDivClipGroup(clipBounds);

    this.emptyDataRender && this.emptyDataRender.remove(); // 空数据时显示空数据提示，并且返回
    // 非空数据时移除存在的空数据提示，继续渲染操作

    if (this._isEmptyDataChart()) {
      this._showEmptyDataTip();

      return;
    }

    this._renderBackground();

    this.renderComponents();
    this.renderSeries();
  },
  _addDivClipGroup: function (clipBounds) {
    var vanchart = this;

    if (!vanchart.seriesTextDivGroup) {
      vanchart.seriesTextDivGroup = this.renderer.div().add();
    } // clip: rect(<top>, <right>, <bottom>, <left>);


    vanchart.seriesTextDivGroup.style({
      clip: 'rect(' + [clipBounds.y, clipBounds.x + clipBounds.width, clipBounds.y + clipBounds.height, clipBounds.x].join('px ') + 'px)'
    });
  },
  _renderBackground: function () {
    var chartBounds = _BaseUtils["default"].makeBounds(0, 0, this.width, this.height),
        plotBounds = this.bounds,
        options = this.options,
        renderer = this.renderer; // CHART-14372 全屏放大的图表的背景只使用backgroundColor的rgb，不使用opacity


    var chartBackgroundColor = typeof options.backgroundColor == 'string' && this.vancharts.fullScreenFather ? _ColorUtils["default"].colorToHex(options.backgroundColor) : options.backgroundColor;
    var chartConfig = {
      backgroundColor: chartBackgroundColor,
      backgroundImage: options.backgroundImage,
      borderColor: options.borderColor,
      borderWidth: options.borderWidth,
      borderRadius: options.borderRadius || 0,
      shadow: options.shadow
    };
    var plotConfig = {
      backgroundColor: options.plotBackgroundColor,
      backgroundImage: options.plotBackgroundImage,
      borderRadius: options.plotBorderRadius || 0,
      shadow: options.plotShadow
    };
    var plotBorderConfig = {
      borderWidth: options.plotBorderWidth,
      borderColor: options.plotBorderColor,
      borderRadius: options.plotBorderRadius || 0
    };

    if (chartConfig.shadow) {
      chartBounds.width -= 5;
      chartBounds.height -= 5;
    }

    if (chartConfig.backgroundColor || chartConfig.backgroundImage || chartConfig.borderColor) {
      this.chartBackgroundGroup = this.chartBackgroundGroup || renderer.group().addTo(this.backGroup);
    } else if (this.chartBackgroundGroup) {
      this.chartBackgroundGroup.remove();
      this.chartBackgroundGroup = null;
    }

    if (plotConfig.backgroundColor || plotConfig.backgroundImage) {
      this.plotBackgroundGroup = this.plotBackgroundGroup || this.renderer.group().addTo(this.backGroup);
    } else if (this.plotBackgroundGroup) {
      this.plotBackgroundGroup.remove();
      this.plotBackgroundGroup = null;
    }

    if (plotBorderConfig.borderWidth) {
      this.plotBackgroundBorder = this.plotBackgroundBorder || this.renderer.rect().addTo(this.frontGroup);
    } else if (this.plotBackgroundBorder) {
      this.plotBackgroundBorder.remove();
      this.plotBackgroundBorder = null;
    }

    if (!options.geo || false) {
      this._renderRectangleBackground(this.chartBackgroundGroup, chartConfig, chartBounds);
    }

    this._renderRectangleBackground(this.plotBackgroundGroup, plotConfig, plotBounds);

    this._renderPlotBackgroundBorder(this.plotBackgroundBorder, plotBorderConfig, plotBounds);
  },
  renderComponents: function () {
    for (var c in this.components) {
      c !== _component.ComponentCst.POLAR_COMPONENT && this.components[c] && this.components[c].render();
    }

    var vanchart = this,
        renderer = vanchart.renderer;

    if (!vanchart.highlightGroup && vanchart.plotClip) {
      renderer.clip(vanchart.highlightGroup = renderer.group().addTo(vanchart.backGroup), vanchart.plotClip);
    }
  },
  renderSeries: function () {
    var tooltip = this.components[_component.ComponentCst.TOOLTIP_COMPONENT];
    tooltip && tooltip.immediateHide();
    this.clearAllEffects(); // MOBILE-6927

    var shareAxis = this.getSharedAxis();
    shareAxis && shareAxis.removeHighlightBackground && shareAxis.removeHighlightBackground();
    this.fire('animationStart');

    this._renderTrendLine();
  },

  /**
   * 判断是否为空数据图表
   * @return {Boolean} [description]
   */
  _isEmptyDataChart: function () {
    // 系列为空，就为空数据
    //emptyDataTip.enabled开启时显示空数据提示，不开启显示空白
    return !this.isMap() && this.series.length === 0; //地图没有空数据提示，数据为空时，依旧绘制底图等component
  },

  /**
   * Chart-925:空数据时图表显示提示
   * @private
   */
  _showEmptyDataTip: function () {
    this._removeAll();

    this.emptyDataRender = (0, _showEmptyDataTip["default"])({
      dom: this.wrapDom,
      emptyDataTip: this.options.emptyDataTip,
      chartWidth: this.width,
      chartHeight: this.height,
      chart: this
    });
  },

  /**
   * 移除所有的组件和背景等
   * @return {[type]} [description]
   */
  _removeAll: function () {
    // 如果把TOOLTIP_COMPONENT直接remove掉，
    // 目前已知的一个坑：在多图表场景下，生成空数据图表时会先将tooltip给immediateHide，
    // 由于remove时tooltip的_tDom=null，导致immediateHide报错，
    // 所以不知道其他地方还有什么坑，这里的TOOLTIP_COMPONENT还是先immediateHide吧……
    for (var c in this.components) {
      if (c !== _component.ComponentCst.TOOLTIP_COMPONENT) {
        this.components[c] && this.components[c].remove();
      } else {
        this.components[c] && this.components[c].immediateHide();
      }
    } // 框架图LinkLine移除


    this.linkGroup && this.linkGroup.remove(); // 移除背景

    this.chartBackgroundGroup && this.chartBackgroundGroup.remove();
    this.plotBackgroundGroup && this.plotBackgroundGroup.remove();
    this.plotBackgroundBorder && this.plotBackgroundBorder.remove();
    this.linkGroup = this.chartBackgroundGroup = this.plotBackgroundGroup = this.plotBackgroundBorder = null;
  },
  _renderPlotBackgroundBorder: function (borderElementWrapper, option, bounds) {
    if (borderElementWrapper == null) {
      return;
    }

    var borderBounds = _extends({}, bounds, {
      rx: option.borderRadius,
      ry: option.borderRadius
    });

    borderElementWrapper.attr(borderBounds).style({
      'fill': 'none',
      'stroke': option.borderColor,
      'stroke-width': option.borderWidth
    });
  },

  /**
   * 绘制图表背景(颜色,背景图,阴影等)
   * @param  {[type]} backgroundGroup [description]
   * @param  {[type]} option          [description]
   * @param  {[type]} bounds          [description]
   * @return {[type]}                 [description]
   */
  _renderRectangleBackground: function (backgroundGroup, option, bounds) {
    if (!backgroundGroup) {
      return;
    }

    var borderWidth = option.borderWidth || 0,
        renderer = this.renderer;
    var det = borderWidth / 2;

    var borderBounds = _BaseUtils["default"].rectSubPixelOpt(bounds.x + det, bounds.y + det, Math.max(bounds.width - borderWidth, 0), Math.max(bounds.height - borderWidth, 0), borderWidth);

    borderBounds.rx = borderBounds.ry = option.borderRadius;

    if (option.shadow) {
      var shadowBounds = _BaseUtils["default"].rectSubPixelOpt(bounds, 1);

      var width = [5, 3, 1];
      var opacity = [0.05, 0.1, 0.15];
      width.forEach(function (w, i) {
        var key = 'shadowRect' + i;
        backgroundGroup[key] = backgroundGroup[key] || renderer.rect().style({
          'fill': 'none',
          'stroke': 'black',
          'stroke-width': width[i],
          'stroke-opacity': opacity[i]
        }).addTo(backgroundGroup);
        backgroundGroup[key].attr(shadowBounds).attr({
          'rx': option.borderRadius,
          'ry': option.borderRadius,
          'transform': 'translate(1, 1)'
        });
      });
    }

    if (option.backgroundColor && typeof option.backgroundColor == 'object') {
      //ie下面不用渐变了
      if ((0, _EnvUtils.supportFillFilter)()) {
        var gradualOption = option.backgroundColor;
        var attrs = {
          'x1': gradualOption.x1,
          'y1': gradualOption.y1,
          'x2': gradualOption.x2,
          'y2': gradualOption.y2
        };
        var stop1 = {
          'offset': '0%',
          'stop-color': gradualOption.startColor
        };
        var stop2 = {
          'offset': '100%',
          'stop-color': gradualOption.endColor
        };

        if (backgroundGroup.gradientFill) {
          renderer.updateColorGradient(backgroundGroup.gradientFill, attrs, [stop1, stop2]);
        } else {
          backgroundGroup.gradientFill = renderer.colorGradient(attrs, [stop1, stop2]);
        }
      } else {
        option.backgroundColor = option.backgroundColor.startColor;
      }
    }

    if (option.backgroundImage) {
      backgroundGroup.backgroundImage = backgroundGroup.backgroundImage || renderer.image().addTo(backgroundGroup);
      backgroundGroup.backgroundImage.attr(bounds).attr('preserveAspectRatio', 'none').imageContent(option.backgroundImage);
    } else {
      backgroundGroup.backgroundImage && backgroundGroup.backgroundImage.remove();
      backgroundGroup.backgroundImage = null;
    }

    if (option.backgroundColor || option.borderWidth) {
      var fill = 'none';

      if (option.backgroundColor) {
        // 纯色背景
        if (typeof option.backgroundColor == 'string') {
          fill = option.backgroundColor;
        } else {
          // 渐变背景
          fill = renderer.toPatternProperty(backgroundGroup.gradientFill);
        }
      }

      backgroundGroup.backgroundColor = backgroundGroup.backgroundColor || renderer.rect().addTo(backgroundGroup);
      backgroundGroup.backgroundColor.attr(borderBounds).style({
        'fill': fill,
        'stroke': option.borderColor,
        'stroke-width': _BaseUtils["default"].pick(option.borderWidth, 0)
      });
    } else {
      backgroundGroup.backgroundColor && backgroundGroup.backgroundColor.remove();
      backgroundGroup.backgroundColor = null;
    }
  },
  //渐变色图例，直接过滤，不用计算布局什么的
  filterRender: function () {
    for (var i = 0, len = this.series.length; i < len; i++) {
      this.series[i].filterRender();
    }
  },
  cancelLegendHighlight: function (containerPoint) {
    var legend = this.getComponent(_component.ComponentCst.LEGEND_COMPONENT);
    legend = legend || this.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT);

    if (legend) {
      if (legend.highlighted && !_BaseUtils["default"].containsPoint(legend.bounds, containerPoint)) {
        legend.highlighted = false;
        this.highlightTarget = null;

        this._updateSeriesStyle();

        this._updateLegendStyle();

        this._updateTrendLineStyle();
      }
    }
  },
  makeLegendHighlight: function (target) {
    this.highlightTarget = target;

    this._updateSeriesStyle();

    this._updateLegendStyle();

    this._updateTrendLineStyle();
  },
  _updateLegendStyle: function () {
    var legendGroup = this.getComponent(_component.ComponentCst.LEGEND_COMPONENT) || this.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT);
    legendGroup.items.forEach(function (legendItem) {
      legendItem.updateLegendItemGraphicStyle();
    });
  },
  _updateTrendLineStyle: function () {
    var target = this.highlightTarget;
    var trendLineOptions = this.trendLines;
    var trendLines = this.trendLineGroup && this.trendLineGroup.trendLines;

    if (!trendLineOptions || !trendLines) {
      return;
    }

    for (var i = 0; i < trendLineOptions.length; i++) {
      var options = trendLineOptions[i],
          attrs = {
        'd': options.d
      };
      var originStrokeOpacity = options.trendLine.opacity;
      var strokeOpacity = target == null || options.bindName === target ? originStrokeOpacity : _Constants["default"].HOVER_OPACITY;
      trendLines[i].attr(attrs).style({
        'stroke-opacity': strokeOpacity
      });
    }
  },
  _updateSeriesStyle: function () {
    this.series.forEach(function (ser) {
      if (ser.isSupportLegendHighlight()) {
        if (ser.useCanvas()) {
          ser._canvasRender();
        } else {
          // 对于折线图和雷达图这类的，不要忘了使系列高亮
          ser.drawSeries && ser.drawSeries();
          ser.getDataToDraw().filter(function (point) {
            return point.isVisible();
          }).forEach(function (point) {
            ser._updatePointGraphicStyle(point);
          });
          ser.points && ser.points.forEach(function (point) {
            point.hasValidDataLabel() && ser._updatePointLabelStyle(point);
          });
        }
      }
    });
  },
  // 坐标轴缩放,拖拽缩放,点击图例等任何会导致绘图区图形变化的操作由这步完成
  reRenderSeries: function () {
    _VanChartLayout["default"].calculateSeries(this, true);

    _VanChartLayout["default"].calculateSeriesShapes(this);

    this.renderSeries();
  },
  removePointGraphics: function (p) {
    p && p.remove();
    p = null;
  },
  registerInteractiveTarget: function (data, elementWrapper) {
    if (elementWrapper) {
      this._targets[_BaseUtils["default"].stamp(elementWrapper.node())] = data;
    }

    this.activeDataEvents(data);
  },
  activeDataEvents: function (data) {
    data._events = null;
    data.getEvents && data.on(data.getEvents(), data);
  },
  removeInteractiveTarget: function (data, elementWrapper) {
    if (elementWrapper) {
      this._targets[_BaseUtils["default"].stamp(elementWrapper.node())] = null;
      delete this._targets[_BaseUtils["default"].stamp(elementWrapper.node())];
    }

    if (data) {
      data._events = null;
    }
  },
  findInteractiveTarget: function (rawElement) {
    return this._targets[_BaseUtils["default"].stamp(rawElement)];
  },
  //need resize when chart resize
  addCanvasRendererForResize: function (canvas) {
    this._canvasMap = this._canvasMap || [];

    this._canvasMap.push(canvas);
  },
  resize: function () {
    var dom = this.wrapDom;
    this.width = _BaseUtils["default"].getDomWidth(dom);
    this.height = _BaseUtils["default"].getDomHeight(dom); // @Cmen：CHART-1130:同initialize

    if (!this._checkValidSize()) {
      return;
    } // if not inited, init


    this._init();

    this._sizeChanged = true;
    this.clipPool = {};
    this.axisSize = {
      'left': 0,
      'right': 0,
      'bottom': 0,
      'top': 0
    };
    this.renderer.resize();
    this._canvasMap && this._canvasMap.forEach(function (canvas) {
      canvas.resize();
    });

    if (this.isMap()) {
      this.mapRenderer.resize();

      this._onResize();

      this.components.geo.resize();
    } // BI-6380


    var multiPie = this.seriesOfType(_Constants["default"].MULTIPIE_CHART)[0];

    if (multiPie) {
      multiPie.chartInfo.radius = null;
    }

    var moreLabel = this.getComponent(_component.ComponentCst.MORELABEL_COMPONENT);
    moreLabel && moreLabel.resize(); // scale可能也对应改变

    this.update();

    if (this.isMobileFlow()) {
      this.flowResize();
    }
  },
  remove: function () {
    // CHART-996
    // 框架图在label未画完时再次触发动态参数，render已经remove，抛bug
    // 那么问题来了，怎么就框架图发现了……框架图动画时间是不是最长的
    this._animationStarted = false;
    this.__inited = false;
    this.force && this.force.endTick(null).stop();
    this.force = null;
    this.clearAllEffects();
    this.clearTimeQueue();
    this.renderer && this.renderer.remove();
    this.handler && this.handler.destroy();
    var tooltip = this.getComponent(_component.ComponentCst.TOOLTIP_COMPONENT);
    tooltip && tooltip.remove();
    var moreLabel = this.getComponent(_component.ComponentCst.MORELABEL_COMPONENT);
    moreLabel && moreLabel.remove();
    this.emptyDataRender && this.emptyDataRender.remove();
    this.mainRenderer && this.mainRenderer.remove();
    this.animationRenderer && this.animationRenderer.remove();
    this.emptyDataRender = null;
    this.mainRenderer = null;
    this.animationRenderer = null;

    if (this.largeSeries) {
      Object.keys(this.largeSeries).map(function (key) {
        if (this.largeSeries[key]._canvas) {
          this.largeSeries[key]._canvas.remove();
        }

        this.largeSeries[key] = null;
      }, this);
    }

    this.largeSeries = null;
    this.renderer = this.plotClip = this._leaflet = this.handler = this.chartBackgroundGroup = this.trendLineGroup = this.seriesGroup = this.clipSeriesGroup = this.seriesTextRenderGroup = this.seriesTextDivGroup = null;
    this._animatingZoom = false; //下钻+参数刷新。刷新前停止下钻

    this.validPoints = [];
  },

  /**
   * 是否可以响应原生的PanMove
   * @returns {boolean}
   */
  canFireNativePanMove: function () {
    return true;
  },
  isMobile: function () {
    var op = this.options;
    return op && op.mobile != null ? op.mobile : _BaseUtils["default"].hasTouch();
  },
  showTooltip: function () {
    this._showTooltip.apply(this, arguments);
  },
  isDarkTheme: function () {
    var options = this.options;
    return options.theme === _Constants["default"].DARK;
  },
  useCanvas: _BaseUtils["default"].falseFn
});
var _default = VanChart;
exports["default"] = _default;

/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _LatLng = _interopRequireDefault(__webpack_require__(19));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/19.
 */
var LatLngBounds = function (corner1, corner2) {
  // (LatLng, LatLng) or (LatLng[])
  if (!corner1) {
    return;
  }

  var latlngs = corner2 ? [corner1, corner2] : corner1;

  for (var i = 0, len = latlngs.length; i < len; i++) {
    this.extend(latlngs[i]);
  }
};

LatLngBounds.prototype = {
  extend: function (obj) {
    var sw = this._southWest,
        ne = this._northEast,
        sw2,
        ne2;

    if (obj instanceof _LatLng["default"]) {
      sw2 = obj;
      ne2 = obj;
    } else if (obj instanceof LatLngBounds) {
      sw2 = obj._southWest;
      ne2 = obj._northEast;

      if (!sw2 || !ne2) {
        return this;
      }
    } else {
      return obj ? this.extend(_LatLng["default"].create(obj) || LatLngBounds.create(obj)) : this;
    }

    if (!sw && !ne) {
      this._southWest = new _LatLng["default"](sw2.lat, sw2.lng);
      this._northEast = new _LatLng["default"](ne2.lat, ne2.lng);
    } else {
      sw.lat = Math.min(sw2.lat, sw.lat);
      sw.lng = Math.min(sw2.lng, sw.lng);
      ne.lat = Math.max(ne2.lat, ne.lat);
      ne.lng = Math.max(ne2.lng, ne.lng);
    }

    return this;
  },
  // @method pad(bufferRatio: Number): LatLngBounds
  // Returns bigger bounds created by extending the current bounds by a given percentage in each direction.
  pad: function (bufferRatio) {
    var sw = this._southWest,
        ne = this._northEast,
        heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio,
        widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
    return new LatLngBounds(new _LatLng["default"](sw.lat - heightBuffer, sw.lng - widthBuffer), new _LatLng["default"](ne.lat + heightBuffer, ne.lng + widthBuffer));
  },
  // @method getCenter(): LatLng
  // Returns the center point of the bounds.
  getCenter: function () {
    return new _LatLng["default"]((this._southWest.lat + this._northEast.lat) / 2, (this._southWest.lng + this._northEast.lng) / 2);
  },
  // @method getSouthWest(): LatLng
  // Returns the south-west point of the bounds.
  getSouthWest: function () {
    return this._southWest;
  },
  // @method getNorthEast(): LatLng
  // Returns the north-east point of the bounds.
  getNorthEast: function () {
    return this._northEast;
  },
  // @method getNorthWest(): LatLng
  // Returns the north-west point of the bounds.
  getNorthWest: function () {
    return new _LatLng["default"](this.getNorth(), this.getWest());
  },
  // @method getSouthEast(): LatLng
  // Returns the south-east point of the bounds.
  getSouthEast: function () {
    return new _LatLng["default"](this.getSouth(), this.getEast());
  },
  // @method getWest(): Number
  // Returns the west longitude of the bounds
  getWest: function () {
    return this._southWest.lng;
  },
  // @method getSouth(): Number
  // Returns the south latitude of the bounds
  getSouth: function () {
    return this._southWest.lat;
  },
  // @method getEast(): Number
  // Returns the east longitude of the bounds
  getEast: function () {
    return this._northEast.lng;
  },
  // @method getNorth(): Number
  // Returns the north latitude of the bounds
  getNorth: function () {
    return this._northEast.lat;
  },
  // @method contains(otherBounds: LatLngBounds): Boolean
  // Returns `true` if the rectangle contains the given one.
  // @alternative
  // @method contains (latlng: LatLng): Boolean
  // Returns `true` if the rectangle contains the given point.
  contains: function (obj) {
    // (LatLngBounds) or (LatLng) -> Boolean
    if (typeof obj[0] === 'number' || obj instanceof _LatLng["default"]) {
      obj = _LatLng["default"].create(obj);
    } else {
      obj = LatLngBounds.create(obj);
    }

    var sw = this._southWest,
        ne = this._northEast,
        sw2,
        ne2;

    if (obj instanceof LatLngBounds) {
      sw2 = obj.getSouthWest();
      ne2 = obj.getNorthEast();
    } else {
      sw2 = ne2 = obj;
    }

    return sw2.lat >= sw.lat && ne2.lat <= ne.lat && sw2.lng >= sw.lng && ne2.lng <= ne.lng;
  },
  // @method intersects(otherBounds: LatLngBounds): Boolean
  // Returns `true` if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
  intersects: function (bounds) {
    bounds = LatLngBounds.create(bounds);
    var sw = this._southWest,
        ne = this._northEast,
        sw2 = bounds.getSouthWest(),
        ne2 = bounds.getNorthEast(),
        latIntersects = ne2.lat >= sw.lat && sw2.lat <= ne.lat,
        lngIntersects = ne2.lng >= sw.lng && sw2.lng <= ne.lng;
    return latIntersects && lngIntersects;
  },
  // @method overlaps(otherBounds: Bounds): Boolean
  // Returns `true` if the rectangle overlaps the given bounds. Two bounds overlap if their intersection is an area.
  overlaps: function (bounds) {
    bounds = LatLngBounds.create(bounds);
    var sw = this._southWest,
        ne = this._northEast,
        sw2 = bounds.getSouthWest(),
        ne2 = bounds.getNorthEast(),
        latOverlaps = ne2.lat > sw.lat && sw2.lat < ne.lat,
        lngOverlaps = ne2.lng > sw.lng && sw2.lng < ne.lng;
    return latOverlaps && lngOverlaps;
  },
  // @method toBBoxString(): String
  // Returns a string with bounding box coordinates in a 'southwest_lng,southwest_lat,northeast_lng,northeast_lat' format. Useful for sending requests to web services that return geo data.
  toBBoxString: function () {
    return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(',');
  },
  // @method equals(otherBounds: LatLngBounds): Boolean
  // Returns `true` if the rectangle is equivalent (within a small margin of error) to the given bounds.
  equals: function (bounds) {
    if (!bounds) {
      return false;
    }

    bounds = LatLngBounds.create(bounds);
    return this._southWest.equals(bounds.getSouthWest()) && this._northEast.equals(bounds.getNorthEast());
  },
  // @method isValid(): Boolean
  // Returns `true` if the bounds are properly initialized.
  isValid: function () {
    return !!(this._southWest && this._northEast);
  },
  isSame: function () {
    var sw = this._southWest,
        ne = this._northEast;
    return sw.lat === ne.lat && sw.lng === ne.lng;
  }
};

LatLngBounds.create = function (a, b) {
  if (a instanceof LatLngBounds) {
    return a;
  }

  return new LatLngBounds(a, b);
};

var _default = LatLngBounds;
exports["default"] = _default;

/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by eason on 2017/2/15.
 */
var d3_map_proto = "__proto__",
    d3_map_zero = "\x00";

function vMap(object, f) {
  this._ = Object.create(null);

  if (object) {
    var map = this;

    if (object instanceof vMap) {
      object.forEach(function (key, value) {
        map.set(key, value);
      });
    } else if (Array.isArray(object)) {
      var i = -1,
          n = object.length,
          o;

      if (arguments.length === 1) {
        while (++i < n) {
          map.set(i, object[i]);
        }
      } else {
        while (++i < n) {
          map.set(f.call(object, o = object[i], i), o);
        }
      }
    } else {
      for (var key in object) {
        map.set(key, object[key]);
      }
    }
  }
}

vMap.prototype = {
  has: d3_map_has,
  get: function (key) {
    return this._[d3_map_escape(key)];
  },
  set: function (key, value) {
    return this._[d3_map_escape(key)] = value;
  },
  remove: d3_map_remove,
  keys: d3_map_keys,
  values: function () {
    var values = [];

    for (var key in this._) {
      values.push(this._[key]);
    }

    return values;
  },
  entries: function () {
    var entries = [];

    for (var key in this._) {
      entries.push({
        key: d3_map_unescape(key),
        value: this._[key]
      });
    }

    return entries;
  },
  size: d3_map_size,
  empty: d3_map_empty,
  forEach: function (f) {
    for (var key in this._) {
      f.call(this, d3_map_unescape(key), this._[key]);
    }
  }
};

function d3_map_escape(key) {
  return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key;
}

function d3_map_unescape(key) {
  return (key += "")[0] === d3_map_zero ? key.slice(1) : key;
}

function d3_map_has(key) {
  return d3_map_escape(key) in this._;
}

function d3_map_remove(key) {
  return (key = d3_map_escape(key)) in this._ && delete this._[key];
}

function d3_map_keys() {
  var keys = [];

  for (var key in this._) {
    keys.push(d3_map_unescape(key));
  }

  return keys;
}

function d3_map_size() {
  var size = 0;

  for (var key in this._) {
    ++size;
  }

  return size;
}

function d3_map_empty() {
  for (var key in this._) {
    return false;
  }

  return true;
}

var _default = vMap;
exports["default"] = _default;

/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isNeedBorder = isNeedBorder;
exports.getHorizontalPadding = getHorizontalPadding;
exports.getLabelPadding = getLabelPadding;
exports.fixLabelDimWithBorder = fixLabelDimWithBorder;
exports.getBorderBounds = getBorderBounds;
exports.getPathAndTransform = getPathAndTransform;
exports.createTextBorderPath = createTextBorderPath;
exports.labelTransWithBorder = labelTransWithBorder;
exports.borderPaddingFn = void 0;

var _BorderPathGeneretor = __webpack_require__(105);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _GradualColorUtils = __webpack_require__(42);

var _GradualColor = __webpack_require__(31);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var DIALOG_BORDER = 'dialog';
var PARALLELOGRAM_BORDER = 'parallelogram';
var ELLIPSE_BORDER = 'ellipse';
var LINE_TRIANGLE_BORDER = 'lineTriangle';
var DEFAULT_TRIANGLE_SIZE = 3;
var PARALLELOGRAM_CONFIG = {
  radius: 2,
  paddingWidth: 4,
  offsetAngleTan: 0.175 // tan(10度)

};
var ELLIPSE_RADIUS_SCALE = 1.25;
var TRANSPARENT = "rgba(0,0,0,0)";

var DIRECTION = function (location) {
  switch (location) {
    case _Constants["default"].RIGHT_TO_LEFT:
      return 'left';

    case _Constants["default"].LEFT_TO_RIGHT:
      return 'right';

    case _Constants["default"].TOP_TO_BOTTOM:
      return 'bottom';

    default:
      return 'top';
  }
};

function isNeedBorder(point) {
  var labelContent = point.labelContent,
      options = point.options,
      series = point.series;
  var dataLabels = options.dataLabels;

  var _ref = dataLabels || {},
      backgroundColor = _ref.backgroundColor,
      borderWidth = _ref.borderWidth,
      orientation = _ref.orientation;

  var isHorizontalLabel = orientation !== _Constants["default"].VERTICAL_LAYOUT;
  var isNeedBorderChart = series && (series.type === _Constants["default"].PIE_CHART || series.type === _Constants["default"].LINE_CHART || series.type === _Constants["default"].AREA_CHART || series.type === _Constants["default"].BAR_CHART || series.type === _Constants["default"].COLUMN_CHART);
  return isHorizontalLabel && isNeedBorderChart && labelContent && labelContent.length !== 0 && (borderWidth || backgroundColor);
}

function getEllipseBorderPadding(labelTextDim) {
  var _labelTextDim$width = labelTextDim.width,
      width = _labelTextDim$width === void 0 ? 0 : _labelTextDim$width,
      _labelTextDim$height = labelTextDim.height,
      height = _labelTextDim$height === void 0 ? 0 : _labelTextDim$height;

  var paddingArr = function (l, s) {
    var longRadius = l * ELLIPSE_RADIUS_SCALE;
    var shortRadius = s * ELLIPSE_RADIUS_SCALE;
    return [(longRadius - l) * 2, (shortRadius - s) * 2];
  };

  return width > height ? paddingArr(width, height) : paddingArr(height, width).reverse();
}

var borderPaddingFn = function (borderType, isDelTriangleSize, labelTextDim) {
  var _ref2 = labelTextDim || {},
      width = _ref2.width,
      height = _ref2.height;

  var parallelogramOffsetWidth;

  switch (borderType) {
    case DIALOG_BORDER:
      return isDelTriangleSize ? [8, 5] : [8, 8];

    case PARALLELOGRAM_BORDER:
      parallelogramOffsetWidth = height ? 2 * PARALLELOGRAM_CONFIG.offsetAngleTan * (height + 5) + PARALLELOGRAM_CONFIG.paddingWidth : 8;
      return [parallelogramOffsetWidth, 5];

    case ELLIPSE_BORDER:
      return getEllipseBorderPadding(labelTextDim);

    case LINE_TRIANGLE_BORDER:
      return isDelTriangleSize ? [8, 5] : [8, 8];

    default:
      return [8, 5];
  }
};

exports.borderPaddingFn = borderPaddingFn;

function getHorizontalPadding(point) {
  var padding = getLabelPadding(point);

  if (padding && padding.length === 2) {
    return padding[0];
  }

  return 0;
}

function getLabelPadding(point) {
  if (!isNeedBorder(point)) {
    return [0, 0];
  }

  var options = point.options,
      labelDim = point.labelDim;
  var dataLabels = options.dataLabels;
  var borderType = dataLabels.borderType;
  return borderPaddingFn(borderType, false, labelDim.innerTextDim);
}

function fixLabelDimWithBorder(point) {
  var labelDim = point.labelDim;
  var borderPadding = getLabelPadding(point);
  labelDim.width += borderPadding[0];
  labelDim.height += borderPadding[1];
}

function getBorderBounds(point) {
  var options = point.options,
      labelDim = point.labelDim,
      labelPos = point.labelPos;
  var x = labelPos.x,
      y = labelPos.y;
  var width = labelDim.width,
      height = labelDim.height;
  var dataLabels = options.dataLabels;
  var borderType = dataLabels.borderType;
  var direction = DIRECTION(point.location);

  var dialogBorderBounds = function (direction) {
    switch (direction) {
      case 'left':
        return {
          width: width - DEFAULT_TRIANGLE_SIZE,
          height: height,
          x: x,
          y: y
        };

      case 'right':
        return {
          width: width - DEFAULT_TRIANGLE_SIZE,
          height: height,
          x: x + DEFAULT_TRIANGLE_SIZE,
          y: y
        };

      case 'bottom':
        return {
          width: width,
          height: height - DEFAULT_TRIANGLE_SIZE,
          x: x,
          y: y + DEFAULT_TRIANGLE_SIZE
        };

      default:
        return {
          width: width,
          height: height - DEFAULT_TRIANGLE_SIZE,
          x: x,
          y: y
        };
    }
  };

  var rectBounds = function () {
    return {
      width: width,
      height: height,
      x: x,
      y: y
    };
  };

  switch (borderType) {
    case DIALOG_BORDER:
    case LINE_TRIANGLE_BORDER:
      return dialogBorderBounds(direction);

    default:
      return rectBounds();
  }
}

function getPathAndTransform(point) {
  var path;
  var options = point.options;
  var dataLabels = options.dataLabels;
  var borderType = dataLabels.borderType,
      borderRadius = dataLabels.borderRadius;
  var direction = DIRECTION(point.location);

  var _getBorderBounds = getBorderBounds(point),
      width = _getBorderBounds.width,
      height = _getBorderBounds.height,
      x = _getBorderBounds.x,
      y = _getBorderBounds.y;

  var transform = _BaseUtils["default"].makeTranslate({
    x: x,
    y: y
  });

  switch (borderType) {
    case PARALLELOGRAM_BORDER:
      path = (0, _BorderPathGeneretor.parallelogramBorderGenerator)(width, height, PARALLELOGRAM_CONFIG.radius, PARALLELOGRAM_CONFIG.offsetAngleTan * height);
      break;

    case DIALOG_BORDER:
      path = (0, _BorderPathGeneretor.dialogBorderGenerator)(width, height, direction, 0, borderRadius, DEFAULT_TRIANGLE_SIZE);
      break;

    case ELLIPSE_BORDER:
      path = (0, _BorderPathGeneretor.ellipseBorderGenerator)(width, height);
      break;

    case LINE_TRIANGLE_BORDER:
      path = (0, _BorderPathGeneretor.lineTriangleGenerator)(width, height, direction);
      break;

    default:
      path = (0, _BorderPathGeneretor.rectBorderGenerator)(width, height, 0, borderRadius);
      break;
  }

  return {
    path: path,
    transform: transform
  };
}

function _createBorderGradientBackground(renderer, color, point) {
  return (0, _GradualColorUtils.createGradientBackground)(point, 'textBorderBackgroundColorGradient', renderer, color);
}

function createTextBorderPath(point) {
  if (!isNeedBorder(point)) {
    return;
  }

  var options = point.options,
      series = point.series;
  var renderer = series.vanchart.renderer;

  var textLabelGroup = series._getPointTextLabelGroup();

  var dataLabels = options.dataLabels;
  var backgroundColor = dataLabels.backgroundColor,
      borderWidth = dataLabels.borderWidth,
      borderType = dataLabels.borderType,
      borderColor = dataLabels.borderColor;
  var pathAndTransform = getPathAndTransform(point);
  var strokeColor = borderColor === _Constants["default"].AUTO ? (0, _GradualColor.notSupportGradualColor)(options, point.getSeriesColor()) : borderColor || TRANSPARENT;
  var fillColor = typeof backgroundColor === 'string' ? backgroundColor || TRANSPARENT : _createBorderGradientBackground(renderer, backgroundColor, point); // lineTriangle类型的边框stroke和fill需要对应不同的path

  if (borderType === LINE_TRIANGLE_BORDER) {
    point.textBorderPath = renderer.group().addTo(textLabelGroup).attr({
      transform: pathAndTransform.transform
    });
    point.lineTriangleBorder = renderer.path().addTo(point.textBorderPath).attr({
      d: pathAndTransform.path[0]
    }).style({
      stroke: strokeColor,
      'stroke-width': borderWidth
    });
    point.lineTriangleBorderRect = renderer.path().addTo(point.textBorderPath).attr({
      d: pathAndTransform.path[1]
    }).style({
      fill: fillColor,
      'stroke-width': 0
    });
    return;
  }

  point.textBorderPath = renderer.path().addTo(textLabelGroup).attr({
    d: pathAndTransform.path,
    transform: pathAndTransform.transform
  }).style({
    fill: fillColor,
    stroke: strokeColor,
    'stroke-width': borderWidth
  });
}

function labelPosWithBorder(point) {
  var options = point.options,
      location = point.location,
      labelDim = point.labelDim;
  var dataLabels = options.dataLabels;
  var borderType = dataLabels.borderType;
  var borderPadding = borderPaddingFn(borderType, false, labelDim.innerTextDim);

  var _getBorderBounds2 = getBorderBounds(point),
      x = _getBorderBounds2.x,
      y = _getBorderBounds2.y;

  var dialogPos = function (location) {
    if (location === _Constants["default"].LEFT_TO_RIGHT || location === _Constants["default"].RIGHT_TO_LEFT) {
      return {
        x: x - (borderPadding[0] - DEFAULT_TRIANGLE_SIZE) / 2,
        y: y + borderPadding[1] / 2
      };
    } else {
      return {
        x: point.labelPos.x,
        y: y + (borderPadding[1] - DEFAULT_TRIANGLE_SIZE) / 2
      };
    }
  };

  switch (borderType) {
    case DIALOG_BORDER:
    case LINE_TRIANGLE_BORDER:
      return dialogPos(location);

    case PARALLELOGRAM_BORDER:
      return {
        x: point.labelPos.x,
        y: y + borderPadding[1] / 2
      };

    default:
      return {
        x: point.labelPos.x,
        y: y + borderPadding[1] / 2
      };
  }
}

function labelTransWithBorder(point) {
  var _labelPosWithBorder = labelPosWithBorder(point),
      x = _labelPosWithBorder.x,
      y = _labelPosWithBorder.y;

  return {
    x: x + point.labelDim.width / 2,
    y: y + point.labelDim.height / 2
  };
}

/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _SvgElementWrapper = _interopRequireDefault(__webpack_require__(106));

var _VmlElementWrapper = _interopRequireDefault(__webpack_require__(107));

var _ElementWrapper = _interopRequireDefault(__webpack_require__(38));

var _types = __webpack_require__(45);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

// import FineCanvasElementWrapper from "./FineCanvasElementWrapper";
var createElementWrapper = function (rawElement, renderer) {
  var type = renderer && renderer.type;

  switch (type) {
    case _types.SVG_RENDERER:
      return new _SvgElementWrapper["default"](rawElement, renderer);

    case _types.VML_RENDERER:
      return new _VmlElementWrapper["default"](rawElement, renderer);
    // case FINE_CANVAS_RENDERER:
    //     return new FineCanvasElementWrapper(rawElement, renderer);

    default:
      return new _ElementWrapper["default"](rawElement, renderer);
  }
};

var _default = createElementWrapper;
exports["default"] = _default;

/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.transformParser = exports["default"] = void 0;

var _Class = _interopRequireDefault(__webpack_require__(27));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Transition = _interopRequireDefault(__webpack_require__(44));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/7/22.
 * ElementWrapper是一个元素包裹器, 统一了元素操作相关, 支持链式调用, 类似JQuery
 * Example:
 * 对于一个DomElement, 我们要修改其属性或者样式, 一般要这么写
 *      el.setAttribute("name", "小明");
 *      el.setAttribute("age", "22");
 *      el.style.color = "#f00";
 *
 * 使用EleWrapper, 则简单许多
 *  var elw = new ElementWrapper(el).style("color", "#f00").attr("name", "小明").attr("age", "22")
 *  对于同一类操作可以合并, 比如上面的attr("name", "xx").attr("age", "xx")就可以合并写成
 *  elw.attr({name: "小明", age: "22"});
 *
 *  除了DomElement之外, 构造ElementWrapper的时候, 还需指定renderer, 用于判断一些当前元素是基于Svg或者dom实现的
 *
 */
var isArray = _BaseUtils["default"].isArray;
var TRANSITION_PREFIX = '__transition_';

var ElementWrapper = _Class["default"].extend({
  /**
   * wrap the elements to hide implementation details
   * @param rawElement dom elements for svg and vml,and data object for canvas
   * @param renderer the renderer that the rawElement belongs to
   */
  initialize: function (rawElement, renderer) {
    this.rawElement = rawElement;
    this.renderer = renderer;
    return this;
  },
  node: function () {
    return this.rawElement;
  },

  /**
   * add the rawElement to the parent container
   * append to the container for svg and vml
   * or show for canvas
   * @param parentElementWrapper
   * @returns {ElementWrapper}
   */
  addTo: function (parent) {
    parent = parent || this.renderer._container;
    parent.append(this);
    return this;
  },
  addToBack: function (parent) {
    parent = parent || this.renderer._container;
    parent = parent.node();
    parent.firstChild ? parent.insertBefore(this.node(), parent.firstChild) : parent.appendChild(this.node());
    return this;
  },
  add: function () {
    if (this.type === 'div') {
      return this.addTo(this.renderer._divContainer);
    }

    return this.addTo(this.renderer._container);
  },
  append: function (child) {
    this.node().appendChild(child.node());
    return child;
  },
  //bind data to the elementWrapper
  datum: function () {
    if (arguments.length) {
      this._datum = arguments[0];
      return this;
    }

    return this._datum;
  },
  addClass: function (name) {
    _DomUtils["default"].addClass(this.node(), name);

    return this;
  },
  toBack: function () {
    _DomUtils["default"].toBack(this.node());
  },

  /**
   * remove from the renderer container
   * for canvas, we shall clear the context and redraw all
   * the other elements on the container
   */
  remove: function () {
    var vanchart = this.renderer.vanchart;
    var data = vanchart.findInteractiveTarget(this.node());
    data && vanchart.removeInteractiveTarget(data, this);

    _DomUtils["default"].remove(this.node());

    return this;
  },
  removed: function () {
    return !(this.node().parentNode && this.node().parentNode.tagName);
  },
  isVisible: function () {
    return !this.removed() && this.node().style.display != 'none';
  },
  //ie下面用vml path模拟所有的形状,所以需要记录一下形状的类型
  setType: function (type) {
    this.type = type;
    return this;
  },
  // rotate text(div, svg) according to center
  // for less dom operation, set textContent & style first
  // then rotate
  // delayMove for animation
  vRotate: function (deg, delayMove) {
    this.renderer.vRotate(this, deg, delayMove);
    return this;
  },
  vMiddle: function () {
    this.renderer.vMiddle(this);
  },
  // transition stuff
  animate: function (para) {
    if (!para) {
      throw new Error('animate para empty');
    } else if (isArray(para)) {
      var transition = this.transition().setAnimation(para[0]);

      for (var i = 1, len = para.length; i < len; i++) {
        transition = transition.transition(para[i]);
      }

      return this.setTransitionEnd(transition, para[len - 1].style);
    } else {
      return this.setTransitionEnd(this.transition().setAnimation(para), para.style);
    }
  },
  setTransitionEnd: function (transition, styles) {
    var el = this;
    var vanchart = this.renderer.vanchart;
    ++vanchart.animationCount; // 避免同一个Elw上调用多次animate后导致前面的transition不能正常end

    if (el._animating) {
      --vanchart.animationCount;
    }

    el._animating = true;
    return transition.each('end', function () {
      el._animating = false;
      styles && el.style(styles);

      if (vanchart._animationStarted) {
        if (! --vanchart.animationCount) {
          vanchart.animationCount = -1; // console.log('ani transition end');

          vanchart.fire('animationEnd');
        }
      }
    });
  },
  effectTransition: function () {
    this.interrupt(_Constants["default"].EFFECT_KEY); // for resize & effect, interrupt last effect transition

    return new _Transition["default"](this, _Constants["default"].EFFECT_KEY);
  },
  transition: function (name) {
    return new _Transition["default"](this, name, null, !this.renderer.isAnimation);
  },
  interrupt: function (name) {
    var node = this.node(),
        ns = _Transition["default"].d3_transitionNamespace(name);

    var lock;

    if ((lock = node[ns]) && lock[lock.active]) {
      if (--lock.count) {
        delete lock[lock.active];
      } else {
        delete node[ns];
      }

      lock.active += .5;
    }

    return this;
  },

  /**
   * interrupt all transition on node[ns]
   * @param name
   * @returns {ElementWrapper}
   */
  removeTransition: function (name) {
    var node = this.node(); //node 可能为null

    if (!node) return this;
    var ns; //点地图chart.clear() 先clear的icon 再clear effect。

    if (name && (ns = _Transition["default"].d3_transitionNamespace(name))) {
      node[ns] && delete node[ns];
      return this;
    } // remove all animator


    for (ns in node) {
      // ie8及以下DOM Element、window对象没有hasOwnProperty方法
      if (!Object.prototype.hasOwnProperty.call(node, ns) || ns.indexOf(TRANSITION_PREFIX) < 0) continue;
      node[ns] && delete node[ns];
    }

    return this;
  },
  removeEffectTransition: function () {
    return this.removeTransition(_Constants["default"].EFFECT_KEY);
  }
});

var _default = ElementWrapper;
exports["default"] = _default;

var transformParser = function (transformStr) {
  var translate, rotate, scale;
  translate = transformStr.match(/translate\(\s*([\d|.|e|-]+)(?:[,\s]*)([\d|.|e|-]*)\s*\)/i);
  translate && translate.shift();
  rotate = transformStr.match(/rotate\(\s*([\d|.|e|-]+[degratun]*)(?:[,\s]*)([\d|.|e|-]*)(?:[,\s]*)([\d|.|e|-]*)\s*\)/i);
  rotate = rotate && rotate[1] || 0;
  scale = transformStr.match(/scale\(\s*([\d|.|e|-]+)\s*\)/i);
  scale = scale && +scale[1] || 1;
  return {
    translate: translate,
    rotate: rotate,
    scale: scale
  };
};

exports.transformParser = transformParser;

/***/ }),
/* 39 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by Yuqian on 2017/2/7.
 */
var _default = {
  PADDING: '0.25rem',
  WEEKEND_COLOR: 'rgba(169, 195, 200, 0.1)',
  OUTLINE: {
    'fill': 'none',
    'stroke': 'rgba(207, 207, 207, 1)',
    'stroke-width': 1
  },
  TWEENLINE: {
    'fill': 'none',
    'stroke': 'rgba(207, 207, 207, 0.6)',
    // 'stroke': 'red',
    'stroke-width': 1
  },
  INNERLINE: {
    'fill': 'none',
    'stroke': 'rgba(207, 207, 207, 0.6)',
    // 'stroke': 'green',
    'stroke-width': 0.5
  },
  THUMB_WIDTH: 14,
  THUMB_FILTER: {
    dx: 0,
    dy: 0,
    opacity: 0.15,
    deviation: 3,
    r: 0 / 255,
    g: 0 / 255,
    b: 0 / 255
  },
  SLIDER_STYLE: {
    'fill': '#8E8E8E',
    'fill-opacity': 0.7,
    'height': 4,
    'rx': 3,
    'ry': 3
  },
  SLIDER_BACKGROUND_WIDTH: [18, 120],
  // sliderBackground的最大最小值
  SLIDER_BACKGROUND_STYLE: {
    'fill': '#9D9D9D',
    'fill-opacity': 0.2,
    'height': 4,
    'rx': 3,
    'ry': 3
  },
  MINUS_PATH: {
    size: [24, 24],
    graphic: {
      cursor: 'pointer',
      fill: '#8E8E8E',
      'fill-opacity': 0.7,
      d: 'M19,13 L19,11 L5,11 L5,13Z'
    }
  },
  PLUS_PATH: {
    size: [24, 24],
    graphic: {
      cursor: 'pointer',
      fill: '#8E8E8E',
      'fill-opacity': 0.7,
      d: 'M13,5 L13,11 L19,11 L19,13 L13,13 L13,19 L11,19 L11,13 L5,13 L5,11 L11,11 L11,5 L13,5 Z'
    }
  },
  MOUSE_EVENT_PATH: {
    size: [24, 24],
    graphic: {
      cursor: 'pointer',
      fill: '#FFFFFF',
      'fill-opacity': 0,
      d: 'M0,0 L0,24 L24,24 L24,0 L0,0Z'
    }
  }
};
exports["default"] = _default;

/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getLinearFormatTicks = getLinearFormatTicks;
exports.getFormatFunc = getFormatFunc;
exports.getLogTicks = getLogTicks;
exports.getLinearTicks = getLinearTicks;
exports.getLinearTicksWithMin = getLinearTicksWithMin;
exports.getLinearTicksWithMax = getLinearTicksWithMax;
exports.getIntegerNiceDomain = getIntegerNiceDomain;
exports.isValidLinearInterval = isValidLinearInterval;
exports.getLinearNiceInterval = getLinearNiceInterval;
exports.getLinearValidInterval = getLinearValidInterval;
exports.getPercentValidInterval = getPercentValidInterval;
exports.getLogValidInterval = getLogValidInterval;
exports.getFixedDomain = getFixedDomain;
exports.getEmptyDataDomain = getEmptyDataDomain;
exports.isInDomainValue = isInDomainValue;
exports.hasVisibleSery = hasVisibleSery;
exports.getForecast = getForecast;
exports.isFromZeroAxis = isFromZeroAxis;
exports.isUseMaxHeight = isUseMaxHeight;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function getLinearFormatTicks(props) {
  var formatFunc = getFormatFunc(props.formatObj);
  var ticks = getLinearTicks(props);
  return ticks.map(function (tick) {
    return formatFunc(tick);
  });
}

function getFormatFunc(formatObj) {
  return typeof formatObj === 'function' ? formatObj : function (value) {
    return value;
  };
}

function getLogTicks(min, max, logBase, interval) {
  var ticks = [];
  var step = Math.pow(logBase, interval);

  while (min <= max) {
    ticks.push(min);
    min = _BaseUtils["default"].accMul(min, step);
  }

  return ticks;
}

function getLinearTicks(props) {
  var options = props.options,
      min = props.min,
      max = props.max,
      interval = props.interval;

  if ((0, _CoreUtils.hasDefined)(options.tickInterval)) {
    if ((0, _CoreUtils.hasDefined)(options.min)) {
      return getLinearTicksWithMin(options.min, max, interval);
    }

    if ((0, _CoreUtils.hasDefined)(options.max)) {
      return getLinearTicksWithMax(min, options.max, interval);
    }
  }

  return getLinearTicksWithMin(min, max, interval);
}

function getLinearTicksWithMin(min, max, interval) {
  var ticks = [];

  while (min <= max) {
    ticks.push(min);
    min = _BaseUtils["default"].accAdd(min, interval);
  }

  return ticks;
}

function getLinearTicksWithMax(min, max, interval) {
  var ticks = [];

  while (max >= min) {
    ticks.unshift(max);
    max = _BaseUtils["default"].accAdd(max, -interval);
  }

  return ticks;
}

function getIntegerNiceDomain(min, max, interval) {
  min = _BaseUtils["default"].accMul(Math.floor(min / interval), interval);
  max = _BaseUtils["default"].accMul(Math.ceil(max / interval), interval);
  return [min, max];
}

function isValidLinearInterval(min, max, interval) {
  if (interval == null) {
    return false;
  }

  return Math.abs((max - min) / interval) <= _Constants["default"].MAX_TICKS_NUM;
}

function getLinearNiceInterval(min, max, count, type) {
  var span = max - min;
  var step = Math.pow(10, Math.floor(Math.log(span / count) / Math.LN10));
  var err = count / span * step;

  if (err <= 0.15) {
    step *= 10;
  } else if (err <= 0.35) {
    step *= 5;
  } else if (err <= 0.75) {
    step *= 2;
  }

  if (type && type === _component.ComponentCst.DATE_AXIS_COMPONENT) {
    step = Math.max(step, _Constants["default"].MIN_TIME_AXIS_INTERVAL);
  }

  return step;
}

function getLinearValidInterval(props) {
  var min = props.min,
      max = props.max,
      interval = props.interval,
      count = props.count,
      type = props.type;

  if (isValidLinearInterval(min, max, interval)) {
    return interval;
  }

  return getLinearNiceInterval(min, max, count, type);
}

function getPercentValidInterval(min, max, interval) {
  if (interval == null) {
    return _Constants["default"].DEFAULT_PERCENT_INTERVAL;
  }

  if (Math.abs((max - min) / interval) > _Constants["default"].MAX_TICKS_NUM) {
    return (max - min) / _Constants["default"].MAX_TICKS_NUM;
  }

  return interval;
}

function getLogValidInterval(min, max, logBase, interval) {
  if (interval == null) {
    return _Constants["default"].DEFAULT_LOG_INTERVAL;
  }

  if (min * Math.pow(logBase, interval * _Constants["default"].MAX_TICKS_NUM) < max) {
    return _BaseUtils["default"].log(logBase, max / min) / _Constants["default"].MAX_TICKS_NUM;
  }

  return interval;
}

function getFixedDomain(customDomain, zoomDomain, isBaseAxis) {
  if (isBaseAxis && zoomDomain && zoomDomain.length === 2) {
    var min, max;
    min = parseFloat(zoomDomain[0] || customDomain[0]);
    max = parseFloat(zoomDomain[1] || customDomain[1]);
    min = isNaN(min) ? null : min;
    max = isNaN(max) ? null : max;

    if (min && max) {
      var tmp = min;
      min = Math.min(min, max);
      max = Math.max(tmp, max);
    }

    return [min, max];
  }

  return customDomain;
}

function getEmptyDataDomain(interval) {
  var _Constants$EMPTY_DATA = _Constants["default"].EMPTY_DATA_DOMAIN,
      min = _Constants$EMPTY_DATA[0],
      max = _Constants$EMPTY_DATA[1];

  if (interval && !isNaN(interval)) {
    max = max * Math.pow(10, Math.floor(Math.log(interval) / Math.LN10));
  }

  return [min, max];
}

function isInDomainValue(domain, value) {
  var min = Math.min.apply(Math, domain);
  var max = Math.max.apply(Math, domain);
  return value >= min && value <= max;
}

function hasVisibleSery(series) {
  for (var i = 0, len = series.length; i < len; i++) {
    if (series[i].visible) {
      return true;
    }
  }

  return false;
}

function getForecast(series) {
  var isVisibleSeries = hasVisibleSery(series);
  var forecast = [0, 0];

  for (var i = 0, len = series.length; i < len; i++) {
    if (series[i].visible || !isVisibleSeries) {
      var trendLine = series[i].options.trendLine;

      if (trendLine && trendLine.period && trendLine.period.length === 2) {
        var _trendLine$period = trendLine.period,
            prePeriod = _trendLine$period[0],
            afterPeriod = _trendLine$period[1];
        forecast[0] = Math.min(forecast[0] || 0, prePeriod);
        forecast[1] = Math.max(forecast[1] || 0, afterPeriod);
      }
    }
  }

  return forecast;
}

function isFromZeroAxis(axis) {
  if (axis.isAxisReversed()) {
    return Math.abs(axis._domain[1]) < 1e-6;
  }

  return Math.abs(axis._domain[0]) < 1e-6;
}

function isUseMaxHeight(isHorizontal, isInverted) {
  if (isInverted) {
    return !isHorizontal;
  }

  return isHorizontal;
}

/***/ }),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getXYSizeString = getXYSizeString;
exports.calculateTextDim = calculateTextDim;
exports.propMap = exports.DATA_OUTLIER = exports.DATA_MIN = exports.DATA_Q1 = exports.DATA_MEDIAN = exports.DATA_Q3 = exports.DATA_MAX = exports.DATA_NUMBER = exports.LEVEL = exports.PROGRESS = exports.DURATION = exports.FINISHTIME = exports.STARTTIME = exports.PROCESSES = exports.TO = exports.FROM = exports.ARRIVALRATE = exports.PERCENT = exports.VALUE = exports.DESCRIPTION = exports.SIZE = exports.NAME = exports.Y = exports.X = exports.CATEGORY = exports.SERIES = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/3/6.
 * 标签内容的计算，从series里拿出来
 */
var LABEL_NAME_VALUE_GAP = 0.02;
var LABEL_GAP = 2;
var SERIES = '{SERIES}';
exports.SERIES = SERIES;
var CATEGORY = '{CATEGORY}';
exports.CATEGORY = CATEGORY;
var X = '{X}';
exports.X = X;
var Y = '{Y}';
exports.Y = Y;
var NAME = '{NAME}';
exports.NAME = NAME;
var SIZE = '{SIZE}';
exports.SIZE = SIZE;
var DESCRIPTION = '{DESCRIPTION}';
exports.DESCRIPTION = DESCRIPTION;
var VALUE = '{VALUE}';
exports.VALUE = VALUE;
var PERCENT = '{PERCENT}';
exports.PERCENT = PERCENT;
var ARRIVALRATE = '{ARRIVALRATE}';
exports.ARRIVALRATE = ARRIVALRATE;
var FROM = '{FROM.NAME}';
exports.FROM = FROM;
var TO = '{TO.NAME}';
exports.TO = TO;
var PROCESSES = '{PROCESSES}';
exports.PROCESSES = PROCESSES;
var STARTTIME = '{STARTTIME}';
exports.STARTTIME = STARTTIME;
var FINISHTIME = '{FINISHTIME}';
exports.FINISHTIME = FINISHTIME;
var DURATION = '{DURATION}';
exports.DURATION = DURATION;
var PROGRESS = '{PROGRESS}';
exports.PROGRESS = PROGRESS;
var LEVEL = '{LEVEL}';
exports.LEVEL = LEVEL;
var DATA_NUMBER = '{DATA_NUMBER}';
exports.DATA_NUMBER = DATA_NUMBER;
var DATA_MAX = '{DATA_MAX}';
exports.DATA_MAX = DATA_MAX;
var DATA_Q3 = '{DATA_Q3}';
exports.DATA_Q3 = DATA_Q3;
var DATA_MEDIAN = '{DATA_MEDIAN}';
exports.DATA_MEDIAN = DATA_MEDIAN;
var DATA_Q1 = '{DATA_Q1}';
exports.DATA_Q1 = DATA_Q1;
var DATA_MIN = '{DATA_MIN}';
exports.DATA_MIN = DATA_MIN;
var DATA_OUTLIER = '{DATA_OUTLIER}';
exports.DATA_OUTLIER = DATA_OUTLIER;
var propMap = {};
exports.propMap = propMap;
["name", "category", "processes", "startTime", "finishTime", "duration", "progress", "level", "arrivalRate"].map(function (prop) {
  var key = '{' + prop.toUpperCase() + '}';
  propMap[key] = [prop, prop + 'Format'];
});
propMap[VALUE] = ['originalValue', 'valueFormat'];
propMap[SERIES] = ['seriesName', 'seriesFormat'];
propMap[PERCENT] = ['percentage', 'percentFormat'];

function getXYSizeString(point, formatter, identifier) {
  var options = point.options;

  var xString = _BaseUtils["default"].format(options.x, formatter.XFormat);

  var yString = _BaseUtils["default"].format(options.y, formatter.YFormat);

  var sizeString = options.size == '-' ? '-' : _BaseUtils["default"].format(options.size, formatter.sizeFormat);
  var text = '';

  if (identifier.indexOf(X) != -1 || identifier.indexOf(Y) != -1) {
    text = '(';

    if (identifier.indexOf(X) != -1) {
      text += xString;

      if (identifier.indexOf(Y) != -1) {
        text = text + ',' + yString;
      }

      text += ')';
    } else {
      text += yString;
      text += ')';
    }

    text += _Constants["default"].BLANK_VALUE_PERCENTAGE;
  }

  if (identifier.indexOf(SIZE) != -1 && sizeString != '-') {
    text += sizeString;
  }

  return text;
}

function calculateTextDim(labelContent, point) {
  var outsideDim = labelContent && (labelContent.nameLabelContent || labelContent.valueLabelContent);

  if (outsideDim && point.series.type == 'funnel') {
    return _calculateFunnelOutSideTextDim(point, labelContent);
  } else {
    var width = 0,
        height = 0;

    if (labelContent && labelContent.length) {
      for (var i = 0, count = labelContent.length; i < count; i++) {
        var dim = labelContent[i].dim;
        width = Math.max(width, dim.width);
        height += dim.height;
      }

      height += (count - 1) * LABEL_GAP;
    }

    return {
      width: width,
      height: height
    };
  }
}

function _calculateFunnelOutSideTextDim(point, labelContent) {
  var width = 0;
  var height = 0;
  var gapWidth = 0;

  if (labelContent.nameLabelContent) {
    var dim = labelContent.nameLabelContent.dim;
    width += dim.width;
    height = Math.max(height, dim.height);
  }

  if (labelContent.valueLabelContent) {
    var dim = labelContent.valueLabelContent.dim;
    width += dim.width;
    height = Math.max(height, dim.height);
  }

  if (labelContent.nameLabelContent && labelContent.valueLabelContent) {
    var funnel = point.series,
        vanchart = funnel.vanchart,
        plotBounds = vanchart.bounds;
    gapWidth = plotBounds.width * LABEL_NAME_VALUE_GAP;
    width += gapWidth;
  }

  return {
    width: width,
    height: height,
    nameValueGap: gapWidth
  };
}

/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.gradualLocation = gradualLocation;
exports.createGradientBackground = createGradientBackground;

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function gradualLocation(location) {
  var x1, y1, x2, y2;
  x1 = y1 = x2 = y2 = '0%';

  switch (location) {
    case _Constants["default"].BOTTOM_TO_TOP:
      y1 = '100%';
      break;

    case _Constants["default"].TOP_TO_BOTTOM:
      y2 = '100%';
      break;

    case _Constants["default"].LEFT_TO_RIGHT:
      x2 = '100%';
      break;

    case _Constants["default"].RIGHT_TO_LEFT:
      x1 = '100%';
      break;
  }

  return {
    x1: x1,
    y1: y1,
    x2: x2,
    y2: y2
  };
}

function createGradientBackground(target, key, renderer, color) {
  var toPercent = function (n) {
    return n * 100 + '%';
  };

  var x1 = toPercent(color.x1),
      x2 = toPercent(color.x2),
      y1 = toPercent(color.y1),
      y2 = toPercent(color.y2);
  var attrs = {
    'x1': x1,
    'y1': y1,
    'x2': x2,
    'y2': y2
  };
  var stop1 = {
    'offset': '0%',
    'stop-color': color.startColor
  };
  var stop2 = {
    'offset': '100%',
    'stop-color': color.endColor
  };
  target[key] = target[key] || renderer.colorGradient(attrs, [stop1, stop2]);
  return renderer.toPatternProperty(target[key]);
}

/***/ }),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/*! Hammer.JS - v2.0.7 - 2016-04-22
 * http://hammerjs.github.io/
 *
 * Copyright (c) 2016 Jorik Tangelder;
 * Licensed under the MIT license */


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Browser = _interopRequireDefault(__webpack_require__(8));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
var TEST_ELEMENT = document.createElement('div');
var TYPE_FUNCTION = 'function';
var MOUSE_UP_DOWN = 'mousedown mouseup pointerdown pointerup MSPointerDown MSPointerUp';

var _preventDefault = function (e) {
  if (e.type && MOUSE_UP_DOWN.indexOf(e.type) != -1) {
    //bi那边不能prevent
    return;
  }

  if (e.preventDefault) {
    e.preventDefault();
  } else {
    e.returnValue = false;
  }

  return this;
};

var ie8 = !window.SVGSVGElement;
var round = Math.round;
var abs = Math.abs;
var now = Date.now;
/**
 * set a timeout with a given scope
 * @param {Function} fn
 * @param {Number} timeout
 * @param {Object} context
 * @returns {number}
 */

function setTimeoutContext(fn, timeout, context) {
  return setTimeout(bindFn(fn, context), timeout);
}
/**
 * if the argument is an array, we want to execute the fn on each entry
 * if it aint an array we don't want to do a thing.
 * this is used by all the methods that accept a single and array argument.
 * @param {*|Array} arg
 * @param {String} fn
 * @param {Object} [context]
 * @returns {Boolean}
 */


function invokeArrayArg(arg, fn, context) {
  if (Array.isArray(arg)) {
    each(arg, context[fn], context);
    return true;
  }

  return false;
}
/**
 * walk objects and arrays
 * @param {Object} obj
 * @param {Function} iterator
 * @param {Object} context
 */


function each(obj, iterator, context) {
  var i;

  if (!obj) {
    return;
  }

  if (obj.forEach) {
    obj.forEach(iterator, context);
  } else if (obj.length !== undefined) {
    i = 0;

    while (i < obj.length) {
      iterator.call(context, obj[i], i, obj);
      i++;
    }
  } else {
    for (i in obj) {
      obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
    }
  }
}
/**
 * wrap a method with a deprecation warning and stack trace
 * @param {Function} method
 * @param {String} name
 * @param {String} message
 * @returns {Function} A new function wrapping the supplied method.
 */


function deprecate(method, name, message) {
  var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\n' + message + ' AT \n';
  return function () {
    var e = new Error('get-stack-trace');
    var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, '').replace(/^\s+at\s+/gm, '').replace(/^Object.<anonymous>\s*\(/gm, '{anonymous}()@') : 'Unknown Stack Trace'; // var log = window.console && (window.console.warn || window.console.log);
    // if (log) {
    //     log.call(window.console, deprecationMessage, stack);
    // }

    return method.apply(this, arguments);
  };
}
/**
 * extend object.
 * means that properties in dest will be overwritten by the ones in src.
 * @param {Object} target
 * @param {...Object} objects_to_assign
 * @returns {Object} target
 */


var assign;

if (typeof Object.assign !== 'function') {
  assign = function assign(target) {
    if (target === undefined || target === null) {
      throw new TypeError('Cannot convert undefined or null to object');
    }

    var output = Object(target);

    for (var index = 1; index < arguments.length; index++) {
      var source = arguments[index];

      if (source !== undefined && source !== null) {
        for (var nextKey in source) {
          if (source.hasOwnProperty(nextKey)) {
            output[nextKey] = source[nextKey];
          }
        }
      }
    }

    return output;
  };
} else {
  assign = Object.assign;
}
/**
 * extend object.
 * means that properties in dest will be overwritten by the ones in src.
 * @param {Object} dest
 * @param {Object} src
 * @param {Boolean} [merge=false]
 * @returns {Object} dest
 */


var extend = deprecate(function extend(dest, src, merge) {
  var keys = Object.keys(src);
  var i = 0;

  while (i < keys.length) {
    if (!merge || merge && dest[keys[i]] === undefined) {
      dest[keys[i]] = src[keys[i]];
    }

    i++;
  }

  return dest;
}, 'extend', 'Use `assign`.');
/**
 * merge the values from src in the dest.
 * means that properties that exist in dest will not be overwritten by src
 * @param {Object} dest
 * @param {Object} src
 * @returns {Object} dest
 */

var merge = deprecate(function merge2(dest, src) {
  // CHART-13227 如果命名为merge，IE8下会将原有merge代替这个fn
  return extend(dest, src, true);
}, 'merge', 'Use `assign`.');
/**
 * simple class inheritance
 * @param {Function} child
 * @param {Function} base
 * @param {Object} [properties]
 */

function inherit(child, base, properties) {
  var baseP = base.prototype,
      childP;
  childP = child.prototype = Object.create(baseP);
  childP.constructor = child;
  childP._super = baseP;

  if (properties) {
    assign(childP, properties);
  }
}
/**
 * simple function bind
 * @param {Function} fn
 * @param {Object} context
 * @returns {Function}
 */


function bindFn(fn, context) {
  return function boundFn() {
    return fn.apply(context, arguments);
  };
}
/**
 * let a boolean value also be a function that must return a boolean
 * this first item in args will be used as the context
 * @param {Boolean|Function} val
 * @param {Array} [args]
 * @returns {Boolean}
 */


function boolOrFn(val, args) {
  if (typeof val == TYPE_FUNCTION) {
    return val.apply(args ? args[0] || undefined : undefined, args);
  }

  return val;
}
/**
 * use the val2 when val1 is undefined
 * @param {*} val1
 * @param {*} val2
 * @returns {*}
 */


function ifUndefined(val1, val2) {
  return val1 === undefined ? val2 : val1;
}
/**
 * addEventListener with multiple events at once
 * @param {EventTarget} target
 * @param {String} types
 * @param {Function} handler
 */


function addEventListeners(target, types, handler) {
  each(splitStr(types), function (type) {
    if (target.addEventListener) {
      // IE9开始支持addEventListener和wheel，同时保留了非标准的事件mousewheel
      // IE9-IE11中"onwheel" in target返回false,为BUG,在Edge中已修复:https://connect.microsoft.com/IE/Feedback/Details/768199
      target.addEventListener(type, handler, false);
    } else if (target.attachEvent) {
      if (type == 'wheel') {
        type = 'mousewheel';
      }

      target.attachEvent('on' + type, handler);
    }
  });
  return this;
}
/**
 * removeEventListener with multiple events at once
 * @param {EventTarget} target
 * @param {String} types
 * @param {Function} handler
 */


function removeEventListeners(target, types, handler) {
  each(splitStr(types), function (type) {
    if (target.removeEventListener) {
      target.removeEventListener(type, handler, false);
    } else if (target.detachEvent) {
      if (type == 'wheel') {
        type = 'mousewheel';
      }

      target.detachEvent('on' + type, handler);
    }
  });
}
/**
 * find if a node is in the given parent
 * @method hasParent
 * @param {HTMLElement} node
 * @param {HTMLElement} parent
 * @return {Boolean} found
 */


function hasParent(node, parent) {
  while (node) {
    if (node == parent) {
      return true;
    }

    node = node.parentNode;
  }

  return false;
}
/**
 * small indexOf wrapper
 * @param {String} str
 * @param {String} find
 * @returns {Boolean} found
 */


function inStr(str, find) {
  return str.indexOf(find) > -1;
}
/**
 * split string on whitespace
 * @param {String} str
 * @returns {Array} words
 */


function splitStr(str) {
  return str.trim().split(/\s+/g);
}
/**
 * find if a array contains the object using indexOf or a simple polyFill
 * @param {Array} src
 * @param {String} find
 * @param {String} [findByKey]
 * @return {Boolean|Number} false when not found, or the index
 */


function inArray(src, find, findByKey) {
  if (src.indexOf && !findByKey) {
    return src.indexOf(find);
  } else {
    var i = 0;

    while (i < src.length) {
      if (findByKey && src[i][findByKey] == find || !findByKey && src[i] === find) {
        return i;
      }

      i++;
    }

    return -1;
  }
}
/**
 * convert array-like objects to real arrays
 * @param {Object} obj
 * @returns {Array}
 */


function toArray(obj) {
  return Array.prototype.slice.call(obj, 0);
}
/**
 * unique array with objects based on a key (like 'id') or just by the array's value
 * @param {Array} src [{id:1},{id:2},{id:1}]
 * @param {String} [key]
 * @param {Boolean} [sort=False]
 * @returns {Array} [{id:1},{id:2}]
 */


function uniqueArray(src, key, sort) {
  var results = [];
  var values = [];
  var i = 0;

  while (i < src.length) {
    var val = key ? src[i][key] : src[i];

    if (inArray(values, val) < 0) {
      results.push(src[i]);
    }

    values[i] = val;
    i++;
  }

  if (sort) {
    if (!key) {
      results = results.sort();
    } else {
      results = results.sort(function sortUniqueArray(a, b) {
        return a[key] > b[key];
      });
    }
  }

  return results;
}
/**
 * get the prefixed property
 * @param {Object} obj
 * @param {String} property
 * @returns {String|Undefined} prefixed
 */


function prefixed(obj, property) {
  if (false) {}

  var prefix, prop;
  var camelProp = property.charAt(0).toUpperCase() + property.slice(1);
  var i = 0;

  while (i < VENDOR_PREFIXES.length) {
    prefix = VENDOR_PREFIXES[i];
    prop = prefix ? prefix + camelProp : property;

    if (prop in obj) {
      return prop;
    }

    i++;
  }

  return undefined;
}
/**
 * get a unique id
 * @returns {number} uniqueId
 */


var _uniqueId = 1;

function uniqueId() {
  return _uniqueId++;
}
/**
 * get the window object of an element
 * @param {HTMLElement} element
 * @returns {DocumentView|Window}
 */


function getWindowForElement(element) {
  var doc = element.ownerDocument || element;
  return doc.defaultView || doc.parentWindow || window;
}

var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
var SUPPORT_TOUCH = ('ontouchstart' in window);
var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined && !_Browser["default"].ios;
var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
var INPUT_TYPE_TOUCH = 'touch';
var INPUT_TYPE_PEN = 'pen';
var INPUT_TYPE_MOUSE = 'mouse';
var INPUT_TYPE_KINECT = 'kinect';
var COMPUTE_INTERVAL = 25;
var INPUT_START = 1;
var INPUT_MOVE = 2;
var INPUT_END = 4;
var INPUT_CANCEL = 8;
var DIRECTION_NONE = 1;
var DIRECTION_LEFT = 2;
var DIRECTION_RIGHT = 4;
var DIRECTION_UP = 8;
var DIRECTION_DOWN = 16;
var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
var PROPS_XY = ['x', 'y'];
var PROPS_CLIENT_XY = ['clientX', 'clientY'];
/**
 * create new input type manager
 * @param {Manager} manager
 * @param {Function} callback
 * @returns {Input}
 * @constructor
 */

function Input(manager, callback) {
  var self = this;
  this.manager = manager;
  this.callback = callback;
  this.element = manager.element;
  this.target = manager.options.inputTarget; // smaller wrapper around the handler, for the scope and the enabled state of the manager,
  // so when disabled the input events are completely bypassed.

  this.domHandler = function (ev) {
    if (boolOrFn(manager.options.enable, [manager])) {
      self.handler(ev);
    }
  };

  this.init();
}

Input.prototype = {
  /**
   * should handle the inputEvent data and trigger the callback
   * @virtual
   */
  handler: function () {},

  /**
   * bind the events
   */
  init: function () {
    this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
    this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
    this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler); //TODO CHART-1238
  },

  /**
   * unbind the events
   */
  destroy: function () {
    this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
    this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
    this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
  }
};
/**
 * create new input type manager
 * called by the Manager constructor
 * @param {VanHammer} manager
 * @returns {Input}
 */

function createInputInstance(manager) {
  var Type;
  var inputClass = manager.options.inputClass;

  if (inputClass) {
    Type = inputClass;
  } else if (SUPPORT_POINTER_EVENTS) {
    Type = PointerEventInput;
  } else if (SUPPORT_ONLY_TOUCH) {
    Type = TouchInput;
  } else if (!SUPPORT_TOUCH) {
    Type = MouseInput;
  } else {
    Type = TouchMouseInput;
  }

  return new Type(manager, inputHandler);
}
/**
 * handle input events
 * @param {Manager} manager
 * @param {String} eventType
 * @param {Object} input
 */


function inputHandler(manager, eventType, input) {
  var pointersLen = input.pointers.length;
  var changedPointersLen = input.changedPointers.length;
  var isFirst = eventType & INPUT_START && pointersLen - changedPointersLen === 0;
  var isFinal = eventType & (INPUT_END | INPUT_CANCEL) && pointersLen - changedPointersLen === 0;
  input.isFirst = !!isFirst;
  input.isFinal = !!isFinal;

  if (isFirst) {
    manager.session = {};
  } // source event is the normalized value of the domEvents
  // like 'touchstart, mouseup, pointerdown'


  input.eventType = eventType; // compute scale, rotation etc

  computeInputData(manager, input); // emit secret event

  manager.emit('hammer.input', input);
  manager.recognize(input);
  manager.session.prevInput = input;
}
/**
 * extend the data with some usable properties like scale, rotate, velocity etc
 * @param {Object} manager
 * @param {Object} input
 */


function computeInputData(manager, input) {
  var session = manager.session;
  var pointers = input.pointers;
  var pointersLength = pointers.length; // store the first input to calculate the distance and direction

  if (!session.firstInput) {
    session.firstInput = simpleCloneInputData(input);
  } // to compute scale and rotation we need to store the multiple touches


  if (pointersLength > 1 && !session.firstMultiple) {
    session.firstMultiple = simpleCloneInputData(input);
  } else if (pointersLength === 1) {
    session.firstMultiple = false;
  }

  var firstInput = session.firstInput;
  var firstMultiple = session.firstMultiple;
  var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
  var center = input.center = getCenter(pointers);
  input.timeStamp = now();
  input.deltaTime = input.timeStamp - firstInput.timeStamp;
  input.angle = getAngle(offsetCenter, center);
  input.distance = getDistance(offsetCenter, center);
  computeDeltaXY(session, input);
  input.offsetDirection = getDirection(input.deltaX, input.deltaY);
  var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
  input.overallVelocityX = overallVelocity.x;
  input.overallVelocityY = overallVelocity.y;
  input.overallVelocity = abs(overallVelocity.x) > abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y;
  input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
  input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
  input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers;
  computeIntervalInputData(session, input); // find the correct target

  var target = manager.element;

  if (hasParent(input.srcEvent.target, target)) {
    target = input.srcEvent.target;
  }

  input.target = target;
}

function computeDeltaXY(session, input) {
  var center = input.center;
  var offset = session.offsetDelta || {};
  var prevDelta = session.prevDelta || {};
  var prevInput = session.prevInput || {};

  if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
    prevDelta = session.prevDelta = {
      x: prevInput.deltaX || 0,
      y: prevInput.deltaY || 0
    };
    offset = session.offsetDelta = {
      x: center.x,
      y: center.y
    };
  }

  input.deltaX = prevDelta.x + (center.x - offset.x);
  input.deltaY = prevDelta.y + (center.y - offset.y);
}
/**
 * velocity is calculated every x ms
 * @param {Object} session
 * @param {Object} input
 */


function computeIntervalInputData(session, input) {
  var last = session.lastInterval || input,
      deltaTime = input.timeStamp - last.timeStamp,
      velocity,
      velocityX,
      velocityY,
      direction;

  if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
    var deltaX = input.deltaX - last.deltaX;
    var deltaY = input.deltaY - last.deltaY;
    var v = getVelocity(deltaTime, deltaX, deltaY);
    velocityX = v.x;
    velocityY = v.y;
    velocity = abs(v.x) > abs(v.y) ? v.x : v.y;
    direction = getDirection(deltaX, deltaY);
    session.lastInterval = input;
  } else {
    // use latest velocity info if it doesn't overtake a minimum period
    velocity = last.velocity;
    velocityX = last.velocityX;
    velocityY = last.velocityY;
    direction = last.direction;
  }

  input.velocity = velocity;
  input.velocityX = velocityX;
  input.velocityY = velocityY;
  input.direction = direction;
}
/**
 * create a simple clone from the input used for storage of firstInput and firstMultiple
 * @param {Object} input
 * @returns {Object} clonedInputData
 */


function simpleCloneInputData(input) {
  // make a simple copy of the pointers because we will get a reference if we don't
  // we only need clientXY for the calculations
  var pointers = [];
  var i = 0;

  while (i < input.pointers.length) {
    pointers[i] = {
      clientX: round(input.pointers[i].clientX),
      clientY: round(input.pointers[i].clientY)
    };
    i++;
  }

  return {
    timeStamp: now(),
    pointers: pointers,
    center: getCenter(pointers),
    deltaX: input.deltaX,
    deltaY: input.deltaY
  };
}
/**
 * get the center of all the pointers
 * @param {Array} pointers
 * @return {Object} center contains `x` and `y` properties
 */


function getCenter(pointers) {
  var pointersLength = pointers.length; // no need to loop when only one touch

  if (pointersLength === 1) {
    return {
      x: round(pointers[0].clientX),
      y: round(pointers[0].clientY)
    };
  }

  var x = 0,
      y = 0,
      i = 0;

  while (i < pointersLength) {
    x += pointers[i].clientX;
    y += pointers[i].clientY;
    i++;
  }

  return {
    x: round(x / pointersLength),
    y: round(y / pointersLength)
  };
}
/**
 * calculate the velocity between two points. unit is in px per ms.
 * @param {Number} deltaTime
 * @param {Number} x
 * @param {Number} y
 * @return {Object} velocity `x` and `y`
 */


function getVelocity(deltaTime, x, y) {
  return {
    x: x / deltaTime || 0,
    y: y / deltaTime || 0
  };
}
/**
 * get the direction between two points
 * @param {Number} x
 * @param {Number} y
 * @return {Number} direction
 */


function getDirection(x, y) {
  if (x === y) {
    return DIRECTION_NONE;
  }

  if (abs(x) >= abs(y)) {
    return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
  }

  return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
}
/**
 * calculate the absolute distance between two points
 * @param {Object} p1 {x, y}
 * @param {Object} p2 {x, y}
 * @param {Array} [props] containing x and y keys
 * @return {Number} distance
 */


function getDistance(p1, p2, props) {
  if (!props) {
    props = PROPS_XY;
  }

  var x = p2[props[0]] - p1[props[0]],
      y = p2[props[1]] - p1[props[1]];
  return Math.sqrt(x * x + y * y);
}
/**
 * calculate the angle between two coordinates
 * @param {Object} p1
 * @param {Object} p2
 * @param {Array} [props] containing x and y keys
 * @return {Number} angle
 */


function getAngle(p1, p2, props) {
  if (!props) {
    props = PROPS_XY;
  }

  var x = p2[props[0]] - p1[props[0]],
      y = p2[props[1]] - p1[props[1]];
  return Math.atan2(y, x) * 180 / Math.PI;
}
/**
 * calculate the rotation degrees between two pointersets
 * @param {Array} start array of pointers
 * @param {Array} end array of pointers
 * @return {Number} rotation
 */


function getRotation(start, end) {
  return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
}
/**
 * calculate the scale factor between two pointersets
 * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
 * @param {Array} start array of pointers
 * @param {Array} end array of pointers
 * @return {Number} scale
 */


function getScale(start, end) {
  return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
}

var MOUSE_INPUT_MAP = {
  mousedown: INPUT_START,
  mousemove: INPUT_MOVE,
  mouseup: INPUT_END
};
var MOUSE_ELEMENT_EVENTS = 'mousedown mousemove mouseout mouseover wheel';
var MOUSE_WINDOW_EVENTS = 'mousemove mouseup'; //ie8的bug,在document上mouseup不相应

if (ie8) {
  MOUSE_ELEMENT_EVENTS = 'mousedown mousemove mouseout mouseover mouseup wheel';
  MOUSE_WINDOW_EVENTS = 'mousemove';
}
/**
 * Mouse events input
 * @constructor
 * @extends Input
 */


function MouseInput() {
  this.evEl = MOUSE_ELEMENT_EVENTS;
  this.evWin = MOUSE_WINDOW_EVENTS;
  this.pressed = false; // mousedown state

  Input.apply(this, arguments);
}

inherit(MouseInput, Input, {
  /**
   * handle mouse events
   * @param {Object} ev
   */
  handler: function MEhandler(ev) {
    var data = {
      pointers: [ev],
      changedPointers: [ev],
      pointerType: INPUT_TYPE_MOUSE,
      srcEvent: ev
    };
    var eventType = MOUSE_INPUT_MAP[ev.type];
    var isLeftButton = ie8 ? ev.button === 1 : ev.button === 0; // on start we want to have the left mouse button down

    if (eventType & INPUT_START && isLeftButton) {
      this.pressed = true;
    }

    if (eventType & INPUT_MOVE && (ie8 ? !this.pressed : ev.which !== 1)) {
      eventType = INPUT_END;
    } // mouse must be down


    if (!this.pressed) {
      var eventType = ev.type;

      if (eventType.indexOf('wheel') != -1) {
        eventType = 'wheel';
      }

      var handlers = this.manager.handlers[eventType] && this.manager.handlers[eventType].slice();

      if (handlers && handlers.length) {
        var i = 0;

        while (i < handlers.length) {
          handlers[i](data);
          i++;
        }
      }

      return;
    }

    if (eventType & INPUT_END) {
      this.pressed = false;
    }

    this.callback(this.manager, eventType, data);
  }
});
var POINTER_INPUT_MAP = {
  pointerdown: INPUT_START,
  pointermove: INPUT_MOVE,
  pointerup: INPUT_END,
  pointercancel: INPUT_CANCEL,
  pointerout: INPUT_CANCEL
}; // in IE10 the pointer types is defined as an enum

var IE10_POINTER_TYPE_ENUM = {
  2: INPUT_TYPE_TOUCH,
  3: INPUT_TYPE_PEN,
  4: INPUT_TYPE_MOUSE,
  5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816

};
var _MOUSE_EVENTS = 'mousemove mouseout mouseover wheel';
var POINTER_ELEMENT_EVENTS = 'pointerdown wheel';
var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel mousemove mouseout mouseover'; // IE10 has prefixed support, and case-sensitive

if (window.MSPointerEvent && !window.PointerEvent) {
  POINTER_ELEMENT_EVENTS = 'MSPointerDown mousemove mouseout mouseover wheel';
  POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
}
/**
 * Pointer events input
 * @constructor
 * @extends Input
 */


function PointerEventInput() {
  this.evEl = POINTER_ELEMENT_EVENTS;
  this.evWin = POINTER_WINDOW_EVENTS;
  Input.apply(this, arguments);
  this.store = this.manager.session.pointerEvents = [];
}

inherit(PointerEventInput, Input, {
  /**
   * handle mouse events
   * @param {Object} ev
   */
  handler: function PEhandler(ev) {
    var store = this.store;
    var removePointer = false;
    var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
    var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
    var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
    var isTouch = pointerType == INPUT_TYPE_TOUCH; // get index of the event in the store

    var storeIndex = inArray(store, ev.pointerId, 'pointerId'); // start and mouse must be down

    if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
      if (storeIndex < 0) {
        store.push(ev);
        storeIndex = store.length - 1;
      }
    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
      removePointer = true;
    }

    var data = {
      pointers: store,
      changedPointers: [ev],
      pointerType: pointerType,
      srcEvent: ev
    }; // it not found, so the pointer hasn't been down (so it's probably a hover)

    if (storeIndex < 0) {
      var _evType = ev.type;
      _evType = _evType.indexOf("wheel") >= 0 ? "wheel" : _evType; // @chart-1112 IE下触发mousewheel需要替换成wheel才能被识别

      if (_MOUSE_EVENTS.indexOf(_evType) != -1) {
        var handlers = this.manager.handlers[_evType] && this.manager.handlers[_evType].slice();

        if (handlers && handlers.length) {
          var i = 0;

          while (i < handlers.length) {
            handlers[i](data);
            i++;
          }
        }
      }

      return;
    } // update the event in the store


    store[storeIndex] = ev;
    this.callback(this.manager, eventType, data);

    if (removePointer) {
      // remove from the store
      store.splice(storeIndex, 1);
    }
  }
});
var SINGLE_TOUCH_INPUT_MAP = {
  touchstart: INPUT_START,
  touchmove: INPUT_MOVE,
  touchend: INPUT_END,
  touchcancel: INPUT_CANCEL
};
var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
/**
 * Touch events input
 * @constructor
 * @extends Input
 */

function SingleTouchInput() {
  this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
  this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
  this.started = false;
  Input.apply(this, arguments);
}

inherit(SingleTouchInput, Input, {
  handler: function TEhandler(ev) {
    var type = SINGLE_TOUCH_INPUT_MAP[ev.type]; // should we handle the touch events?

    if (type === INPUT_START) {
      this.started = true;
    }

    if (!this.started) {
      return;
    }

    var touches = normalizeSingleTouches.call(this, ev, type); // when done, reset the started state

    if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
      this.started = false;
    }

    this.callback(this.manager, type, {
      pointers: touches[0],
      changedPointers: touches[1],
      pointerType: INPUT_TYPE_TOUCH,
      srcEvent: ev
    });
  }
});
/**
 * @this {TouchInput}
 * @param {Object} ev
 * @param {Number} type flag
 * @returns {undefined|Array} [all, changed]
 */

function normalizeSingleTouches(ev, type) {
  var all = toArray(ev.touches);
  var changed = toArray(ev.changedTouches);

  if (type & (INPUT_END | INPUT_CANCEL)) {
    all = uniqueArray(all.concat(changed), 'identifier', true);
  }

  return [all, changed];
}

var TOUCH_INPUT_MAP = {
  touchstart: INPUT_START,
  touchmove: INPUT_MOVE,
  touchend: INPUT_END,
  touchcancel: INPUT_CANCEL
};
var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
/**
 * Multi-user touch events input
 * @constructor
 * @extends Input
 */

function TouchInput() {
  this.evTarget = TOUCH_TARGET_EVENTS;
  this.targetIds = {};
  Input.apply(this, arguments);
}

inherit(TouchInput, Input, {
  handler: function MTEhandler(ev) {
    var type = TOUCH_INPUT_MAP[ev.type];
    var touches = getTouches.call(this, ev, type);

    if (!touches) {
      return;
    }

    this.callback(this.manager, type, {
      pointers: touches[0],
      changedPointers: touches[1],
      pointerType: INPUT_TYPE_TOUCH,
      srcEvent: ev
    });
  }
});
/**
 * @this {TouchInput}
 * @param {Object} ev
 * @param {Number} type flag
 * @returns {undefined|Array} [all, changed]
 */

function getTouches(ev, type) {
  var allTouches = toArray(ev.touches);
  var targetIds = this.targetIds; // when there is only one touch, the process can be simplified

  if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
    targetIds[allTouches[0].identifier] = true;
    return [allTouches, allTouches];
  }

  var i,
      targetTouches,
      changedTouches = toArray(ev.changedTouches),
      changedTargetTouches = [],
      target = this.target; // get target touches from touches

  targetTouches = allTouches.filter(function (touch) {
    return hasParent(touch.target, target);
  }); // collect touches

  if (type === INPUT_START) {
    i = 0;

    while (i < targetTouches.length) {
      targetIds[targetTouches[i].identifier] = true;
      i++;
    }
  } // filter changed touches to only contain touches that exist in the collected target ids


  i = 0;

  while (i < changedTouches.length) {
    if (targetIds[changedTouches[i].identifier]) {
      changedTargetTouches.push(changedTouches[i]);
    } // cleanup removed touches


    if (type & (INPUT_END | INPUT_CANCEL)) {
      delete targetIds[changedTouches[i].identifier];
    }

    i++;
  }

  if (!changedTargetTouches.length) {
    return;
  }

  return [// merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
  uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true), changedTargetTouches];
}
/**
 * Combined touch and mouse input
 *
 * Touch has a higher priority then mouse, and while touching no mouse events are allowed.
 * This because touch devices also emit mouse events while doing a touch.
 *
 * @constructor
 * @extends Input
 */


var DEDUP_TIMEOUT = 2500;
var DEDUP_DISTANCE = 25;

function TouchMouseInput() {
  Input.apply(this, arguments);
  var handler = bindFn(this.handler, this);
  this.touch = new TouchInput(this.manager, handler);
  this.mouse = new MouseInput(this.manager, handler);
  this.primaryTouch = null;
  this.lastTouches = [];
}

inherit(TouchMouseInput, Input, {
  /**
   * handle mouse and touch events
   * @param {VanHammer} manager
   * @param {String} inputEvent
   * @param {Object} inputData
   */
  handler: function TMEhandler(manager, inputEvent, inputData) {
    var isTouch = inputData.pointerType == INPUT_TYPE_TOUCH,
        isMouse = inputData.pointerType == INPUT_TYPE_MOUSE;

    if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
      return;
    } // when we're in a touch event, record touches to  de-dupe synthetic mouse event


    if (isTouch) {
      recordTouches.call(this, inputEvent, inputData);
    } else if (isMouse && isSyntheticEvent.call(this, inputData)) {
      return;
    }

    this.callback(manager, inputEvent, inputData);
  },

  /**
   * remove the event listeners
   */
  destroy: function destroy() {
    this.touch.destroy();
    this.mouse.destroy();
  }
});

function recordTouches(eventType, eventData) {
  if (eventType & INPUT_START) {
    this.primaryTouch = eventData.changedPointers[0].identifier;
    setLastTouch.call(this, eventData);
  } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
    setLastTouch.call(this, eventData);
  }
}

function setLastTouch(eventData) {
  var touch = eventData.changedPointers[0];

  if (touch.identifier === this.primaryTouch) {
    var lastTouch = {
      x: touch.clientX,
      y: touch.clientY
    };
    this.lastTouches.push(lastTouch);
    var lts = this.lastTouches;

    var removeLastTouch = function () {
      var i = lts.indexOf(lastTouch);

      if (i > -1) {
        lts.splice(i, 1);
      }
    };

    setTimeout(removeLastTouch, DEDUP_TIMEOUT);
  }
}

function isSyntheticEvent(eventData) {
  var x = eventData.srcEvent.clientX,
      y = eventData.srcEvent.clientY;

  for (var i = 0; i < this.lastTouches.length; i++) {
    var t = this.lastTouches[i];
    var dx = Math.abs(x - t.x),
        dy = Math.abs(y - t.y);

    if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
      return true;
    }
  }

  return false;
}

var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined; // magical touchAction value

var TOUCH_ACTION_COMPUTE = 'compute';
var TOUCH_ACTION_AUTO = 'auto';
var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented

var TOUCH_ACTION_NONE = 'none';
var TOUCH_ACTION_PAN_X = 'pan-x';
var TOUCH_ACTION_PAN_Y = 'pan-y';
var TOUCH_ACTION_MAP = getTouchActionProps();
/**
 * Touch Action
 * sets the touchAction property or uses the js alternative
 * @param {Manager} manager
 * @param {String} value
 * @constructor
 */

function TouchAction(manager, value) {
  this.manager = manager;
  this.set(value);
}

TouchAction.prototype = {
  /**
   * set the touchAction value on the element or enable the polyfill
   * @param {String} value
   */
  set: function (value) {
    // find out the touch-action by the event handlers
    if (value == TOUCH_ACTION_COMPUTE) {
      value = this.compute();
    }

    if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
      // #touchActionAndriod
      this._shouldChangeTouchAction = value === TOUCH_ACTION_MANIPULATION;
      this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
    }

    this.actions = value.toLowerCase().trim();
  },

  /**
   * by Jeffrey
   * #touchActionAndriod
   */
  setTouchActionNone: function () {
    if (this._shouldChangeTouchAction) {
      // set to none
      // enable the pan event
      this.manager.element.style[PREFIXED_TOUCH_ACTION] = TOUCH_ACTION_NONE;
    }
  },
  recoverTouchAction: function () {
    if (this._shouldChangeTouchAction) {
      // recover to origin
      // enable scroll
      this.manager.element.style[PREFIXED_TOUCH_ACTION] = TOUCH_ACTION_MANIPULATION;
    }
  },

  /**
   * just re-set the touchAction value
   */
  update: function () {
    this.set(this.manager.options.touchAction);
  },

  /**
   * compute the value for the touchAction property based on the recognizer's settings
   * @returns {String} value
   */
  compute: function () {
    var actions = [];
    each(this.manager.recognizers, function (recognizer) {
      if (boolOrFn(recognizer.options.enable, [recognizer])) {
        actions = actions.concat(recognizer.getTouchAction());
      }
    });
    return cleanTouchActions(actions.join(' '));
  },

  /**
   * this method is called on each input cycle and provides the preventing of the browser behavior
   * @param {Object} input
   */
  preventDefaults: function (input) {
    var srcEvent = input.srcEvent;
    var hammerHandler = this.manager.options._handler; // @CHART-2281  ios端不支持touch-action:none，这边力学气泡图如果不preventDefault就导致长按时页面和气泡一起滑动的尴尬现象
    // 之前为什么对力学气泡图做特殊处理也因代码过于久远，不得而知了，这边先这么改，后面要是出现别的问题就再说吧

    var _prevent = hammerHandler && hammerHandler.preventDefault(input);

    if (_prevent || this.manager.session.prevented) {
      _preventDefault(srcEvent);

      return;
    }

    var actions = this.actions;
    var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];

    if (hasNone) {
      //do not prevent defaults if this is a tap gesture
      var isTapPointer = input.pointers.length === 1;
      var isTapMovement = input.distance < 2;
      var isTapTouchTime = input.deltaTime < 250;

      if (isTapPointer && isTapMovement && isTapTouchTime) {
        return;
      }
    }

    if (hasPanX && hasPanY) {
      return;
    } // if (hasNone ||
    //     (hasPanY && direction & DIRECTION_HORIZONTAL) ||
    //     (hasPanX && direction & DIRECTION_VERTICAL)) {
    //     return this.preventSrc(srcEvent);
    // }

  },

  /**
   * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
   * @param {Object} srcEvent
   */
  preventSrc: function (srcEvent) {
    this.manager.session.prevented = true;

    _preventDefault(srcEvent);
  }
};
/**
 * when the touchActions are collected they are not a valid value, so we need to clean things up. *
 * @param {String} actions
 * @returns {*}
 */

function cleanTouchActions(actions) {
  // none
  if (inStr(actions, TOUCH_ACTION_NONE)) {
    return TOUCH_ACTION_NONE;
  }

  var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
  var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y); // if both pan-x and pan-y are set (different recognizers
  // for different directions, e.g. horizontal pan but vertical swipe?)
  // we need none (as otherwise with pan-x pan-y combined none of these
  // recognizers will work, since the browser would handle all panning
  //部分的安卓机型，如果返回TOUCH_ACTION_NONE，页面滚动就没了。。。。
  //
  // 2017-04-27 Jeffrey:
  // 但是返回manipulation会导致blink上pan事件失效……
  // 只好要pan 的时候改回none试试→_→
  // 见上 setTouchActionNone / recoverTouchAction
  // #touchActionAndriod

  if (hasPanX && hasPanY) {
    return TOUCH_ACTION_MANIPULATION; // return TOUCH_ACTION_NONE;
  } // pan-x OR pan-y


  if (hasPanX || hasPanY) {
    return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
  } // manipulation


  if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
    return TOUCH_ACTION_MANIPULATION;
  }

  return TOUCH_ACTION_AUTO;
}

function getTouchActionProps() {
  if (!NATIVE_TOUCH_ACTION) {
    return false;
  }

  var touchMap = {};
  var cssSupports = window.CSS && window.CSS.supports;
  ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function (val) {
    // If css.supports is not supported but there is native touch-action assume it supports
    // all values. This is the case for IE 10 and 11.
    touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;
  });
  return touchMap;
}
/**
 * Recognizer flow explained; *
 * All recognizers have the initial state of POSSIBLE when a input session starts.
 * The definition of a input session is from the first input until the last input, with all it's movement in it. *
 * Example session for mouse-input: mousedown -> mousemove -> mouseup
 *
 * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
 * which determines with state it should be.
 *
 * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
 * POSSIBLE to give it another change on the next cycle.
 *
 *               Possible
 *                  |
 *            +-----+---------------+
 *            |                     |
 *      +-----+-----+               |
 *      |           |               |
 *   Failed      Cancelled          |
 *                          +-------+------+
 *                          |              |
 *                      Recognized       Began
 *                                         |
 *                                      Changed
 *                                         |
 *                                  Ended/Recognized
 */


var STATE_POSSIBLE = 1;
var STATE_BEGAN = 2;
var STATE_CHANGED = 4;
var STATE_ENDED = 8;
var STATE_RECOGNIZED = STATE_ENDED;
var STATE_CANCELLED = 16;
var STATE_FAILED = 32;
/**
 * Recognizer
 * Every recognizer needs to extend from this class.
 * @constructor
 * @param {Object} options
 */

function Recognizer(options) {
  this.options = assign({}, this.defaults, options || {});
  this.id = uniqueId();
  this.manager = null; // default is enable true

  this.options.enable = ifUndefined(this.options.enable, true);
  this.state = STATE_POSSIBLE;
  this.simultaneous = {};
  this.requireFail = [];
}

Recognizer.prototype = {
  /**
   * @virtual
   * @type {Object}
   */
  defaults: {},

  /**
   * set options
   * @param {Object} options
   * @return {Recognizer}
   */
  set: function (options) {
    assign(this.options, options); // also update the touchAction, in case something changed about the directions/enabled state

    this.manager && this.manager.touchAction.update();
    return this;
  },

  /**
   * recognize simultaneous with an other recognizer.
   * @param {Recognizer} otherRecognizer
   * @returns {Recognizer} this
   */
  recognizeWith: function (otherRecognizer) {
    if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
      return this;
    }

    var simultaneous = this.simultaneous;
    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);

    if (!simultaneous[otherRecognizer.id]) {
      simultaneous[otherRecognizer.id] = otherRecognizer;
      otherRecognizer.recognizeWith(this);
    }

    return this;
  },

  /**
   * drop the simultaneous link. it doesnt remove the link on the other recognizer.
   * @param {Recognizer} otherRecognizer
   * @returns {Recognizer} this
   */
  dropRecognizeWith: function (otherRecognizer) {
    if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
      return this;
    }

    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
    delete this.simultaneous[otherRecognizer.id];
    return this;
  },

  /**
   * recognizer can only run when an other is failing
   * @param {Recognizer} otherRecognizer
   * @returns {Recognizer} this
   */
  requireFailure: function (otherRecognizer) {
    if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
      return this;
    }

    var requireFail = this.requireFail;
    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);

    if (inArray(requireFail, otherRecognizer) === -1) {
      requireFail.push(otherRecognizer);
      otherRecognizer.requireFailure(this);
    }

    return this;
  },

  /**
   * drop the requireFailure link. it does not remove the link on the other recognizer.
   * @param {Recognizer} otherRecognizer
   * @returns {Recognizer} this
   */
  dropRequireFailure: function (otherRecognizer) {
    if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
      return this;
    }

    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
    var index = inArray(this.requireFail, otherRecognizer);

    if (index > -1) {
      this.requireFail.splice(index, 1);
    }

    return this;
  },

  /**
   * has require failures boolean
   * @returns {boolean}
   */
  hasRequireFailures: function () {
    return this.requireFail.length > 0;
  },

  /**
   * if the recognizer can recognize simultaneous with an other recognizer
   * @param {Recognizer} otherRecognizer
   * @returns {Boolean}
   */
  canRecognizeWith: function (otherRecognizer) {
    return !!this.simultaneous[otherRecognizer.id];
  },

  /**
   * You should use `tryEmit` instead of `emit` directly to check
   * that all the needed recognizers has failed before emitting.
   * @param {Object} input
   */
  emit: function (input) {
    var self = this;
    var state = this.state;

    function emit(event) {
      self.manager.emit(event, input);
    } // 'panstart' and 'panmove'


    if (state < STATE_ENDED) {
      emit(self.options.event + stateStr(state));
    }

    emit(self.options.event); // simple 'eventName' events

    if (input.additionalEvent) {
      // additional event(panleft, panright, pinchin, pinchout...)
      emit(input.additionalEvent);
    } // panend and pancancel


    if (state >= STATE_ENDED) {
      emit(self.options.event + stateStr(state));
    }
  },

  /**
   * Check that all the require failure recognizers has failed,
   * if true, it emits a gesture event,
   * otherwise, setup the state to FAILED.
   * @param {Object} input
   */
  tryEmit: function (input) {
    if (this.canEmit()) {
      return this.emit(input);
    } // it's failing anyway


    this.state = STATE_FAILED;
  },

  /**
   * can we emit?
   * @returns {boolean}
   */
  canEmit: function () {
    var i = 0;

    while (i < this.requireFail.length) {
      if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
        return false;
      }

      i++;
    }

    return true;
  },

  /**
   * update the recognizer
   * @param {Object} inputData
   */
  recognize: function (inputData) {
    // make a new copy of the inputData
    // so we can change the inputData without messing up the other recognizers
    var inputDataClone = assign({}, inputData); // is is enabled and allow recognizing?

    if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
      this.reset();
      this.state = STATE_FAILED;
      return;
    } // reset when we've reached the end


    if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
      this.state = STATE_POSSIBLE;
    }

    this.state = this.process(inputDataClone); // the recognizer has recognized a gesture
    // so trigger an event

    if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
      this.tryEmit(inputDataClone);
    }
  },

  /**
   * return the state of the recognizer
   * the actual recognizing happens in this method
   * @virtual
   * @param {Object} inputData
   * @returns {Const} STATE
   */
  process: function (inputData) {},
  // jshint ignore:line

  /**
   * return the preferred touch-action
   * @virtual
   * @returns {Array}
   */
  getTouchAction: function () {},

  /**
   * called when the gesture isn't allowed to recognize
   * like when another is being recognized or it is disabled
   * @virtual
   */
  reset: function () {}
};
/**
 * get a usable string, used as event postfix
 * @param {Const} state
 * @returns {String} state
 */

function stateStr(state) {
  if (state & STATE_CANCELLED) {
    return 'cancel';
  } else if (state & STATE_ENDED) {
    return 'end';
  } else if (state & STATE_CHANGED) {
    return 'move';
  } else if (state & STATE_BEGAN) {
    return 'start';
  }

  return '';
}
/**
 * direction cons to string
 * @param {Const} direction
 * @returns {String}
 */


function directionStr(direction) {
  if (direction == DIRECTION_DOWN) {
    return 'down';
  } else if (direction == DIRECTION_UP) {
    return 'up';
  } else if (direction == DIRECTION_LEFT) {
    return 'left';
  } else if (direction == DIRECTION_RIGHT) {
    return 'right';
  }

  return '';
}
/**
 * get a recognizer by name if it is bound to a manager
 * @param {Recognizer|String} otherRecognizer
 * @param {Recognizer} recognizer
 * @returns {Recognizer}
 */


function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
  var manager = recognizer.manager;

  if (manager) {
    return manager.get(otherRecognizer);
  }

  return otherRecognizer;
}
/**
 * This recognizer is just used as a base for the simple attribute recognizers.
 * @constructor
 * @extends Recognizer
 */


function AttrRecognizer() {
  Recognizer.apply(this, arguments);
}

inherit(AttrRecognizer, Recognizer, {
  /**
   * @namespace
   * @memberof AttrRecognizer
   */
  defaults: {
    /**
     * @type {Number}
     * @default 1
     */
    pointers: 1
  },

  /**
   * Used to check if it the recognizer receives valid input, like input.distance > 10.
   * @memberof AttrRecognizer
   * @param {Object} input
   * @returns {Boolean} recognized
   */
  attrTest: function (input) {
    var optionPointers = this.options.pointers;
    return optionPointers === 0 || input.pointers.length === optionPointers;
  },

  /**
   * Process the input and return the state for the recognizer
   * @memberof AttrRecognizer
   * @param {Object} input
   * @returns {*} State
   */
  process: function (input) {
    var state = this.state;
    var eventType = input.eventType;
    var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
    var isValid = this.attrTest(input); // on cancel input and we've recognized before, return STATE_CANCELLED

    if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
      return state | STATE_CANCELLED;
    } else if (isRecognized || isValid) {
      if (eventType & INPUT_END) {
        return state | STATE_ENDED;
      } else if (!(state & STATE_BEGAN)) {
        return STATE_BEGAN;
      }

      return state | STATE_CHANGED;
    }

    return STATE_FAILED;
  }
});
/**
 * Pan
 * Recognized when the pointer is down and moved in the allowed direction.
 * @constructor
 * @extends AttrRecognizer
 */

function PanRecognizer() {
  AttrRecognizer.apply(this, arguments);
  this.pX = null;
  this.pY = null;
}

inherit(PanRecognizer, AttrRecognizer, {
  /**
   * @namespace
   * @memberof PanRecognizer
   */
  defaults: {
    event: 'pan',
    threshold: 10,
    pointers: 1,
    direction: DIRECTION_ALL
  },
  getTouchAction: function () {
    var direction = this.options.direction;
    var actions = [];

    if (direction & DIRECTION_HORIZONTAL) {
      actions.push(TOUCH_ACTION_PAN_Y);
    }

    if (direction & DIRECTION_VERTICAL) {
      actions.push(TOUCH_ACTION_PAN_X);
    }

    return actions;
  },
  directionTest: function (input) {
    var options = this.options;
    var hasMoved = true;
    var distance = input.distance;
    var direction = input.direction;
    var x = input.deltaX;
    var y = input.deltaY; //点击以后响应拖拽

    var _handler = this.manager.options._handler;

    var _pressed = _handler && _handler.preventDefault(input); // lock to axis?


    if (!(direction & options.direction)) {
      if (options.direction & DIRECTION_HORIZONTAL) {
        direction = x === 0 ? DIRECTION_NONE : x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
        hasMoved = x != this.pX;
        distance = Math.abs(input.deltaX);
      } else {
        direction = y === 0 ? DIRECTION_NONE : y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
        hasMoved = y != this.pY;
        distance = Math.abs(input.deltaY);
      }
    }

    input.direction = direction;
    return _pressed && hasMoved && distance > options.threshold && direction & options.direction;
  },
  attrTest: function (input) {
    return AttrRecognizer.prototype.attrTest.call(this, input) && (this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input));
  },
  emit: function (input) {
    this.pX = input.deltaX;
    this.pY = input.deltaY;
    var direction = directionStr(input.direction);

    if (direction) {
      input.additionalEvent = this.options.event + direction;
    }

    this._super.emit.call(this, input);
  }
});
/**
 * Pinch
 * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
 * @constructor
 * @extends AttrRecognizer
 */

function PinchRecognizer() {
  AttrRecognizer.apply(this, arguments);
}

inherit(PinchRecognizer, AttrRecognizer, {
  /**
   * @namespace
   * @memberof PinchRecognizer
   */
  defaults: {
    event: 'pinch',
    threshold: 0,
    pointers: 2
  },
  getTouchAction: function () {
    return [TOUCH_ACTION_NONE];
  },
  attrTest: function (input) {
    return this._super.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
  },
  emit: function (input) {
    if (input.scale !== 1) {
      var inOut = input.scale < 1 ? 'in' : 'out';
      input.additionalEvent = this.options.event + inOut;
    }

    this._super.emit.call(this, input);
  }
});
/**
 * Press
 * Recognized when the pointer is down for x ms without any movement.
 * @constructor
 * @extends Recognizer
 */

function PressRecognizer() {
  Recognizer.apply(this, arguments);
  this._timer = null;
  this._input = null;
}

inherit(PressRecognizer, Recognizer, {
  /**
   * @namespace
   * @memberof PressRecognizer
   */
  defaults: {
    event: 'press',
    pointers: 1,
    time: 251,
    // minimal time of the pointer to be pressed
    threshold: 9 // a minimal movement is ok, but keep it low

  },
  getTouchAction: function () {
    return [TOUCH_ACTION_AUTO];
  },
  process: function (input) {
    var options = this.options;
    var validPointers = input.pointers.length === options.pointers;
    var validMovement = input.distance < options.threshold;
    var validTime = input.deltaTime > options.time;
    this._input = input; // we only allow little movement
    // and we've reached an end event, so a tap is possible

    if (!validMovement || !validPointers || input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime) {
      this.reset();
    } else if (input.eventType & INPUT_START) {
      this.reset();
      this._timer = setTimeoutContext(function () {
        this.state = STATE_RECOGNIZED;
        this.tryEmit();
      }, options.time, this);
    } else if (input.eventType & INPUT_END) {
      return STATE_RECOGNIZED;
    }

    return STATE_FAILED;
  },
  reset: function () {
    clearTimeout(this._timer);
  },
  emit: function (input) {
    if (this.state !== STATE_RECOGNIZED) {
      return;
    }

    if (input && input.eventType & INPUT_END) {
      this.manager.emit(this.options.event + 'up', input);
    } else {
      this._input.timeStamp = now();
      this.manager.emit(this.options.event, this._input);
    }
  }
});
/**
 * Rotate
 * Recognized when two or more pointer are moving in a circular motion.
 * @constructor
 * @extends AttrRecognizer
 */

function RotateRecognizer() {
  AttrRecognizer.apply(this, arguments);
}

inherit(RotateRecognizer, AttrRecognizer, {
  /**
   * @namespace
   * @memberof RotateRecognizer
   */
  defaults: {
    event: 'rotate',
    threshold: 0,
    pointers: 2
  },
  getTouchAction: function () {
    return [TOUCH_ACTION_NONE];
  },
  attrTest: function (input) {
    return this._super.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
  }
});
/**
 * Swipe
 * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
 * @constructor
 * @extends AttrRecognizer
 */

function SwipeRecognizer() {
  AttrRecognizer.apply(this, arguments);
}

inherit(SwipeRecognizer, AttrRecognizer, {
  /**
   * @namespace
   * @memberof SwipeRecognizer
   */
  defaults: {
    event: 'swipe',
    threshold: 10,
    velocity: 0.3,
    direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
    pointers: 1
  },
  getTouchAction: function () {
    return PanRecognizer.prototype.getTouchAction.call(this);
  },
  attrTest: function (input) {
    var direction = this.options.direction;
    var velocity;

    if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
      velocity = input.overallVelocity;
    } else if (direction & DIRECTION_HORIZONTAL) {
      velocity = input.overallVelocityX;
    } else if (direction & DIRECTION_VERTICAL) {
      velocity = input.overallVelocityY;
    }

    return this._super.attrTest.call(this, input) && direction & input.offsetDirection && input.distance > this.options.threshold && input.maxPointers == this.options.pointers && abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
  },
  emit: function (input) {
    var direction = directionStr(input.offsetDirection);

    if (direction) {
      this.manager.emit(this.options.event + direction, input);
    }

    this.manager.emit(this.options.event, input);
  }
});
/**
 * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
 * between the given interval and position. The delay option can be used to recognize multi-taps without firing
 * a single tap.
 *
 * The eventData from the emitted event contains the property `tapCount`, which contains the amount of
 * multi-taps being recognized.
 * @constructor
 * @extends Recognizer
 */

function TapRecognizer() {
  Recognizer.apply(this, arguments); // previous time and center,
  // used for tap counting

  this.pTime = false;
  this.pCenter = false;
  this._timer = null;
  this._input = null;
  this.count = 0;
}

inherit(TapRecognizer, Recognizer, {
  /**
   * @namespace
   * @memberof PinchRecognizer
   */
  defaults: {
    event: 'tap',
    pointers: 1,
    taps: 1,
    interval: 300,
    // max time between the multi-tap taps
    time: 250,
    // max time of the pointer to be down (like finger on the screen)
    threshold: 9,
    // a minimal movement is ok, but keep it low
    posThreshold: 10 // a multi-tap can be a bit off the initial position

  },
  getTouchAction: function () {
    return [TOUCH_ACTION_MANIPULATION];
  },
  process: function (input) {
    var options = this.options;
    var validPointers = input.pointers.length === options.pointers;
    var validMovement = input.distance < options.threshold;
    var validTouchTime = input.deltaTime < options.time;
    this.reset();

    if (input.eventType & INPUT_START && this.count === 0) {
      return this.failTimeout();
    } // we only allow little movement
    // and we've reached an end event, so a tap is possible


    if (validMovement && validTouchTime && validPointers) {
      if (input.eventType != INPUT_END) {
        return this.failTimeout();
      }

      var validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true;
      var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
      this.pTime = input.timeStamp;
      this.pCenter = input.center;

      if (!validMultiTap || !validInterval) {
        this.count = 1;
      } else {
        this.count += 1;
      }

      this._input = input; // if tap count matches we have recognized it,
      // else it has began recognizing...

      var tapCount = this.count % options.taps;

      if (tapCount === 0) {
        // no failing requirements, immediately trigger the tap event
        // or wait as long as the multitap interval to trigger
        if (!this.hasRequireFailures()) {
          return STATE_RECOGNIZED;
        } else {
          this._timer = setTimeoutContext(function () {
            this.state = STATE_RECOGNIZED;
            this.tryEmit();
          }, options.interval, this);
          return STATE_BEGAN;
        }
      }
    }

    return STATE_FAILED;
  },
  failTimeout: function () {
    this._timer = setTimeoutContext(function () {
      this.state = STATE_FAILED;
    }, this.options.interval, this);
    return STATE_FAILED;
  },
  reset: function () {
    clearTimeout(this._timer);
  },
  emit: function () {
    if (this.state == STATE_RECOGNIZED) {
      this._input.tapCount = this.count;
      this.manager.emit(this.options.event, this._input);
    }
  }
});
/**
 * Simple way to create a manager with a default set of recognizers.
 * @param {HTMLElement} element
 * @param {Object} [options]
 * @constructor
 */

function VanHammer(element, options) {
  options = options || {};
  options.recognizers = ifUndefined(options.recognizers, VanHammer.defaults.preset);
  return new Manager(element, options);
}
/**
 * @const {string}
 */


VanHammer.VERSION = '2.0.7';
/**
 * default settings
 * @namespace
 */

VanHammer.defaults = {
  /**
   * set if DOM events are being triggered.
   * But this is slower and unused by simple implementations, so disabled by default.
   * @type {Boolean}
   * @default false
   */
  domEvents: false,

  /**
   * The value for the touchAction property/fallback.
   * When set to `compute` it will magically set the correct value based on the added recognizers.
   * @type {String}
   * @default compute
   */
  touchAction: TOUCH_ACTION_COMPUTE,

  /**
   * @type {Boolean}
   * @default true
   */
  enable: true,

  /**
   * EXPERIMENTAL FEATURE -- can be removed/changed
   * Change the parent input target element.
   * If Null, then it is being set the to main element.
   * @type {Null|EventTarget}
   * @default null
   */
  inputTarget: null,

  /**
   * force an input class
   * @type {Null|Function}
   * @default null
   */
  inputClass: null,

  /**
   * Default recognizer setup when calling `Hammer()`
   * When creating a new Manager these will be skipped.
   * @type {Array}
   */
  preset: [// RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
  [RotateRecognizer, {
    enable: false
  }], [PinchRecognizer, {
    enable: false
  }, ['rotate']], [SwipeRecognizer, {
    direction: DIRECTION_HORIZONTAL
  }], [PanRecognizer, {
    direction: DIRECTION_HORIZONTAL
  }, ['swipe']], [TapRecognizer], [TapRecognizer, {
    event: 'doubletap',
    taps: 2
  }, ['tap']], [PressRecognizer]],

  /**
   * Some CSS properties can be used to improve the working of Hammer.
   * Add them to this method and they will be set when creating a new Manager.
   * @namespace
   */
  cssProps: {
    /**
     * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
     * @type {String}
     * @default 'none'
     */
    userSelect: 'none',

    /**
     * Disable the Windows Phone grippers when pressing an element.
     * @type {String}
     * @default 'none'
     */
    touchSelect: 'none',

    /**
     * Disables the default callout shown when you touch and hold a touch target.
     * On iOS, when you touch and hold a touch target such as a link, Safari displays
     * a callout containing information about the link. This property allows you to disable that callout.
     * @type {String}
     * @default 'none'
     */
    touchCallout: 'none',

    /**
     * Specifies whether zooming is enabled. Used by IE10>
     * @type {String}
     * @default 'none'
     */
    contentZooming: 'none',

    /**
     * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
     * @type {String}
     * @default 'none'
     */
    userDrag: 'none',

    /**
     * Overrides the highlight color shown when the user taps a link or a JavaScript
     * clickable element in iOS. This property obeys the alpha value, if specified.
     * @type {String}
     * @default 'rgba(0,0,0,0)'
     */
    tapHighlightColor: 'rgba(0,0,0,0)'
  }
};
var STOP = 1;
var FORCED_STOP = 2;
/**
 * Manager
 * @param {HTMLElement} element
 * @param {Object} [options]
 * @constructor
 */

function Manager(element, options) {
  this.options = assign({}, VanHammer.defaults, options || {});
  this.options.inputTarget = this.options.inputTarget || element;
  this.handlers = {};
  this.session = {};
  this.recognizers = [];
  this.oldCssProps = {};
  this.element = element;
  this.input = createInputInstance(this);
  this.touchAction = new TouchAction(this, this.options.touchAction);
  toggleCssProps(this, true);
  each(this.options.recognizers, function (item) {
    var recognizer = this.add(new item[0](item[1]));
    item[2] && recognizer.recognizeWith(item[2]);
    item[3] && recognizer.requireFailure(item[3]);
  }, this);
}

Manager.prototype = {
  /**
   * set options
   * @param {Object} options
   * @returns {Manager}
   */
  set: function (options) {
    assign(this.options, options); // Options that need a little more setup

    if (options.touchAction) {
      this.touchAction.update();
    }

    if (options.inputTarget) {
      // Clean up existing event listeners and reinitialize
      this.input.destroy();
      this.input.target = options.inputTarget;
      this.input.init();
    }

    return this;
  },

  /**
   * stop recognizing for this session.
   * This session will be discarded, when a new [input]start event is fired.
   * When forced, the recognizer cycle is stopped immediately.
   * @param {Boolean} [force]
   */
  stop: function (force) {
    this.session.stopped = force ? FORCED_STOP : STOP;
  },

  /**
   * run the recognizers!
   * called by the inputHandler function on every movement of the pointers (touches)
   * it walks through all the recognizers and tries to detect the gesture that is being made
   * @param {Object} inputData
   */
  recognize: function (inputData) {
    var session = this.session;

    if (session.stopped) {
      return;
    } // run the touch-action polyfill


    this.touchAction.preventDefaults(inputData);
    var recognizer;
    var recognizers = this.recognizers; // this holds the recognizer that is being recognized.
    // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
    // if no recognizer is detecting a thing, it is set to `null`

    var curRecognizer = session.curRecognizer; // reset when the last recognizer is recognized
    // or when we're in a new session

    if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) {
      curRecognizer = session.curRecognizer = null;
    }

    var i = 0;

    while (i < recognizers.length) {
      recognizer = recognizers[i]; // find out if we are allowed try to recognize the input for this one.
      // 1.   allow if the session is NOT forced stopped (see the .stop() method)
      // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
      //      that is being recognized.
      // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
      //      this can be setup with the `recognizeWith()` method on the recognizer.

      if (session.stopped !== FORCED_STOP && ( // 1
      !curRecognizer || recognizer == curRecognizer || // 2
      recognizer.canRecognizeWith(curRecognizer))) {
        // 3
        recognizer.recognize(inputData);
      } else {
        recognizer.reset();
      } // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
      // current active recognizer. but only if we don't already have an active recognizer


      if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
        curRecognizer = session.curRecognizer = recognizer;
      }

      i++;
    }
  },

  /**
   * get a recognizer by its event name.
   * @param {Recognizer|String} recognizer
   * @returns {Recognizer|Null}
   */
  get: function (recognizer) {
    if (recognizer instanceof Recognizer) {
      return recognizer;
    }

    var recognizers = this.recognizers;

    for (var i = 0; i < recognizers.length; i++) {
      if (recognizers[i].options.event == recognizer) {
        return recognizers[i];
      }
    }

    return null;
  },

  /**
   * add a recognizer to the manager
   * existing recognizers with the same event name will be removed
   * @param {Recognizer} recognizer
   * @returns {Recognizer|Manager}
   */
  add: function (recognizer) {
    if (invokeArrayArg(recognizer, 'add', this)) {
      return this;
    } // remove existing


    var existing = this.get(recognizer.options.event);

    if (existing) {
      this.remove(existing);
    }

    this.recognizers.push(recognizer);
    recognizer.manager = this;
    this.touchAction.update();
    return recognizer;
  },

  /**
   * remove a recognizer by name or instance
   * @param {Recognizer|String} recognizer
   * @returns {Manager}
   */
  remove: function (recognizer) {
    if (invokeArrayArg(recognizer, 'remove', this)) {
      return this;
    }

    recognizer = this.get(recognizer); // let's make sure this recognizer exists

    if (recognizer) {
      var recognizers = this.recognizers;
      var index = inArray(recognizers, recognizer);

      if (index !== -1) {
        recognizers.splice(index, 1);
        this.touchAction.update();
      }
    }

    return this;
  },

  /**
   * bind event
   * @param {String} events
   * @param {Function} handler
   * @returns {EventEmitter} this
   */
  on: function (events, handler) {
    if (events === undefined) {
      return;
    }

    if (handler === undefined) {
      return;
    }

    var handlers = this.handlers;
    each(splitStr(events), function (event) {
      handlers[event] = handlers[event] || [];
      handlers[event].push(handler);
    });
    return this;
  },

  /**
   * unbind event, leave emit blank to remove all handlers
   * @param {String} events
   * @param {Function} [handler]
   * @returns {EventEmitter} this
   */
  off: function (events, handler) {
    if (events === undefined) {
      return;
    }

    var handlers = this.handlers;
    each(splitStr(events), function (event) {
      if (!handler) {
        delete handlers[event];
      } else {
        handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
      }
    });
    return this;
  },

  /**
   * emit event to the listeners
   * @param {String} event
   * @param {Object} data
   */
  emit: function (event, data) {
    // we also want to trigger dom events
    if (this.options.domEvents) {
      triggerDomEvent(event, data);
    } // no handlers, so skip it all


    var handlers = this.handlers[event] && this.handlers[event].slice();

    if (!handlers || !handlers.length) {
      return;
    }

    data.type = event;

    data.preventDefault = function () {
      _preventDefault(data.srcEvent);
    };

    var i = 0;

    while (i < handlers.length) {
      handlers[i](data);
      i++;
    }
  },

  /**
   * destroy the manager and unbinds all events
   * it doesn't unbind dom events, that is the user own responsibility
   */
  destroy: function () {
    this.element && toggleCssProps(this, false);
    this.handlers = {};
    this.session = {};
    this.input.destroy();
    this.element = null;
  }
};
/**
 * add/remove the css properties as defined in manager.options.cssProps
 * @param {Manager} manager
 * @param {Boolean} add
 */

function toggleCssProps(manager, add) {
  var element = manager.element;

  if (!element.style) {
    return;
  }

  var prop;
  each(manager.options.cssProps, function (value, name) {
    prop = prefixed(element.style, name);

    if (add) {
      manager.oldCssProps[prop] = element.style[prop];
      element.style[prop] = value;
    } else {
      element.style[prop] = manager.oldCssProps[prop] || '';
    }
  });

  if (!add) {
    manager.oldCssProps = {};
  }
}
/**
 * trigger dom event
 * @param {String} event
 * @param {Object} data
 */


function triggerDomEvent(event, data) {
  var gestureEvent = document.createEvent('Event');
  gestureEvent.initEvent(event, true, true);
  gestureEvent.gesture = data;
  data.target.dispatchEvent(gestureEvent);
}

assign(VanHammer, {
  INPUT_START: INPUT_START,
  INPUT_MOVE: INPUT_MOVE,
  INPUT_END: INPUT_END,
  INPUT_CANCEL: INPUT_CANCEL,
  STATE_POSSIBLE: STATE_POSSIBLE,
  STATE_BEGAN: STATE_BEGAN,
  STATE_CHANGED: STATE_CHANGED,
  STATE_ENDED: STATE_ENDED,
  STATE_RECOGNIZED: STATE_RECOGNIZED,
  STATE_CANCELLED: STATE_CANCELLED,
  STATE_FAILED: STATE_FAILED,
  DIRECTION_NONE: DIRECTION_NONE,
  DIRECTION_LEFT: DIRECTION_LEFT,
  DIRECTION_RIGHT: DIRECTION_RIGHT,
  DIRECTION_UP: DIRECTION_UP,
  DIRECTION_DOWN: DIRECTION_DOWN,
  DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
  DIRECTION_VERTICAL: DIRECTION_VERTICAL,
  DIRECTION_ALL: DIRECTION_ALL,
  Manager: Manager,
  Input: Input,
  TouchAction: TouchAction,
  TouchInput: TouchInput,
  MouseInput: MouseInput,
  PointerEventInput: PointerEventInput,
  TouchMouseInput: TouchMouseInput,
  SingleTouchInput: SingleTouchInput,
  Recognizer: Recognizer,
  AttrRecognizer: AttrRecognizer,
  Tap: TapRecognizer,
  Pan: PanRecognizer,
  Swipe: SwipeRecognizer,
  Pinch: PinchRecognizer,
  Rotate: RotateRecognizer,
  Press: PressRecognizer,
  on: addEventListeners,
  off: removeEventListeners,
  each: each,
  merge: merge,
  extend: extend,
  assign: assign,
  inherit: inherit,
  bindFn: bindFn,
  prefixed: prefixed
});
var _default = VanHammer;
exports["default"] = _default;

/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Timer = _interopRequireDefault(__webpack_require__(70));

var _vMap = _interopRequireDefault(__webpack_require__(35));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/15.
 * NOTE 简要概述一下Transition的原理
 * 首先Transition用来实现动画,
 * 构造Transition需要指定:
 *  1. 对应的Elw(ElementWrapper), 用户动画过程中更新的元素包裹器,
 *  2. 动画名称name, 用于生成transition对应的唯一标识namespace  (用于生成transition对应的唯一标识namespace = d3_transitionNamespace(name))
 *  3. 动画过渡的属性transition(ease, delay, duration)
 *
 *  当创建一个transition之后, 会生成一个transition对象, 然后交给d3_transitionNode去处理:
 *      这一步主要将transition添加到node[ns]中, 这里值得注意的是, 一个node可以同时保留很多个ns, 每个ns上可以有可以保留多个transition
 *  transition生成之后可以通过指定方法修改transition对应的ease, delay, duration,
 *  也可以指定style, attr的目标值, 此时会自动生成插值函数添加到transition.tween中, 然后使用d3Timer生成一个计时器来定时刷新, 计算当前动画帧, 然后判断从tween里面取回调函数更新元素节点
 *
 */
var d3_transitionId = 0;

var Transition = function (elW, name, transition, noAnimation) {
  var id = nextTransitionID(),
      ns = d3_transitionNamespace(name);
  transition = transition || {
    time: Date.now(),
    // do not know why, css.linear is wrong
    ease: _BezierEasing["default"].ease('linear'),
    delay: 0,
    duration: 250
  };

  if (!elW.node) {
    //for elw not elementWrapper but element
    elW.node = function () {
      return elW;
    };
  }

  this.noAnimation = noAnimation || !(0, _EnvUtils.isSupportSVG)() || false;

  if (noAnimation) {
    transition.time = 0;
  }

  d3_transitionNode(elW.node(), ns, id, transition);
  this.elW = elW;
  this.namespace = ns;
  this.id = id;
  this.name = name;
};

_BaseUtils["default"].extend(Transition.prototype, {
  setAnimation: function (para) {
    for (var key in para) {
      this[key] && this[key](para[key]);
    }

    return this;
  },

  /**
   * !!!consider VML
   * @param name
   * @param tween !!!consider VML
   * @returns {*}
   */
  tween: function (name, tween) {
    var id = this.id,
        ns = this.namespace,
        node = this.elW.node();

    if (arguments.length < 2) {
      return node[ns][id].tween.get(name);
    }

    tween == null ? node[ns][id].tween.remove(name) : node[ns][id].tween.set(name, tween);
    return this;
  },
  attr: function (nameNS, value) {
    if (arguments.length < 2) {
      for (value in nameNS) {
        this.attr(value, nameNS[value]);
      }

      return this;
    }

    if (this.noAnimation) {
      this.elW.attr(nameNS, value);
      return this;
    }

    var interpolate = nameNS == "transform" ? _interpolator["default"].interpolateTransform : _interpolator["default"],
        name = nameNS;

    function attrNull() {
      this.removeAttribute(name);
    }

    function attrNullNS() {
      this.removeAttributeNS(name.space, name.local);
    }

    function attrTween(b) {
      return b == null ? attrNull : (b += "", function () {
        var a = this.getAttribute(name),
            i;
        return a !== b && (i = interpolate(a, b), function (t) {
          this.setAttribute(name, i(t));
        });
      });
    }

    function attrTweenNS(b) {
      return b == null ? attrNullNS : (b += "", function () {
        var a = this.getAttributeNS(name.space, name.local),
            i;
        return a !== b && (i = interpolate(a, b), function (t) {
          this.setAttributeNS(name.space, name.local, i(t));
        });
      });
    }

    return d3_transition_tween(this, "attr." + nameNS, value, name.local ? attrTweenNS : attrTween);
  },
  attrTween: function (nameNS, tween) {
    if (arguments.length < 2) {
      for (tween in nameNS) {
        this.attrTween(tween, nameNS[tween]);
      }

      return this;
    }

    var name = nameNS;

    if (this.noAnimation) {
      var f = tween.call(this.elW.node());
      this.elW.attr(name, f(1));
      return this;
    }

    function attrTween(d, i) {
      var f = tween.call(this, d, i, this.getAttribute(name));
      return f && function (t) {
        this.setAttribute(name, f(t));
      };
    }

    function attrTweenNS(d, i) {
      var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
      return f && function (t) {
        this.setAttributeNS(name.space, name.local, f(t));
      };
    }

    return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween);
  },
  style: function (name, value, priority) {
    var n = arguments.length;

    if (n < 3) {
      if (typeof name !== "string") {
        if (n < 2) {
          value = "";
        }

        for (priority in name) {
          this.style(priority, name[priority], value);
        }

        return this;
      }

      priority = "";
    }

    if (this.noAnimation) {
      this.elW.style && this.elW.style(name, value);
      return this;
    }

    function styleNull() {
      this.style.removeProperty(name);
    }

    function styleString(b) {
      return b == null ? styleNull : (b += "", function () {
        var a = d3_window(this).getComputedStyle(this, null).getPropertyValue(name),
            i;
        return a !== b && (i = (0, _interpolator["default"])(a, b), function (t) {
          // FixME IE9 throw error when pass an illegal style param
          try {
            this.style.setProperty(name, i(t), priority);
          } catch (e) {// console.warn("unValid style param!!")
          }
        });
      });
    }

    return d3_transition_tween(this, "style." + name, value, styleString);
  },
  styleTween: function (name, tween, priority) {
    if (arguments.length < 3) {
      priority = "";
    }

    if (this.noAnimation) {
      var f = tween.call(this.elW.node());
      this.elW.style(name, f(1));
      return this;
    }

    function styleTween(d, i) {
      var f = tween.call(this, d, i, d3_window(this).getComputedStyle(this, null).getPropertyValue(name));
      return f && function (t) {
        try {
          this.style.setProperty(name, f(t), priority);
        } catch (e) {}
      };
    }

    return this.tween("style." + name, styleTween);
  },
  remove: function () {
    var ns = this.namespace;
    return this.each("end.transition", function () {
      var p;

      if (this[ns].count < 2 && (p = this.parentNode)) {
        p.removeChild(this);
      }
    });
  },
  each: function (type, listener) {
    var node = this.elW.node(),
        id = this.id,
        ns = this.namespace;
    var transition = node[ns][id];

    (transition.event || (transition.event = _BaseUtils["default"].dispatch("start", "end", "interrupt"))).on(type, listener);

    return this;
  },
  ease: function (value) {
    var id = this.id,
        ns = this.namespace,
        node = this.elW.node();

    if (arguments.length < 1) {
      return node[ns][id].ease;
    }

    if (typeof value !== "function") {
      value = _BezierEasing["default"].ease.apply(null, arguments);
    }

    node[ns][id].ease = value;
    return this;
  },
  delay: function (value) {
    var id = this.id,
        ns = this.namespace,
        node = this.elW.node();

    if (arguments.length < 1) {
      return node[ns][id].delay;
    }

    value = +value;
    node[ns][id].delay = value;
    return this;
  },
  duration: function (value) {
    var id = this.id,
        ns = this.namespace,
        node = this.elW.node();

    if (arguments.length < 1) {
      return node[ns][id].duration;
    }

    value = Math.max(1, value);
    node[ns][id].duration = value;
    return this;
  },
  transition: function (para) {
    var id0 = this.id,
        ns = this.namespace,
        node = this.elW.node();
    var transition = node[ns][id0]; // 这里返回的transition 与当前transition应该属于同一个namespace

    return new Transition(this.elW, this.name, {
      time: transition.time,
      ease: transition.ease,
      delay: transition.delay + transition.duration,
      duration: transition.duration
    }, this.noAnimation).setAnimation(para);
  },
  animate: function (para) {
    return this.setAnimation(para);
  }
});

function d3_transition_tween(transition, name, value, tween) {
  var id = transition.id,
      ns = transition.namespace,
      value = tween(value);
  transition.elW.node()[ns][id].tween.set(name, value);
  return transition;
}

function d3_transitionNode(node, ns, id, inherit) {
  var lock = node[ns] || (node[ns] = {
    active: 0,
    count: 0
  }),
      transition = lock[id];

  if (!transition) {
    var time = inherit.time;
    transition = lock[id] = {
      tween: new _vMap["default"](),
      time: time,
      delay: inherit.delay,
      duration: inherit.duration,
      ease: inherit.ease
    };
    inherit = null;
    ++lock.count;
    (0, _Timer["default"])(function (elapsed) {
      var delay = transition.delay,
          duration,
          ease,
          timer = _Timer["default"].getActiveTimer(),
          tweened = [];

      timer.t = delay + time;

      if (delay <= elapsed) {
        return start(elapsed - delay);
      }

      timer.c = start;

      function start(elapsed) {
        if (lock.active > id) {
          return stop();
        }

        var active = lock[lock.active];

        if (active) {
          --lock.count;
          delete lock[lock.active];
          active.event && active.event.interrupt.call(node);
        }

        lock.active = id;
        transition.event && transition.event.start.call(node);
        transition.tween.forEach(function (key, value) {
          if (value = value.call(node)) {
            tweened.push(value);
          }
        });
        ease = transition.ease;
        duration = transition.duration;
        (0, _Timer["default"])(function () {
          timer.c = tick(elapsed || 1) ? _BaseUtils["default"].trueFn : tick;
          return 1;
        }, 0, time);
      }

      function tick(elapsed) {
        if (lock.active !== id || !node[ns]) {
          return 1;
        }

        var t = elapsed / duration,
            e = ease(t),
            n = tweened.length;

        while (n > 0) {
          tweened[--n].call(node, e);
        }

        if (t >= 1) {
          transition.event && transition.event.end.call(node);
          return stop();
        }
      }

      function stop() {
        if (--lock.count) {
          lock[id] = undefined; // delete lock[id];
        } else {
          node[ns] = undefined; // IE 11 兼容7下抛错: "对象不支持此操作"
          // delete node[ns]
        }

        return 1;
      }
    }, 0, time);
  }
}

function nextTransitionID() {
  return ++d3_transitionId;
}

function d3_transitionNamespace(name) {
  return name == null ? "__transition__" : "__transition_" + name + "__";
}

function d3_window(node) {
  return node && (node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView);
}

Transition.d3_transitionNamespace = d3_transitionNamespace;
Transition.nextTransitionID = nextTransitionID;
var _default = Transition;
exports["default"] = _default;

/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.FINE_CANVAS_RENDERER = exports.CANVAS_RENDERER = exports.VML_RENDERER = exports.SVG_RENDERER = void 0;
var SVG_RENDERER = "svg-renderer";
exports.SVG_RENDERER = SVG_RENDERER;
var VML_RENDERER = "vml-renderer";
exports.VML_RENDERER = VML_RENDERER;
var CANVAS_RENDERER = "canvas-renderer";
exports.CANVAS_RENDERER = CANVAS_RENDERER;
var FINE_CANVAS_RENDERER = "fine-canvas-renderer";
exports.FINE_CANVAS_RENDERER = FINE_CANVAS_RENDERER;

/***/ }),
/* 46 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isUseSeriesColorPoint = isUseSeriesColorPoint;
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _EnvUtils = __webpack_require__(2);

var _VanChartInterface = __webpack_require__(57);

var _helper = __webpack_require__(47);

var _CoreUtils = __webpack_require__(3);

var _ThemeConfig = __webpack_require__(17);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/2/19.
 * 数据点的抽象
 */
var NEGATIVE_COLOR = 'rgb(138, 138, 138)';

var Point = _Evented["default"].extend({
  vanChartType: 'point',
  initialize: function (options, series) {
    this.series = series;
    this.refresh(options || {});
  },
  refresh: function (options) {
    var series = this.series,
        vanchart = series.vanchart; //确定标记点颜色用

    this.originalColor = options.color;
    this.originalMarkerFillColor = options.marker && options.marker.fillColor;
    options = this.options = _BaseUtils["default"].createOptions(options, [series.options]);
    var isSeriesAcc = series.isSeriesAccumulated();
    var category = series.type === _Constants["default"].BAR_CHART ? options.y : options.x;
    var seriesName = series.name;
    this.category = isSeriesAcc ? seriesName : category;
    this.seriesName = isSeriesAcc ? category : seriesName;
    this.value = this.getTargetValue();
    this.originalValue = this.options[this.series.getTargetKey()];
    this.name = _BaseUtils["default"].pick(this.options.x, this.options.name); // point.categoryArray为数组

    this.categoryArray = _BaseUtils["default"].isArray(options.categoryArray) ? options.categoryArray.map(function (cate) {
      return cate;
    }) : [this.category];
    this.categoryArrayStr = _BaseUtils["default"].encodeCategoryArray(this.categoryArray); // 缓存起来，不用每次都重新算了

    if (series.type === _Constants["default"].LINE_MAP) {
      this.from = {
        name: options.from.name
      };
      this.to = {
        name: options.to.name
      };
    } //shine:y不能用value，因为value有可能是size（bubble chart）


    this.x = options.x;
    this.y = options.y; // 之前的版本计算百分比之类的都是用的y作为targetKey取值，现在 把y去掉，导致百分比之类的计算出错

    this.size = options.size;
    this.target = options.target; // 百分比圆环、滑槽仪表盘、试管仪表盘的目标值

    this.visible = true;
    this.isNull = series.isNullValue(this);
    this.points = isSeriesAcc ? series.points : vanchart.registerPointsPara(this); // try to eliminate properties in large mode
    // if (series.options.large) {
    //     return;
    // }
    // 点地图大数据模式需要geo

    if (options.drilldown && options.drilldown.geo) {
      var Geo = (0, _component.getComponent)(_component.ComponentCst.GEO_COMPONENT);
      this.geo = new Geo(options.drilldown.geo, _component.ComponentCst.GEO_COMPONENT, vanchart);
    }

    _BaseUtils["default"].calculateFontSizeWithScale(options.dataLabels && options.dataLabels.style);

    _BaseUtils["default"].calculateFontSizeWithScale(options.tooltip && options.tooltip.style); //@deprecated H5兼容,暂时不能删


    this.jsonHyperlink = options.jsonHyperlink;
    this.drillUpLink = options.drillUpLink; //todo 下周移动端发布以后删掉，暂时需要兼容

    this.hyperlink = options.hyperlink;
    this.location = _Constants["default"].BOTTOM_TO_TOP; // 图形的增长方向
  },
  // todo 重构这个方法 根据范围图例的值来计算颜色
  refreshPointColor: function () {
    var point = this,
        options = point.options,
        series = point.series,
        vanchart = series.vanchart;

    if (!series.isTreeSeries()) {
      //点的颜色：colors，范围图例，系列条件属性配色，点条件属性配色
      //标记点的颜色取的顺序：colors配色、plotOptions的标记点的颜色、范围图例、条件属性系列配色、条件属性系列标记点颜色、条件属性数据点的配色、条件属性数据点的标记点的配色
      var _opacity = options.opacity,
          _markerOpacity = options.opacity;
      var colorKey;

      if (series.type === _Constants["default"].STRUCTURE_CHART) {
        colorKey = this.level;
      } else {
        // 这边的options.name再createOptions的时候就跳过了？
        colorKey = series.isSeriesAccumulated() ? _BaseUtils["default"].pick(options.x, options.name, series.options.name) : series.name;
      } //默认配色


      var _color = vanchart.getDefaultSeriesColor(colorKey);

      var _markerColor = _color;

      if (options.marker) {
        options.marker = _BaseUtils["default"].clone(options.marker);
        _markerColor = options.marker.fillColor || _markerColor;
      } // 范围图例
      // large lineMap cannot use range


      if (!(series.type === _Constants["default"].LINE_MAP && series.options.large)) {
        var rangeLegend = vanchart.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT);

        if (rangeLegend) {
          _color = rangeLegend.getColorWithSize(this.getTargetValue(), series.options.large);
          _markerColor = _color;
          this.visible = !!_color;
        }
      } //系列条件属性配色


      _markerColor = series.originalColor || _markerColor;
      _markerColor = series.originalMarkerFillColor || _markerColor; //点条件属性配色

      _color = this.originalColor || series.originalColor || _color;
      _markerColor = this.originalColor || _markerColor;
      _markerColor = this.originalMarkerFillColor || _markerColor; //负气泡、bands等特殊的。

      if ((series.type === _Constants["default"].BUBBLE_CHART || series.type === _Constants["default"].FORCE_BUBBLE_CHART) && !rangeLegend) {
        if (point.getTargetValue() < 0 && point.options.displayNegative) {
          _color = options.color || NEGATIVE_COLOR;
        } else if (point.getTargetValue() < 0) {
          _color = null;
        }
      }

      var hexAlpha;

      if (_color) {
        hexAlpha = _ColorUtils["default"].getStandardColorAndOpacity(_color, _opacity);
        _color = hexAlpha.hex;
        _opacity = hexAlpha.alpha;
      }

      if (_markerColor) {
        hexAlpha = _ColorUtils["default"].getStandardColorAndOpacity(_markerColor, _markerOpacity);
        _markerColor = hexAlpha.hex;
        _markerOpacity = hexAlpha.alpha;
      }

      var marker = options.marker;

      if (marker) {
        marker.fillColor = _markerColor;
        marker.fillColorOpacity = _markerOpacity;
        marker.radius = isNaN(marker.radius) ? _Constants["default"].MARKER_RADIUS : marker.radius;
      }

      (0, _helper.refreshBoxMarkerColor)(options, _markerColor);
      _opacity = this.isGradualStyle() ? this._getGradualStyleOpacity() : _opacity;

      if (_color) {
        this.color = _color;
        this.opacity = _opacity;
        this.mouseOverColor = this.options.mouseOverColor || _ColorUtils["default"].getHighLightColor(_color);
        this.clickColor = _ColorUtils["default"].getClickColor(_color);
        this.clickOpacity = _opacity * 0.95;
      }

      this.borderColor = this.options.borderColor;
      this.borderOpacity = this.options.borderOpacity;
      (0, _helper.refreshBoxBorderColor)(point, this.color);
    }
  },
  _getGradualStyleOpacity: function () {
    return this.options.opacity || 1;
  },
  isGradualStyle: function () {
    return this.options.gradualStyle === _Constants["default"].STYLE_CUSTOM || this.series.isGradualStyle();
  },
  getTargetValue: function () {
    //兼容值可能是字符串的情况
    var value = this.options[this.series.getTargetKey()];
    var vanchart = this.series.vanchart;
    var geo = vanchart.getComponent(_component.ComponentCst.GEO_COMPONENT);

    if (geo) {
      return this.getMapTargetValue(value);
    }

    return this.getNumberValue(value);
  },
  getNumberValue: function (value) {
    // +'' = 0; isNaN('') = false
    if (isNaN(+value) || value == '') {
      if (this.series.isNullValue(this)) {
        return 0;
      }

      if (_BaseUtils["default"].isArray(value) || value && (0, _CoreUtils.hasDefined)(value.min) && (0, _CoreUtils.hasDefined)(value.max)) {
        var domain = (0, _helper.getPointDomain)(value, this.options.isDetailed);
        var total = 0;

        for (var i = 0, len = domain.length; i < len; i++) {
          if ((0, _CoreUtils.isNumberValue)(domain[i])) {
            total = +domain[i] + total;
          }
        }

        return total / domain.length;
      }

      return value;
    } else {
      return +value;
    }
  },
  getMapTargetValue: function (value) {
    var _this$series = this.series,
        vanchart = _this$series.vanchart,
        options = _this$series.options;
    var geo = vanchart.getComponent(_component.ComponentCst.GEO_COMPONENT);
    var isBubbleMap = geo || options.type === _Constants["default"].BUBBLE_CHART;
    var isRangeLegend = vanchart.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT); // 数据为''时，因为''== 0，
    // 1、导致范围图例计算数据范围时，将''当作0处理visible为true，
    // 2、气泡计算半径时，将''当作0处理了，但实际值为字符串类型的气泡不该画出来

    return (isRangeLegend || isBubbleMap) && value === '' ? '-' : value;
  },
  getLatLng: function (feature) {
    var lnglat = this.options.lnglat;

    if (!lnglat) {
      var geo = this.series.vanchart.getCurrentGeo();

      if (!feature) {
        feature = geo.getFeaturesByName(this.name, this.series.type);
        feature = feature && feature[0];
      }

      if (feature) {
        lnglat = geo.getDataPointLngLat(this, feature);
      }
    }

    return lnglat ? [lnglat[1], lnglat[0]] : null;
  },
  getStackPointPreSufPoint: function (point) {
    var series = point.series,
        stackKey = [series.type, series.stack, point.category].join('-');
    var preP,
        sufP,
        find = false;

    for (var dataIndex = 0, dataCount = point.points.length; dataIndex < dataCount; dataIndex++) {
      var p = point.points[dataIndex],
          ser = p.series,
          key = [ser.type, ser.stack, p.category].join('-');

      if (p == point) {
        find = true;
      } else if (key == stackKey && p.isVisible()) {
        if (find) {
          sufP = p;
          break;
        } else {
          preP = p;
        }
      }
    }

    return {
      pre: preP,
      suf: sufP
    };
  },
  _mapPointOnMouseState: function (isChosen, duration, ease, style) {
    var point = this,
        series = point.series,
        vanchart = series.vanchart;

    if (point.layers) {
      point.layers && point.layers.forEach(function (layer) {
        layer._onMouseState(isChosen, duration, ease, style);
      });
    }
  },

  /**
   * 获取point的分类，这里的分类指的是其对应的id，用于识别这个点，同时也是分类轴上的domain的取值。
   * !!!注意，使用tooltip的时候，其分类仍旧是point.category
   * @return {[type]} [description]
   */
  getCategory: function () {
    var series = this.series,
        isMultiCategoryBased = series.isMultiCategoryAxisBased();
    return isMultiCategoryBased ? this.categoryArrayStr : this.category;
  },
  isLogAxisValidValue: function () {
    var x = true,
        y = true;
    var xAxisOpt = this.series.xAxis.options,
        yAxisOpt = this.series.yAxis.options,
        options = this.options;

    if (xAxisOpt.log && options.x <= 0) {
      x = false;
    }

    if (yAxisOpt.log && options.y <= 0) {
      y = false;
    }

    return x && y;
  }
});

Point.include({
  /**
   * 判断数据点是否支持数据提示共享
   * @returns {options.tooltip|{formatter, enabled}|boolean|*}
   */
  isPointSupportTooltipShared: function () {
    var point = this,
        options = point.options,
        tooltip = options.tooltip,
        series = this.series,
        vanchart = series.vanchart,
        sharedAxis = vanchart.getSharedAxis();
    return tooltip && tooltip.shared && point.points && sharedAxis && series.supportTooltipShared();
  },
  _onPointMouseOver: function (ev) {
    var point = this,
        options = point.options,
        series = this.series,
        vanchart = series.vanchart;
    var hoverPoint = vanchart.hoverPoint,
        hoverSeries = vanchart.hoverSeries,
        hoverPoints = vanchart.hoverPoints,
        sharedAxis = vanchart.getSharedAxis();

    if (hoverPoint === point) {
      return;
    }

    var share = this.isPointSupportTooltipShared();
    var hoverSameCategory = hoverPoints && hoverPoints.length && point.getCategory() == hoverPoints[0].getCategory();

    if (share && hoverSameCategory && series.defaultMarker) {
      // 折线图默认标记点 数据点提示共享 同一个分类里鼠标移动。
      // 不return掉，会一直over-create-default-marker then out-delete-default-marker
      return;
    }

    if (series.isTreeSeries()) {
      series.fire('pointMouseOver', point); //@MOBILE-6474

      series.vanchart.showTooltip(point, ev);
      return;
    }

    hoverPoint && hoverPoint.fire('mouseout', ev);

    if (share) {
      var valid = vanchart.getValidPointsPara(point.getCategory()); //out要在over之前。否则，over series.createDefaultMarker then out delete
      // todo 共享数据点提示时，鼠标移至另一个分类下是，要将之前的hoverPoints的高亮去掉

      if (hoverPoints && hoverPoints.length && hoverPoints[0] != valid[0]) {
        hoverPoints[0]._onPointMouseOut.call(hoverPoints[0], ev); // 折线图无标记点的时候移到柱形图上 || 移到另一个分类上，之前选中点的标签得回到非选中状态


        hoverPoints[0].points.forEach(function (p) {
          p.series.defaultMarker && p.series.fire('pointMouseOut', p);
        });
      } // var max = valid   暂未用到


      valid.reduce(function (prev, curr) {
        curr.series._onPointMouseOver.call(curr, curr); //  这里的作用是让同类别的所有点触发mouseOver事件，因此传入的应该是对应的curr点！


        if (!prev) {
          return curr;
        }

        return curr.getTargetValue() > prev.getTargetValue() ? curr : prev;
      }, 0);

      if (sharedAxis && valid.length) {
        sharedAxis.drawHighlightBackground(valid);
      }

      series.vanchart.showSharedTooltip(point, ev);
      vanchart.hoverPoints = valid; // todo 这里记得更新一下hoverPoints，鼠标移除绘图区时清除highLight时会用到
    } else {
      vanchart.handler._removeHighlight(ev); //@CHART-1597:组合图中柱形图的鼠标悬浮不会移除折线图共享的高亮选中效果


      if (series.type === _Constants["default"].BOX_CHART) {
        point.outlierData = (0, _helper.selectOutlierData)(point, ev);
      }

      series.vanchart.showTooltip(point, ev);
      series.fire('pointMouseOver', point);

      if (hoverSeries != point.series) {
        hoverSeries && hoverSeries.fire('seriesUnChosen', ev);
        point.series.fire('mouseover', ev);
      }

      vanchart.hoverSeries = point.series;
      vanchart.hoverPoint = point;
    }
  },
  _onPointMouseMove: function (ev) {
    var point = this,
        options = point.options,
        series = this.series,
        vanchart = series.vanchart,
        sharedAxis = vanchart.getSharedAxis();
    var share = options.tooltip && options.tooltip.shared && point.points && sharedAxis && point.series.supportTooltipShared();
    share ? vanchart.showSharedTooltip(vanchart.hoverPoints && vanchart.hoverPoints[0], ev) : vanchart.showTooltip(vanchart.hoverPoint, ev);
  },
  _onPointMouseOut: function (ev) {
    var point = this,
        tooltip = point.options.tooltip;
    var series = this.series,
        vanchart = series.vanchart,
        sharedAxis = vanchart.getSharedAxis(),
        hoverPoint = vanchart.hoverPoint;

    if (series.isTreeSeries()) {
      series.fire('pointMouseOut', point);
      return;
    }

    if (tooltip && tooltip.shared && point.points && point.points.length && sharedAxis) {
      point.points.forEach(function (point) {
        //有图形||折线图无标记点时移除绘图区
        // PC端为了避免数据点提示共享情况下鼠标在数据点上移动出现point.mouseout后又mouseover的无聊举措，只有鼠标位置在vanchart.bounds之外才响应mouseout，
        // 移动端则不必考虑该问题
        var canFireMouseout = ev && !_BaseUtils["default"].containsPoint(vanchart.bounds, ev.containerPoint) || vanchart.isMobile();
        var fire = point.graphic || point.series.defaultMarker && canFireMouseout;
        fire && point.series.fire('pointMouseOut', point); // CHART-9090 与当前的面积图选中设计冲突, 先注释掉
        // point.series.fire('seriesUnChosen', ev);
      });
    } else {
      point.series.fire('pointMouseOut', point);
    } // @10418: 普通的事件中当前点即hoverPoint,
    // 但是存在特殊情况如页面刷新时鼠标悬浮点A, 然后自动数据提示, 触发点B的mouseover后, 此时点A mouseout导致点B的高亮不能被移除.


    if (hoverPoint && hoverPoint !== this) {
      hoverPoint.fire('mouseout', ev);
    }

    series.vanchart.hideTooltip();
  },
  _onPointTap: function (ev) {
    var point = this,
        series = this.series,
        vanchart = series.vanchart,
        hoverPoint = vanchart.hoverPoint;
    var visible = vanchart.isMap() && point.options.drilldown ? true : point.isVisible();

    if (!visible) {
      return;
    }

    if (vanchart.isMobileFlow) {
      // 防止流转到dom manager，然后fire hide
      ev.stop && ev.stop();
    } // mpie & treemap have no drill down in flow


    if (!vanchart.isMobileFlow() && series.isTreeSeries() && series.allowDrillDown(point)) {
      series.onPointTap(point);
    } //触发超链


    var srcEvent = ev.srcEvent;
    var touch = srcEvent.touches && (srcEvent.touches.length ? srcEvent.touches[0] : srcEvent.changedTouches[0]);

    if (touch) {
      //移动端clientY，clientX不在event上
      srcEvent.clientX = touch.clientX;
      srcEvent.clientY = touch.clientY;
    } //移动端的时候触发选中效果


    if (vanchart.isMobile()) {
      point.fire('mouseover', ev);
      point === hoverPoint && point.fire("mousemove", ev); //@CHART-1680 移动端数据点提示鼠标跟随
    }

    point.onClick(srcEvent);

    if (vanchart.allowDrillDown && vanchart.allowDrillDown(point)) {
      if (vanchart.isMobileFlow()) {
        vanchart.vancharts.holdDrillDownPoint(point);
      } else {
        vanchart.drillDown(point);
      }
    }
  },
  hasValidDataLabel: function () {
    var point = this;
    var hasLabel = point.labelPos && !isNaN(point.labelPos.x) && !isNaN(point.labelPos.y) && point.options.dataLabels && point.options.dataLabels.enabled;
    return point.series.visible && !point.isNull && point.visible && hasLabel;
  },
  clearPointEffect: function () {
    var point = this;

    _BaseUtils["default"].clearInterval(point.effectInterval);

    point.effectGraphic && point.effectGraphic.remove();
    point.effectGraphic = null;
    point.effectInterval = null;

    if (point.series && point.series.type === _Constants["default"].TREEMAP_CHART) {
      point.graphic && point.graphic.interrupt(_Constants["default"].SCALE_EXPAND_ANIMATION) && point.graphic.interrupt(_Constants["default"].SCALE_MINIFY_ANIMATION);
    }

    point.children && point.children.forEach(function (childPoint) {
      childPoint.clearPointEffect();
    });
  },
  isVisible: function () {
    var point = this;
    return point && point.visible && point.series.visible && !point.isNull;
  },
  getEffectTime: function () {
    var point = this;

    if ((0, _EnvUtils.isSupportSVG)() && point.isVisible() && point.options.effect && point.options.effect.enabled) {
      return point.series._getEffectTime(point);
    }

    return 0;
  },
  hasEffect: function () {
    return this.getEffectTime() > 0;
  },
  // dataLabels for gauge
  autoLabelColor: function (dataLabels) {
    var point = this;
    var series = point.series;
    var pointDataLabels = dataLabels || point.options.dataLabels;
    var isUseSeriesColor = pointDataLabels && isUseSeriesColorPoint(pointDataLabels.align, series.type, series.columnType);
    var seriesColor = this.getSeriesColor();
    return isUseSeriesColor ? seriesColor : '#ffffff';
  },
  getSeriesColor: function () {
    var point = this;

    if (point.options && point.options.marker && point.options.marker.fillColor) {
      return point.options.marker.fillColor;
    }

    return point.color;
  },
  _onPointPress: function (ev) {
    var point = this,
        series = this.series,
        vanchart = series.vanchart;
    var hoverPoint = vanchart.hoverPoint;

    if (hoverPoint) {
      series.onPointPress.call(point, ev);
    }
  },
  _onPointPressUp: function (ev) {
    var point = this,
        series = this.series,
        vanchart = series.vanchart;
    var hoverPoint = vanchart.hoverPoint;

    if (hoverPoint) {
      series.onPointPressUp.call(point, ev);

      hoverPoint._onPointTap(ev);
    }
  },
  onClick: function (ev) {
    var point = this,
        series = point.series,
        vanchart = series.vanchart,
        vancharts = vanchart.vancharts;
    var hyperlinkFunc = vancharts.doHyperlink;

    if (hyperlinkFunc) {
      var params = _BaseUtils["default"].extend({
        event: ev
      }, point);

      _BaseUtils["default"].getFormatterFunction(hyperlinkFunc)(params);

      vanchart.options.hyperLink && (0, _VanChartInterface.hideFullScreenChart)();
    }

    var pointOptions = point.options;
    var clickFunc = pointOptions.click || pointOptions.onClick;

    if (clickFunc) {
      var extendedPoint = _BaseUtils["default"].extend({
        tooltipText: vanchart.__tooltipText,
        event: ev
      }, point);

      if (vanchart.allowDrillDown && vanchart.allowDrillDown(point)) {
        extendedPoint.allowDrillType = 'down';
      }

      _BaseUtils["default"].getFormatterFunction(clickFunc).call(extendedPoint, ev);
    }
  },
  getEvents: function () {
    return {
      'mouseover': this._onPointMouseOver,
      'mouseout': this._onPointMouseOut,
      'mousemove': this._onPointMouseMove,
      'tap': this._onPointTap,
      'press': this._onPointPress,
      'pressup': this._onPointPressUp
    };
  },
  remove: function () {
    this.visible = false;
    this.graphic && this.graphic.remove();
    this.removeTextGraphic();
    this.moreLabelG && this.moreLabelG.remove();
    this.clearPointEffect();
    this.graphic = this.textGraphic = this.moreLabelG = this.leadLine = null;
  },

  /**
   * 数据点标签移除
   */
  removeTextGraphic: function () {
    if (this.textGraphic) {
      this.textGraphic.remove();
      this.textGraphic = null;
    }

    if (this.leadLine) {
      this.leadLine.remove();
      this.leadLine = null;
    }

    if (this.textBorderPath) {
      this.lineTriangleBorder && this.lineTriangleBorder.remove();
      this.lineTriangleBorderRect && this.lineTriangleBorderRect.remove();
      this.textBorderPath.remove();
      this.textBorderPath = this.lineTriangleBorder = this.lineTriangleBorderRect = null;
    }
  },
  // FIXME
  // itself is removed from parent.children
  // thus the name 'clearChild' is confused
  clearChild: function () {
    var point = this;

    if (point.parent) {
      var childs = point.parent.children;
      childs && childs.splice(_BaseUtils["default"].indexOf(childs, point), 1);
    }

    if (point.children) {
      var len = point.children.length;

      while (--len > -1) {
        point.children[len].clearChild();
      }
    }

    point.remove();
  },
  getPointBorderColor: function (borderColorOpt) {
    var point = this;
    var series = point.series;
    var vanchart = series.vanchart;

    if (borderColorOpt === _Constants["default"].AUTO) {
      return series._getBackgroundColorWithAlpha() || (0, _ThemeConfig.getThemeAutoValue)(borderColorOpt, 'pointBorderColor', vanchart.isDarkTheme());
    }

    return borderColorOpt;
  }
});

function isUseSeriesColorPoint(align, chartType, isColumnType) {
  // 气泡图、矩形树图、力学气泡图、堆积柱形雷达图中的point的标签不使用系列色，
  // 散点图和点地图中的point的标签使用系列色，其他图形的标签是否使用系列色根据align来判断
  var useSeriesColor = align === _Constants["default"].TOP || align === _Constants["default"].BOTTOM || align === _Constants["default"].OUTSIDE;

  if (isUnusedSeriesColorChart(chartType) || isColumnType) {
    useSeriesColor = false;
  } else if (isUseSeriesColorChart(chartType)) {
    useSeriesColor = true;
  }

  return useSeriesColor;
}

function isUseSeriesColorChart(chartType) {
  return chartType === _Constants["default"].SCATTER_CHART || chartType === _Constants["default"].POINT_MAP || chartType === _Constants["default"].LINE_CHART || chartType === _Constants["default"].AREA_CHART || chartType === _Constants["default"].RADAR_CHART;
}

function isUnusedSeriesColorChart(chartType) {
  return chartType === _Constants["default"].BUBBLE_CHART || chartType === _Constants["default"].TREEMAP_CHART || chartType === _Constants["default"].FORCE_BUBBLE_CHART;
}

var _default = Point;
exports["default"] = _default;

/***/ }),
/* 47 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getBoxBounds = getBoxBounds;
exports.getBoxRect = getBoxRect;
exports.getBoxInitRect = getBoxInitRect;
exports.getBoxLine = getBoxLine;
exports.getLinkLine = getLinkLine;
exports.getPointDomain = getPointDomain;
exports.getBoxDataResult = getBoxDataResult;
exports.refreshBoxMarkerColor = refreshBoxMarkerColor;
exports.refreshBoxBorderColor = refreshBoxBorderColor;
exports.findInteractiveMarker = findInteractiveMarker;
exports.hasValidNormalMarker = hasValidNormalMarker;
exports.hasValidOutlierMarker = hasValidOutlierMarker;
exports.selectOutlierData = selectOutlierData;
exports.clearMarker = clearMarker;
exports.updateMarker = updateMarker;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var NORMAL_MARKER_OPACITY = 0.6;
var OUTLIER_MARKER_OPACITY = 1;

function getBoxBounds(props) {
  var offset = props.offset,
      width = props.width,
      startPos = props.startPos,
      scale = props.scale,
      result = props.result,
      isInverted = props.isInverted;
  var maxPos = scale(result.max);
  var minPos = scale(result.min);

  if (isInverted) {
    return {
      x: minPos,
      y: startPos + offset - width / 2,
      width: Math.abs(maxPos - minPos),
      height: +width
    };
  } else {
    return {
      x: startPos + offset - width / 2,
      y: maxPos,
      width: width,
      height: Math.abs(maxPos - minPos)
    };
  }
}

function getBoxRect(props) {
  var offset = props.offset,
      width = props.width,
      startPos = props.startPos,
      scale = props.scale,
      result = props.result,
      isInverted = props.isInverted;
  var q3Pos = scale(result.q3);
  var q1Pos = scale(result.q1);

  if (isInverted) {
    return {
      x: Math.min(q1Pos, q3Pos),
      y: startPos + offset - width / 2,
      width: Math.abs(q1Pos - q3Pos),
      height: +width
    };
  }

  return {
    x: startPos + offset - width / 2,
    y: Math.min(q1Pos, q3Pos),
    width: width,
    height: Math.abs(q1Pos - q3Pos)
  };
}

function getBoxInitRect(props) {
  var offset = props.offset,
      width = props.width,
      startPos = props.startPos,
      midPos = props.midPos,
      isInverted = props.isInverted;

  if (isInverted) {
    return {
      x: midPos,
      y: startPos + offset - width / 2,
      width: 0,
      height: +width
    };
  }

  return {
    x: startPos + offset - width / 2,
    y: midPos,
    width: width,
    height: 0
  };
}

function getBoxLine(props) {
  var offset = props.offset,
      width = props.width,
      startPos = props.startPos,
      valuePos = props.valuePos,
      isInverted = props.isInverted;

  if (isInverted) {
    return {
      x1: valuePos,
      y1: startPos + offset - width / 2,
      x2: valuePos,
      y2: startPos + offset + width / 2
    };
  }

  return {
    x1: startPos + offset - width / 2,
    y1: valuePos,
    x2: startPos + offset + width / 2,
    y2: valuePos
  };
}

function getLinkLine(props) {
  var offset = props.offset,
      startPos = props.startPos,
      downPos = props.downPos,
      upPos = props.upPos,
      isInverted = props.isInverted;

  if (isInverted) {
    return {
      x1: downPos,
      y1: startPos + offset,
      x2: upPos,
      y2: startPos + offset
    };
  }

  return {
    x1: startPos + offset,
    y1: downPos,
    x2: startPos + offset,
    y2: upPos
  };
}

function getMedian(sorted) {
  if (_BaseUtils["default"].isArray(sorted) && sorted.length) {
    if (sorted.length % 2 === 0) {
      return (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2;
    } else {
      return sorted[(sorted.length + 1) / 2 - 1];
    }
  }
}

function getBoxDataResult(originValue, isDetailed) {
  var max, q3, median, q1, min, mid;
  var normal = [];
  var outlier = [];

  if (originValue == null) {
    return;
  }

  if (isDetailed) {
    var filtered = filterNotNumber(originValue);
    var numerical = convertToNumber(filtered);
    var sorted = sortDetailedData(numerical);

    if (sorted.length === 0) {
      return {};
    }

    if (sorted.length === 1) {
      median = q3 = q1 = sorted[0];
    } else {
      median = getMedian(sorted);

      if (sorted.length % 2 === 0) {
        q1 = getMedian(sorted.slice(0, Math.ceil(sorted.length / 2)));
        q3 = getMedian(sorted.slice(Math.floor(sorted.length / 2)));
      } else {
        q1 = getMedian(sorted.slice(0, Math.ceil(sorted.length / 2) - 1));
        q3 = getMedian(sorted.slice(Math.floor(sorted.length / 2) + 1));
      }
    }

    var link = _BaseUtils["default"].accMul(_BaseUtils["default"].accAdd(q3, -q1), 1.5);

    max = _BaseUtils["default"].accAdd(q3, link);
    min = _BaseUtils["default"].accAdd(q1, -link);

    for (var i = 0, len = sorted.length; i < len; i++) {
      if (sorted[i] < min || sorted[i] > max) {
        outlier.push(sorted[i]);
      } else {
        normal.push(sorted[i]);
      }
    }

    mid = (min + max) / 2;
    return {
      number: filtered.length,
      max: max,
      q3: q3,
      median: median,
      min: min,
      q1: q1,
      outlier: outlier,
      normal: normal,
      mid: mid
    };
  } // 兼容结果数据缺失的情况，max向下取，min向上取，median不做调整


  max = adjustOriginMax(originValue);
  min = adjustOriginMin(originValue);
  mid = (min + max) / 2;
  q3 = (0, _CoreUtils.isNumberValue)(originValue.q3) ? +originValue.q3 : (max + mid) / 2;
  q1 = (0, _CoreUtils.isNumberValue)(originValue.q1) ? +originValue.q1 : (min + mid) / 2;
  median = originValue.median;
  return {
    max: max,
    q3: q3,
    median: median,
    q1: q1,
    min: min,
    mid: mid,
    outlier: outlier
  };
}

function adjustOriginMax(originResult) {
  var max = originResult.max,
      q3 = originResult.q3,
      median = originResult.median,
      q1 = originResult.q1,
      min = originResult.min;
  return getNumberValue([max, q3, median, q1, min, 0]);
}

function adjustOriginMin(originResult) {
  var max = originResult.max,
      q3 = originResult.q3,
      median = originResult.median,
      q1 = originResult.q1,
      min = originResult.min;
  return getNumberValue([min, q1, median, q3, max, 0]);
}

function getNumberValue(valueGroup) {
  // IE不支持Array.find
  for (var i = 0, len = valueGroup.length; i < len; i++) {
    var temp = valueGroup[i];

    if ((0, _CoreUtils.isNumberValue)(temp)) {
      return +temp;
    }
  }

  return 0;
}

function filterNotNumber(originValue) {
  // 先过滤无效数据 "-" ，再过滤数据中非数值类型的value
  if (_BaseUtils["default"].isArray(originValue) && originValue.length) {
    return originValue.filter(function (value) {
      return (0, _CoreUtils.isNumberValue)(value);
    });
  }

  return [];
}

function convertToNumber(originValue) {
  if (originValue == null || originValue.length === 0) {
    return [];
  }

  return originValue.map(function (v) {
    return +v;
  });
}

function sortDetailedData(originValue) {
  if (originValue == null || originValue.length === 0) {
    return [];
  }

  var result = [originValue[0]];

  for (var i = 1, len = originValue.length; i < len; i++) {
    result.push(originValue[i]);

    if (result[i] < result[i - 1]) {
      var temp = result[i];
      var j = i - 1;

      for (; j > -1 && temp < result[j]; j--) {
        result[j + 1] = result[j];
      }

      result[j + 1] = temp;
    }
  }

  return result;
}

function getPointDomain(originValue, isDetailed) {
  if (isDetailed === void 0) {
    isDetailed = true;
  }

  if (originValue == null) {
    return;
  }

  var result = isDetailed ? getBoxDataResult(originValue, true) : originValue;
  var max = result.max,
      q3 = result.q3,
      median = result.median,
      q1 = result.q1,
      min = result.min,
      outlier = result.outlier;
  return [max, q3, median, q1, min].concat(outlier);
}

function refreshBoxMarkerColor(options, fillColor) {
  var normalMarker = options.normalMarker,
      outlierMarker = options.outlierMarker;

  if (normalMarker) {
    var clonedNormalMarker = _BaseUtils["default"].clone(normalMarker);

    clonedNormalMarker.fillColor = normalMarker.fillColor || fillColor;
    clonedNormalMarker.fillColorOpacity = NORMAL_MARKER_OPACITY;
    clonedNormalMarker.radius = isNaN(normalMarker.radius) ? _Constants["default"].MARKER_RADIUS : normalMarker.radius;
    options.normalMarker = clonedNormalMarker;
  }

  if (outlierMarker) {
    var clonedOutlierMarker = _BaseUtils["default"].clone(outlierMarker);

    clonedOutlierMarker.fillColor = outlierMarker.fillColor || fillColor;
    clonedOutlierMarker.fillColorOpacity = OUTLIER_MARKER_OPACITY;
    clonedOutlierMarker.radius = isNaN(outlierMarker.radius) ? _Constants["default"].MARKER_RADIUS : outlierMarker.radius;
    options.outlierMarker = clonedOutlierMarker;
  }
}

function refreshBoxBorderColor(point, seriesColor) {
  point.borderColor = point.borderColor || seriesColor;
}

function findInteractiveMarker(vanchart, event) {
  if (event.srcEvent) {
    var rowElement = event.srcEvent.target || event.srcEvent.srcElement;
    return vanchart.findInteractiveTarget(rowElement);
  }
}

function selectOutlierData(point, event) {
  var vanchart = point.series.vanchart; // 自动数据点提示时，模拟的event只有containerPoint属性

  if (event.containerPoint && point.contains(event.containerPoint)) {
    return null;
  }

  return findInteractiveMarker(vanchart, event);
} // CHART-15791 没有进行marker更新


function updateMarker(point) {
  var markerGroupDomObj = point.graphic.markerGroup,
      normalMarkerDataArr = point.normalMarkerGroup || [],
      outlierMarkerDataArr = point.outlierMarkerGroup || [],
      _point$options = point.options,
      normalMarker = _point$options.normalMarker,
      outlierMarker = _point$options.outlierMarker;

  _updateMarkerGroup(markerGroupDomObj, normalMarkerDataArr, point, 'normalMarker_', normalMarker);

  _updateMarkerGroup(markerGroupDomObj, outlierMarkerDataArr, point, 'outlierMarker_', outlierMarker);
}
/*
* markerGroup是Dom节点对象，里面存储的格式是normalMarker_1或者oulierMarker_1等，两种可能都存在在同一个点中
* markerData是对应的marker的数据数组，数组多长就有多少个对应marker
* */


function _updateMarkerGroup(markerGroup, markerData, point, prefix, markerConstruct) {
  var index, marker; // remove

  index = markerData.length;

  while (markerGroup[prefix + index]) {
    clearMarker(markerGroup[prefix + index]);
    delete markerGroup[prefix + index];
    index++;
  } // add


  index = markerData.length - 1;

  if (index >= 0) {
    while (!markerGroup[prefix + index] && markerData[index]) {
      marker = point.series._createMarker(markerConstruct);
      marker.attr({
        'transform': 'translate(' + markerData[index].x + ',' + markerData[index].y + ') scale(1)'
      });
      markerGroup[prefix + index] = marker.addTo(markerGroup);
      index--;
    }
  }
}

function clearMarker(group) {
  group.image && group.image.remove();
  group.markerPath && group.markerPath.remove();
  group.remove();
}

function hasValidNormalMarker(point) {
  if (point == null || point.options == null) {
    return false;
  }

  var normalMarker = point.options.normalMarker;
  return (0, _CoreUtils.hasDefined)(normalMarker) && (0, _CoreUtils.hasDefined)(normalMarker.symbol);
}

function hasValidOutlierMarker(point) {
  if (point == null || point.options == null) {
    return false;
  }

  var outlierMarker = point.options.outlierMarker;
  return (0, _CoreUtils.hasDefined)(outlierMarker) && (0, _CoreUtils.hasDefined)(outlierMarker.symbol);
}

/***/ }),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/8.
 */
var INIT_TIME = 1200;
var INIT_EASE = 'cubic-out';
var EXIT_TIME = 300;
var EXIT_EASE = 'ease';
var RESHOW_TIME = 1000;
var RESHOW_EASE = INIT_EASE;
var INIT_TRANSITION = 'init';

var Path = _Layer["default"].extend({
  onAdd: function () {
    this._path = this._renderer.path().style(this.options);

    this._reset();

    this._path.add();
  },
  onRemove: function () {
    this._path.remove();
  },
  // @method redraw(): this
  // Redraws the layer. Sometimes useful after you changed the coordinates that the path uses.
  redraw: function () {
    if (this._map) {
      this._reset();
    }

    return this;
  },
  // @method setStyle(style: Path options): this
  // Changes the appearance of a Path based on the options in the `Path options` object.
  setStyle: function (style) {
    this._path.interrupt(INIT_TRANSITION); //path 只存样式信息


    this.options = style || this.options;

    if (this._renderer) {
      this._path.style(this.options);
    }

    return this;
  },
  initAnimate: function () {
    this._path.style({
      'fill-opacity': 0
    }).interrupt(INIT_TRANSITION).transition(INIT_TRANSITION).ease(INIT_EASE).style(this.options).duration(INIT_TIME);
  },
  exitAnimate: function (vanchart, animate) {
    var geo = vanchart.getCurrentGeo();

    if (animate) {
      this._path.interrupt(INIT_TRANSITION).transition(INIT_TRANSITION).ease(EXIT_EASE).style(geo.defaultAreaStyle()).duration(EXIT_TIME);
    } else {
      this._path.interrupt(INIT_TRANSITION).removeTransition().style(geo.defaultAreaStyle());
    }
  },
  reShowAnimate: function () {
    this._path.style({
      'fill-opacity': 0
    }).animate({
      style: this.options,
      duration: RESHOW_TIME,
      ease: RESHOW_EASE
    });
  },
  _onMouseState: function (isChosen, duration, ease, style) {
    style.filter = "none"; // todo 这里的动画应该用不到filter吧，不禁用的话，和effect的attr.filter就冲突导致闪烁变白

    this._path.animate({
      duration: duration,
      ease: ease,
      style: style
    });
  },
  _reset: function () {
    // defined in children classes
    this._project();

    this._update();
  },
  _clickTolerance: function () {
    // used when doing hit detection for Canvas layers
    return (this.options['stroke-width'] ? this.options['stroke-width'] / 2 : 0) + (_Browser["default"].touch ? 10 : 0);
  },
  node: function () {
    return this._path.node();
  }
});

var _default = Path;
exports["default"] = _default;

/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/20.
 */
var LayerGroup = _Layer["default"].extend({
  initialize: function (layers) {
    this._layers = {};
    var i, len;

    if (layers) {
      for (i = 0, len = layers.length; i < len; i++) {
        this.addLayer(layers[i]);
      }
    }
  },
  // @method addLayer(layer: Layer): this
  // Adds the given layer to the group.
  addLayer: function (layer) {
    var id = this.getLayerId(layer);
    this._layers[id] = layer;

    if (this._map) {
      this._map.addLayer(layer);
    }

    return this;
  },
  // @method removeLayer(layer: Layer): this
  // Removes the given layer from the group.
  // @alternative
  // @method removeLayer(id: Number): this
  // Removes the layer with the given internal ID from the group.
  removeLayer: function (layer) {
    var id = layer in this._layers ? layer : this.getLayerId(layer);

    if (this._map && this._layers[id]) {
      this._map.removeLayer(this._layers[id]);
    }

    delete this._layers[id];
    return this;
  },
  // @method hasLayer(layer: Layer): Boolean
  // Returns `true` if the given layer is currently added to the group.
  hasLayer: function (layer) {
    return !!layer && (layer in this._layers || this.getLayerId(layer) in this._layers);
  },
  // @method clearLayers(): this
  // Removes all the layers from the group.
  clearLayers: function () {
    for (var i in this._layers) {
      this.removeLayer(this._layers[i]);
    }

    return this;
  },
  // @method invoke(methodName: String, …): this
  // Calls `methodName` on every layer contained in this group, passing any
  // additional parameters. Has no effect if the layers contained do not
  // implement `methodName`.
  invoke: function (methodName) {
    var args = Array.prototype.slice.call(arguments, 1),
        i,
        layer;

    for (i in this._layers) {
      layer = this._layers[i];

      if (layer[methodName]) {
        layer[methodName].apply(layer, args);
      }
    }

    return this;
  },
  onAdd: function (map) {
    for (var i in this._layers) {
      map.addLayer(this._layers[i]);
    }
  },
  onRemove: function (map) {
    for (var i in this._layers) {
      map.removeLayer(this._layers[i]);
    }
  },
  // @method eachLayer(fn: Function, context?: Object): this
  // Iterates over the layers of the group, optionally specifying context of the iterator function.
  // ```js
  // group.eachLayer(function (layer) {
  // 	layer.bindPopup('Hello');
  // });
  // ```
  eachLayer: function (method, context) {
    for (var i in this._layers) {
      method.call(context, this._layers[i]);
    }

    return this;
  },
  // @method getLayer(id: Number): Layer
  // Returns the layer with the given internal ID.
  getLayer: function (id) {
    return this._layers[id];
  },
  // @method getLayers(): Layer[]
  // Returns an array of all the layers added to the group.
  getLayers: function () {
    var layers = [];

    for (var i in this._layers) {
      layers.push(this._layers[i]);
    }

    return layers;
  },
  // @method setZIndex(zIndex: Number): this
  // Calls `setZIndex` on every layer contained in this group, passing the z-index.
  setZIndex: function (zIndex) {
    return this.invoke('setZIndex', zIndex);
  },
  // @method getLayerId(layer: Layer): Number
  // Returns the internal ID for a layer
  getLayerId: function (layer) {
    return _BaseUtils["default"].stamp(layer);
  }
});

var _default = LayerGroup;
exports["default"] = _default;

/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Series = _interopRequireDefault(__webpack_require__(13));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _ThemeConfig = __webpack_require__(17);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/12/2.
 */
var MIN_FONTSIZE = 10;
var LINE_HEIGHT = 1.2; // 字体行高

var PERCENT_VALUE_LABEL_GAP = 0.13; // 百分比标签与值标签间隔占百分比字体高度的比例

var Gauge = _Series["default"].extend({
  DEFAULT_PADDING: 5,
  LINE_GAP: 0.3,
  VERTICAL_GAP: 0.3,
  HORIZONTAL_GAP: 0.5,
  LABEL_AUTO_FONTSIZE: '12px',
  DEFAULT_LABEL_WIDTH: 0.25,
  // vertical试管型仪表盘的标签宽度默认占绘图区宽度的比例
  ANIMATION_TIME: 1200,
  EASE_TYPE: 'cubic-out',
  CHOSEN_EASE: _BezierEasing["default"].css['ease'],
  CHOSEN_TIME: 200,
  OUT_EASE: _BezierEasing["default"].css['ease-out'],
  OUT_TIME: 900,
  LABEL_BACKGROUND_COLOR: 'rgba(255,255,255,0)',
  refresh: function (options, index) {
    _Series["default"].prototype.refresh.call(this, options, index);

    options = this.options;
    this.gaugeType = options.style;
    this.center = null;

    if (options.center) {
      this.center = [this._getPercentValue(options.center[0], this.vanchart.width), this._getPercentValue(options.center[1], this.vanchart.height)];
    }

    _BaseUtils["default"].calculateFontSizeWithScale(options.seriesLabel && options.seriesLabel.style);

    _BaseUtils["default"].calculateFontSizeWithScale(options.valueLabel && options.valueLabel.style);

    _BaseUtils["default"].calculateFontSizeWithScale(options.percentageLabel && options.percentageLabel.style);

    return this;
  },
  getBaseAxisType: function () {
    return 'gaugeAxis';
  },
  doLayout: function () {
    var seriesBounds = this._calculateGaugeBounds(),
        series = this,
        options = series.options;

    if (!seriesBounds && !options.radius && !series.center) {
      throw new Error('gauge has no bounds');
    }

    this.bounds = seriesBounds;

    this._calculatePercentage(); //bands和color这两个属性放在doLayout原因：default bands depend on gauge axis domain.


    series.defaultBands = (options.bands || []).concat(series._getDefaultBands(series.gaugeAxis.scale.domain()));
    series.points.forEach(function (point) {
      var bandsColor = series._getColorFromBands(point.getTargetValue(), series.defaultBands);

      if (bandsColor) {
        bandsColor = _ColorUtils["default"].getStandardColorAndOpacity(bandsColor);
        point.color = bandsColor.hex;
        point.opacity = bandsColor.alpha;
      }

      point.mouseOverColor = _ColorUtils["default"].getHighLightColor(point.color);
      point.clickColor = _ColorUtils["default"].getClickColor(point.color);
    });

    this._doLayout();
  },
  _doLayout: function () {},
  // 槽型、圆环仪表盘
  _fixCenterAndRadius: function (paddingPercent) {
    var gauge = this,
        options = gauge.options,
        radius = options.radius,
        centerX,
        circleWidth = options.circleWidth,
        centerY,
        startY,
        totalHeight,
        lineGap,
        labelCount;

    if (gauge.center) {
      centerX = gauge.center[0];
      centerY = gauge.center[1];
    } else {
      var bounds = gauge.bounds;
      radius = radius || Math.min(bounds.width / 2, bounds.height / 2) / (1 + paddingPercent);
      centerX = bounds.x + bounds.width / 2;
      centerY = bounds.y + bounds.height / 2;
    }

    gauge.centerX = centerX;
    gauge.centerY = centerY;
    gauge.radius = radius;

    if (gauge.percentageLabelContent && gauge.valueLabelContent && gauge.valueLabelContent.length > 0) {
      var valueLabelTotalHeight = this.calculateLabelTotalHeight(gauge.valueLabelContent);
      labelCount = gauge.valueLabelContent.length;
      var valueLabelLineGap = valueLabelTotalHeight * (LINE_HEIGHT - 1) / labelCount;
      totalHeight = valueLabelTotalHeight + gauge.percentageLabelDim.height * (1 + PERCENT_VALUE_LABEL_GAP);
      startY = -totalHeight / 2;
      gauge.percentageLabelPos = {
        x: -gauge.percentageLabelDim.width / 2,
        y: startY
      };
      startY += gauge.percentageLabelDim.height * (1 + PERCENT_VALUE_LABEL_GAP);

      for (var i = 0, count = gauge.valueLabelContent.length; i < count; i++) {
        var valueLabel = gauge.valueLabelContent[i];
        valueLabel.labelPos = {
          x: -valueLabel.labelDim.width / 2,
          y: startY
        };
        startY += valueLabel.labelDim.height + valueLabelLineGap;
      }
    } else if (gauge.percentageLabelContent) {
      gauge.percentageLabelPos = {
        x: -gauge.percentageLabelDim.width / 2,
        y: -gauge.percentageLabelDim.height / 2
      };
    } else if (gauge.valueLabelContent && gauge.valueLabelContent.length > 0) {
      labelCount = gauge.valueLabelContent.length;
      totalHeight = this.calculateLabelTotalHeight(gauge.valueLabelContent);
      lineGap = totalHeight * (LINE_HEIGHT - 1) / labelCount;
      startY = -(totalHeight / 2 - lineGap / 2);

      for (var i = 0; i < labelCount; i++) {
        var valueLabel = gauge.valueLabelContent[i];
        valueLabel.labelPos = {
          x: -valueLabel.labelDim.width / 2,
          y: startY
        };
        startY += valueLabel.labelDim.height + lineGap;
      }
    }
  },
  calculateLabelTotalHeight: function (labelContent) {
    var totalHeight = 0;
    var labelCount = labelContent.length;

    for (var i = 0; i < labelCount; i++) {
      totalHeight += labelContent[i].labelDim.height;
    }

    return totalHeight * LINE_HEIGHT;
  },
  calculateLabelInfo: function (point) {},
  _createGroup: function (renderer, vanchart) {
    return renderer.group().addTo(vanchart.seriesGroup);
  },
  _getAxisTypes: function () {
    return ['gaugeAxis'];
  },
  getDataToDraw: function () {
    return [];
  },
  _calculatePercentage: function () {
    if (this.points.length) {
      var gaugeAxis = this.gaugeAxis,
          minMax = gaugeAxis.scale.domain();
      var points = this.points;
      points.forEach(function (point) {
        point.points = points;
        point.percentage = (point.value - minMax[0]) / (minMax[1] - minMax[0]);
      });
    }
  },
  _calculateLabelPos: function () {},
  _getTranslate: function () {
    return [Math.round(this.centerX), Math.round(this.centerY)];
  },
  _validPoint: function () {
    var validPoints = this.points.filter(function (point) {
      return !point.isNull;
    });
    return validPoints[0] || this.points[0];
  },
  isValidDataLabel: function (point, dataLabels) {
    return point && !point.isNull && dataLabels && dataLabels.enabled;
  },
  getThemeLabelColor: function (labelStyle) {
    var isDarkTheme = this.vanchart.isDarkTheme();
    var autoColor = labelStyle.autoColor;

    if (autoColor) {
      return (0, _ThemeConfig.getThemeAutoValue)(_Constants["default"].AUTO, 'gaugeLabelColor', isDarkTheme);
    }

    return labelStyle.color;
  },
  _autoValueLabelWithPercent: function (labelContents, valueLabel, fontHeight, limitWidth, series) {
    var valueString = labelContents.value;
    var categoryString = labelContents.category;
    var valueLabelContent = [];
    var useHtml = valueLabel.useHtml;

    var labelStyle = _BaseUtils["default"].clone(valueLabel.style);

    labelStyle.fontSize = fontHeight;

    if (labelContents.category && labelContents.value) {
      valueLabelContent = this._categoryAndValue(labelContents, valueLabel, fontHeight, limitWidth);
    } else if (labelContents.category) {
      var categoryLabel = _BaseUtils["default"].splitAndShrinkText(categoryString, MIN_FONTSIZE, labelStyle, limitWidth, useHtml);

      labelContents = categoryLabel.text;
      labelStyle.fontSize = categoryLabel.fontSize;

      for (var i = 0, len = labelContents.length; i < len; i++) {
        var labelContent = labelContents[i];
        valueLabelContent.push({
          labelContent: labelContent,
          labelStyle: labelStyle,
          labelDim: _BaseUtils["default"].getTextDimension(labelContent, labelStyle, useHtml)
        });
      }
    } else {
      var label = valueString || labelContents.text;
      label = _BaseUtils["default"].shrinkText(label, MIN_FONTSIZE, fontHeight, limitWidth, labelStyle, useHtml);
      labelStyle.fontSize = label.fontSize;
      valueLabelContent.push({
        labelContent: label.labelContent,
        labelStyle: labelStyle,
        labelDim: _BaseUtils["default"].getTextDimension(label.labelContent, labelStyle, useHtml)
      });
    }

    series.valueLabelContent = valueLabelContent;
  },
  _categoryAndValue: function (labelContents, valueLabel, fontHeight, limitWidth) {
    var valueString = labelContents.value;
    var categoryString = labelContents.category;
    var valueLabelContent = [];
    var useHtml = valueLabel.useHtml;

    var labelStyle = _BaseUtils["default"].clone(valueLabel.style);

    labelStyle.fontSize = Math.max(fontHeight, MIN_FONTSIZE) + 'px';
    var singleLineText = categoryString + ' ' + valueString;

    var singleLineWidth = _BaseUtils["default"].getTextDimension(singleLineText, labelStyle, useHtml).width;

    if (singleLineWidth <= limitWidth) {
      valueLabelContent.push({
        labelContent: singleLineText,
        labelStyle: labelStyle,
        labelDim: _BaseUtils["default"].getTextDimension(singleLineText, labelStyle, useHtml)
      });
    } else {
      labelContents = _BaseUtils["default"].objectToArray(labelContents);

      for (var i = 0, len = labelContents.length; i < len; i++) {
        var labelContent = labelContents[i];

        var labelStyle = _BaseUtils["default"].clone(valueLabel.style);

        var autoSizeLabel = _BaseUtils["default"].shrinkText(labelContent, MIN_FONTSIZE, fontHeight, limitWidth, labelStyle, useHtml);

        labelContent = autoSizeLabel.labelContent;
        labelStyle.fontSize = autoSizeLabel.fontSize;
        valueLabelContent.push({
          labelContent: labelContent,
          labelStyle: labelStyle,
          labelDim: _BaseUtils["default"].getTextDimension(labelContent, labelStyle, useHtml)
        });
      }
    }

    return valueLabelContent;
  },
  // 勾选百分比，分类、值非自动调整情况下的显示
  _valueLabelWithPercent: function (labelContents, valueLabel, limitWidth, series, isThermometer) {
    var separator = isThermometer ? ':' : ' ';
    var valueString = (0, _CoreUtils.isEmpty)(labelContents.value) ? '' : labelContents.value;
    var categoryString = (0, _CoreUtils.isEmpty)(labelContents.category) ? '' : labelContents.category;
    var connectionSymbol = (0, _CoreUtils.isEmpty)(labelContents.category) || (0, _CoreUtils.isEmpty)(valueString) ? '' : separator;
    var singleLineText = categoryString + connectionSymbol + valueString;

    var labelStyle = _BaseUtils["default"].clone(valueLabel.style);

    var valueLabelContent = [];
    var useHtml = valueLabel.useHtml;

    var singleLineWidth = _BaseUtils["default"].getTextDimension(singleLineText, labelStyle, useHtml).width;

    var percentageLabel = series.options.percentageLabel;

    if (isThermometer && series.percentageLabelContent && valueLabel.align === percentageLabel.align) {
      singleLineWidth += series.percentageLabelDim.width;
    } // 内容设置为通用的情况


    if (singleLineWidth >= limitWidth) {
      labelContents = _BaseUtils["default"].objectToArray(labelContents);

      for (var i = 0, len = labelContents.length; i < len; i++) {
        var labelContent = _BaseUtils["default"].getEllipsisText(labelContents[i], limitWidth, labelStyle, useHtml);

        valueLabelContent.push({
          labelContent: labelContent,
          labelStyle: labelStyle,
          labelDim: _BaseUtils["default"].getTextDimension(labelContent, labelStyle, useHtml)
        });
      }
    } else {
      valueLabelContent.push({
        labelContent: singleLineText,
        labelStyle: labelStyle,
        labelDim: _BaseUtils["default"].getTextDimension(singleLineText, labelStyle, useHtml)
      });
    }

    series.valueLabelContent = valueLabelContent;
  },
  _getDefaultBands: function (domain) {
    var color = this.options.color,
        bands = [];

    if (color) {
      bands.push({
        from: domain[0],
        to: domain[1],
        color: color
      });
    } else {
      var min = domain[0],
          max = domain[1];

      var band = _BaseUtils["default"].accDiv(max - min, 3);

      var fStop = _BaseUtils["default"].accAdd(min, band);

      var sStop = _BaseUtils["default"].accAdd(fStop, band);

      var colors = this.vanchart.options.colors;
      bands = [{
        from: min,
        to: fStop,
        color: colors[0]
      }, {
        from: fStop,
        to: sStop,
        color: colors[1]
      }, {
        from: sStop,
        to: max,
        color: colors[2]
      }];
    }

    return bands;
  },

  /**
   * 仪表盘会取配色方案中前三种颜色，分配适配刻度0~1/3, 1/3~2/3, 2/3~1的区间色
   * 0以下的配色取0～1/3的区间色，1以上的取2/3～1的区间色
   * @param value
   * @param bands
   * @returns {*}
   * @private
   */
  _getColorFromBands: function (value, bands) {
    if (bands && bands.length) {
      var bandValues = [];

      for (var i = 0, len = bands.length; i < len; i++) {
        var band = bands[i];
        var min = Math.min(band.from, band.to);
        var max = Math.max(band.from, band.to);
        bandValues.push(min, max);

        if (value >= min && value <= max) {
          return band.color;
        }
      }

      var minBandValues = Math.min.apply(Math, bandValues);
      var maxBandValues = Math.max.apply(Math, bandValues);

      if (value < minBandValues) {
        return bands[0].color;
      }

      if (value > maxBandValues) {
        return bands[bands.length - 1].color;
      }
    }
  },
  //计算每个系列的边界,要么定义了圆心和半径,作为悬浮元素处理,要么两者都不定义,自定平分区域
  //只定义半径没定义圆心,或者只定义了圆心没有定义半径,效果都是未知的
  _calculateGaugeBounds: function () {
    var series = this.vanchart.seriesOfType(_Constants["default"].GAUGE_CHART);
    var plotBounds = this.vanchart.bounds;
    var GAUGE_PLOT_RATE = 0.9;
    var gaugePlotBounds = {
      width: GAUGE_PLOT_RATE * plotBounds.width,
      height: GAUGE_PLOT_RATE * plotBounds.height,
      x: plotBounds.x + _BaseUtils["default"].accDiv(1 - GAUGE_PLOT_RATE, 2) * plotBounds.width,
      y: plotBounds.y + _BaseUtils["default"].accDiv(1 - GAUGE_PLOT_RATE, 2) * plotBounds.height
    };
    var fixedSize = 0;

    for (var i = 0, len = series.length; i < len; i++) {
      if (series[i].center && series[i].options.radius) {
        fixedSize++;
      }
    } //平均半径


    var isHorizontalLayout = this.options.layout == _Constants["default"].HORIZONTAL_LAYOUT;
    var divideDimKey = isHorizontalLayout ? 'width' : 'height';
    var averageSize = gaugePlotBounds[divideDimKey] / Math.max(1, series.length - fixedSize);

    for (var i = 0, len = series.length; i < len; i++) {
      if (series[i] == this) {
        if (!this.center) {
          if (isHorizontalLayout) {
            return {
              x: gaugePlotBounds.x + i * averageSize,
              y: gaugePlotBounds.y,
              width: averageSize,
              height: gaugePlotBounds.height
            };
          } else {
            return {
              x: gaugePlotBounds.x,
              y: gaugePlotBounds.y + i * averageSize,
              width: gaugePlotBounds.width,
              height: averageSize
            };
          }
        }
      }
    }

    return {
      x: 0,
      y: 0,
      width: 0,
      height: 0
    };
  },
  //试管的重写了
  _getFixedPos: function (datum, divDim) {
    var gauge = datum.series,
        style = gauge.gaugeType;
    var x, y;

    if (style == 'pointer_semi') {
      x = gauge.centerX - divDim.width / 2;
      y = gauge.centerY + 0.14 * gauge.radius + 10;
    } else {
      x = gauge.centerX + gauge.radius + 10;
      y = gauge.centerY - divDim.height / 2;
    }

    return [x, y];
  },
  _animateEnd: function () {},
  _getPointTextLabelGroup: function () {
    if (!this.textGraphicGroup) {
      var vanchart = this.vanchart,
          textRenderGroup = vanchart.seriesTextRenderGroup,
          textDivGroup = vanchart.seriesTextDivGroup;
      this.textGraphicGroup = vanchart.renderer.vgroup();
      this.textGraphicGroup.renderG.addTo(this.group);
      textDivGroup.append(this.textGraphicGroup.divG);
    }

    this.textGraphicGroup.divG.attr('transform', _BaseUtils["default"].makeTranslate(this._getTranslate()));
    return this.textGraphicGroup;
  },
  _drawGaugeLabels: function (labelG) {
    var series = this,
        vanchart = series.vanchart;

    series._removeNormalLabels(labelG);

    series._drawNormalLabels(labelG); // 试管仪表盘更新一下标签动画Init的偏移，
    // 下一次标签绘制时动画应从上一次的位置开始


    series.updateLastLabelPos && series.updateLastLabelPos(); // 标签和系列绘制完成再绘制MoreLabel

    if (vanchart._needShowMoreLabel() && series.visible) {
      series._drawDiffMoreLabels();
    } // 改回vanchart._changeDataState


    vanchart._removeChangeDataState(series);
  },
  //默认的是ring and slot 其他要重写这个方法
  _drawDiffMoreLabels: function () {
    var series = this,
        point = this.points[0];

    if (!point || point.isNull) {
      return;
    }

    this._showMoreLabel(point, series.centerX, series.centerY);
  },
  _removeNormalLabels: function (labelG) {
    //简化代码,标签每次都重画
    var labels = labelG.labels || [];

    for (var i = 0, len = labels.length; i < len; i++) {
      labels[i] && labels[i].remove();
      labels[i] = null;
    }

    this._drawExitValueLabel && this._drawExitValueLabel(); // 仪表盘的valueLabel单独拿出来画了，因此也要单独移除
  },
  _drawNormalLabels: function (labelG) {
    var series = this,
        options = series.options,
        vanchart = series.vanchart,
        renderer = vanchart.renderer;
    labelG.labels = [];

    if (series.seriesLabelContent) {
      var seriesLabel = {
        labelContent: series.seriesLabelContent,
        labelDim: series.seriesLabelDim,
        labelPos: series.seriesLabelPos,
        labelStyle: series.seriesLabelStyle
      };

      series._drawLabel(labelG, seriesLabel, options.seriesLabel.useHtml);
    }

    if (series.percentageLabelContent) {
      var percentageLabel = {
        labelContent: series.percentageLabelContent,
        labelDim: series.percentageLabelDim,
        labelPos: series.percentageLabelPos,
        labelStyle: series.percentageLabelStyle
      };

      series._drawLabel(labelG, percentageLabel, options.percentageLabel.useHtml, series.animateLabelPara());
    }

    if (series.valueLabelContent && series.valueLabelContent.length) {
      // 指针类型的仪表盘值标签后面有背景
      if (series.valueLabelBackground) {
        var valueLabelBackground = series.valueLabelBackground;

        var background = _BaseUtils["default"].rectSubPixelOpt(series.valueLabelBackground, 0);

        background.rx = background.rx = series.radius * 0.02;
        var valueLabelCfg = series.options.valueLabel;
        var valueLabelBackgroundColor = valueLabelCfg.backgroundColor || this.LABEL_BACKGROUND_COLOR; // @Cmen:这里注明一下，仪表盘刷新的时候，旧的ValueLabel和新的ValueLabel要同时存在，且应该在backgroundRect上面，因此这里只更新，不重绘

        series.valueLabelBackgroundRect = series.valueLabelBackgroundRect || renderer.rect().addTo(labelG);
        series.valueLabelBackgroundRect.attr(background).style({
          'fill': valueLabelBackgroundColor,
          'fill-opacity': _ColorUtils["default"].getColorOpacity(valueLabelBackgroundColor),
          'filter': renderer.toPatternProperty(series.innerFilter)
        });
        series.labelGroups = series.labelGroups || [];
        series.labelGroups.push(series.valueLabelG); // 把旧的存起来,移除的时候可能需要等到动画结束后

        var valueLabelG = series.valueLabelG = renderer.group().addTo(labelG);

        if (!series.clipRect) {
          series.clipRect = renderer.createClip(series.valueLabelBackground);
        } else {
          renderer.updateClip(series.clipRect, series.valueLabelBackground);
        }

        renderer.clip(valueLabelG, series.clipRect);
        labelG.valueLabelDivG = renderer.vtext(true).style({
          clip: 'rect(' + [valueLabelBackground.y, valueLabelBackground.x + valueLabelBackground.width, valueLabelBackground.y + valueLabelBackground.height, valueLabelBackground.x].join('px ') + 'px)'
        }).addTo(labelG);
      }

      var isPointerGaugeValueLabel = series.isPointerGauge();

      for (var i = 0, len = series.valueLabelContent.length; i < len; i++) {
        var valueLabel = series.valueLabelContent[i];

        series._drawLabel(labelG, valueLabel, options.valueLabel.useHtml, series.animateLabelPara(), valueLabelG, isPointerGaugeValueLabel);
      }
    } else {
      series.valueLabelBackgroundRect && series.valueLabelBackgroundRect.remove();
      series.valueLabelBackgroundRect = null; //@CHART-1747
    }
  },
  animateLabelPara: function () {},
  _getGaugeLabelG: function (labelG, parentG, useHtml, isPointerGaugeValueLabel) {
    var parentDivG = isPointerGaugeValueLabel ? labelG.valueLabelDivG : labelG;
    return (useHtml ? parentDivG : parentG) || labelG;
  },
  _drawLabel: function (labelG, label, useHtml, animatePara, parentG, isPointerGaugeValueLabel) {
    var labelContent = label.labelContent,
        labelDim = label.labelDim,
        labelPos = label.labelPos,
        labelStyle = label.labelStyle;

    if (!labelPos) {
      return;
    }

    var series = this,
        vanchart = series.vanchart,
        renderer = vanchart.renderer;

    var gaugeLabelG = this._getGaugeLabelG(labelG, parentG, useHtml, isPointerGaugeValueLabel);

    var textAttr = {
      'x': labelPos.x,
      'y': labelPos.y,
      'width': labelDim.width + 'px',
      'height': labelDim.height + 'px',
      'text-align': 'center',
      'overflow': 'hidden'
    };
    var textG = renderer.vtext(useHtml).attr(textAttr).style(labelStyle).textContent(labelContent).addTo(gaugeLabelG);

    var offsetAttr = this._textOffset(labelDim, useHtml);

    textG = textG.attr(offsetAttr); // 指针仪表盘的ValueLabel要单独对待

    if (isPointerGaugeValueLabel) {
      series.valueLabels = series.valueLabels || [];
      series.valueLabels.push(textG);
    } else {
      labelG.labels.push(textG);
    } // IE8及以下有动画也不执行


    if ((0, _EnvUtils.isSupportSVG)() && animatePara && animatePara.enabled) {
      if (!series.hasChangedPointWithChangeDataState() && !series.initialAnimationMoving) {
        return;
      } // 未发生值变化，不执行动画


      textG.attr(animatePara.initAttr || {}).style(animatePara.initStyle || {}).animate({
        ease: series.EASE_TYPE,
        duration: series.ANIMATION_TIME,
        style: {
          'opacity': 1,
          'transform': _BaseUtils["default"].makeTranslateWithPX({
            x: 0,
            y: 0
          })
        },
        attr: {
          'transform': _BaseUtils["default"].makeTranslate({
            x: 0,
            y: 0
          })
        }
      });
    }
  },
  // ie浏览器不支持dominant-baseline，其他浏览器以及移动端直接使用{'dy': '.85em'}会出现偏移
  _textOffset: function (labelDim, useHtml) {
    var offset; // vmlRenderer会将dx、dy解析成margin-left、margin-top导致标签位置不对，所以使用html解析的无需添加dx、dy

    if (useHtml) {
      return {};
    }

    if (this.isSupportVerticalLabel()) {
      offset = 0.5 * labelDim.width;
      return _Browser["default"].ie ? {
        dx: '.85em'
      } : {
        dx: offset,
        'dominant-baseline': 'central'
      };
    }

    offset = 0.5 * labelDim.height;
    return _Browser["default"].ie ? {
      dy: '.85em'
    } : {
      dy: offset,
      'dominant-baseline': 'central'
    };
  },
  _onState: function (graphic, isChosen, style) {
    var series = this;
    graphic && graphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      ease: isChosen ? series.CHOSEN_EASE : series.OUT_EASE,
      duration: isChosen ? series.CHOSEN_TIME : series.OUT_TIME,
      style: style
    });
  },
  isPointerGauge: function () {
    return false;
  },
  _onSinglePointerTap: function (ev) {
    if (this.vanchart.isMobileFlow()) {
      // todo, which point?
      var p = this.points[0];
      this.vanchart.showTooltip(p, ev);

      p._onPointTap(ev);
    } else {
      this.vanchart && this.vanchart.isMobile() && this.fire("mousemove", ev); // MOBILE-4762
      //单个指针的时候点击触发超链

      if (this.points && this.points.length === 1) {
        this.points[0].onClick(ev.srcEvent);
      }
    }
  },
  _onSeriesMouseOver: function (ev) {
    if (this.points && this.points.length === 1 || this.isSupportSharedTooltip()) {
      this.vanchart.showTooltip(this.points[0], ev);
    }
  },
  _onSeriesMouseOut: function () {
    this.vanchart.hideTooltip();
  },
  getClosestPoint: function () {
    return this.points.length === 1 ? this.points[0] : null;
  },
  //一个点一个系列
  getEvents: function () {
    return {
      'pointMouseOver': this._onPointMouseOver,
      'pointMouseOut': this._onPointMouseOut,
      'mousemove': this._onSeriesMouseOver,
      'mouseout': this._onSeriesMouseOut,
      'tap': this._onSinglePointerTap,
      'press': this.onSeriesPress,
      'pressup': this.onSeriesPressUp
    };
  },
  isSupportLegendHighlight: function () {
    return false;
  },
  isSeriesAccumulated: function () {
    return true;
  },
  isSupportSharedTooltip: function () {
    var tooltip = this.vanchart.options.plotOptions.tooltip || {};
    return !!this.options.tooltip.shared || !!tooltip.shared;
  },
  isSupportVerticalLabel: function () {
    var options = this.options,
        gaugeType = this.gaugeType;
    var _options$percentageLa = options.percentageLabel,
        percentageLabel = _options$percentageLa === void 0 ? {} : _options$percentageLa,
        _options$valueLabel = options.valueLabel,
        valueLabel = _options$valueLabel === void 0 ? {} : _options$valueLabel;
    var isVerticalThermometerGauge = gaugeType === _Constants["default"].THERMOMETER_GAUGE && options.thermometerLayout === _Constants["default"].VERTICAL_LAYOUT;
    return isVerticalThermometerGauge && (percentageLabel.orientation === _Constants["default"].VERTICAL_LAYOUT || valueLabel.orientation === _Constants["default"].VERTICAL_LAYOUT);
  }
});

var _default = Gauge;
exports["default"] = _default;

/***/ }),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseAxis = _interopRequireDefault(__webpack_require__(63));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _component = __webpack_require__(4);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/18.
 * 分类轴的定义
 */
var LABEL_LINE_GAP = 2.5;

var LABEL_LINE_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(LABEL_LINE_GAP);
};

var CategoryAxis = _BaseAxis["default"].extend({
  type: _component.ComponentCst.CATEGORY_AXIS_COMPONENT,
  initScale: function () {
    this.lastScale = this.scale;
    this.scale = _Scale["default"].ordinal();
  },
  calculateDomainFromData: function () {
    this._dataDomain = this._getDomainFromData();
    var zoomTool = this.vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT);
    this._zoomDomain = this._zoomDomain || zoomTool && zoomTool.getZoomDomain(this);
    this._domain = this._zoomDomain || this._dataDomain;
  },
  calculateDomainFromZoom: function () {
    this._domain = this._zoomDomain;
    this.isBaseAxisOnZoomOnly() && this.vanchart.reCalcValueAxisDataDomain(this.componentType); //缩放控件方向只有一个且在baseAxis上时，重新计算值轴值域
  },
  _getStartAndEndTick: function () {
    return [this._domain[0], this._domain[this._domain.length - 1]];
  },
  _getDomainFromData: function () {
    var axisOption = this.options,
        series = this.series,
        axis = this,
        stored = {};
    var categories = axisOption.categories || [];
    categories.forEach(function (category) {
      stored[category] = true;
    });
    series.forEach(function (sery) {
      this.getTrendLineForecast(sery);

      for (var i = 0, len = sery.points.length; i < len; i++) {
        var tickLabel = sery.points[i].getCategory();

        if (!stored[tickLabel]) {
          stored[tickLabel] = true;
          categories.push(tickLabel);
        }
      } // 多分类轴下面积图isRangePoints也是false


      if (sery.type !== _Constants["default"].AREA_CHART || this.isMultiCateAxis()) {
        axis.isRangePoints = false;
      }
    }, this); // 多分类轴下，需要将_dataDomain格式一下，保证相同父层级的分类在一起

    if (this.isMultiCateAxis() && categories.length) {
      categories = this.resortDataDomain(categories);
    }

    return this.addTrendLineCategories(categories);
  },
  setCategories: function (categories) {
    var lastDomain = this._dataDomain;
    this._dataDomain = this.addTrendLineCategories(categories);
    var zoomTool = this.vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT);

    if (this._isBaseAxis() && zoomTool && zoomTool.zoomToolEnabled()) {
      zoomTool.updateRangeLeftAndRight(this, lastDomain, categories);
      var zoomDomain = zoomTool && zoomTool.getZoomDomain(this);
      this._zoomDomain = zoomDomain;
      this.calculateDomainFromZoom();
    } else {
      this._domain = this._dataDomain;
      this._zoomDomain = null;
    }

    this.fixScaleAndTickData();
  },
  addTrendLineCategories: function (categories) {
    var newArray = _BaseUtils["default"].getTargetFillArray;

    if (this.forecast && (this.forecast[0] || this.forecast[1])) {
      var emptyL = 0;
      categories = newArray(-this.forecast[0], function () {
        return Array(2 + emptyL++).join(' ');
      }).concat(categories).concat(newArray(this.forecast[1], function () {
        return Array(2 + emptyL++).join(' ');
      }));
    }

    return categories;
  },
  getOriginalCategories: function () {
    if (this.forecast && (this.forecast[0] || this.forecast[1])) {
      return this._dataDomain.slice(-this.forecast[0], this._dataDomain.length - this.forecast[1]);
    }

    return this._dataDomain;
  },
  //处理自动旋转的情况
  updateAxisSizeAndBounds: function () {
    this._updateOriginTickData();

    this._calculateSize(this.tickData);

    this._setComponentBounds(this.getPosition(), this._size);
  },
  _getTickValuesWithEndValue: function () {
    return this._getTickValues();
  },
  fixScaleAndTickData: function () {
    this.scale.domain(this._dataDomain);
    this.isRangePoints ? this.scale.rangePoints(this._getRange()) : this.scale.rangeBands(this._getRange());

    this._updateOriginTickData();

    this._calculateTickPosAndStep();
  },
  _getRange: function () {
    var plotRange = this._getPlotRange(); //没有缩放的时候直接返回


    if (this._dataDomain.length == this._domain.length) {
      return plotRange;
    }

    var rangeBands,
        rangeLength = Math.abs(plotRange[1] - plotRange[0]);

    if (this.isRangePoints) {
      rangeBands = rangeLength / Math.max(this._domain.length - 1, 1);
    } else {
      rangeBands = rangeLength / this._domain.length;
    }

    var startIndex = _BaseUtils["default"].indexOf(this._dataDomain, this._domain[0]);

    var endIndex = this._dataDomain.length - _BaseUtils["default"].indexOf(this._dataDomain, this._domain[this._domain.length - 1]) - 1;

    if (!(this.isAxisReversed() ^ this.isHorizontal())) {
      var tmp = startIndex;
      startIndex = endIndex;
      endIndex = tmp;
    }

    var min = -startIndex * rangeBands,
        max = rangeLength + endIndex * rangeBands;

    if (this.isHorizontal()) {
      return this.isAxisReversed() ? [max, min] : [min, max];
    } else {
      return this.isAxisReversed() ? [min, max] : [max, min];
    }
  },
  _getRangeFromDomain: function (domain) {
    var plotRange = this._getPlotRange();

    var rangeBands,
        rangeLength = Math.abs(plotRange[1] - plotRange[0]);

    if (this.isRangePoints) {
      rangeBands = rangeLength / Math.max(domain.length - 1, 1);
    } else {
      rangeBands = rangeLength / domain.length;
    }

    var startIndex = _BaseUtils["default"].indexOf(this._dataDomain, domain[0]);

    var endIndex = this._dataDomain.length - _BaseUtils["default"].indexOf(this._dataDomain, domain[domain.length - 1]) - 1;

    if (!(this.isAxisReversed() ^ this.isHorizontal())) {
      var tmp = startIndex;
      startIndex = endIndex;
      endIndex = tmp;
    }

    var min = -startIndex * rangeBands,
        max = rangeLength + endIndex * rangeBands;

    if (this.isHorizontal()) {
      return this.isAxisReversed() ? [max, min] : [min, max];
    } else {
      return this.isAxisReversed() ? [min, max] : [max, min];
    }
  },
  _getPlotRange: function () {
    return this.vanchart.isMobileFlow() ? this.getWholeRange() : _BaseAxis["default"].prototype._getPlotRange.call(this);
  },
  getLabelAutoRotation: function (labels, axisOption, formatter) {
    if (axisOption.autoRotate && !axisOption.labelRotation) {
      var isInverted = this.vanchart.isInverted();
      var longLabel = labels.reduce(function (a, b) {
        return _BaseUtils["default"].getTextDimension(a).width > _BaseUtils["default"].getTextDimension(b).width ? a : b;
      });

      var longContent = this._getTickContent(longLabel, formatter);

      var longDim = _BaseUtils["default"].getTextDimensionWithRotation(longContent, axisOption.labelStyle, axisOption.useHtml, axisOption.labelRotation);

      var gap = Math.max.apply(null, this._getPlotRange()) / this._domain.length - LABEL_LINE_GAP_FUN();
      var w, h;

      if (isInverted) {
        w = longDim.height;
        h = longDim.width;
      } else {
        w = longDim.width;
        h = longDim.height;
      }

      var l = Math.sqrt(w * w + h * h);

      if (h > gap) {
        return -90;
      } else if (w > gap) {
        var alpha = Math.acos(gap / l);
        var beta = Math.atan(h / w);
        var theta = alpha + beta;
        return -_BaseUtils["default"].toDegree(theta);
      }
    }
  },
  getCategoryCount: function () {
    return this._dataDomain.length;
  },
  indexOfLabel: function (label) {
    return _BaseUtils["default"].indexOf(this._dataDomain, label);
  },
  getTickLength: function () {
    var domain = this.scale.domain();
    var range = this.scale.rangeExtent();
    var cateLength = Math.abs(range[1] - range[0]);

    if (this.isRangePoints && domain.length <= 1) {
      return cateLength;
    }

    return this.isRangePoints ? cateLength / (domain.length - 1) : this.scale.rangeBand();
  },
  _getTickValues: function () {
    return this._domain;
  },
  getCategories: function () {
    return this._dataDomain;
  },
  axisZoom: function (downPos, upPos) {
    var startPos, endPos;
    var plotBounds = this.vanchart.bounds; //坐标轴是横向的

    if (this.isHorizontal()) {
      startPos = Math.min(downPos.x, upPos.x) - plotBounds.x;
      endPos = Math.max(downPos.x, upPos.x) - plotBounds.x;
    } else {
      startPos = Math.min(downPos.y, upPos.y) - plotBounds.y;
      endPos = Math.max(downPos.y, upPos.y) - plotBounds.y;
    }

    var domain = this.scale.domain();

    var range = this._getRange();

    var tmpScale = _Scale["default"].quantize().domain(range).range(domain);

    var start = _BaseUtils["default"].indexOf(this._dataDomain, tmpScale(startPos));

    var end = _BaseUtils["default"].indexOf(this._dataDomain, tmpScale(endPos));

    this.zoomRefresh(this._dataDomain.slice(Math.min(start, end), Math.max(start, end) + 1));
  },
  getIndexByPosition: function (pos) {
    return this._getIndexByXYCoordinate(pos);
  },
  _getIndexByXYCoordinate: function (pos) {
    var plotBounds = this.getPlotBounds();
    var scale = this.scale;
    var isHorizontal = this.isHorizontal();
    var isReversed = this.isAxisReversed() ^ !isHorizontal;
    var startX = scale(isReversed ? scale.domain()[scale.domain().length - 1] : scale.domain()[0]);
    var x;

    if (isHorizontal) {
      x = pos[0] - plotBounds.x - startX;
    } else {
      x = pos[1] - plotBounds.y - startX;
    }

    var index;
    var categories = this.getCategories();

    if (categories.length > 1) {
      var unitLength = Math.abs(scale(scale.domain()[1]) - scale(scale.domain()[0]));
      index = isReversed ? categories.length - 1 - x / unitLength : x / unitLength;
    } else {
      index = 0;
    }

    if (this.isRangePoints) {
      index = Math.round(index);
    } else {
      index = isReversed ? Math.ceil(index) : Math.floor(index);
    }

    return index;
  },
  getPointsInCategory: function (containerPoint) {
    var plotBounds = this.vanchart.bounds;

    var domain = this.scale.domain(),
        range = this._getRange();

    var tmpScale = _Scale["default"].quantize().domain(range).range(domain);

    var category = tmpScale(this.isHorizontal() ? containerPoint.x - plotBounds.x : containerPoint.y - plotBounds.y);
    return this.vanchart.getValidPointsPara(category);
  },
  drawHighlightBackground: function (sharedPoints) {
    if (this.vanchart.onSeriesRendering()) {
      return;
    } // TODO 当所有的动画执行完成的时候，animationCount应该归为0，否则将无法触发animationEnd


    var category = sharedPoints[0].getCategory();
    var highlightType = 'line';
    sharedPoints.map(function (point) {
      var series = point.series;

      if (series.type === _Constants["default"].BAR_CHART || series.type === _Constants["default"].COLUMN_CHART) {
        highlightType = 'band';
      }
    }); // 缓存下这一次的sharedPoints，在图表resize的时候，重新绘制坐标轴会用上。

    this._lastSharedPoints = sharedPoints;
    var plotBounds = this.getPlotBounds(),
        isHorizontal = this.isHorizontal();
    var scale = this.scale,
        rangeBand = scale.rangeBand ? scale.rangeBand() : 0;
    var from = scale(category),
        to = from + rangeBand,
        renderer = this.vanchart.renderer;

    if ((0, _CoreUtils.isNull)(from)) {
      //监控刷新 改变坐标轴的scale，这边from为undefined
      return;
    }

    var x = 'x',
        y = 'y',
        width = 'width',
        height = 'height',
        size = plotBounds.height;
    var x1 = 'x1',
        x2 = 'x2',
        y1 = 'y1',
        y2 = 'y2';

    if (!isHorizontal) {
      x = 'y';
      y = 'x';
      width = 'height';
      height = 'width';
      size = plotBounds.width;
      x1 = 'y1';
      x2 = 'y2';
      y1 = 'x1';
      y2 = 'x2';
    }

    switch (highlightType) {
      case 'band':
        var bandAttr = {};
        bandAttr[x] = from;
        bandAttr[y] = 0;
        bandAttr[width] = Math.abs(from - to);
        bandAttr[height] = size;

        if (!this.highlightBand) {
          this.highlightBand = renderer.rect().attr(bandAttr).style({
            'fill': 'rgb(98,179,240)',
            'fill-opacity': 0.2
          }).addTo(this.vanchart.highlightGroup);
        }

        this.highlightBand.attr('transform', _BaseUtils["default"].makeTranslate(plotBounds)).animate({
          duration: 250,
          ease: _BezierEasing["default"].css['ease'],
          attr: bandAttr
        });
        this.highlightLine && this.highlightLine.remove();
        this.highlightLine = null;
        break;

      case 'line':
      default:
        if (rangeBand) {
          from = (from + to) / 2;
        }

        var attr = {};
        attr[x1] = from;
        attr[y1] = 0;
        attr[x2] = from;
        attr[y2] = size;

        if (!this.highlightLine) {
          this.highlightLine = renderer.line().attr(attr).style({
            'stroke': 'rgb(140,140,140)',
            'stroke-width': 1
          }).addTo(this.vanchart.highlightGroup);
        }

        this.highlightLine.attr('transform', _BaseUtils["default"].makeTranslate(plotBounds)).animate({
          duration: 250,
          ease: _BezierEasing["default"].css['ease'],
          attr: attr
        });
        this.highlightBand && this.highlightBand.remove();
        this.highlightBand = null;
    }
  },
  removeHighlightBackground: function () {
    this.highlightBand && this.highlightBand.remove();
    this.highlightLine && this.highlightLine.remove();
    this.highlightBand = null;
    this.highlightLine = null;
  },
  isMultiCateAxis: function () {
    return false;
  }
});

var _default = CategoryAxis;
exports["default"] = _default;

/***/ }),
/* 52 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _component = __webpack_require__(4);

var _BoundsManager = _interopRequireDefault(__webpack_require__(25));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _VanChartLabel = _interopRequireDefault(__webpack_require__(160));

var _CoreUtils = __webpack_require__(3);

var _VanChartAutoLabel = __webpack_require__(76);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2016/11/8.
 */
var MIN_POINTS_DISTANCE = 40; // 折线图与面积图标记点类型为自动时，标记点显示时的最小距离

function calculateSeries(vanchart, reRender) {
  var init = !reRender;

  _calculatePercentageRelated(vanchart);

  _calculateTypePercentage(vanchart.seriesOfType(_Constants["default"].WORD_CLOUD_CHART));

  if (init) {
    calculateDelayTime(vanchart, vanchart.seriesOfType(_Constants["default"].BUBBLE_CHART), _Constants["default"].BUBBLE_CHART);
    calculateDelayTime(vanchart, vanchart.seriesOfType(_Constants["default"].SCATTER_CHART), _Constants["default"].SCATTER_CHART);
    calculateBubbleRadius(vanchart.seriesOfType(_Constants["default"].BUBBLE_CHART));
    calculateBubbleRadius(vanchart.seriesOfType(_Constants["default"].FORCE_BUBBLE_CHART));
  }
}

function calculateSeriesShapes(vanchart) {
  for (var i = 0, len = vanchart.series.length; i < len; i++) {
    var ser = vanchart.series[i];

    if (ser.visible) {
      ser.doLayout();
    }
  }

  (0, _VanChartLabel["default"])(vanchart);
  (0, _VanChartAutoLabel.adjustAutoChartLabel)(vanchart);

  _adjustMobileFlowLabel(vanchart);

  _adjustPieRadius(vanchart.seriesOfType(_Constants["default"].PIE_CHART));
}

function setSeriesMarkerDisplayable(series, isMarkerDisplayable) {
  series.forEach(function (ser) {
    var symbol = ser.marker && ser.marker.symbol;

    if (symbol === _Constants["default"].SYMBOL_AUTO) {
      ser.isMarkerDisplayable = isMarkerDisplayable;
    }
  });
}
/**
 * 根据标记点类型自动规则判断标记点是否显示
 * @param vanchart
 * @param series
 * @param type
 * @private
 */


function _adjustMarkerDisplayable(vanchart, series, type) {
  if (series.length === 0) {
    return;
  }

  var plotOptions = vanchart.options.plotOptions,
      _options = plotOptions[type];
  var plotOptionsMarker = _options && _options.marker || plotOptions.marker;
  var symbol = plotOptionsMarker && plotOptionsMarker.symbol;

  if (symbol !== _Constants["default"].SYMBOL_AUTO) {
    return;
  }

  var isInverted = vanchart.isInverted();
  var plotBounds = vanchart.bounds,
      allDistance = isInverted ? plotBounds.height : plotBounds.width;
  var maxLimitNum = Math.round(allDistance / MIN_POINTS_DISTANCE);

  var validPoints = function (points) {
    return points.filter(function (point) {
      return !point.isNull;
    });
  };

  var maxPointsNum = Math.max.apply(Math, series.map(function (ser) {
    return validPoints(ser.points).length;
  }));

  if (maxLimitNum < maxPointsNum) {
    setSeriesMarkerDisplayable(series, false);
    return;
  }

  var serWidthMaxPoints = series.filter(function (ser) {
    return validPoints(ser.points).length === maxPointsNum;
  })[0];
  var axis = serWidthMaxPoints.xAxis;

  if (axis.type === 'category') {
    setSeriesMarkerDisplayable(series, true);
    return;
  }

  var key = 'x';

  var valueArr = _getAllPointsValue(series, axis, key);

  var min = Math.min.apply(Math, valueArr),
      max = Math.max.apply(Math, valueArr);
  var serValidPoints = validPoints(serWidthMaxPoints.points);
  var averageLimitNum = maxLimitNum / 4,
      averageValue = (max - min) / 4;
  var firstPart = [],
      secondPart = [],
      thirdPart = [],
      fourthPart = [];
  serValidPoints.forEach(function (point) {
    var options = point.options;
    var value = axis.getAxisValue(options[key], point) - min;

    if (0 <= value && value < averageValue) {
      firstPart.push(point);
    } else if (value >= averageValue && value < averageValue * 2) {
      secondPart.push(point);
    } else if (value >= averageValue * 2 && value < averageValue * 3) {
      thirdPart.push(point);
    } else {
      fourthPart.push(point);
    }
  });
  var isMarkerDisplayable = firstPart.length <= averageLimitNum && secondPart.length <= averageLimitNum && thirdPart.length <= averageLimitNum && fourthPart.length <= averageLimitNum;
  setSeriesMarkerDisplayable(series, isMarkerDisplayable);
}

function _getAllPointsValue(series, axis, key) {
  var valueArr = [];
  series.forEach(function (ser) {
    var valueOrigin = ser.points.map(function (point) {
      return axis.getAxisValue(point.options[key], point);
    });
    valueArr = valueArr.concat(valueOrigin);
  });
  return valueArr;
}

function _adjustMobileFlowLabel(vanchart) {
  if (vanchart.isMobileFlow()) {
    var manager = new _BoundsManager["default"]();

    for (var i = 0, len = vanchart.series.length; i < len; i++) {
      var ser = vanchart.series[i];

      if (ser.visible) {
        ser.points.forEach(function (point) {
          if (!point.labelPos) {
            return;
          }

          var absLabelPos = ser.getAbsoluteLabelPos(point.labelPos);

          var b = _BaseUtils["default"].makeBounds(absLabelPos, point.labelDim);

          if (manager.isOverlapped(b)) {
            point.labelPos = null;
          } else {
            manager.addBounds(b);
          }
        });
      }
    }
  }
}

function PLANE_SYSTEM_LAYOUT(vanchart) {
  calculateSeries(vanchart);
  fixCoordinateSystem(vanchart);
}

function _adjustPieRadius(series) {
  var _sCache = [];
  var minRadius = series.reduce(function (min, s) {
    if (!s.options.radius) {
      // if it's calculated by us
      _sCache.push(s);
    }

    return min ? Math.min(min, s.chartInfo.radius) : s.chartInfo.radius; // get min calculated radius
  }, 0);

  _sCache.map(function (s) {
    s.adjustRadius(minRadius);
  });
}
/**
 *计算百分比，然后堆积的值，然后标签
 * @private
 */


function _calculatePercentageRelated(vanchart) {
  var stackMap = {},
      series = vanchart.series;

  for (var i = 0, len = series.length; i < len; i++) {
    var ser = series[i],
        type = ser.type;

    if (ser.isTreeSeries() || type == _Constants["default"].WORD_CLOUD_CHART) {
      continue; //树图在内部计算
    }

    if (ser.isSeriesAccumulated()) {
      if (ser._calculatePercentage) {
        ser._calculatePercentage();
      } else {
        var key = ser.getTargetKey();

        _calculatePercentage(ser.points, key);

        _calculateStackedValue(ser.points, key);
      }
    } else {
      if (ser.visible) {
        ser.points.map(function (p) {
          var stackKey = [type, ser.stack, p.getCategory()].join('-');
          stackMap[stackKey] || (stackMap[stackKey] = []);
          stackMap[stackKey].push(p);
        });
      }
    }
  }

  for (var stackKey in stackMap) {
    var points = stackMap[stackKey];
    var key = points[0].series.getTargetKey();

    _calculatePercentage(points, key);

    _calculateStackedValue(points, key);
  } //百分比确定以后标签也确定了


  for (var i = 0, len = series.length; i < len; i++) {
    var sery = series[i];
    sery.points.forEach(function (p) {
      sery.calculateLabelInfo(p);
    });
  }
}

function _calculateTypePercentage(series) {
  if (series && series.length) {
    var allPoints = [];
    series.forEach(function (ser) {
      allPoints = allPoints.concat(ser.points);
    });

    _calculatePercentage(allPoints, series[0].getTargetKey());
  }
}

function calculateDelayTime(vanchart, series, type) {
  var sortFunc, easeFunc;

  if (type == _Constants["default"].BUBBLE_CHART) {
    easeFunc = 'swing';

    sortFunc = function (pointA, pointB) {
      return pointB.radius - pointA.radius;
    };
  } else if (type == _Constants["default"].SCATTER_CHART) {
    var isInverted = vanchart.isInverted();
    easeFunc = 'exp-in-out';

    sortFunc = function (pA, pB) {
      return isInverted ? pA.posY - pB.posY : pA.posX - pB.posX;
    };
  }

  var allPoints = [];
  series.forEach(function (sery) {
    allPoints = allPoints.concat(sery.points);
  });
  allPoints.sort(sortFunc);
  var len = allPoints.length;

  if (len > 0) {
    allPoints.forEach(function (point, i) {
      point.delayTime = _BezierEasing["default"].ease(easeFunc)(i / len) * 800;
    });
  }
}

function calculateBubbleRadius(bubbleSeries) {
  //要先把各个系列计算半径用的最大最小值算清楚，再去算各个点的半径
  bubbleSeries.forEach(function (sery) {
    sery._calculateMinMax4Radius();
  });
  bubbleSeries.forEach(function (sery) {
    sery._calculateBubbleRadius();
  });
}
/**
 * 计算数据点的y0属性，用于数据在值轴上的起始位置计算
 * @param points
 * @param key
 * @private
 */


function _calculateStackedValue(points, key) {
  if (points && points.length) {
    var preSumP, preSumN;
    points.forEach(function (point) {
      // @CHART-1604  这里的series应该是具体point的series.因为points下面的每个point可能不在同一个值轴上
      // 这时如果第一个值轴为对数轴，其他的值轴为普通轴，那么不是对数轴的数据点的y0也会变成1了
      var options = point.options,
          series = point.series;
      var byPercent = series.options.stackByPercent;
      var stack = series.stack || byPercent;
      var stackAxis = series.getStackAxis();
      var dividingLine = stackAxis && stackAxis.isLog() ? 1 : 0; //值轴起始

      if (!(0, _CoreUtils.hasDefined)(preSumP)) {
        preSumP = dividingLine;
      }

      if (!(0, _CoreUtils.hasDefined)(preSumN)) {
        preSumN = dividingLine;
      }

      if (stack) {
        // 堆积值轴
        var usedValue = byPercent ? point.percentage : point.getTargetValue();

        if (usedValue >= dividingLine) {
          options[key + '0'] = preSumP;
          preSumP += usedValue;
        } else {
          options[key + '0'] = preSumN;
          preSumN += usedValue;
        }
      } else {
        options[key + '0'] = dividingLine;
      }
    });
  }
}

function _calculatePercentage(points, key) {
  var total = 0;
  points.filter(function (d) {
    return !d.isNull && d.visible;
  }).forEach(function (d) {
    total += Math.abs(d[key]);
  });
  total = total > 0 ? total : 1;
  points.forEach(function (point) {
    var series = point.series,
        key = series.getTargetKey(),
        baseAxis = series[series.getBaseAxisType()];
    var temp = !series.stack && baseAxis && baseAxis.type != _component.ComponentCst.CATEGORY_AXIS_COMPONENT; //不堆积，双值轴，百分比为1

    point.percentage = temp ? 1 : point.series.isNullValue(point) ? 0 : Math.abs(point[key]) / total;
  });
}

function fixCoordinateSystem(vanchart) {
  vanchart.bounds = vanchart._getDefaultBounds();

  _adjustMarkerDisplayable(vanchart, vanchart.seriesOfType(_Constants["default"].LINE_CHART), _Constants["default"].LINE_CHART); // 组件的布局只有在刷新属性的时候会发生


  _component.ComponentsOrder.map(function (c) {
    // axis layout的时候不去clip vanchart.bounds,这一步的时候认为坐标轴和绘图区是一起的
    if (c in vanchart.components) {
      vanchart.components[c] && vanchart.components[c].doLayout();
    }
  }, this);

  vanchart._initPlotBounds = vanchart.bounds; //记录一下plotBounds
  // 先确定横向宽度, 再更新分类轴的自动旋转和数据表的高度

  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].updateAxisClip();
  }); // only for axis bounds now

  _cutPlotBounds(vanchart); // 先确定横向宽度, 再更新分类轴的自动旋转和数据表的高度


  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.DATA_SHEET_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].updateAxisSizeAndBounds();
  });
  var adjusted = false; // 先确定横向宽度, 再更新分类轴的自动旋转

  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT].forEach(function (cName) {
    adjusted = vanchart.components[cName] && vanchart.components[cName].adjustDomain4Radius() || adjusted;
  });
  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.DATA_SHEET_COMPONENT, _component.ComponentCst.ZOOM_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].fixBoundsByPlot();
  });
  [_component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.Y_AXIS_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].dealOnZero();
  }); // CHART-1450
  // 下一步的作用是在js处理值轴的0值对齐之后更新每一个值轴的bounds属性，为什么要提取到这里来写呢？
  // 因为由于CHART-1450我才发现原来散点图的两个轴都是type为value的值轴，
  // 而刚开始的思路是一个图表中的两种坐标轴类型只有一种是值轴，其他的可以是分类轴、时间轴，所以就有了散点图的问题
  // 现将updateAxisBounds提取到这里来调用也是为了避免js重复运算。

  [_component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.Y_AXIS_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].updateAxisBounds();
  }); // in case:
  // 'adjustDomain4Radius' adjust yAxis max label 800 -> 1000.
  // Thus yAxis width is changed;

  adjusted && reLayoutPlotBounds(vanchart);
  calculateSeriesShapes(vanchart);
}

function reLayoutPlotBounds(vanchart) {
  // tmp solution: map has no _initPlotBounds
  if (vanchart._initPlotBounds) {
    vanchart.bounds = _QueryUtils["default"].merge({}, vanchart._initPlotBounds);
  }

  vanchart.clipPool = {};
  vanchart.axisSize = {
    'left': 0,
    'right': 0,
    'bottom': 0,
    'top': 0
  }; // CHART-2118  数据表的布局放在前面，后面axisSize那边会更新clipPool去掉数据表对多计算的部分

  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.DATA_SHEET_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].reCalculateSize();
  }); //先确定横向宽度, 再更新分类轴的自动旋转和数据表的高度

  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].updateAxisClip();
  }); // only for axis bounds now

  _cutPlotBounds(vanchart); //先确定横向宽度, 再更新分类轴的自动旋转和数据表的高度


  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.DATA_SHEET_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].updateAxisSizeAndBounds();
  });
  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.ZOOM_COMPONENT, _component.ComponentCst.DATA_SHEET_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].fixBoundsByPlot();
  });
  [_component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.Y_AXIS_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].dealOnZero();
  });
  [_component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.Y_AXIS_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].updateAxisBounds();
  });
} // CHART-1215 / 9.0-0值对齐
// 当处理分类轴对值轴0值对齐之后，改变了某些值轴的_domain和_step，
// 所以需要重新计算这些值轴的所占的宽度、位置以及重新计算在新的_domain和_step下的tickData


function reLayoutPlotBoundsAfterDealOnZero(vanchart) {
  // tmp solution: map has no _initPlotBounds
  if (vanchart._initPlotBounds) {
    vanchart.bounds = _QueryUtils["default"].merge({}, vanchart._initPlotBounds);
  }

  vanchart.clipPool = {};
  vanchart.axisSize = {
    'left': 0,
    'right': 0,
    'bottom': 0,
    'top': 0
  };
  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.DATA_SHEET_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].reCalculateSize();
  }); //先确定横向宽度, 再更新分类轴的自动旋转和数据表的高度

  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].updateAxisClip();
  }); // only for axis bounds now

  _cutPlotBounds(vanchart); // 先确定横向宽度, 再更新分类轴的自动旋转和数据表的高度


  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.DATA_SHEET_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].updateAxisSizeAndBounds();
  });
  [_component.ComponentCst.Y_AXIS_COMPONENT, _component.ComponentCst.X_AXIS_COMPONENT, _component.ComponentCst.ZOOM_COMPONENT, _component.ComponentCst.DATA_SHEET_COMPONENT].forEach(function (cName) {
    vanchart.components[cName] && vanchart.components[cName].fixBoundsByPlot();
  });
} // compare bounds to check if we need cut more


function _cutPlotBounds(vanchart) {
  var chartBounds = vanchart.getChartBounds();
  var originBounds = vanchart.bounds;
  var x = originBounds.x;
  var y = originBounds.y;
  var width = originBounds.width;
  var height = originBounds.height;
  var left = Math.max(vanchart.clipPool[_Constants["default"].LEFT] || 0, x);
  var right = Math.max(vanchart.clipPool[_Constants["default"].RIGHT] || 0, chartBounds.width - (x + width));
  var top = Math.max(vanchart.clipPool[_Constants["default"].TOP] || 0, y);
  var bottom = Math.max(vanchart.clipPool[_Constants["default"].BOTTOM] || 0, chartBounds.height - (y + height));
  originBounds = {
    x: left,
    y: top,
    width: chartBounds.width - left - right,
    height: chartBounds.height - top - bottom
  };
  vanchart.setPlotBounds(originBounds);
}

var _default = {
  PLANE_SYSTEM_LAYOUT: PLANE_SYSTEM_LAYOUT,
  reLayoutPlotBounds: reLayoutPlotBounds,
  calculateBubbleRadius: calculateBubbleRadius,
  calculateDelayTime: calculateDelayTime,
  calculateSeries: calculateSeries,
  calculateSeriesShapes: calculateSeriesShapes,
  reLayoutPlotBoundsAfterDealOnZero: reLayoutPlotBoundsAfterDealOnZero
};
exports["default"] = _default;

/***/ }),
/* 53 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Browser = _interopRequireDefault(__webpack_require__(8));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/8/17.
 */
var LegendPath = {};
var LegendSize = {};
var ICON_TEXT_SCALE = 0.85; // 圆形方形占字体大小的比例

var rectAndCircleIcon = [_Constants["default"].NORMAL_ICON, _Constants["default"].BUBBLE_ICON, _Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE, _Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE_HOLLOW, _Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE, _Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE_HOLLOW];
LegendPath[_Constants["default"].PIE_ICON] = "M16.1711539,7 C22.882066,7 28.7582496,10.4779063 32.0002511,15.682597 L15.492372,25 L0.00021052449,16.2548919 C3.15945315,10.7344266 9.21715568,7 16.1711539,7 Z";
LegendSize[_Constants["default"].PIE_ICON] = {
  width: 32,
  height: 32
};
LegendPath[_Constants["default"].TREEMAP_ICON] = 'M9,12H3c-1.6,0-3-1.4-3-3l0-6c0-1.6,1.3-3,3-3l6,0c1.7,0,3,1.4,3,3v6C12,10.6,10.6,12,9,12z';
LegendSize[_Constants["default"].TREEMAP_ICON] = {
  width: 12,
  height: 12
};
LegendPath[_Constants["default"].DONUT_ICON] = "M16.1709434,8 C22.8819622,8 28.7582258,11.4603001 32.0001952,16.6386156 L21.5039708,22.5334633 C20.579905,20.4209885 18.4632188,18.9439669 15.9997895,18.9439669 C13.3586911,18.9439669 11.1161556,20.6417249 10.3145981,23.0001357 L-0.000152222903,17.2080129 C3.15904804,11.7155231 9.21683346,8 16.1709434,8 Z";
LegendSize[_Constants["default"].DONUT_ICON] = {
  width: 32,
  height: 32
};
LegendPath[_Constants["default"].NORMAL_ICON] = 'M0,0L12,0L12,12L0,12Z';
LegendSize[_Constants["default"].NORMAL_ICON] = {
  width: 12,
  height: 12
};
LegendPath[_Constants["default"].BUBBLE_ICON] = "M6,11.5c-1.47,0-2.851-0.572-3.889-1.611C1.072,8.851,0.5,7.47,0.5,6s0.572-2.851,1.611-3.889C3.149,1.072,4.53,0.5,6,0.5s2.851,0.572,3.889,1.611C10.928,3.149,11.5,4.53,11.5,6s-0.572,2.851-1.611,3.889C8.851,10.928,7.47,11.5,6,11.5z";
LegendSize[_Constants["default"].BUBBLE_ICON] = {
  width: 11,
  height: 11
};
LegendPath[_Constants["default"].NULL_MARKER] = "M29.5,13.5 C30.8807119,13.5 32,14.6192881 32,16 C32,17.3254834 30.9684641,18.4100387 29.6643757,18.4946823 L29.5,18.5 L2.5,18.5 C1.11928813,18.5 0,17.3807119 0,16 C0,14.6745166 1.03153594,13.5899613 2.33562431,13.5053177 L2.5,13.5 L29.5,13.5 Z";
LegendSize[_Constants["default"].NULL_MARKER] = {
  width: 32,
  height: 32
};
LegendPath[_Constants["default"].CIRCLE] = "M16,8 C19.5449966,8 22.5514499,10.3057777 23.6014229,13.499396 L23.6015963,13.4999235 L23.6167542,13.5465233 C23.6794628,13.741351 23.7349038,13.9394393 23.7827579,14.1404689 C23.7899489,14.1706765 23.7969842,14.2010193 23.8038463,14.2314277 C23.8497915,14.435015 23.8879903,14.641655 23.9180904,14.8509119 C23.9229126,14.8844344 23.9275355,14.9180889 23.9319484,14.9518094 C23.9586369,15.1557661 23.9776373,15.3620364 23.9886632,15.5704214 C23.9903758,15.6027909 23.9918939,15.6351629 23.993219,15.6675847 C23.997724,15.7777783 24,15.8886233 24,16 C24,16.1090141 23.9978195,16.217519 23.9934998,16.3254733 L24,16 C24,16.1417048 23.9963157,16.2825491 23.9890377,16.4224424 C23.9781504,16.6316396 23.9592447,16.8385728 23.9326156,17.0430797 C23.927786,17.0801933 23.922611,17.1178568 23.9171747,17.1554359 C23.8871888,17.3626011 23.8494053,17.5665752 23.8040476,17.7676797 C23.797382,17.7972309 23.7905887,17.8265688 23.7836345,17.8558445 C23.7356361,18.0579429 23.6798772,18.2573617 23.6167542,18.4534767 C23.6115923,18.4695107 23.6065308,18.4850679 23.6014229,18.500604 C22.5514499,21.6942223 19.5449966,24 16,24 C12.4550034,24 9.44855013,21.6942223 8.39857709,18.500604 L8.39857709,18.500604 L8.38324583,18.4534767 C8.32012283,18.2573617 8.26436385,18.0579429 8.21629457,17.855546 C8.2094113,17.8265688 8.20261802,17.7972309 8.19598662,17.7678316 C8.15059467,17.5665752 8.11281122,17.3626011 8.08291749,17.1560731 C8.07738904,17.1178568 8.072214,17.0801933 8.06730206,17.042447 C8.04075528,16.8385728 8.02184959,16.6316396 8.01096962,16.4225824 C8.00928221,16.3901483 8.00779361,16.3578034 8.00649762,16.3254091 C8.00218048,16.217519 8,16.1090141 8,16 C8,15.8872733 8.00233152,15.7750912 8.00694897,15.6634992 L8,16 C8,15.8559017 8.00380981,15.7126932 8.01133421,15.5704698 C8.02236272,15.3620364 8.04136312,15.1557661 8.06803842,14.9519101 C8.07246447,14.9180889 8.07708736,14.8844344 8.08191889,14.8508474 C8.11200967,14.641655 8.15020846,14.435015 8.19617811,14.2313197 C8.20301581,14.2010193 8.21005106,14.1706765 8.21725841,14.1404005 C8.26509616,13.9394393 8.32053716,13.741351 8.38324583,13.5465233 C8.38826834,13.5309195 8.393313,13.5154111 8.39840368,13.4999235 C9.44855013,10.3057777 12.4550034,8 16,8 Z M6.3149723,13.5002775 C6.10935719,14.2992437 6,15.136851 6,16 C6,16.8634306 6.10942855,17.7013028 6.31517356,18.5005044 L2.5,18.5 C1.11928813,18.5 1.69088438e-16,17.3807119 0,16 C-1.69088438e-16,14.6192881 1.11928813,13.5 2.5,13.5 L6.3149723,13.5002775 Z M29.5,13.5 C30.8807119,13.5 32,14.6192881 32,16 C32,17.3807119 30.8807119,18.5 29.5,18.5 L25.6848264,18.5005044 C25.8905715,17.7013028 26,16.8634306 26,16 C26,15.136851 25.8906428,14.2992437 25.6850277,13.5002775 L29.5,13.5 Z";
LegendSize[_Constants["default"].CIRCLE] = {
  width: 32,
  height: 32
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].NULL_MARKER] = 'M0,0L12,0L12,12L0,12Z';
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].NULL_MARKER] = {
  width: 12,
  height: 12
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].NORMAL_ICON] = 'M0,0L12,0L12,12L0,12Z';
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].NORMAL_ICON] = {
  width: 12,
  height: 12
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE] = "M4,8C2.897,8,1.897,7.551,1.173,6.827S0,5.103,0,4s0.449-2.103,1.173-2.827S2.897,0,4,0s2.103,0.449,2.827,1.173S8,2.897,8,4S7.551,6.103,6.827,6.827S5.103,8,4,8";
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE] = {
  width: 8,
  height: 8
};
LegendPath[_Constants["default"].SQUARE] = 'M24,24 L8,24 L8,8 L24,8 L24,24 Z M6,13.5 L6,18.5 L2.5,18.5 C1.11928813,18.5 1.69088438e-16,17.3807119 0,16 C-1.69088438e-16,14.6192881 1.11928813,13.5 2.5,13.5 L6,13.5 Z M29.5,13.5 C30.8807119,13.5 32,14.6192881 32,16 C32,17.3807119 30.8807119,18.5 29.5,18.5 L26,18.5 L26,13.5 L29.5,13.5 Z';
LegendSize[_Constants["default"].SQUARE] = {
  width: 32,
  height: 32
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE] = "M0,0h8c0,0,0,3.889,0,8C4,8,0,8,0,8V0z";
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE] = {
  width: 8,
  height: 8
};
LegendPath[_Constants["default"].DIAMOND] = "M15.9903066,23.9806133 L8,15.9903066 L9.208,14.782 L10.49,13.5 L10.491,13.499 L15.9903066,8 L21.489,13.499 L21.49,13.5 L23.9806133,15.9903066 L15.9903066,23.9806133 Z M7.661,13.5 L5.17157288,15.9903066 L7.681,18.5 L2.5,18.5 C1.11928813,18.5 1.69088438e-16,17.3807119 0,16 C-1.69088438e-16,14.6192881 1.11928813,13.5 2.5,13.5 L7.661,13.5 Z M29.5,13.5 C30.8807119,13.5 32,14.6192881 32,16 C32,17.3807119 30.8807119,18.5 29.5,18.5 L24.299,18.5 L26.8090404,15.9903066 L24.319,13.5 L29.5,13.5 Z";
LegendSize[_Constants["default"].DIAMOND] = {
  width: 32,
  height: 32
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].DIAMOND] = "M0,4.5L4.502,0l4.5,4.5c0,0,0,0-4.5,4.5C0,4.5,0,4.5,0,4.5z";
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].DIAMOND] = {
  width: 9,
  height: 9
};
LegendPath[_Constants["default"].TRIANGLE] = "M16.0378418,0 L19.117,5.499 L19.118,5.5 L21.919,10.5 L25,16 L7,16 L10.106,10.5 L12.93,5.5 L12.931,5.499 L16.0378418,0 Z M10.634,5.5 L7.809,10.5 L2.5,10.5 C1.11928813,10.5 1.69088438e-16,9.38071187 0,8 C-1.69088438e-16,6.61928813 1.11928813,5.5 2.5,5.5 L10.634,5.5 Z M29.5,5.5 C30.8807119,5.5 32,6.61928813 32,8 C32,9.38071187 30.8807119,10.5 29.5,10.5 L24.211,10.5 L21.411,5.5 L29.5,5.5 Z";
LegendSize[_Constants["default"].TRIANGLE] = {
  width: 32,
  height: 16
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].TRIANGLE] = "M4.5,0L9,8c0,0-4.617,0-9,0L4.5,0z";
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].TRIANGLE] = {
  width: 9,
  height: 8
};
LegendPath[_Constants["default"].CIRCLE_HOLLOW] = "M16,8 C19.5449966,8 22.5514499,10.3057777 23.6014229,13.499396 L23.6015963,13.4999235 L23.6167542,13.5465233 C23.6777019,13.7358801 23.7317845,13.928317 23.7787086,14.1235407 C23.7872882,14.1592297 23.7956896,14.1952824 23.8038463,14.2314277 C23.8497915,14.435015 23.8879903,14.641655 23.9180904,14.8509119 C23.9229126,14.8844344 23.9275355,14.9180889 23.9319484,14.9518094 C23.9586369,15.1557661 23.9776373,15.3620364 23.9886632,15.5704214 C23.9903776,15.6028264 23.9918972,15.635234 23.9932234,15.6676915 C23.997724,15.7777783 24,15.8886233 24,16 C24,16.1090141 23.9978195,16.217519 23.9934998,16.3254733 L24,16 C24,16.1376367 23.9965242,16.2744617 23.9896556,16.4103918 C23.9794061,16.6131334 23.9616331,16.8136946 23.9366014,17.0119943 C23.9305879,17.059654 23.9240928,17.1076134 23.9171747,17.1554359 C23.8871888,17.3626011 23.8494053,17.5665752 23.8040476,17.7676797 C23.797382,17.7972309 23.7905887,17.8265688 23.7836345,17.8558445 C23.7356361,18.0579429 23.6798772,18.2573617 23.6167542,18.4534767 C23.6115923,18.4695107 23.6065308,18.4850679 23.6014229,18.500604 C22.5514499,21.6942223 19.5449966,24 16,24 C12.4550034,24 9.44855013,21.6942223 8.39857709,18.500604 L8.39857709,18.500604 L8.38324583,18.4534767 C8.32012283,18.2573617 8.26436385,18.0579429 8.21629457,17.855546 C8.2094113,17.8265688 8.20261802,17.7972309 8.19598662,17.7678316 C8.15059467,17.5665752 8.11281122,17.3626011 8.08291749,17.1560731 C8.0759072,17.1076134 8.06941213,17.059654 8.063344,17.0115615 C8.03836689,16.8136946 8.02059389,16.6131334 8.01035419,16.4105853 C8.00891706,16.3821445 8.00763622,16.3538585 8.00650265,16.3255346 C8.00218048,16.217519 8,16.1090141 8,16 C8,15.8828858 8.00251655,15.7663593 8.00749852,15.6504717 L8,16 C8,15.8559017 8.00380981,15.7126932 8.01133421,15.5704698 C8.02236272,15.3620364 8.04136312,15.1557661 8.06803842,14.9519101 C8.07246447,14.9180889 8.07708736,14.8844344 8.08191889,14.8508474 C8.11200967,14.641655 8.15020846,14.435015 8.19617811,14.2313197 C8.20431043,14.1952824 8.21271182,14.1592297 8.22135606,14.1232717 C8.26821552,13.928317 8.32229806,13.7358801 8.38324583,13.5465233 C8.38826834,13.5309195 8.393313,13.5154111 8.39840368,13.4999235 C9.44855013,10.3057777 12.4550034,8 16,8 Z M16,13 C15.3111497,13 14.6765255,13.232169 14.1701084,13.6225257 C14.1362044,13.6486674 14.1032121,13.675235 14.0708045,13.7024756 L14.1701084,13.6225257 C14.1165669,13.6637965 14.0644586,13.7068356 14.0138709,13.7515554 L14.0708045,13.7024756 C14.0277118,13.7386977 13.9856529,13.7761098 13.9446782,13.8146614 L14.0138709,13.7515554 C13.9699051,13.7904213 13.9270879,13.8305567 13.8854766,13.8719043 L13.9446782,13.8146614 C13.8378985,13.9151265 13.7384824,14.0233298 13.6473258,14.1383756 C13.6368951,14.1515401 13.6265907,14.1647705 13.6163955,14.1780888 L13.6473258,14.1383756 C13.6090135,14.1867283 13.5721602,14.2362897 13.5368324,14.2869932 L13.6163955,14.1780888 C13.5743585,14.2330025 13.5341763,14.2894111 13.4959425,14.3472212 L13.5368324,14.2869932 C13.5027613,14.3358931 13.4701091,14.3858553 13.4389354,14.4368202 L13.4959425,14.3472212 C13.4626638,14.3975389 13.4308612,14.4489183 13.4005963,14.5012977 L13.4389354,14.4368202 C13.4033853,14.4949401 13.369758,14.554364 13.3381421,14.6150034 L13.4005963,14.5012977 C13.3723903,14.5501138 13.3455199,14.5997986 13.3200351,14.6503019 L13.3381421,14.6150034 C13.2473225,14.7891954 13.1730999,14.9734175 13.1175715,15.1655725 C13.1073093,15.2010618 13.0975615,15.2373171 13.0884828,15.2738368 L13.1175715,15.1655725 C13.1012458,15.2220675 13.086536,15.2792482 13.0734954,15.3370614 L13.0884828,15.2738368 C13.0754205,15.3263804 13.0637434,15.3794713 13.0534925,15.4330686 L13.0734954,15.3370614 C13.0585643,15.4032557 13.0458216,15.470279 13.0353471,15.5380514 L13.0534925,15.4330686 C13.0413244,15.4966897 13.0311658,15.5610243 13.0230852,15.6260037 L13.0353471,15.5380514 C13.0253363,15.6028242 13.0173974,15.6682813 13.0116003,15.7343527 L13.0230852,15.6260037 C13.0157079,15.6853277 13.0100626,15.7451891 13.0062016,15.8055359 L13.0116003,15.7343527 C13.0039209,15.8218778 13,15.910481 13,16 L13.0062016,16.1944641 C13.0073861,16.2129774 13.0087385,16.231445 13.0102573,16.2498654 C13.013632,16.2908481 13.0178705,16.3319203 13.022929,16.3727383 L13.0102573,16.2498654 C13.0161479,16.3213064 13.0245416,16.3920378 13.0353507,16.4619715 L13.022929,16.3727383 C13.0310364,16.4381585 13.04125,16.5029257 13.0534998,16.5669698 L13.0353507,16.4619715 C13.0458294,16.5297683 13.0585781,16.5968154 13.0735166,16.6630328 L13.0534998,16.5669698 C13.0637294,16.6204516 13.075379,16.6734291 13.0884078,16.7258617 L13.0735166,16.6630328 C13.0865895,16.7209803 13.1013393,16.7782923 13.1177125,16.8349153 L13.0884078,16.7258617 C13.1423026,16.9427533 13.2197982,17.1503204 13.3180108,17.3456792 C13.3246022,17.3587906 13.3312971,17.3718666 13.3380847,17.3848865 L13.3180108,17.3456792 C13.3441457,17.3976651 13.3717476,17.4487866 13.4007621,17.4989892 L13.3380847,17.3848865 C13.3696522,17.4454392 13.4032253,17.50478 13.4387159,17.5628208 L13.4007621,17.4989892 C13.4310644,17.5514199 13.4629075,17.6028484 13.4962296,17.6532128 L13.4387159,17.5628208 C13.4698686,17.6137675 13.5024986,17.6637125 13.5365465,17.7125963 L13.4962296,17.6532128 C13.5318401,17.707036 13.5691396,17.759644 13.6080526,17.8109611 L13.5365465,17.7125963 C13.5719556,17.7634347 13.6088982,17.8131252 13.6473073,17.861601 L13.6080526,17.8109611 C13.6931837,17.9232288 13.7860372,18.0293185 13.885822,18.1284389 C13.8964986,18.1390479 13.9076052,18.149915 13.9187954,18.160696 L13.885822,18.1284389 C13.9274271,18.1697669 13.9702371,18.2098833 14.0141947,18.2487309 L13.9187954,18.160696 C13.9678609,18.2079674 14.0185326,18.2535833 14.0707205,18.2974537 L14.0141947,18.2487309 C14.0629696,18.2918356 14.1131575,18.3333782 14.16468,18.3732801 L14.0707205,18.2974537 C14.1103221,18.3307438 14.1507968,18.3630288 14.1921052,18.3942694 L14.16468,18.3732801 C14.2121928,18.4100768 14.2608407,18.4454783 14.3105621,18.4794232 L14.1921052,18.3942694 C14.6948472,18.7744814 15.3210873,19 16,19 C16.6911088,19 17.3276354,18.7663061 17.8348687,18.3736296 C17.8671266,18.3486473 17.8984246,18.3233892 17.9291955,18.2975244 L17.8348687,18.3736296 C17.8866635,18.3335325 17.9371101,18.2917776 17.9861291,18.2484446 L17.9291955,18.2975244 C17.9813387,18.2536948 18.0319684,18.2081227 18.080995,18.1608979 L17.9861291,18.2484446 C18.0300949,18.2095787 18.0729121,18.1694433 18.1145234,18.1280957 L18.080995,18.1608979 C18.1780724,18.0673882 18.2688642,17.9673983 18.3526742,17.8616244 C18.3659682,17.8448461 18.3790685,17.8279461 18.3919909,17.8109037 L18.3526742,17.8616244 C18.3909865,17.8132717 18.4278398,17.7637103 18.4631676,17.7130068 L18.3919909,17.8109037 C18.4309928,17.7594668 18.4683737,17.7067332 18.5040575,17.6527788 L18.4631676,17.7130068 C18.4972387,17.6641069 18.5298909,17.6141447 18.5610646,17.5631798 L18.5040575,17.6527788 C18.5373362,17.6024611 18.5691388,17.5510817 18.5994037,17.4987023 L18.5610646,17.5631798 C18.5966147,17.5050599 18.630242,17.445636 18.6618579,17.3849966 L18.5994037,17.4987023 C18.6283612,17.4485855 18.655911,17.3975532 18.6819991,17.3456595 L18.6618579,17.3849966 C18.7526775,17.2108046 18.8269001,17.0265825 18.8824285,16.8344275 C18.8926907,16.7989382 18.9024385,16.7626829 18.9115172,16.7261632 L18.8824285,16.8344275 C18.8987542,16.7779325 18.913464,16.7207518 18.9265046,16.6629386 L18.9115172,16.7261632 C18.9245795,16.6736196 18.9362566,16.6205287 18.9465075,16.5669314 L18.9265046,16.6629386 C18.9414357,16.5967443 18.9541784,16.529721 18.9646529,16.4619486 L18.9465075,16.5669314 C18.9587383,16.5029825 18.9689389,16.4383128 18.9770396,16.3729919 L18.9646529,16.4619486 C18.9754767,16.3919157 18.9838783,16.321083 18.9897696,16.2495386 L18.9770396,16.3729919 C18.9843968,16.3136658 18.990022,16.2538025 18.9938628,16.1934542 L18.9897696,16.2495386 C18.9965451,16.1672556 19,16.0840312 19,16 L18.9938628,15.8065458 C18.9923202,15.782308 18.9904898,15.7581485 18.9883749,15.7340706 C18.985222,15.6981354 18.9814008,15.6621027 18.9769475,15.6262662 L18.9883749,15.7340706 C18.9825793,15.6680872 18.9746476,15.6027166 18.9646493,15.5380285 L18.9769475,15.6262662 C18.96886,15.5611844 18.9586879,15.4967495 18.9465002,15.4330302 L18.9646493,15.5380285 C18.9541706,15.4702317 18.9414219,15.4031846 18.9264834,15.3369672 L18.9465002,15.4330302 C18.9362706,15.3795484 18.924621,15.3265709 18.9115922,15.2741383 L18.9264834,15.3369672 C18.9134105,15.2790197 18.8986607,15.2217077 18.8822875,15.1650847 L18.9115922,15.2741383 C18.8573364,15.0557938 18.7791625,14.8468991 18.6800126,14.6503964 C18.6740235,14.6385277 18.6680068,14.6267981 18.6619153,14.6151135 L18.6800126,14.6503964 C18.6544637,14.5997616 18.627522,14.5499496 18.5992379,14.5010108 L18.6619153,14.6151135 C18.6303478,14.5545608 18.5967747,14.49522 18.5612841,14.4371792 L18.5992379,14.5010108 C18.5689356,14.4485801 18.5370925,14.3971516 18.5037704,14.3467872 L18.5612841,14.4371792 C18.5301314,14.3862325 18.4975014,14.3362875 18.4634535,14.2874037 L18.5037704,14.3467872 C18.4656557,14.2891789 18.425606,14.2329629 18.383714,14.1782318 L18.4634535,14.2874037 C18.4280444,14.2365653 18.3911018,14.1868748 18.3526927,14.138399 L18.383714,14.1782318 C18.3008397,14.069958 18.2107553,13.9674954 18.114178,13.8715611 C18.0950728,13.852577 18.0753587,13.8335145 18.055387,13.8147227 L18.114178,13.8715611 C18.0725729,13.8302331 18.0297629,13.7901167 17.9858053,13.7512691 L18.055387,13.8147227 C18.0144184,13.7761746 17.9723657,13.7387655 17.9292795,13.7025463 L17.9858053,13.7512691 C17.9354288,13.7067489 17.883545,13.6638953 17.8302402,13.6227944 L17.9292795,13.7025463 C17.8874332,13.6673692 17.844612,13.6333145 17.8008624,13.6004283 L17.8302402,13.6227944 C17.7830456,13.5864048 17.7347371,13.5513893 17.6853746,13.5178077 L17.8008624,13.6004283 C17.2993184,13.2234229 16.6757508,13 16,13 Z M2.5,13.5 L6.3149723,13.5002775 C6.10935719,14.2992437 6,15.136851 6,16 C6,16.8634306 6.10942855,17.7013028 6.31517356,18.5005044 L2.5,18.5 C1.11928813,18.5 1.69088438e-16,17.3807119 0,16 C-1.69088438e-16,14.6192881 1.11928813,13.5 2.5,13.5 Z M29.5,13.5 C30.8807119,13.5 32,14.6192881 32,16 C32,17.3807119 30.8807119,18.5 29.5,18.5 L25.6848264,18.5005044 C25.8905715,17.7013028 26,16.8634306 26,16 C26,15.136851 25.8906428,14.2992437 25.6850277,13.5002775 L29.5,13.5 Z";
LegendSize[_Constants["default"].CIRCLE_HOLLOW] = {
  width: 32,
  height: 32
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE_HOLLOW] = "M4,2c1.102,0,2,0.898,2,2S5.102,6,4,6S2,5.102,2,4S2.898,2,4,2 M4,0C1.791,0,0,1.791,0,4s1.791,4,4,4s4-1.791,4-4S6.209,0,4,0";
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE_HOLLOW] = {
  width: 8,
  height: 8
};
LegendPath[_Constants["default"].SQUARE_HOLLOW] = "M24,16 L8,16 L8,0 L24,0 L24,16 Z M13,11 L19,11 L19,5 L13,5 L13,11 Z M6,5.5 L6,10.5 L2.5,10.5 C1.11928813,10.5 1.69088438e-16,9.38071187 0,8 C-1.69088438e-16,6.61928813 1.11928813,5.5 2.5,5.5 L6,5.5 Z M29.5,5.5 C30.8807119,5.5 32,6.61928813 32,8 C32,9.38071187 30.8807119,10.5 29.5,10.5 L26,10.5 L26,5.5 L29.5,5.5 Z";
LegendSize[_Constants["default"].SQUARE_HOLLOW] = {
  width: 32,
  height: 16
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE_HOLLOW] = "M6,6H2V2h4V6z M8,0H0v8h8V0z";
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE_HOLLOW] = {
  width: 8,
  height: 8
};
LegendPath[_Constants["default"].DIAMOND_HOLLOW] = "M24.1403066,15.9903066 L16.15,23.9806133 L8.15969337,15.9903066 L16.15,8 L24.1403066,15.9903066 Z M16.1952273,12.5 L15.254,13.44 L15.255,13.4403066 L12.6596934,16.0355339 L15.065,18.4403066 L15.064,18.44 L16.1952273,19.5710678 L17.326,18.44 L17.325,18.4403066 L19.7307612,16.0355339 L17.135,13.4403066 L17.136,13.44 L16.1952273,12.5 Z M7.881,13.4403066 L5.33126625,15.9903066 L7.781,18.4403066 L2.5,18.4403066 C1.11928813,18.4403066 1.69088438e-16,17.3210185 0,15.9403066 C-1.69088438e-16,14.5595948 1.11928813,13.4403066 2.5,13.4403066 L7.881,13.4403066 Z M29.5,13.4403066 C30.8807119,13.4403066 32,14.5595948 32,15.9403066 C32,17.3210185 30.8807119,18.4403066 29.5,18.4403066 L24.518,18.4403066 L26.9687338,15.9903066 L24.418,13.4403066 L29.5,13.4403066 Z";
LegendSize[_Constants["default"].DIAMOND_HOLLOW] = {
  width: 32,
  height: 32
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].DIAMOND_HOLLOW] = "M2.121,4.999L5,2.121l2.878,2.878L5,7.879L2.121,4.999z M5,0L0,4.999L5,10l4.999-5.001L5,0z";
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].DIAMOND_HOLLOW] = {
  width: 10,
  height: 10
};
LegendPath[_Constants["default"].TRIANGLE_HOLLOW] = "M16.0378418,8 L19.117,13.499 L19.118,13.5 L21.919,18.5 L21.918,18.499 L25,24 L7,24 L10.49,17.821 L12.931,13.5 L16.0378418,8 Z M16.0126139,14.5555556 L13,20.5555556 L19,20.5555556 L16.0126139,14.5555556 Z M10.634,13.5 L7.81,18.5 L2.5,18.5 C1.11928813,18.5 1.69088438e-16,17.3807119 0,16 C-1.69088438e-16,14.6192881 1.11928813,13.5 2.5,13.5 L10.634,13.5 Z M29.5,13.5 C30.8807119,13.5 32,14.6192881 32,16 C32,17.3807119 30.8807119,18.5 29.5,18.5 L24.211,18.5 L21.41,13.5 L29.5,13.5 Z";
LegendSize[_Constants["default"].TRIANGLE_HOLLOW] = {
  width: 32,
  height: 32
};
LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].TRIANGLE_HOLLOW] = "M5.001,3.34L7.402,7.5H2.598L5.001,3.34z M5.001,0.34L0,9h10L5.001,0.34z";
LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].TRIANGLE_HOLLOW] = {
  width: 10,
  height: 9
};
var ie8LegendPath = {};
var ie8LegendSize = {};
ie8LegendPath[_Constants["default"].PIE_ICON] = 'M15.795,7.943L7.909,12.5L0.205,8.052C1.756,5.333,4.68,3.5,8.032,3.5C11.338,3.5,14.23,5.287,15.795,7.943z';
ie8LegendSize[_Constants["default"].PIE_ICON] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].DONUT_ICON] = 'M8.945,11.107c1.671,0,3.181,0.684,4.269,1.786l4.271-4.271c-4.686-4.686-12.284-4.686-16.971,0l4.216,4.216C5.815,11.768,7.302,11.107,8.945,11.107z';
ie8LegendSize[_Constants["default"].DONUT_ICON] = {
  width: 18,
  height: 18
};
ie8LegendPath[_Constants["default"].NORMAL_ICON] = 'M0,0L12,0L12,12L0,12Z';
ie8LegendSize[_Constants["default"].NORMAL_ICON] = {
  width: 12,
  height: 12
};
ie8LegendPath[_Constants["default"].BUBBLE_ICON] = "M6,11.5c-1.47,0-2.851-0.572-3.889-1.611C1.072,8.851,0.5,7.47,0.5,6s0.572-2.851,1.611-3.889C3.149,1.072,4.53,0.5,6,0.5s2.851,0.572,3.889,1.611C10.928,3.149,11.5,4.53,11.5,6s-0.572,2.851-1.611,3.889C8.851,10.928,7.47,11.5,6,11.5z";
ie8LegendSize[_Constants["default"].BUBBLE_ICON] = {
  width: 11,
  height: 11
};
ie8LegendPath[_Constants["default"].NULL_MARKER] = 'M1,8L1,8c0-0.552,0.448-1,1-1h12c0.552,0,1,0.448,1,1v0c0,0.552-0.448,1-1,1H2C1.448,9,1,8.552,1,8z';
ie8LegendSize[_Constants["default"].NULL_MARKER] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].CIRCLE] = 'M11,8c0,1.657-1.343,3-3,3S5,9.657,5,8s1.343-3,3-3S11,6.343,11,8z M14,7h-2.142C11.942,7.322,12,7.653,12,8s-0.058,0.678-0.142,1H14c0.552,0,1-0.448,1-1C15,7.448,14.552,7,14,7z M4,8c0-0.347,0.058-0.678,0.142-1H2C1.448,7,1,7.448,1,8c0,0.552,0.448,1,1,1h2.142C4.058,8.678,4,8.347,4,8z';
ie8LegendSize[_Constants["default"].CIRCLE] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE] = "M4,8C2.897,8,1.897,7.551,1.173,6.827S0,5.103,0,4s0.449-2.103,1.173-2.827S2.897,0,4,0s2.103,0.449,2.827,1.173S8,2.897,8,4S7.551,6.103,6.827,6.827S5.103,8,4,8";
ie8LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE] = {
  width: 8,
  height: 8
};
ie8LegendPath[_Constants["default"].SQUARE] = 'M11,11H5V5h6V11z M14,7h-2v2h2c0.552,0,1-0.448,1-1C15,7.448,14.552,7,14,7z M4,7H2C1.448,7,1,7.448,1,8c0,0.552,0.448,1,1,1h2V7z';
ie8LegendSize[_Constants["default"].SQUARE] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE] = "M0,0h8c0,0,0,3.889,0,8C4,8,0,8,0,8V0z";
ie8LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE] = {
  width: 8,
  height: 8
};
ie8LegendPath[_Constants["default"].DIAMOND] = 'M8,11L5,8l3-3l3,3L8,11z M14,7h-2.586l1,1l-1,1H14c0.552,0,1-0.448,1-1C15,7.448,14.552,7,14,7z M3.586,8l1-1H2C1.448,7,1,7.448,1,8c0,0.552,0.448,1,1,1h2.586L3.586,8z';
ie8LegendSize[_Constants["default"].DIAMOND] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].DIAMOND] = "M0,4.5L4.502,0l4.5,4.5c0,0,0,0-4.5,4.5C0,4.5,0,4.5,0,4.5z";
ie8LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].DIAMOND] = {
  width: 9,
  height: 9
};
ie8LegendPath[_Constants["default"].TRIANGLE] = 'M5,10l3-5.196L11,10H5z M14,7h-3.577l1.155,2H14c0.552,0,1-0.448,1-1C15,7.448,14.552,7,14,7z M5.577,7H2C1.448,7,1,7.448,1,8c0,0.552,0.448,1,1,1h2.423L5.577,7z';
ie8LegendSize[_Constants["default"].TRIANGLE] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].TRIANGLE] = "M4.5,0L9,8c0,0-4.617,0-9,0L4.5,0z";
ie8LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].TRIANGLE] = {
  width: 9,
  height: 8
};
ie8LegendPath[_Constants["default"].CIRCLE_HOLLOW] = 'M4.142,9H2C1.448,9,1,8.552,1,8c0-0.552,0.448-1,1-1h2.142C4.058,7.322,4,7.653,4,8S4.058,8.678,4.142,9zM14,7h-2.142C11.942,7.322,12,7.653,12,8s-0.058,0.678-0.142,1H14c0.552,0,1-0.448,1-1C15,7.448,14.552,7,14,7z M8,7C7.449,7,7,7.449,7,8s0.449,1,1,1s1-0.449,1-1S8.551,7,8,7 M8,5c1.657,0,3,1.343,3,3s-1.343,3-3,3S5,9.657,5,8S6.343,5,8,5L8,5z';
ie8LegendSize[_Constants["default"].CIRCLE_HOLLOW] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE_HOLLOW] = "M4,2c1.102,0,2,0.898,2,2S5.102,6,4,6S2,5.102,2,4S2.898,2,4,2 M4,0C1.791,0,0,1.791,0,4s1.791,4,4,4s4-1.791,4-4S6.209,0,4,0";
ie8LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].CIRCLE_HOLLOW] = {
  width: 8,
  height: 8
};
ie8LegendPath[_Constants["default"].SQUARE_HOLLOW] = 'M4,9H2C1.448,9,1,8.552,1,8c0-0.552,0.448-1,1-1h2V9z M14,7h-2v2h2c0.552,0,1-0.448,1-1C15,7.448,14.552,7,14,7z M9,7H7v2h2V7 M11,5v6H5V5H11L11,5z';
ie8LegendSize[_Constants["default"].SQUARE_HOLLOW] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE_HOLLOW] = "M6,6H2V2h4V6z M8,0H0v8h8V0z";
ie8LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].SQUARE_HOLLOW] = {
  width: 8,
  height: 8
};
ie8LegendPath[_Constants["default"].DIAMOND_HOLLOW] = 'M4.157,9H2C1.448,9,1,8.552,1,8c0-0.552,0.448-1,1-1h2.157l-1,1L4.157,9z M14,7h-2.157l1,1l-1,1H14c0.552,0,1-0.448,1-1C15,7.448,14.552,7,14,7z M8,5.986L5.986,8L8,10.014L10.014,8L8,5.986 M8,4.571L11.429,8L8,11.429L4.571,8L8,4.571L8,4.571z';
ie8LegendSize[_Constants["default"].DIAMOND_HOLLOW] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].DIAMOND_HOLLOW] = "M2.121,4.999L5,2.121l2.878,2.878L5,7.879L2.121,4.999z M5,0L0,4.999L5,10l4.999-5.001L5,0z";
ie8LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].DIAMOND_HOLLOW] = {
  width: 10,
  height: 10
};
ie8LegendPath[_Constants["default"].TRIANGLE_HOLLOW] = 'M4.5,9H2C1.448,9,1,8.552,1,8s0.448-1,1-1h3.655L4.5,9z M14,7h-3.655L11.5,9H14c0.552,0,1-0.448,1-1S14.552,7,14,7z M8,6.938L6.232,10h3.536L8,6.938 M8,4.938L11.5,11h-7L8,4.938L8,4.938z';
ie8LegendSize[_Constants["default"].TRIANGLE_HOLLOW] = {
  width: 16,
  height: 16
};
ie8LegendPath[_Constants["default"].SCATTER_ICON + _Constants["default"].TRIANGLE_HOLLOW] = "M5.001,3.34L7.402,7.5H2.598L5.001,3.34z M5.001,0.34L0,9h10L5.001,0.34z";
ie8LegendSize[_Constants["default"].SCATTER_ICON + _Constants["default"].TRIANGLE_HOLLOW] = {
  width: 10,
  height: 9
}; // ie8及以下浏览器不支持图例Icon跟随图例字体大小变化：原因是ie8不支持transform，并且固定path路径也无法调整宽高

function getLegendIconSizeAndScale(name, textSize) {
  if (_Browser["default"].ielt9) {
    return getIe8LegendIconSize(name);
  }

  var originIconSize = getLegendIconSize(name);
  var iconSize = _BaseUtils["default"].includes(rectAndCircleIcon, name) || !LegendSize[name] ? ICON_TEXT_SCALE * textSize : textSize;
  var scale = iconSize / originIconSize.width;
  return {
    scale: scale,
    iconWidth: iconSize,
    // icon的实际宽度
    width: textSize,
    // icon所占位置的宽度：icon的实际宽度 + 左右边距
    height: scale * originIconSize.height
  };
}

function getLegendIconPath(name) {
  return _Browser["default"].ielt9 ? ie8LegendPath[name] : LegendPath[name];
}

function getLegendIconSize(name) {
  return LegendSize[name] ? LegendSize[name] : LegendSize[_Constants["default"].NORMAL_ICON];
}

function getIe8LegendIconSize(name) {
  var iconSize = ie8LegendSize[name] ? ie8LegendSize[name] : ie8LegendSize[_Constants["default"].NORMAL_ICON];
  return {
    scale: 1,
    iconWidth: iconSize.width,
    width: iconSize.width,
    height: iconSize.height
  };
}

function hasIcon(name) {
  return LegendPath[name];
}

var _default = {
  getLegendIconSizeAndScale: getLegendIconSizeAndScale,
  getLegendIconPath: getLegendIconPath,
  hasIcon: hasIcon,
  maxIconSize: 18
};
exports["default"] = _default;

/***/ }),
/* 54 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.richTextSpanMount = richTextSpanMount;
exports.createRichTextLabel = createRichTextLabel;
exports.createDivRichTextWrapper = createDivRichTextWrapper;
exports.createRichTextTooltip = createRichTextTooltip;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _richTextDetail = __webpack_require__(55);

var _VanChartLabelBorder = __webpack_require__(36);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var DEFAULT_PADDING = 5; // fixme 参数有点多了

function richTextSpanMount(renderer, textWrapper, richTextContent, richTextDim, labelPadding, useHtml) {
  var halfHeight = richTextDim.height / 2;
  var halfWidth = richTextDim.width / 2;
  var horizontal = 0;
  var vertical = 0;

  if (labelPadding && labelPadding.length === 2) {
    horizontal = labelPadding[0] / 2;
    vertical = labelPadding[1] / 2;
  }

  var startY = 0;
  textWrapper.tspans = [];

  if (richTextContent && richTextContent.length) {
    var rowShift = (0, _richTextDetail.getAlignShift)(richTextContent, richTextDim, horizontal);
    var baseLineShift = (0, _richTextDetail.getBaseLineShift)(richTextContent);

    for (var rowIndex = 0, rowLen = richTextContent.length; rowIndex < rowLen; rowIndex++) {
      var row = richTextContent[rowIndex];
      var curRowBaseLineShift = baseLineShift[rowIndex];

      if (row && row.length) {
        var xShift = -halfWidth,
            yShift = -halfHeight;
        var alignShift = rowShift[rowIndex];
        var rowHeight = 0;

        for (var fieldIndex = 0, fieldLen = row.length; fieldIndex < fieldLen; fieldIndex++) {
          var _row$fieldIndex = row[fieldIndex],
              value = _row$fieldIndex.text,
              style = _row$fieldIndex.style,
              dim = _row$fieldIndex.dim;

          var _baseLineShift = dim.height * 0.85 + curRowBaseLineShift[fieldIndex];

          textWrapper.tspans.push(renderer.vtspan(useHtml).style({
            'margin-top': -halfHeight + 'px',
            'text-align': "center",
            'white-space': "nowrap"
          }).attr('y', vertical + startY).attr('x', 0).attr('dy', yShift + _baseLineShift).attr('dx', alignShift + xShift).style({
            color: style.color,
            fontFamily: style.fontFamily,
            fontSize: style.fontSize,
            fontStyle: style.fontStyle,
            fontWeight: style.fontWeight,
            textDecoration: style.textDecoration
          }).textContent(value).addTo(textWrapper));
          xShift += dim.width;
          rowHeight = Math.max(rowHeight, dim.height);
        }

        startY += rowHeight + _richTextDetail.LABEL_GAP;
      }
    }
  }
}

function createRichTextLabel(point) {
  var series = point.series,
      vanchart = series.vanchart,
      renderer = vanchart.renderer;

  var textLabelGroup = series._getPointTextLabelGroup();

  var textWrapper = renderer.text().attr('transform', _BaseUtils["default"].makeTranslate(series._labelTrans(point))).style({
    'pointer-events': 'none'
  });
  var labelPadding = [(0, _VanChartLabelBorder.getHorizontalPadding)(point), 0];
  richTextSpanMount(renderer, textWrapper, point.labelContent, point.labelDim, labelPadding, false);
  point.textGraphic = textLabelGroup.append(textWrapper);
}

function createDivRichTextWrapper(point, richTextContent, wrapperOffset, labelPadding) {
  if (wrapperOffset === void 0) {
    wrapperOffset = 0;
  }

  if (labelPadding === void 0) {
    labelPadding = [0, 0];
  }

  var series = point.series,
      vanchart = series.vanchart,
      renderer = vanchart.renderer;
  var richTextDim = (0, _richTextDetail.getRichTextDim)(richTextContent);
  var textWrapper = renderer.vtext(true).attr('transform', _BaseUtils["default"].makeTranslate({
    x: richTextDim.width / 2 + wrapperOffset,
    y: richTextDim.height / 2 + wrapperOffset
  })).style({
    'pointer-events': 'none'
  });
  richTextSpanMount(renderer, textWrapper, richTextContent, richTextDim, labelPadding, true);
  return textWrapper;
}

function createRichTextTooltip(point, richTextContent, dom, wrapperOffset) {
  if (wrapperOffset === void 0) {
    wrapperOffset = DEFAULT_PADDING;
  }

  var textWrapper = createDivRichTextWrapper(point, richTextContent, wrapperOffset);

  var _dom = document.createElement('div');

  _dom.appendChild(textWrapper.node());

  dom.innerHTML = _dom.innerHTML;
  point.richTextTooltip = textWrapper;
  _dom.innerHTML = "";
}

/***/ }),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getRichTextDim = getRichTextDim;
exports.getBaseLineShift = getBaseLineShift;
exports.getAlignShift = getAlignShift;
exports.getLabelRichTextDetail = getLabelRichTextDetail;
exports.getTooltipRichTextDetail = getTooltipRichTextDetail;
exports.LABEL_GAP = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _CoreUtils = __webpack_require__(3);

var _richTextParser = __webpack_require__(104);

var _FormattedText = __webpack_require__(41);

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var LABEL_COLOR = '#666666';
var TOOLTIP_COLOR = '#ffffff';
var LABEL_GAP = 2;
exports.LABEL_GAP = LABEL_GAP;

function getMapField(point, series, formatter, key) {
  if (key.indexOf(_FormattedText.VALUE) !== -1 || key.indexOf(_FormattedText.SIZE) !== -1) {
    return _BaseUtils["default"].format(point.originalValue, formatter.valueFormat);
  }

  return getDefaultField(point, series, formatter, key);
}

function getBubbleField(point, series, formatter, key) {
  var options = point.options;

  if (key === _FormattedText.X) {
    return _BaseUtils["default"].format(options.x, formatter.XFormat);
  } else if (key === _FormattedText.Y) {
    return _BaseUtils["default"].format(options.y, formatter.YFormat);
  } else if (key === _FormattedText.SIZE) {
    return _BaseUtils["default"].format(options.size, formatter.sizeFormat);
  }

  return getDefaultField(point, series, formatter, key);
}

function getLineMapField(point, series, formatter, key) {
  var options = point.options;

  if (key.indexOf(_FormattedText.FROM) !== -1 && key.indexOf(_FormattedText.TO) !== -1) {
    return options.from.name + '→' + options.to.name;
  }

  return getMapField(point, series, formatter, key);
}

function getBoxField(point, series, formatter, key) {
  var result = point.dataResult;

  if (result == null) {
    return '';
  }

  var valueGroup = [result.number, result.max, result.q3, result.median, result.q1, result.min];
  var formatterGroup = [formatter.dataNumberFormat, formatter.dataMaxFormat, formatter.dataQ3Format, formatter.dataMedianFormat, formatter.dataQ1Format, formatter.dataMinFormat];
  var identifier = [_FormattedText.DATA_NUMBER, _FormattedText.DATA_MAX, _FormattedText.DATA_Q3, _FormattedText.DATA_MEDIAN, _FormattedText.DATA_Q1, _FormattedText.DATA_MIN];
  var index = identifier.indexOf(key);

  if (index !== -1) {
    return _BaseUtils["default"].format(valueGroup[index], formatterGroup[index]);
  }

  if (key === _FormattedText.DATA_OUTLIER) {
    if ((0, _CoreUtils.hasDefined)(point.outlierData)) {
      var outlier = point.outlierData.outlier;

      if ((0, _CoreUtils.hasDefined)(outlier)) {
        return _BaseUtils["default"].format(outlier, formatter.dataOutlierFormat);
      }
    }

    return '';
  }

  return getDefaultField(point, series, formatter, key);
}

function getDefaultField(point, series, formatter, key) {
  var prop = _FormattedText.propMap[key];

  if (prop && prop.length === 2) {
    var propKey = prop[0],
        fmtKey = prop[1];
    var origin = series._formatValue ? series._formatValue(point, propKey) : point[propKey];

    var format = formatter[fmtKey] || series._getTooltipFormatFn && series._getTooltipFormatFn(propKey);

    return _BaseUtils["default"].format(origin, format);
  }

  return '';
}

function getFormattedText(point, series, formatter, filed) {
  if ((0, _CoreUtils.isEmpty)(filed)) {
    return '';
  }

  var text = filed.text,
      isField = filed.isField;

  if (isField) {
    // 富文本解析出来的text含有$
    var key = text.substring(1);
    var type = series.type;

    if (type === _Constants["default"].LINE_MAP) {
      return getLineMapField(point, series, formatter, key);
    } else if (series.vanchart.isMap()) {
      return getMapField(point, series, formatter, key);
    } else if (type === _Constants["default"].BUBBLE_CHART || type === _Constants["default"].SCATTER_CHART) {
      return getBubbleField(point, series, formatter, key);
    } else if (type === _Constants["default"].BOX_CHART) {
      return getBoxField(point, series, formatter, key);
    }

    return getDefaultField(point, series, formatter, key);
  }

  return text;
}

function getRichTextDim(richTextContent) {
  var width = 0,
      height = 0;

  if (richTextContent && richTextContent.length) {
    for (var rowIndex = 0, rowLen = richTextContent.length; rowIndex < rowLen; rowIndex++) {
      var row = richTextContent[rowIndex];
      var rowWidth = 0,
          rowHeight = 0;

      if (row && row.length) {
        for (var fieldIndex = 0, fieldLen = row.length; fieldIndex < fieldLen; fieldIndex++) {
          var dim = row[fieldIndex].dim;
          rowWidth += dim.width;
          rowHeight = Math.max(rowHeight, dim.height);
        }
      }

      width = Math.max(width, rowWidth);
      height += rowHeight + LABEL_GAP;
    }

    height -= LABEL_GAP;
  }

  return {
    width: width,
    height: height
  };
}

function getBaseLineShift(richTextContent) {
  if (richTextContent && richTextContent.length) {
    var baseLineShift = [];

    for (var rowIndex = 0, rowLen = richTextContent.length; rowIndex < rowLen; rowIndex++) {
      var row = richTextContent[rowIndex];

      if (row && row.length) {
        var curRowShift = [];
        var rowHeight = 0;

        for (var fieldIndex = 0, fieldLen = row.length; fieldIndex < fieldLen; fieldIndex++) {
          var dim = row[fieldIndex].dim;
          rowHeight = Math.max(rowHeight, dim.height);
        }

        for (var _fieldIndex = 0, _fieldLen = row.length; _fieldIndex < _fieldLen; _fieldIndex++) {
          var _dim = row[_fieldIndex].dim;
          var curFieldShift = (rowHeight - _dim.height) / 2;
          curRowShift.push(curFieldShift);
        }

        baseLineShift.push(curRowShift);
      }
    }

    return baseLineShift;
  }
}

function getAlignShift(richTextContent, labelDim, padding) {
  var width = labelDim.width;

  if (richTextContent && richTextContent.length) {
    var rowShift = [];

    for (var rowIndex = 0, rowLen = richTextContent.length; rowIndex < rowLen; rowIndex++) {
      var row = richTextContent[rowIndex];
      var alignShift = padding;
      var align = '';
      var rowWidth = 0;

      if (row && row.length) {
        rowWidth = 0;
        align = '';

        for (var fieldIndex = 0, fieldLen = row.length; fieldIndex < fieldLen; fieldIndex++) {
          var _row$fieldIndex = row[fieldIndex],
              dim = _row$fieldIndex.dim,
              style = _row$fieldIndex.style;
          rowWidth += dim.width;
          align = align || style.textAlign;
        }
      }

      if (align.trim() === 'center') {
        alignShift = (width - rowWidth) / 2;
      }

      if (align.trim() === 'right') {
        alignShift = width - rowWidth - padding;
      }

      rowShift.push(alignShift);
    }

    return rowShift;
  }
}

function getAutoStyle(point, isTooltip) {
  var color = isTooltip ? TOOLTIP_COLOR : point.autoLabelColor();
  return _BaseUtils["default"].calculateFontSizeWithScale({
    fontSize: '0.75rem',
    fontFamily: 'Verdana',
    color: color,
    textAlign: "left"
  });
}

function getFieldStyle(fieldStyle, autoStyle, useAutoStyle, customColor) {
  if (fieldStyle == null) {
    return autoStyle;
  }

  if ((0, _CoreUtils.isEmpty)(fieldStyle.fontSize)) {
    fieldStyle.fontSize = autoStyle.fontSize;
  }

  if ((0, _CoreUtils.isEmpty)(fieldStyle.fontFamily)) {
    fieldStyle.fontFamily = autoStyle.fontFamily;
  }

  if ((0, _CoreUtils.isEmpty)(fieldStyle.color)) {
    fieldStyle.color = useAutoStyle ? autoStyle.color : customColor;
  }

  return fieldStyle;
}

function getLabelRichTextDetail(point, richTextStr, useAutoStyle, formatter) {
  return _getRichTextDetail(point, richTextStr, useAutoStyle, formatter, false);
}

function getTooltipRichTextDetail(point, richTextStr, useAutoStyle, formatter) {
  return _getRichTextDetail(point, richTextStr, useAutoStyle, formatter, true);
}

function _getRichTextDetail(point, richTextStr, useAutoStyle, formatter, isTooltip) {
  var series = point.series;

  if ((0, _CoreUtils.isEmpty)(richTextStr)) {
    return [];
  }

  var result = [];
  var isMap = series && series.vanchart.isMap();
  var content = (0, _richTextParser.richTextParse)(richTextStr);

  for (var rowIndex = 0, rowLen = content.length; rowIndex < rowLen; rowIndex++) {
    var row = content[rowIndex];

    if (row && row.length) {
      var line = [];

      for (var fieldIndex = 0, fieldLen = row.length; fieldIndex < fieldLen; fieldIndex++) {
        var field = row[fieldIndex];
        var customColor = isTooltip ? TOOLTIP_COLOR : LABEL_COLOR;
        var style = getFieldStyle(field.style, getAutoStyle(point, isTooltip), useAutoStyle, customColor);
        var text = getFormattedText(point, series, formatter, field) || '';

        var dim = _BaseUtils["default"].getTextDimension(text, style, isTooltip || isMap);

        line.push({
          text: text,
          style: style,
          dim: dim
        });
      }

      result.push(line);
    }
  }

  return result;
}

/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _Bounds = _interopRequireDefault(__webpack_require__(21));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _wrapper = _interopRequireDefault(__webpack_require__(37));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/6/1.
 * 这个js做成类似接口的东西吧
 */
var PADDING = 0;

var Renderer = _Layer["default"].extend({
  /**
   * this._container may be svg,canvas,dom
   */
  initialize: function (dom, vanchart, config) {
    this.dom = dom;
    this.vanchart = vanchart;
    this.config = config;
    this.isSupportSVG = (0, _EnvUtils.isSupportSVG)();
    this.isAnimation = this.isSupportSVG && _BaseUtils["default"].pick(this.vanchart.options.plotOptions.animation, true);
  },
  resize: function () {},
  remove: function () {
    _DomUtils["default"].remove(this._container.node());

    _DomUtils["default"].remove(this._divContainer.node());

    this.off('update', this._updatePaths, this);
  },
  div: function (isHtml) {
    var d = (0, _wrapper["default"])(document.createElement('div'), this).setType('div').style({
      position: 'absolute',
      left: 0,
      top: 0
    });
    d.isHtml = isHtml; // log for IE8

    return d;
  },
  vgroup: function () {
    var divG = this.div();
    var renderG = this.group();
    return {
      divG: divG,
      renderG: renderG,
      type: 'vgroup',
      attr: function () {
        this.divG.attr.apply(this.divG, arguments);
        this.renderG.attr.apply(this.renderG, arguments);
        return this;
      },
      style: function () {
        this.divG.style.apply(this.divG, arguments);
        this.renderG.style.apply(this.renderG, arguments);
        return this;
      },
      append: function (ele) {
        if (ele.type === 'div' && ele.isHtml) {
          divG.append(ele);
        } else if (ele.type === 'vgroup') {
          divG.append(ele.divG);
          renderG.append(ele.renderG);
        } else {
          renderG.append(ele);
        }

        return ele;
      },
      add: function (parentG) {
        parentG ? this.renderG.addTo(parentG) : this.renderG.add();
        this.divG.add();
        return this;
      },
      remove: function () {
        this.divG.node() && this.divG.remove();
        this.renderG.node() && this.renderG.remove();
      },
      node: function () {
        return renderG.node();
      },
      vRotate: function (deg) {
        if (isNaN(deg)) {
          return;
        }

        this.divG.vRotate(deg);
        this.renderG.vRotate(deg);
      }
    };
  },
  vtext: function (isHtml) {
    if (isHtml || !this.isSupportSVG) {
      return this.div(isHtml); // for IE8, innerText or innerHtml
    }

    return this.text();
  },
  vtspan: function (isHtml) {
    if (isHtml || !this.isSupportSVG) {
      return this.div(isHtml);
    }

    return this.tspan();
  },
  onAdd: function () {
    if (!this._container) {
      this._initContainer(); // defined by renderer implementations


      if (this._zoomAnimated) {
        _DomUtils["default"].addClass(this._container.node(), 'leaflet-zoom-animated');
      }
    }

    this.dom.appendChild(this._container.node());
    this._divContainer && this.dom.appendChild(this._divContainer.node());

    this._update();

    this.on('update', this._updatePaths, this);
  },
  _update: function () {
    var size = this.vanchart.getSize();
    this._bounds = new _Bounds["default"]([0, 0], size);

    if (this._map) {
      var p = PADDING,
          min = this._map.containerPointToLayerPoint(size.multiplyBy(-p)).round();

      this._bounds = new _Bounds["default"](min, min.add(size.multiplyBy(1 + p * 2)).round());
      this._center = this._map.getCenter();
      this._zoom = this._map.getZoom();
    }
  },
  getEvents: function () {
    var events = {
      viewreset: this._reset,
      zoom: this._onZoom,
      moveend: this._update,
      zoomend: this._onZoomEnd
    };

    if (this._zoomAnimated) {
      events.zoomanim = this._onAnimZoom;
    }

    return events;
  },
  _onAnimZoom: function (ev) {
    this._updateTransform(ev.center, ev.zoom);
  },
  _onZoom: function () {
    this._updateTransform(this._map.getCenter(), this._map.getZoom());
  },
  _reset: function () {
    this._update();

    this._updateTransform(this._center, this._zoom);

    var layers = this.vanchart._layers;

    for (var id in layers) {
      layers[id]._path && layers[id]._reset();
    }
  },
  _onZoomEnd: function () {
    var layers = this.vanchart._layers;

    for (var id in layers) {
      layers[id]._path && layers[id]._project();
    }
  },
  _updatePaths: function () {
    var layers = this.vanchart._layers;

    for (var id in layers) {
      layers[id]._path && layers[id]._update();
    }
  },
  _updateTransform: function (center, zoom) {
    var container = this._container.node();

    var scale = this._map.getZoomScale(zoom, this._zoom),
        position = _DomUtils["default"].getPosition(container),
        viewHalf = this._map.getSize().multiplyBy(0.5 + PADDING),
        currentCenterPoint = this._map.project(this._center, zoom),
        destCenterPoint = this._map.project(center, zoom),
        centerOffset = destCenterPoint.subtract(currentCenterPoint),
        topLeftOffset = viewHalf.multiplyBy(-scale).add(position).add(viewHalf).subtract(centerOffset);

    if (_Browser["default"].any3d) {
      _DomUtils["default"].setTransform(container, topLeftOffset, scale);
    } else if ((0, _EnvUtils.isSupportSVG)()) {
      _DomUtils["default"].setPosition(container, topLeftOffset);
    } else {
      container.style.left = 0 + 'px';
      container.style.top = 0 + 'px';
    }
  },
  _updateGradientFill: function () {}
});

var _default = Renderer;
exports["default"] = _default;

/***/ }),
/* 57 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.hideFullScreenChart = hideFullScreenChart;
exports.hideLightBox = hideLightBox;
exports.hideLightBoxWithReInit = hideLightBoxWithReInit;
exports.showLightBox = showLightBox;
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _validMapPoints = __webpack_require__(28);

var _EnvUtils = __webpack_require__(2);

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * VanChart接口相关
 */
var _default = {
  /**
   * 设置地图缩放等级&中心点
   * @param option
   */
  setMapZoom: function (option) {
    var chart = this,
        geo = chart.getComponent(_component.ComponentCst.GEO_COMPONENT);
    var validOption = {}; //目前只开了这两个接口，这边控制下，以防option里面传过来其他属性。

    validOption.zoomLevel = option.zoomLevel;
    validOption.viewCenter = option.viewCenter;

    var oldOptions = _BaseUtils["default"].clone(geo.options);

    _BaseUtils["default"].extend(geo.options, validOption);

    geo.doLayout();
    geo.options = oldOptions;
  },

  /**
   * 开启数据点提示自动轮播
   * @param delay
   * @param initPoints
   * @returns {{stop: stop}}
   */
  openAutoTooltip: function (delay, initPoints) {
    delay = delay || 3000;
    var chart = this,
        series = chart.series,
        chartType = chart.chartType();
    var option = chart.options;
    var shared = option && option.plotOptions && option.plotOptions.tooltip && option.plotOptions.shared; // 获取node节点下所有层级的所有节点

    var getTreeNodeChildrenPoint = function (node, container) {
      if (!node.children) {
        return;
      }

      node.children.forEach(function (child) {
        container.push(child);
        getTreeNodeChildrenPoint(child, container);
      });
    };

    var getAllChartPoints = function () {
      var points = [];

      if (shared) {
        points = series[0].points;
      } else if (chartType === _Constants["default"].TREEMAP_CHART || chartType === _Constants["default"].MULTIPIE_CHART) {
        series[0].points.forEach(function (point) {
          points.push(point);
          getTreeNodeChildrenPoint(point, points);
        });
      } else if (chart.isMap()) {
        points = (0, _validMapPoints.getAllMapPoints)(chart);
      } else {
        series.forEach(function (ser) {
          points = points.concat(ser.points);
        });
      } // 指显示展示点的提示


      return points.filter(function (point) {
        return point && point.isVisible();
      });
    }; // 没有指定轮播点集合则默认轮播所有点
    // 否则使用全部数据点, 考虑监控刷新时数据增减, 这边使用动态的方法获取


    var points = initPoints && initPoints.length ? initPoints : getAllChartPoints;
    this.autoTooltipController = this.autoTooltipController || autoTooltip();
    this.autoTooltipController.chart(chart).delay(delay).points(points).restart(); // @CHART-11774
    // 开启数据点提示轮播的过程中, 图表监控刷新了新数据, 需要隐藏数据点提示(当前提示的数据可能已经被移除了)

    var removeFn = chart.__removeAutoTooltip;

    if (!removeFn) {
      removeFn = chart.__removeAutoTooltip = function () {
        chart.hideTooltip();
      };
    } // remove & set listener .


    chart.off('update', removeFn);
    chart.on('update', removeFn); // 返回一个可以关闭自动数据点提示的控制器

    return {
      stop: function () {
        chart.autoTooltipController.sleep();
        chart.autoTooltipController.status('custom_sleep');
        chart.handler.removeAllChosen({
          containerPoint: {
            x: 0,
            y: 0
          }
        });
      },
      moveOn: function () {
        chart.autoTooltipController.wake();
      }
    };
  },

  /**
   * 显示自动数据点提示并触发数据点mouseover效果
   * @param point
   */
  showAutoTooltip: function (point) {
    if (!point.isVisible()) {
      return;
    } // 用series._getFixedPos来模拟鼠标位置


    var series = point.series,
        vanchart = series.vanchart;

    var pos = series._getFixedPos(point, {
      width: 0,
      height: 0
    }),
        chartType = this.chartType();

    var x = pos[0],
        y = pos[1];
    x = Math.max(1, Math.min(x, this.width - 1));
    y = Math.max(1, Math.min(y, this.height - 1)); // make sure containerPoint inside chartBounds

    var simulateEv = {
      containerPoint: {
        x: x,
        y: y
      }
    }; // trigger highlight

    if (chartType === _Constants["default"].HEAT_MAP || chartType === _Constants["default"].LINE_MAP) {
      this.fire("mousemove", simulateEv);
    } else {
      point.listens("mouseover") ? point.fire("mouseover", simulateEv) : point.series.fire("mouseover", simulateEv);
    } // trigger tooltip
    // @CHART-9748: 被隐藏的系列, fireMouseOver触发不了高亮和数据点提示, 这里需要手动触发一下


    point.isPointSupportTooltipShared() ? vanchart.showSharedTooltip(point, simulateEv) : vanchart.showTooltip(point, simulateEv);
  },
  switchAutoTooltipStatus: function (eventType) {
    var autoTooltipController = this.autoTooltipController;

    if (!autoTooltipController || autoTooltipController.status() === 'custom_sleep') {
      return;
    }

    eventType === "mouseover" ? autoTooltipController.sleep() : autoTooltipController.wake();
  },

  /**
   * 设置图表排序
   * @param sortType 排序类型,1为正序,-1为逆序
   */
  sortChart: function (sortType) {
    var vanchart = this,
        tools = this.getComponent("tools"),
        sortIcon;
    var ascending = _Constants["default"].ASCENDING,
        descending = _Constants["default"].DESCENDING;
    vanchart.orderType = sortType != null ? sortType > 0 ? ascending : descending : vanchart.orderType === ascending ? descending : ascending;
    vanchart.orderData(); // 存在工具栏的时候，修改工具栏内排序按钮的形态

    tools && (sortIcon = tools.getIcon(_Constants["default"].SORT)) && sortIcon.updateSortIconPath();
  },

  /**
   * 设置图表显示系列
   * @param showItems  展示系列对应的下标数组
   * 例：setSeriesVisible([0,1,3])则系列1，2，4显示，其他不显示；隐藏的系列图例也同样灰化。
   */
  setSeriesVisible: function (showItems) {
    showItems = showItems || [];
    var series = this.series,
        isSeriesAccumulated = series[0].isSeriesAccumulated();
    var legend = this.getComponent(_component.ComponentCst.LEGEND_COMPONENT);
    var legendItems = legend.items;
    var len = isSeriesAccumulated ? series[0].points.length : series.length; //1、switch series visibility and LegendItem state  2、reRender  3、LegendItem reset state

    var seriesNames = [],
        repeatSeriesNum = 0; //组合图中，不同类型图表系列可能系列名相同，重复的系列不重复处理。

    for (var i = 0; i < len; i++) {
      var visible = isSeriesAccumulated ? series[0].points[i].visible : series[i].visible,
          name = isSeriesAccumulated ? series[0].points[i].name : series[i].name;

      if (seriesNames.indexOf(name) !== -1) {
        repeatSeriesNum++;
        continue;
      }

      var item,
          itemIndex = i - repeatSeriesNum;

      if (legendItems.length >= itemIndex) {
        item = legendItems[itemIndex];
      }

      showItems.indexOf(itemIndex) !== -1 ? !visible && legend.switchSeriesItemVisible(name, item) : visible && legend.switchSeriesItemVisible(name, item);
      seriesNames.push(name);
    }

    this.reRenderWholePlot();
    legendItems.forEach(function (item) {
      item.resetState();
    });
  }
};
exports["default"] = _default;

function autoTooltip() {
  var chart,
      delay,
      points,
      pointIndex = 0,
      interval = 0,
      status = 0;

  function loopTooltip(autoStart) {
    if (status === 'loop') {
      return;
    }

    interval && clearInterval(interval);

    function switchTooltip() {
      points[pointIndex] && chart.showAutoTooltip(points[pointIndex]);
      pointIndex = pointIndex >= points.length - 1 ? 0 : pointIndex + 1;
    }

    interval = setInterval(switchTooltip, delay);
    status = 'loop'; // auto start

    autoStart && switchTooltip();
  }

  var controller = {
    points: function (_points) {
      // dynamic update points.
      if (typeof _points === 'function') {
        points = _points();
        chart.off(_Constants["default"].AUTO_REFRESH);
        chart.on(_Constants["default"].AUTO_REFRESH, function () {
          points = _points();
        });
      } else {
        points = _points || [];
      }

      return controller;
    },
    chart: function (_chart) {
      chart = _chart;
      return controller;
    },
    delay: function (_delay) {
      delay = _delay || 3000;
      return controller;
    },
    restart: function () {
      pointIndex = 0;
      !interval && loopTooltip(true);
    },
    sleep: function () {
      if (interval) {
        interval = clearInterval(interval);
      }

      status = 'mouse_sleep';
      return controller;
    },
    status: function (_) {
      return _ ? status = _ : status;
    },
    wake: function () {
      loopTooltip();
    },
    destroy: function () {
      clearInterval(interval);
      points = chart = null;
    }
  };
  return controller;
}

function getTopWindow() {
  var w, d;

  try {
    d = window.top.document;
    w = window.top; // 在最上层document中判断是否存在全屏元素，存在则在全屏元素内寻找合适的window&document，
    // 关于document.fullscreenElement:
    // https://developer.mozilla.org/en-US/docs/Web/API/Document/fullscreenElement
    // https://bobscript.com/archives/423/

    var fullScreenElement = d.fullscreenElement || d.mozFullScreenElement || d.webkitFullscreenElement || d.msFullscreenElement; // @CHART-2003
    // 存在全屏元素, 则向上寻找直到全屏元素下第一层iFrame(此时的图表肯定在全屏元素里面的某一个iFrame里面)

    if (fullScreenElement) {
      w = window;
      d = w.document;
      var isParentFs = w.parent && w !== w.parent && !w.parent.document.fullscreenElement && !w.parent.document.mozFullScreenElement && !w.parent.document.webkitFullscreenElement && !w.parent.document.msFullscreenElement;

      while (isParentFs) {
        w = w.parent;
        d = w.document;
      }
    }
  } catch (e) {
    w = window;
    d = w.document;
  }

  return {
    w: w,
    d: d
  };
}

function hideFullScreenChart() {
  if (VanCharts.fullScreenChart) {
    var fullScrVanCharts = VanCharts.fullScreenChart;
    hideLightBox(fullScrVanCharts.dom, fullScrVanCharts.fullScreenFather);
  }
}

function hideLightBox(container, fullScreenFather) {
  var parent = container.parentNode;

  if (parent) {
    parent.removeChild(container);

    if (container.boxDiv) {
      parent.removeChild(container.boxDiv);
    }
  }

  fullScreenFather.set({
    enable: true
  });
  fullScreenFather.fullScreenChart = null;
  VanCharts.fullScreenChart = null;
  fullScreenFather.fire("fullScreenOff");
} // @Mango  Chart-1675 中第二种情况
//图表全屏展示后，点击超链动态参数，原图重新初始化
//原图重新初始化时，全屏展示应该关闭


function hideLightBoxWithReInit() {
  if (VanCharts.fullScreenChart) {
    var fullScrVanCharts = VanCharts.fullScreenChart,
        fullScreenFather = fullScrVanCharts.fullScreenFather,
        fatherChartDom = fullScreenFather.getDivParentDom();

    if (!fatherChartDom || !document.body.contains(fatherChartDom)) {
      hideLightBox(fullScrVanCharts.dom, fullScrVanCharts.fullScreenFather);
    }
  }
}

function showLightBox(vanchart, zIndex) {
  var options = _QueryUtils["default"].merge({}, vanchart.options);

  options.width = options.height = null; // 默认放在window.top，当存在全屏元素时，需要判断特殊处理一下

  var wd = getTopWindow(),
      w = wd.w,
      d = wd.d;
  var body = d.body; //todo FR的zIndex没有一个统一的逻辑,3000,8000都是写死的值
  //var currentMaxZ = 7998;  留着以后做参考，这里改成3330是为了全屏之后超链能显示

  var currentMaxZ = 3330;

  if (zIndex == null) {
    var el,
        i = -1,
        len = document.body.children.length;

    while (++i < len) {
      el = document.body.children[i];

      if ((el.style.display || '').toLowerCase() !== 'none') {
        currentMaxZ = Math.max(currentMaxZ, el.style.zIndex);
      }
    }
  } else {
    currentMaxZ = zIndex - 1;
  }

  var boxDiv = d.createElement('div');
  boxDiv.style.cssText = 'position: fixed;' + 'top:0;' + 'left:0;' + 'width:100%;' + 'height:100%;' + 'z-index:' + (currentMaxZ + 1) + ';';

  if ((0, _EnvUtils.isSupportSVG)()) {
    boxDiv.style.background = 'rgba(0,0,0,0.3)';
  } else {
    boxDiv.style.background = '#000000';
    boxDiv.style.filter = 'alpha(opacity=30)';
  }

  body.appendChild(boxDiv);
  var container = d.createElement('div');
  container.style.cssText = 'position: fixed;' + 'top:5%;' + 'left:10%;' + 'width:80%;' + 'height:90%;' + 'z-index:' + (currentMaxZ + 2) + ';' + 'background:#ffffff;' + 'box-shadow:0px 4px 50px rgba(0,0,0,0.5);'; // for ie quirks mode

  try {
    container.style.setExpression("top", "( ignoreMe = document.body.scrollTop + this.previousSibling.clientHeight * 0.05) + 'px' ");
    boxDiv.style.setExpression("top", "( ignoreMe = document.body.scrollTop ) + 'px' ");
    container.style.position = 'absolute';
    boxDiv.style.position = 'absolute';
  } catch (e) {}

  body.appendChild(container);
  var fullScrVanCharts = VanCharts.init(container); // It's a little strange that
  // the VanChart[S] instance's father is a VanChart instance
  // 'cause we have only one chart in full screen mode

  fullScrVanCharts.fullScreenFather = vanchart;
  fullScrVanCharts.setOptions(options);
  fullScrVanCharts.doHyperlink = vanchart.vancharts.doHyperlink;
  vanchart.set({
    enable: false
  });
  vanchart.fullScreenChart = fullScrVanCharts;
  VanCharts.fullScreenChart = fullScrVanCharts;
  container.boxDiv = boxDiv;

  boxDiv.onclick = function () {
    hideLightBox(container, vanchart);
  };

  container.onclick = function (e) {
    e = e || w.event;

    if (e.stopPropagation) {
      e.stopPropagation();
    } else {
      e.cancelBubble = true;
    }
  };

  vanchart.fire("fullScreenOn");
}

/***/ }),
/* 58 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isCustomLabel = isCustomLabel;
exports.customLabel = customLabel;
exports.customDataLabel = customDataLabel;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _dataLabelFormatter = __webpack_require__(24);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var LABEL_MIN_FONTSIZE = 10;

function isCustomLabel(formatter) {
  return typeof formatter != 'object';
}

function customLabel(point, dataLabelsOpt, autoSize) {
  var dataLabels = _BaseUtils["default"].clone(dataLabelsOpt);

  var style = dataLabels.style;

  if (style.autoSize) {
    style.fontSize = Math.max(autoSize, LABEL_MIN_FONTSIZE) + 'px';
  }

  var customLabel = (0, _dataLabelFormatter.calculateCustomLabel)(point, dataLabels)[0];
  return {
    labelContent: customLabel.text,
    labelStyle: customLabel.style,
    labelDim: customLabel.dim
  };
}

function customDataLabel(series, labelOpt, autoSize, fixColor) {
  var point = series.points[0];
  var label = customLabel(point, labelOpt, autoSize);
  var labelStyle = label.labelStyle,
      labelContent = label.labelContent,
      labelDim = label.labelDim;

  if (fixColor) {
    labelStyle.color = point.color;
  }

  return {
    labelContent: labelContent,
    labelStyle: labelStyle,
    labelDim: labelDim
  };
}

/***/ }),
/* 59 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createMultiLineLabelContent = createMultiLineLabelContent;
exports.calculateSingleLineLabelContent = calculateSingleLineLabelContent;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _FormattedText = __webpack_require__(41);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function createMultiLineLabelContent(formatter, data) {
  if (!formatter) {
    return {};
  }

  if (typeof formatter == 'object') {
    var content = {};
    var label = formatter.identifier;

    var categoryString = _BaseUtils["default"].format(data.category, formatter.categoryFormat);

    var seriesString = _BaseUtils["default"].format(data.seriesName, formatter.seriesFormat);

    var valueString = _BaseUtils["default"].format(data.originalValue, formatter.valueFormat);

    var percentString = _BaseUtils["default"].format(data.percentage, formatter.percentFormat);

    if (label.indexOf(_FormattedText.CATEGORY) != -1) {
      content.category = categoryString;
    }

    if (label.indexOf(_FormattedText.SERIES) != -1) {
      content.series = seriesString;
    }

    if (label.indexOf(_FormattedText.VALUE) != -1) {
      content.value = valueString;
    }

    if (label.indexOf(_FormattedText.PERCENT) != -1) {
      content.percent = percentString;
    }

    return content;
  } else {
    return {
      text: _BaseUtils["default"].getFormatterFunction(formatter).call(data)
    };
  }
}

function calculateSingleLineLabelContent(formatter, data) {
  if (!formatter) {
    return '';
  }

  if (typeof formatter == 'object') {
    var content = '';
    var label = formatter.identifier;

    var categoryString = _BaseUtils["default"].format(_BaseUtils["default"].pick(data.category, ''), formatter.categoryFormat);

    var seriesString = _BaseUtils["default"].format(_BaseUtils["default"].pick(data.seriesName, ''), formatter.seriesFormat);

    if (label.indexOf(_FormattedText.CATEGORY) != -1 || label.indexOf(_FormattedText.SERIES) != -1) {
      if (label.indexOf(_FormattedText.CATEGORY) != -1 && label.indexOf(_FormattedText.SERIES) != -1) {
        content += categoryString + ' ' + seriesString;
      } else if (label.indexOf(_FormattedText.CATEGORY) != -1) {
        content += categoryString;
      } else {
        content += seriesString;
      }
    }

    if (!data.isNull && label.indexOf(_FormattedText.VALUE) != -1 || label.indexOf(_FormattedText.PERCENT) != -1) {
      if (!(0, _CoreUtils.isEmpty)(content)) {
        content += ':';
      }

      var valueString = _BaseUtils["default"].format(data[data.series.getTargetKey()], formatter.valueFormat);

      var percentString = _BaseUtils["default"].format(data.percentage, formatter.percentFormat);

      if (label.indexOf(_FormattedText.VALUE) != -1 && label.indexOf(_FormattedText.PERCENT) != -1) {
        content += valueString + ' ' + percentString;
      } else if (label.indexOf(_FormattedText.VALUE) != -1) {
        content += valueString;
      } else {
        content += percentString;
      }
    }

    return content;
  } else {
    return _BaseUtils["default"].getFormatterFunction(formatter).call(data);
  }
}

/***/ }),
/* 60 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ScrollbarItem = _interopRequireDefault(__webpack_require__(61));

var _ScrollbarItemCanvas = _interopRequireDefault(__webpack_require__(155));

var _component = __webpack_require__(4);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/2/27.
 */
var MIN_BAR_LENGTH = 20;

function toFixed(value) {
  return +value.toFixed(3);
}
/**
 * usage:
 *
 // view
 var view = this;
 view.scrollbar = new Scrollbar({
         view: view, // view
         group: g, // svg group
         width: this.bounds.width,
         height: this.bounds.height,
         innerWidth: this.innerWidth,
         innerHeight: this.innerBodyHeight
     })

 // listen on:
 view.scrollbar
 .on('scrollX', this.onScrollX, view) // data: {x: Number}
 .on('scrollY', this.onScrollY, view) // data: {y: Number}

 // fire:
 view.fire('innerChange', pos) // give it a pos object {x: Number, y: Number}
 view.fire('resize', options) // new width, height, innerWidth, innerHeight
 view.fire('mouseover') // display
 view.fire('mouseout') // hide

 */


var _default = _Evented["default"].extend({
  /**
   *
   * @param options
   * {
   *   view: object, // the view this bar built on
   *   group: object, // the dom g this manager appended
   *   onChangeName: string, | 'innerChange' // listen on eventName
   *   onResizeName: string, | 'resize'
   *   onOverName: string, | 'mouseover'
   *   onOutName: string, | 'mouseout'
   *   width: 0, // visible area
   *   height: 0,
   *   innerWidth: 0, // inner real size
   *   innerHeight: 0,
   *   scrollX: true,
   *   scrollY: true,
   *   autoHide: true
   * }
   */
  initialize: function (options) {
    // for convenient
    this.view = options.view;
    this.vanchart = options.view.vanchart;
    this.renderer = options.view.renderer || this.vanchart.renderer;
    this.group = options.group;
    this.options = options;
    this.options.autoHide = options.autoHide !== false;
    this.x = this.y = 0; // inner bounds translation

    if (this._isScrollX(options)) {
      this.barX = this._barBottom();
    }

    if (this._isScrollY(options)) {
      this.barY = this._barRight();
    }

    var changeName = options.onChangeName || 'innerChange';
    var resizeName = options.onResizeName || 'resize';
    var overName = options.onOverName || 'mouseover';
    var outName = options.onOutName || 'mouseout';
    this.view.on(changeName, this.setPos, this).on(resizeName, this.setSize, this);

    if (options.autoHide) {
      this.barX && this.barX.show(false);
      this.barY && this.barY.show(false);
      this.view.on(overName, this.onover, this);
      this.view.on(outName, this.onout, this);
    }
  },
  onover: function () {
    this.show(true);
  },
  onout: function () {
    this.show(false);
  },
  show: function (d) {
    this.barX && this.barX.show(d);
    this.barY && this.barY.show(d);
  },
  setPos: function (pos) {
    // if (pos.initiator === this) {
    //     return
    // }
    if (this.barX && pos.x != null) {
      var pctX = pos.x / (this.options.width - this.options.innerWidth);
      this.barX.setPct(pctX);
    }

    if (this.barY && pos.y != null) {
      var pctY = pos.y / (this.options.height - this.options.innerHeight);
      this.barY.setPct(pctY);
    }
  },
  // resize, bar group pos and bar size
  setSize: function (options) {
    options.scrollX = this.options.scrollX;
    options.scrollY = this.options.scrollY;

    if (this.options.scrollX) {
      var shouldX = this._isScrollX(options);

      if (shouldX && !this.barX) {
        this.barX = this._barBottom();
      }

      if (!shouldX && this.barX) {
        this.barX.remove();
        this.barX = null;
      }

      if (shouldX && this.barX) {
        var lengths = this._getLengths(options, 'width');

        this.barX.setPos(0, options.height - _ScrollbarItem["default"].SIZE);
        this.barX.setSize(lengths.length, lengths.barLength);
      }
    }

    if (this.options.scrollY) {
      var shouldY = this._isScrollY(options);

      if (shouldY && !this.barY) {
        this.barY = this._barBottom();
      }

      if (!shouldY && this.barY) {
        this.barY.remove();
        this.barX = null;
      }

      if (shouldY && this.barY) {
        var lengths = this._getLengths(options, 'height');

        this.barY.setPos(options.width - _ScrollbarItem["default"].SIZE, 0);
        this.barY.setSize(lengths.length, lengths.barLength);
      }
    }

    _BaseUtils["default"].extend(this.options, options);
  },
  _barBottom: function () {
    var lengths = this._getLengths(this.options, 'width');

    return this._bar('x', 0, this.options.height - _ScrollbarItem["default"].SIZE, lengths.length, lengths.barLength);
  },
  _barRight: function () {
    var lengths = this._getLengths(this.options, 'height');

    return this._bar('y', this.options.width - _ScrollbarItem["default"].SIZE, 0, lengths.length, lengths.barLength);
  },
  _getLengths: function (options, prop) {
    var outer = options[prop];
    var inner = prop === 'width' ? options.innerWidth : options.innerHeight;
    var length = outer - (this._isScrollBoth(options) ? _ScrollbarItem["default"].SIZE : 0);
    return {
      length: length,
      barLength: Math.max(outer / inner * length, MIN_BAR_LENGTH)
    };
  },

  /**
   *
   * @param dir 'x'/'y'
   * @param x translate x
   * @param y translate y
   * @param length background length
   * @param barLength
   * @private
   */
  _bar: function (dir, x, y, length, barLength) {
    var opt = {
      manager: this,
      group: this.group,
      x: x,
      y: y,
      length: length,
      barLength: barLength,
      dir: dir
    };

    if (this.options.barStyle) {
      opt = _BaseUtils["default"].extend(opt, this.options.barStyle);
    }

    return this.useCanvas() ? new _ScrollbarItemCanvas["default"](opt) : new _ScrollbarItem["default"](opt);
  },
  useCanvas: function () {
    if (this.view && this.view.componentType === _component.ComponentCst.LEGEND_COMPONENT) {
      return false;
    }

    return this.vanchart.useCanvas();
  },
  onx: function (pct) {
    this.fire('scrollX', {
      initiator: this,
      x: pct * (this.options.width - this.options.innerWidth)
    });
  },
  ony: function (pct) {
    this.fire('scrollY', {
      initiator: this,
      y: pct * (this.options.height - this.options.innerHeight)
    });
  },
  _isScrollX: function (options) {
    return options.scrollX && toFixed(options.width) < toFixed(options.innerWidth);
  },
  _isScrollY: function (options) {
    return options.scrollY && toFixed(options.height) < toFixed(options.innerHeight);
  },
  _isScrollBoth: function (options) {
    return this._isScrollX(options) && this._isScrollY(options);
  },
  remove: function () {
    this.barX && this.barX.remove();
    this.barY && this.barY.remove();
    this.barX = this.barY = null;
  }
});

exports["default"] = _default;

/***/ }),
/* 61 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/2/27.
 */
// todo, need a transform util
var transReg = /translate\(\s*([\d|.|e|-]+)(?:[,\s]*)([\d|.|e|-]*)\s*\)/i;
var BG_SIZE = 12;
var BG_COLOR = 'rgba(233, 233, 233, 0.6)';
var BG_STROKE = 'rgba(207, 207, 207, 0.6)';
var BG_STROKE_WIDTH = 0.5;
var BAR_SIZE = 6;
var BAR_COLOR = 'rgba(160, 160, 160, 0.6)';
var BAR_HOVER_COLOR = 'rgba(88, 88, 88, 0.6)';

var ScrollbarItem = _Evented["default"].extend({
  initialize: function (cfg) {
    var opt = this.opt = _QueryUtils["default"].merge(cfg, {
      backgroundSize: BG_SIZE,
      backgroundColor: BG_COLOR,
      backgroundStroke: BG_STROKE,
      barColor: BAR_COLOR,
      barHoverColor: BAR_HOVER_COLOR,
      barSize: BAR_SIZE
    });

    opt.length = Math.max(0, opt.length);
    opt.barLength = Math.max(0, opt.barLength);
    var backgroundSize = opt.backgroundSize;
    var barSize = opt.barSize;
    var barRound = opt.barSize / 2;
    this.pos = {
      x: 0,
      y: 0
    };
    var vanchart = opt.manager.vanchart,
        R = opt.manager.renderer;
    this.group = opt.group.append(R.group());
    this.group.style('transition', 'opacity 0.3s');
    this.group.attr('transform', _BaseUtils["default"].makeTranslate([opt.x, opt.y]));
    var width, height, barWidth, barHeight, offsetDir;

    if (opt.dir === 'x') {
      width = this.opt.length;
      height = backgroundSize;
      barWidth = this.opt.barLength;
      barHeight = barSize;
      offsetDir = 'y';
    } else {
      width = backgroundSize;
      height = this.opt.length;
      barWidth = barSize;
      barHeight = this.opt.barLength;
      offsetDir = 'x';
    }

    this.background = this.group.append(R.rect().attr({
      'width': width,
      'height': height
    }).style({
      'fill': opt.backgroundColor,
      'stroke': opt.backgroundStroke,
      'stroke-width': BG_STROKE_WIDTH
    }));
    var barAttrs = {
      'rx': barRound,
      'ry': barRound,
      'width': barWidth,
      'height': barHeight
    };
    barAttrs[offsetDir] = (backgroundSize - barSize) / 2;
    this.bar = this.group.append(R.rect().attr(barAttrs).style('fill', opt.barColor));
    vanchart.registerInteractiveTarget(this, this.bar);
  },
  show: function (d) {
    d = this._over || d;

    if (this.opt.length <= this.opt.barLength) {
      d = false;
    }

    if (d !== this._showed) {
      this._showed = d;
      this.group.style('display', d ? '' : 'none');
    }
  },
  remove: function () {
    this.group.remove();
    this.bar.remove();
  },
  setPos: function (x, y) {
    if (x !== this.opt.x || y !== this.opt.y) {
      this.group.attr('transform', _BaseUtils["default"].makeTranslate([x, y]));
      this.opt.x = x;
      this.opt.y = y;
    }
  },
  setSize: function (length, barLength) {
    if (length !== this.opt.length || barLength !== this.opt.barLength) {
      // 这些size啊看上去就像个bug
      if (length < barLength || length < 0 || barLength < 0) {
        length = barLength = 0;
      }

      this.opt.length = length;
      this.opt.barLength = barLength;

      if (length === 0) {
        this.show(false);
      } else {
        var key = this.opt.dir === 'x' ? 'width' : 'height';
        this.background.attr(key, length);
        this.bar.attr(key, barLength);
      }
    }
  },
  setPct: function (pct) {
    this.setBarPos(this._getRemainLength() * pct);
  },
  getBarPos: function () {
    return this.pos[this.opt.dir];
  },
  setBarPos: function (value) {
    value = Math.max(0, Math.min(value, this._getRemainLength()));

    if (this.getBarPos() !== value) {
      this.pos[this.opt.dir] = value;
      this.bar.attr('transform', _BaseUtils["default"].makeTranslate(this.pos));
    }
  },
  _getRemainLength: function () {
    return this.opt.length - this.opt.barLength;
  },
  // _getBarPos: function () {
  //     var translate;
  //     if (isSupportSVG) {
  //         translate = this.bar.attr('transform').match(transReg);
  //         translate && translate.shift();
  //
  //     } else {
  //         var style = this.bar.node().style;
  //         translate = [parseFloat(style.left), parseFloat(style.top)];
  //     }
  // },
  getEvents: function () {
    return {
      'mouseover': this.onMouseOver,
      'mouseout': this.onMouseOut,
      'panstart': this.onPanStart,
      'panmove': this.onPanMove,
      'panend': this.onPanEnd
    };
  },
  onMouseOver: function () {
    this._over = true;
    this.bar.style({
      fill: this.opt.barHoverColor
    });
  },
  onMouseOut: function () {
    this._over = false;
    this.bar.style({
      fill: this.opt.barColor
    });
  },
  onPanStart: function (ev) {
    this.initPos = this.getBarPos();
    this.initPointPos = ev.containerPoint;
  },
  onPanMove: function (ev) {
    var delta = ev.containerPoint[this.opt.dir] - this.initPointPos[this.opt.dir]; // this.setBarPos(this.initPos + delta); // 不改变自己, 避免重复事件还要加判断

    this.opt.manager['on' + this.opt.dir]((this.initPos + delta) / this._getRemainLength());
  },
  onPanEnd: function () {
    this.opt.manager.vanchart.handler.panTarget = null;
  }
});

ScrollbarItem.SIZE = BG_SIZE;
var _default = ScrollbarItem;
exports["default"] = _default;

/***/ }),
/* 62 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _CategoryAxis = _interopRequireDefault(__webpack_require__(51));

var _ValueAxis = _interopRequireDefault(__webpack_require__(64));

var _DateAxis = _interopRequireDefault(__webpack_require__(89));

var _MultiCategoryAxis = _interopRequireDefault(__webpack_require__(90));

var _component = __webpack_require__(4);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/15.
 * 坐标轴组建的定义
 */
var Axis = _Base["default"].extend({
  _refresh: function () {
    this._axisList = this._axisList || [];
    var options = this.options;
    options = _BaseUtils["default"].isArray(options) ? options : [options]; //最终生成的坐标轴数应该和新的option一样

    var len = options.length;

    for (var axisIndex = len; axisIndex < this._axisList.length; axisIndex++) {
      this._axisList[axisIndex].remove();

      this._axisList[axisIndex] = null;
    }

    this._axisList.length = len;

    for (var axisIndex = len - 1; axisIndex >= 0; axisIndex--) {
      //增加一个坐标轴序号的标记
      options[axisIndex].axisIndex = axisIndex;

      if (this._axisList[axisIndex] && this._axisList[axisIndex].type != options[axisIndex].type) {
        this._axisList[axisIndex].remove();

        this._axisList[axisIndex] = null;
      }

      if (this._axisList[axisIndex]) {
        this._axisList[axisIndex].refresh(options[axisIndex]);
      } else {
        var AxisClass;
        var axisType = options[axisIndex].type || _component.ComponentCst.VALUE_AXIS_COMPONENT;

        if (axisType == _component.ComponentCst.VALUE_AXIS_COMPONENT) {
          AxisClass = _ValueAxis["default"];
        } else if (axisType == _component.ComponentCst.CATEGORY_AXIS_COMPONENT) {
          AxisClass = _CategoryAxis["default"];
        } else if (axisType == _component.ComponentCst.DATE_AXIS_COMPONENT) {
          AxisClass = _DateAxis["default"];
        } else if (axisType === _component.ComponentCst.MULTI_CATEGORY_AXIS_COMPONENT) {
          AxisClass = _MultiCategoryAxis["default"];
        }

        this._axisList[axisIndex] = new AxisClass(options[axisIndex], this.componentType, this.vanchart);
      }
    }
  },
  doLayout: function () {
    var axisCount = this._axisList.length;

    for (var i = axisCount - 1; i >= 0; i--) {
      this._axisList[i].calculateDomainFromData();

      this._axisList[i]._calculateSize();

      this._axisList[i]._recordAxisSize();
    }
  },
  reCalculateSize: function () {
    var axisCount = this._axisList.length;

    for (var i = axisCount - 1; i >= 0; i--) {
      this._axisList[i]._calculateSize();

      this._axisList[i]._recordAxisSize();
    }
  },
  updateAxisClip: function () {
    var clipBounds = {};
    var axisCount = this._axisList.length;

    for (var i = axisCount - 1; i >= 0; i--) {
      this._axisList[i].updateClipBounds(clipBounds);
    }

    this._recordForPlotBounds(_Constants["default"].LEFT, clipBounds[_Constants["default"].LEFT] || 0);

    this._recordForPlotBounds(_Constants["default"].RIGHT, clipBounds[_Constants["default"].RIGHT] || 0);

    this._recordForPlotBounds(_Constants["default"].TOP, clipBounds[_Constants["default"].TOP] || 0);

    this._recordForPlotBounds(_Constants["default"].BOTTOM, clipBounds[_Constants["default"].BOTTOM] || 0);
  },
  updateAxisSizeAndBounds: function () {
    var axisCount = this._axisList.length;

    for (var i = axisCount - 1; i >= 0; i--) {
      this._axisList[i].updateAxisSizeAndBounds();
    }
  },
  adjustDomain4Radius: function () {
    var adjusted = false;
    var axisCount = this._axisList.length;

    for (var i = axisCount - 1; i >= 0; i--) {
      adjusted = this._axisList[i].adjustDomain4Radius() || adjusted;
    }

    return adjusted;
  },
  fixBoundsByPlot: function () {
    var plotBounds = this.vanchart.bounds;
    var map = {};

    for (var i = 0, axisCount = this._axisList.length; i < axisCount; i++) {
      var axis = this._axisList[i],
          position = axis.getPosition();

      if (axis.isOnZero()) {
        if (position == _Constants["default"].TOP || position == _Constants["default"].BOTTOM) {
          axis.bounds.width = plotBounds.width;
        } else {
          axis.bounds.height = plotBounds.height;
        } //计算坐标轴的scale和tickData


        axis.fixScaleAndTickData();
      } else {
        map[position] = map[position] || [];
        map[position].push(axis);
      }
    }

    for (var position in map) {
      var axisList = map[position];
      var isHorizontal = position == _Constants["default"].TOP || position == _Constants["default"].BOTTOM;

      for (var i = 0, count = axisList.length; i < count; i++) {
        var axis = axisList[i],
            axisBounds = axis.bounds;
        var baseBounds = axisList[i - 1] && axisList[i - 1].bounds || plotBounds;

        if (isHorizontal) {
          var y = position == _Constants["default"].TOP ? baseBounds.y - axisBounds.height : baseBounds.y + baseBounds.height;
          axis.bounds = _BaseUtils["default"].makeBounds(baseBounds.x, y, baseBounds.width, axisBounds.height);
        } else {
          var x = position == _Constants["default"].LEFT ? baseBounds.x - axisBounds.width : baseBounds.x + baseBounds.width;
          axis.bounds = _BaseUtils["default"].makeBounds(x, baseBounds.y, axisBounds.width, baseBounds.height);
        } //计算坐标轴的scale和tickData


        axis.fixScaleAndTickData();
      }
    }
  },
  getAxis: function (axisIndex) {
    if (axisIndex >= this._axisList.length) {
      axisIndex = 0;
    }

    return this._axisList[axisIndex];
  },
  getAxisCount: function () {
    return this._axisList.length;
  },
  axisZoom: function (downPos, upPos) {
    this._axisList.forEach(function (axis) {
      axis.axisZoom(downPos, upPos);
    });
  },
  //处理0值对齐
  dealOnZero: function () {
    this._axisList.forEach(function (axis) {
      axis.dealOnZero();
    });
  },
  updateAxisBounds: function () {
    // 处理0值对齐之后会改变当前值轴的bounds属性，现在将其改回来
    this._axisList.forEach(function (axis) {
      axis.updateAxisBounds();
    });
  },
  render: function () {
    for (var i = 0, len = this._axisList.length; i < len; i++) {
      this._axisList[i].render();
    }
  },

  /**
   * 移除Axis组件下所有细分的axis
   * @return {[type]} [description]
   */
  remove: function () {
    for (var i = 0, len = this._axisList.length; i < len; i++) {
      this._axisList[i].remove();
    }
  }
});

var _default = Axis;
exports["default"] = _default;

/***/ }),
/* 63 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _VanChartLayout = _interopRequireDefault(__webpack_require__(52));

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _component = __webpack_require__(4);

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _StyleUtils = __webpack_require__(29);

var _AxisUtils = __webpack_require__(40);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/6/18.
 */
var TIME = 400;
var EASE = _BezierEasing["default"].css.swing;
var LABEL_LINE_GAP = 4;

var LABEL_LINE_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(LABEL_LINE_GAP);
};

var TICK_LENGTH = 4;
var TITLE_LABEL_GAP = 8;

var TITLE_LABEL_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(TITLE_LABEL_GAP);
};

var PADDING = 5;
var TICK_COUNT = 5;
var POINTER_GAUGE_COUNT = 8;
var RADAR_TICK_COUNT = 4;
var MIN_MAX_GAP = 100;
var MAIN_TICK = 'main';
var MINOR_TICKS = 'minor';
var ARROW_SIZE = 15;

var BaseAxis = _Base["default"].extend({
  labelRotation: 0,
  _refresh: function () {
    this.series = []; //for category axis

    this.isRangePoints = true;
    this.piece = null;
    this.forecast = [0, 0]; // trendline period

    this._zoomDomain = this._dataDomain = this._domain = this._tickStart = this._step = 0;

    if (this._firstCalcDomain) {
      this._firstCalcDomain = null;
    }

    this.initScale();
    var options = this.options,
        titleOptions = options.title;

    _BaseUtils["default"].calculateFontSizeWithScale(options.labelStyle);

    _BaseUtils["default"].calculateFontSizeWithScale(titleOptions && titleOptions.style);

    if (options.plotLines && options.plotLines.length) {
      options.plotLines.forEach(function (opt) {
        _BaseUtils["default"].calculateFontSizeWithScale(opt && opt.label && opt.label.style);
      });
    }

    options.tickPadding = isNaN(options.tickPadding) ? 6 : options.tickPadding;
    options.tickLength = options.enableTick ? isNaN(options.tickLength) ? 4 : options.tickLength : 0;
    options.minorTickLength = options.enableMinorTick ? isNaN(options.minorTickLength) ? 2 : options.minorTickLength : 0;
  },
  //计算坐标轴挤占绘图区的空间
  _calculateSize: function (tickData) {
    var axisOption = this.options;
    this.tickLabelLength = this._getTickLabelLength(tickData);

    var axisTitleLength = this.labelLength = this._getAxisTitleLength();

    axisTitleLength += axisTitleLength > 0 ? TITLE_LABEL_GAP_FUN() : 0;
    var usedSize = this.tickLabelLength + axisTitleLength;
    var isHorizontal = this.isHorizontal();
    var isInverted = this.vanchart.isInverted();
    var useMaxHeight = (0, _AxisUtils.isUseMaxHeight)(isHorizontal, isInverted);
    /**
     * CHART-1275 解决坐标轴翻转之后设置maxWidth或者maxHeight导致坐标轴消失的问题。
     * 给变量isHorizontal赋值的时候程序已经判断了当前坐标轴最终在屏幕上绘制的方向了，
     * 所以我们只需判断当前轴最终的方向，如果是横向的话，那么计算该轴挤占空间应该使用绘图区的height，
     * 反之使用绘图区的width。
     */

    var calcMaxFunc = isHorizontal ? this._maxHeight : this._maxWidth,
        max = useMaxHeight ? axisOption.maxHeight : axisOption.maxWidth;
    usedSize = max ? Math.min(calcMaxFunc.call(this, max), usedSize) : usedSize;
    this._size = this.series.length === 0 ? 0 : Math.round(usedSize);
  },

  /**
   * 抵消VanChartPool数据表中所占的有待裁剪区域，避免多裁剪了尺寸
   */
  offsetDataSheetClipPoolSize: function () {
    var position = this.getPosition(),
        vanchart = this.vanchart,
        clipPool = vanchart.clipPool;
    var isValueAxis = this.isValue(),
        hasDataSheet = vanchart.getComponent(_component.ComponentCst.DATA_SHEET_COMPONENT);

    if (isValueAxis && hasDataSheet && position === _Constants["default"].LEFT && clipPool[position]) {
      clipPool[position] -= this._size;
    }
  },
  _recordAxisSize: function () {
    if (!this.isOnZero()) {
      this.vanchart.axisSize[this.getPosition()] += this._size;
    }
  },

  /**
   * 计算出当前坐标轴的_dataDomain
   * @param dataDomain  给定的值域
   * @param needConsiderBaseAxisDataDomain 是否需要考虑基础轴的值域：布尔值
   */
  calculateDomainFromData: function (dataDomain, needConsiderBaseAxisDataDomain) {
    if (!dataDomain) {
      this.byPercent = !this._isBaseAxis() && this.isPercentAxis();
      dataDomain = this._getDomainFromData(needConsiderBaseAxisDataDomain);
    } // 为什么要在这里写：排序的时候doLayout不执行，就先放这里了


    if (this.indicator) {
      this._calculateCateDomainData();
    }

    this._dataDomain = dataDomain;
    var zoomTool = this.vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT);
    var zoomDomain = this._zoomDomain || zoomTool && zoomTool.getZoomInitDomain(this);
    var customDomain = [this.options.min, this.options.max];
    var fixedDomain = (0, _AxisUtils.getFixedDomain)(customDomain, zoomDomain, this._isBaseAxis());

    this._calculateNiceDomain(this._dataDomain[0], this._dataDomain[1], fixedDomain[0], fixedDomain[1]); // 日期轴计算默认格式


    this._calculateDateFormat && this._calculateDateFormat();
  },
  _calculateNiceDomain: function (minValue, maxValue, fixedMin, fixedMax) {
    var axisOption = this.options;

    if (axisOption.log) {
      return this._calculateLogNiceDomain(minValue, maxValue, fixedMin, fixedMax);
    } else if (this.byPercent) {
      return this._calculatePercentValueDomain(minValue, maxValue, fixedMin, fixedMax);
    } else {
      return this._calculateValueNiceDomain(minValue, maxValue, fixedMin, fixedMax);
    }
  },
  // todo 先把属性的计算都抽出来，然后再考虑能不能简化属性
  isPercentAxis: function () {
    var series = this.series;
    var isPercent = false;

    for (var i = 0, len = series.length; i < len; i++) {
      isPercent = isPercent || series[i].options.stackByPercent;
    }

    return isPercent;
  },

  /**
   * 图表缩放时判断是否只开启了baseAxis所在的方向的缩放
   * @returns {*|boolean}
   */
  isBaseAxisOnZoomOnly: function () {
    var chartOption = this.vanchart.options,
        zoomType = chartOption.zoom && chartOption.zoom.zoomType;
    return this._isBaseAxis() && zoomType === this.componentType.substr(0, 1);
  },
  calculateDomainFromZoom: function () {
    var zoomDomain = this._zoomDomain,
        cfg = this.options;

    if (this._isBaseAxis()) {
      this._calculateNiceDomain(this._dataDomain[0], this._dataDomain[1], zoomDomain[0], zoomDomain[1]);

      this.isBaseAxisOnZoomOnly() && this.vanchart.reCalcValueAxisDataDomain(this.componentType);
    } else {
      var min = (0, _CoreUtils.hasDefined)(cfg.min) ? Math.max(cfg.min, zoomDomain[0]) : zoomDomain[0];
      var max = (0, _CoreUtils.hasDefined)(cfg.max) ? Math.min(cfg.max, zoomDomain[1]) : zoomDomain[1];

      if (min > max) {
        return;
      }

      var fromZero = this.type === _component.ComponentCst.VALUE_AXIS_COMPONENT && (0, _CoreUtils.hasNotDefined)(cfg.min);
      var baseValue = this.isLog() ? 1 : 0;
      min = fromZero ? Math.min(baseValue, min) : min;
      /**
       * 缩放的时候，对于设置了0值对齐，存在基准轴，且该值轴不是标准轴的情况，就不需要调用_calculateNiceDomain了，
       * 因为当前值轴的domain会在dealOnZero中进行最后显示之前的更新，这里就不做多余的事情了。
       * 由于在上一次的dealOnZero中，为了保证坐标轴的刻度是一个符合人类阅读习惯的数值，就把domain扩展了，
       * 比如[0, 1900]可能会扩展成[0, 2000]，现在获取的zoomDomain是按照[0, 2000]这个区间来获取的，
       * 现在要把它转化成[0, 1900]对应的区间段，这样获得最终区间才不会太离谱！！！
       */

      if (this.alignAxisId && !/^standard/.test(this.alignAxisId) && this._firstCalcDomain) {
        var t = (zoomDomain[0] - this._domain[0]) / (this._domain[1] - this._domain[0]);
        var t1 = (zoomDomain[1] - this._domain[0]) / (this._domain[1] - this._domain[0]);
        min = this._firstCalcDomain[0] + (this._firstCalcDomain[1] - this._firstCalcDomain[0]) * t;
        max = this._firstCalcDomain[0] + (this._firstCalcDomain[1] - this._firstCalcDomain[0]) * t1;
        this._domain = [min, max];
      } else {
        this._calculateNiceDomain.apply(this, [zoomDomain[0], zoomDomain[1], min, max]);
      }
    }
  },
  isCategory: function () {
    return this.type === _component.ComponentCst.CATEGORY_AXIS_COMPONENT;
  },
  isValue: function () {
    return this.type === _component.ComponentCst.VALUE_AXIS_COMPONENT;
  },
  isDate: function () {
    return this.type === _component.ComponentCst.DATE_AXIS_COMPONENT;
  },
  zoomRefresh: function (zoom) {
    this._zoomDomain = zoom;
    this.calculateDomainFromZoom();
  },
  axisZoom: function (downPos, upPos) {
    var startPos,
        endPos,
        isDateAxis = this.type === _component.ComponentCst.DATE_AXIS_COMPONENT,
        det = isDateAxis ? 1000 : 1e-11;
    var plotBounds = this.vanchart.bounds; //坐标轴是横向的

    if (this.isHorizontal()) {
      startPos = Math.min(downPos.x, upPos.x) - plotBounds.x;
      endPos = Math.max(downPos.x, upPos.x) - plotBounds.x;
      startPos = Math.max(startPos, 0);
      endPos = Math.min(endPos, plotBounds.width);
    } else {
      startPos = Math.min(downPos.y, upPos.y) - plotBounds.y;
      endPos = Math.max(downPos.y, upPos.y) - plotBounds.y;
      startPos = Math.max(startPos, 0);
      endPos = Math.min(endPos, plotBounds.height);
    }

    var startValue = this.scale.invert(startPos);
    var endValue = this.scale.invert(endPos);

    if (isDateAxis) {
      startValue = _BaseUtils["default"].date2int(startValue);
      endValue = _BaseUtils["default"].date2int(endValue);
    }

    if (Math.abs(startValue - endValue) < det) {
      return;
    }

    this.zoomRefresh([Math.min(startValue, endValue), Math.max(startValue, endValue)]);
  },
  getAxisValue: function (value) {
    return value;
  },
  getTrendLineForecast: function (sery) {
    var trendLine = sery.options.trendLine;

    if (trendLine && trendLine.period && trendLine.period.length === 2) {
      var period = trendLine.period;
      this.forecast[0] = Math.min(this.forecast[0] || 0, period[0]);
      this.forecast[1] = Math.max(this.forecast[1] || 0, period[1]);
    }
  },
  _getStartAndEndTick: function () {
    return this._domain;
  },
  //即使自动旋转，也能保证这里clip出来的边界够用
  updateClipBounds: function (clipBounds) {
    if (this.series.length === 0) {
      return;
    }

    var startSize, endSize, t_s, t_e;
    var isHorizontal = this.isHorizontal(),
        isReversed = this.isAxisReversed(),
        cfg = this.options;

    if (this.options.showLabel) {
      var tick = this._getStartAndEndTick();

      var tick_0 = tick[0];
      var tick_1 = tick[1];

      if (this.isMultiCateAxis && this.isMultiCateAxis()) {
        var tickArray_0 = _BaseUtils["default"].decodeCategoryArray(tick_0);

        var tickArray_1 = _BaseUtils["default"].decodeCategoryArray(tick_1);

        tick_0 = tickArray_0.length ? tickArray_0[tickArray_0.length - 1] : '';
        tick_1 = tickArray_1.length ? tickArray_1[tickArray_1.length - 1] : '';
      }

      var startDim = this._getTickDim(this._getTickContent(tick_0, cfg.formatter));

      var endDim = this._getTickDim(this._getTickContent(tick_1, cfg.formatter));

      if (isReversed) {
        t_s = endDim;
        t_e = startDim;
      } else {
        t_s = startDim;
        t_e = endDim;
      }

      startSize = isHorizontal ? t_s.width : t_s.height;
      endSize = isHorizontal ? t_e.width : t_e.height; //标签与四周保证有个边距

      startSize = Math.round(startSize / 2) + PADDING;
      endSize = Math.round(endSize / 2) + PADDING;

      if (this.showArrow()) {
        endSize = Math.max(endSize, ARROW_SIZE);
      }
    } else {
      startSize = 0;
      endSize = this.showArrow() ? ARROW_SIZE : 0;
    }

    var plotBounds = this.vanchart.bounds;

    if (isHorizontal) {
      var axisSize = this.vanchart.axisSize;
      var leftDis = axisSize.left + PADDING;
      var rightDis = axisSize.right + PADDING;

      if (this.isCategory() && !this.isRangePoints) {
        var domain = this._zoomDomain || this._dataDomain;
        var rangeBand = (plotBounds.width - axisSize.left - axisSize.right) / domain.length;
        leftDis += Math.round(rangeBand / 2);
        rightDis += Math.round(rangeBand / 2);
      }

      if (this.options.labelRotation <= -15) {
        startSize = Math.round((startSize - PADDING) * 2);
      } else if (this.options.labelRotation >= 15) {
        endSize = Math.round((endSize - PADDING) * 2);
      }

      startSize = Math.max(startSize - leftDis, 0) + PADDING;
      endSize = Math.max(endSize - rightDis, 0) + PADDING + (this.showArrow() ? ARROW_SIZE : 0);
      clipBounds[_Constants["default"].LEFT] = Math.max(clipBounds[_Constants["default"].LEFT] || 0, startSize);
      clipBounds[_Constants["default"].RIGHT] = Math.max(clipBounds[_Constants["default"].RIGHT] || 0, endSize);
    } else {
      clipBounds[_Constants["default"].TOP] = Math.max(clipBounds[_Constants["default"].TOP] || 0, endSize);
      clipBounds[_Constants["default"].BOTTOM] = Math.max(clipBounds[_Constants["default"].BOTTOM] || 0, startSize);
    } //CHART-917 && CHART-2071 && CHART-2118
    // 问题在于裁剪了两次(数据表和左侧值轴:存在重复区域)，之前的计算逻辑是修改dataSheet和yAxis的layout顺序，目的也是在cutPlotBounds之前，就把重复的这部分给剔除，但是那样写会导致
    // dataSheet的unitLength计算过大，从而导致数据表内系列高度计算偏小进而导致系列内容显示不完全，这边不改变布局的顺序，但是在cutPlotBounds之前，判断是否为左侧值轴，然后去除重复的那部分


    this.offsetDataSheetClipPoolSize();
  },
  updateAxisSizeAndBounds: function () {
    this._setComponentBounds(this.getPosition(), this._size);
  },
  fixScaleAndTickData: function () {
    // 留着注释做参考:  使用rangeRound的话，zoom时invert算出的domain只能为整数，在坐标轴极值差 < 1的情况下会出问题
    // this.scale.domain(this._domain).rangeRound(this._getRange());
    this.scale.domain(this._domain).range(this._getRange());

    this._updateOriginTickData();

    this._calculateTickPosAndStep();
  },

  /**
   * FR9.0 的0值对齐的问题处理
   * @param axisList {array} 所有的值轴的数组
   * @returns {array} 处理之后的所有值轴的数组
   * @private
   */
  _alignByZeroValue: function (axisList) {
    var alignId = Date.now() + "" + Math.random() * 100000; // 在这里给每一个值轴做上标记

    axisList.forEach(function (obj, index) {
      index === 0 ? obj.axis.alignAxisId = 'standard' + alignId : obj.axis.alignAxisId = alignId;
    }); // 值轴小于两个直接返回

    if (axisList.length < 2) {
      return axisList;
    } // 现在默认axisList里面的第一个元素就是标准轴


    var standard = axisList[0].axis; // Note: 小夫以前的逻辑是, 从需要对齐的值轴中，找一个作为标准轴, 然后其他的轴和标准轴进行对齐, 而标准轴本身不会发生变化,
    // Note: 这个逻辑应该只适用于存在自定义大小的值轴时, 而对于所有值轴都为设置自定义时, 所有的值轴都应该是可以自动调整对齐的
    // Note: 比如[0, 100]和[-200, 0], 在调整后应该是[-100, 100], [-200, 200]这样, 即满足0值对齐，又能使图形显示完全
    // Note: 这里我们判断一下, 标准轴为自定义大小时, 使用原有逻辑调整, 否则按照自动Domain处理

    if (standard && (standard.options.max != null || standard.options.min != null)) {
      // 更新非标准轴之外的值轴的domain、_step
      return this._forceUpdateAxisDomain(axisList);
    } else {
      return this._dealAutoDomainOnZero(axisList);
    }
  },

  /**
   * 处理0值对齐时自动值轴区间
   * @param axisList
   * @returns {*}
   * @private
   */
  _dealAutoDomainOnZero: function (axisList) {
    var maxNegativeRatio = 0,
        maxPositiveRatio = 0;

    function getAxisDomain(axis) {
      var dataDomain = axis._dataDomain;

      if (dataDomain[0] === dataDomain[1]) {
        return axis._domain;
      }

      return dataDomain;
    } // 第一步, 先计算出每个值轴的正负值占比, 以及最大的正值占比和负值占比


    var npRatios = axisList.map(function (axisObject) {
      var domain = getAxisDomain(axisObject.axis);
      var min = domain[0],
          max = domain[1]; // 同号时, from zero or to zero

      if (max * min >= 0) {
        max = Math.max(0, max);
        min = Math.min(0, min);
      }

      var dis = max - min;
      var negativeRatio = Math.abs(min / dis);
      var positiveRatio = Math.abs(max / dis);
      maxNegativeRatio = Math.max(maxNegativeRatio, negativeRatio);
      maxPositiveRatio = Math.max(maxPositiveRatio, positiveRatio);
      return [negativeRatio, positiveRatio];
    }); // 计算正负值最优比例

    maxPositiveRatio = maxPositiveRatio / (maxPositiveRatio + maxNegativeRatio);
    maxNegativeRatio = maxNegativeRatio / (maxPositiveRatio + maxNegativeRatio);
    var maxPositiveTickCount = 0,
        maxNegativeTickCount = 0; // 要想全部显示且对齐，那么调整后的所有的值轴的区间正负比应该是一致的, 即[maxNegativeRatio, maxPositiveRatio]
    // 我们根据这个比例去从dataDomain中计算出理想的niceDomain和tickInterval

    var preCached = npRatios.map(function (ratio, index) {
      var axis = axisList[index].axis;
      var axisDomain = getAxisDomain(axis);
      var min = axisDomain[0],
          max = axisDomain[1];
      var negativeRatio = ratio[0],
          positiveRatio = ratio[1]; // 同号

      if (max * min >= 0) {
        max = Math.max(0, max);
        min = Math.min(0, min);
      }

      var newMax = max,
          newMin = min; // 调整newMax, newMax / (newMax - newMin) = maxPositiveRatio

      if (negativeRatio > maxNegativeRatio) {
        newMax = newMin * maxPositiveRatio / (maxPositiveRatio - 1);
      } // 调整newMin, -newMin / (newMax - newMin) = maxNegativeRatio


      if (positiveRatio > maxPositiveRatio) {
        newMin = newMax * maxNegativeRatio / (maxNegativeRatio - 1);
      }

      var interval = (0, _AxisUtils.getLinearValidInterval)({
        min: newMin,
        max: newMax,
        interval: axis.options.tickInterval,
        count: axis._getDefaultTickCount(),
        type: axis.type
      }); // Note: 考虑到_linearTickInterval的差异性, 如[-200, 100]和[-12, 6]对应的interval可能为50 & 2, 和domain比例不一致
      // Note: 从而导致了某一侧的默认刻度会比另一侧多, 甚至会跳过0值刻度, 这里我们手动从0开始去向上和向下构造ticks
      // Note: 并记录最大的正值tickCount和最大的负值tickCount, 用以后面强制对齐

      var niceMax = 0,
          niceMin = 0,
          positiveTickCount = 0,
          negativeTickCount = 0; // niceMax >= domain.max

      while (niceMax <= max) {
        niceMax += interval;
        positiveTickCount++;
      } // niceMin <= domain.min


      while (niceMin >= min) {
        niceMin -= interval;
        negativeTickCount++;
      }

      maxPositiveTickCount = Math.max(positiveTickCount, maxPositiveTickCount);
      maxNegativeTickCount = Math.max(negativeTickCount, maxNegativeTickCount); // 这里缓存一下预期的计算结果

      return {
        domain: [niceMin, niceMax],
        tickInterval: interval,
        positiveTickCount: positiveTickCount,
        negativeTickCount: negativeTickCount,
        axis: axis
      };
    }); // 根据maxPositiveTickCount&maxNegativeTickCount, 将不足的值轴标签继续补充, 得出最终的domain & start

    preCached.map(function (cached) {
      var domain = cached.domain,
          tickInterval = cached.tickInterval,
          positiveTickCount = cached.positiveTickCount,
          negativeTickCount = cached.negativeTickCount,
          axis = cached.axis;
      var min = domain[0],
          max = domain[1];
      var i;

      for (i = positiveTickCount; i < maxPositiveTickCount; i++) {
        max += tickInterval;
      }

      for (i = negativeTickCount; i < maxNegativeTickCount; i++) {
        min -= tickInterval;
      } // 这里直接赋值使用, 不走默认的计算逻辑


      axis._domain = [min, max];
      axis._tickStart = min;
      axis._step = tickInterval;
      axis.scale.domain([min, max]);
    });
    return axisList;
  },

  /**
   * 计算出每一个值轴要与标准轴的0刻度对齐需要移动的距离，
   * 然后更新当前值轴的domain、_step、_tickInterval
   * @param axisList
   * @returns {*}
   * @private
   */
  _forceUpdateAxisDomain: function (axisList) {
    var standardAxis = axisList[0].axis;
    var zeroPos = standardAxis.getZeroPos();

    var ticks = standardAxis._getTickValues();

    var self = this;
    axisList.forEach(function (obj, index) {
      if (index === 0) {
        return;
      }

      var axis = obj.axis;
      var max = axis._domain[1],
          min = axis._domain[0],
          originMin = axis._firstCalcDomain ? axis._firstCalcDomain[2] : min,
          originMax = axis._firstCalcDomain ? axis._firstCalcDomain[3] : max;
      var greaterThanZeroTicks = ticks.filter(function (tick) {
        //标准轴上所有大于等于0的刻度
        return tick >= 0;
      });
      var lessThanZeroTicks = ticks.filter(function (tick) {
        // 标准轴上所有小于等于0的刻度
        return tick <= 0;
      });
      calcRatio();
      calcNewMinMax(); // 这里保存下第一次更新值轴的domain使之与标准轴0值对齐之后的domain，
      // 在缩放时，从zoomDomain中计算domain的时候会用上

      if (!axis._firstCalcDomain) {
        axis._firstCalcDomain = [min, max, originMin, originMax];
      } // 这一步重新计算出一个比较好的domain、tickInterval


      axis._calculateNiceDomain(min, max, min, max);

      axis.scale.domain([min, max]).range(axis._getRange()); // 提取出重新计算domain的min和max的部分，要不然太长了

      function calcNewMinMax() {
        if (min === 0) {
          // 使用niceValue函数获取到一个比较符合人类阅读习惯的数值。
          max = _BaseUtils["default"].niceValue(originMax || max, greaterThanZeroTicks.length);
        } else if (max === 0) {
          /**
           * 现在max为0，将min赋值为一个小于0的数值，如果原先没有更新domain之前的min不为0的话，使用它就很好，
           * 但是如果为0的话，就需要重新计算一个符合人类阅读习惯的数值了。
           */
          min = _BaseUtils["default"].niceValue(originMin || min, lessThanZeroTicks.length);
        } else {
          //CHART-1995没有考虑originMax为零的情况，originMax为零时，用originMin计算multiple
          // 坐标轴原始min为0时，使用原始max进行缩放；
          // 坐标轴原始max为0时，使用原始min进行缩放；
          // 坐标轴原始min和原始max都不为0时，以占比较大的原始值为基准进行缩放
          // 保证缩放之后，区域不会减小
          var multiple = originMin === 0 || originMax !== 0 && originMin / originMax > min / max ? _BaseUtils["default"].niceValue(originMax / standardAxis._domain[1], greaterThanZeroTicks.length) : _BaseUtils["default"].niceValue(originMin / standardAxis._domain[0], lessThanZeroTicks.length);
          max = _BaseUtils["default"].accMul(standardAxis._domain[1], multiple);
          min = _BaseUtils["default"].accMul(standardAxis._domain[0], multiple);
        }
      }

      function calcRatio() {
        var innerZeroPos = axis.scale(0),
            // 当前值轴的0刻度与标准轴的0刻度在真实距离上的差值
        distance = innerZeroPos - zeroPos,
            minMaxRange = max - min,
            // 当前值轴在绘图区的范围
        visibleRange = axis._getRange(),
            changeDistance;

        visibleRange = Math.abs(visibleRange[0] - visibleRange[1]); // 计算出当前值轴要让0值与标准轴的0值对齐需要移动的距离

        changeDistance = distance * minMaxRange / visibleRange; // 太多的if，使用真值表来简化

        var sign = 1,
            Y,
            A = axis.vanchart.options.chartType !== _Constants["default"].BAR_CHART,
            B = self.vanchart.isInverted(),
            // 在options的reversed的值
        C = axis.options.reversed;
        Y = A && !B && C || B && !C || !A && !C;
        sign = Y ? sign : -sign; // 下面的注释是未简化之前的代码，还是别删除了，要不然下一个要看懂的话那就太难了。

        /*// 条形图的情况与柱形图、折线图正好相反
        if (axis.vanchart.options.chartType !== Constants.BAR_CHART){
            if( (self.vanchart.isInverted() && !axis.options.reversed)
                || (!self.vanchart.isInverted() && axis.options.reversed)) {
                sign = 1;
            }else {
                sign = -1;
            }
        }else {
            if( (self.vanchart.isInverted() && axis.options.reversed)
                || (!self.vanchart.isInverted() && axis.options.reversed) ) {
                sign = -1;
            }else {
                sign = 1;
            }
        }
        */

        max = _BaseUtils["default"].accAdd(max, changeDistance * sign);
        min = _BaseUtils["default"].accAdd(min, changeDistance * sign);
        /**
         * CHART-1344
         * 上一步的操作在绝大多数的情况下会导致原先的图表超出了图表可视区，
         * 所以下一步的操作就是保证当前值轴能够显示数据点的最高点或者最低点。有的时候不能两者兼顾，
         * 比如标准轴设定了min>=0,那么当前值轴0以下的部分就不能显示了，但是这个时候可以显示所有大于0的数据点。
         *
         */

        Math.abs(min - 0) < 1e-6 && (min = 0);
        Math.abs(max - 0) < 1e-6 && (max = 0);
      }
    });
    return axisList;
  },

  /**
   * 将值轴分类，分为有自定义的，未自定义的以及没有数据挂载的三个类别，
   * 将每一个值轴分类的同时将它们各自的下标也记录下来，最后处理完0值对齐需要将它们重新组合，
   * 新的组合值轴数组要与原来的值轴数组的排列顺序一致
   * @param axisList
   * @returns {{preset: Array, nonPreset: Array, nonSeries: Array}}
   * @private
   */
  _classifyAxis: function (axisList) {
    // 将值轴分成三个部分——有自定义的：preset，未自定义的——nonPreset，没有数据挂载的——nonSeries
    var preset = [],
        nonPreset = [],
        nonSeries = [],
        self = this; // 各种for个if，要缩进不少代码，看起来很困难，就把它们提取到各个函数中去了

    classifyAxisWhileRefresh(axisList);

    if (!preset.length && !nonPreset.length) {
      nonSeries = [];
      classifyAxisWhileInitial(axisList);
    }

    return {
      preset: preset,
      nonPreset: nonPreset,
      nonSeries: nonSeries
    };
    /**
     * 现在只是刷新图表，而不是重绘整个图表的各个组件的时候，这个时候0值对齐的标准轴不会改变，
     * 所以选取classifyAxisWhileInitial函数中得到的标准轴即可。
     * @param axisList
     */

    function classifyAxisWhileRefresh(axisList) {
      var axisObj;

      for (var i = 0, len = axisList.length; i < len; i++) {
        axisObj = {
          axis: axisList[i],
          index: i
        };

        if (axisList[i].alignAxisId) {
          if (/^stand/.test(axisList[i].alignAxisId)) {
            preset.push(axisObj);
          } else {
            nonPreset.push(axisObj);
          }
        } else {
          nonSeries.push(axisObj);
        }
      }
    }
    /**
     * 第一次绘制图表，还没有选取过标准轴，在这里对值轴进行分类。
     * @param axisList
     */


    function classifyAxisWhileInitial(axisList) {
      var onZeroAttr = self.options.onZero,
          axisIndex = onZeroAttr === true ? 0 : onZeroAttr; // options中有onZero: number这样的设置的时候

      onZeroAttr !== true && axisList.forEach(function (axis, i) {
        var obj = {
          axis: axis,
          index: i
        };

        if (i === axisIndex) {
          preset.unshift(obj);
          return;
        }

        if (axis.series.length === 0) {
          nonSeries.push(obj);
        } else {
          nonPreset.push(obj);
        }
      }); // 没有指定需要与哪一个值轴0值对齐的时候

      onZeroAttr === true && axisList.forEach(function (axis, i) {
        var obj = {
          axis: axis,
          index: i
        };
        var options = axis.options;

        if (axis.series.length === 0) {
          nonSeries.push(obj);
        } else if ((0, _CoreUtils.hasDefined)(options.tickInterval) || (0, _CoreUtils.hasDefined)(options.min) || (0, _CoreUtils.hasDefined)(options.max) || (0, _CoreUtils.hasDefined)(options.log)) {
          preset.push(obj);
        } else {
          nonPreset.push(obj);
        }
      }); // 如果所有的值轴中都没有进行自定义，也就时preset.length等于0的时候，
      // 需要从nonPreset里面的之后中寻找一个最适合的值轴作为标准轴。

      if (!preset.length) {
        nonPreset = getStandardAxis(nonPreset);
      }
    } // 根据domain的范围来从axisArray中寻找最合适的之后作为标准轴，
    // 优先顺序是：(min < 0 && max > 0) > (max <= 0, domain小于等于0) > (min >= 0，domain大于等于0)，
    // 如果需要从同一个优先级中筛选出最合适的那一个值轴，就选择tick刻度数量最少的那一个。


    function getStandardAxis(axisArray) {
      if (!axisArray.length) {
        return axisArray;
      } // 根据值轴的domain来划分，如果domain是min<0 && max > 0，则axis属于both，
      // 推算下去，domain的min>=0的时候axis属于pos……


      var both = [],
          pos = [],
          nag = [];

      for (var i = 0, len = axisArray.length; i < len; i++) {
        if (Math.abs(0 - axisArray[i].axis._domain[0]) < 1e-6) {
          pos.push(axisArray[i]);
        } else if (Math.abs(0 - axisArray[i].axis._domain[1]) < 1e-6) {
          nag.push(axisArray[i]);
        } else {
          both.push(axisArray[i]);
        }
      }

      both.sort(sortByTicksNum);
      pos.sort(sortByTicksNum);
      nag.sort(sortByTicksNum);
      return both.concat(nag.concat(pos));

      function sortByTicksNum(a, b) {
        return a.axis.tickData.length - b.axis.tickData.length;
      }
    }
  },

  /**
   * 将已经分类的值轴按照原来的排列顺序重新排列
   * @param classifiedAxis
   * @returns {Array}
   * @private
   */
  _reassembleAxis: function (classifiedAxis) {
    var axisList = classifiedAxis.nonPreset.concat(classifiedAxis.preset.concat(classifiedAxis.nonSeries)); // 按照原来的值轴数组排列顺序重新排序一下

    axisList.sort(function (a, b) {
      return a.index - b.index;
    });
    return axisList.map(function (item) {
      return item.axis;
    });
  },

  /**
   * 具体处理多个值轴0值对齐
   * @param relyOn
   * @private
   */
  _dealOnZeroDetail: function (relyOn) {
    var axisList = this.vanchart.getComponent(relyOn)._axisList; // 0值对齐只能是值轴，分类轴不行


    if (axisList[0].options.type !== 'value') {
      return;
    }

    var classifiedAxis = this._classifyAxis(axisList); // 如果有多个自定义的值轴，那么所有未自定义的值轴与第一个自定义的值轴0值对齐
    // 所以这里将第一个自定义的值轴放到未自定义的值轴数组的首位，在后面的处理中将以它作为标准轴


    if (classifiedAxis.preset.length > 0) {
      var standard = this.findStandardAxisProp(classifiedAxis.preset);

      if ((0, _CoreUtils.hasDefined)(standard)) {
        classifiedAxis.preset.splice(standard.index, 1);
        classifiedAxis.nonPreset.unshift(standard.axisProp);
      }
    } // 现在开始从nonPreset中筛选出与nonPreset[0]有着相同reverse属性的值轴


    classifiedAxis.nonPreset = classifiedAxis.nonPreset.filter(function (obj) {
      var thisReverse = !!obj.axis.options.reversed,
          standardReverse = !!classifiedAxis.nonPreset[0].axis.options.reversed;

      if (thisReverse !== standardReverse) {
        // reversed属性不同则不要进行0值对齐的操作
        classifiedAxis.preset.push(obj);
        return false;
      }

      return true;
    }); // 现在nonPreset数组里面存储的值轴都是0值对齐的值轴，只让它们显示一条gridLine就可以了
    // 要不然有可能绘制出重影的线儿
    // classifiedAxis.nonPreset.forEach(function (obj, index) {
    //     var thisOpt = obj.axis.options,
    //         standardAxisOpt = classifiedAxis.nonPreset[0].axis.options;
    //
    //     if (thisOpt.gridLineWidth !== 0 && index !== 0) {
    //         standardAxisOpt.gridLineWidth = standardAxisOpt.gridLineWidth || 1;
    //         standardAxisOpt.gridLineColor = standardAxisOpt.gridLineColor || thisOpt.gridLineColor;
    //         thisOpt.gridLineWidth = 0;
    //     }
    // });
    // 处理0所有未自定义的值轴0值对齐

    classifiedAxis.nonPreset = this._alignByZeroValue(classifiedAxis.nonPreset);
    axisList = this._reassembleAxis(classifiedAxis); // 对值轴们重新赋值

    this.vanchart.getComponent(relyOn)._axisList = axisList; // 重新计算一下每一个轴的位置、label的大小之类的信息

    _VanChartLayout["default"].reLayoutPlotBoundsAfterDealOnZero(this.vanchart);
  },
  dealOnZero: function () {
    var cfg = this.options;
    var relyOn = this.componentType === _component.ComponentCst.X_AXIS_COMPONENT ? _component.ComponentCst.Y_AXIS_COMPONENT : _component.ComponentCst.X_AXIS_COMPONENT;
    cfg.onZero && this._dealOnZeroDetail(relyOn);
  },
  findStandardAxisProp: function (presetAxis) {
    if (presetAxis && presetAxis.length) {
      for (var i = 0, len = presetAxis.length; i < len; i++) {
        var axis = presetAxis[i].axis; // 从基准轴数组中找到第一个非对数的坐标轴和在基准轴数组中的序号

        if ((0, _CoreUtils.hasNotDefined)(axis.options.log)) {
          return {
            axisProp: presetAxis[i],
            index: i
          };
        }
      }
    }
  },

  /**
   * 原本这个函数里面的内容是在dealOnZero函数里面的，但是由于0值对齐为了适应多分类轴的情况，
   * 把它们提出来作为一个单独的函数，减少重复执行的代码。
   * 该函数的作用是更新当前Axis的bounds属性
   * @returns {boolean}
   */
  updateAxisBounds: function () {
    var cfg = this.options;

    if (!cfg.onZero) {
      return false;
    }

    var relyOn = this.getStandardAxis();
    var isFromZero = relyOn && (0, _AxisUtils.isFromZeroAxis)(relyOn);
    var pos = relyOn.getZeroPos();
    var plotBounds = this.vanchart.bounds;
    var x, y, width, height, exceed;

    if (this.isHorizontal()) {
      x = plotBounds.x;
      y = pos + plotBounds.y - (this.getPosition() === _Constants["default"].TOP ? this.bounds.height : 0);
      width = plotBounds.width;
      height = this.bounds.height;
      exceed = y + height > plotBounds.y + plotBounds.height;

      if (!isFromZero && exceed) {
        height = plotBounds.y + plotBounds.height - y;
      }
    } else {
      x = pos + plotBounds.x - (this.getPosition() === _Constants["default"].LEFT ? this.bounds.width : 0);
      y = plotBounds.y;
      width = this.bounds.width;
      height = plotBounds.height;
      exceed = x + width > plotBounds.x + plotBounds.width;

      if (!isFromZero && exceed) {
        width = plotBounds.x + plotBounds.width - x;
      }
    }

    height < 0 && (height = 0);
    width < 0 && (width = 0);
    this.bounds = {
      x: x,
      y: y,
      width: width,
      height: height
    };
  },
  //坐标轴的标签占据的大小
  _getTickLabelLength: function (tickData) {
    var axisOption = this.options;
    var tickLength = 0,
        maxLabelLength = 0,
        isHorizontal = this.isHorizontal();

    if (axisOption.showLabel) {
      tickLength = isNaN(+axisOption.tickPadding) ? LABEL_LINE_GAP_FUN() : axisOption.tickPadding;
    }

    if (axisOption.enableTick) {
      tickLength += isNaN(+axisOption.tickLength) ? TICK_LENGTH : axisOption.tickLength;
    }

    if (tickData) {
      tickData.forEach(function (t) {
        var labelDim = t.tickDim;
        maxLabelLength = Math.max(maxLabelLength, isHorizontal ? labelDim.height : labelDim.width);
      });
    } else {
      // dim calc duplicated
      // CHART-1454 0值对齐之后的坐标轴的标签显示不全，
      // 是因为_getTickValues函数获取到的是原来的坐标轴的标签，而不是0值对齐之后的标签
      var ticks = this.alignAxisId ? this._getTickValuesAlignByAxis() : this._getTickValues();

      for (var i = 0, len = ticks.length; i < len; i++) {
        var testDim = this._getTickDim(this._getTickContent(ticks[i], axisOption.formatter));

        maxLabelLength = Math.max(isHorizontal ? testDim.height : testDim.width, maxLabelLength);
      }
    }

    var tickLabelPaddingBottom = LABEL_LINE_GAP_FUN();
    return tickLength + (axisOption.showLabel ? maxLabelLength + tickLabelPaddingBottom : 0);
  },
  _getTickDim: function (tickContent) {
    // @CHART-10873: 考虑竖直得文字, 需要更改style['writing-mode'], 这里使用统一得方法计算
    return this._calcTickLabelDim(tickContent).labelDim;
  },
  //不考虑step和自动间隔
  _updateOriginTickData: function () {
    var labels = this.alignAxisId ? this._getTickValuesAlignByAxis() : this._getTickValues(),
        axis = this;

    this._calculateLabelRotation(labels);

    this.tickData = [];

    for (var i = 0, len = labels.length; i < len; i++) {
      var tickValue = labels[i];
      this.tickData.push(axis._calculateSingleTickData(tickValue, tickValue));
    }

    this._setPeriod();
  },

  /**
   * 设置初始周期,这边一旦设置，后期的缩放等其他操作，不会对其修改
   * CHART-15773 删除了如果有initperiod就返回的代码，因为监控刷新坐标轴可能变化，导致period不对应
   * @private
   */
  _setPeriod: function () {
    var tickData = this.tickData;

    if (this.isMultiCateAxis && this.isMultiCateAxis()) {
      this._initPeriod = tickData.length > 1 && tickData[0].length > 1 ? [tickData[0][0].tickValue, tickData[0][1].tickValue] : 0;
    } else {
      this._initPeriod = tickData.length > 1 ? [tickData[0].tickValue, tickData[1].tickValue] : 0;
    }
  },

  /**
   * 获取周期的大小(px)
   */
  getPeriodSize: function () {
    var scale = this.scale;
    var period = this._initPeriod;

    if (_BaseUtils["default"].isArray(period)) {
      return Math.abs(scale(period[0]) - scale(period[1]));
    } else {
      // 初始只有一个标签的只可能为rangeBand
      return scale.rangeBand();
    }
  },

  /**
   * 计算标签旋转角度
   * @param  {[type]} labels [description]
   * @return {[type]}        [description]
   */
  _calculateLabelRotation: function (labels) {
    var option = this.options,
        formatter = option.formatter;

    if (!isNaN(option.labelRotation)) {
      this.labelRotation = option.labelRotation;
    } else if (option.autoRotate) {
      this.labelRotation = this.getLabelAutoRotation(labels, option, formatter);
    } else {
      this.labelRotation = 0;
    }
  },

  /**
   * 计算单个tickData
   * @return {[type]} [description]
   */
  _calculateSingleTickData: function (value, content, option) {
    option = option || {};
    var axisOption = this.options,
        formatter = axisOption.formatter,
        rectDim,
        labelDim,
        labelRotation;

    var tickContent = this._getTickContent(content, formatter);

    var computed = this._calcTickLabelDim(tickContent);

    rectDim = computed.rectDim;
    labelDim = computed.labelDim;
    tickContent = computed.tickContent;
    labelRotation = computed.labelRotation;
    return _QueryUtils["default"].merge({
      tickValue: value,
      tickContent: tickContent,
      tickDim: labelDim,
      tickRectDim: rectDim,
      labelRotation: labelRotation
    }, option);
  },

  /**
   * 计算标签实际占用尺寸, 需要考虑旋转角度(90度时文字竖直排版), 以及html显示
   * @param tickContent formatted tick content
   * @returns {{labelDim: *, rectDim: *}}
   * @private
   */
  _calcTickLabelDim: function (tickContent) {
    var axisOption = this.options,
        useHtml = axisOption.useHtml;
    var style = axisOption.labelStyle || {};

    var tbStyle = _BaseUtils["default"].extend({
      'writingMode': 'tb-rl',
      'writing-mode': 'tb-rl',
      '-webkit-writing-mode': 'vertical-rl'
    }, style);

    if (this.type === _component.ComponentCst.CATEGORY_AXIS_COMPONENT && tickContent) {
      tickContent = (tickContent + '').trim();
    }

    var rectDim,
        labelDim,
        tmpStyle = style; // @CHART-12643：坐标轴标签旋转统一从options上获取

    var labelRotation = axisOption.labelRotation;

    if (Math.abs(labelRotation) === 90 && _BaseUtils["default"].hasChn(tickContent)) {
      labelRotation = 360; // as a log

      tmpStyle = tbStyle;
    }

    rectDim = _BaseUtils["default"].getTextDimension(tickContent, tmpStyle, useHtml);
    labelDim = _BaseUtils["default"].getTextDimRotated(rectDim, labelRotation);

    if (useHtml) {
      labelDim.width = isNaN(parseFloat(axisOption.labelWidth)) ? labelDim.width : parseFloat(axisOption.labelWidth);
      labelDim.height = isNaN(parseFloat(axisOption.labelHeight)) ? labelDim.height : parseFloat(axisOption.labelHeight);
    }

    return {
      rectDim: rectDim,
      labelDim: labelDim,
      tickContent: tickContent,
      labelRotation: labelRotation
    };
  },
  _isBaseAxis: function () {
    if (this.series.length) {
      return this.componentType === this.series[0].getBaseAxisType();
    }

    return false;
  },
  getLabelAutoRotation: function () {
    return 0;
  },
  _getAxisTitleLength: function () {
    var title = this.options.title;

    if (!title || (0, _CoreUtils.isEmpty)(title.text)) {
      return 0;
    }

    var rectDim, dim;
    this.titleRotation = title.rotation;

    if (_BaseUtils["default"].hasChn(title.text) && Math.abs(title.rotation) === 90) {
      this.titleRotation = 360;
      title.style = _BaseUtils["default"].extend({
        'writingMode': 'tb-rl',
        'writing-mode': 'tb-rl',
        '-webkit-writing-mode': 'vertical-rl'
      }, title.style);
    }

    rectDim = _BaseUtils["default"].getTextDimension(title.text, title.style, title.useHtml);
    dim = _BaseUtils["default"].getTextDimRotated(rectDim, this.titleRotation);
    this.titleRectDim = rectDim;
    this.titleDim = dim;
    return this.isHorizontal() ? dim.height : dim.width;
  },
  //坐标轴占据的空间
  getAxisTitleBounds: function () {
    var bounds = this.bounds;
    var tickLength = this.tickLabelLength + TITLE_LABEL_GAP_FUN();
    var labelLength = this.labelLength;
    var position = this.getPosition();
    var x = bounds.x;
    var y = bounds.y;
    var width = bounds.width;
    var height = bounds.height;

    switch (position) {
      case _Constants["default"].LEFT:
        x += width - tickLength - labelLength; // 限制坐标轴尺寸时，标题与标签不应该重叠

        width -= tickLength;
        break;

      case _Constants["default"].BOTTOM:
        y += tickLength;
        height -= tickLength;
        break;

      case _Constants["default"].RIGHT:
        x += tickLength;
        width -= tickLength;
        break;

      case _Constants["default"].TOP:
        y += height - tickLength - labelLength; // 同Left时x计算

        height -= tickLength;
        break;
    }

    return {
      x: x,
      y: y,
      width: Math.max(width, 0),
      height: Math.max(height, 0)
    };
  },
  getTickLength: function () {
    var range = this.scale.range();
    return Math.abs(range[0] - range[1]) / Math.max(this.tickData.length, 1);
  },
  // fixme 100行的function。。有空整理下
  // 这个调整是有条件的，没有缩放，没有自定义的最大最小值
  adjustDomain4Radius: function () {
    if (this.type === _component.ComponentCst.VALUE_AXIS_COMPONENT || this.type === _component.ComponentCst.DATE_AXIS_COMPONENT) {
      var domain = this._domain,
          isDate = this.type === _component.ComponentCst.DATE_AXIS_COMPONENT;

      var range = this._getRange();

      var minMax = this._dataDomain;
      var originLabelWidth = this.tickLabelLength;

      if (isDate) {
        domain = [_BaseUtils["default"].int2date(domain[0]), _BaseUtils["default"].int2date(domain[1])];
      } //要考虑对数坐标轴的情况


      var scale = this.options.log ? _Scale["default"].log().base(this.options.log) : _Scale["default"].linear();
      scale.domain(domain).range(range);

      var axis = this,
          isBaseAxis = this._isBaseAxis();

      var key = this.componentType === _component.ComponentCst.X_AXIS_COMPONENT ? 'x' : 'y';
      var downBound = Number.MAX_VALUE,
          upBound = -Number.MAX_VALUE;
      this.series.map(function (item) {
        if (!item.visible) {
          return;
        }

        if (item.type === _Constants["default"].BUBBLE_CHART || item.type === _Constants["default"].SCATTER_CHART) {
          item.points.map(function (point) {
            var pos = scale(axis.getAxisValue(point[key], point));

            if (point.visible && !point.isNull && !isNaN(pos)) {
              var radius = _BaseUtils["default"].pick(point.radius, point.options.marker && point.options.marker.radius);

              downBound = Math.min(downBound, pos - radius);
              upBound = Math.max(upBound, pos + radius);
            }
          });
        }

        if (item.type === _Constants["default"].COLUMN_CHART || item.type === _Constants["default"].BAR_CHART || item.type === _Constants["default"].BOX_CHART || item.type === _Constants["default"].LINE_CHART || item.type === _Constants["default"].AREA_CHART) {
          var points = item.points;

          if (!points.length) {
            return;
          }

          var range1 = scale(minMax[0]);
          var range2 = scale(minMax[1]);
          var left = Math.min(range1, range2);
          var right = Math.max(range1, range2);
          var space;

          if (item.type === _Constants["default"].COLUMN_CHART || item.type === _Constants["default"].BAR_CHART || item.type === _Constants["default"].BOX_CHART) {
            // bar/column/box
            space = isBaseAxis ? item.getSeriesOffsetAndWidth().width / 2 : 0;
          } else if (points[0]) {
            // line/area
            space = points[0].options.marker && points[0].options.marker.radius || item.options.lineWidth;
          }

          if (!isNaN(left)) {
            downBound = Math.min(downBound, left - space);
          }

          if (!isNaN(right)) {
            upBound = Math.max(upBound, right + space);
          }
        }
      });

      if (downBound === Number.MAX_VALUE || upBound === -Number.MAX_VALUE) {
        return;
      }

      var b1 = scale.invert(downBound),
          b2 = scale.invert(upBound);

      if (isDate) {
        b1 = _BaseUtils["default"].date2int(b1);
        b2 = _BaseUtils["default"].date2int(b2);
      }

      if ((0, _AxisUtils.isInDomainValue)(this._domain, b1) && (0, _AxisUtils.isInDomainValue)(this._domain, b2)) {
        return;
      }

      this.calculateDomainFromData([Math.min(Math.min(b1, b2), minMax[0]), Math.max(Math.max(b1, b2), minMax[1])]);

      var labelWidth = this._getTickLabelLength();

      if (labelWidth > originLabelWidth) {
        return true;
      }
    }
  },
  // 为了搞缩放、平移，axis采取了不同的策略：
  // 分类轴是离散的，domain的变化只能一个一个category变，所以要变动range大小；tick是确定的。
  // 值轴是连续的，可以看作是domain一直在变，range保持可视区域大小；并且要重新算可视区域内tick，只能变domain。
  // For pinch zoom, get the whole range even exceed the visible area.
  // Used by category axis `_getPlotRange`.
  getWholeRange: function () {
    var plotBounds = this.vanchart.getPlotContentBounds();
    var left = plotBounds.x,
        right = plotBounds.x + plotBounds.width,
        top = plotBounds.y,
        bottom = plotBounds.y + plotBounds.height;

    if (this.isHorizontal()) {
      return this.isAxisReversed() ? [right, left] : [left, right];
    } else {
      return this.isAxisReversed() ? [top, bottom] : [bottom, top];
    }
  },
  _getRange: function () {
    return this._getPlotRange();
  },
  // It's visible range.
  // Used by value axis `_getPlotRange`.
  _getPlotRange: function () {
    var plotBounds = this.vanchart.bounds;
    var left = 0,
        right = plotBounds.width,
        top = 0,
        bottom = plotBounds.height;

    if (this.isHorizontal()) {
      return this.isAxisReversed() ? [right, left] : [left, right];
    } else {
      return this.isAxisReversed() ? [top, bottom] : [bottom, top];
    }
  },
  isPlotRangeWithMarker: function () {
    return this.vanchart.seriesOfType(_Constants["default"].AREA_CHART).length > 0 && this.options.type === _component.ComponentCst.CATEGORY_AXIS_COMPONENT;
  },
  getPlotRangePadding: function () {
    return this.isPlotRangeWithMarker() ? this._getMarkerRadius(this.vanchart, _Constants["default"].AREA_CHART) : 0;
  },
  _getMarkerRadius: function (vanchart, type) {
    var plotOptions = vanchart.options.plotOptions,
        _options = plotOptions[type];
    var plotOptionsMarker = _options && _options.marker || plotOptions.marker;
    var symbol = plotOptionsMarker.symbol;

    if (_BaseUtils["default"].isImageMarker(symbol) && plotOptionsMarker.width) {
      return plotOptionsMarker.width / 2;
    }

    if (symbol === _Constants["default"].SYMBOL_AUTO) {
      return _Constants["default"].MARKER_RADIUS;
    }

    return symbol && plotOptionsMarker.radius || 0;
  },
  _getPlotBands: function () {
    var plotBands = this.options.plotBands;
    var scale = this.scale;
    var isRangeBand = !!(scale.rangeBand && scale.rangeBand());
    var multiCategory = this.isMultiCateAxis();

    if (typeof plotBands === 'string') {
      var color = plotBands;
      plotBands = [];

      var labels = this._getTickValuesWithEndValue();

      labels = multiCategory ? labels[0].map(function (label) {
        return label.tickValue;
      }) : labels;
      var endIndex = isRangeBand ? -1 : 0;

      for (var index = labels.length - 1; index > endIndex; index -= 2) {
        plotBands.push({
          color: color,
          from: isRangeBand ? labels[index] : labels[index - 1],
          to: labels[index]
        });
      }
    } else {
      plotBands = plotBands || [];
      var result = [];

      for (var i = 0, count = plotBands.length; i < count; i++) {
        var t_bands = plotBands[i];

        if (multiCategory) {
          t_bands.from = _BaseUtils["default"].encodeCategoryArray(t_bands.from);
          t_bands.to = _BaseUtils["default"].encodeCategoryArray(t_bands.to);
        }

        if ((0, _CoreUtils.hasDefined)(t_bands.from) && (0, _CoreUtils.hasDefined)(t_bands.to)) {
          result.push(t_bands);
        }
      }

      plotBands = result;
    }

    return plotBands;
  },
  _getTickValuesWithEndValue: function () {
    var result = this._getTickValues();

    var max = this._domain[1],
        isDate = this.type === _component.ComponentCst.DATE_AXIS_COMPONENT;

    if (result.length) {
      var maxInList = result[result.length - 1];

      if (isDate) {
        if (_BaseUtils["default"].date2int(maxInList) < max) {
          result.push(_BaseUtils["default"].int2date(max));
        }
      } else {
        if (maxInList < max) {
          result.push(max);
        }
      }
    }

    return result;
  },
  //画的时候计算自定义标签间隔等
  getTickData: function () {
    return this.tickData;
  },
  // 获取次要刻度数据
  getMinorTickData: function (ticksNum) {
    var minorTicksNum = ticksNum || 5;
    var mainTickData = this.getTickData();
    var minorTickData = [],
        cfg = this.options,
        interval = this._step;

    if (this.options.enableMinorTick && this.tickData.length) {
      var i,
          count = mainTickData.length,
          isDate,
          value; //分类轴

      if (this.isCategory()) {
        var minorTickLength = Math.round(this.getTickLength() / minorTicksNum);

        var _mainTickData = mainTickData.sort(function (a, b) {
          return a.tickPos - b.tickPos;
        });

        var endIndex = this.isRangePoints ? count - 1 : count;

        for (i = 0; i < endIndex; i++) {
          var startPos = _mainTickData[i].tickPos;

          for (var j = 1; j < 5; j++) {
            minorTickData.push(startPos + minorTickLength * j);
          }
        }
      } else {
        var minorInterval = cfg.minorTickInterval ? cfg.minorTickInterval : interval / minorTicksNum;

        for (i = 0; i < count - 1; i++) {
          var start = mainTickData[i].tickValue;
          var end = mainTickData[i + 1].tickValue;
          isDate = start instanceof Date && end instanceof Date;
          start = isDate ? _BaseUtils["default"].date2int(start) : start;
          end = isDate ? _BaseUtils["default"].date2int(end) : end;

          for (value = _BaseUtils["default"].accAdd(start, minorInterval); value < end; value = _BaseUtils["default"].accAdd(value, minorInterval)) {
            minorTickData.push(isDate ? _BaseUtils["default"].int2date(value) : value);
          }
        }

        var endValue = mainTickData[count - 1].tickValue;
        var maxValue = this.scale.domain()[1];
        isDate = endValue instanceof Date && maxValue instanceof Date;
        endValue = isDate ? _BaseUtils["default"].date2int(endValue) : endValue;
        maxValue = isDate ? _BaseUtils["default"].date2int(maxValue) : maxValue;

        if (endValue < maxValue) {
          for (value = endValue + minorInterval; value <= maxValue; value += minorInterval) {
            minorTickData.push(isDate ? _BaseUtils["default"].int2date(value) : value);
          }
        }

        var startValue = mainTickData[0].tickValue;
        var minValue = this.scale.domain()[0];
        isDate = startValue instanceof Date && minValue instanceof Date;
        startValue = isDate ? _BaseUtils["default"].date2int(startValue) : startValue;
        minValue = isDate ? _BaseUtils["default"].date2int(minValue) : minValue;

        if (startValue > minValue) {
          for (value = startValue - minorInterval; value >= minValue; value -= minorInterval) {
            minorTickData.push(isDate ? _BaseUtils["default"].int2date(value) : value);
          }
        }
      }
    }

    return minorTickData;
  },
  getMaxTickWidth: function () {
    var maxWidth = 0; // CHART-1141
    // options中设置了不显示tickLabel，但是仍然会占位，
    // 这里判断一下，如果不显示tickLabel的话，直接返回0吧。

    if (!this.options.showLabel) {
      return maxWidth;
    }

    this.tickData.forEach(function (data) {
      maxWidth = Math.max(maxWidth, data.tickDim.width);
    });
    return maxWidth;
  },
  getTickHeight: function () {
    if (this.options.labelStyle && this.options.showLabel) {
      return (0, _EnvUtils.getTextHeight)(this.options.labelStyle);
    }

    return 0;
  },
  _calculateTickPosAndStep: function () {
    var axisOption = this.options,
        scale = this.scale,
        tickInterval = this.getTickLength();
    var det = scale.rangeBand ? scale.rangeBand() / 2 : 0;
    var tickData = this.getTickData(),
        index;
    tickData.forEach(function (t) {
      t.tickPos = scale(t.tickValue);
      t.tickLabelPos = t.tickPos + det;
    });

    if (!axisOption.showLabel) {
      tickData.forEach(function (t) {
        t.tickContent = '';
      });
    } else if (axisOption.step) {
      index = 0;
      tickData.forEach(function (t) {
        if (index++ % axisOption.step) {
          t.tickContent = '';
        }
      });
    } else {
      var isHorizontal = this.isHorizontal(),
          testStep = 1,
          longestStep = 1; // label rotated [15-90) can as long as it can
      // otherwise check the dim

      var labelRotation = Math.abs(Math.abs(this.labelRotation) - (isHorizontal ? 0 : 90)),
          isRotated = labelRotation >= 15 && labelRotation !== 90,
          labelRadian;
      labelRadian = _BaseUtils["default"].toRadian(labelRotation);
      var lastTickPos,
          lastH = -1,
          gap,
          l,
          h,
          sin = Math.sin(labelRadian);
      tickData.forEach(function (t) {
        if (t.tickContent === '') {
          return;
        }

        if (isRotated) {
          h = t.tickRectDim.height;
          gap = Math.abs(t.tickPos - lastTickPos);
          l = (h + lastH) / 2;

          if (l < gap * sin || lastH === -1) {
            testStep = 1;
            lastTickPos = t.tickPos;
            lastH = h;
          } else {
            testStep++;
            longestStep = Math.max(longestStep, testStep);
          }
        } else {
          var testLength = isHorizontal ? t.tickDim.width : t.tickDim.height;

          if (tickInterval) {
            longestStep = Math.max(longestStep, Math.ceil(testLength / tickInterval));
          }
        }
      });
      index = 0;
      tickData.forEach(function (t) {
        if (index++ % longestStep) {
          t.tickContent = '';
        }
      });
    }
  },
  _getAxisOriginPoint: function () {
    var axisBounds = this.bounds;
    var position = this.getPosition();
    var x, y;

    switch (position) {
      case _Constants["default"].TOP:
        x = axisBounds.x;
        y = axisBounds.y + axisBounds.height;
        break;

      case _Constants["default"].BOTTOM:
        x = axisBounds.x;
        y = axisBounds.y;
        break;

      case _Constants["default"].LEFT:
        x = axisBounds.x + axisBounds.width;
        y = axisBounds.y;
        break;

      case _Constants["default"].RIGHT:
        x = axisBounds.x;
        y = axisBounds.y;
        break;
    }

    return {
      x: x,
      y: y
    };
  },
  getPosition: function () {
    var defaultPosition = this.componentType === _component.ComponentCst.X_AXIS_COMPONENT ? 'bottom' : 'left';
    var position = this.options.position || defaultPosition;

    if (this.vanchart.isInverted()) {
      switch (position) {
        case _Constants["default"].TOP:
          return _Constants["default"].RIGHT;

        case _Constants["default"].RIGHT:
          return _Constants["default"].BOTTOM;

        case _Constants["default"].BOTTOM:
          return _Constants["default"].LEFT;

        case _Constants["default"].LEFT:
          return _Constants["default"].TOP;
      }
    } else {
      return position;
    }
  },
  isAxisReversed: function () {
    if (this.componentType === _component.ComponentCst.X_AXIS_COMPONENT && this.vanchart.isInverted()) {
      return !this.options.reversed;
    }

    return this.options.reversed;
  },
  isOnZero: function () {
    return this.options.onZero;
  },
  getLineWidth: function () {
    return this.options.lineWidth;
  },
  showArrow: function () {
    return this.options.showArrow;
  },
  getTitleAlign: function () {
    var title = this.options.title;

    if (!title) {
      return null;
    }

    var align = title.align || 'center';

    if (this.vanchart.isInverted()) {
      switch (align) {
        case _Constants["default"].TOP:
          return _Constants["default"].RIGHT;

        case _Constants["default"].RIGHT:
          return _Constants["default"].BOTTOM;

        case _Constants["default"].BOTTOM:
          return _Constants["default"].LEFT;

        case _Constants["default"].LEFT:
          return _Constants["default"].TOP;
      }
    }

    return align;
  },
  _calculateLogNiceDomain: function (minValue, maxValue, fixedMin, fixedMax) {
    var axisOption = this.options,
        logBase = axisOption.log;
    minValue = minValue >= 1 ? 1 : minValue;
    minValue = minValue <= 0 ? 1 : minValue;
    /**
     * CHART-1250
     * fixedMin在(0, 1)区间的时候会被保留下来，而fixedMax如果小于fixedMin的话，
     * 直接设置为undefined，计算domain的时候使用maxValue好了，因为maxValue一定是存在的，
     * 除非options的数据有问题。
     */
    //改正：大于等于1的保留

    fixedMin = fixedMin <= 0 ? 1 : fixedMin;
    fixedMax = fixedMax <= fixedMin ? undefined : fixedMax;
    minValue = _BaseUtils["default"].pick(fixedMin, minValue);
    maxValue = _BaseUtils["default"].pick(fixedMax, maxValue);
    minValue = Math.pow(logBase, Math.floor(_BaseUtils["default"].log(logBase, minValue)));
    maxValue = Math.pow(logBase, Math.ceil(_BaseUtils["default"].log(logBase, maxValue)));
    this._domain = [minValue, maxValue];
    this._tickStart = minValue;
    this._step = (0, _AxisUtils.getLogValidInterval)(minValue, maxValue, logBase, axisOption.tickInterval);
  },
  _calculatePercentValueDomain: function (minValue, maxValue, fixedMin, fixedMax) {
    var axisOption = this.options,
        min = _BaseUtils["default"].pick(fixedMin, 0),
        max = _BaseUtils["default"].pick(fixedMax, 1);

    var interval = (0, _AxisUtils.getPercentValidInterval)(min, max, axisOption.tickInterval);
    this._domain = [min, max];

    if (this.vanchart.isMobileFlow()) {
      this._tickStart = 0;
      this._step = interval;
    } else {
      this._tickStart = min;
      this._step = interval;
    }
  },
  //普通的值轴
  _calculateValueNiceDomain: function (minValue, maxValue, fixedMin, fixedMax) {
    // CHART-1382
    // 仪表盘的数据如果没有自定义并且都是正数的话，fromZero也应该为true，
    // 但是gaugeAxis.isBaseAxis()函数返回的是true，结果就GG了
    var fromZero = this.type === _component.ComponentCst.VALUE_AXIS_COMPONENT && !this._isBaseAxis() || this.componentType === 'gaugeAxis';
    var axisOption = this.options; // 缓存一下

    var isDefinedMin = (0, _CoreUtils.hasDefined)(fixedMin),
        isDefinedMax = (0, _CoreUtils.hasDefined)(fixedMax);

    if (fromZero) {
      if (minValue > 0) {
        minValue = 0;
      } else if (maxValue < 0) {
        maxValue = 0;
      }
    }

    minValue = isDefinedMin ? fixedMin : minValue;
    maxValue = isDefinedMax ? fixedMax : maxValue; // if any exceeded min, adjust max to min + 100

    if (minValue >= maxValue) {
      maxValue = minValue + MIN_MAX_GAP * (this.type === _component.ComponentCst.DATE_AXIS_COMPONENT ? 1000 : 1);
    }

    var tickInterval = (0, _AxisUtils.getLinearValidInterval)({
      min: minValue,
      max: maxValue,
      interval: axisOption.tickInterval,
      count: this._getDefaultTickCount(),
      type: this.type
    });
    var domain = (0, _AxisUtils.getIntegerNiceDomain)(minValue, maxValue, tickInterval);
    minValue = isDefinedMin ? fixedMin : domain[0];
    maxValue = isDefinedMax ? fixedMax : domain[1];

    if (minValue >= maxValue) {
      maxValue = minValue + MIN_MAX_GAP * (this.type === _component.ComponentCst.DATE_AXIS_COMPONENT ? 1000 : 1);
    }

    var start = domain[0];

    if (isDefinedMin) {
      // ceil( (fixedMin - start) / tickInterval ) * tickInterval
      var diff = _BaseUtils["default"].accMul(Math.ceil(_BaseUtils["default"].accDiv(_BaseUtils["default"].accAdd(fixedMin, -start), tickInterval)), tickInterval);

      start = _BaseUtils["default"].accAdd(start, diff);
    }

    this._domain = [minValue, maxValue];
    this._tickStart = start;
    this._step = tickInterval; // CHART-1142
    // 值轴在开启趋势线之后同时也应该更新定义域domain

    this._extendDomainWithForecastRange(isDefinedMin, isDefinedMax);
  },

  /**
   * 开启趋势线之后，同时更新轴的定义域。
   * @param isDefinedMin
   * @param isDefinedMax
   * @returns {boolean}
   * @private
   */
  _extendDomainWithForecastRange: function (isDefinedMin, isDefinedMax) {
    var isBaseAxis = this._isBaseAxis(),
        isCategoryAxis = this.options.type === 'category',
        isSupportForecast = function (series) {
      // 如果检测到系列开启了趋势线，那么就会立即返回true
      return series.some(function (sery) {
        var trendLine = sery.options.trendLine;
        return trendLine && trendLine.period && trendLine.period.length === 2;
      });
    }(this.series);
    /**
     * 三种情况下不更新定义域
     * 1、不是基础轴，
     * 2、没有设置开启趋势线，
     * 3、不是值轴或者时间轴
     */


    if (!isBaseAxis || !isSupportForecast || isCategoryAxis) {
      return false;
    } // 只有在定义域中没有主动设置最大值和最小值的时候才去更新domain


    if (!isDefinedMin) {
      this._domain[0] = _BaseUtils["default"].accAdd(this._domain[0], _BaseUtils["default"].accMul(this.forecast[0], this._step));
      this._tickStart = _BaseUtils["default"].accAdd(this._tickStart, _BaseUtils["default"].accMul(this.forecast[0], this._step));
    }

    if (!isDefinedMax) {
      this._domain[1] = _BaseUtils["default"].accAdd(this._domain[1], _BaseUtils["default"].accMul(this.forecast[1], this._step));
    }
  },
  _getDefaultTickCount: function () {
    var options = this.vanchart.options;
    return options.chartType === _Constants["default"].RADAR_CHART ? RADAR_TICK_COUNT : this.series[0] && this.series[0].gaugeType === _Constants["default"].POINTER_GAUGE ? POINTER_GAUGE_COUNT : TICK_COUNT;
  },
  getIndexByPosition: function (pos) {
    var plotBounds = this.getPlotBounds();
    var scale = this.scale;
    var startX = scale(this.isAxisReversed() ? scale.domain()[scale.domain().length - 1] : scale.domain()[0]);
    var x;

    if (this.isHorizontal()) {
      x = pos[0] - plotBounds.x - startX;
    } else {
      x = pos[1] - plotBounds.y - startX;
    }

    var index;

    switch (this.type) {
      case _component.ComponentCst.DATE_AXIS_COMPONENT:
        index = _BaseUtils["default"].date2int(scale.invert(x));
        break;

      default:
        index = scale.invert(x);
    }

    index = Math.round(index);
    return index;
  },
  _valueInDomain: function () {
    return true;
  },
  render: function () {
    this.lastScale = this.scale && this.scale.copy();
    var vanchart = this.vanchart,
        renderer = vanchart.renderer;

    if (!this.axisGroup) {
      renderer.clip(this.clipAxisGroup = this.createComponentGroup(), vanchart.plotClip);
      this.axisGroup = this.createComponentGroup();
    } //clip的显示区域


    var b = this.bounds;
    var clipBounds = {
      x: b.x,
      y: b.y,
      width: b.width,
      height: b.height
    };

    if (this.isHorizontal()) {
      clipBounds.x = 0;
      clipBounds.width = vanchart.width;

      if (clipBounds.y < vanchart.bounds.y && this.options.onZero) {
        clipBounds.y = vanchart.bounds.y;
      }
    } else {
      clipBounds.y = 0;
      clipBounds.height = vanchart.height;

      if (clipBounds.x + clipBounds.width > vanchart.bounds.x + vanchart.bounds.width && this.options.onZero) {
        clipBounds.width = vanchart.bounds.x + vanchart.bounds.width - clipBounds.x;
      }

      clipBounds.width < 0 && (clipBounds.width = 0);
    }

    if (!this.axisGroupClip) {
      this.axisGroupClip = renderer.createClip(clipBounds);
      renderer.clip(this.axisGroup, this.axisGroupClip);
    } else {
      renderer.updateClip(this.axisGroupClip, clipBounds);
    } // 缓存下裁剪的位置


    this.clipBounds = clipBounds;

    if (!this.axisLineGroup) {
      this.axisLineGroup = renderer.group().addTo(vanchart.seriesGroup);
    } // 没有数据时，不绘制任何轴线


    if (this.series.length === 0) {
      this.remove();
      return;
    }

    this._drawPlotBands();

    this._drawGridLine();

    if (this.isNeedDrawAxis()) {
      this._drawTickLine();

      this._drawTickLabel();

      this._drawAxisLine();

      this._drawAxisTitle();

      this._drawPlotLines();
    } // CHART-1164
    // 图表设置了tootip shared===true,每当resize、重新绘制坐标轴的时候都检查一下resize之前图表是否还在显示系列高亮背景，
    // 是的话就在resize之后也绘制这个高亮背景。


    this._lastSharedPoints && this.drawHighlightBackground(this._lastSharedPoints);
  },
  isLog: function () {
    return this.options.log;
  },

  /**
   * CHART-1543
   * 判断是否需要绘制坐标轴，这个判断逻辑不是判断坐标轴是否在绘图区，
   * 而是判断在当前轴是否设置了0值对齐，如果它对齐的值轴设置了min>0或者max<0，那么就不显示坐标轴了。
   */
  isNeedDrawAxis: function () {
    var onZero = this.options.onZero,
        index = onZero === true ? 0 : onZero,
        relyOnAxis = this.componentType === _component.ComponentCst.X_AXIS_COMPONENT ? _component.ComponentCst.Y_AXIS_COMPONENT : _component.ComponentCst.X_AXIS_COMPONENT,
        // 默认是显示坐标轴的
    result = true; // 没有设置0值对齐，直接返回true

    if (!onZero) {
      return result;
    }

    relyOnAxis = this.vanchart[relyOnAxis](index); // 判断relyOnAxis的是否有min>0 或者 max < 0

    if (relyOnAxis.options.min > 0 || relyOnAxis.options.max < 0) {
      result = false;
    }

    return result;
  },
  getZeroPos: function () {
    switch (this.type) {
      case _component.ComponentCst.VALUE_AXIS_COMPONENT:
        return this.isLog() ? this.scale(1) : this.scale(0);

      case _component.ComponentCst.DATE_AXIS_COMPONENT:
        return this.scale(_BaseUtils["default"].int2date(0));

      case _component.ComponentCst.CATEGORY_AXIS_COMPONENT:
        return 0;
    }
  },
  _drawPlotBands: function () {
    var plotBands = this._getPlotBands(),
        scale = this.scale,
        isRangeBand = scale.rangeBand;

    var rangeBand = isRangeBand ? scale.rangeBand() : 0;
    var renderer = this.vanchart.renderer;
    var plotBounds = this.vanchart.bounds,
        axis = this,
        isHorizontal = axis.isHorizontal();
    var i, len, from, to, rect;
    var x = 0,
        y = 0,
        width = plotBounds.width,
        height = plotBounds.height;

    if (!this.plotBandsGroup) {
      this.plotBandsGroup = renderer.group().addTo(this.clipAxisGroup);
      this.plotBands = [];
    }

    this.plotBandsGroup.attr({
      'transform': _BaseUtils["default"].makeTranslate(plotBounds)
    });

    for (i = plotBands.length; i < this.plotBands.length; i++) {
      this.plotBands[i] && this.plotBands[i].remove();
      this.plotBands[i] = null;
    }

    this.plotBands.length = plotBands.length;

    for (i = 0, len = plotBands.length; i < len; i++) {
      var d = plotBands[i];
      var t_f = scale(d.from),
          t_t = scale(d.to);
      from = Math.min(t_f, t_t);
      to = Math.max(t_f + rangeBand, t_t + rangeBand);
      from = Math.max(isHorizontal ? x : y, from);
      to = Math.min(isHorizontal ? width : height, to);
      rect = isHorizontal ? {
        x: from,
        y: y,
        width: Math.max(to - from, 0),
        height: height
      } : {
        x: x,
        y: from,
        width: width,
        height: Math.max(to - from, 0)
      };
      this.plotBands[i] = this.plotBands[i] || renderer.rect(rect).addTo(this.plotBandsGroup);
      this.plotBands[i].style({
        'fill': d.color
      }).animate({
        'duration': TIME,
        'ease': EASE,
        attr: rect
      });
    }
  },
  _drawAxisLine: function () {
    var cfg = this.options;
    var lineColor = cfg.lineColor;
    var lineWidth = lineColor ? cfg.lineWidth : 0;

    var plotBounds = this.getPlotBounds(),
        axisOrigin = this._getAxisOriginPoint();

    var x1 = 'x1',
        y1 = 'y1',
        x2 = 'x2',
        y2 = 'y2';
    var size = plotBounds.width,
        renderer = this.vanchart.renderer;

    if (!this.isHorizontal()) {
      x1 = 'y1';
      y1 = 'x1';
      x2 = 'y2';
      y2 = 'x2';
      size = plotBounds.height;
    }

    if (axisOrigin.y <= plotBounds.y && this.isHorizontal() && this.options.onZero || axisOrigin.x >= plotBounds.x + plotBounds.width && this.isVertical() && this.options.onZero) {
      this.axisLine && this.axisLine.remove();
      this.arrowGroup && this.arrowGroup.remove();
      this.axisLine = null;
      this.arrowGroup = null;
      return false;
    }

    var det = _BaseUtils["default"].lineSubPixelOpt(0, lineWidth);

    if (!this.axisLine) {
      this.axisLine = renderer.line().addTo(this.axisLineGroup);
    }

    var attrs = {};
    attrs[x1] = 0;
    attrs[x2] = size;
    attrs[y1] = attrs[y2] = det;
    attrs.transform = _BaseUtils["default"].makeTranslate(axisOrigin);
    this.axisLine.attr(attrs).style({
      stroke: lineColor,
      'stroke-width': lineWidth
    });

    if (this.showArrow()) {
      if (!this.arrowGroup) {
        this.arrowGroup = renderer.group().addTo(this.axisLineGroup);
      }

      var line = this.arrowGroup.line || renderer.line().addTo(this.arrowGroup);
      var path = this.arrowGroup.path || renderer.path().addTo(this.arrowGroup);
      this.arrowGroup.line = line;
      this.arrowGroup.path = path;
      var isReversed = this.isAxisReversed(),
          translateParam,
          // 箭柄的长度是固定的
      arrowHandleLength = 6,
          arrowType;

      if (this.isHorizontal()) {
        isReversed ? (translateParam = [axisOrigin.x, axisOrigin.y], arrowHandleLength *= -1, arrowType = 'left') : (translateParam = [axisOrigin.x + plotBounds.width, axisOrigin.y], arrowType = 'right');
        this.arrowGroup.attr('transform', _BaseUtils["default"].makeTranslate(translateParam));
        line.attr({
          'x1': 0,
          'y1': det,
          'x2': arrowHandleLength,
          'y2': det
        }).style({
          stroke: lineColor,
          'stroke-width': lineWidth
        });
        path.attr({
          'd': _Constants["default"].AXIS_ARROW_PATH[arrowType]
        }).style({
          'fill': lineColor
        });
      } else {
        isReversed ? (translateParam = [axisOrigin.x, axisOrigin.y + plotBounds.height], arrowHandleLength *= -1, arrowType = 'down') : (translateParam = axisOrigin, arrowType = 'up');
        this.arrowGroup.attr('transform', _BaseUtils["default"].makeTranslate(translateParam));
        line.attr({
          'x1': det,
          'y1': 0,
          'x2': det,
          'y2': -arrowHandleLength
        }).style({
          stroke: lineColor,
          'stroke-width': lineWidth
        });
        path.attr({
          'd': _Constants["default"].AXIS_ARROW_PATH[arrowType]
        }).style({
          'fill': lineColor
        });
      }
    } else {
      this.arrowGroup && this.arrowGroup.remove();
    }
  },
  _drawGridLine: function () {
    var cfg = this.options,
        plotBounds = this.getPlotBounds();
    var ticks = this.getTickData(),
        scale = this.scale,
        lastScale = this.lastScale || scale;
    var gridLineColor = cfg.gridLineColor,
        gridLineWidth = cfg.gridLineWidth,
        gridLineType = cfg.gridLineType;

    if (cfg.axisIndex > 0) {
      return;
    } // phantomjs 1.9,
    // svg 'stroke-width' has a default value 1
    // 0 is still 1 (→_→ maybe "value || 1" in apple's webkit...)


    if (gridLineWidth === 0) {
      gridLineColor = '';
    }

    var det = _BaseUtils["default"].lineSubPixelOpt(0, gridLineWidth),
        renderer = this.vanchart.renderer;

    var x1 = 'x1',
        y1 = 'y1',
        x2 = 'x2',
        y2 = 'y2',
        lineSize = plotBounds.height;

    if (!this.isHorizontal()) {
      x1 = 'y1';
      y1 = 'x1';
      x2 = 'y2';
      y2 = 'x2';
      lineSize = plotBounds.width;
    }

    if (!this.gridLinesGroup) {
      this.gridLinesGroup = renderer.group().addTo(this.clipAxisGroup);
      this.gridLines = [];
    }

    this.gridLinesGroup.attr('transform', _BaseUtils["default"].makeTranslate(plotBounds));
    var pos = this.getPosition(),
        isBottomOrTop = pos === _Constants["default"].TOP || pos === _Constants["default"].BOTTOM; // 当轴在上方或者下方时，需要在最右侧加一个边界线，在左方或者右方是，在最下方加

    var concatArray = this.type === _component.ComponentCst.CATEGORY_AXIS_COMPONENT ? [{
      tickPos: isBottomOrTop ? plotBounds.width : plotBounds.height - 1
    }] : [];

    var selection = this._bindData(this.gridLines, ticks.concat(concatArray), function (d) {
      return d.tickValue;
    });

    var currentGridLines = [];
    var i, len, attr, d, gridLine;

    for (i = 0, len = selection.exit.length; i < len; i++) {
      d = selection.exit[i].datum();
      pos = scale(d.tickValue);
      attr = {};
      attr[x1] = pos;
      attr[x2] = pos;
      selection.exit[i].animate({
        'duration': TIME,
        'ease': EASE,
        'attr': attr,
        'style': {
          'opacity': 0
        }
      }).remove();
    }

    var lineConfig = {
      color: gridLineColor,
      lineWidth: gridLineWidth,
      lineType: gridLineType
    };

    for (i = 0, len = selection.enter.length; i < len; i++) {
      d = selection.enter[i];
      gridLine = renderer.line().style((0, _StyleUtils.getLineStyle)(lineConfig)).addTo(this.gridLinesGroup);
      var lastPos = lastScale(d.tickValue) + det;
      pos = d.tickPos + det;
      lastPos = isNaN(lastPos) ? pos : lastPos;
      gridLine.attr(x1, lastPos).attr(x2, lastPos).attr(y1, 0).attr(y2, lineSize);
      attr = {};
      attr[x1] = attr[x2] = pos;
      attr[y1] = 0;
      attr[y2] = lineSize;
      gridLine.animate({
        'attr': attr,
        'duration': TIME,
        'ease': EASE
      });
      gridLine.datum(d);
      currentGridLines.push(gridLine);
    }

    currentGridLines = currentGridLines.concat(selection.update);

    for (i = 0, len = currentGridLines.length; i < len; i++) {
      gridLine = currentGridLines[i].style((0, _StyleUtils.getLineStyle)(lineConfig));
      d = gridLine.datum();
      pos = d.tickPos + det;
      attr = {};
      attr[x1] = attr[x2] = _BaseUtils["default"].lineSubPixelOpt(pos);
      attr[y1] = 0;
      attr[y2] = lineSize;
      gridLine.animate({
        'attr': attr,
        'duration': TIME,
        'ease': EASE
      });
    }

    this.gridLines = currentGridLines;
  },
  //包括主要刻度线和次要刻度线,不加动画了
  _drawTickLine: function () {
    var renderer = this.vanchart.renderer,
        cfg = this.options;

    if (!this.tickLinesGroup) {
      this.tickLinesGroup = renderer.group().addTo(this.axisGroup);
      this.tickLines = {};
      this.tickLines[MAIN_TICK] = [];
      this.tickLines[MINOR_TICKS] = [];
    }

    var tickLength = cfg.enableTick ? cfg.tickLength || 0 : 0;
    var tickWidth = cfg.tickWidth || 1,
        tickColor = cfg.tickColor;

    var detMain = _BaseUtils["default"].lineSubPixelOpt(0, tickWidth);

    var minorTickLength = cfg.enableMinorTick ? cfg.minorTickLength || 0 : 0;
    var minorTickColor = cfg.minorTickColor,
        minorTickWidth = cfg.minorTickWidth || 1;

    var detMinor = _BaseUtils["default"].lineSubPixelOpt(0, minorTickWidth); // 绘制主要间隔线


    this._drawMainTickLine({
      det: detMain,
      tickWidth: tickWidth,
      tickLength: tickColor ? tickLength : 0,
      tickColor: tickColor
    }); // 绘制次要间隔线


    this._drawMinorTickLine({
      det: detMinor,
      tickWidth: minorTickWidth,
      tickLength: minorTickColor ? minorTickLength : 0,
      tickColor: minorTickColor
    });
  },

  /**
   * 绘制主要刻度线，多分类轴时重写该方法
   * @param  {[type]} option [description]
   * @return {[type]}        [description]
   */
  _drawMainTickLine: function (option) {
    var tickData = this.getTickData(); // rangeBand 即非面积图时，主要刻度比tickLabel数多一个

    if (this.isCategory() && !this.isRangePoints) {
      var reversed = this.options.reversed;

      var range = this._getRange();

      var extraTick = [{
        tickPos: range[reversed ? 0 : 1]
      }]; // reverse时在前面

      tickData = reversed ? extraTick.concat(tickData) : tickData.concat(extraTick);
    }

    this.tickLines[MAIN_TICK] = this._drawTickLineWithData(this.tickLines[MAIN_TICK], tickData, option);
  },

  /**
   * 绘制次要刻度线
   * @param  {[type]} option [description]
   * @return {[type]}        [description]
   */
  _drawMinorTickLine: function (option) {
    var minorTickData = this.getMinorTickData();
    this.tickLines[MINOR_TICKS] = this._drawTickLineWithData(this.tickLines[MINOR_TICKS], minorTickData, option);
  },

  /**
   * 根据给定的数据绘制标签间隔线
   * @param  {[type]} tickLines [存放tickLine的数组，方便以后更新tickLine]
   * @param  {[type]} tickData  [刻度线数据：包括文字内容，位置等]
   * @param  {[type]} options   [刻度线的样式等]
   * @return {[type]}           [description]
   */
  _drawTickLineWithData: function (tickLines, tickData, options) {
    // #scroll zoom 隐藏过界tick
    var shouldHideOutside = this.vanchart.isMobileFlow() && this.isCategory();
    var isH = this.isHorizontal();

    if (shouldHideOutside) {
      var plotBounds = this.vanchart.bounds;
      tickData = tickData.filter(function (t) {
        if (isH) {
          return t.tickPos >= 0 && t.tickPos <= plotBounds.width;
        } else {
          return t.tickPos >= 0 && t.tickPos <= plotBounds.height;
        }
      });
    }

    var axisOrigin = this._getAxisOriginPoint(),
        orient = this.getPosition();

    var renderer = this.vanchart.renderer,
        axis = this;
    var axisLineWidth = axis.options.lineWidth || 0;
    var sign = orient === _Constants["default"].TOP || orient === _Constants["default"].LEFT ? -1 : 1;
    var x1 = 'x1',
        y1 = 'y1',
        x2 = 'x2',
        y2 = 'y2';

    if (!this.isHorizontal()) {
      x1 = 'y1';
      y1 = 'x1';
      x2 = 'y2';
      y2 = 'x2';
    }

    var selection = axis._bindData(tickLines, tickData, options.keyFunction);

    var currentTickLines = [],
        i,
        len;

    for (i = 0, len = selection.exit.length; i < len; i++) {
      selection.exit[i].remove();
    }

    for (i = 0, len = selection.enter.length; i < len; i++) {
      currentTickLines.push(renderer.line().datum(selection.enter[i]).addTo(axis.tickLinesGroup));
    }

    currentTickLines = currentTickLines.concat(selection.update);

    for (i = 0, len = currentTickLines.length; i < len; i++) {
      var datum = currentTickLines[i].datum(),
          attrs = {};
      var tickPos;

      if ((0, _CoreUtils.hasDefined)(datum.tickPos)) {
        tickPos = datum.tickPos;
      } else {
        tickPos = axis.type === _component.ComponentCst.CATEGORY_AXIS_COMPONENT ? datum : axis.scale(datum);
      }

      var detX = axisOrigin.x,
          detY = axisOrigin.y;

      if (!axis.isHorizontal()) {
        detX = axisOrigin.y;
        detY = axisOrigin.x;
      } // 多分类轴的时候，其主要刻度线的高度应该根据其categoryKey来计算


      var tickLength = typeof options.tickLengthFuc === "function" ? options.tickLengthFuc(datum) : options.tickLength; // 给刻度的长度加上axis的lineWidth的一半，防止axis的lineWidth较大把刻度线覆盖的情况

      tickLength += tickLength > 0 ? axisLineWidth / 2 : 0;
      attrs[x1] = tickPos + options.det + detX;
      attrs[x2] = attrs[x1];
      attrs[y1] = detY;
      attrs[y2] = (sign * tickLength || 0) + detY;
      currentTickLines[i].attr(attrs).style({
        'stroke': options.tickColor,
        'stroke-width': options.tickWidth
      });
    }

    return currentTickLines;
  },
  _drawPlotLines: function () {
    var plotLines = this.options.plotLines || [];
    var plotBounds = this.vanchart.bounds;
    var scale = this.scale,
        isDate = this.type === _component.ComponentCst.DATE_AXIS_COMPONENT,
        isMultiCategory = this.isMultiCateAxis();
    var result = [],
        axis = this,
        renderer = this.vanchart.renderer;
    plotLines.forEach(function (d) {
      if ((0, _CoreUtils.isEmpty)(d.value)) {
        return;
      }

      var originPos = scale(getPlotLineValue(d.value)) + (scale.rangeBand ? scale.rangeBand() / 2 : 0);

      if (isNaN(originPos)) {
        return;
      }

      var pos = _BaseUtils["default"].lineSubPixelOpt(originPos, d.width);

      var x1, x2, y1, y2;

      if (axis.isHorizontal()) {
        if (originPos < 0 || originPos > plotBounds.width) {
          return;
        }

        x1 = x2 = pos;
        y1 = 0;
        y2 = plotBounds.height;
      } else {
        if (originPos < 0 || originPos > plotBounds.height) {
          return;
        }

        x1 = 0;
        x2 = plotBounds.width;
        y1 = y2 = pos;
      }

      var textX, textY, text, style;
      var lineWidth = _Constants["default"].DASH_ARRAY[d.lineType] == null ? 0 : d.lineWidth;

      if (d.label && d.label.text && d.label.style) {
        style = d.label.style;
        text = d.label.text;
        var align = d.label.align;

        var textDim = _BaseUtils["default"].getTextDimension(text, style, d.label.useHtml);

        switch (align) {
          case _Constants["default"].TOP:
            textX = x1 - textDim.width;
            textY = y1;
            break;

          case _Constants["default"].BOTTOM:
            textX = x1 - textDim.width;
            textY = y2 - textDim.height;
            break;

          case _Constants["default"].LEFT:
            textX = x1;
            textY = y1 - textDim.height - LABEL_LINE_GAP_FUN();
            break;

          case _Constants["default"].RIGHT:
            textX = x2 - textDim.width;
            textY = y2 - textDim.height - LABEL_LINE_GAP_FUN();
            break;
        }
      }

      result.push({
        color: d.color,
        line: {
          x1: x1,
          y1: y1,
          x2: x2,
          y2: y2
        },
        width: lineWidth,
        dataArray: _Constants["default"].DASH_ARRAY[d.lineType],
        text: text,
        textDim: textDim,
        style: style,
        textX: textX,
        textY: textY
      });
    });

    function getPlotLineValue(value) {
      if (isDate) {
        return _BaseUtils["default"].object2date(value);
      }

      if (isMultiCategory) {
        return _BaseUtils["default"].encodeCategoryArray(value);
      }

      return value;
    }

    function _getPlotLineStyle(datum) {
      return {
        'stroke': datum.color,
        'stroke-width': datum.width,
        'stroke-dasharray': datum.dataArray
      };
    }

    function _getLabelGraphic(datum) {
      return renderer.text().style(datum.style).attr({
        'x': datum.textX,
        'y': datum.textY,
        'text-anchor': 'left',
        'dy': datum.textDim.height * .85
      }).textContent(datum.text);
    }

    function _createLabelGraphic(datum, g) {
      if (g._textG) {
        g._textG.remove();

        g._textG = null;
      }

      if (datum.text && datum.textDim) {
        g._textG = _getLabelGraphic(datum).addTo(g);
      }
    }

    if (!this.plotLinesGroup) {
      this.plotLinesGroup = renderer.group().addTo(this.vanchart.frontGroup); // plotLines需要显示在最其前面，放在新添加的frontGroup中

      this.plotLines = [];
    }

    this.plotLinesGroup.attr('transform', _BaseUtils["default"].makeTranslate(plotBounds));

    var selection = this._bindData(this.plotLines, result),
        i,
        len,
        datum;

    this.plotLines = [];

    for (i = 0, len = selection.exit.length; i < len; i++) {
      selection.exit[i].remove();
    }

    for (i = 0, len = selection.enter.length; i < len; i++) {
      datum = selection.enter[i];
      g = renderer.group();
      this.plotLines.push(g);
      g._lineG = g.append(renderer.line(datum.line).style(_getPlotLineStyle(datum)));

      _createLabelGraphic(datum, g);

      g.addTo(this.plotLinesGroup);
    }

    for (i = 0, len = selection.update.length; i < len; i++) {
      var g = selection.update[i];
      datum = g.datum();

      g._lineG.attr(datum.line).style(_getPlotLineStyle(datum));

      _createLabelGraphic(datum, g);

      this.plotLines.push(g);
    }
  },
  _drawTickLabel: function () {
    this._drawSvgTickLabel();
  },

  /**
   * 使用SVG绘制轴标签：多分类轴下，需要重写这个方法
   * @return {[type]} [description]
   */
  _drawSvgTickLabel: function () {
    var vanchart = this.vanchart,
        renderer = vanchart.renderer;
    var ticks = this.getTickData().filter(function (tick) {
      return tick.tickContent !== '';
    });

    if (!this.tickLabelsGroup) {
      this.tickLabelsGroup = renderer.vgroup().add();
      this.axisGroup.append(this.tickLabelsGroup.renderG);
      this.tickLabels = [];
    }
    /**
     * CHART-1182
     * 使用HTML元素来显示标签的时候，svg元素的clipPath对这些标签元素不齐作用，
     * 所以要给这些标签的父元素设置clip属性，才能保证在设置坐标轴最大占比的时候能够隐藏超出的部分。
     */


    if (this.options.useHtml) {
      this.tickLabelsGroup.style({
        width: this.vanchart.width + "px",
        height: this.vanchart.height + "px"
      });
      var clipRect = "rect(" + this.clipBounds.y + "px, " + (this.clipBounds.x + this.clipBounds.width) + "px, " + (this.clipBounds.y + this.clipBounds.height) + "px, " + this.clipBounds.x + "px )";
      this.tickLabelsGroup.attr("clip", clipRect);
    }

    this.tickLabels = this._drawSvgTickLabelWithData(this.tickLabels, ticks);
  },

  /**
   * 绘制单行的svg标签
   * @param  {[type]} tickLabels [description]
   * @param  {[type]} ticks      [description]
   * @param  {[type]} level      [description]
   * @return {[type]}            [description]
   */
  _drawSvgTickLabelWithData: function (tickLabels, ticks, level) {
    var axis = this,
        vanchart = this.vanchart,
        renderer = vanchart.renderer;
    var startPos = level ? this._getLabelStartPos(level) : 0;
    var scale = this.scale,
        lastScale = this.lastScale || scale;
    var cfg = this.options,
        labelStyle = cfg.labelStyle,
        useHtml = cfg.useHtml;
    var shouldHideOutside = this.vanchart.isMobileFlow() && this.isCategory();
    var isH = this.isHorizontal();
    var self = this; // #scroll zoom 隐藏过界tickLabel

    if (shouldHideOutside) {
      var plotBounds = this.vanchart.bounds;
      ticks = ticks.filter(function (d) {
        var transform = self._getLabelAttr(scale, d, startPos);

        if (isH) {
          var x = transform._x + d.tickRectDim.width / 2 - d.tickDim.width / 2 - plotBounds.x;
          var width = d.tickDim.width;
          return x + width >= 0 && x <= plotBounds.width;
        } else {
          var y = transform._y + d.tickRectDim.height / 2 - d.tickDim.height / 2 - plotBounds.y;
          var height = d.tickDim.height;
          return y + height >= 0 && y <= plotBounds.height;
        }
      });
    }

    var selection = this._bindData(tickLabels, ticks, function (d) {
      return d.tickValue;
    }),
        i,
        len,
        d,
        pos;

    var currentTickLabels = [],
        para = {
      'duration': TIME,
      'ease': EASE,
      'style': {
        'opacity': 0
      }
    };

    for (i = 0, len = selection.exit.length; i < len; i++) {
      d = selection.exit[i].datum();
      pos = scale(d.tickValue);
      selection.exit[i].animate(_BaseUtils["default"].extend({}, para, axis.isHorizontal() ? {
        'x': pos
      } : {
        'y': pos
      })).remove();
    }

    var transform, tickLabel, rotateStr;

    for (i = 0, len = selection.enter.length; i < len; i++) {
      d = selection.enter[i];
      transform = this._getLabelAttr(lastScale, d, startPos);
      tickLabel = this.tickLabelsGroup.append(renderer.vtext(useHtml).textContent(d.tickContent).style({
        'opacity': 0
      }));
      rotateStr = d.labelRotation % 360 ? tickLabel.vRotate(d.labelRotation, true
      /* delay */
      ).rotateStr : '';
      transform.transform += rotateStr;
      tickLabel.attr(transform);
      tickLabel.datum(d);
      currentTickLabels.push(tickLabel);
    }

    currentTickLabels = currentTickLabels.concat(selection.update);

    for (i = 0, len = currentTickLabels.length; i < len; i++) {
      tickLabel = currentTickLabels[i];
      d = tickLabel.datum();
      tickLabel.style(labelStyle).textContent(d.tickContent);
      transform = this._getLabelAttr(scale, d, startPos);
      var opacity = this._valueInDomain(d.tickValue) ? 1 : 0; // 0值对齐的时候为了让刻度与标准轴对齐，得到的tickValue可能不在domain范围内，
      // 所以这里稍稍修改一下,alignAxisId属性是在处理0值对齐的函数中添加上的

      opacity = this.alignAxisId ? 1 : opacity;

      if (this.useHtmlLabel()) {
        tickLabel.attr(transform).style({
          'opacity': opacity
        });
        tickLabel.vRotate(d.labelRotation);
      } else {
        rotateStr = d.labelRotation % 360 ? tickLabel.vRotate(d.labelRotation, true
        /* delay */
        ).rotateStr : '';
        transform.transform += rotateStr;
        tickLabel.animate({
          'ease': EASE,
          'duration': TIME,
          'attr': transform,
          'style': {
            'opacity': opacity
          }
        });
      }
    }

    return currentTickLabels;
  },

  /**
   * 计算标签的位置属性,当为多分类轴是，需要传入startPos表示标签的位置偏移
   * @param  {[type]} scale    [description]
   * @param  {[type]} d        [description]
   * @param  {[type]} startPos [description]
   * @return {[type]}          [description]
   */
  _getLabelAttr: function (scale, d, startPos) {
    var origin = this._getAxisOriginPoint();

    var det = scale.rangeBand ? scale.rangeBand() / 2 * (d.length || 1) : 0;
    var tickLabelPos = scale(d.tickValue) + det;
    var cfg = this.options,
        isHorizontal = this.isHorizontal();
    var tickLength = cfg.enableTick ? cfg.tickLength : 0,
        tickPadding = cfg.tickPadding + tickLength || 0;
    var labelRotation = d.labelRotation || 0,
        useHtml = this.useHtmlLabel();
    var position = this.getPosition(),
        sign = position === _Constants["default"].TOP || position === _Constants["default"].LEFT ? -1 : 1;
    var rectDim = d.tickRectDim,
        labelDim = d.tickDim; // 90 degree has no rotation
    // rotation represents in writing-mode;

    var textX = 0,
        textY = 0,
        dx = 0,
        dy = rectDim.height * 0.85,
        direction,
        rotationRadian = _BaseUtils["default"].toRadian(labelRotation),
        writingMode;

    if (labelRotation === 360) {
      dx = useHtml || _Browser["default"].ie ? 0 : rectDim.width * 0.85 / 2;
      dy = 0;
      writingMode = 'tb-rl';
    }

    direction = this._getLabelDirection(labelRotation, isHorizontal);

    if (isHorizontal) {
      textY += sign * (labelDim.height - rectDim.height) / 2;
      textX += sign * direction * (labelDim.width - Math.abs(rectDim.height * Math.sin(rotationRadian))) / 2;

      if (position === _Constants["default"].TOP) {
        textY -= rectDim.height;
        textY -= startPos;
      } else {
        textY += startPos;
      }

      textY += sign * tickPadding;
      textX += origin.x + tickLabelPos - rectDim.width / 2;
      textY += origin.y;
    } else {
      textX += sign * (labelDim.width - rectDim.width) / 2;
      textY += sign * direction * (labelDim.height - rectDim.height * Math.cos(rotationRadian)) / 2;

      if (position === _Constants["default"].LEFT) {
        textX -= rectDim.width;
        textX -= startPos;
      } else {
        textX += startPos;
      }

      textX += sign * tickPadding;
      textX += origin.x;
      textY += origin.y + tickLabelPos - rectDim.height / 2;
    }

    var px = useHtml ? 'px' : '';
    var transform = 'translate(' + textX + px + ' ' + textY + px + ')';
    var result = {
      _x: textX,
      // for boundary check after zoom/scroll
      _y: textY,
      transform: transform,
      dy: dy,
      dx: dx,
      'writingMode': writingMode,
      'writing-mode': writingMode
    }; // phantomjs bug

    if (useHtml && writingMode) {
      result['-webkit-writing-mode'] = 'vertical-rl';
    }

    return result;
  },
  // todo add test
  _getLabelDirection: function (rotation, isHorizontal) {
    if (isHorizontal) {
      if (Math.abs(rotation % 90) < 15) {
        return 0;
      }

      return rotation > 0 ? 1 : -1;
    } // 标签旋转90度时，如果含有中文，则tickDate中的labelRotation为360，否则为90
    // 360度的标签旋转使用css属性tb-rl来实现，90度的标签使用rotate属性来实现


    if (Math.abs(rotation % 90) > 85 || rotation === 90) {
      return 0;
    }

    return rotation > 0 ? 1 : -1;
  },
  _drawAxisTitle: function () {
    var cfg = this.options,
        title = cfg.title;

    if (!title || (0, _CoreUtils.isEmpty)(title.text)) {
      this.titleGroup && this.titleGroup.remove();
      this.titleGroup = null;
      return;
    }

    var R = this.vanchart.renderer,
        axisGroup = this.axisGroup;
    var useHtml = title.useHtml,
        rotation = this.titleRotation,
        align = this.getTitleAlign(),
        text = title.text,
        style = title.style;
    var textDim = this.titleDim,
        rectDim = this.titleRectDim;
    var titleBounds = this.getAxisTitleBounds();

    if (!this.titleGroup) {
      this.titleGroup = R.vgroup().add();
      axisGroup.append(this.titleGroup.renderG);
    }

    this.titleGroup.attr({
      'transform': _BaseUtils["default"].makeTranslate(titleBounds)
    });
    var titleGroup = this.titleGroup; //标题每次刷新重新添加，原因：用中文的刷新没有中文的，中文应该没有rotate(deg,x,y)类似东西

    if (titleGroup.text) {
      titleGroup.text.remove();
    }

    titleGroup.text = titleGroup.append(R.vtext(useHtml));
    var x = 0,
        y = 0,
        dx = 0,
        dy = rectDim.height * 0.85;

    switch (align) {
      case _Constants["default"].TOP:
        y = 0;
        break;

      case _Constants["default"].BOTTOM:
        y = titleBounds.height - textDim.height;
        break;

      case _Constants["default"].LEFT:
        x = 0;
        break;

      case _Constants["default"].RIGHT:
        x = titleBounds.width - textDim.width;
        break;

      case _Constants["default"].CENTER:
      default:
        if (this.isHorizontal()) {
          x = (titleBounds.width - textDim.width) / 2;
        } else {
          y = (titleBounds.height - textDim.height) / 2;
        }

    }

    if (this.titleRotation === 360) {
      dx = useHtml ? 0 : _Browser["default"].ie ? '0.2ex' : rectDim.width * 0.85 / 2; // @CHART-769 IE下面竖直排版某些中文会往左边缩一点.

      dy = 0;
    } else {
      x += (textDim.width - rectDim.width) / 2;
      y += (textDim.height - rectDim.height) / 2;
    }

    titleGroup.text.style(style).attr({
      x: x,
      y: y,
      dy: dy,
      dx: dx
    }).textContent(text);
    rotation % 360 && titleGroup.text.vRotate(rotation);
  },
  remove: function () {
    this.axisGroup && this.axisGroup.remove();
    this.clipAxisGroup && this.clipAxisGroup.remove();
    this.axisGroup = this.clipAxisGroup = null;
    this.axisLineGroup && this.axisLineGroup.remove();
    this.axisLineGroup = null;
    this.axisLine && this.axisLine.remove();
    this.axisLine = null;
    this.gridLinesGroup && this.gridLinesGroup.remove();
    this.gridLinesGroup = null;
    this.gridLines && this.gridLines.forEach(function (gridLine) {
      gridLine && gridLine.remove();
      gridLine = null;
    });
    this.gridLines = null;
    this.plotLinesGroup && this.plotLinesGroup.remove();
    this.plotLinesGroup = null;
    this.plotLines && this.plotLines.forEach(function (plotLine) {
      plotLine && plotLine.remove();
      plotLine = null;
    });
    this.plotLines = null; // remove vgroup

    this.tickLabelsGroup && this.tickLabelsGroup.remove();
    this.tickLabelsGroup = null;
    this.tickLabels = null;
    this.cateTickLabelsGroup && this.cateTickLabelsGroup.remove();
    this.cateTickLabelsGroup = null;
    this.cateTickLabels = null;
    this.titleGroup && this.titleGroup.remove();
    this.titleGroup = null;
    this.removeHighlightBackground && this.removeHighlightBackground();
  },

  /**
   * 判断数据点是否在其基础轴的值域范围内
   * @param point
   * @returns {boolean}
   */
  isPointWithinDataDomain: function (point) {
    var axisType = this.options.type;
    var domain = this._domain;

    switch (axisType) {
      // 基础轴为时间轴
      case _component.ComponentCst.DATE_AXIS_COMPONENT:
        return _BaseUtils["default"].date2int(point.category) >= domain[0] && _BaseUtils["default"].date2int(point.category) <= domain[1];
      // 基础轴为值轴

      case _component.ComponentCst.VALUE_AXIS_COMPONENT:
        return parseFloat(point.category) >= domain[0] && parseFloat(point.category) <= domain[1];
      // 默认的分类轴或者多分类轴

      default:
        return domain.indexOf(point.getCategory()) >= 0;
    }
  },
  isMultiCateAxis: function () {
    return false;
  }
});

var _default = BaseAxis;
exports["default"] = _default;

/***/ }),
/* 64 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseAxis = _interopRequireDefault(__webpack_require__(63));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _component = __webpack_require__(4);

var _CoreUtils = __webpack_require__(3);

var _AxisUtils = __webpack_require__(40);

var _helper = __webpack_require__(47);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/18.
 * 值轴的定义
 */
var ValueAxis = _BaseAxis["default"].extend({
  type: _component.ComponentCst.VALUE_AXIS_COMPONENT,
  initScale: function () {
    this.lastScale = this.scale;
    this.scale = this.options.log ? _Scale["default"].log().base(this.options.log) : _Scale["default"].linear();
  },
  getAxisValue: function (value, point) {
    //布局用到， value === "-"时返回0
    return value === "-" ? 0 : this.byPercent ? point.percentage : +value;
  },
  _valueInDomain: function (value) {
    var domain = this.scale.domain();
    return value >= Math.min(domain[0], domain[1]) && value <= Math.max(domain[0], domain[1]);
  },

  /**
   * 从给定的数据中计算出最大值最小值
   * @param needConsiderBaseAxisDataDomain boolean  是否需要考虑基础坐标轴的值域范围
   * @returns {[min,max]} 返回所有有效数据中最小和最大的值
   * @private
   */
  _getDomainFromData: function (needConsiderBaseAxisDataDomain) {
    var minValue = Number.MAX_VALUE,
        maxValue = -minValue,
        emptyData = true;
    var series = this.series,
        dataMap = {};
    var isVisibleSeries = (0, _AxisUtils.hasVisibleSery)(series);
    this.forecast = (0, _AxisUtils.getForecast)(series);

    for (var i = 0, len = series.length; i < len; i++) {
      if (series[i].visible || !isVisibleSeries) {
        this._getSeriesValue(dataMap, series[i], needConsiderBaseAxisDataDomain);
      }
    }

    for (var key in dataMap) {
      var data = dataMap[key];

      for (var j = 0, count = data.length; j < count; j++) {
        if (!isNaN(data[j]) && !(this.options.log && data[j] <= 0)) {
          minValue = Math.min(minValue, data[j]);
          maxValue = Math.max(maxValue, data[j]);
          emptyData = false;
        }
      }
    }

    if (emptyData) {
      return (0, _AxisUtils.getEmptyDataDomain)(this.options.tickInterval);
    }

    return [minValue, maxValue];
  },
  //获取系列的值，如果是堆积的话获取系列的和
  _getSeriesValue: function (dataMap, sery, needConsiderBaseAxisDataDomain) {
    var seriesName = sery.name || '';
    var seryBaseAxisType = sery.getBaseAxisType(),
        baseAxis = this.vanchart.components[seryBaseAxisType]._axisList[sery.options[seryBaseAxisType] || 0];
    var key = this.componentType == _component.ComponentCst.X_AXIS_COMPONENT ? 'x' : 'y';

    var unstack = (0, _CoreUtils.hasNotDefined)(sery.stack) || sery.stack === false || this._isBaseAxis();

    if (unstack) {
      dataMap[seriesName] = dataMap[seriesName] || [];
      sery.points.forEach(function (point) {
        // 没有指定需要考虑baseAxisDomain的时候，默认全部的点都有效
        var isPointInBaseAxisDataDomain = !needConsiderBaseAxisDataDomain ? true : baseAxis.isPointWithinDataDomain(point);

        if (!point.isNull && point.visible && isPointInBaseAxisDataDomain) {
          var value = point.options[key];

          if (_BaseUtils["default"].isArray(value) || (0, _CoreUtils.hasDefined)(value.min) && (0, _CoreUtils.hasDefined)(value.max)) {
            dataMap[seriesName] = dataMap[seriesName].concat((0, _helper.getPointDomain)(value, point.options.isDetailed));
          } else {
            dataMap[seriesName].push(value);
          }
        }
      });
    } else {
      var PK = sery.stack + sery.type + 'STACK_POSITIVE';
      var NK = sery.stack + sery.type + 'STACK_NEGATIVE';
      dataMap[PK] = dataMap[PK] || [];
      dataMap[NK] = dataMap[NK] || [];
      sery.points.forEach(function (point, i) {
        // 没有指定需要考虑baseAxisDomain的时候，默认全部的点都有效
        var isPointInBaseAxisDataDomain = !needConsiderBaseAxisDataDomain ? true : baseAxis.isPointWithinDataDomain(point);

        if (!point.isNull && point.visible && isPointInBaseAxisDataDomain) {
          var value = +point.options[key];

          if (value > 0) {
            if (dataMap[PK][i] != null && dataMap[PK][i] != undefined) {
              dataMap[PK][i] += value;
            } else {
              dataMap[PK][i] = value;
            }
          } else {
            if (dataMap[NK][i] != null && dataMap[NK][i] != undefined) {
              dataMap[NK][i] += value;
            } else {
              dataMap[NK][i] = value;
            }
          }
        }
      });
    }
  },
  //考虑有正负值的时候的0值对齐的功能
  getStartPos: function () {
    return this.scale(this.getStartPosValue());
  },
  getStartPosValue: function () {
    var axisOption = this.options;
    return axisOption.log && axisOption.log !== 1 ? 1 : 0;
  },
  _getTickValues: function () {
    if (this.options.log) {
      return (0, _AxisUtils.getLogTicks)(this._tickStart, this._domain[1], this.options.log, this._step);
    } else {
      var _this$options = this.options,
          min = _this$options.min,
          max = _this$options.max,
          tickInterval = _this$options.tickInterval;
      return (0, _AxisUtils.getLinearTicks)({
        options: {
          min: min,
          max: max,
          tickInterval: tickInterval
        },
        min: this._tickStart,
        max: this._domain[1],
        interval: this._step
      });
    }
  },

  /**
   * CHART-1256
   * 根据某一个值轴的标签位置来返回当前值轴相对应位置的标签
   * 当存在0值对齐设置的时候，为了让某一个值轴的刻度与标准轴的刻度相对应，只能来点儿硬的：
   * 获取每一个标准轴刻度在绘图区的位置，然后再求解这个位置上当前值轴的刻度值，
   * 这样最后得到的当前值轴的刻度就会与标准值轴的刻度处于差不多的位置。
   * @private
   */
  _getTickValuesAlignByAxis: function () {
    var componentType = this.componentType;
    var relyOnAxis;

    this.vanchart.getComponent(componentType)._axisList.forEach(function (axis) {
      // BaseAxis.js --- _alignByZeroValue函数里面定义了alignAxisId
      if (/^standard/.exec(axis.alignAxisId)) {
        relyOnAxis = axis;
      }
    });

    var range = relyOnAxis._getRange(); //更新relyOnAxis scale range


    relyOnAxis.scale.range(range);

    if (relyOnAxis == this) {
      return this._getTickValues();
    }

    var ticks = relyOnAxis._getTickValues();

    var valueList = [];
    var value;
    this.scale.range(range);

    for (var i = 0, len = ticks.length; i < len; i++) {
      value = this.scale.invert(relyOnAxis.scale(ticks[i])); // 接近于0的情况

      if (Math.abs(0 - value) < 1e-6 || Math.abs(0 - ticks[i]) < 1e-6) {
        value = 0;
      } // 如果value是绝对值大于1的小数，直接四舍五入
      // 但是这可能导致一些小的显示问题……


      if (Math.abs(value) > 1 && value % 1 !== 0) {
        // value = Math.round(value);
        value = Math.floor(value * 100) / 100;
      }

      valueList.push(value);
    } // 返回规范化之后的刻度值


    return this._normalizeTicks(valueList);
  },

  /**
   * CHART-1514
   * 规范化刻度值。
   *
   * Q：为什么要再写这么一个函数呢？
   * A：因为在_getTickValuesAlignByAxis函数中获取到0值对齐的刻度很有可能是这样的——0.0000……1、5.9999……6、11999.99999……6，
   * 这个问题在测试人员以及产品大佬的意识里是有问题的，所以最后受伤的还是开发！！！所以在这里单独写一个函数来解决这个问题。
   *
   * Q：那么获取到这些小数是因为什么呢？
   * A：因为所有的刻度值都是通过比例尺反转（invert）求解得到的，在反转的过程很大概率会出现小数的计算，
   * 由于js在计算一些小数的时候会出现不精确的问题，所以才导致了获取到的刻度值也出现很长的小数。
   * @param ticks
   * @returns {Array|[null]}
   * @private
   */
  _normalizeTicks: function (ticks) {
    var i = -1,
        len = ticks.length - 1,
        diff; // 差值
    // 如果ticks.length < 3， if语句之后的逻辑是多余的，最终还是会返回ticks，所以这里处理一下这种情况

    if (ticks.length < 3) {
      return ticks.map(function (tick) {
        return Math.abs(tick) > 1 ? Math.round(tick) : tick;
      });
    } // 找到第一个差值是整数的时候就break出来


    while (++i < len) {
      diff = _BaseUtils["default"].accAdd(ticks[i + 1], -ticks[i]);

      if ((diff | 0) === diff) {
        break;
      }
    }

    var index, value;
    len = ticks.length;
    i = -1; // 找到第一个刻度值是整数的时候就break出来

    while (++i < len) {
      value = ticks[i];
      index = i;

      if ((value | 0) === value) {
        break;
      }
    }

    len = ticks.length;
    ticks = [value];
    i = index; // 现在得到了差值diff、刻度值value以及知道了value在ticks的下标，
    // 下一步的操作是重新构造ticks数组，从value的位置开始，往前添加刻度值，然后再往后添加刻度值

    while (--i >= 0) {
      ticks.unshift(_BaseUtils["default"].accAdd(value, _BaseUtils["default"].accMul(index - i, -diff)));
    }

    i = index;

    while (++i < len) {
      ticks.push(_BaseUtils["default"].accAdd(value, _BaseUtils["default"].accMul(i - index, diff)));
    }

    return ticks;
  }
});

var _default = ValueAxis;
exports["default"] = _default;

/***/ }),
/* 65 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Bounds = _interopRequireDefault(__webpack_require__(21));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Projection = _interopRequireDefault(__webpack_require__(170));

var _Transformation = _interopRequireDefault(__webpack_require__(171));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/19.
 */
var CRS = {
  // @method latLngToPoint(latlng: LatLng, zoom: Number): Point
  // Projects geographical coordinates into pixel coordinates for a given zoom.
  latLngToPoint: function (latlng, zoom) {
    var projectedPoint = this.projection.project(latlng),
        scale = this.scale(zoom);
    return this.transformation._transform(projectedPoint, scale);
  },
  // @method pointToLatLng(point: Point, zoom: Number): LatLng
  // The inverse of `latLngToPoint`. Projects pixel coordinates on a given
  // zoom into geographical coordinates.
  pointToLatLng: function (point, zoom) {
    var scale = this.scale(zoom),
        untransformedPoint = this.transformation.untransform(point, scale);
    return this.projection.unproject(untransformedPoint);
  },
  // @method project(latlng: LatLng): Point
  // Projects geographical coordinates into coordinates in units accepted for
  // this CRS (e.g. meters for EPSG:3857, for passing it to WMS services).
  project: function (latlng) {
    return this.projection.project(latlng);
  },
  // @method unproject(point: Point): LatLng
  // Given a projected coordinate returns the corresponding LatLng.
  // The inverse of `project`.
  unproject: function (point) {
    return this.projection.unproject(point);
  },
  // @method scale(zoom: Number): Number
  // Returns the scale used when transforming projected coordinates into
  // pixel coordinates for a particular zoom. For example, it returns
  // `256 * 2^zoom` for Mercator-based CRS.
  scale: function (zoom) {
    return 256 * Math.pow(2, zoom);
  },
  // @method zoom(scale: Number): Number
  // Inverse of `scale()`, returns the zoom level corresponding to a scale
  // factor of `scale`.
  zoom: function (scale) {
    return Math.log(scale / 256) / Math.LN2;
  },
  // @method getProjectedBounds(zoom: Number): Bounds
  // Returns the projection's bounds scaled and transformed for the provided `zoom`.
  getProjectedBounds: function (zoom) {
    if (this.infinite) {
      return null;
    }

    var b = this.projection.bounds,
        s = this.scale(zoom),
        min = this.transformation.transform(b.min, s),
        max = this.transformation.transform(b.max, s);
    return _Bounds["default"].create(min, max);
  },
  // @method distance(latlng1: LatLng, latlng2: LatLng): Number
  // Returns the distance between two geographical coordinates.
  // @property code: String
  // Standard code name of the CRS passed into WMS services (e.g. `'EPSG:3857'`)
  //
  // @property wrapLng: Number[]
  // An array of two numbers defining whether the longitude (horizontal) coordinate
  // axis wraps around a given range and how. Defaults to `[-180, 180]` in most
  // geographical CRSs. If `undefined`, the longitude axis does not wrap around.
  //
  // @property wrapLat: Number[]
  // Like `wrapLng`, but for the latitude (vertical) axis.
  // wrapLng: [min, max],
  // wrapLat: [min, max],
  // @property infinite: Boolean
  // If true, the coordinate space will be unbounded (infinite in both axes)
  infinite: false,
  // @method wrapLatLng(latlng: LatLng): LatLng
  // Returns a `LatLng` where lat and lng has been wrapped according to the
  // CRS's `wrapLat` and `wrapLng` properties, if they are outside the CRS's bounds.
  wrapLatLng: function (latlng) {
    var lng = this.wrapLng ? _BaseUtils["default"].wrapNum(latlng.lng, this.wrapLng, true) : latlng.lng,
        lat = this.wrapLat ? _BaseUtils["default"].wrapNum(latlng.lat, this.wrapLat, true) : latlng.lat,
        alt = latlng.alt;
    return new _LatLng["default"](lat, lng, alt);
  }
};
CRS.Simple = _BaseUtils["default"].extend({}, CRS, {
  projection: _Projection["default"].LonLat,
  transformation: new _Transformation["default"](1, 0, -1, 0),
  scale: function (zoom) {
    return Math.pow(2, zoom);
  },
  zoom: function (scale) {
    return Math.log(scale) / Math.LN2;
  },
  distance: function (latlng1, latlng2) {
    var dx = latlng2.lng - latlng1.lng,
        dy = latlng2.lat - latlng1.lat;
    return Math.sqrt(dx * dx + dy * dy);
  },
  infinite: true
});
CRS.Earth = _BaseUtils["default"].extend({}, CRS, {
  wrapLng: [-180, 180],
  // Mean Earth Radius, as recommended for use by
  // the International Union of Geodesy and Geophysics,
  // see http://rosettacode.org/wiki/Haversine_formula
  R: 6371000,
  // distance between two geographical points using spherical law of cosines approximation
  distance: function (latlng1, latlng2) {
    var rad = Math.PI / 180,
        lat1 = latlng1.lat * rad,
        lat2 = latlng2.lat * rad,
        a = Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos((latlng2.lng - latlng1.lng) * rad);
    return this.R * Math.acos(Math.min(a, 1));
  }
});
CRS.EPSG3857 = _BaseUtils["default"].extend({}, CRS.Earth, {
  code: 'EPSG:3857',
  projection: _Projection["default"].SphericalMercator,
  transformation: function () {
    var scale = 0.5 / (Math.PI * _Projection["default"].SphericalMercator.R);
    return new _Transformation["default"](scale, 0.5, -scale, 0.5);
  }()
});
CRS.EPSG900913 = _BaseUtils["default"].extend({}, CRS.EPSG3857, {
  code: 'EPSG:900913'
});
CRS.EPSG4326 = _BaseUtils["default"].extend({}, CRS.Earth, {
  code: 'EPSG:4326',
  projection: _Projection["default"].LonLat,
  transformation: new _Transformation["default"](1 / 180, 1, -1 / 180, 0.5)
});
CRS.EPSG4490 = _BaseUtils["default"].extend({}, CRS.Earth, {
  code: 'EPSG:4490',
  projection: _Projection["default"].LonLat,
  transformation: new _Transformation["default"](1 / 180, 1, -1 / 180, 0.5)
});
CRS.EPSG4480 = _BaseUtils["default"].extend({}, CRS.EPSG4490, {
  code: 'EPSG:4480'
});
CRS.EPSG4479 = _BaseUtils["default"].extend({}, CRS.EPSG4490, {
  code: 'EPSG:4479'
});
CRS.EPSG3395 = _BaseUtils["default"].extend({}, CRS.Earth, {
  code: 'EPSG:3395',
  projection: _Projection["default"].Mercator,
  transformation: function () {
    var scale = 0.5 / (Math.PI * _Projection["default"].Mercator.R);
    return new _Transformation["default"](scale, 0.5, -scale, 0.5);
  }()
});
var _default = CRS;
exports["default"] = _default;

/***/ }),
/* 66 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.unescapeEntities = unescapeEntities;
exports.parseInlineStr = parseInlineStr;
exports.getInlineStyle = getInlineStyle;
exports.removeUnSupportTag = removeUnSupportTag;
exports.splitTspans = splitTspans;
exports.splitStr = splitStr;
exports.getRowHeight = getRowHeight;
exports.getRowWidth = getRowWidth;
exports.addTranslate = addTranslate;
exports.replaceTag = replaceTag;
exports.getTspansProp = getTspansProp;
exports.mergeTspansProps = mergeTspansProps;
exports.buildSvgTspansGroup = buildSvgTspansGroup;
exports.getSvgTransSize = getSvgTransSize;
exports.getSvgTspans = getSvgTspans;

var _EnvUtils = __webpack_require__(2);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var LINE_HEIGHT = 1.4;
var ITALIC_DET = 5;
var DEFAULT_FONT = {
  fontSize: "12px",
  fontStyle: "",
  fontWeight: "",
  fontFamily: ""
};
var ESCAPES = {
  '&': '&amp;',
  '<': '&lt;',
  '>': '&gt;',
  "'": '&#39;',
  '"': '&quot;'
};
var KEY_MAP = {
  'font-size': 'fontSize',
  'font-family': 'fontFamily',
  'font-style': 'fontStyle',
  'font-weight': 'fontWeight',
  'color': 'color'
};

function unescapeEntities(inputStr, except) {
  for (var key in ESCAPES) {
    var value = ESCAPES[key];

    if (!except || except.indexOf(key) === -1) {
      inputStr = inputStr.toString().replace(new RegExp(value, 'g'), key);
    }
  }

  return inputStr;
}

function parseInlineStr(str, attr) {
  var start, delimiter;
  start = str.indexOf('<');
  str = str.substring(start, str.indexOf('>') - start);
  start = str.indexOf(attr + '=');

  if (start !== -1) {
    start = start + attr.length + 1;
    delimiter = str.charAt(start);

    if (delimiter === '"' || delimiter === "'") {
      // eslint-disable-line quotes
      str = str.substring(start + 1);
      return str.substring(0, str.indexOf(delimiter));
    }
  }
}

function getInlineStyle(inlineStr) {
  inlineStr = inlineStr || '';
  var inlineStyle = {};
  inlineStr.split(';').forEach(function (str) {
    var keyAndValue = str.split(':');

    if (keyAndValue && keyAndValue.length === 2) {
      var key = KEY_MAP[keyAndValue[0].trim()];
      inlineStyle[key] = keyAndValue[1];
    }
  });
  return inlineStyle;
}

function removeUnSupportTag(span) {
  if (span == null || span === "") {
    return "";
  }

  return span.replace(/<[a-zA-Z\/](.|\n)*?>/g, '') || ' ';
}

function splitTspans(span) {
  // 第二次分行：以span内部的换行符来分割出tspan
  return span.split(/<br.*?>/g);
}

function splitStr(str) {
  var lines = [];
  var line = [];
  var spans = str.replace(/^\s+|\s+$/g, '').replace(/<span/g, '|||<span').replace(/<\/span>/g, '</span>|||').split('|||').filter(function (span) {
    return span !== '';
  });
  spans.forEach(function (span) {
    if (span.trim() === '<br>') {
      lines.push(line);
      line = [];
    } else {
      line.push(span);
    }
  });

  if (line.length > 0) {
    lines.push(line);
  }

  return lines;
}

function getRowHeight(rowTspans) {
  if (rowTspans == null || rowTspans.length < 1) {
    return 0;
  }

  var maxHeight = 0;
  rowTspans.forEach(function (tspan) {
    maxHeight = Math.max(maxHeight, tspan.height);
  });
  return maxHeight * LINE_HEIGHT;
}

function getRowWidth(rowTspans) {
  if (rowTspans == null || rowTspans.length < 1) {
    return 0;
  }

  var width = 0;
  rowTspans.forEach(function (tspan) {
    width += tspan.width;
  });
  return width;
}

function addTranslate(rowTspansGroup) {
  var x = 0,
      y = 0;
  rowTspansGroup.forEach(function (rowTspans) {
    var height = getRowHeight(rowTspans);
    rowTspans.forEach(function (tspan) {
      tspan.translate = [x, y];
      x += tspan.width;
    });
    x = 0;
    y += height;
  });
}

function replaceTag(textStr) {
  return textStr.replace(/<(b|strong)>/g, '<span style="font-weight:bold">').replace(/<(i|em)>/g, '<span style="font-style:italic">').replace(/<\/(b|strong|i|em|a)>/g, '</span>');
}

function getTspansProp(span, style) {
  var inlineStyle = getInlineStyle(parseInlineStr(span, 'style'));
  var tspans = splitTspans(span);
  return tspans.map(function (tspan) {
    var textContent = unescapeEntities(removeUnSupportTag(tspan));

    var textStyle = _BaseUtils["default"].extend({}, style, inlineStyle);

    var _getCanvasTextDim2 = (0, _EnvUtils._getCanvasTextDim)(textContent, textStyle),
        width = _getCanvasTextDim2.width,
        height = _getCanvasTextDim2.height; // canvas计算斜体宽度时在字体宽度的基础上加了5px，导出时不需要


    if (textStyle['fontStyle'] === 'italic') {
      width -= ITALIC_DET;
    }

    return {
      text: textContent,
      inlineStyle: inlineStyle,
      width: width,
      height: height
    };
  });
}

function mergeTspansProps(transPropGroup) {
  var lines = [];
  var line = []; // 首尾合并：上一个span的最后一个tspan和下一个span的第一个tspan在一行
  // 1、如果span中只有一个tspan，则tspan和上一个span的尾tspan、下一个span的首tspan位于一行
  // 2、如果span中含有多个tspan，则首tspan和上一个span的尾tspan位于一行，中间的tspan独占一行

  transPropGroup.forEach(function (transProp) {
    for (var i = 0, len = transProp.length; i < len; i++) {
      if (transProp.length === 1) {
        line.push(transProp[i]);
      } else if (i === 0) {
        line.push(transProp[i]);
        lines.push(line);
        line = [];
      } else if (i < len - 1) {
        lines.push([transProp[i]]);
      } else if (i === len - 1) {
        line = [transProp[i]];
      }
    }
  }); // 添加最后一个span的最后一个tspan

  if (line.length > 0) {
    lines.push(line);
  }

  return lines;
}

function buildSvgTspansGroup(textStr, style) {
  var replacedDStr = replaceTag(textStr + '');
  var spansGroup = splitStr(replacedDStr);
  var svgTspansGroup = [];
  spansGroup.forEach(function (spans) {
    var tspansPropGroup = spans.map(function (span) {
      return getTspansProp(span, style);
    });
    var mergedTspansProps = mergeTspansProps(tspansPropGroup);
    svgTspansGroup = svgTspansGroup.concat(mergedTspansProps);
  });
  return svgTspansGroup;
} // 获取textStr对应的trans的尺寸


function getSvgTransSize(textStr, style) {
  if (style === void 0) {
    style = DEFAULT_FONT;
  }

  var svgTspansGroup = buildSvgTspansGroup(textStr + '', style);
  var width = 0,
      height = 0;
  svgTspansGroup.forEach(function (rowTspans) {
    width = Math.max(width, getRowWidth(rowTspans));
    height += getRowHeight(rowTspans);
  });
  return {
    width: width,
    height: height
  };
} // 获取含有tspan的二维数组


function getSvgTspans(textStr, style) {
  if (style === void 0) {
    style = DEFAULT_FONT;
  }

  var svgTspansGroup = buildSvgTspansGroup(textStr + '', style);
  addTranslate(svgTspansGroup);
  return svgTspansGroup;
}

/***/ }),
/* 67 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by eason on 16/6/20.
 */

/**
 * Created by eason on 16/6/7.
 * vml下面用path来构造所有的形状,输出vml的path
 */
var pathCommand = /([achlmrqstvz])[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*)+)/ig;
var pathValues = /(-?\d*\.?\d*(?:e[\-+]?\d+)?)[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*/ig;
var concat = "concat",
    apply = "apply",
    upperCase = String.prototype.toUpperCase,
    mmax = Math.max,
    math = Math,
    round = math.round;
var PI = math.PI,
    abs = Math.abs,
    split = "split";
var p2s = /,?([achlmqrstvxz]),?/gi,
    val = /-?\d*\.?\d+(?:[eE][\-+]?\d+)?/g;
var S = " ",
    E = "",
    fillString = "fill",
    zoom = 1;

function path2vml(path) {
  var bites = /([clmz]),?([^clmz]*)/gi;
  var map = {
    M: "m",
    L: "l",
    C: "c",
    Z: "x",
    m: "t",
    l: "r",
    c: "v",
    z: "x"
  };
  var total = /[ahqstv]/ig,
      command = pathToAbsolute;
  String(path).match(total) && (command = path2curve);
  total = /[clmz]/g;

  if (command == pathToAbsolute && !String(path).match(total)) {
    var res = String(path).replace(bites, function (all, command, args) {
      var vals = [],
          isMove = command.toLowerCase() == "m",
          res = map[command];
      args.replace(val, function (value) {
        if (isMove && vals.length === 2) {
          res += vals + map[command == "m" ? "l" : "L"];
          vals = [];
        }

        vals.push(round(value * zoom));
      });
      return res + vals;
    });
    return res;
  }

  var pa = command(path),
      p,
      r;
  res = [];

  for (var i = 0, ii = pa.length; i < ii; i++) {
    p = pa[i];
    r = pa[i][0].toLowerCase();
    r == "z" && (r = "x");

    for (var j = 1, jj = p.length; j < jj; j++) {
      r += round(p[j] * zoom) + (j != jj - 1 ? "," : E);
    }

    res.push(r);
  }

  return res.join(S);
}

function parsePathString(pathString) {
  if (!pathString && typeof pathString != 'string') {
    return null;
  }

  var paramCounts = {
    a: 7,
    c: 6,
    h: 1,
    l: 2,
    m: 2,
    r: 4,
    q: 4,
    s: 4,
    t: 2,
    v: 1,
    z: 0
  },
      data = [];
  String(pathString).replace(pathCommand, function (a, b, c) {
    var params = [],
        name = b.toLowerCase();
    c.replace(pathValues, function (a, b) {
      b && params.push(+b);
    });

    if (name == "m" && params.length > 2) {
      data.push([b][concat](params.splice(0, 2)));
      name = "l";
      b = b == "m" ? "l" : "L";
    }

    if (name == "r") {
      data.push([b][concat](params));
    } else while (params.length >= paramCounts[name]) {
      data.push([b][concat](params.splice(0, paramCounts[name])));

      if (!paramCounts[name]) {
        break;
      }
    }
  });
  data.toString = path2string;
  return data;
}

function path2string() {
  return this.join(",").replace(p2s, "$1");
}

function path2curve(path, path2) {
  var p = pathToAbsolute(path),
      p2 = path2 && pathToAbsolute(path2),
      attrs = {
    x: 0,
    y: 0,
    bx: 0,
    by: 0,
    X: 0,
    Y: 0,
    qx: null,
    qy: null
  },
      attrs2 = {
    x: 0,
    y: 0,
    bx: 0,
    by: 0,
    X: 0,
    Y: 0,
    qx: null,
    qy: null
  },
      processPath = function (path, d, pcom) {
    var nx,
        ny,
        tq = {
      T: 1,
      Q: 1
    };

    if (!path) {
      return ["C", d.x, d.y, d.x, d.y, d.x, d.y];
    }

    !(path[0] in tq) && (d.qx = d.qy = null);

    switch (path[0]) {
      case "M":
        d.X = path[1];
        d.Y = path[2];
        break;

      case "A":
        path = ["C"][concat](a2c[apply](0, [d.x, d.y][concat](path.slice(1))));
        break;

      case "S":
        if (pcom == "C" || pcom == "S") {
          // In "S" case we have to take into account, if the previous command is C/S.
          nx = d.x * 2 - d.bx; // And reflect the previous

          ny = d.y * 2 - d.by; // command's control point relative to the current point.
        } else {
          // or some else or nothing
          nx = d.x;
          ny = d.y;
        }

        path = ["C", nx, ny][concat](path.slice(1));
        break;

      case "T":
        if (pcom == "Q" || pcom == "T") {
          // In "T" case we have to take into account, if the previous command is Q/T.
          d.qx = d.x * 2 - d.qx; // And make a reflection similar

          d.qy = d.y * 2 - d.qy; // to case "S".
        } else {
          // or something else or nothing
          d.qx = d.x;
          d.qy = d.y;
        }

        path = ["C"][concat](q2c(d.x, d.y, d.qx, d.qy, path[1], path[2]));
        break;

      case "Q":
        d.qx = path[1];
        d.qy = path[2];
        path = ["C"][concat](q2c(d.x, d.y, path[1], path[2], path[3], path[4]));
        break;

      case "L":
        path = ["C"][concat](l2c(d.x, d.y, path[1], path[2]));
        break;

      case "H":
        path = ["C"][concat](l2c(d.x, d.y, path[1], d.y));
        break;

      case "V":
        path = ["C"][concat](l2c(d.x, d.y, d.x, path[1]));
        break;

      case "Z":
        path = ["C"][concat](l2c(d.x, d.y, d.X, d.Y));
        break;
    }

    return path;
  },
      fixArc = function (pp, i) {
    if (pp[i].length > 7) {
      pp[i].shift();
      var pi = pp[i];

      while (pi.length) {
        pcoms1[i] = "A"; // if created multiple C:s, their original seg is saved

        p2 && (pcoms2[i] = "A"); // the same as above

        pp.splice(i++, 0, ["C"][concat](pi.splice(0, 6)));
      }

      pp.splice(i, 1);
      ii = mmax(p.length, p2 && p2.length || 0);
    }
  },
      fixM = function (path1, path2, a1, a2, i) {
    if (path1 && path2 && path1[i][0] == "M" && path2[i][0] != "M") {
      path2.splice(i, 0, ["M", a2.x, a2.y]);
      a1.bx = 0;
      a1.by = 0;
      a1.x = path1[i][1];
      a1.y = path1[i][2];
      ii = mmax(p.length, p2 && p2.length || 0);
    }
  },
      pcoms1 = [],
      // path commands of original path p
  pcoms2 = [],
      // path commands of original path p2
  pfirst = "",
      // temporary holder for original path command
  pcom = ""; // holder for previous path command of original path


  for (var i = 0, ii = Math.max(p.length, p2 && p2.length || 0); i < ii; i++) {
    p[i] && (pfirst = p[i][0]); // save current path command

    if (pfirst != "C") // C is not saved yet, because it may be result of conversion
      {
        pcoms1[i] = pfirst; // Save current path command

        i && (pcom = pcoms1[i - 1]); // Get previous path command pcom
      }

    p[i] = processPath(p[i], attrs, pcom); // Previous path command is inputted to processPath

    if (pcoms1[i] != "A" && pfirst == "C") {
      pcoms1[i] = "C";
    }

    ; // A is the only command
    // which may produce multiple C:s
    // so we have to make sure that C is also C in original path

    fixArc(p, i); // fixArc adds also the right amount of A:s to pcoms1

    if (p2) {
      // the same procedures is done to p2
      p2[i] && (pfirst = p2[i][0]);

      if (pfirst != "C") {
        pcoms2[i] = pfirst;
        i && (pcom = pcoms2[i - 1]);
      }

      p2[i] = processPath(p2[i], attrs2, pcom);

      if (pcoms2[i] != "A" && pfirst == "C") {
        pcoms2[i] = "C";
      }

      fixArc(p2, i);
    }

    fixM(p, p2, attrs, attrs2, i);
    fixM(p2, p, attrs2, attrs, i);
    var seg = p[i],
        seg2 = p2 && p2[i],
        seglen = seg.length,
        seg2len = p2 && seg2.length;
    attrs.x = seg[seglen - 2];
    attrs.y = seg[seglen - 1];
    attrs.bx = parseFloat(seg[seglen - 4]) || attrs.x;
    attrs.by = parseFloat(seg[seglen - 3]) || attrs.y;
    attrs2.bx = p2 && (parseFloat(seg2[seg2len - 4]) || attrs2.x);
    attrs2.by = p2 && (parseFloat(seg2[seg2len - 3]) || attrs2.y);
    attrs2.x = p2 && seg2[seg2len - 2];
    attrs2.y = p2 && seg2[seg2len - 1];
  }

  return p2 ? [p, p2] : p;
}

function q2c(x1, y1, ax, ay, x2, y2) {
  var _13 = 1 / 3,
      _23 = 2 / 3;

  return [_13 * x1 + _23 * ax, _13 * y1 + _23 * ay, _13 * x2 + _23 * ax, _13 * y2 + _23 * ay, x2, y2];
}

function l2c(x1, y1, x2, y2) {
  return [x1, y1, x2, y2, x2, y2];
}

function a2c(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {
  // for more information of where this math came from visit:
  // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
  var _120 = PI * 120 / 180,
      rad = PI / 180 * (+angle || 0),
      res = [],
      xy,
      rotate = function (x, y, rad) {
    var X = x * math.cos(rad) - y * math.sin(rad),
        Y = x * math.sin(rad) + y * math.cos(rad);
    return {
      x: X,
      y: Y
    };
  };

  if (!recursive) {
    xy = rotate(x1, y1, -rad);
    x1 = xy.x;
    y1 = xy.y;
    xy = rotate(x2, y2, -rad);
    x2 = xy.x;
    y2 = xy.y;
    var cos = math.cos(PI / 180 * angle),
        sin = math.sin(PI / 180 * angle),
        x = (x1 - x2) / 2,
        y = (y1 - y2) / 2;
    var h = x * x / (rx * rx) + y * y / (ry * ry);

    if (h > 1) {
      h = math.sqrt(h);
      rx = h * rx;
      ry = h * ry;
    }

    var rx2 = rx * rx,
        ry2 = ry * ry,
        k = (large_arc_flag == sweep_flag ? -1 : 1) * math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),
        cx = k * rx * y / ry + (x1 + x2) / 2,
        cy = k * -ry * x / rx + (y1 + y2) / 2,
        f1 = math.asin(((y1 - cy) / ry).toFixed(9)),
        f2 = math.asin(((y2 - cy) / ry).toFixed(9));
    f1 = x1 < cx ? PI - f1 : f1;
    f2 = x2 < cx ? PI - f2 : f2;
    f1 < 0 && (f1 = PI * 2 + f1);
    f2 < 0 && (f2 = PI * 2 + f2);

    if (sweep_flag && f1 > f2) {
      f1 = f1 - PI * 2;
    }

    if (!sweep_flag && f2 > f1) {
      f2 = f2 - PI * 2;
    }
  } else {
    f1 = recursive[0];
    f2 = recursive[1];
    cx = recursive[2];
    cy = recursive[3];
  }

  var df = f2 - f1;

  if (abs(df) > _120) {
    var f2old = f2,
        x2old = x2,
        y2old = y2;
    f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
    x2 = cx + rx * math.cos(f2);
    y2 = cy + ry * math.sin(f2);
    res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
  }

  df = f2 - f1;
  var c1 = math.cos(f1),
      s1 = math.sin(f1),
      c2 = math.cos(f2),
      s2 = math.sin(f2),
      t = math.tan(df / 4),
      hx = 4 / 3 * rx * t,
      hy = 4 / 3 * ry * t,
      m1 = [x1, y1],
      m2 = [x1 + hx * s1, y1 - hy * c1],
      m3 = [x2 + hx * s2, y2 - hy * c2],
      m4 = [x2, y2];
  m2[0] = 2 * m1[0] - m2[0];
  m2[1] = 2 * m1[1] - m2[1];

  if (recursive) {
    return [m2, m3, m4][concat](res);
  } else {
    res = [m2, m3, m4][concat](res).join()[split](",");
    var newres = [];

    for (var i = 0, ii = res.length; i < ii; i++) {
      newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;
    }

    return newres;
  }
}

function pathToAbsolute(pathArray) {
  if (typeof pathArray == 'string') {
    pathArray = parsePathString(pathArray);
  }

  if (!pathArray || !pathArray.length) {
    return [["M", 0, 0]];
  }

  var res = [],
      x = 0,
      y = 0,
      mx = 0,
      my = 0,
      start = 0;

  if (pathArray[0][0] == "M") {
    x = +pathArray[0][1];
    y = +pathArray[0][2];
    mx = x;
    my = y;
    start++;
    res[0] = ["M", x, y];
  }

  var crz = pathArray.length === 3 && pathArray[0][0] === "M" && pathArray[1][0].toUpperCase() === "R" && pathArray[2][0].toUpperCase() === "Z";

  for (var r, pa, i = start, ii = pathArray.length; i < ii; i++) {
    res.push(r = []);
    pa = pathArray[i];

    if (pa[0] != upperCase.call(pa[0])) {
      r[0] = upperCase.call(pa[0]);

      switch (r[0]) {
        case "A":
          r[1] = pa[1];
          r[2] = pa[2];
          r[3] = pa[3];
          r[4] = pa[4];
          r[5] = pa[5];
          r[6] = +(pa[6] + x);
          r[7] = +(pa[7] + y);
          break;

        case "V":
          r[1] = +pa[1] + y;
          break;

        case "H":
          r[1] = +pa[1] + x;
          break;

        case "R":
          var dots = [x, y][concat](pa.slice(1));

          for (var j = 2, jj = dots.length; j < jj; j++) {
            dots[j] = +dots[j] + x;
            dots[++j] = +dots[j] + y;
          }

          res.pop();
          res = res[concat](catmullRom2bezier(dots, crz));
          break;

        case "M":
          mx = +pa[1] + x;
          my = +pa[2] + y;

        default:
          for (j = 1, jj = pa.length; j < jj; j++) {
            r[j] = +pa[j] + (j % 2 ? x : y);
          }

      }
    } else if (pa[0] == "R") {
      dots = [x, y][concat](pa.slice(1));
      res.pop();
      res = res[concat](catmullRom2bezier(dots, crz));
      r = ["R"][concat](pa.slice(-2));
    } else {
      for (var k = 0, kk = pa.length; k < kk; k++) {
        r[k] = pa[k];
      }
    }

    switch (r[0]) {
      case "Z":
        x = mx;
        y = my;
        break;

      case "H":
        x = r[1];
        break;

      case "V":
        y = r[1];
        break;

      case "M":
        mx = r[r.length - 2];
        my = r[r.length - 1];

      default:
        x = r[r.length - 2];
        y = r[r.length - 1];
    }
  }

  res.toString = path2string;
  return res;
}

function catmullRom2bezier(crp, z) {
  var d = [];

  for (var i = 0, iLen = crp.length; iLen - 2 * !z > i; i += 2) {
    var p = [{
      x: +crp[i - 2],
      y: +crp[i - 1]
    }, {
      x: +crp[i],
      y: +crp[i + 1]
    }, {
      x: +crp[i + 2],
      y: +crp[i + 3]
    }, {
      x: +crp[i + 4],
      y: +crp[i + 5]
    }];

    if (z) {
      if (!i) {
        p[0] = {
          x: +crp[iLen - 2],
          y: +crp[iLen - 1]
        };
      } else if (iLen - 4 == i) {
        p[3] = {
          x: +crp[0],
          y: +crp[1]
        };
      } else if (iLen - 2 == i) {
        p[2] = {
          x: +crp[0],
          y: +crp[1]
        };
        p[3] = {
          x: +crp[2],
          y: +crp[3]
        };
      }
    } else {
      if (iLen - 4 == i) {
        p[3] = p[2];
      } else if (!i) {
        p[0] = {
          x: +crp[i],
          y: +crp[i + 1]
        };
      }
    }

    d.push(["C", (-p[0].x + 6 * p[1].x + p[2].x) / 6, (-p[0].y + 6 * p[1].y + p[2].y) / 6, (p[1].x + 6 * p[2].x - p[3].x) / 6, (p[1].y + 6 * p[2].y - p[3].y) / 6, p[2].x, p[2].y]);
  }

  return d;
}

function rectPath(x, y, w, h, r) {
  var path;

  if (r) {
    var rx = r > w / 2 ? w / 2 : r;
    var ry = r > h / 2 ? h / 2 : r;
    path = [["M", x, y + ry], ["a", rx, ry, 0, 0, 1, rx, -ry], ["h", w - rx - rx], ["a", rx, ry, 0, 0, 1, rx, ry], ["v", h - ry - ry], ["a", rx, ry, 0, 0, 1, -rx, ry], ["h", rx + rx - w], ["a", rx, ry, 0, 0, 1, -rx, -ry], ["z"]];
  } else {
    path = [["M", x, y], ["l", w, 0], ["l", 0, h], ["l", -w, 0], ["z"]];
  }

  return path2vml(path);
}

function circlePath(x, y, r) {
  return path2vml([["M", x, y], ["m", 0, -r], ["a", r, r, 0, 1, 1, 0, 2 * r], ["a", r, r, 0, 1, 1, 0, -2 * r], ["z"]]);
}

function linePath(x1, y1, x2, y2) {
  return path2vml([["M", x1, y1], ["L", x2, y2]]);
}

var _default = {
  path2vml: path2vml,
  rectPath: rectPath,
  linePath: linePath,
  circlePath: circlePath
};
exports["default"] = _default;

/***/ }),
/* 68 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _tooltipFormatter = _interopRequireDefault(__webpack_require__(103));

var _EnvUtils = __webpack_require__(2);

var _richTextMount = __webpack_require__(54);

var _richTextDetail = __webpack_require__(55);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/7/3.
 * reused and modified tooltip component from echarts
 */
//Copyright (c) 2013, Baidu Inc.
//    All rights reserved.
//
//    Redistribution and use of this software in source and binary forms, with or
//    without modification, are permitted provided that the following conditions
//are met:
//
//    Redistributions of source code must retain the above copyright notice, this
//list of conditions and the following disclaimer.
//
//    Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//and/or other materials provided with the distribution.
//
//    Neither the name of Baidu Inc. nor the names of its contributors may be used
//to endorse or promote products derived from this software without specific
//prior written permission of Baidu Inc.
//
//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
//ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
//ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
var DEFAULT_DURATION = 0.4;
var DEFAULT_CUSTOM_CONTENT_STYLE = {
  color: 'rgba(255,255,255,1)'
};
var WIDTH_MAGIC_NUMBER = 2;

var Tooltip = _Base["default"].extend({
  _gCssText: 'position:absolute;display:block;border-style:solid;white-space:nowrap;z-index:2000;-webkit-user-select:none;-moz-user-select:none;-o-user-select:none;user-select:none;pointer-events:none;',
  _style: function (opt) {
    if (!opt) {
      return '';
    }

    var cssText = [];

    if (opt.animation && !opt.follow) {
      var transitionText = 'left ' + DEFAULT_DURATION + 's,' + 'top ' + DEFAULT_DURATION + 's';
      cssText.push('transition:' + transitionText);
      cssText.push('-moz-transition:' + transitionText);
      cssText.push('-webkit-transition:' + transitionText);
      cssText.push('-o-transition:' + transitionText);
    }

    var style = typeof opt.formatter !== 'object' ? opt.style || DEFAULT_CUSTOM_CONTENT_STYLE : opt.style;

    if (style && !opt.useRichText) {
      var fontStyle = _BaseUtils["default"].cssNormalization(style);

      for (var styleName in fontStyle) {
        if (styleName == 'color') {
          cssText.push(styleName + ':' + _ColorUtils["default"].colorToHex(fontStyle[styleName]));
        } else {
          cssText.push(styleName + ':' + fontStyle[styleName]);
        }
      }
    }

    var colorToHexAlpha = function (color) {
      var hexAlpha = _ColorUtils["default"].colorToHexAlpha(color);

      return '#' + ('0' + (hexAlpha.alpha * 255 | 0).toString(16)).slice(-2) + hexAlpha.hex.replace('#', '');
    };

    if (opt.backgroundColor) {
      if (typeof opt.backgroundColor == 'string') {
        if ((0, _EnvUtils.isSupportSVG)()) {
          cssText.push('background-Color:' + opt.backgroundColor);
        } else {
          var msColor = colorToHexAlpha(opt.backgroundColor); // ms: #alpha+hex

          cssText.push('filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=' + msColor + ', endColorstr=' + msColor + ', GradientType=0)');
        }
      } else if (typeof opt.backgroundColor == 'object') {
        var color = opt.backgroundColor;
        var startColor = color.startColor;
        var endColor = color.endColor;
        var start = 'left';
        var startPos = 'left top';
        var endPos = 'right top';
        var type = 1;

        if (color.x1 == color.x2) {
          start = 'top';
          startPos = 'left top';
          endPos = 'left bottom';
          type = 0;
        }

        cssText.push('background: -ms-linear-gradient(' + start + ', ' + startColor + ', ' + endColor + ')');
        cssText.push('background-image: -moz-linear-gradient(' + start + ', ' + startColor + ', ' + endColor + ')');
        cssText.push('background-image: -webkit-gradient(linear, ' + startPos + ', ' + endPos + ', color-stop(0, ' + startColor + '), color-stop(1, ' + endColor + '))');
        cssText.push('filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=' + colorToHexAlpha(startColor) + ', endColorstr=' + colorToHexAlpha(endColor) + ', GradientType=' + type + ')');
      }
    }

    if (opt.borderWidth != null) {
      cssText.push('border-width:' + opt.borderWidth + 'px');
    }

    if (opt.borderColor != null) {
      cssText.push('border-color:' + opt.borderColor);
    }

    if (opt.borderRadius != null) {
      cssText.push('border-radius:' + opt.borderRadius + 'px');
      cssText.push('-moz-border-radius:' + opt.borderRadius + 'px');
      cssText.push('-webkit-border-radius:' + opt.borderRadius + 'px');
      cssText.push('-o-border-radius:' + opt.borderRadius + 'px');
    }

    if (opt.shadow) {
      cssText.push('box-shadow:1px 1px 2px rgba(0,0,0,0.2)');
    }

    var padding = opt.padding;

    if (padding != null && padding != undefined) {
      padding = _BaseUtils["default"].reformCssArray(padding);
      cssText.push('padding:' + padding[0] + 'px ' + padding[1] + 'px ' + padding[2] + 'px ' + padding[3] + 'px');
    }

    cssText = cssText.join(';') + ';';
    return cssText;
  },
  doLayout: function (dom) {
    if (false) {}

    if (!this._tDom) {
      dom = dom || this.vanchart.getDivParentDom();
      this._tDom = document.createElement('div');
      this._hiddenDom = document.createElement('div');

      this._tDom.onselectstart = function () {
        return false;
      };

      this._tDom.style.position = 'absolute';
      this._hiddenDom.style.visibility = 'hidden';
      dom.appendChild(this._tDom);
      dom.appendChild(this._hiddenDom);
      this._tooltipHideTick = null;
    }
  },
  remove: function () {
    var dom = this.vanchart.getDivParentDom();

    if (this._tDom && dom && dom.contains(this._tDom)) {
      //@CHART-2024, IE11
      dom.removeChild(this._tDom);
      dom.removeChild(this._hiddenDom);
    }

    this._tDom = null;
  },

  /**
   * 根据toolbarIcon和提示内容，显示工具栏提示
   * @param  {Obejct} icon 触发mouseover的toolbarIcon
   * @param  {String} text 对应的提示内容
   */
  showWithToolbarIcon: function (icon, text) {
    var toolbar = icon.toolbar,
        opt = toolbar.options.tooltip;
    var tooltipDim = this.calculateTooltipDivDim(opt, text);
    var pos = icon.toolbar.calcToolbarTipPos(icon, tooltipDim);

    this._show(pos, opt, text);
  },
  showWithPoint: function (point, event, formatPoint) {
    var vanchartDim = this.vanchart.getChartBounds();

    if (point && point.options.tooltip && point.series.vanchart.renderer && (event ? _BaseUtils["default"].containsPoint(vanchartDim, event.containerPoint) : true)) {
      //todo 自动数据提示可能还需要触发鼠标悬浮效果，等王军回来再找他确认吧
      var fmtPoint = formatPoint || point,
          opt = fmtPoint.options.tooltip,
          // use formatPoint's style
      seriesChart = point.series;

      if (opt.useRichText) {
        this.showRichTextPoint(point, event, fmtPoint);
        return;
      }

      var tooltipText = (0, _tooltipFormatter["default"])(fmtPoint);
      var tooltipDim = this.calculateTooltipDivDim(opt, tooltipText); // 优先从地图那边取数据点提示的位置

      var pos = seriesChart.getTooltipPos(point, tooltipDim, event);
      pos && this._show(pos, opt, tooltipText);
    }
  },
  showRichTextPoint: function (point, event, fmtPoint) {
    var series = point.series;
    var tooltip = fmtPoint.options.tooltip;
    var formatter = tooltip.formatter;

    if (this.vanchart.isMouseDown) {
      return;
    }

    var richTextContent = (0, _richTextDetail.getTooltipRichTextDetail)(fmtPoint, tooltip.richText, tooltip.autoStyle, formatter);
    var richTextDim = (0, _richTextDetail.getRichTextDim)(richTextContent);
    var tooltipDivDim = this.calculateRichTextTooltipDivDim(tooltip, richTextDim);
    var pos = series.getTooltipPos(point, tooltipDivDim, event);
    clearTimeout(this._tooltipHideTick);
    (0, _richTextMount.createRichTextTooltip)(fmtPoint, richTextContent, this._tDom, tooltip.padding);
    this._tDom.style.cssText = this._gCssText + this._style(tooltip) + 'width:' + richTextDim.width + 'px;height:' + richTextDim.height + 'px;' + 'left:' + pos[0] + 'px;top:' + pos[1] + 'px;';
  },
  calculateRichTextTooltipDivDim: function (opt, richTextDim) {
    var padding = opt.padding,
        borderWidth = opt.borderWidth;
    return {
      width: richTextDim.width + padding * 2 + borderWidth * 2 + WIDTH_MAGIC_NUMBER,
      // CHART-1401
      height: richTextDim.height + padding * 2 + borderWidth * 2
    };
  },
  // 很脏地从原始html里返回字符串数组
  getMobileTextArray: function (point, event, formatPoint) {
    if (point && point.options.tooltip && point.series.vanchart.renderer) {
      var fmtPoint = formatPoint || point;
      var style = fmtPoint.options.tooltip.style;
      var tooltip = fmtPoint.options.tooltip;

      if (tooltip.useRichText) {
        var richText = tooltip.richText,
            autoStyle = tooltip.autoStyle,
            formatter = tooltip.formatter;
        return (0, _richTextDetail.getTooltipRichTextDetail)(fmtPoint, richText, autoStyle, formatter);
      } // 居然3个if (捂眼睛


      if (style) {
        style = _BaseUtils["default"].extend({}, style);
        delete style.FONT_SCALE;
        var fontSize = style.fontSize;

        if (fontSize) {
          if (fontSize.indexOf('pt') !== -1) {
            fontSize = parseFloat(fontSize) * 4 / 3;
          }

          style.fontSize = parseFloat(fontSize) | 0;
        }

        if (style.color) {
          style.textFill = style.color;
        }
      }

      var text = (0, _tooltipFormatter["default"])(fmtPoint);
      text = text.replace(/&lt/g, "<").replace(/&gt/g, ">"); // MOBILE-24221

      text = text.replace(/<br>|<br \/>/g, '\n');
      text = text.replace(/<[^<>]+>/g, '');
      text = text.replace(/&nbsp;/g, ' ');
      return text.split('\n').filter(function (line) {
        return line;
      }).map(function (line) {
        return [{
          style: style,
          text: line
        }];
      });
    }
  },
  // replace '-' with '&#150;' in ie 10, 11, edge;
  // innerHTML '-' will lead to repaint
  _getTooltipText: function () {
    // todo
    // browser detail version function
    // ie 10, 11, edge
    var ua = navigator.userAgent;
    var msie = ua.indexOf('MSIE ');

    if (ua.indexOf('Trident/7.0') > 0 || ua.indexOf('Edge/') > 0 || msie > 0 && parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10) === 10) {
      return function (text) {
        text += '';
        var replaced = '';
        var isContent = true;
        var i = -1;
        var len = text.length;
        var t;

        while (++i < len) {
          t = text.charAt(i);

          if (isContent && t === '-') {
            t = '&#150;';
          } else if (t === '<') {
            isContent = false;
          } else if (t === '>') {
            isContent = true;
          }

          replaced += t;
        }

        return replaced;
      };
    } else {
      return function (text) {
        return text;
      };
    }
  }(),
  _show: function (pos, opt, tooltipText) {
    if (pos && opt && tooltipText && !this.vanchart.isMouseDown) {
      clearTimeout(this._tooltipHideTick);
      this._tDom.innerHTML = this._getTooltipText(tooltipText);
      this._tDom.style.cssText = this._gCssText + this._style(opt) + 'left:' + pos[0] + 'px;top:' + pos[1] + 'px;';
    }
  },
  hide: function () {
    clearTimeout(this._tooltipHideTick);
    this._tooltipHideTick = setTimeout(function () {
      this.immediateHide();
    }.bind(this), 400);
  },
  immediateHide: function () {
    if (this._tDom) {
      this._tDom.style.display = 'none';
    }
  },
  calculateTooltipDivDim: function (opt, tooltipText) {
    opt = opt || '';
    var testDiv = this._hiddenDom;
    testDiv.innerHTML = this._getTooltipText(tooltipText);
    testDiv.style.cssText = this._gCssText + this._style(opt) + 'visibility:hidden;';

    var widthAndHeight = _BaseUtils["default"].getComputedStyle(testDiv, 'width height border-left-width padding-left', function (x) {
      x = Math.ceil(window.parseFloat(x));
      return isNaN(x) ? 0 : x;
    });

    var width = widthAndHeight.width + widthAndHeight.borderLeftWidth * 2 + widthAndHeight.paddingLeft * 2;
    var height = widthAndHeight.height + widthAndHeight.borderLeftWidth * 2 + widthAndHeight.paddingLeft * 2; // CHART-1401
    // 不适用offsetHeight和offsetWidth，转而使用computedStyle的原因是：
    // offsetHeight得到的值是经过四舍五入计算之后的值，而真实绘制出来的DOM元素的width或者height是一个浮点数，
    // 网上说的浏览器绘制元素的最小单位是1px都是童话。

    return {
      // CHART-1401
      // 不管了，tooltip超出边界现在已经肯定不是图表的锅，调试模板的js又太麻烦了，
      // 而且这个问题也不大，来个快刀斩乱麻，直接给宽度加上2px，我看它还会不会超出来。
      width: width + WIDTH_MAGIC_NUMBER,
      height: height
    };
  },
  render: function () {//do nothing
  }
});

var _default = Tooltip;
exports["default"] = _default;

/***/ }),
/* 69 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Renderer = _interopRequireDefault(__webpack_require__(56));

var _PathUtils = _interopRequireDefault(__webpack_require__(67));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _wrapper = _interopRequireDefault(__webpack_require__(37));

var _types = __webpack_require__(45);

var _ElementWrapper = __webpack_require__(38);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/6/1.
 */
var CSS = "position:absolute;left:0px;top:0px;width:1px;height:1px;behavior:url(#default#VML);display:inline-block;";
var SubCss = "position:absolute;behavior:url(#default#VML);display:inline-block;";

var VmlRenderer = _Renderer["default"].extend({
  type: _types.VML_RENDERER,
  _initContainer: function () {
    var root = this.div().style({
      'white-space': 'nowrap',
      'display': 'inline-block'
    });

    _DomUtils["default"].addClass(root.node(), 'van-vml');

    this.dom.appendChild(root.node()); //vml可以和div混合

    this._divContainer = root;
    this._container = root;
    return root;
  },
  line: function (attrs) {
    return this._shapeWithPath(attrs, 'line');
  },
  rect: function (attrs) {
    return this._shapeWithPath(attrs, 'rect');
  },
  circle: function (attrs) {
    return this._shapeWithPath(attrs, 'circle');
  },
  path: function (attrs) {
    return this._shapeWithPath(attrs, 'path');
  },
  image: function (attrs) {
    var image = (0, _wrapper["default"])(document.createElement('image'), this).setType('image');
    image.attr(attrs);
    return image;
  },
  //ie8 group套group就显示不出了,奇葩
  group: function (attrs) {
    var group = this.div().style({
      'white-space': 'nowrap',
      'pointer-events': 'none'
    });
    return group.attr(attrs);
  },
  colorGradient: function (attrs, stops, type) {
    type = type || 'linearGradient';
    return {
      type: type,
      attrs: attrs,
      stops: stops,
      elements: []
    };
  },
  toPatternProperty: function (patternEl) {
    return "url(#" + _BaseUtils["default"].stamp(patternEl) + ")";
  },
  updateColorGradient: function (gradient, attrs, stops) {
    gradient.attrs = attrs;
    gradient.stops = stops;
  },
  //todo 怎样和svg的效果统一
  _updateGradientFill: function (elementWrapper, colorGradient) {
    var node = elementWrapper.node(),
        fill = elementWrapper._fill;
    var stops = colorGradient.stops,
        attrs = colorGradient.attrs;

    if (fill) {
      node.removeChild(fill);
      fill.on = true;
      fill.method = "none";
      fill.color = stops[0]['stop-color'];
      fill.color2 = stops[stops.length - 1]['stop-color'];
      var clrs = [];

      for (var i = 0, ii = stops.length; i < ii; i++) {
        var offset = stops[i].offset * 100 + '%';
        clrs.push(offset + ' ' + stops[i]['stop-color']);
      } // fill.colors = clrs.length ? clrs.join() : "0% " + fill.color;


      fill.type = "gradient";
      fill.angle = attrs.x1 == attrs.x2 ? 0 : 270;
      node.appendChild(fill);
    }
  },
  textContent: function (elementW, text) {},
  text: function () {
    return this.vtext(false);
  },
  tspan: function () {
    return this.vtspan(false);
  },
  _shapeWithPath: function (attrs, type) {
    var shape = (0, _wrapper["default"])(this.create('shape'), this).setType(type),
        container = shape.rawElement;
    container.style.cssText = CSS;
    container.coordsize = '1 1';
    return shape.attr(attrs);
  },
  create: function () {
    try {
      document.namespaces.add('lvml', 'urn:schemas-microsoft-com:vml');
      return function (name) {
        return document.createElement('<lvml:' + name + ' class="lvml">');
      };
    } catch (e) {
      return function (name) {
        return document.createElement('<' + name + ' xmlns="urn:schemas-microsoft.com:vml" class="lvml">');
      };
    }
  }(),
  createClip: function (attrs, type) {
    if (type && type != 'rect') {
      return;
    }

    return {
      'x': attrs.x,
      'y': attrs.y,
      'width': attrs.width,
      'height': attrs.height,
      'clipped': []
    };
  },
  _getClipStr: function (elementWrapper, attrs) {
    var top = attrs.y || 0,
        left = attrs.x || 0;

    if (elementWrapper.type != 'div') {
      var node = elementWrapper.isLineChart ? elementWrapper.node().parentNode.firstChild : elementWrapper.node(); // @CHART-1968 VML-Clip  这里我们通过修改visibility去强制浏览器重绘从而更新clip
      // @CHART-2557 之前的报表tab的切换用的是display:none，导致的我们拿到的domSize不对，后来那边统一改成了visibility:hidden
      // 那么这里在触发重绘之后，重置visibility属性，不然父元素visibility:hidden之后这个node还是可以看得见的

      var lastVisibilityValue = node.style.visibility;
      node.style.visibility = 'hidden';
      node.style.visibility = 'visible';
      node.style.visibility = lastVisibilityValue;
      top -= node.offsetTop;
      left -= node.offsetLeft;
    }

    var right = left + attrs.width,
        bottom = top + attrs.height;
    return 'rect(' + top + 'px ' + right + 'px ' + bottom + 'px ' + left + 'px)';
  },
  clip: function (elementWrapper, clipWrapper) {
    if (clipWrapper) {
      var node;

      if (elementWrapper.node && (node = elementWrapper.node())) {
        node.style.clip = this._getClipStr(elementWrapper, clipWrapper);
        node.clip = "True";
        clipWrapper.clipped.indexOf(elementWrapper) < 0 && clipWrapper.clipped.push(elementWrapper);
      }
    }
  },
  updateClip: function (clipWrapper, attrs) {
    var renderer = this;

    if (clipWrapper) {
      _BaseUtils["default"].extend(clipWrapper, attrs);

      clipWrapper.clipped.forEach(function (elementWrapper) {
        var node = elementWrapper.node();

        if (node) {
          node.style.clip = renderer._getClipStr(elementWrapper, clipWrapper);
        }
      });
    }
  },
  _update: function () {
    if (this._map && this._map._animatingZoom && this._bounds) {
      return;
    }

    _Renderer["default"].prototype._update.call(this);

    this.fire('update');
  },
  imagePattern: function (p, attrs) {},
  createDropShadowFilter: function () {
    return {};
  },
  createInnerShadowFilter: function () {
    return {};
  },
  attr: function (domWrapper, args) {
    if (!args || args.length <= 0 || !args[0]) {
      return;
    }

    var attrs = {},
        elem = domWrapper.rawElement;

    if (args.length === 2) {
      attrs[args[0]] = args[1];
    } else {
      attrs = args[0];
    }

    var oldAttrs = domWrapper.attrs,
        type = domWrapper.type;

    if (oldAttrs) {
      attrs = _BaseUtils["default"].extend(oldAttrs, attrs);
    } else {
      // avoid revising original attr obj
      attrs = _BaseUtils["default"].extend({}, attrs);
    }

    domWrapper.attrs = attrs; // transform属性先屏蔽掉,暂时只更新矩形

    if (attrs.transform) {
      var transform = (0, _ElementWrapper.transformParser)(attrs.transform);

      try {
        if (transform.translate) {
          elem.style.left = transform.translate[0] + 'px';
          elem.style.top = transform.translate[1] + 'px';
        }
      } catch (e) {}

      if (transform.rotate) {}
    }

    if (type == 'image') {
      elem.style.position = 'absolute';
      elem.style.left = attrs.x + 'px';
      elem.style.top = attrs.y + 'px';
      elem.style.width = attrs.width + 'px';
      elem.style.height = attrs.height + 'px';
    } else if (type != 'group') {
      var pathStr = '';

      if (type == 'rect') {
        pathStr = _PathUtils["default"].rectPath(attrs.x || 0, attrs.y || 0, attrs.width, attrs.height, attrs.rx);
      } else if (type == 'line') {
        pathStr = _PathUtils["default"].linePath(attrs.x1, attrs.y1, attrs.x2, attrs.y2);
      } else if (type == 'path') {
        pathStr = _PathUtils["default"].path2vml(attrs.d);
      } else if (type == 'circle') {
        pathStr = _PathUtils["default"].circlePath(attrs.cx || 0, attrs.cy || 0, attrs.r);
      }

      elem.path = pathStr;
    }
  },
  style: function (domWrapper, styles) {
    var oldStyles = domWrapper.styles,
        newStyles = {},
        elem = domWrapper.rawElement,
        styleName; // convert legacy

    if (styles && styles.color) {
      styles.fill = styles.color;
    }

    if (styles && styles.fill && domWrapper.type === 'div') {
      styles.color = styles.fill;
    } // Filter out existing styles to increase performance (#2640)


    if (oldStyles) {
      for (styleName in styles) {
        if (styles[styleName] !== oldStyles[styleName]) {
          newStyles[styleName] = styles[styleName];
        }
      }
    }

    if (domWrapper.type === 'div') {
      if (newStyles['transform']) {
        var trans = (0, _ElementWrapper.transformParser)(newStyles['transform'].replace(/px/gi, ''));

        if (trans.translate) {
          newStyles['transform'] = '';
          newStyles['x'] = trans.translate[0];
          newStyles['y'] = trans.translate[1];
        }
      }

      var map = {
        'x': 'left',
        'y': 'top',
        'dx': 'margin-left' // 'dy': 'margin-top'

      };

      for (var name in map) {
        var s;

        if ((s = newStyles[name]) != null) {
          // em or +'px' suffix
          newStyles[map[name]] = /em/gi.test(s) ? s : s + 'px';
          delete newStyles[name];
        }
      }
    } // Merge the new styles with the old ones


    if (oldStyles) {
      styles = _BaseUtils["default"].extend(oldStyles, newStyles);
    }

    domWrapper.styles = styles;

    if (domWrapper.type === 'div') {
      var hyphenate = function (a, b) {
        return '-' + b.toLowerCase();
      };

      var alpha = 1;

      if (/rgba/i.test(styles.color)) {
        var c = _ColorUtils["default"].colorToHexAlpha(styles.color);

        styles.color = c.hex;
        alpha = c.alpha;
      }

      if ((0, _CoreUtils.hasDefined)(styles['fill-opacity'])) {
        alpha *= styles['fill-opacity'];
      }

      if (alpha < 1) {
        styles['filter'] = "progid:DXImageTransform.Microsoft.Alpha(Opacity=" + alpha * 100 + ")";
      }

      var serializedCss = '';

      for (styleName in styles) {
        serializedCss += styleName.replace(/([A-Z])/g, hyphenate) + ':' + styles[styleName] + ';';
      }

      elem.style.cssText = serializedCss;
    } else if (domWrapper.type != 'group') {
      if (domWrapper.type == 'image') {
        domWrapper.node().src = styles.src;
      } else {
        var stroke = domWrapper._stroke,
            fill = domWrapper._fill,
            container = domWrapper.node();
        container.stroked = true; //默认的样式

        container.filled = !!(styles.fill && styles.fill != 'none' || domWrapper.type == 'image');

        if (!stroke) {
          stroke = domWrapper._stroke = this.create('stroke');
          stroke.style.cssText = SubCss;
        }

        container.appendChild(stroke);
        stroke.weight = (styles['stroke-width'] || 0) + 'px';
        var strokeColor = styles.stroke;
        var strokeOpacity = (0, _CoreUtils.hasDefined)(styles['stroke-opacity']) ? styles['stroke-opacity'] : 1; //兼容rgba的写法

        if (strokeColor && strokeColor.indexOf('rgba') != -1) {
          strokeColor = _ColorUtils["default"].colorToHexAlpha(strokeColor);
          strokeOpacity *= strokeColor.alpha;
          strokeColor = strokeColor.hex;
        }

        stroke.color = strokeColor;
        stroke.opacity = styles['stroke-width'] ? strokeOpacity : 0;

        if (styles['stroke-dasharray']) {
          stroke.dashStyle = styles['stroke-dasharray'].replace(/( *, *)/g, ' ');
        } else {
          stroke.dashStyle = '';
        }

        if (styles['stroke-linecap'] == 'round') {
          stroke.endcap = 'round';
        }

        if (container.filled) {
          if (!fill) {
            fill = domWrapper._fill = this.create('fill');
            fill.style.cssText = SubCss;
          }

          container.appendChild(fill);
          var fillColor = styles.fill;
          var fillOpacity = (0, _CoreUtils.hasDefined)(styles['fill-opacity']) ? styles['fill-opacity'] : 1; //兼容rgba的写法

          if (fillColor.indexOf('rgba') != -1) {
            fillColor = _ColorUtils["default"].colorToHexAlpha(fillColor);
            fillOpacity *= fillColor.alpha;
            fillColor = fillColor.hex;
          }

          fill.color = fillColor;
          fill.opacity = Math.min(1, Math.max(fillOpacity, 0)); // todo 这之前肯定有操作导致的fillOpacity>1，从而在IE8下面报错，有时间在慢慢找吧
        } else if (fill) {
          container.removeChild(fill);
          domWrapper._fill = null;
        }
      }
    }

    if ('display' in styles) {
      domWrapper.node().style.display = styles.display;
    }

    if ('cursor' in styles) {
      domWrapper.node().style.cursor = styles.cursor;
    }
  },
  // assume there's no margin
  // if margin(as offset) is needed,
  // revise this func, record offset to other attr
  // then combine the offset and the rotate adjustment to margin.
  vRotate: function (domWrapper, deg) {
    deg = deg % 360;
    var dom = domWrapper.node();

    var originDim = _BaseUtils["default"].getTextBBoxWithRotation(domWrapper, 0);

    var rotatedDim = _BaseUtils["default"].getTextBBoxWithRotation(domWrapper, deg);

    var ow = originDim.width,
        oh = originDim.height;
    var rw = rotatedDim.width,
        rh = rotatedDim.height;

    _BaseUtils["default"].domRotate(dom, deg);

    dom.style.marginLeft = (ow - rw) / 2 + 'px';
    dom.style.marginTop = (oh - rh) / 2 + 'px';
  },
  // again, no dx/margin-left used,
  // or revise it
  vMiddle: function (domWrapper) {
    var dom = domWrapper.node();
    var ow = dom.offsetWidth;
    dom.style.marginLeft = -ow / 2 + 'px';
  }
});

var _default = VmlRenderer;
exports["default"] = _default;

/***/ }),
/* 70 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/15.
 */
//timer的定义
var d3_timer_queueHead,
    d3_timer_queueTail,
    d3_timer_interval,
    d3_timer_timeout,
    d3_timer_active,
    d3_timer_frame = _BaseUtils["default"].requestAnimFrame;

var Timer = function (callback, delay, then) {
  var n = arguments.length;

  if (n < 2) {
    delay = 0;
  }

  if (n < 3) {
    then = Date.now();
  }

  var time = then + delay,
      timer = {
    c: callback,
    t: time,
    f: false,
    n: null
  };

  if (d3_timer_queueTail) {
    d3_timer_queueTail.n = timer;
  } else {
    d3_timer_queueHead = timer;
  }

  d3_timer_queueTail = timer;

  if (!d3_timer_interval) {
    d3_timer_timeout = clearTimeout(d3_timer_timeout);
    d3_timer_interval = 1;
    d3_timer_frame(d3_timer_step);
  }
};

function d3_timer_step() {
  var now = d3_timer_mark(),
      delay = d3_timer_sweep() - now;

  if (delay > 24) {
    if (isFinite(delay)) {
      clearTimeout(d3_timer_timeout);
      d3_timer_timeout = _BaseUtils["default"].setTimeout(d3_timer_step, delay);
    }

    d3_timer_interval = 0;
  } else {
    d3_timer_interval = 1;
    d3_timer_frame(d3_timer_step);
  }
}

Timer.flush = function () {
  d3_timer_mark();
  d3_timer_sweep();
};

function d3_timer_mark() {
  var now = Date.now();
  d3_timer_active = d3_timer_queueHead;

  while (d3_timer_active) {
    if (now >= d3_timer_active.t) {
      d3_timer_active.f = d3_timer_active.c(now - d3_timer_active.t);
    }

    d3_timer_active = d3_timer_active.n;
  }

  return now;
}

function d3_timer_sweep() {
  var t0,
      t1 = d3_timer_queueHead,
      time = Infinity;

  while (t1) {
    if (t1.f) {
      t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n;
    } else {
      if (t1.t < time) {
        time = t1.t;
      }

      t1 = (t0 = t1).n;
    }
  }

  d3_timer_queueTail = t0;
  return time;
}

;

Timer.getActiveTimer = function () {
  return d3_timer_active;
};

var _default = Timer;
exports["default"] = _default;

/***/ }),
/* 71 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * 移动端事件助手
 */
var touchEventConfig = {};

function setConfig(cfg) {
  touchEventConfig = cfg;
}

function getConfig(key) {
  return key != null ? touchEventConfig[key] : touchEventConfig;
}

var _default = {
  setConfig: setConfig,
  getConfig: getConfig
};
exports["default"] = _default;

/***/ }),
/* 72 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _localeText = _interopRequireDefault(__webpack_require__(32));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _renderer = _interopRequireDefault(__webpack_require__(22));

var _Browser = _interopRequireDefault(__webpack_require__(8));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by shine on 2018/12/10.
 */
// 空数据提示的图案-尺寸120px * 125px
var patternPathArrayIe8 = [{
  d: "M108.5,47.4l-7.7,57.2c-10.7,9.4-25.9,15-41.4,15c-14.1,0.1-27.7-4.8-38.5-13.8l11.8-86.5c0.7-5.3,5.6-9,11-8.3c0,0,0.1,0,0.1,0L85.5,17L108.5,47.4z",
  fill: "#fff"
}, {
  d: "M108.5,47.4l-16.4-2c-5.6-0.8-9.4-5.9-8.6-11.4L85.7,17L108.5,47.4z",
  fill: "#F4F4F4"
}, {
  d: "M6.2,29.7C1.6,31.5-0.7,36.6,1,41.2L2.1,44l20,52.8l10.5-77L8.7,28.8L6.2,29.7z",
  fill: "#979797"
}, {
  d: "M71.4,14.5C69.7,9.9,64.6,7.6,60,9.3l-7.6,2.9l19.3,2.7L71.4,14.5z",
  fill: "#979797"
}, {
  d: "M53,74.6c-1.2,3.4-1,7.2,0.6,10.4l2.9-1.4c-0.9-2.5-0.8-5.3,0.1-7.8c1.6-4.2,4.2-5.2,4.2-5.2l-2.2-2.9C58.7,67.6,55,69.1,53,74.6z",
  fill: "#DDDDDD"
}, {
  d: "M91.4,79.2c0-13.2-10.7-23.9-24-23.9c-13.2,0-24,10.7-24,23.9c0,13.2,10.7,23.9,24,23.9c4.7,0,9.2-1.4,13.2-3.9l6.4,7.6l2.7-2.2l-6.3-7.5C88.4,92.5,91.3,86,91.4,79.2z M67.4,98c-10.4,0-18.9-8.4-18.9-18.8s8.5-18.8,18.9-18.8s18.9,8.4,18.9,18.8C86.3,89.6,77.9,98,67.4,98C67.4,98,67.4,98,67.4,98z",
  fill: "#DDDDDD"
}, {
  d: "M105.3,118.4l-8.9-10.2l-0.6-0.7l-2-2.4c-0.8-1-2.3-1.1-3.3-0.2c0,0,0,0,0,0l-3.1,2.7c-1,0.8-1.1,2.3-0.2,3.3c0,0,0,0,0,0l0.9,1.1l0.7,0.8l10,11.4c0.8,1,2.3,1.1,3.3,0.2c0,0,0,0,0,0l3.1-2.7C106,120.8,106.1,119.4,105.3,118.4z",
  fill: "#DDDDDD"
}, {
  d: "M59.9,0c-21,0-40.6,10.9-51.5,28.8l24.3-9.2v-0.1c0.8-5.4,5.8-9.2,11.2-8.4l8.4,1.2l7.6-2.9c4.6-1.7,9.7,0.6,11.5,5.1l0.1,0.4l13,1.8l0.8,0.1l23.1,30.6l-0.1,0.9l-7.4,55c-1.7,1.4-3.5,2.8-5.3,4.1l0.6,0.7c1.6-1.2,3.1-2.3,4.6-3.6l0,0C113.1,93.1,120.1,77,120,60.1c0.2-33-26.5-60-59.7-60.1C60.2,0,60,0,59.9,0z",
  fill: "#DDDDDD"
}, {
  d: "M59.5,118.2c-14,0.1-27.5-4.6-38.4-13.4c0.1-0.4,0.1-0.7,0.2-1.3l0.9-6.6l-20-52.5C0.7,49.6,0,55,0,60.4c-0.2,17.5,7.5,34.2,20.9,45.4l0,0c10.8,9,24.4,13.8,38.4,13.7c10.1,0,20.1-2.4,29.2-6.8l-0.7-0.8C79,116,69.3,118.2,59.5,118.2z",
  fill: "#DDDDDD"
}];
var patternPathArray = [{
  d: "M21.6861532,105.868125 C8.56232631,94.8838731 0.212429854,78.359709 0.212429854,59.880479 C0.212429854,54.1840955 1.00586564,48.6734891 2.48799073,43.4536664 L22.649,98.9938826 L29.8304299,47.755 Z M59.9445727,2.27373675e-13 C92.9337243,2.27373675e-13 119.676716,26.8094036 119.676716,59.880479 C119.676716,77.3491812 112.21507,93.0707947 100.31259,104.017006 C101.601855,101.431409 101.93585,98.3020432 100.982765,95.6764616 L100.982765,95.6764616 L100.728,94.9798826 L107.347001,47.7557915 L85.4660013,18.6387915 L72.346,16.7888826 L71.4610072,14.3492268 C69.9550861,10.2006797 65.3654552,8.05535596 61.2144051,9.57025436 L61.2144051,9.57025436 L50.042,13.6468826 L42.8305214,12.6314795 C38.4498159,12.0141653 34.4135621,15.0621991 33.8003155,19.4373425 L33.8003155,19.4373425 L33.78,19.5818826 L8.98152276,28.6307416 C19.4824442,11.4570476 38.3788544,2.27373675e-13 59.9445727,2.27373675e-13 Z",
  fill: "#9D9D9D",
  opacity: 0.3
}, {
  d: "M100.728,94.9768826 L100.982765,95.6764616 C101.997482,98.4718299 101.553276,101.838245 100.051207,104.510569 C98.3525075,106.035263 96.5661693,107.464069 94.7006853,108.788491 C96.298204,107.635324 97.8364558,106.405043 99.3099089,105.102972 L99.3099089,105.102972 L100.728,94.9768826 Z M33.78,19.5818826 L22.649,98.9938826 L1.22819621,39.9802288 C-0.279795786,35.8259768 1.86154843,31.2306887 6.01387621,29.715324 L33.78,19.5818826 Z M71.4610072,14.3492268 L72.347,16.7898826 L50.042,13.6468826 L61.2144051,9.57025436 C65.3654552,8.05535596 69.9550861,10.2006797 71.4610072,14.3492268 Z",
  fill: "#8E8E8E",
  opacity: 0.69938151
}, {
  d: "M85.8592018,19.448828 L107.46743,48.2007765 L90.0638031,45.7485946 C85.6930747,45.1326864 82.6471655,41.0857006 83.2597822,36.7150512 L85.4496228,21.0918641 C85.5298171,20.5197267 85.6686523,19.9703052 85.8592018,19.448828 Z",
  fill: "#A7A7A7",
  opacity: 0.1
}, {
  d: "M95.3748961,104.873902 L105.633766,117.132637 C106.696782,118.402877 106.527565,120.300004 105.261031,121.365594 L102.868981,123.378128 C101.600109,124.445685 99.7101798,124.281903 98.6467241,123.011137 L88.3878545,110.752402 C87.3248384,109.482162 87.4940556,107.585035 88.7605896,106.519445 L91.152639,104.506911 C92.421511,103.439354 94.3114404,103.603136 95.3748961,104.873902 Z M68.7838584,55.3155994 C81.801999,55.3155994 92.355287,65.895095 92.355287,78.9455642 C92.355287,85.761736 89.4764532,91.9038503 84.8711975,96.2166335 L91.2729565,103.86633 L88.4003636,106.283167 L81.935358,98.5585057 C78.1787435,101.095028 73.6537675,102.575529 68.7838584,102.575529 C55.7657179,102.575529 45.2124299,91.9960334 45.2124299,78.9455642 C45.2124299,65.895095 55.7657179,55.3155994 68.7838584,55.3155994 Z M68.7838584,60.686046 C58.7243862,60.686046 50.5695727,68.8611108 50.5695727,78.9455642 C50.5695727,89.0300177 58.7243862,97.2050825 68.7838584,97.2050825 C78.8433307,97.2050825 86.9981441,89.0300177 86.9981441,78.9455642 C86.9981441,68.8611108 78.8433307,60.686046 68.7838584,60.686046 Z M59.8827396,66.9250971 L62.0152487,69.4938832 C59.2320766,71.8167394 57.5933822,75.2452735 57.5933822,78.9455642 C57.5933822,80.4102854 57.8482896,81.8374574 58.3403299,83.1812251 L58.3403299,83.1812251 L55.211225,84.3331282 C54.5845843,82.6217653 54.2600489,80.804761 54.2600489,78.9455642 C54.2600489,74.2419962 56.3466436,69.8763492 59.8827396,66.9250971 L59.8827396,66.9250971 Z",
  fill: "#B7B7B7",
  opacity: 0.496744792
}];
patternPathArray = _Browser["default"].ielt9 ? patternPathArrayIe8 : patternPathArray;
/**
 * 图片在组件内宽高等比例缩放，一旦图片的任意一条边等于组件的相应边，停止缩放：
 * 先判断图片的宽等于组件的宽时，图片的高进行等比例缩放时是否大于组件的高，
 * 如果大于，则根据图片的高等于组件的高来进行等比例缩放计算宽高；
 * 反之，返回图片的宽等于组件的宽时计算出的宽高
 */

function calculateTipSize(chartSize, imageSize) {
  var width = imageSize.width,
      height = imageSize.height;
  var chartWidth = chartSize.chartWidth,
      chartHeight = chartSize.chartHeight;
  var heightWithWidthScale = height * chartWidth / width;

  if (heightWithWidthScale <= chartHeight) {
    return {
      width: chartWidth,
      height: heightWithWidthScale
    };
  }

  var widthWithHeightScale = width * chartHeight / height;
  return {
    width: widthWithHeightScale,
    height: chartHeight
  };
}

function getEmptyDataImageSize(emptyDataImage, chartSize) {
  var width = emptyDataImage.width,
      height = emptyDataImage.height;

  if (!emptyDataImage.auto) {
    return {
      width: width,
      height: height
    };
  }

  var imageSize = calculateTipSize(chartSize, emptyDataImage);
  return {
    width: imageSize.width,
    height: imageSize.height
  };
}

function getEmptyDataImage(renderer, emptyDataGroup, emptyDataImage, chartSize) {
  var chartWidth = chartSize.chartWidth,
      chartHeight = chartSize.chartHeight;
  var emptyDataImageSize = getEmptyDataImageSize(emptyDataImage, chartSize);
  var src = emptyDataImage.src;
  var width = emptyDataImageSize.width,
      height = emptyDataImageSize.height;
  renderer.image().addTo(emptyDataGroup).attr({
    "width": width,
    "height": height,
    "x": (chartWidth - width) / 2,
    "y": (chartHeight - height) / 2,
    "preserveAspectRatio": "none"
  }).imageContent(src);
  return {
    remove: function () {
      renderer && renderer.remove();
      renderer = null;
    },
    renderer: renderer
  };
} // ie8及以下浏览器不支持图案跟随图表区域自适应


function getEmptyDataTipTrans(chartSize, size) {
  if (_Browser["default"].ielt9) {
    return getEmptyDataTipTransIe8(chartSize, size);
  }

  var chartWidth = chartSize.chartWidth,
      chartHeight = chartSize.chartHeight;
  var width = size.tipWidth,
      height = size.tipHeight;
  var imageSize = calculateTipSize(chartSize, {
    width: width,
    height: height
  });
  var imageWidth = imageSize.width,
      imageHeight = imageSize.height;
  var scale = imageWidth / width;
  var translateX = (chartWidth - imageWidth) / 2,
      translateY = (chartHeight - imageHeight) / 2;
  return "translate(" + translateX + "," + translateY + ") scale(" + scale + ")";
}

function getEmptyDataTipTransIe8(chartSize, tipSize) {
  var chartWidth = chartSize.chartWidth,
      chartHeight = chartSize.chartHeight;
  var tipWidth = tipSize.tipWidth,
      tipHeight = tipSize.tipHeight;
  var translateX = (chartWidth - tipWidth) / 2,
      translateY = (chartHeight - tipHeight) / 2;
  return "translate(" + translateX + ", " + translateY + ")";
}

function showEmptyDataTip(attrs) {
  var dom = attrs.dom,
      emptyDataTip = attrs.emptyDataTip,
      chartWidth = attrs.chartWidth || 200,
      chartHeight = attrs.chartHeight || 200,
      chart = attrs.chart;

  if (!dom) {
    return;
  }

  if (!emptyDataTip || !emptyDataTip.enabled) {
    //空数据没有开启，直接返回
    return;
  }

  if (!chart) {
    chart = {
      options: {
        plotOptions: {
          animation: true
        }
      }
    };

    chart.getSize = function () {
      return [chartWidth, chartHeight];
    };
  }

  if (attrs.language) {
    _localeText["default"].setLocale(attrs.language);
  }

  var wrapDiv = dom;

  if (true) {
    wrapDiv = document.createElement('div');
    wrapDiv.style.cssText += ';position:absolute;width:100%;height:100%;left:0;top:0;pointer-events:none';
    wrapDiv.onselectstart = wrapDiv.onmousemove = wrapDiv.ondrag = _BaseUtils["default"].falseFn;
    dom.appendChild(wrapDiv);
  }

  var renderer = (0, _renderer["default"])(wrapDiv, chart);
  renderer.onAdd();
  var PATTERN_GAP = 10,
      TEXT_GAP = 5;
  var emptyDataClipGroup = renderer.group().add();
  renderer.clip(emptyDataClipGroup, renderer.createClip({
    x: 0,
    y: 0,
    width: chartWidth,
    height: chartHeight
  }));
  var emptyDataGroup = renderer.group().addTo(emptyDataClipGroup);
  var emptyDataImage = emptyDataTip.emptyDataImage;

  if (emptyDataImage) {
    return getEmptyDataImage(renderer, emptyDataGroup, emptyDataImage, {
      chartWidth: chartWidth,
      chartHeight: chartHeight
    });
  }

  var patternWidth = 120,
      patternHeight = 125;
  var tipWidth = patternWidth,
      tipHeight = patternHeight + PATTERN_GAP;
  emptyDataTip.content = emptyDataTip.content || []; // 先计算宽高，然后再排版绘制

  var contentArray = emptyDataTip.content.map(function (contentObj) {
    var text = _localeText["default"].i18nText("emptyDataTip"),
        style = _BaseUtils["default"].convertToREMUseDefault16PX(contentObj.style);

    var textDim = _BaseUtils["default"].getTextDimension(text, style, false);

    tipWidth = Math.max(tipWidth, textDim.width);
    return {
      text: text,
      style: style,
      width: textDim.width,
      height: textDim.height
    };
  }); // 绘制图案并设置水平居中

  var patternGroup = renderer.group().attr("transform", "translate(" + (tipWidth - patternWidth) / 2 + ",0)").addTo(emptyDataGroup);
  patternPathArray.forEach(function (pathData) {
    var path = renderer.path().addTo(patternGroup);
    path.attr({
      "d": pathData.d
    }).style({
      "fill": pathData.fill,
      "opacity": pathData.opacity
    });
  }); // 绘制文字并设置偏移

  contentArray.forEach(function (contentObj, index, arr) {
    var x = (tipWidth - contentObj.width) / 2,
        y = tipHeight;
    tipHeight += contentObj.height + (index === arr.length - 1 ? 0 : TEXT_GAP);
    var text = renderer.text().addTo(emptyDataGroup);
    text.style(contentObj.style).attr({
      "dy": 0.85 * contentObj.height,
      "transform": "translate(" + x + "," + y + ")"
    }).textContent(contentObj.text);
  });
  var emptyDataTipTrans = getEmptyDataTipTrans({
    chartWidth: chartWidth,
    chartHeight: chartHeight
  }, {
    tipWidth: tipWidth,
    tipHeight: tipHeight
  });
  emptyDataGroup.attr("transform", emptyDataTipTrans);
  return {
    remove: function () {
      renderer && renderer.remove();
      wrapDiv && _DomUtils["default"].remove(wrapDiv);
      wrapDiv = null;
    },
    renderer: renderer
  };
}

var _default = showEmptyDataTip;
exports["default"] = _default;

/***/ }),
/* 73 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Arc = _interopRequireDefault(__webpack_require__(118));

var _Circle = _interopRequireDefault(__webpack_require__(119));

var _Diamond = _interopRequireDefault(__webpack_require__(120));

var _Image = _interopRequireDefault(__webpack_require__(121));

var _LineEffect = _interopRequireDefault(__webpack_require__(123));

var _Rect = _interopRequireDefault(__webpack_require__(124));

var _Triangle = _interopRequireDefault(__webpack_require__(125));

var _IconLocation = _interopRequireDefault(__webpack_require__(126));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var shapes = {};
shapes['arc'] = _Arc["default"];
shapes['circle'] = _Circle["default"];
shapes['diamond'] = _Diamond["default"];
shapes['iconLocation'] = _IconLocation["default"];
shapes['image'] = _Image["default"];
shapes['lineEffect'] = _LineEffect["default"];
shapes['rect'] = _Rect["default"];
shapes['triangle'] = _Triangle["default"];
var _default = shapes;
exports["default"] = _default;

/***/ }),
/* 74 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Bar = _interopRequireDefault(__webpack_require__(128));

var _Box = _interopRequireDefault(__webpack_require__(131));

var _Bubble = _interopRequireDefault(__webpack_require__(77));

var _ColumnRadar = _interopRequireDefault(__webpack_require__(134));

var _ForceBubble = _interopRequireDefault(__webpack_require__(135));

var _Funnel = _interopRequireDefault(__webpack_require__(136));

var _Line = _interopRequireDefault(__webpack_require__(137));

var _LineMap = _interopRequireDefault(__webpack_require__(138));

var _LineRadar = _interopRequireDefault(__webpack_require__(140));

var _Map = _interopRequireDefault(__webpack_require__(141));

var _MultiPie = _interopRequireDefault(__webpack_require__(142));

var _Pie = _interopRequireDefault(__webpack_require__(143));

var _PointerGauge = _interopRequireDefault(__webpack_require__(144));

var _WordCloud = _interopRequireDefault(__webpack_require__(146));

var _TreeMap = _interopRequireDefault(__webpack_require__(147));

var _ThermometerGauge = _interopRequireDefault(__webpack_require__(148));

var _RingGauge = _interopRequireDefault(__webpack_require__(150));

var _GanttSeries = _interopRequireDefault(__webpack_require__(151));

var _LevelBar = _interopRequireDefault(__webpack_require__(152));

var _Processes = _interopRequireDefault(__webpack_require__(153));

var _TimeAxis = _interopRequireDefault(__webpack_require__(156));

var _Axis = _interopRequireDefault(__webpack_require__(62));

var _CategoryAxis = _interopRequireDefault(__webpack_require__(51));

var _DataSheet = _interopRequireDefault(__webpack_require__(161));

var _DateAxis = _interopRequireDefault(__webpack_require__(89));

var _DrillTools = _interopRequireDefault(__webpack_require__(162));

var _GaugeAxis = _interopRequireDefault(__webpack_require__(163));

var _Geo = _interopRequireDefault(__webpack_require__(164));

var _GradientRangeLegend = _interopRequireDefault(__webpack_require__(178));

var _IntervalRangeLegend = _interopRequireDefault(__webpack_require__(180));

var _Legend = _interopRequireDefault(__webpack_require__(92));

var _AutoTip = _interopRequireDefault(__webpack_require__(181));

var _MultiCategoryAxis = _interopRequireDefault(__webpack_require__(90));

var _PolarAxis = _interopRequireDefault(__webpack_require__(182));

var _Title = _interopRequireDefault(__webpack_require__(186));

var _ToolBar = _interopRequireDefault(__webpack_require__(187));

var _Tooltip = _interopRequireDefault(__webpack_require__(68));

var _ValueAxis = _interopRequireDefault(__webpack_require__(64));

var _Zoom = _interopRequireDefault(__webpack_require__(189));

var _CrossLine = _interopRequireDefault(__webpack_require__(190));

var _PieIndicator = _interopRequireDefault(__webpack_require__(191));

var _PlotScroll = _interopRequireDefault(__webpack_require__(193));

var _component = __webpack_require__(4);

var _SlotGauge = _interopRequireDefault(__webpack_require__(194));

var _Scatter = _interopRequireDefault(__webpack_require__(195));

var _Structure = _interopRequireDefault(__webpack_require__(196));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

// import GeoExport from "../map/geo/GeoExport";
var _registeredCharts = {};
_registeredCharts[_Constants["default"].COLUMN_CHART] = _Bar["default"];
_registeredCharts[_Constants["default"].BAR_CHART] = _Bar["default"];
_registeredCharts[_Constants["default"].BOX_CHART] = _Box["default"];
_registeredCharts[_Constants["default"].BUBBLE_CHART] = _Bubble["default"];
_registeredCharts[_Constants["default"].SCATTER_CHART] = _Scatter["default"];
_registeredCharts[_Constants["default"].COLUMN_RADAR] = _ColumnRadar["default"];
_registeredCharts[_Constants["default"].FORCE_BUBBLE_CHART] = _ForceBubble["default"];
_registeredCharts[_Constants["default"].FUNNEL_CHART] = _Funnel["default"];
_registeredCharts[_Constants["default"].LINE_CHART] = _Line["default"];
_registeredCharts[_Constants["default"].AREA_CHART] = _Line["default"];
_registeredCharts[_Constants["default"].STRUCTURE_CHART] = _Structure["default"];
_registeredCharts[_Constants["default"].LINE_MAP] = _LineMap["default"];
_registeredCharts[_Constants["default"].LINE_RADAR] = _LineRadar["default"];
_registeredCharts[_Constants["default"].POINT_MAP] = _Map["default"];
_registeredCharts[_Constants["default"].AREA_MAP] = _Map["default"];
_registeredCharts[_Constants["default"].HEAT_MAP] = _Map["default"];
_registeredCharts[_Constants["default"].MULTIPIE_CHART] = _MultiPie["default"];
_registeredCharts[_Constants["default"].PIE_CHART] = _Pie["default"];
_registeredCharts[_Constants["default"].POINTER_GAUGE] = _PointerGauge["default"];
_registeredCharts[_Constants["default"].POINTER_SEMI_GAUGE] = _PointerGauge["default"];
_registeredCharts[_Constants["default"].WORD_CLOUD_CHART] = _WordCloud["default"];
_registeredCharts[_Constants["default"].TREEMAP_CHART] = _TreeMap["default"];
_registeredCharts[_Constants["default"].THERMOMETER_GAUGE] = _ThermometerGauge["default"];
_registeredCharts[_Constants["default"].RING_GAUGE] = _RingGauge["default"];
_registeredCharts[_Constants["default"].SLOT_GAUGE] = _SlotGauge["default"];
_registeredCharts[_Constants["default"].GANTT_CHART] = _GanttSeries["default"]; //components

(0, _component.register)(_component.ComponentCst.LEVELBAR, _LevelBar["default"]);
(0, _component.register)(_component.ComponentCst.PROCESSES, _Processes["default"]);
(0, _component.register)(_component.ComponentCst.TIMEAXIS, _TimeAxis["default"]);
(0, _component.register)(_component.ComponentCst.X_AXIS_COMPONENT, _Axis["default"]);
(0, _component.register)(_component.ComponentCst.Y_AXIS_COMPONENT, _Axis["default"]);
(0, _component.register)(_component.ComponentCst.CATEGORY_AXIS_COMPONENT, _CategoryAxis["default"]);
(0, _component.register)(_component.ComponentCst.DATA_SHEET_COMPONENT, _DataSheet["default"]);
(0, _component.register)(_component.ComponentCst.DATE_AXIS_COMPONENT, _DateAxis["default"]);
(0, _component.register)(_component.ComponentCst.DRILL_TOOLS, _DrillTools["default"]);
(0, _component.register)(_component.ComponentCst.GAUGE_AXIS_COMPONENT, _GaugeAxis["default"]); // if(__export__) {
//     register(ComponentCst.GEO_COMPONENT, GeoExport);
// }else{

(0, _component.register)(_component.ComponentCst.GEO_COMPONENT, _Geo["default"]); // }

(0, _component.register)(_component.ComponentCst.GradientRangeLegend, _GradientRangeLegend["default"]);
(0, _component.register)(_component.ComponentCst.INTERVAL_RANGE_LEGEND, _IntervalRangeLegend["default"]);
(0, _component.register)(_component.ComponentCst.LEGEND_COMPONENT, _Legend["default"]);
(0, _component.register)(_component.ComponentCst.MORELABEL_COMPONENT, _AutoTip["default"]);
(0, _component.register)(_component.ComponentCst.MULTI_CATEGORY_AXIS_COMPONENT, _MultiCategoryAxis["default"]);
(0, _component.register)(_component.ComponentCst.RADIUS_AXIS_COMPONENT, _PolarAxis["default"]);
(0, _component.register)(_component.ComponentCst.ANGLE_AXIS_COMPONENT, _PolarAxis["default"]);
(0, _component.register)(_component.ComponentCst.POLAR_COMPONENT, _PolarAxis["default"]);
(0, _component.register)(_component.ComponentCst.TITLE_COMPONENT, _Title["default"]);
(0, _component.register)(_component.ComponentCst.TOOLBAR_COMPONENT, _ToolBar["default"]);
(0, _component.register)(_component.ComponentCst.TOOLTIP_COMPONENT, _Tooltip["default"]);
(0, _component.register)(_component.ComponentCst.VALUE_AXIS_COMPONENT, _ValueAxis["default"]);
(0, _component.register)(_component.ComponentCst.ZOOM_COMPONENT, _Zoom["default"]);
(0, _component.register)(_component.ComponentCst.CROSS_LINE, _CrossLine["default"]);
(0, _component.register)(_component.ComponentCst.PIE_INDICATOR, _PieIndicator["default"]);
(0, _component.register)(_component.ComponentCst.PLOT_SCROLL, _PlotScroll["default"]);

var _default = function _default(name) {
  return _registeredCharts[name];
};

exports["default"] = _default;

/***/ }),
/* 75 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.seriesOfType = seriesOfType;
exports.isAutoRefreshChart = isAutoRefreshChart;

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function seriesOfType(series, type) {
  series = series || [];
  return series.filter(function (ser) {
    return ser.type == type;
  });
} // 树形结构系列或者钻取地图的监控刷新走全局刷新


function isAutoRefreshChart(options) {
  return options.refreshType == _Constants["default"].INCREMENT_TIP_REFRESH && options.chartType != _Constants["default"].MULTIPIE_CHART && options.chartType != _Constants["default"].TREEMAP_CHART && options.chartType != _Constants["default"].STRUCTURE_CHART && !_isDrillDownChart(options);
}

function _isDrillDownChart(options) {
  var seriess = options.series,
      series,
      data;

  if (seriess.length) {
    // 之前看过性能文章，用forEach等方法都没有原生for循环性能好，还是少写forEach啥的了，而且也不好退出
    for (var i = 0, len = seriess.length; i < len; i++) {
      series = seriess[i];
      data = series.data || [];

      if (data.length) {
        for (var j = 0, dataLen = data.length; j < dataLen; j++) {
          if (data[j].drilldown) {
            return true;
          }
        }
      }
    }
  }

  return false;
}

/***/ }),
/* 76 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.verticalPosFix = verticalPosFix;
exports.horizontalPosFix = horizontalPosFix;
exports.adjustAutoChartLabel = adjustAutoChartLabel;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _CoreUtils = __webpack_require__(3);

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BoundsManager = _interopRequireDefault(__webpack_require__(25));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function verticalPosFix(start, end, step, labelDim, labelPos, manager) {
  for (var y = start; step < 0 ? y > end : y < end; y += step) {
    var pos = {
      x: labelPos.x,
      y: y
    };

    if (!manager.isOverlapped(_BaseUtils["default"].makeBounds(pos, labelDim))) {
      return pos;
    }
  }
}

function horizontalPosFix(start, end, step, labelDim, labelPos, manager) {
  for (var x = start; step < 0 ? x > end : x < end; x += step) {
    var pos = {
      x: x,
      y: labelPos.y
    };

    if (!manager.isOverlapped(_BaseUtils["default"].makeBounds(pos, labelDim))) {
      return pos;
    }
  }
}
/**
 * 根据category获取需要标签自动调整的points
 * @param category
 * @param vanchart
 * @returns {*}
 */


function getAutoLabelPointsWithCate(category, vanchart) {
  return vanchart.cateMap[category].filter(function (p) {
    // 柱形图自动时若竖排居内显示，无需重叠调整
    var isVerticalColumnLabel = p.options.dataLabels && vanchart.options.chartType !== _Constants["default"].MULTI_CHARTS && !p.options.dataLabels.useHtml && p.options.dataLabels.align === _Constants["default"].AUTO && p.series.type === _Constants["default"].COLUMN_CHART && p.labelAlign === _Constants["default"].INSIDE; // 折线图x轴为数值轴时，存在labelContent为空的point，无需考虑这样的point

    var isNotEmptyLabelContent = p.labelContent.length !== 0;
    return p.labelPos && !isVerticalColumnLabel && p.options.dataLabels.autoAdjust && isCategoryAxisChart(p.series.type) && isNotEmptyLabelContent;
  });
}

function isCategoryAxisChart(chartType) {
  return chartType === _Constants["default"].BAR_CHART || chartType === _Constants["default"].COLUMN_CHART || chartType === _Constants["default"].AREA_CHART || chartType === _Constants["default"].LINE_CHART;
}

function getAutoLabelPos(points, isHorizontalBaseAxis, toRightBottom) {
  var manager = new _BoundsManager["default"](),
      labelPosArr = [];

  for (var i = 0; i < points.length; i++) {
    var point = points[i];

    var labelPos = point.series._calculateAutoLabelPos(point, point.labelPos, isHorizontalBaseAxis, manager, toRightBottom, true);

    manager.addBounds(_BaseUtils["default"].makeBounds(labelPos, point.labelDim));
    labelPosArr.push(labelPos);
  }

  return labelPosArr;
}

function sortPoints(points, key, isOriginalPos, isDesc) {
  return points.sort(function (a, b) {
    var aLabelPos = isOriginalPos ? a.originalLabelPos : a.labelPos;
    var bLabelPos = isOriginalPos ? b.originalLabelPos : b.labelPos;
    var aPos = key === 'y' ? aLabelPos[key] + a.labelDim.height : aLabelPos[key];
    var bPos = key === 'y' ? bLabelPos[key] + b.labelDim.height : bLabelPos[key];
    return isDesc ? bPos - aPos : aPos - bPos;
  });
}
/**
 * 当标签超出边界时，根据分类将标签位置往中间调整
 * @param vanchart
 * @param isVertical
 * @private
 */


function adjustAutoLabelToMiddle(vanchart, isVertical) {
  var manager = new _BoundsManager["default"]();
  var needAdjustCatePoints = {};

  for (var category in vanchart.cateMap) {
    var points = getAutoLabelPointsWithCate(category, vanchart);
    var isNeedAdjust = points.filter(function (point) {
      return (0, _CoreUtils.isEmptyObj)(point.labelPos);
    }).length !== 0;

    if (isNeedAdjust) {
      needAdjustCatePoints[category] = points;
    } else {
      points.forEach(function (point) {
        manager.addBounds(_BaseUtils["default"].makeBounds(point.labelPos, point.labelDim));
      });
    }
  }

  if ((0, _CoreUtils.isEmptyObj)(needAdjustCatePoints)) {
    return;
  }

  var plotBounds = vanchart.bounds;
  var key = isVertical ? 'y' : 'x';
  var end = isVertical ? plotBounds.height : plotBounds.width;

  for (var cate in needAdjustCatePoints) {
    var catePoints = needAdjustCatePoints[cate];
    var leftTopPoints = [],
        rightBottomPoints = [];
    catePoints.forEach(function (point) {
      var pos = key === 'y' ? point.originalLabelPos[key] + point.labelDim.height : point.originalLabelPos[key];
      pos < end / 2 ? leftTopPoints.push(point) : rightBottomPoints.push(point);
    });
    leftTopPoints = sortPoints(leftTopPoints, key, true);
    rightBottomPoints = sortPoints(rightBottomPoints, key, true, true);
    fixPointLabelPos(leftTopPoints, manager, end, isVertical, true);
    fixPointLabelPos(rightBottomPoints, manager, end, isVertical, false);
  }
}

function fixPointLabelPos(points, manager, end, isVertical, toRightBottom) {
  var step = toRightBottom ? 3 : -3;
  var key = isVertical ? 'y' : 'x';
  points.forEach(function (point) {
    var labelDim = point.labelDim;
    var labelDistance = isVertical ? labelDim.height : labelDim.width;
    var posEnd = toRightBottom ? end - labelDistance : 0;
    var originalLabelPos = point.originalLabelPos;
    var startPos = toRightBottom ? Math.max(0, originalLabelPos[key]) : Math.min(end - labelDistance, originalLabelPos[key]);
    var testPos = isVertical ? verticalPosFix(startPos, posEnd, step, labelDim, originalLabelPos, manager) : horizontalPosFix(startPos, posEnd, step, labelDim, originalLabelPos, manager);
    point.labelPos = testPos || {};

    if (testPos) {
      manager.addBounds(_BaseUtils["default"].makeBounds(testPos, labelDim));
    }
  });
}
/**
 * 对柱形图，条形图，面积图，折线图的标签，开启标签重叠自动调整后进行位置调整
 * 先将所有标签按照原位置排序，然后获取向上调整后的标签和向下调整后的标签，
 * 向上向下调整后哪种方式标签显示的多，就选择哪种方式调整；
 * 再当标签超出边界时，根据分类将标签位置往中间调整
 * @param vanchart
 * @private
 */


function adjustAutoChartLabel(vanchart) {
  var allPoints = [];

  for (var category in vanchart.cateMap) {
    var points = getAutoLabelPointsWithCate(category, vanchart);
    allPoints = allPoints.concat(points);
  }
  /**
   * CHART-1532
   * 在所有包含x、y轴的图表类型当中，就条形图最特殊，它的基础轴是y轴，
   * 所以在这里将xAxis函数换成baseAxis函数
   */


  var isHorizontalBaseAxis = vanchart.baseAxis() && vanchart.baseAxis().isHorizontal();
  var key = isHorizontalBaseAxis ? 'y' : 'x';
  allPoints = sortPoints(allPoints, key); // 往下调整(条形图往右调整)

  var labelPosToRightBottom = getAutoLabelPos(allPoints, isHorizontalBaseAxis, true);
  var unVisibleLabelPosToRightBottom = labelPosToRightBottom.filter(function (labelPos) {
    return (0, _CoreUtils.isEmptyObj)(labelPos);
  }); // 往上调整(条形图往左调整)

  allPoints.reverse();
  var labelPosToLeftTop = getAutoLabelPos(allPoints, isHorizontalBaseAxis, false);
  var unVisibleLabelPosToLeftTop = labelPosToLeftTop.filter(function (labelPos) {
    return (0, _CoreUtils.isEmptyObj)(labelPos);
  });
  var isToRightBottom = unVisibleLabelPosToLeftTop.length > unVisibleLabelPosToRightBottom.length;
  var labelPosArr = isToRightBottom ? labelPosToRightBottom.reverse() : labelPosToLeftTop;
  allPoints.forEach(function (point, index) {
    point.originalLabelPos = point.labelPos;
    point.labelPos = labelPosArr[index];
  });
  adjustAutoLabelToMiddle(vanchart, isHorizontalBaseAxis);
}

/***/ }),
/* 77 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Series = _interopRequireDefault(__webpack_require__(13));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Mitisky on 16/3/14.
 */
var BUBBLE_INIT_TIME = 500;
var BUBBLE_UPDATE_TIME = 500;
var BUBBLE_EXIT_TIME = 300;
var BUBBLE_RE_SHOW_TIME = 300;
var CHOSEN_TIME = 200;
var CHOSEN_EASE = _BezierEasing["default"].custom["ease-out-back"];
var OUT_EASE = _BezierEasing["default"].css["ease-out"];

var Bubble = _Series["default"].extend({
  doLayout: function () {
    this._calculateBubblePosition();
  },
  useCanvas: function () {
    // 力学气泡图在渲染系列之前也使用当前的方法来判断是否需要使用canvas来渲染，
    // 但是力学气泡图可没有canvas的绘制逻辑，然后就会报错……
    return this.vanchart.chartType() !== _Constants["default"].FORCE_BUBBLE_CHART && this.options.large;
  },
  //用来计算百分比的指标的名字,相当于value的含义
  getTargetKey: function () {
    return 'size';
  },
  isNullValue: function (point) {
    var options = point.options;

    if (this.vanchart.isMap()) {
      return options.size == '-' || (0, _CoreUtils.hasNotDefined)(options.size);
    } else {
      return options.x == '-' || options.y == '-' || options.size == '-' || (0, _CoreUtils.hasNotDefined)(options.size) || !point.isLogAxisValidValue();
    }
  },
  _getPointKey: function (point) {
    var option = point.options || point;
    return this.vanchart.isMap() ? point.name : '' + option.x + option.y;
  },
  //计算位置的时候 顺道儿就给了
  _calculateLabelPos: function () {},
  //shine:这边的系列最大最小值用来算气泡半径，特殊：绝对值等
  _calculateMinMax4Radius: function () {
    var series = this,
        points = series.points;
    var seriesMinSize = Number.MAX_VALUE,
        seriesMaxSize = -Number.MAX_VALUE;

    for (var index = 0, len = points.length; index < len; index++) {
      var point = points[index];
      var value = point.getTargetValue();

      if (!point.visible || point.isNull) {
        continue;
      } //shine:这个就是当前点要不要展示负气泡，拿系列的属性做什么
      //过滤 是负气泡且不展示负气泡的点


      if (value < 0 && !point.options.displayNegative) {
        continue;
      } //过滤 设置了直径，不参与计算的点


      if (point.options.minSize || point.options.maxSize) {
        continue;
      } //todo:这个0目测有问题，可能因为这个奇怪的点把100-200扩展成0-200


      seriesMaxSize = Math.max(seriesMaxSize, isNaN(value) ? 0 : Math.abs(value));
      seriesMinSize = Math.min(seriesMinSize, isNaN(value) ? 0 : Math.abs(value));
    }

    series.seriesAbsMinValue = seriesMinSize;
    series.seriesAbsMaxValue = seriesMaxSize;
  },
  _calculateBubbleRadius: function () {
    var series = this,
        options = series.options; //这边需要的是合并后的属性

    var seriesMaxDiameter = Math.max(series.maxSize, series.minSize);
    var seriesMinDiameter = Math.min(series.minSize, series.maxSize);
    var sizeByArea = options.sizeBy == _Constants["default"].SIZE_BY_AREA; //系列条件属性设置最大最小半径，则气泡半径根据该系列最大最小size计算

    var max = this.seriesAbsMaxValue,
        min = this.seriesAbsMinValue;

    if (!this._sizeByCurrentSeries()) {
      //系列没有单独设置最大最小值，去算整个图表的。
      var minMax = this._calculateChartMinMax();

      max = _BaseUtils["default"].pick(minMax.max, minMax[1]);
      min = _BaseUtils["default"].pick(minMax.min, minMax[0]);
    }

    var denominator = max - min;
    var unit = sizeByArea ? (seriesMaxDiameter * seriesMaxDiameter - seriesMinDiameter * seriesMinDiameter) / denominator : (seriesMaxDiameter - seriesMinDiameter) / denominator;
    unit = isFinite(unit) ? unit : 0;

    var scale = _BaseUtils["default"].pick(this.vanchart.scale, 1);

    this.points.forEach(function (point) {
      var temp = unit * (Math.abs(point.value) - min);
      var diameter = sizeByArea ? Math.sqrt(seriesMinDiameter * seriesMinDiameter + temp) : seriesMinDiameter + temp;

      if (point.options.minSize || point.options.maxSize) {
        //shine:这个判断的意思是如果气泡图的某个点里面设置了最大最小半径，就用它自己的，不用和其他点一起算半径了
        //所以不要乱改逻辑
        var _tmp = isNaN(point.options.minSize) ? point.options.maxSize : point.options.minSize;

        diameter = sizeByArea ? Math.sqrt(_tmp) * 2 : _tmp;
      }

      diameter = point.getTargetValue() < 0 && !point.options.displayNegative ? 0 : diameter;
      point.radius = diameter / 2 * scale;
    });
  },
  //这边需要的是合并属性前的原始属性
  _sizeByCurrentSeries: function () {
    return (0, _CoreUtils.hasDefined)(this.options.minSize) && (0, _CoreUtils.hasDefined)(this.options.maxSize);
  },
  //这个是用来算半径的，特殊：绝对值&不包含自定义直径的系列
  _calculateChartMinMax: function () {
    var series = this.vanchart.seriesOfType(this.type);
    var minSize = Number.MAX_VALUE; //所有数据的最大最小值

    var maxSize = -minSize;
    series.forEach(function (sery) {
      if (!sery._sizeByCurrentSeries()) {
        minSize = Math.min(minSize, sery.seriesAbsMinValue);
        maxSize = Math.max(maxSize, sery.seriesAbsMaxValue);
      }
    });
    return {
      min: minSize,
      max: maxSize
    };
  },
  _calculateBubblePosition: function () {
    var isInverted = this.vanchart.isInverted();
    var xAxis = this.xAxis,
        yAxis = this.yAxis;
    this.points.forEach(function (point) {
      var options = point.options;
      var det = xAxis.scale.rangeBand ? xAxis.scale.rangeBand() / 2 : 0;
      var t1 = xAxis.scale(xAxis.getAxisValue(options.x)) + det;
      var t2 = yAxis.scale(yAxis.getAxisValue(options.y));
      point.posX = isInverted ? t2 : t1;
      point.posY = isInverted ? t1 : t2;
      var valid = point.labelDim && !point.isNull && !(point.getTargetValue() < 0 && !options.displayNegative);

      if (valid && options.dataLabels && options.dataLabels.enabled) {
        point.labelPos = {
          x: point.posX - point.labelDim.width / 2,
          y: point.posY - point.labelDim.height / 2
        };
      }
    });
  },
  getTrendLineXYValues: function (sery) {
    return this._getNormalTrendLineXYValues(sery);
  },
  _getFixedPos: function (point) {
    var vanchart = this.vanchart,
        plotBounds = vanchart.bounds,
        radius = point.radius || 0;
    var pos;

    if (vanchart.isMap()) {
      var latlng = point.getLatLng();

      if (!latlng) {
        return;
      }

      pos = vanchart.latLngToContainerPoint(latlng);
    } else {
      pos = {
        x: plotBounds.x + point.posX,
        y: plotBounds.y + point.posY
      };
    }

    radius = (radius + 1) / 1.414;
    return [pos.x + radius, pos.y + radius];
  },

  /**
   * @override Series.calcMoreLabelPosition
   * @param  {[type]} point [description]
   * @return {[type]}       [description]
   */
  calcMoreLabelPosition: function (point, moreLabelDim) {
    var chartBounds = this.vanchart.bounds;
    var startX = point.posX,
        startY = point.posY;
    return {
      startX: startX + chartBounds.x,
      startY: startY + chartBounds.y,
      direction: "top"
    };
  },
  getPointGraphicKey: function () {
    return 'circle';
  },
  effectAnimation: function (d) {
    _EffectHelper["default"].bubbleEffectAnimation(d, this.vanchart.isMap());
  },
  getDefaultEffectTime: function () {
    return _EffectHelper["default"].MARKER_EFFECT_TIME;
  },
  getPointInitAttr: function (point) {
    return {
      'transform': _BaseUtils["default"].makeTranslate([point.posX, point.posY]),
      'r': 0
    };
  },
  getPointInitAnimationAttr: function (point) {
    return {
      delay: point.delayTime || 0,
      ease: 'bounce',
      duration: BUBBLE_INIT_TIME,
      attr: {
        'r': point.radius
      }
    };
  },
  getPointReShowAnimationAttr: function (point) {
    return {
      ease: 'bounce',
      duration: BUBBLE_RE_SHOW_TIME,
      attr: {
        'r': point.radius
      }
    };
  },
  getPointUpdateAnimationAttr: function (point) {
    return {
      ease: 'back-out',
      duration: BUBBLE_UPDATE_TIME,
      attr: {
        'r': point.radius,
        'transform': _BaseUtils["default"].makeTranslate({
          x: point.posX,
          y: point.posY
        })
      }
    };
  },
  getPointDropAnimationAttr: function () {
    return {
      ease: 'back-in',
      duration: BUBBLE_EXIT_TIME,
      attr: {
        'r': 0
      }
    };
  },
  _getShadowFilter: function () {
    var series = this,
        vanchart = series.vanchart,
        renderer = vanchart.renderer;
    vanchart.bubbleShadowFilter = vanchart.bubbleShadowFilter || renderer.createDropShadowFilter(0, 0, 0.2, 2);
    return renderer.toPatternProperty(vanchart.bubbleShadowFilter);
  },
  getStyle: function (p) {
    var series = p.series;
    var style = {
      'stroke': p.mouseOverColor,
      'stroke-opacity': 0,
      'stroke-width': 0,
      'fill': p.color,
      'fill-opacity': p.opacity
    }; //todo ie10加阴影报错

    if (p.options.shadow && !_Browser["default"].ie) {
      style.filter = series._getShadowFilter();
    }

    return style;
  },
  getHighLightStyle: function (p) {
    return {
      'stroke': p.mouseOverColor,
      'stroke-opacity': 0.35,
      'stroke-width': 6,
      'fill': p.mouseOverColor,
      'fill-opacity': p.opacity + 0.35
    };
  },
  getPressedStyle: function (p) {
    return {
      'stroke': p.mouseOverColor,
      'stroke-opacity': 0.35,
      'stroke-width': 6,
      'fill': p.clickColor,
      'fill-opacity': p.clickOpacity
    };
  },
  _onPointMouseOver: function (point) {
    var series = point.series,
        style = series.getHighLightStyle(point);

    series._onState(point, true, CHOSEN_EASE, style);
  },
  _onPointMouseOut: function (point) {
    var series = point.series,
        style = series.getStyle(point);

    series._onState(point, false, OUT_EASE, style);
  },
  _onState: function (point, isChosen, ease, style) {
    point._isChosen = isChosen;
    var series = point.series,
        vanchart = series.vanchart;

    if (series.vanchart.isLargeMode()) {
      return;
    }

    if (vanchart.isMap()) {
      point._mapPointOnMouseState(isChosen, CHOSEN_TIME, ease, style);

      point.textLayers && point.textLayers.forEach(function (layer) {
        layer._fontSizeState(isChosen, CHOSEN_TIME, CHOSEN_EASE);
      });
    } else {
      point.graphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
        ease: ease,
        duration: CHOSEN_TIME,
        style: style,
        attr: {
          'r': point.radius + (isChosen ? 1 : 0)
        }
      });

      series._labelFontSizeState(point, isChosen, CHOSEN_TIME, ease);
    }
  },
  getDefaultTooltipFormatter: function () {
    return this.vanchart.isMap() ? {
      areaNameFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{NAME}{SERIES}{VALUE}{SIZE}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    } : {
      XFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      YFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{SERIES}{X}{Y}{SIZE}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      sizeFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = Bubble;
exports["default"] = _default;

/***/ }),
/* 78 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Series = _interopRequireDefault(__webpack_require__(13));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _component = __webpack_require__(4);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/12/31.
 */
var Radar = _Series["default"].extend({
  refresh: function (options, index) {
    _Series["default"].prototype.refresh.call(this, options, index);

    this.columnType = this.options.columnType;
    this.stack = this.columnType ? 'radar-column' + this.options.stack : this.options.stack;
    return this;
  },
  _getAxisTypes: function () {
    return ['angleAxis', 'radiusAxis', 'polar'];
  },
  getBaseAxisType: function () {
    return 'angleAxis';
  },
  _bindAxis: function () {
    var series = this,
        seriesOptions = series.options,
        vanchart = series.vanchart;

    series._getAxisTypes().forEach(function (axisType) {
      if (vanchart[axisType]) {
        var targetAxis = vanchart[axisType](seriesOptions['polar']);

        if (targetAxis) {
          targetAxis.series.push(series);
          series[axisType] = targetAxis;
        }
      }
    });
  },
  _getDefaultFillColorOpacity: function () {
    return this.options.columnType ? 1 : 0.15;
  },
  _getTranslate: function () {
    return this.getCenter();
  },
  getCenter: function () {
    return this.polar && this.polar.center;
  },
  getRadius: function () {
    return this.polar && this.polar.radius;
  },
  doLayout: function () {
    var series = this,
        polar = series.polar,
        radiusAxis = polar.radiusAxis,
        angleAxis = polar.angleAxis;
    var center = this.getCenter(),
        radius = this.getRadius(),
        piece = angleAxis.piece,
        valueScale = radiusAxis.scale,
        cateScale = angleAxis.scale;
    var indicator = radiusAxis.indicator;

    var scaleValueNotNaN = function (num) {
      return isNaN(valueScale(num)) ? 0 : valueScale(num);
    }; //todo 先排序作用是


    series.points.sort(function (pointA, pointB) {
      return cateScale(pointA.category) - cateScale(pointB.category);
    });
    var options;
    series.points.forEach(function (point) {
      options = point.options;
      var category = point.category,
          innerValue = options.y0,
          outerValue = point.value + options.y0; // calc point inner-outer radius for every categroy when use indicastor

      point.innerRadius = indicator ? series._cateValueScale(category, innerValue) : scaleValueNotNaN(innerValue);
      point.outerRadius = indicator ? series._cateValueScale(category, outerValue) : scaleValueNotNaN(outerValue);
      point.animateInitRadius = radiusAxis.getStartPos();
      point.radian = cateScale(point.category) * piece;

      var pos = series._getArcPoint(point.outerRadius, point.radian);

      point.posX = pos[0];
      point.posY = pos[1];

      this._calcLabelPos(point);
    }, this);
    series.pathSegment = series._getPathSegment(series.points, series.options.connectNulls);
  },
  drawPolarAxis: function () {
    this._renderPolarAxis();
  },
  _renderPolarAxis: function () {
    var vanchart = this.vanchart;
    vanchart.components[_component.ComponentCst.POLAR_COMPONENT] && vanchart.components[_component.ComponentCst.POLAR_COMPONENT].render();
  },
  _calculateLabelPos: function () {},
  getTargetKey: function () {
    return 'y';
  },
  _createGroup: function (renderer, vanchart) {
    return renderer.group().addTo(vanchart.seriesGroup);
  },
  _getPathSegment: function (dataPoints, connectNulls) {
    var series = this,
        polar = series.polar,
        angleAxis = polar.angleAxis,
        cateScale = angleAxis.scale;
    dataPoints = [].concat(dataPoints);
    dataPoints.sort(function (pointA, pointB) {
      return cateScale(pointA.category) - cateScale(pointB.category);
    });
    var pathSeg = [];
    var tmp = [];

    if (connectNulls) {
      pathSeg.push(tmp);
      dataPoints.forEach(function (dataPoint) {
        if (!dataPoint.isNull) {
          tmp.push([dataPoint.posX, dataPoint.posY]);
        }
      });
    } else {
      var startIndex = 0;
      var count = dataPoints.length;

      for (var index = count - 1; index > 0; index--) {
        var current = dataPoints[index];
        var pre = dataPoints[index - 1];

        if (!current.isNull && pre.isNull) {
          startIndex = index;
        }
      }

      for (var index = 0; index < count; index++) {
        var dataPoint = dataPoints[(index + startIndex) % count];

        if (dataPoint.isNull && tmp.length) {
          if (tmp.length > 1) {
            pathSeg.push(tmp);
          }

          ;
          tmp = [];
        } else if (!dataPoint.isNull) {
          tmp.push([dataPoint.posX, dataPoint.posY]);
        }
      }

      if (tmp.length) {
        pathSeg.push(tmp);
      }
    }

    return pathSeg;
  },
  _getRadarSeriesPath: function (pathSeg, connectNulls, toCenter) {
    var path = '';
    var tmp = [];

    if (pathSeg.length === 1) {
      tmp = pathSeg[0];
      var fullShape = tmp.length == this.angleAxis.getCategoryCount() || connectNulls;
      toCenter = !fullShape && toCenter;
      path = toCenter ? 'M0,0' : '';

      for (var i = 0, count = tmp.length; i < count; i++) {
        var mOrl = i || toCenter ? 'L' : 'M';
        path += mOrl + _BaseUtils["default"].dealFloatPrecision(tmp[i][0]) + "," + _BaseUtils["default"].dealFloatPrecision(tmp[i][1]);
      }

      path += fullShape || toCenter ? 'Z' : '';
    } else {
      pathSeg.forEach(function (tmp) {
        path += toCenter ? 'M0,0' : '';
        tmp.forEach(function (pos, i) {
          path += (i || toCenter ? 'L' : 'M') + _BaseUtils["default"].dealFloatPrecision(pos[0]) + "," + _BaseUtils["default"].dealFloatPrecision(pos[1]);
        });
        path += toCenter ? 'Z' : '';
      });
    }

    return path;
  },
  _getInitPathSegment: function (pathSeg) {
    var init = [];
    pathSeg.forEach(function (seg) {
      var tmp = [];
      init.push(tmp);
      seg.forEach(function () {
        tmp.push([0, 0]);
      });
    });
    return init;
  },
  // when use indicator, domain of each categroy need to calc one by one
  _cateValueScale: function (cate, value) {
    var series = this,
        radiusAxis = series.radiusAxis,
        cateScale = radiusAxis._cateScale;
    var domain; // get domain value of specific category

    radiusAxis._cateDomain.forEach(function (d) {
      if (d.name === cate) {
        domain = d.domain;
      }
    }); // calc scale value


    cateScale.domain(domain);
    return isNaN(cateScale(value)) ? 0 : cateScale(value);
  }
});

var _default = Radar;
exports["default"] = _default;

/***/ }),
/* 79 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Series = _interopRequireDefault(__webpack_require__(13));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Point = _interopRequireDefault(__webpack_require__(46));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 16/8/9.
 * 树状系列
 */
var LABEL_GAP = 2;

var TreeSeries = _Series["default"].extend({
  refresh: function (options, index) {
    _Series["default"].prototype.refresh.call(this, options, index); //chart type specific attributes


    this._refresh();

    this._initChildren();

    return this;
  },
  // Tree data's key of children is varied,
  // so '_initChildren' may be varied;
  // 'visitBefore' is intended for initializing some property like colors;
  // 'visitAfter' for calculating.
  _initChildren: function () {
    this.traverseInitData(this.visitBefore, null); // make it as normal series

    this.points = this.root.children;
    this.root.options.tooltip = null;
  },
  _getPointKey: function (point) {
    return point.name;
  },
  //用来计算百分比的指标的名字,相当于value的含义
  getTargetKey: function () {
    return 'value';
  },
  _getChildrenKey: function () {
    return 'children';
  },
  traverseData: function (root, visitBefore, visitAfter) {
    // get depth, parent, ancestor, height
    // 'ancestor' is depth 1 node (for legend).
    var series = this;

    function dfsData(node, depth, parent, ancestor) {
      if (!node.children) {
        node.children = node.options[series._getChildrenKey()];
      }

      var c = node.children;
      node.parent = parent;
      node.depth = depth;
      node.level = depth;
      node.height = 0;
      node.ancestor = ancestor;
      visitBefore && visitBefore.call(series, node);

      if (c && (n = c.length)) {
        var i = -1,
            n;

        while (++i < n) {
          if (c[i] instanceof _Point["default"]) {// c[i].refresh();
          } else {
            c[i] = new _Point["default"](c[i], root.series);
          } // ancestor's ancestor is itself


          if (depth === 0) {
            ancestor = c[i];
          }

          dfsData(c[i], depth + 1, node, ancestor);
          node.height = Math.max(node.height, c[i].visible ? c[i].height + 1 : 0);
        }
      }

      visitAfter && visitAfter.call(series, node);
    }

    dfsData(root, 0, null, null);
  },
  traverseInitData: function (visitBefore, visitAfter) {
    // get depth, parent, ancestor, height
    // 'ancestor' is depth 1 node (for legend).
    var series = this;
    var rootOptions = {
      children: this.options.data,
      name: this.name
    };

    if (this.root) {
      this.root.refresh(rootOptions);
    } else {
      this.root = new _Point["default"](rootOptions, series);
    }

    function dfsData(node, nodeOptions, depth, parent, ancestor) {
      var data = nodeOptions[series._getChildrenKey()];

      node.parent = parent;
      node.depth = depth;
      node.level = depth; // 下次全改成level好了→_→

      node.height = 0;
      node.ancestor = ancestor;
      node.seriesName = series.name;
      node.children = node.children || [];
      visitBefore && visitBefore.call(series, node); // todo, diff algorithm and unit test

      if ((0, _CoreUtils.hasDefined)(data)) {
        var newChildrens = [];

        for (var i = 0, len = data.length; i < len; i++) {
          var refresh = false;
          var child;

          if (node.children.length) {
            node.children.forEach(function (point) {
              var pointkey = series._getPointKey(point);

              if ((0, _CoreUtils.hasDefined)(pointkey) && pointkey == series._getPointKey(data[i])) {
                point._lastValue = point.options[series.getTargetKey()];
                point.refresh(data[i]);
                refresh = true;
                child = point;
                newChildrens.push(point);
              }
            });
          }

          if (!refresh) {
            child = new _Point["default"](data[i], series);
            newChildrens.push(child);
          } // ancestor's ancestor is itself


          if (depth === 0) {
            ancestor = child;
          }

          child.index = i;
          dfsData(child, data[i], depth + 1, node, ancestor);
          node.height = Math.max(node.height, child.visible ? child.height + 1 : 0);
        }

        for (var j = 0, size = node.children.length; j < size;) {
          if (_BaseUtils["default"].indexOf(newChildrens, node.children[j]) === -1) {
            node.children[j].clearChild(); // child is removed in clearChild;

            size--;
          } else {
            j++;
          }
        } // parent: {value: 123} ----> parent: {children: [1,2,3], value: 123}


        if (series.type === _Constants["default"].TREEMAP_CHART && node.children.length === 0 && newChildrens.length) {
          node.remove();
          node.visible = true;
        }
        /**
         * TODO
         * 不好好搞个diff后患无穷……
         *  I. data diff:
         *     树状结构添删改
         * II. data - dom diff:
         *     现在data = dom，data删除即dom删除
         *     但是如上，data保留，dom不需要，所以一一严格对应并不完全对
         *     还是正紧搞diff好，也可提高dom效率
         */


        node.children = newChildrens;
      } else {
        // parent: {children: [1,2,3], value: 123} ----> parent: {value: 123}
        var len = node.children.length;

        while (--len > -1) {
          node.children[len].clearChild();
        }
      }

      visitAfter && visitAfter.call(series, node);
    }

    dfsData(this.root, rootOptions, 0, null, null);
  },
  visitBefore: function (node) {
    if (node.depth === 1) {
      node.color = this.vanchart.getDefaultSeriesColor(node.name);
    }
  },
  visitAfter: function () {},
  drawPoint: function (point, delay) {
    delay = delay || 0;
    var shouldBeVisible = point.isVisible();
    var currentVisibleState = point.graphic && point.graphic.isVisible();

    if (shouldBeVisible === currentVisibleState) {
      point.graphic && this._drawUpdatePoints(point, delay);
    } else if (shouldBeVisible && !currentVisibleState) {
      this._drawEnterPoints(point);
    } else if (!shouldBeVisible && currentVisibleState) {
      this._drawExitPoints(point);
    }
  },
  _calculatePercentage: function (points, key) {
    var total = 0;
    points.forEach(function (d) {
      total += Math.abs(d[key]);
    });
    total = total > 0 ? total : 1;
    points.forEach(function (point) {
      point.percentage = Math.abs(point[key]) / total;
    });
  },
  _onPointMouseOver: function (point) {
    var series = point.series,
        vanchart = series.vanchart,
        hoverPoint = vanchart.hoverPoint;

    if (hoverPoint) {
      this._onPointMouseOut(hoverPoint);
    }

    if (!point.depth) {
      return;
    }

    series.onPointMouseOver(point);
    vanchart.hoverPoint = point;
  },
  _onPointMouseOut: function (point) {
    var series = point.series;
    series.onPointMouseOut(point);
    series.vanchart.hideTooltip();
  },
  isSeriesAccumulated: function () {
    return true;
  },
  getLegendKey: function (point) {
    //CHART-1850 初始的parent应该为他本身
    //解决TreeSeries只有一个层级时bug
    var parent = point;

    while (parent && parent.parent != this.root) {
      parent = parent.parent;
    }

    return parent ? parent.name : '';
  },
  isTreeSeries: function () {
    return true;
  }
});

var _default = TreeSeries;
exports["default"] = _default;

/***/ }),
/* 80 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Series = _interopRequireDefault(__webpack_require__(13));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _BoundsManager = _interopRequireDefault(__webpack_require__(25));

var _EnvUtils = __webpack_require__(2);

var _dataLabelFormatter = _interopRequireDefault(__webpack_require__(24));

var _VanChartLabelBorder = __webpack_require__(36);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/3/20.
 */
var HOVER_PERCENT = 1.1;
var LABEL_GAP = 2;
var DECREASE = [0.9, 0.85, 0.8, 0.75, 0.7, 0.65, 0.6, 0.55, 0.5];
var RIGHT_TOP = _Constants["default"].RIGHT_TOP;
var RIGHT_BOTTOM = _Constants["default"].RIGHT_BOTTOM;
var LEFT_TOP = _Constants["default"].LEFT_TOP;
var LEFT_BOTTOM = _Constants["default"].LEFT_BOTTOM;
var STEP = Math.PI / 180;
var _default = {
  // calculate pie/multiPie label position
  // 3 things: outside labels pos,
  //           inside labels pos,
  //           lead lines;
  //
  // outside labels may adjust the chart's radius
  // 3 steps for outside labels:
  // 1. ignore minimal arc labels to content each part's height (4 parts);
  // 2. place labels, no overlap (regardless of part bounds)
  // 3. (when not fixed) test if all labels' bounds are within this chart's bounds.
  //    if not, decrease the radius, return to step 1.
  calculateLabelInfo: function (point) {
    (0, _dataLabelFormatter["default"])(point);
    (0, _VanChartLabelBorder.fixLabelDimWithBorder)(point);
  },
  _fixLocation: function (loc) {
    if (loc === LEFT_TOP || loc === LEFT_BOTTOM) {
      return _Constants["default"].RIGHT_TO_LEFT;
    }

    return _Constants["default"].LEFT_TO_RIGHT;
  },

  /**
   * place outside labels, get new radius if needed
   * @param {Array} outPoints
   * @param {object} bounds
   * @param {Array} center
   * @param {number} [radius]
   * @returns {number} radius Original radius or new radius
   */
  calcOutsideLabel: function (outPoints, bounds, center, radius) {
    var series = this;
    var pointsGroups = {};
    outPoints.map(function (p) {
      var loc = series.getLocByArc(series.getCenterAngle(p));
      p.location = series._fixLocation(loc);
      pointsGroups[loc] = pointsGroups[loc] || [];
      !p.isNull && pointsGroups[loc].push(p); // @CHART-1369
    });

    if (radius) {
      pointsGroups = series.ignoreMin(pointsGroups, radius); // step 1

      series.placeOutSideLabels(pointsGroups, radius); // step 2

      return radius;
    } else {
      radius = Math.min(center[0] - bounds.x, bounds.x + bounds.width - center[0], center[1] - bounds.y, bounds.y + bounds.height - center[1]);

      for (var i = 0, len = DECREASE.length; i < len; i++) {
        var usedR = radius * DECREASE[i];
        var usedPointsG = series.ignoreMin(pointsGroups, usedR); // step 1

        series.placeOutSideLabels(usedPointsG, usedR); // step 2

        if (series.testWithinBounds(usedPointsG, center, bounds)) {
          // step 3
          break;
        }
      }

      return usedR;
    }
  },
  calculateInsideLabelBounds: function (inPoints) {
    var series = this;
    inPoints.map(function (a, i) {
      var node = inPoints[i];
      var center = series.getCenterPoint(node);
      var x = center[0] - node.labelDim.width / 2;
      var y = center[1] - node.labelDim.height / 2;
      node.labelPos = {
        x: x,
        y: y
      };
    });

    if (this.vanchart.isMobileFlow()) {
      var manager = new _BoundsManager["default"]();
      inPoints.map(function (point) {
        if (!point.labelPos) {
          return;
        }

        var b = _BaseUtils["default"].makeBounds(point.labelPos, point.labelDim);

        if (manager.isOverlapped(b)) {
          point.labelPos = null;
        } else {
          manager.addBounds(b);
        }
      });
    }
  },
  calculateLeadLineStartPos: function (outPoints) {
    var series = this;
    outPoints.map(function (arcPoint) {
      var radius = series._getOuterRadius(arcPoint);

      var centerArc = series.getCenterAngle(arcPoint);

      if (arcPoint.labelPos) {
        arcPoint.labelPos.startPos = {
          x: (radius + 1) * Math.sin(centerArc),
          y: (radius + 1) * Math.cos(centerArc + Math.PI)
        };
      }
    });
  },
  getCenterAngle: function (node) {
    var rotate = this.chartInfo.rotate || 0;
    var centerAngle = rotate + (this._getStartAngle(node) + this._getEndAngle(node)) / 2;
    return _BaseUtils["default"].makeValueInRange(0, 2 * Math.PI, centerAngle);
  },
  getCenterRadius: function (node) {
    var innerRadius = this._getInnerRadius(node),
        outerRadius = this._getOuterRadius(node);

    return innerRadius + (outerRadius - innerRadius) / 2;
  },
  getCenterPoint: function (node) {
    var centerAngle = this.getCenterAngle(node),
        centerR = this.getCenterRadius(node);
    return this._getArcPoint(centerR, centerAngle);
  },
  getLocByArc: function (arc) {
    arc = arc % (2 * Math.PI);

    if (arc < Math.PI / 2) {
      return RIGHT_TOP;
    } else if (arc < Math.PI) {
      return RIGHT_BOTTOM;
    } else if (arc < 3 * Math.PI / 2) {
      return LEFT_BOTTOM;
    } else {
      return LEFT_TOP;
    }
  },
  // ignore min for 4 parts
  ignoreMin: function (pointsGroups, radius) {
    var result = {};

    for (var i in pointsGroups) {
      pointsGroups[i].map(function (p) {
        p.labelPos = null;
      });
      result[i] = this._ignoreMinArcLabel(radius, pointsGroups[i]);
    }

    return result;
  },
  // ignore 1 part
  _ignoreMinArcLabel: function (radius, arcs) {
    var totalHeight = 0,
        i,
        len;

    for (i = 0, len = arcs.length; i < len; i++) {
      var labelDim = arcs[i].labelDim;
      totalHeight += labelDim.height;
    } //高度不够，需要省略一些标签


    if (radius * 1.2 < totalHeight) {
      var det = totalHeight - radius * 1.2;
      arcs.sort(function (a, b) {
        return a.value - b.value;
      });

      for (i = 0, len = arcs.length; i < len; i++) {
        if (det < 0) {
          break;
        }

        var labelHeight = arcs[i].labelDim.height;
        det -= labelHeight;
      }

      arcs = arcs.slice(i, arcs.length);
    }

    var series = this;
    arcs.sort(function (a, b) {
      return series.getCenterAngle(a) - series.getCenterAngle(b);
    });
    return arcs;
  },
  placeOutSideLabels: function (pointsGroups, radius) {
    var series = this;
    Object.keys(pointsGroups).map(function (key) {
      series.findNiceBounds(true, pointsGroups[key], radius, key) || series.findNiceBounds(false, pointsGroups[key], radius, key);
    }); // here MUST be true.
    // for we have ignored min arcs, the problem is how to place them.
    // the solution now is incomplete though.
    // return true;
  },
  findNiceBounds: function (isAngleIncrease, arcPoints, usedR, location) {
    var outerR = usedR * 1.2;
    var hWidth = usedR * 0.1;

    var angleRange = this._getStartAndEndAngle(location);

    var searchEnd = isAngleIncrease ? angleRange.endAngle : angleRange.startAngle;
    var step = isAngleIncrease ? STEP : -STEP;
    var preBounds;
    var preArc;
    arcPoints.map(function (p) {
      p.labelPos = null;
    });

    for (var i = 0, len = arcPoints.length; i < len; i++) {
      var pointIndex = isAngleIncrease ? i : len - i - 1;
      var compare = isAngleIncrease ? Math.max : Math.min;
      var point = arcPoints[pointIndex];
      var labelDim = point.labelDim;
      var centerArc = this.getCenterAngle(point);
      centerArc = preArc ? compare(centerArc, preArc) : centerArc;
      var found = false;

      for (var arc = centerArc; isAngleIncrease ? arc <= searchEnd : arc >= searchEnd; arc += step) {
        var centerX = outerR * Math.sin(arc);
        var centerY = outerR * Math.cos(arc + Math.PI);

        var bounds = this._getLabelBounds(location, centerX, centerY, hWidth, labelDim);

        if (preBounds ? !this._isOverlapOrShadow(preBounds, bounds) : true) {
          found = true;
          preArc = arc;
          break;
        }
      }

      if (!found) {
        return false;
      }

      var midPos = {
        x: centerX,
        y: centerY
      };
      var endPos;

      if (location == RIGHT_TOP || location == RIGHT_BOTTOM) {
        endPos = {
          x: centerX + hWidth,
          y: centerY
        };
      } else {
        endPos = {
          x: centerX - hWidth,
          y: centerY
        };
      }

      preBounds = bounds;
      point.labelPos = {
        x: bounds.x,
        y: bounds.y,
        midPos: midPos,
        endPos: endPos
      };
    }

    return true;
  },
  _getStartAndEndAngle: function (location) {
    switch (location) {
      case RIGHT_TOP:
        return {
          startAngle: 0,
          endAngle: Math.PI / 2
        };

      case RIGHT_BOTTOM:
        return {
          startAngle: Math.PI / 2,
          endAngle: Math.PI
        };

      case LEFT_BOTTOM:
        return {
          startAngle: Math.PI,
          endAngle: 3 * Math.PI / 2
        };

      case LEFT_TOP:
        return {
          startAngle: 3 * Math.PI / 2,
          endAngle: 2 * Math.PI
        };
    }
  },
  _getLabelBounds: function (location, centerX, centerY, hWidth, labelDim) {
    var x, y;

    if (location == RIGHT_TOP || location == RIGHT_BOTTOM) {
      x = centerX + hWidth + LABEL_GAP;
    } else {
      x = centerX - hWidth - LABEL_GAP - labelDim.width;
    }

    y = centerY - labelDim.height / 2;
    return {
      x: x,
      y: y,
      width: labelDim.width,
      height: labelDim.height
    };
  },
  // 1. judge overlapped
  // 2. the Y pos should not exceed the previous's half
  _isOverlapOrShadow: function (a, b) {
    var topHalfMinY = Math.max(a.y, b.y);
    var topHalfMaxY = Math.min(a.y + a.height / 2, b.y + b.height / 2);
    var bottomHalfMinY = Math.max(a.y + a.height / 2, b.y + b.height / 2);
    var bottomHalfMaxY = Math.min(a.y + a.height, b.y + b.height);
    return _BaseUtils["default"].rectangleOverlapped(a, b) || topHalfMinY <= topHalfMaxY || bottomHalfMinY <= bottomHalfMaxY;
  },
  testWithinBounds: function (pointsGroups, center, wholeBounds) {
    for (var i in pointsGroups) {
      var bounds, x, y, width, height;
      x = y = 0;

      switch (i) {
        case RIGHT_TOP:
        case RIGHT_BOTTOM:
          y = wholeBounds.y - center[1];
          width = wholeBounds.width + wholeBounds.x - center[0];
          height = wholeBounds.height;
          break;

        case LEFT_BOTTOM:
        case LEFT_TOP:
          x = wholeBounds.x - center[0];
          y = wholeBounds.y - center[1];
          width = -x;
          height = wholeBounds.height;
          break;
      }

      bounds = {
        x: x,
        y: y,
        width: width,
        height: height
      };

      for (var j = 0; j < pointsGroups[i].length; j++) {
        var p = pointsGroups[i][j];

        if (!p.labelPos) {
          continue;
        }

        var pBounds = {
          x: p.labelPos.x,
          y: p.labelPos.y,
          width: p.labelDim.width,
          height: p.labelDim.height
        };

        if (!_BaseUtils["default"].containsRect(bounds, pBounds)) {
          return false;
        }
      }
    }

    return true;
  },
  //多层饼图外面层内径也要变在数据点提示共享的情况下
  _changeInnerRadius: function (d) {
    return d.depth > 1 && d.options.tooltip && d.options.tooltip.shared;
  },
  _onPointState: function (d, isChosen, style, attr) {
    if (this.isFlowTouch()) {
      d.graphic.style(style);
    } else {
      var series = this;

      var arc = _PathGenerator["default"].arc();

      var startAngle = series._getStartAngle(d),
          endAngle = series._getEndAngle(d),
          innerRadius = series._getInnerRadius(d),
          outerRadius = series._getOuterRadius(d);

      var inRadiusScale = series._changeInnerRadius(d) ? HOVER_PERCENT : 1;
      var outStartRadius = outerRadius * HOVER_PERCENT,
          outEndRadius = outerRadius,
          inStartRadius = innerRadius * inRadiusScale,
          inEndRadius = innerRadius,
          duration = 400;

      if (isChosen) {
        outStartRadius = outerRadius;
        outEndRadius = outerRadius * HOVER_PERCENT;
        duration = 300;
        inStartRadius = innerRadius;
        inEndRadius = innerRadius * inRadiusScale;
      }

      var outInterpolate = (0, _interpolator["default"])(outStartRadius, outEndRadius),
          inInterpolate = (0, _interpolator["default"])(inStartRadius, inEndRadius),
          arcData = {
        startAngle: startAngle,
        endAngle: endAngle,
        innerRadius: innerRadius
      };
      d.graphic.style(style).interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
        ease: _BezierEasing["default"].css["ease-out-back"],
        duration: duration,
        attr: attr,
        attrTween: {
          'd': function () {
            return function (t) {
              return arc.outerRadius(outInterpolate(t)).innerRadius(inInterpolate(t))(arcData);
            };
          }
        }
      });
    }
  },

  /**
   * 选中的标签偏移计算，考虑标签在里面和在外面两种情况
   * @param point
   * @returns {*|{x, y}}
   * @private
   */
  _chosenPointLabelTrans: function (point) {
    var series = this;

    if (!point.labelPos || !point.textGraphic) {
      return;
    }

    var options = point.options,
        dataLabels = options.dataLabels,
        align = dataLabels.align;

    var trans = series._labelTrans(point);

    var centerAngle = series.getCenterAngle(point);

    if (align === _Constants["default"].INSIDE) {
      var inRadiusScale = series._changeInnerRadius(point) ? HOVER_PERCENT : 1; //多层饼图外面层内径也要变

      var innerR = series._getInnerRadius(point) * inRadiusScale,
          outerR = series._getOuterRadius(point) * HOVER_PERCENT,
          centerR = innerR + (outerR - innerR) / 2;
      trans = series._getArcPoint(centerR, centerAngle);
    } else if (align === _Constants["default"].OUTSIDE) {
      var _translateInfo = this._chosenPointOutsideLabelTranslate(point);

      trans = {
        x: trans.x + _translateInfo[0],
        y: trans.y + _translateInfo[1]
      };
    }

    return trans;
  },

  /**
   * 选中的数据点标签在外的偏移量计算，这个在计算连接线时也会用到，故拿出来
   * @param point
   * @returns {[null,null]}
   * @private
   */
  _chosenPointOutsideLabelTranslate: function (point) {
    var series = this;
    var centerAngle = series.getCenterAngle(point);

    var diffR = series._getOuterRadius(point) * (HOVER_PERCENT - 1),
        diffP = series._getArcPoint(diffR, centerAngle),
        diffX = diffP[0],
        diffY = diffP[1];

    return [diffX, diffY];
  },

  /**
   * 数据点选中或者取消选中时文字状态变化
   * @param point
   * @param isChosen
   * @returns {*|{x, y}}
   * @private
   */
  _onTextState: function (point, isChosen) {
    if (this.isFlowTouch()) {
      isChosen = false;
    }

    var series = this;

    if (!point.labelPos || !point.textGraphic) {
      return;
    }

    point._isChosen = isChosen;
    var options = point.options,
        dataLabels = options.dataLabels,
        align = dataLabels.align;
    var trans = isChosen ? this._chosenPointLabelTrans(point) : series._labelTrans(point);
    var duration = isChosen ? 300 : 400,
        ease = _BezierEasing["default"].css["ease-out-back"];
    var paras = point.textGraphic.type === 'div' ? {
      duration: duration,
      ease: ease,
      style: {
        'transform': 'translate(' + _BaseUtils["default"].pick(trans.x || trans[0]) + 'px,' + _BaseUtils["default"].pick(trans.y || trans[1]) + 'px)'
      }
    } : {
      duration: duration,
      ease: ease,
      attr: {
        'transform': _BaseUtils["default"].makeTranslate(trans)
      }
    };
    point.textGraphic && point.textGraphic.transition(_Constants["default"].SELECT_ANIMATION).animate(paras); // 标签在外的时候，需要更新连接线

    if (align === _Constants["default"].OUTSIDE) {
      var translateInfo = this._chosenPointOutsideLabelTranslate(point);

      series._outSideLabelColorState(point, isChosen, duration, ease);

      series._leadLineState(point, translateInfo[0], translateInfo[1], isChosen, duration, ease);
    }

    this._pieLabelBorderTransformState(point, isChosen, duration, ease);

    return trans;
  },
  _pieLabelBorderTrans: function (point) {
    var series = this;
    var options = point.options,
        labelDim = point.labelDim;
    var _options$dataLabels = options.dataLabels,
        align = _options$dataLabels.align,
        borderType = _options$dataLabels.borderType;
    var isChosen = point._isChosen;
    var textBorderPathTrans;
    var borderBounds = (0, _VanChartLabelBorder.getBorderBounds)(point);

    if (align === _Constants["default"].OUTSIDE) {
      var diff = isChosen ? series._chosenPointOutsideLabelTranslate(point) : [0, 0];
      textBorderPathTrans = [borderBounds.x + diff[0], borderBounds.y + diff[1]];
    } else {
      var textTrans = isChosen ? this._chosenPointLabelTrans(point) : series._labelTrans(point);
      var textTransInfo = {
        x: _BaseUtils["default"].pick(textTrans.x, textTrans[0]),
        y: _BaseUtils["default"].pick(textTrans.y, textTrans[1])
      };
      var borderPadding = (0, _VanChartLabelBorder.borderPaddingFn)(borderType, true, labelDim.innerTextDim);
      textBorderPathTrans = {
        x: textTransInfo.x - point.labelDim.width / 2,
        y: textTransInfo.y - borderPadding[1] / 2 - point.labelDim.height / 2
      };
    }

    return textBorderPathTrans;
  },
  _pieLabelBorderTransformState: function (point, isChosen, duration, ease) {
    var series = this;

    if (!point.textBorderPath) {
      return;
    }

    var textBorderPathTrans = series._pieLabelBorderTrans(point);

    point.textBorderPath.transition(_Constants["default"].SELECT_ANIMATION).animate({
      duration: duration,
      ease: ease,
      attr: {
        transform: _BaseUtils["default"].makeTranslate(textBorderPathTrans)
      }
    });
  },
  _getInnerRadius: function (d) {
    return d.innerRadius;
  },
  _getOuterRadius: function (d) {
    return d.outerRadius;
  },
  _getStartAngle: function (d) {
    return d.startAngle;
  },
  _getEndAngle: function (d) {
    return d.endAngle;
  },
  _getPositionInPie: function (absPos) {
    var x = absPos.x - this.chartInfo.centerX;
    var y = absPos.y - this.chartInfo.centerY;
    return {
      x: x,
      y: y
    };
  },
  _isRotatable: function () {
    return (0, _EnvUtils.isSupportSVG)() && this.options.rotatable;
  },
  onPanStart: function (ev) {
    if (!this._isRotatable()) {
      return;
    }

    if (ev.stop) {
      ev.stop();
    }

    this.initPos = ev.containerPoint;
    this.initRotate = _BaseUtils["default"].toDegree(this.chartInfo.rotate);
  },
  onPanMove: function (ev) {
    if (!this._isRotatable()) {
      return;
    }

    if (ev.stop) {
      ev.stop();
    }

    this.vanchart.removeMoreLabel(); //旋转时移除moreLabel

    var startAngle = this._getAngle(this._getPositionInPie(this.initPos));

    var newAngle = this._getAngle(this._getPositionInPie(ev.containerPoint));

    var rotate = newAngle - startAngle + this.initRotate;

    this._getPointGraphicGroup().attr("transform", "rotate(" + rotate + ")");

    this.chartInfo.rotate = _BaseUtils["default"].toRadian(rotate);

    this._calculateLabelPosWhenRadiusFixed();

    this._rotateLabels();
  },
  onPanEnd: function (ev) {
    if (ev.stop) {
      ev.stop();
    }

    this.vanchart.handler.panTarget = null;
  },
  getEvents: function () {
    return _BaseUtils["default"].extend(_Series["default"].prototype.getEvents.call(this), {
      'panstart': this.onPanStart,
      'panmove': this.onPanMove,
      'panend': this.onPanEnd
    });
  },
  _rotateLabels: function () {
    var series = this;
    series.getDataToDraw().forEach(function (point) {
      if (point.textGraphic && !point.labelPos) {
        point.removeTextGraphic();
      } else if (point.textGraphic && point.labelPos) {
        point.textGraphic.interrupt(_Constants["default"].SELECT_ANIMATION) // 旋转过程中，取消动画，直接用最终的attr
        .attr('transform', _BaseUtils["default"].makeTranslate(point._isChosen ? series._chosenPointLabelTrans(point, true) : series._labelTrans(point)));

        series._rotateTextBorder(point);

        if (point.labelPos.startPos) {
          if (point.leadLine) {
            var leadLinePath = point._isChosen ? function () {
              var translateInfo = series._chosenPointOutsideLabelTranslate(point);

              return series._getChosenPointLeadLinePath(point, translateInfo[0], translateInfo[1]);
            }() : series._getLeadLinePath(point); // 这里和标签一样，需要考虑旋转的过程中选中的效果

            point.leadLine.interrupt(_Constants["default"].SELECT_ANIMATION).attr('d', leadLinePath);
          } else {
            point.leadLine = series._getLeadLine(point);
          }
        }
      } else if (!point.textGraphic && point.labelPos) {
        series._createTextGraphic(point);
      }
    });
  },
  _rotateTextBorder: function (point) {
    if (!point.textBorderPath) {
      return;
    }

    var dataLabels = point.options.dataLabels;

    var textBorderPathTrans = this._pieLabelBorderTrans(point); // 标签居内时标签边框只有一个方向，无需更新path


    if (dataLabels.align === _Constants["default"].INSIDE) {
      return point.textBorderPath.interrupt(_Constants["default"].SELECT_ANIMATION).attr({
        'transform': _BaseUtils["default"].makeTranslate(textBorderPathTrans)
      });
    } // 标签居外时标签边框旋转会导致边框方向不同，需更新path


    var labelBorderPath = (0, _VanChartLabelBorder.getPathAndTransform)(point).path; // lineTriangle类型的边框stroke和fill对应不同的path

    if (point.lineTriangleBorder) {
      point.textBorderPath.interrupt(_Constants["default"].SELECT_ANIMATION).attr({
        'transform': _BaseUtils["default"].makeTranslate(textBorderPathTrans)
      });
      point.lineTriangleBorder.attr('d', labelBorderPath[0]);
      point.lineTriangleBorderRect.attr('d', labelBorderPath[1]);
      return;
    }

    point.textBorderPath.interrupt(_Constants["default"].SELECT_ANIMATION).attr({
      'd': labelBorderPath,
      'transform': _BaseUtils["default"].makeTranslate(textBorderPathTrans)
    });
  },
  isPanMovingAtTheBoundary: function () {
    return false;
  }
};
exports["default"] = _default;

/***/ }),
/* 81 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.treemapLayout = exports.treeLayout = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/20.
 */
var hierarchyLayout = function () {
  var sort = d3_layout_hierarchySort,
      children = d3_layout_hierarchyChildren,
      value = d3_layout_hierarchyValue;

  function hierarchy(root) {
    var stack = [root],
        nodes = [],
        node;
    root.depth = 0;

    while ((node = stack.pop()) != null) {
      nodes.push(node);

      if ((childs = children.call(hierarchy, node, node.depth)) && (n = childs.length)) {
        var n, childs, child;

        while (--n >= 0) {
          stack.push(child = childs[n]);
          child.parent = node;
          child.depth = node.depth + 1;
        }

        if (value) {
          node.value = 0;
        }

        node.children = childs;
      } else {
        if (value) {
          node.value = +value.call(hierarchy, node, node.depth) || 0;
        }

        delete node.children;
      }
    }

    d3_layout_hierarchyVisitAfter(root, function (node) {
      var childs, parent;

      if (sort && (childs = node.children)) {
        childs.sort(sort);
      }

      if (value && (parent = node.parent)) {
        parent.value += node.value;
      }
    });
    return nodes;
  }

  hierarchy.sort = function (x) {
    if (!arguments.length) {
      return sort;
    }

    sort = x;
    return hierarchy;
  };

  hierarchy.children = function (x) {
    if (!arguments.length) {
      return children;
    }

    children = x;
    return hierarchy;
  };

  hierarchy.value = function (x) {
    if (!arguments.length) {
      return value;
    }

    value = x;
    return hierarchy;
  };

  hierarchy.revalue = function (root) {
    if (value) {
      d3_layout_hierarchyVisitBefore(root, function (node) {
        if (node.children) {
          node.value = 0;
        }
      });
      d3_layout_hierarchyVisitAfter(root, function (node) {
        var parent;

        if (!node.children) {
          node.value = +value.call(hierarchy, node, node.depth) || 0;
        }

        if (parent = node.parent) {
          parent.value += node.value;
        }
      });
    }

    return root;
  };

  return hierarchy;
};

function d3_layout_hierarchyRebind(object, hierarchy) {
  _BaseUtils["default"].rebind(object, hierarchy, "sort", "children", "value");

  object.nodes = object;
  object.links = d3_layout_hierarchyLinks;
  return object;
}

function d3_layout_hierarchyVisitBefore(node, callback) {
  var nodes = [node];

  while ((node = nodes.pop()) != null) {
    callback(node);

    if ((children = node.children) && (n = children.length)) {
      var n, children;

      while (--n >= 0) {
        nodes.push(children[n]);
      }
    }
  }
}

function d3_layout_hierarchyVisitAfter(node, callback) {
  var nodes = [node],
      nodes2 = [];

  while ((node = nodes.pop()) != null) {
    nodes2.push(node);

    if ((children = node.children) && (n = children.length)) {
      var i = -1,
          n,
          children;

      while (++i < n) {
        nodes.push(children[i]);
      }
    }
  }

  while ((node = nodes2.pop()) != null) {
    callback(node);
  }
}

function d3_layout_hierarchyChildren(d) {
  return d.children;
}

function d3_layout_hierarchyValue(d) {
  return d.value;
}

function d3_layout_hierarchySort(a, b) {
  return b.value - a.value;
}

function d3_layout_hierarchyLinks(nodes) {
  return d3.merge(nodes.map(function (parent) {
    return (parent.children || []).map(function (child) {
      return {
        source: parent,
        target: child
      };
    });
  }));
}

var treeLayout = function () {
  var hierarchy = hierarchyLayout().sort(null).value(null),
      separation = d3_layout_treeSeparation,
      size = [1, 1],
      nodeSize = null;

  function tree(d, i) {
    var nodes = hierarchy.call(this, d, i),
        root0 = nodes[0],
        root1 = wrapTree(root0);
    d3_layout_hierarchyVisitAfter(root1, firstWalk), root1.parent.m = -root1.z;
    d3_layout_hierarchyVisitBefore(root1, secondWalk);

    if (nodeSize) {
      d3_layout_hierarchyVisitBefore(root0, sizeNode);
    } else {
      var left = root0,
          right = root0,
          bottom = root0;
      d3_layout_hierarchyVisitBefore(root0, function (node) {
        if (node.x < left.x) {
          left = node;
        }

        if (node.x > right.x) {
          right = node;
        }

        if (node.depth > bottom.depth) {
          bottom = node;
        }
      });
      var tx = separation(left, right) / 2 - left.x,
          kx = size[0] / (right.x + separation(right, left) / 2 + tx),
          ky = size[1] / (bottom.depth || 1);
      d3_layout_hierarchyVisitBefore(root0, function (node) {
        node.x = (node.x + tx) * kx;
        node.y = node.depth * ky;
      });
    }

    return nodes;
  }

  function wrapTree(root0) {
    var root1 = {
      A: null,
      children: [root0]
    },
        queue = [root1],
        node1;

    while ((node1 = queue.pop()) != null) {
      for (var children = node1.children, child, i = 0, n = children.length; i < n; ++i) {
        queue.push((children[i] = child = {
          _: children[i],
          parent: node1,
          children: (child = children[i].children) && child.slice() || [],
          A: null,
          a: null,
          z: 0,
          m: 0,
          c: 0,
          s: 0,
          t: null,
          i: i
        }).a = child);
      }
    }

    return root1.children[0];
  }

  function firstWalk(v) {
    var children = v.children,
        siblings = v.parent.children,
        w = v.i ? siblings[v.i - 1] : null;

    if (children.length) {
      d3_layout_treeShift(v);
      var midpoint = (children[0].z + children[children.length - 1].z) / 2;

      if (w) {
        v.z = w.z + separation(v._, w._);
        v.m = v.z - midpoint;
      } else {
        v.z = midpoint;
      }
    } else if (w) {
      v.z = w.z + separation(v._, w._);
    }

    v.parent.A = apportion(v, w, v.parent.A || siblings[0]);
  }

  function secondWalk(v) {
    v._.x = v.z + v.parent.m;
    v.m += v.parent.m;
  }

  function apportion(v, w, ancestor) {
    if (w) {
      var vip = v,
          vop = v,
          vim = w,
          vom = vip.parent.children[0],
          sip = vip.m,
          sop = vop.m,
          sim = vim.m,
          som = vom.m,
          shift;

      while (vim = d3_layout_treeRight(vim), vip = d3_layout_treeLeft(vip), vim && vip) {
        vom = d3_layout_treeLeft(vom);
        vop = d3_layout_treeRight(vop);
        vop.a = v;
        shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);

        if (shift > 0) {
          d3_layout_treeMove(d3_layout_treeAncestor(vim, v, ancestor), v, shift);
          sip += shift;
          sop += shift;
        }

        sim += vim.m;
        sip += vip.m;
        som += vom.m;
        sop += vop.m;
      }

      if (vim && !d3_layout_treeRight(vop)) {
        vop.t = vim;
        vop.m += sim - sop;
      }

      if (vip && !d3_layout_treeLeft(vom)) {
        vom.t = vip;
        vom.m += sip - som;
        ancestor = v;
      }
    }

    return ancestor;
  }

  function sizeNode(node) {
    node.x *= size[0];
    node.y = node.depth * size[1];
  }

  tree.separation = function (x) {
    if (!arguments.length) {
      return separation;
    }

    separation = x;
    return tree;
  };

  tree.size = function (x) {
    if (!arguments.length) {
      return nodeSize ? null : size;
    }

    nodeSize = (size = x) == null ? sizeNode : null;
    return tree;
  };

  tree.nodeSize = function (x) {
    if (!arguments.length) {
      return nodeSize ? size : null;
    }

    nodeSize = (size = x) == null ? null : sizeNode;
    return tree;
  };

  return d3_layout_hierarchyRebind(tree, hierarchy);
};

exports.treeLayout = treeLayout;

function d3_layout_treeSeparation(a, b) {
  return a.parent == b.parent ? 1 : 2;
}

function d3_layout_treeLeft(v) {
  var children = v.children;
  return children.length ? children[0] : v.t;
}

function d3_layout_treeRight(v) {
  var children = v.children,
      n;
  return (n = children.length) ? children[n - 1] : v.t;
}

function d3_layout_treeMove(wm, wp, shift) {
  var change = shift / (wp.i - wm.i);
  wp.c -= change;
  wp.s += shift;
  wm.c += change;
  wp.z += shift;
  wp.m += shift;
}

function d3_layout_treeShift(v) {
  var shift = 0,
      change = 0,
      children = v.children,
      i = children.length,
      w;

  while (--i >= 0) {
    w = children[i];
    w.z += shift;
    w.m += shift;
    shift += w.s + (change += w.c);
  }
}

function d3_layout_treeAncestor(vim, v, ancestor) {
  return vim.a.parent === v.parent ? vim.a : ancestor;
}

var treemapLayout = function () {
  var hierarchy = hierarchyLayout(),
      round = Math.round,
      size = [1, 1],
      padding = null,
      pad = d3_layout_treemapPadNull,
      sticky = false,
      stickies,
      mode = "squarify",
      ratio = .5 * (1 + Math.sqrt(5));

  function scale(children, k) {
    var i = -1,
        n = children.length,
        child,
        area;

    while (++i < n) {
      area = (child = children[i]).value * (k < 0 ? 0 : k);
      child.area = isNaN(area) || area <= 0 ? 0 : area;
    }
  }

  function squarify(node) {
    var children = node.children;

    if (children && children.length) {
      var rect = pad(node),
          row = [],
          remaining = children.slice(),
          child,
          best = Infinity,
          score,
          u = mode === "slice" ? rect.dx : mode === "dice" ? rect.dy : mode === "slice-dice" ? node.depth & 1 ? rect.dy : rect.dx : Math.min(rect.dx, rect.dy),
          n;
      scale(remaining, rect.dx * rect.dy / node.value);
      row.area = 0;

      while ((n = remaining.length) > 0) {
        row.push(child = remaining[n - 1]);
        row.area += child.area;

        if (mode !== "squarify" || (score = worst(row, u)) <= best) {
          remaining.pop();
          best = score;
        } else {
          row.area -= row.pop().area;
          position(row, u, rect, false);
          u = Math.min(rect.dx, rect.dy);
          row.length = row.area = 0;
          best = Infinity;
        }
      }

      if (row.length) {
        position(row, u, rect, true);
        row.length = row.area = 0;
      }

      children.forEach(squarify);
    }
  }

  function stickify(node) {
    var children = node.children;

    if (children && children.length) {
      var rect = pad(node),
          remaining = children.slice(),
          child,
          row = [];
      scale(remaining, rect.dx * rect.dy / node.value);
      row.area = 0;

      while (child = remaining.pop()) {
        row.push(child);
        row.area += child.area;

        if (child.z != null) {
          position(row, child.z ? rect.dx : rect.dy, rect, !remaining.length);
          row.length = row.area = 0;
        }
      }

      children.forEach(stickify);
    }
  }

  function worst(row, u) {
    var s = row.area,
        r,
        rmax = 0,
        rmin = Infinity,
        i = -1,
        n = row.length;

    while (++i < n) {
      if (!(r = row[i].area)) {
        continue;
      }

      if (r < rmin) {
        rmin = r;
      }

      if (r > rmax) {
        rmax = r;
      }
    }

    s *= s;
    u *= u;
    return s ? Math.max(u * rmax * ratio / s, s / (u * rmin * ratio)) : Infinity;
  }

  function position(row, u, rect, flush) {
    var i = -1,
        n = row.length,
        x = rect.x,
        y = rect.y,
        v = u ? round(row.area / u) : 0,
        o;

    if (u == rect.dx) {
      if (flush || v > rect.dy) {
        v = rect.dy;
      }

      while (++i < n) {
        o = row[i];
        o.x = x;
        o.y = y;
        o.dy = v;
        x += o.dx = Math.min(rect.x + rect.dx - x, v ? round(o.area / v) : 0);
      }

      o.z = true;
      o.dx += rect.x + rect.dx - x;
      rect.y += v;
      rect.dy -= v;
    } else {
      if (flush || v > rect.dx) {
        v = rect.dx;
      }

      while (++i < n) {
        o = row[i];
        o.x = x;
        o.y = y;
        o.dx = v;
        y += o.dy = Math.min(rect.y + rect.dy - y, v ? round(o.area / v) : 0);
      }

      o.z = false;
      o.dy += rect.y + rect.dy - y;
      rect.x += v;
      rect.dx -= v;
    }
  }

  function treemap(d) {
    var nodes = stickies || hierarchy(d),
        root = nodes[0];
    root.x = 0;
    root.y = 0;
    root.dx = size[0];
    root.dy = size[1];

    if (stickies) {
      hierarchy.revalue(root);
    }

    scale([root], root.dx * root.dy / root.value);
    (stickies ? stickify : squarify)(root);

    if (sticky) {
      stickies = nodes;
    }

    return nodes;
  }

  treemap.size = function (x) {
    if (!arguments.length) {
      return size;
    }

    size = x;
    return treemap;
  };

  treemap.padding = function (x) {
    if (!arguments.length) {
      return padding;
    }

    function padFunction(node) {
      var p = x.call(treemap, node, node.depth);
      return p == null ? d3_layout_treemapPadNull(node) : d3_layout_treemapPad(node, typeof p === "number" ? [p, p, p, p] : p);
    }

    function padConstant(node) {
      return d3_layout_treemapPad(node, x);
    }

    var type;
    pad = (padding = x) == null ? d3_layout_treemapPadNull : (type = typeof x) === "function" ? padFunction : type === "number" ? (x = [x, x, x, x], padConstant) : padConstant;
    return treemap;
  };

  treemap.round = function (x) {
    if (!arguments.length) {
      return round != Number;
    }

    round = x ? Math.round : Number;
    return treemap;
  };

  treemap.sticky = function (x) {
    if (!arguments.length) {
      return sticky;
    }

    sticky = x;
    stickies = null;
    return treemap;
  };

  treemap.ratio = function (x) {
    if (!arguments.length) {
      return ratio;
    }

    ratio = x;
    return treemap;
  };

  treemap.mode = function (x) {
    if (!arguments.length) {
      return mode;
    }

    mode = x + "";
    return treemap;
  };

  return d3_layout_hierarchyRebind(treemap, hierarchy);
};

exports.treemapLayout = treemapLayout;

function d3_layout_treemapPadNull(node) {
  return {
    x: node.x,
    y: node.y,
    dx: node.dx,
    dy: node.dy
  };
}

function d3_layout_treemapPad(node, padding) {
  var x = node.x + padding[3],
      y = node.y + padding[0],
      dx = node.dx - padding[1] - padding[3],
      dy = node.dy - padding[0] - padding[2];

  if (dx < 0) {
    x += dx / 2;
    dx = 0;
  }

  if (dy < 0) {
    y += dy / 2;
    dy = 0;
  }

  return {
    x: x,
    y: y,
    dx: dx,
    dy: dy
  };
}

/***/ }),
/* 82 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.dealSlotAndRingPercentLabel = dealSlotAndRingPercentLabel;
exports.dealSlotAndRingValueLabel = dealSlotAndRingValueLabel;

var _CoreUtils = __webpack_require__(3);

var _customLabel = __webpack_require__(58);

var _dataLabelFormatter = __webpack_require__(24);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _gaugeTextFormatter = __webpack_require__(59);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var MIN_FONTSIZE = 10;
var PERCENTAGE_FONT_HEIGHT = 0.3; // 百分比标签字体占仪表盘半径的比例

var VALUE_FONT_HEIGHT_1 = 0.12; // 勾选百分比，分类、值自动时字体占半径的比例

var VALUE_FONT_HEIGHT_2 = 0.2; // 未勾选百分比，分类、值自动时字体占半径的比例

function fixRadius(radius, bounds, paddingPercent) {
  var autoRadius = Math.min(bounds.width / 2, bounds.height / 2) / (1 + paddingPercent);
  return (0, _CoreUtils.hasDefined)(radius) ? radius : autoRadius;
}

function getLimitWidth(radius, paddingPercent, circleWidth) {
  return 2 * radius * (1 - paddingPercent - circleWidth);
}

function normalPercentLabel(series, paddingPercent, radius) {
  var points = series.points,
      options = series.options;
  var circleWidth = options.circleWidth;
  var point = points[0];

  var percentageLabel = _BaseUtils["default"].clone(options.percentageLabel);

  var autoSize = PERCENTAGE_FONT_HEIGHT * radius;
  var limitWidth = getLimitWidth(radius, paddingPercent, circleWidth);
  var style = percentageLabel.style;

  if (style.autoColor) {
    style.color = point.color;
  }

  var initLabel = (0, _dataLabelFormatter.defaultLabelContent)(point, percentageLabel);
  var initLabelContent = initLabel && initLabel[0] ? initLabel[0].text : '';
  var labelContent;

  if (style.autoSize) {
    var autoSizeLabel = _BaseUtils["default"].shrinkText(initLabelContent, MIN_FONTSIZE, autoSize, limitWidth, style, false);

    labelContent = autoSizeLabel.labelContent;
    style.fontSize = autoSizeLabel.fontSize;
  } else {
    labelContent = _BaseUtils["default"].getEllipsisText(initLabelContent, limitWidth, style, false);
  }

  return {
    labelContent: labelContent,
    labelStyle: style,
    labelDim: _BaseUtils["default"].getTextDimension(labelContent, style, false)
  };
}

function normalValueLabelWithPercentLabel(series, limitWidth, autoSize) {
  var options = series.options,
      points = series.points;

  var valueLabel = _BaseUtils["default"].clone(options.valueLabel);

  var formatter = valueLabel.formatter,
      style = valueLabel.style;
  var labelContents = (0, _gaugeTextFormatter.createMultiLineLabelContent)(formatter, points[0]);

  if (style.autoSize) {
    series._autoValueLabelWithPercent(labelContents, valueLabel, autoSize, limitWidth, series);
  } else {
    series._valueLabelWithPercent(labelContents, valueLabel, limitWidth, series);
  }

  return series.valueLabelContent;
}

function normalValueLabelWithoutPercentLabel(series, limitWidth, autoSize) {
  var options = series.options,
      points = series.points;

  var valueLabel = _BaseUtils["default"].clone(options.valueLabel);

  var formatter = valueLabel.formatter,
      style = valueLabel.style;
  var valueLabelContent = [];
  var labelContents = (0, _gaugeTextFormatter.createMultiLineLabelContent)(formatter, points[0]);
  labelContents = _BaseUtils["default"].objectToArray(labelContents);
  labelContents.forEach(function (labelContent) {
    var labelStyle = _BaseUtils["default"].clone(style);

    if (style.autoSize) {
      var autoSizeLabel = _BaseUtils["default"].shrinkText(labelContent, MIN_FONTSIZE, autoSize, limitWidth, labelStyle, false);

      labelContent = autoSizeLabel.labelContent;
      labelStyle.fontSize = autoSizeLabel.fontSize;
    } else {
      labelContent = _BaseUtils["default"].getEllipsisText(labelContent, limitWidth, labelStyle, false);
    }

    valueLabelContent.push({
      labelContent: labelContent,
      labelStyle: labelStyle,
      labelDim: _BaseUtils["default"].getTextDimension(labelContent, labelStyle, false)
    });
  });
  return valueLabelContent;
}

function normalValueLabel(series, limitWidth, autoSize) {
  if (series.percentageLabelContent) {
    return normalValueLabelWithPercentLabel(series, limitWidth, autoSize);
  }

  return normalValueLabelWithoutPercentLabel(series, limitWidth, autoSize);
}

function dealSlotAndRingPercentLabel(series, paddingPercent) {
  var label;
  var options = series.options,
      bounds = series.bounds;
  var percentageLabel = options.percentageLabel;
  var point = series.points[0];
  var radius = fixRadius(options.radius, bounds, paddingPercent);
  var autoSize = PERCENTAGE_FONT_HEIGHT * radius;

  if (!series.isValidDataLabel(point, percentageLabel)) {
    series.percentageLabelContent = '';
    series.percentageLabelDim = {
      width: 0,
      height: 0
    };
    return;
  }

  if ((0, _customLabel.isCustomLabel)(percentageLabel.formatter)) {
    var fixColor = percentageLabel.style.autoColor;
    label = (0, _customLabel.customDataLabel)(series, percentageLabel, autoSize, fixColor);
  } else {
    label = normalPercentLabel(series, paddingPercent, radius);
  }

  var _label = label,
      labelContent = _label.labelContent,
      labelStyle = _label.labelStyle,
      labelDim = _label.labelDim;
  series.percentageLabelContent = labelContent;
  series.percentageLabelDim = labelDim;
  series.percentageLabelStyle = labelStyle;
}

function dealSlotAndRingValueLabel(series, paddingPercent) {
  var valueLabelContent = [];
  var options = series.options,
      bounds = series.bounds;
  var valueLabel = options.valueLabel,
      circleWidth = options.circleWidth;
  var point = series.points[0];
  var radius = fixRadius(options.radius, bounds, paddingPercent);
  var limitWidth = getLimitWidth(radius, paddingPercent, circleWidth);
  var autoSize = series.percentageLabelContent ? VALUE_FONT_HEIGHT_1 * radius : VALUE_FONT_HEIGHT_2 * radius;
  valueLabel.style.color = series.getThemeLabelColor(valueLabel.style);

  if (!series.isValidDataLabel(point, valueLabel)) {
    series.valueLabelContent = [];
    return;
  }

  if ((0, _customLabel.isCustomLabel)(valueLabel.formatter)) {
    var label = (0, _customLabel.customDataLabel)(series, valueLabel, autoSize);
    valueLabelContent.push(label);
  } else {
    valueLabelContent = normalValueLabel(series, limitWidth, autoSize);
  }

  series.valueLabelContent = valueLabelContent;
}

/***/ }),
/* 83 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Evented = _interopRequireDefault(__webpack_require__(12));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Mitisky on 16/8/10.
 */
var EventObject = _Evented["default"].extend({
  initialize: function (events) {
    this.events = events;
  },
  getEvents: function () {
    return this.events;
  }
});

var _default = EventObject;
exports["default"] = _default;

/***/ }),
/* 84 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by Yuqian on 2017/2/6.
 */
var SECOND = 1000,
    MINUTE = 60 * SECOND,
    HOUR = 60 * MINUTE,
    DAY = 24 * HOUR,
    WEEK = 7 * DAY,
    MIN_HALF_YEAR = 181 * DAY,
    // not accurate
YEAR = 365 * DAY,
    MONTH = YEAR / 12,
    QUARTER = YEAR / 4,
    HALF_YEAR = YEAR / 2;
var units = [// 0
['year', 'halfYear'], // 1
['year', 'halfYear'], // 2
['year', 'quarter'], // 3
['halfYear', 'month'], // 4
['quarter', 'month'], // 5
['quarter', 'month'], // 6
['month', 'week'], // 7
['week', 'day'], // 8
['month', 'date'], // 9
['month', 'date'], // 10
['date', 'meridiem'], // 11
['date', 'qDay'], // 12
['date', 'hour'], // 13
['meridiem', 'hour'], // 14
['hour', 'halfHour'], // 15
['hour', 'tenMinute'], // 16
['halfHour', 'fiveMinute'], // 17
['halfHour', 'fiveMinute'], // 18
['halfHour', 'minute'], // 19
['tenMinute', 'minute'], // 20
['minute', 'halfMinute'], // 21
['minute', 'tenSecond']];
var r0 = 3 / MIN_HALF_YEAR; // R0 = 1emWidth * 3 / halfYear

function upUnit(level) {
  return units[level][0];
}

function subUnit(level) {
  return units[level][1];
}
/***
 * @returns {number}
 */


function Ratio(em, level) {
  return r0 * em * Math.pow(2, level);
}

var _default = {
  r0: r0,
  LEN: units.length,
  Ratio: Ratio,
  upUnit: upUnit,
  subUnit: subUnit
};
exports["default"] = _default;

/***/ }),
/* 85 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/1/12.
 */
var _default = _Base["default"].extend({
  _getHeader: function () {
    return this.options.header;
  },
  _getBody: function () {
    return this.options.body;
  }
});

exports["default"] = _default;

/***/ }),
/* 86 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Scrollbar = _interopRequireDefault(__webpack_require__(60));

var _helper = _interopRequireDefault(__webpack_require__(30));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/2/24.
 */
var toBack = _DomUtils["default"].toBack;
var sum = _helper["default"].sum;
var makeTranslate = _BaseUtils["default"].makeTranslate;
var mixColorWithAlpha = _ColorUtils["default"].mixColorWithAlpha;
var min = Math.min;
var max = Math.max;
var X_SCROLLBAR_PAN_START = 1;
var Y_SCROLLBAR_PAN_START = 2;

var _default = _Evented["default"].extend({
  _parts: ['header', 'body', 'outline', 'scrollbar'],
  _getEventNames: function () {
    var vanchart = this.vanchart;

    if (vanchart.useCanvas()) {
      return ['wheelMove', 'over', 'pan'];
    }

    return ['wheelMove', 'resizeStart', 'resizeMove', 'over', 'pan'];
  },
  initialize: function (model, vanchart) {
    this.model = model;
    this.vanchart = vanchart;
    this.renderer = vanchart.renderer;
    var G = this.G = {};
    var cn = this.className; // todo, &vanchart.render, group init seq

    ['', 'body', 'inner-body'].map(function (name) {
      G[name || cn] = vanchart[name ? cn + '-' + name : cn];
    });
    this.innerPosX = this.innerPosY = 0;
    var innerBodyHeight = this.model.tableDims.rowHeight * this.model.tableDims.rowNum;
    this.visibleBodyHeight = this.model.bounds.height - this.model.tableDims.headerHeight;
    this.innerBodyHeight = max(innerBodyHeight, this.visibleBodyHeight);
  },
  _getInnerWidth: function () {
    return this.model.innerWidth;
  },
  render: function () {
    var renderer = this.renderer,
        bounds = this.model.bounds;
    this.clip = renderer.createClip({
      width: bounds.width,
      height: bounds.height
    });

    var group = this._getGroup().attr('transform', makeTranslate(bounds));

    renderer.clip(group, this.clip);

    this._parts.map(function (key) {
      this['_' + key]();
    }, this);

    this._getEventNames().map(function (key) {
      this.vanchart.handler && this.vanchart.handler.on(key, this['on' + key], this);
    }, this);
  },
  _prepareBody: function () {
    var R = this.renderer;

    var bodyG = this._getGroup('body'),
        G = this._getGroup('inner-body');

    var backGroup = this._addGroup('inner-body-back', G);

    toBack(backGroup.node());
    bodyG.attr('transform', _BaseUtils["default"].makeTranslate({
      x: 0,
      y: this.model.tableDims.headerHeight
    })); // make it exceed any bounds, so needn't to update

    this.bodyClip = R.createClip({
      width: this.vanchart.bounds.width,
      height: this.vanchart.bounds.height
    });
    R.clip(bodyG, this.bodyClip);
    this._bodyEles = {
      hLines: [],
      vLines: [],
      rects: []
    };
    this._bodyEles.gs = [];
  },
  _buildScrollbar: function (opt) {
    this.scrollbar = new _Scrollbar["default"](_BaseUtils["default"].extend({
      view: this,
      group: this._getGroup('body'),
      width: this.model.bounds.width,
      height: this.visibleBodyHeight,
      innerWidth: this._getInnerWidth(),
      innerHeight: this.innerBodyHeight
    }, opt));
    this.scrollbar.on('scrollX', this.onScrollX, this).on('scrollY', this.vanchart.onScrollY, this.vanchart); // sync with another

    this.vanchart.on('moveY', this.onScrollY, this); // sync with another
  },
  _addGroup: function (name, parentG) {
    var newGroup = this.renderer.group();
    var className = name ? this.className + '-' + name : this.className;
    newGroup.attr('class', className);
    this.G[name || this.className] = newGroup;

    if (parentG) {
      parentG.append(newGroup);
    }

    return newGroup;
  },
  _getGroup: function (name) {
    return this.G[name || this.className];
  },
  _getOptionsColor: function (obj) {
    if ((0, _CoreUtils.isEmpty)(obj.opacity)) {
      return obj.backgroundColor;
    } else {
      return mixColorWithAlpha(obj.backgroundColor, obj.opacity);
    }
  },
  moveInner: function (pos) {
    this._setInnerPos(pos);
  },
  onwheelMove: function (ev) {
    var pos = {
      x: null,
      y: null
    };

    if (this._shouldYMove(ev.containerPoint)) {
      pos.y = this.innerPosY - ev.wheel.pixelY;
    }

    if (this._shouldXMove(ev.containerPoint)) {
      pos.x = this.innerPosX - ev.wheel.pixelX;
    }

    this.moveInner(pos);
  },
  onpan: function (ev) {
    var limitBounds = this.getViewScrollBoundary();
    var limitLeft = limitBounds.left,
        limitRight = limitBounds.right,
        limitTop = limitBounds.top,
        limitBottom = limitBounds.bottom;

    switch (ev.type) {
      case 'panstart':
        if (this._inCanvasScrollBarBounds(ev)) {
          return this._onScrollBarPanStart(ev);
        }

        this._moveInnerPos = this._initInnerPos = {
          x: this.innerPosX,
          y: this.innerPosY
        };
        this._initPoint = ev.containerPoint;
        this._initPointPos = {
          x: ev.deltaX,
          y: ev.deltaY
        }; // 存储最开始的ev.point的x和y变化，用于计算move时的movement

        break;

      case 'panmove':
        if (this._isCanvasScrollBarPan()) {
          return this._onScrollBarPanMove(ev);
        }

        var pos = {
          x: null,
          y: null
        };

        if (this._shouldYMove(this._initPoint)) {
          // pos.y = this._initInnerPos.y + ev.deltaY;
          this._moveInnerPos.y += ev.deltaY - this._initPointPos.y;
          this._moveInnerPos.y = this._moveInnerPos.y > limitBottom ? limitBottom : this._moveInnerPos.y < limitTop ? limitTop : this._moveInnerPos.y;
          pos.y = this._moveInnerPos.y;
        }

        if (this._shouldXMove(this._initPoint)) {
          // pos.x = this._initInnerPos.x + ev.deltaX;   // 这样会存在一个问题，当右划到边界时继续划100px，这时左划需要把多出的100px划回去才能使图表滚动
          this._moveInnerPos.x += ev.deltaX - this._initPointPos.x;
          this._moveInnerPos.x = this._moveInnerPos.x > limitRight ? limitRight : this._moveInnerPos.x < limitLeft ? limitLeft : this._moveInnerPos.x;
          pos.x = this._moveInnerPos.x;
        }

        this.moveInner(pos);
        this._initPointPos = {
          x: ev.deltaX,
          y: ev.deltaY
        };
        break;

      case 'panend':
        if (this._isCanvasScrollBarPan()) {
          return this._onScrollBarPanEnd(ev);
        }

        break;
    }
  },
  _inCanvasScrollBarBounds: function (ev) {
    var vanchart = this.vanchart;

    if (!vanchart.useCanvas()) {
      return false;
    }

    var _vanchart$ganttScroll = vanchart.ganttScrollBar,
        barxBounds = _vanchart$ganttScroll.barxBounds,
        baryBounds = _vanchart$ganttScroll.baryBounds;
    return _BaseUtils["default"].containsPoint(barxBounds, ev.containerPoint) || _BaseUtils["default"].containsPoint(baryBounds, ev.containerPoint);
  },
  _isCanvasScrollBarPan: function () {
    var ganttScrollBar = this.vanchart.ganttScrollBar;
    return ganttScrollBar && ganttScrollBar._panState;
  },
  _onScrollBarPanStart: function (ev) {
    if (this._getGroup('processesGroup')) {
      return;
    }

    var vanchart = this.vanchart,
        scrollbar = this.scrollbar;
    var ganttScrollBar = vanchart.ganttScrollBar;
    var barxBounds = ganttScrollBar.barxBounds;

    if (_BaseUtils["default"].containsPoint(barxBounds, ev.containerPoint)) {
      ganttScrollBar._panState = X_SCROLLBAR_PAN_START;
      scrollbar.barX.onPanStart(ev);
    } else {
      ganttScrollBar._panState = Y_SCROLLBAR_PAN_START;
      scrollbar.barY.onPanStart(ev);
    }
  },
  _onScrollBarPanMove: function (ev) {
    if (this._getGroup('processesGroup')) {
      return;
    }

    var vanchart = this.vanchart,
        scrollbar = this.scrollbar;
    var ganttScrollBar = vanchart.ganttScrollBar;

    if (ganttScrollBar._panState === X_SCROLLBAR_PAN_START) {
      scrollbar.barX.onPanMove(ev);
    } else if (ganttScrollBar._panState === Y_SCROLLBAR_PAN_START) {
      scrollbar.barY.onPanMove(ev);
    }
  },
  _onScrollBarPanEnd: function (ev) {
    if (this._getGroup('processesGroup')) {
      return;
    }

    var vanchart = this.vanchart,
        scrollbar = this.scrollbar;
    var ganttScrollBar = vanchart.ganttScrollBar;

    if (ganttScrollBar._panState === X_SCROLLBAR_PAN_START) {
      scrollbar.barX.onPanEnd(ev);
    } else if (ganttScrollBar._panState === Y_SCROLLBAR_PAN_START) {
      scrollbar.barY.onPanEnd(ev);
    }

    ganttScrollBar._panState = null;
  },
  // not strict since y is within bounds
  _shouldYMove: function (p) {
    return p.y > this.model.bounds.y + this.model.tableDims.headerHeight;
  },
  _shouldXMove: function (p) {
    return _BaseUtils["default"].containsPoint(this.model.bounds, p);
  },
  onScrollX: function (data) {
    this.moveInner(data);
  },
  onScrollY: function (data) {
    this.moveInner(data);
  },

  /**
   * check and set inner group position
   * @param {Object} pos = {
   *     x: {Number}
   *     y: {Number}
   * }
   * @returns {Object} pos // valid pos
   * @private
   */
  _setInnerPos: function (pos) {
    var x, y;

    if (pos) {
      if (pos.x != null) {
        x = pos.x;
      }

      if (pos.y != null) {
        y = pos.y;
      }
    }

    if (x == null) {
      x = this.innerPosX;
    }

    if (y == null) {
      y = this.innerPosY;
    }

    x = min(max(this.model.bounds.width - this._getInnerWidth(), x), 0);
    y = min(max(this.visibleBodyHeight - this.innerBodyHeight, y), 0);

    if (x !== this.innerPosX || y !== this.innerPosY) {
      this._showShadow && this._showShadow(x !== 0); // this._getGroup('header').attr('transform', BaseUtils.makeTranslate([x, 0]));
      // this._getGroup('inner-body').attr('transform', BaseUtils.makeTranslate([x, y]));
      // horizontal virtual

      /**
       * Dirty:
       */

      if (this._canMoveX()) {
        this._getGroup('header').attr('transform', _BaseUtils["default"].makeTranslate([x, 0]));

        this._getGroup('inner-body').attr('transform', _BaseUtils["default"].makeTranslate([x, y]));
      } else {
        this._getGroup('inner-body').attr('transform', _BaseUtils["default"].makeTranslate([0, y]));
      }

      this.innerPosX = x;
      this.innerPosY = y;
      this.fire('innerChange', {
        x: x,
        y: y
      });
    }
  },
  _canMoveX: function () {
    return true;
  },

  /**
   * 判断当前view是否滚动到边界，无法在拖拽方向上继续滚动
   * @param ev
   * @returns {boolean}
   */
  isViewScrollAtTheBoundary: function (ev) {
    var posX = this.innerPosX,
        posY = this.innerPosY;
    var limitBounds = this.getViewScrollBoundary();
    var direction = ev.direction;
    return posX === limitBounds.left && direction === _Constants["default"].DIRECTION_LEFT || posX === limitBounds.right && direction === _Constants["default"].DIRECTION_RIGHT || posY === limitBounds.top && direction === _Constants["default"].DIRECTION_UP || posY === limitBounds.bottom && direction === _Constants["default"].DIRECTION_DOWN;
  },

  /**
   * 获取当前view的滚动边界
   * @returns {{left: number, right: number, top: number, bottom: number}}
   */
  getViewScrollBoundary: function () {
    return {
      left: this.model.bounds.width - this._getInnerWidth(),
      right: 0,
      top: this.visibleBodyHeight - this.innerBodyHeight,
      bottom: 0
    };
  },
  onresizeStart: function (ev) {
    this._initX = this.model.bounds.x;
    this._initWidth = this.model.bounds.width;
    this._initPointX = ev.containerPoint.x;
  },
  onresizeMove: function () {
    this._setInnerPos(); // bounds checking


    this.update();

    this._fireResize();
  },
  _fireResize: function () {
    this.fire('resize', {
      width: this.model.bounds.width,
      height: this.visibleBodyHeight,
      innerWidth: this._getInnerWidth(),
      innerHeight: this.innerBodyHeight
    });
  },
  onover: function (ev) {
    if (_BaseUtils["default"].containsPoint(this.model.bounds, ev.containerPoint)) {
      this.fire('mouseover');
    } else {
      this.fire('mouseout');
    }
  }
});

exports["default"] = _default;

/***/ }),
/* 87 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _dateFormat = _interopRequireDefault(__webpack_require__(88));

var _dateDuration = _interopRequireDefault(__webpack_require__(158));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/2/13.
 */
var formatDate = _dateFormat["default"].formatDate;
var DAY_SECOND = 864e5;
var HALF_HOUR = 'halfHour',
    TEN_MINUTE = 'tenMinute',
    FIVE_MINUTE = 'fiveMinute',
    HALF_MINUTE = 'halfMinute',
    TEN_SECOND = 'tenSecond',
    YEAR = 'year',
    MONTH = 'month',
    HALF_YEAR = 'halfYear',
    QUARTER = 'quarter',
    WEEK = 'week',
    DAY = 'day',
    DATE = 'date',
    MERIDIEM = 'meridiem',
    Q_DAY = 'qDay',
    HOUR = 'hour',
    MINUTE = 'minute',
    SECOND = 'second',
    MILLISECOND = 'millisecond'; // for gantt unit, not a basic unit

var additional = [HALF_HOUR, TEN_MINUTE, FIVE_MINUTE, HALF_MINUTE, TEN_SECOND];
var unitList = [YEAR, MONTH, HALF_YEAR, QUARTER, WEEK, DAY, DATE, MERIDIEM, Q_DAY, HOUR, MINUTE, SECOND, MILLISECOND];
var ALIAS = {};
additional.map(function (unit) {
  ALIAS[unit + 's'] = unit;
});
unitList.map(function (unit) {
  ALIAS[unit + 's'] = unit;
});
/**
 *
 * @param num
 * @param from
 * @param to
 * @returns {{
 * c: number,  c circles
 * r: number   r remainder
 * }}
 */

function getCR(num, from, to) {
  var c = Math.floor((num - from) / (to - from + 1));
  var r = num - (to - from + 1) * c;
  return {
    c: c,
    r: r
  };
}

function isLeapYear(year) {
  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
}

function daysInYear(year) {
  return isLeapYear(year) ? 366 : 365;
} // https://en.wikipedia.org/wiki/ISO_week_date#First_week
// 4 Jan is always in the first week


function firstWeekOffset(year) {
  var jan4Day = new Date(year, 0, 4).getDay() || 7;
  return 4 - jan4Day;
}

function weeksInYear(year) {
  var weekOffset = firstWeekOffset(year),
      weekOffsetNext = firstWeekOffset(year + 1);
  return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
}
/**
 * get local date unit
 * @param date
 * @constructor
 */


var DateUnits = function (date) {
  this._d = date;
};

var proto = DateUnits.prototype = {
  valueOf: function () {
    return +this._d;
  },
  year: function (year) {
    if (year != null) {
      this._d.setFullYear(year);

      return this;
    }

    return this._d.getFullYear();
  },

  /**
   * month from 0
   * @returns {number|Object}
   */
  month: function (month) {
    if (month != null) {
      this._d.setMonth(month);

      return this;
    }

    return this._d.getMonth();
  },

  /**
   * get 1 or 2 (h1 or h2)
   * @returns {number|Object}
   */
  halfYear: function (h) {
    if (h != null) {
      var o = getCR(h, 1, 2);
      o.c && this.year(this.year() + o.c);
      this.month(o.r === 1 ? 0 : 6);
      return this;
    }

    return this.month() < 6 ? 1 : 2;
  },

  /**
   * quarter 1, 2, 3, 4
   * @returns {number|Object}
   */
  quarter: function (q) {
    if (q != null) {
      var o = getCR(q, 1, 4);
      o.c && this.year(this.year() + o.c);
      this.month((o.r - 1) * 3);
      return this;
    }

    return Math.ceil((this.month() + 1) / 3);
  },
  dayOfYear: function () {
    return Math.floor((this._d - new Date(this.year(), 0, 1)) / DAY_SECOND) + 1;
  },

  /**
   * 1-53 week of year
   * https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
   * @returns {{week: number, year: number}}
   */
  // moving to 'doy, dow' version may be better
  // doy = 1, dow = 4 now
  weekOfYear: function () {
    var week = Math.floor((this.dayOfYear() - (this.day() || 7) + 10) / 7);
    var year = this.year();

    if (week < 1) {
      year -= 1;
      week = weeksInYear(year);
    } else if (week > weeksInYear(year)) {
      week = week - weeksInYear(year);
      year += 1;
    }

    return {
      week: week,
      year: year
    };
  },
  week: function () {
    return this.weekOfYear().week;
  },
  day: function (day) {
    if (day != null) {
      var diff = day - (this.day() || 7);

      this._d.setDate(this.date() + diff);

      return this;
    }

    return this._d.getDay();
  },
  date: function (date) {
    if (date != null) {
      this._d.setDate(date);

      return this;
    }

    return this._d.getDate();
  },

  /**
   * 1 for a.m.; 2 for p.m.
   * @returns {number|Object}
   */
  meridiem: function (m) {
    if (m != null) {
      var o = getCR(m, 1, 2);
      o.c && this.date(this.date() + o.c);
      this.hours(o.r === 1 ? 0 : 12);
      return this;
    }

    return this.hours() < 12 ? 1 : 2;
  },

  /**
   * 1 for 0~6; 2 for 6~12; 3 for 12~18; 4 for 18~24
   * @param q
   * @returns {number|object}
   */
  qDay: function (q) {
    if (q != null) {
      var o = getCR(q, 1, 4);
      o.c && this.date(this.date() + o.c);
      this.hour((o.r - 1) * 6);
      return this;
    }

    return Math.ceil((this.hour() + 1) / 6);
  },
  hour: function (h) {
    if (h != null) {
      this._d.setHours(h);

      return this;
    }

    return this._d.getHours();
  },
  minute: function (min) {
    if (min != null) {
      this._d.setMinutes(min);

      return this;
    }

    return this._d.getMinutes();
  },
  second: function (s) {
    if (s != null) {
      this._d.setSeconds(s);

      return this;
    }

    return this._d.getSeconds();
  },
  millisecond: function (ms) {
    if (ms != null) {
      this._d.setMilliseconds(ms);

      return this;
    }

    return this._d.getMilliseconds();
  },
  _roundMinute: function (step) {
    var m = Math.floor(this._d.getMinutes() / step) * step;

    this._d.setMinutes(m);
  },
  _roundSecond: function (step) {
    var s = Math.floor(this._d.getSeconds() / step) * step;

    this._d.setSeconds(s);
  },
  startOf: function (units) {
    units = ALIAS[units] || units;

    switch (units) {
      case YEAR:
        this.month(0);

      /* falls through */

      case HALF_YEAR:
      case QUARTER:
      case MONTH:
        this.date(1);

      /* falls through */

      case WEEK:
      case DAY:
      case DATE:
        this.hours(0);

      /* falls through */

      case HOUR:
      case MERIDIEM:
      case Q_DAY:
        this.minutes(0);

      /* falls through */

      case MINUTE:
      case HALF_HOUR:
      case TEN_MINUTE:
      case FIVE_MINUTE:
        this.seconds(0);

      /* falls through */

      case SECOND:
      case HALF_MINUTE:
      case TEN_SECOND:
        this.milliseconds(0);
        break;

      default:
        throw units + ' error';
    }

    switch (units) {
      case WEEK:
        this.day(1);
        break;

      case QUARTER:
      case HALF_YEAR:
      case MERIDIEM:
      case Q_DAY:
        this[units](this[units]());
        break;

      case HALF_HOUR:
        this._roundMinute(30);

        break;

      case TEN_MINUTE:
        this._roundMinute(10);

        break;

      case FIVE_MINUTE:
        this._roundMinute(5);

        break;

      case HALF_MINUTE:
        this._roundSecond(30);

        break;

      case TEN_SECOND:
        this._roundSecond(10);

        break;
    }

    return this;
  },
  endOf: function (units) {
    if (!units || units === MILLISECOND || units === 'milliseconds') {
      return this;
    }

    return this.add(1, units).startOf(units).add(-1, MILLISECOND);
  },
  add: function (number, period) {
    period = ALIAS[period] || period;

    switch (period) {
      case HALF_YEAR:
        this.add(number * 6, MONTH);
        break;

      case QUARTER:
        this.add(number * 3, MONTH);
        break;

      case WEEK:
        this.add(number * 7, DATE);
        break;

      case MERIDIEM:
        this.add(number * 12, HOUR);
        break;

      case Q_DAY:
        this.add(number * 6, HOUR);
        break;

      case HALF_HOUR:
        this.add(number * 30, MINUTE);
        break;

      case TEN_MINUTE:
        this.add(number * 10, MINUTE);
        break;

      case FIVE_MINUTE:
        this.add(number * 5, MINUTE);
        break;

      case HALF_MINUTE:
        this.add(number * 30, SECOND);
        break;

      case TEN_SECOND:
        this.add(number * 10, SECOND);
        break;

      default:
        if (period === DAY) {
          period = DATE;
        }

        var now = this.get(period);
        this[period](now + number);
    }

    return this;
  },
  isWeekend: function () {
    var d = this.day();
    return d === 6 || d === 0;
  }
}; // alias

unitList.map(function (unit) {
  proto[unit + 's'] = proto[unit];
});

proto.get = function (unit) {
  return this[unit]();
};

proto.format = function (inputString) {
  return formatDate(this, inputString);
};

var dateUnits = function (date) {
  var dateObject;

  if (date instanceof DateUnits) {
    dateObject = new Date(date._d);
  } else if (date) {
    // loose check
    dateObject = new Date(date);
  } else {
    dateObject = new Date();
  }

  return new DateUnits(dateObject);
};

dateUnits.isLeapYear = isLeapYear;
dateUnits.daysInYear = daysInYear;
dateUnits.firstWeekOffset = firstWeekOffset;
dateUnits.weeksInYear = weeksInYear;
dateUnits.setLocale = _dateFormat["default"].setLocale;
dateUnits.duration = _dateDuration["default"];
var _default = dateUnits;
exports["default"] = _default;

/***/ }),
/* 88 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by Yuqian on 2017/2/22.
 */

/*
 Copyright (c) JS Foundation and other contributors

 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
 files (the "Software"), to deal in the Software without
 restriction, including without limitation the rights to use,
 copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following
 conditions:

 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.

 https://github.com/moment/moment
 */
var defaultValues = {};
var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w{1,3}|wo|W[o|W]?|Q{2,3}|Qo?|[yY]{2,6}|gg(ggg?)?|GG(GGG?)?|e{2,6}|E{1,6}|a|A|hh?|HH?H?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
var formatFunctions = {};
var formatTokenFunctions = {};
var durationTokenFunctions = {};

function zeroFill(number, targetLength, forceSign) {
  var absNumber = '' + Math.abs(number),
      zerosToFill = targetLength - absNumber.length,
      sign = number >= 0;
  return (sign ? forceSign ? '+' : '' : '-') + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
}

function addFormatToken(token, padded, ordinal, callback) {
  var func = callback;

  if (typeof callback === 'string') {
    func = function () {
      return this[callback]();
    };
  }

  if (token) {
    formatTokenFunctions[token] = func;
  }

  if (padded) {
    formatTokenFunctions[padded[0]] = function () {
      return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
    };
  }
}

function removeFormattingTokens(input) {
  if (input.match(/\[[\s\S]/)) {
    return input.replace(/^\[|\]$/g, '');
  }

  return input.replace(/\\/g, '');
}

function makeFormatFunction(format) {
  var array = format.match(formattingTokens),
      i,
      length;

  for (i = 0, length = array.length; i < length; i++) {
    if (formatTokenFunctions[array[i]]) {
      array[i] = formatTokenFunctions[array[i]];
    } else {
      array[i] = removeFormattingTokens(array[i]);
    }
  }

  return function (mom) {
    var output = '',
        i;

    for (i = 0; i < length; i++) {
      output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
    }

    return output;
  };
}

function formatDate(m, format) {
  formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
  return formatFunctions[format](m);
} // according to Wang Jun's doc
// 1.222 -> 1.22; 1.20 -> 1.2


function decimalAdjust(value, exp) {
  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? +value[1] - exp : -exp))); // Shift back

  value = value.toString().split('e');
  return +(value[0] + 'e' + (value[1] ? +value[1] + exp : exp));
} // default format like: '25.5hours'


function defaultDurationFormatFunc(token, d) {
  return decimalAdjust(d.get(token), -2) + defaultValues.duration[token];
}

function formatDuration(d, token) {
  if (durationTokenFunctions[token] == null) {
    if (typeof defaultValues.duration[token] === 'string') {
      durationTokenFunctions[token] = defaultDurationFormatFunc.bind(null, token);
    } else {
      // function
      durationTokenFunctions[token] = defaultValues.duration[token];
    }
  }

  return durationTokenFunctions[token](d);
}

function setLocale(config) {
  // if we had to change the locale after load
  // clear and re-init following cache
  // formatFunctions = {};
  // formatTokenFunctions = {};
  // durationTokenFunctions = {};
  for (var prop in config) {
    if (prop.charAt(0) === '_') {
      continue;
    }

    if (prop === 'base') {
      config.base(addFormatToken, defaultValues);
    } else {
      defaultValues[prop] = config[prop];
    }
  }
} // format according to
// http://www.unicode.org/reports/tr35/tr35-dates.html#Parsing_Dates_Times
//
// custom:
// half year = N
// 1/4 day = I
// HHH


var add = addFormatToken; // year

add('y', 0, 0, function () {
  var y = this.year();
  return y <= 9999 ? '' + y : '+' + y;
});
add(0, ['yy', 2], 0, function () {
  return this.year() % 100;
});
add(0, ['yyyy', 4], 0, 'year');
add('Y', 0, 0, function () {
  var y = this.year();
  return y <= 9999 ? '' + y : '+' + y;
});
add(0, ['YY', 2], 0, function () {
  return this.year() % 100;
});
add(0, ['YYYY', 4], 0, 'year'); // useful?

add(0, ['yyyyy', 5], 0, 'year');
add(0, ['yyyyyy', 6, true], 0, 'year'); // half year

add('N', 0, 0, function () {
  return defaultValues.halfYears[this.halfYear() - 1];
}); // quarter

add('Q', ['QQ', 2], 0, 'quarter');
add('QQQ', 0, 0, function () {
  return defaultValues.quarters[this.quarter() - 1];
}); // month

add('M', ['MM', 2], 'Mo', function () {
  return this.month() + 1;
});
add('MMM', 0, 0, function () {
  return defaultValues.monthsShort[this.month()];
});
add('MMMM', 0, 0, function () {
  return defaultValues.months[this.month()];
}); // 和FR那边保持一致吧，FR那边MMMM和MMMMM都表示的是中文月份(十一月)

add('MMMMM', 0, 0, function () {
  return defaultValues.months[this.month()];
}); // week of year

add('w', ['ww', 2], 0, 'week');
add('www', 0, 0, function () {
  return 'Week' + this.week();
}); // week day

add('e', ['ee', 2], 0, 'day');
add('eee', 0, 0, function () {
  return defaultValues.weekdaysShort[this.day()];
});
add('eeee', 0, 0, function () {
  return defaultValues.weekdays[this.day()];
});
add('eeeeee', 0, 0, function () {
  return defaultValues.weekdaysMin[this.day()];
}); // CHART-1720  同eeee

add('EEEEE', 0, 0, function () {
  return defaultValues.weekdays[this.day()];
}); // date

add('d', ['dd', 2], 0, 'date'); // am/pm

add('a', 0, 0, function () {
  return defaultValues.meridiem[this.meridiem() - 1];
}); // 1/4 day

add('I', 0, 0, function () {
  return defaultValues.qDay[this.qDay() - 1];
}); // hour

add('H', ['HH', 2], 0, 'hour');
add('h', ['hh', 2], 0, 'hour'); // custom format

add('HHH', 0, 0, function () {
  return this.hour() + 'h';
}); // minute

add('m', ['mm', 2], 0, 'minute'); // second

add('s', ['ss', 2], 0, 'second');
var _default = {
  // addFormatToken: addFormatToken,
  formatDate: formatDate,
  formatDuration: formatDuration,
  setLocale: setLocale
};
exports["default"] = _default;

/***/ }),
/* 89 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getDomainFromPoints = getDomainFromPoints;
exports.getValueFromDatum = getValueFromDatum;
exports["default"] = void 0;

var _BaseAxis = _interopRequireDefault(__webpack_require__(63));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _component = __webpack_require__(4);

var _AxisUtils = __webpack_require__(40);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/11/2.
 */
var SECOND = 1000;
var MINUTE = SECOND * 60;
var HOUR = MINUTE * 60;
var DAY = HOUR * 24;
var MONTH = DAY * 31;
var YEAR = 12 * MONTH;

var DateAxis = _BaseAxis["default"].extend({
  type: _component.ComponentCst.DATE_AXIS_COMPONENT,
  getAxisValue: function (value) {
    return _BaseUtils["default"].object2date(value);
  },
  fixScaleAndTickData: function () {
    var domain = [_BaseUtils["default"].int2date(this._domain[0]), _BaseUtils["default"].int2date(this._domain[1])]; // this.scale.domain(domain).rangeRound(this._getRange());

    this.scale.domain(domain).range(this._getRange()); //@CHART-1674
    //domain确定以后，日期坐标轴要确定默认的日期格式

    this._calculateDateFormat();

    this._updateOriginTickData();

    this._calculateTickPosAndStep();
  },
  _calculateDateFormat: function () {
    var tickInterval = this._step;
    var format = 'Dyyyy';

    if (tickInterval <= SECOND) {
      format = 'Dss';
    } else if (tickInterval <= MINUTE) {
      format = 'Dmm:ss';
    } else if (tickInterval <= HOUR) {
      format = 'Dhh:mm';
    } else if (tickInterval <= DAY) {
      format = 'Ddd-hh';
    } else if (tickInterval <= MONTH) {
      format = 'DMM-dd';
    } else if (tickInterval <= YEAR) {
      format = 'Dyyyy-MM';
    }

    this.dateFormat = format;
  },
  _getTickContent: function (tick, formatter) {
    var format = this.dateFormat; //todo 为了兼容跟FR一样的格式，无奈之举

    function formatFunc(cv) {
      return window.FR && window.FR.contentFormat(cv, format) || cv;
    }

    formatter = formatter || formatFunc;
    return _BaseUtils["default"].format(tick, formatter);
  },
  initScale: function () {
    this.lastScale = this.scale;
    this.scale = _Scale["default"].linear();
  },
  _getStartAndEndTick: function () {
    return [_BaseUtils["default"].int2date(this._domain[0]), _BaseUtils["default"].int2date(this._domain[1])];
  },
  _getTickValues: function () {
    var _this$options = this.options,
        min = _this$options.min,
        max = _this$options.max,
        tickInterval = _this$options.tickInterval;
    return (0, _AxisUtils.getLinearFormatTicks)({
      options: {
        min: min,
        max: max,
        tickInterval: tickInterval
      },
      formatObj: _BaseUtils["default"].int2date,
      min: this._tickStart,
      max: this._domain[1],
      interval: this._step
    });
  },
  _valueInDomain: function (value) {
    var domain = this.scale.domain();
    return value >= Math.min(domain[0], domain[1]) && value <= Math.max(domain[0], domain[1]);
  },
  _getDomainFromData: function () {
    var minValue = Math.ceil(Number.MAX_VALUE);
    var maxValue = -minValue;
    var hasValidData = false;
    var series = this.series;

    for (var i = 0, len = series.length; i < len; i++) {
      var sery = series[i];
      var byAxis = sery[this.componentType];

      if (byAxis == this && sery.visible) {
        this.getTrendLineForecast(series[i]);
        var seryDomain = getDomainFromPoints(sery.points, this.componentType);

        if (seryDomain && seryDomain.length === 2) {
          hasValidData = true;
          minValue = Math.min(minValue, seryDomain[0]);
          maxValue = Math.max(maxValue, seryDomain[1]);
        }
      }
    }

    if (!hasValidData) {
      minValue = maxValue = new Date().getTime();
    }

    maxValue = minValue >= maxValue ? minValue + SECOND : maxValue;
    return [minValue, maxValue];
  }
});

function getDomainFromPoints(points, type) {
  if (points == null || points.length === 0) {
    return;
  }

  var hasValidData = false,
      min = Math.ceil(Number.MAX_VALUE),
      max = -min;

  for (var i = 0, len = points.length; i < len; i++) {
    var value = getValueFromDatum(points[i], type);

    if (value.getTime) {
      hasValidData = true;
      value = _BaseUtils["default"].date2int(value);
      min = Math.min(min, value);
      max = Math.max(max, value);
    }
  }

  if (hasValidData) {
    return [min, max];
  }
}

function getValueFromDatum(datum, type) {
  var index = type === _component.ComponentCst.X_AXIS_COMPONENT ? 0 : 1;
  var key = type === _component.ComponentCst.X_AXIS_COMPONENT ? 'x' : 'y';
  var value = _BaseUtils["default"].isArray(datum) ? datum[index] : datum[key];
  return _BaseUtils["default"].object2date(value);
}

var _default = DateAxis;
exports["default"] = _default;

/***/ }),
/* 90 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getForecastCategory = getForecastCategory;
exports.getSingleForecastCategoryContent = getSingleForecastCategoryContent;
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _CategoryAxis = _interopRequireDefault(__webpack_require__(51));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BoundsManager = _interopRequireDefault(__webpack_require__(25));

var _component = __webpack_require__(4);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Cmen on 2017/6/29.
 */
var LAST_MAIN_TICK_LINE_KEY = "LAST_MAIN_TICK_LINE";
var EMPTY_STR_LEN = 2;

var AXIS_GAP = 4,
    // 多层级之间的间隔
AXIS_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(AXIS_GAP);
};

var LABEL_LINE_GAP = 4;

var LABEL_LINE_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(LABEL_LINE_GAP);
};

var TICK_LENGTH = 4;
var MAIN_TICK = "main";
var decodeArray = _BaseUtils["default"].decodeCategoryArray,
    encodeArray = _BaseUtils["default"].encodeCategoryArray;

var MultiCategoryAxis = _CategoryAxis["default"].extend({
  /**
   * 计算Axis.tickData，用于绘制tickLabel，传统的tickData为一维数组
   * 在多分类轴下，axis.tickData为多维数组，第一维度表示的是分类轴的层级
   * @return {[type]} [description]
   */
  _updateOriginTickData: function () {
    var axisOption = this.options;

    var labelsArray = this._getTickValues();

    this._calculateLabelRotation(labelsArray[0]); // 标签旋转只考虑第一维


    this.tickData = [];

    for (var i = -1; ++i < labelsArray.length;) {
      var labels = labelsArray[i];
      this.tickData[i] = [];

      for (var j = -1; ++j < labels.length;) {
        var tickValue = labels[j].tickValue,
            tickContent = axisOption.showLabel ? labels[j].content : '';
        this.tickData[i].push(this._calculateSingleTickData(tickValue, tickContent, {
          length: labels[j].length
        }) // length:改分类存在多少个最底层分类轴
        );
      }
    }

    this._updateTickLengthMap(); // 更新间隔线高度Map


    this._setPeriod();
  },

  /**
   * 计算tickValues， 多分类轴下是个二维数组，第一维表示的层级，第二维表示层内的tick
   * @return {[type]} [description]
   */
  _getTickValues: function () {
    var axisArray = [];
    var domain = this._domain;
    domain.forEach(function (cateArrayStr) {
      axisArray.push(decodeArray(cateArrayStr));
    });
    var sortMap = {},
        sortArr = [];
    var pos = this.getPosition();
    var i,
        len = axisArray.length;
    var k1 = this.isAxisReversed() ? 1 : 0,
        k2 = pos === _Constants["default"].LEFT || pos === _Constants["default"].RIGHT ? 1 : 0;
    /**
     * 轴逆序或者在轴在侧边的时候，需要倒过来计算tickValues
     * 其他的情况则按0-len顺序计算
     */

    var reverse = (k1 + k2) % 2;

    if (reverse) {
      for (i = len; --i >= 0;) {
        pushCateMap(axisArray[i]);
      }
    } else {
      for (i = -1; ++i < len;) {
        pushCateMap(axisArray[i]);
      }
    }

    function pushCateMap(categoryArray) {
      var identifierArray = [];
      categoryArray.forEach(function (cate, index) {
        if (!sortArr[index]) {
          sortArr[index] = [];
        } // 分类轴有多少个层级，计算出的tickValues就有几个维度


        identifierArray.push(cate);
        var identifier = encodeArray(identifierArray); // 这边的做法是判断并更新那个层级中具体分类名的层级，出现次数

        if (sortMap[identifier]) {
          sortMap[identifier].length++;
        } else {
          sortMap[identifier] = {
            content: cate,
            level: index,
            length: 1,
            tickValue: encodeArray(categoryArray)
          };
        }
      });
    } // 这边使用map来计算arr，不知道会不会出现顺序错乱的问题，如果低版本ie出现问题，得考虑换一种写法


    for (var identifier in sortMap) {
      var cateInfo = sortMap[identifier],
          index = cateInfo.level;
      sortArr[index].push({
        content: cateInfo.content,
        length: cateInfo.length,
        tickValue: cateInfo.tickValue
      });
    } // 顺序颠倒一下，绘制的时候方便一些


    return sortArr.map(function (lineTicks, index, array) {
      return array[array.length - index - 1];
    });
  },

  /**
   * 计算多分类轴下标签占据的尺寸，Axis.doLayout时候计算裁剪时需要
   * @return {[type]} [description]
   */
  _getTickLabelLength: function () {
    var tickValues = this._getTickValues(),
        axisGap = AXIS_GAP_FUN();

    var option = this.options,
        axis = this;
    var totalHeight = 0,
        // 多层级占据总高度
    tickLengthArray = [],
        // 主要间隔线的长度数组
    labelStartPosArray = []; // 不同层级的标签起始位置（相对于最底层分类轴的偏移量）

    var defultTickLength = isNaN(+option.tickLength) ? TICK_LENGTH : option.tickLength;

    if (option.showLabel) {
      totalHeight += isNaN(+option.tickPadding) ? LABEL_LINE_GAP_FUN() : option.tickPadding;
    }

    if (option.enableTick) {
      totalHeight += defultTickLength;
    }

    var start_gap = totalHeight;
    var isHorizontal = this.isHorizontal();
    var ticksLen = tickValues.length;

    for (var i = -1; ++i < ticksLen;) {
      labelStartPosArray.push(totalHeight - start_gap);
      var lineHeight = 0,
          lineTicks = tickValues[i];
      lineTicks.forEach(function (tickInfo) {
        var textDim = axis._getTickDim(tickInfo.content, option.formatter);

        lineHeight = Math.max(lineHeight, isHorizontal ? textDim.height : textDim.width);
      });
      totalHeight += lineHeight + (i === ticksLen - 1 ? 0 : axisGap);
      tickLengthArray.push(i === 0 ? defultTickLength : totalHeight);
    }

    this._tickLengthArray = tickLengthArray;
    this._tickLabelStartPosArray = labelStartPosArray;
    return option.showLabel ? totalHeight + LABEL_LINE_GAP_FUN() : 0;
  },

  /**
   * 更新存储间隔线长度的Map
   * @return {[type]} [description]
   */
  _updateTickLengthMap: function () {
    var tickValues = this._getTickValues();

    var tickLengthArray = this._tickLengthArray,
        len = tickLengthArray.length;
    var calcMap = {}; // 先计算

    for (var i = tickValues.length; --i >= 0;) {
      var lineTicks = tickValues[i];

      for (var j = -1; ++j < lineTicks.length;) {
        var tickValue = lineTicks[j].tickValue;

        if (!calcMap[tickValue]) {
          calcMap[tickValue] = tickLengthArray[i];
        }
      }
    }

    calcMap[LAST_MAIN_TICK_LINE_KEY] = tickLengthArray[len - 1];
    this._tickLengthMap = calcMap;
  },
  addTrendLineCategories: function (categories) {
    if (categories && categories.length) {
      var level = decodeArray(categories[0]).length;

      if (this.forecast && (this.forecast[0] || this.forecast[1])) {
        var leftForecast = getForecastCategory(-this.forecast[0], 0, level);
        var emptyCharLength = this.forecast[0] ? -this.forecast[0] : 0;
        var rightForecast = getForecastCategory(this.forecast[1], emptyCharLength, level);
        categories = leftForecast.concat(categories).concat(rightForecast);
      }
    }

    return categories;
  },

  /**
   * 根据传入的tickValue计算所在的间隔线的高度
   * @param  {[type]} tickValue [description]
   * @return {[type]}           [description]
   */
  _getTickLength: function (tickValue) {
    return this._tickLengthMap[tickValue];
  },

  /**
   * 绘制主要间隔线，多分类轴下次级间隔线绘制手法不变
   * @param  {[type]} option [description]
   * @return {[type]}        [description]
   */
  _drawMainTickLine: function (option) {
    var ticks = this.getTickData(),
        axis = this;
    var plotBounds = this.getPlotBounds(),
        pos = this.getPosition();
    var isBottomOrTop = pos === _Constants["default"].BOTTOM || pos === _Constants["default"].TOP;
    ticks = ticks.concat([{
      tickPos: isBottomOrTop ? plotBounds.width : plotBounds.height - 1,
      tickValue: LAST_MAIN_TICK_LINE_KEY
    }]); // 绘制结尾处的间隔线

    option.keyFunction = function (datum) {
      return datum.tickValue;
    }; // identifier，用于标识间隔线


    option.tickLengthFuc = function (datum) {
      // 不同的层级对应的间隔线高度不一致，这里根据间隔线的key来计算
      return axis._getTickLength(datum.tickValue) || option.tickLength;
    };

    this.tickLines[MAIN_TICK] = this._drawTickLineWithData(this.tickLines[MAIN_TICK], ticks, option);
  },

  /**
   * 获取坐标轴上点的scaleKey，在柱形图里面计算系列位置的时候会用到
   * @param  {[type]} value [description]
   * @param  {[type]} point [description]
   * @return {[type]}       [description]
   */
  getAxisValue: function (value, point) {
    return point.getCategory();
  },

  /**
   * 很多计算都是使用最低一层分类轴上的tickData。
   * 而多分类轴下tickData为二维数组，因此这里返回tickData[0]
   * @return {[type]} [description]
   */
  getTickData: function () {
    return this.tickData[0] || [];
  },

  /**
   * 返回所有的层级的tickData
   * @return {[type]} [description]
   */
  getMultiTickData: function () {
    return this.tickData;
  },

  /**
   * 对dataDomain进行重新排序：
   * 主要为了解决多分类轴，新增数据点或者对于不规整数据诸如["A","B","C"], ["a","b","c"],["A","C","D"]应该整理成
   * ["A","B","C"],["A","C","D"], ["a","b","c"]的顺序--即具有相同父层级的应该在一起
   * @param categories
   */
  resortDataDomain: function (categories) {
    var domainData = categories.map(function (cate) {
      return decodeArray(cate);
    });
    var levels = domainData[0].map(function () {
      return [];
    });
    var i,
        j,
        data,
        dataStr,
        storageMap = {}; // 先将传入的categories分层

    for (i = -1; ++i < levels.length;) {
      for (j = -1; ++j < domainData.length;) {
        data = domainData[j].slice(0, i + 1);
        dataStr = encodeArray(data);

        if (!storageMap[dataStr]) {
          storageMap[dataStr] = true;
          var identifier = encodeArray(data); // 诸如[""]这样的，生成的id应该是[""

          levels[i].push(identifier.substr(0, identifier.length - 1));
        }
      }
    }

    var levelsLen = levels.length;
    var lastLevel = levels[levelsLen - 1].map(function (str) {
      return str;
    }); // 以最后一层为基础，相对于倒数第二层，进行排序

    return sortLevel(levelsLen - 2, lastLevel).map(function (cate) {
      return encodeArray(decodeArray(cate + "]"));
    });

    function sortLevel(index, lastLevel) {
      // 第一层排序完成则直接返回lastLevel
      if (index < 0) {
        return lastLevel;
      }

      var newLevel = [];
      var curLevel = levels[index],
          curLevellen = curLevel.length;

      for (i = -1; ++i < curLevellen;) {
        var curStr = curLevel[i];

        for (j = -1; ++j < lastLevel.length;) {
          var lastStr = lastLevel[j];

          if (lastStr.indexOf(curStr) === 0) {
            newLevel.push(lastStr);
          }
        }
      } // 递归排序


      return sortLevel(index - 1, newLevel);
    }
  },

  /**
   * 绘制svg标签，多分类轴下，应该根据标签的层级不同来分开绘制
   * @return {[type]} [description]
   */
  _drawSvgTickLabel: function () {
    var axis = this,
        renderer = this.vanchart.renderer;
    var multiTickData = this.getMultiTickData();

    if (!this.tickLabelsGroup) {
      this.tickLabelsGroup = renderer.vgroup().add();
      this.axisGroup.append(this.tickLabelsGroup.renderG);
      this.tickLabels = multiTickData.map(function () {
        return [];
      });
    } // 解决轴标签重叠的问题，只需要考虑第一层以上的轴上的标签


    for (var i = 0; ++i < multiTickData.length;) {
      this._fixConflictLabelsByTickData(multiTickData[i]);
    }

    multiTickData.forEach(function (tickData, index) {
      axis.tickLabels[index] = axis._drawSvgTickLabelWithData(axis.tickLabels[index], tickData, index);
    });
  },

  /**
   * 解决单行内的标签重叠问题
   * @private
   */
  _fixConflictLabelsByTickData: function (tickData) {
    var boundsManager = new _BoundsManager["default"]();
    var scale = this.scale,
        isHorizontal = this.isHorizontal();

    var getLabelBounds = function (labelObj) {
      var det = scale.rangeBand ? scale.rangeBand() / 2 * (labelObj.length || 1) : 0;
      var tickLabelPos = scale(labelObj.tickValue) + det;
      var labelDim = labelObj.tickDim; // 由于轴标签只在一个方向扩展， 因此只需要计算出轴所在防线的标签的位置，另外一个方向用一个固定的相同值即可

      return {
        x: isHorizontal ? tickLabelPos : 0,
        y: isHorizontal ? 0 : tickLabelPos,
        width: labelDim.width,
        height: labelDim.height
      };
    };

    var i,
        len = tickData.length,
        labelObj,
        labelBounds;

    for (i = -1; ++i < len;) {
      labelObj = tickData[i];
      labelBounds = getLabelBounds(labelObj);

      if (boundsManager.isOverlapped(labelBounds)) {
        labelObj.tickContent = "";
      } else {
        boundsManager.addBounds(labelBounds);
      }
    }
  },

  /**
   * 获取指定层级的标签相对于最底层分类轴的偏移值
   * @param  {[type]} level [description]
   * @return {[type]}       [description]
   */
  _getLabelStartPos: function (level) {
    return this._tickLabelStartPosArray[level];
  },

  /**
   * 判断是否为多分类轴
   * @return {Boolean} [description]
   */
  isMultiCateAxis: function () {
    return true;
  }
});

function getSingleForecastCategoryContent(emptyCharLength, level) {
  var emptyArray = _BaseUtils["default"].getTargetFillArray(EMPTY_STR_LEN + emptyCharLength, function (i) {
    return i;
  });

  var emptyStr = '"' + emptyArray.join(' ') + '"';
  var forecastCategoryArray = [];

  for (var i = 0; i < level; i++) {
    forecastCategoryArray.push(emptyStr);
  }

  return "[" + forecastCategoryArray.join(",") + "]";
}

function getForecastCategory(periodNum, emptyCharLength, level) {
  var getSingleContent = function () {
    return getSingleForecastCategoryContent(emptyCharLength++, level);
  };

  return _BaseUtils["default"].getTargetFillArray(periodNum, getSingleContent);
}

var _default = MultiCategoryAxis;
exports["default"] = _default;

/***/ }),
/* 91 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.fixBackgroundOptions = fixBackgroundOptions;

var _ThemeConfig = __webpack_require__(17);

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

function fixBackgroundOptions(vanchart, options) {
  if (!vanchart.isMap()) {
    return options;
  }

  var backgroundColor = (0, _ThemeConfig.getThemeAutoValue)(options.backgroundColor, 'mapLegendBackgroundColor', vanchart.isDarkTheme());
  return _extends({}, options, {
    backgroundColor: backgroundColor
  });
}

/***/ }),
/* 92 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _LegendIconFactory = _interopRequireDefault(__webpack_require__(53));

var _LegendItem = _interopRequireDefault(__webpack_require__(93));

var _Scrollbar = _interopRequireDefault(__webpack_require__(60));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _component = __webpack_require__(4);

var _EnvUtils = __webpack_require__(2);

var _helper = __webpack_require__(91);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/4.
 * 图例
 */
var PADDING = 5;

var PADDING_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING);
}; // Gap between legendItem-icon and legendItem-text


var GAP = 4;

var GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(GAP);
}; // Gap between legendItem & next legendItem when legend with horizontal layout


var HORIZONTAL_GAP = 10;

var HORIZONTAL_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(HORIZONTAL_GAP);
}; //文字换行 行间距为一行字高的0.2倍


var WORD_GAP = 0.2; //vertical layout。 Gap between legendItem & next legendItem is 一行字高的0.6倍。

var PARAGRAPH_GAP = 0.6;
var SCROLLBAR_WIDTH = 12; //横向布局，icon + icon_text_gap + text的最小长度

var MIN_WIDTH = 120;

var MIN_WIDTH_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(MIN_WIDTH);
};

var Legend = _Base["default"].extend({
  isFlowBottom: function () {
    return this.vanchart.isMobileFlow() && this.options.position === 'bottom';
  },
  doLayout: function () {
    this.items = this.items || [];

    if (this.invisible()) {
      this.remove();
      return;
    }

    this.yPanEnabled = false;

    this._updateLegendItems();

    this._layoutLegendItemBounds();
  },
  _updateLegendItems: function () {
    var series = this.vanchart.series,
        namedSeries = {},
        namedTrendLine = {},
        legend = this,
        vanchart = this.vanchart;
    var legendItemOptions = [],
        i,
        len;

    var isLarge = vanchart.isLargeMode(),
        isPointMapChart = vanchart.chartType() === _Constants["default"].POINT_MAP;

    var opacityMap = {}; // @Cmen-Chart-687
    // 饼图这一类图形，只有当条件属性设置系列透明度时，才对图例对应的透明度
    // 之前的问题是使用的第一个point的透明度来作为图例的透明度，理论上说是不正确的
    // 这里在生成legendItem之前，先遍历一边points，当具有相同bindName的point的opacity相同，才可以证明开启了系列透明

    for (i = -1; ++i < series.length;) {
      var ser = series[i];

      if (ser.type === _Constants["default"].GAUGE_CHART) {
        continue; // 测量类图表不支持图例，故no need
      }

      if (ser.isSeriesAccumulated()) {
        ser.points.forEach(function (point) {
          var bindName = legend._itemBindName(point);

          if (!opacityMap[bindName]) {
            opacityMap[bindName] = {
              opacity: point.opacity || 1,
              useSerOpacity: true
            };
          } else {
            if (opacityMap[bindName].opacity != point.opacity) {
              opacityMap[bindName].useSerOpacity = false;
            }
          }
        });
      }
    }

    for (i = 0, len = series.length; i < len; i++) {
      var sery = series[i],
          chartType = sery.type;

      if (chartType == _Constants["default"].GAUGE_CHART) {
        continue;
      }

      if (sery.isSeriesAccumulated()) {
        // BI-7057
        var ovk = chartType === _Constants["default"].PIE_CHART ? 'x' : 'name';
        var orderMap = {};
        sery.options.data.forEach(function (datum, i) {
          orderMap[datum[ovk]] = i;
        });
        var tmp = sery.type === _Constants["default"].FUNNEL_CHART ? sery.points : sery.points.slice().sort(function (a, b) {
          return orderMap[a[ovk]] - orderMap[b[ovk]];
        });
        tmp.map(function (point) {
          var bindName = legend._itemBindName(point);

          if (!namedSeries[bindName]) {
            var item = {
              color: vanchart.getDefaultSeriesColor(bindName),
              opacity: opacityMap[bindName].useSerOpacity ? opacityMap[bindName].opacity : 1,
              bindName: bindName,
              itemName: bindName,
              visible: point.visible
            };

            legend._mergeCommonLegendAttr(sery, item);

            namedSeries[bindName] = true;
            legendItemOptions.push(item);
          }
        });
      } else {
        var item;

        if (!namedSeries[sery.name]) {
          item = {
            color: sery.color,
            opacity: sery.type === _Constants["default"].BOX_CHART ? 1 : sery.opacity,
            bindName: sery.name,
            itemName: sery.name,
            visible: sery.visible
          };

          legend._mergeCommonLegendAttr(sery, item);

          namedSeries[sery.name] = item;
          legendItemOptions.push(item);
        }

        var isValidTrendLine = sery.options.trendLine && _Constants["default"].DASH_ARRAY[sery.options.trendLine.lineType] && !namedTrendLine[sery.name];

        if (isValidTrendLine) {
          item = {
            isTrendLine: true,
            color: sery.options.trendLine.color,
            opacity: sery.opacity,
            bindName: sery.name,
            itemName: sery.options.trendLine.name,
            visible: sery.visible
          };

          legend._mergeCommonLegendAttr(sery, item);

          item.legendIconType = _Constants["default"].NULL_MARKER; // log both legends

          namedSeries[sery.name].pairLegendOpt = item;
          item.pairLegendOpt = namedSeries[sery.name];
          namedTrendLine[sery.name] = item;
          legendItemOptions.push(item);
        }
      }
    }

    for (i = legendItemOptions.length, len = this.items.length; i < len; i++) {
      this.items[i].remove();
      this.items[i] = null;
    }

    for (i = 0, len = legendItemOptions.length; i < len; i++) {
      // 点地图大数据模式下，如果用户设置了图例是自定义图片的话，
      // 将图例转变成默认的散点实心圆
      isLarge && isPointMapChart && !_LegendIconFactory["default"].hasIcon(legendItemOptions[i].legendIconType) && (legendItemOptions[i].legendIconType = "scatter-legend-iconcircle");

      if (this.items[i]) {
        this.items[i].refresh(legendItemOptions[i]);
      } else {
        this.items[i] = new _LegendItem["default"](legend, legendItemOptions[i]);
      }
    }

    this.items.length = legendItemOptions.length;
  },
  _mergeCommonLegendAttr: function (sery, item) {
    var cfg = this.options;
    var hiddenColor = cfg.hiddenColor;
    var hoverColor = cfg.hoverColor || cfg.style.color;

    _BaseUtils["default"].extend(item, {
      series: sery,
      hiddenColor: hiddenColor,
      hoverColor: hoverColor,
      legendIconType: this._getLegendType(sery),
      lineIndex: 0 //记录下如果换行的行号

    });
  },
  _layoutLegendItemBounds: function () {
    //这边的padding是整个图例和别的组件的间隙
    var cfg = this.options,
        position = cfg.position || _Constants["default"].RIGHT;

    if (!this.items.length) {
      return;
    }

    if (position === _Constants["default"].TOP || position === _Constants["default"].BOTTOM) {
      this._layoutHorizontalLegendItemBounds(position);
    } else {
      //考虑不和工具栏&&标题重叠
      //更改:不考虑标题,因为标题已经裁剪过了，this.vanchart.bounds.y已经是考虑了标题的了
      var toolbarHeight = 0;

      if ((position === _Constants["default"].RIGHT || position === _Constants["default"].RIGHT_TOP) && !this.isFloat) {
        var tools = this.vanchart.getComponent(_component.ComponentCst.TOOLBAR_COMPONENT);
        tools && tools.options.hidden != false && (toolbarHeight = 37 + PADDING_FUN() * 2);
      }

      this._layoutVerticalLegendItemBounds(position, toolbarHeight);
    }
  },
  _layoutVerticalLegendItemBounds: function (position, startY) {
    var maxWidth = this._maxLegendWidth() - PADDING_FUN() * 2,
        style = this.options.style,
        useHtml = this.options.useHtml;
    var totalUsedWidth = 0,
        legendY = PADDING_FUN();

    for (var i = 0, len = this.items.length; i < len; i++) {
      var item = this.items[i];
      var options = item.options; // fixme textSize和labels都可以作为item的属性，在init的时候计算，doLayout的时候使用

      var textSize = this._getTextHeight(options.itemName, style, useHtml);

      var iconDim = _LegendIconFactory["default"].getLegendIconSizeAndScale(options.legendIconType, textSize);

      var textMaxWidth = maxWidth - GAP_FUN() - iconDim.width - 2 * PADDING_FUN();

      var textUsedWidth = this._getTextUsedWidth(options.itemName, style, textMaxWidth);

      totalUsedWidth = Math.max(textUsedWidth + GAP_FUN() + iconDim.width, totalUsedWidth); // 使用html解析时单行显示

      item.labels = useHtml ? [options.itemName] : _BaseUtils["default"].splitText(options.itemName, style, textMaxWidth, 0, false);
      item.legendX = PADDING_FUN();
      item.legendY = legendY;
      legendY += Math.max(textSize * item.labels.length + textSize * WORD_GAP * (item.labels.length - 1), iconDim.height) + PARAGRAPH_GAP * textSize;
    }

    legendY -= PARAGRAPH_GAP * textSize; //最后一行下面不用间距

    var legendSize = PADDING_FUN() * 2 + totalUsedWidth,
        needHeight = legendY + PADDING_FUN();
    var offeredHeight = this.vanchart.bounds.height - PADDING_FUN() * 2; //但是要考虑标题高度小于37的时候，减去tools高度才是可用高度

    offeredHeight -= Math.max(0, startY - this.vanchart.bounds.y); //todo 这里有种期限的情况,比如256, 255,理论上算的话应该有翻页,但是因为太小了基本看不出来

    /**
     * CHART-1144
     * 图例竖直排列的时候，设置了maxWidth为0的时候，就没有必要显示这些翻页按钮了，
     * 但是，老实说，都设置maxWidth为0了，为什么不直接设置不显示图例呢？
     * 这是一个令人深思的问题。
     */

    this.yPanEnabled = Math.abs(0 - maxWidth) < 1e-6 ? false : needHeight - PADDING_FUN() > offeredHeight;
    this.maxYPan = Math.min(0, offeredHeight - (needHeight - PADDING_FUN())); // 非浮动下图例占用的实际宽度要再加上两倍间距

    var actualWidth = (legendSize > maxWidth ? maxWidth : legendSize) + PADDING_FUN() * 2;

    this._setComponentBounds(position, actualWidth);

    var x = this.bounds.x + PADDING_FUN();
    var y = this.bounds.y + PADDING_FUN();
    var width = this.bounds.width - PADDING_FUN() * 2;
    var height = this.bounds.height - PADDING_FUN() * 2; //但是要考虑标题高度小于37的时候，减去tools高度才是可用高度

    height -= Math.max(0, startY - this.vanchart.bounds.y);
    var usedHeight = Math.min(needHeight, height); // 实际使用高度需要加上2倍的边框宽度

    y = Math.max(startY, y);

    if (!this.isFloat && position == _Constants["default"].RIGHT_BOTTOM) {
      //右下
      y = Math.round(this.bounds.y + this.bounds.height - usedHeight - PADDING_FUN());
    } else if (!this.isFloat && (position == _Constants["default"].RIGHT || position == _Constants["default"].LEFT)) {
      // 垂直居中
      y += Math.round((this.bounds.y + this.bounds.height - y - usedHeight) / 2);
    }

    this.bounds = {
      x: x,
      y: y,
      width: Math.max(0, width),
      height: Math.max(0, usedHeight)
    };
  },
  _getTextUsedWidth: function (text, style, maxWidth) {
    var dim = _BaseUtils["default"].getTextDimension(text, style, this.options.useHtml);

    if (maxWidth && maxWidth < dim.width) {
      return maxWidth;
    }

    return dim.width;
  },
  _getTextHeight: function (text, style, useHtml) {
    if (useHtml) {
      var _BaseUtils$getTextDim = _BaseUtils["default"].getTextDimension(text, style, true),
          height = _BaseUtils$getTextDim.height;

      return height;
    }

    return parseFloat(style.fontSize);
  },
  _layoutHorizontalLegendItemBounds: function (position) {
    var plotBounds = this.vanchart.bounds;
    var style = this.options.style;
    var useHtml = this.options.useHtml;
    var visibleWidth = plotBounds.width - 4 * PADDING_FUN();
    var offeredWidth = visibleWidth; // non-flow default

    var itemNeedMinWidth = 0,
        //单个图例需要的最小宽度：itemNeedMinWidth = icon + icon_text_gap + text
    legendTotalWidth = 0; //legend至少需要的总宽度

    var i, len, item, options, iconSize, textSize, textDim;

    for (i = 0, len = this.items.length; i < len; i++) {
      options = this.items[i].options;
      textSize = this._getTextHeight(options.itemName, style, useHtml);
      iconSize = _LegendIconFactory["default"].getLegendIconSizeAndScale(options.legendIconType, textSize);
      textDim = _BaseUtils["default"].getTextDimension(options.itemName, style, this.options.useHtml);
      var itemWidth = iconSize.width + GAP_FUN() + textDim.width;
      itemNeedMinWidth = Math.max(itemNeedMinWidth, itemWidth);
      legendTotalWidth += itemWidth + HORIZONTAL_GAP_FUN();
    }

    legendTotalWidth -= HORIZONTAL_GAP_FUN(); //最后一个图例后面不用gap
    // todo, 好混乱的逻辑……

    var shouldFlowCenter = false; // flow, only one line

    if (this.isFlowBottom()) {
      shouldFlowCenter = legendTotalWidth <= visibleWidth;
      offeredWidth = legendTotalWidth;
    }

    var multiLine = !this.isFlowBottom() && legendTotalWidth >= offeredWidth; //是否多行显示

    this.lineHeightMap = {};
    var currentLineMaxHeight = 0;
    var legendY = PADDING_FUN(); //legend单行和多行显示方式不同
    //单行可以显示：不限制单个图例宽度，按照实际需要宽度展示
    //单行显示不下：单个图例宽度为Math.min(itemNeedMinWidth, MIN_WIDTH_FUN())

    if (!multiLine) {
      var currentLegendX = 0;

      for (i = 0, len = this.items.length; i < len; i++) {
        item = this.items[i];
        options = item.options;
        textSize = this._getTextHeight(options.itemName, style, useHtml);
        iconSize = _LegendIconFactory["default"].getLegendIconSizeAndScale(options.legendIconType, textSize);
        textDim = _BaseUtils["default"].getTextDimension(options.itemName, style, this.options.useHtml);
        item.labels = [options.itemName]; //一行显示，直接将单个图例的options.itemName放入item.labels。

        item.legendX = PADDING_FUN() + currentLegendX;
        item.legendY = legendY;
        item.lineIndex = 0;
        currentLegendX = item.legendX + iconSize.width + GAP_FUN() + textDim.width + HORIZONTAL_GAP_FUN();
        currentLineMaxHeight = Math.max(currentLineMaxHeight, Math.max(textSize * item.labels.length + textSize * WORD_GAP * (item.labels.length - 1), iconSize.height) + PARAGRAPH_GAP * textSize);
        this.lineHeightMap[0] = Math.max(this.lineHeightMap[0] || 0, textSize, iconSize.height);
      } // only used by flow


      this._innerWidth = currentLegendX - HORIZONTAL_GAP_FUN();
    } else {
      if (this.options.layout === _Constants["default"].FLOW) {
        var streamLayout = this._horizontalStreamLayout(offeredWidth);

        legendY = streamLayout.legendY;
        currentLineMaxHeight = streamLayout.currentLineMaxHeight;
      } else {
        //84*n+12(n-1) = offeredWidth。itemMaxWidth = icon + icon_text_gap + text + item_item_gap
        var niceNum = Math.floor((offeredWidth + HORIZONTAL_GAP_FUN()) / (Math.min(itemNeedMinWidth, MIN_WIDTH_FUN()) + HORIZONTAL_GAP_FUN()));
        niceNum = Math.min(niceNum, this.items.length) !== 0 ? Math.min(niceNum, this.items.length) : 1;
        var itemMaxWidth = Math.round((offeredWidth + HORIZONTAL_GAP_FUN()) / niceNum);
        var hasWrap = false;
        multiLine = this.items.length > niceNum;
        var lineIndex = -1;

        for (i = 0, len = this.items.length; i < len; i++) {
          item = this.items[i], options = item.options;
          textSize = this._getTextHeight(options.itemName, style, useHtml);
          iconSize = _LegendIconFactory["default"].getLegendIconSizeAndScale(options.legendIconType, textSize);
          var textMaxWidth = itemMaxWidth - GAP_FUN() - iconSize.width - HORIZONTAL_GAP_FUN();
          item.labels = _BaseUtils["default"].splitText(options.itemName, style, textMaxWidth, 0, false);
          hasWrap = hasWrap || item.labels.length > 1;

          if (i % niceNum === 0) {
            //换行
            legendY += currentLineMaxHeight;
            currentLineMaxHeight = 0;
            lineIndex++;
            this.lineHeightMap[lineIndex] = 0;
          }

          item.legendX = PADDING_FUN() + i % niceNum * itemMaxWidth;
          item.legendY = legendY;
          item.lineIndex = lineIndex;
          currentLineMaxHeight = Math.max(currentLineMaxHeight, Math.max(textSize * item.labels.length + textSize * WORD_GAP * (item.labels.length - 1), iconSize.height) + PARAGRAPH_GAP * textSize);
          this.lineHeightMap[lineIndex] = Math.max(this.lineHeightMap[lineIndex] || 0, textSize, iconSize.height);
        }
      }
    }

    legendY += currentLineMaxHeight - PARAGRAPH_GAP * textSize; //最后一行下面不用间距

    var legendSize = Math.round(legendY) + PADDING_FUN();

    var maxHeight = this._maxLegendHeight(); // CHART-1399 将maxHeight设置为0%的时候不生效


    this.yPanEnabled = maxHeight >= 0 && legendSize > maxHeight;
    this.maxYPan = -legendSize + maxHeight; //yPanEnabled = true时，这个才有用
    // 当计算组件占用的实际高度时，需要加上外间距值

    var actualHeight = (this.yPanEnabled ? maxHeight : legendSize) + PADDING_FUN() * 2;

    this._setComponentBounds(position, actualHeight);

    var x = this.bounds.x + PADDING_FUN();
    var y = this.bounds.y + PADDING_FUN();
    var height = this.bounds.height - PADDING_FUN() * 2;
    var width = this.bounds.width - PADDING_FUN() * 2;
    var usedWidth = offeredWidth + PADDING_FUN() * 2;

    if (this.isFlowBottom()) {
      // 情愿多写2遍也不要搅和到原来的逻辑……
      if (shouldFlowCenter) {
        // 图例水平居中
        usedWidth = this._horizontalCenterLayout(style);
        x += (width - usedWidth) / 2;
      } else {
        usedWidth = visibleWidth;
      }
    } else if (!hasWrap && !multiLine) {
      // 图例水平居中
      usedWidth = this._horizontalCenterLayout(style);
      x += (width - usedWidth) / 2;
    } // 历史遗留问题：x、y是指减去边框宽度后bounds的x、y，而width、height是加上了边框宽度的bounds的宽高，现在都改成减去边框后的x、y、height、width


    this.bounds = {
      x: x,
      y: y,
      width: Math.max(0, usedWidth),
      height: Math.max(0, height)
    };
  },
  // 图例位于上下方时的排列方式：流式排列——不限制单个图例宽度，按照实际需要宽度展示，从左到右，从上到下，逐步累加item的位置，一行摆放不下就换行显示
  _horizontalStreamLayout: function (offeredWidth) {
    var legendY = PADDING_FUN(),
        currentLegendX = PADDING_FUN(),
        style = this.options.style;
    var lineIndex = 0,
        textSingleLineWidth = 0,
        currentLineMaxHeight = 0;

    for (var i = 0, len = this.items.length; i < len; i++) {
      var item = this.items[i],
          options = item.options;

      var textSize = this._getTextHeight(options.itemName, style, this.options.useHtml);

      var iconSize = _LegendIconFactory["default"].getLegendIconSizeAndScale(options.legendIconType, textSize);

      var textDim = _BaseUtils["default"].getTextDimension(options.itemName, style, this.options.useHtml);

      var itemWidth = iconSize.width + GAP_FUN() + textDim.width;
      textSingleLineWidth = currentLegendX + itemWidth;

      if (textSingleLineWidth > offeredWidth) {
        legendY += currentLineMaxHeight;
        currentLegendX = PADDING_FUN();
        currentLineMaxHeight = 0;
        textSingleLineWidth = 0;
        lineIndex++;
        this.lineHeightMap[lineIndex] = 0;
      }

      item.labels = [options.itemName];
      item.legendX = currentLegendX;
      item.legendY = legendY;
      item.lineIndex = lineIndex;
      currentLegendX = item.legendX + itemWidth + HORIZONTAL_GAP_FUN();
      currentLineMaxHeight = Math.max(currentLineMaxHeight, Math.max(textSize * item.labels.length + textSize * WORD_GAP * (item.labels.length - 1), iconSize.height) + PARAGRAPH_GAP * textSize);
      this.lineHeightMap[lineIndex] = Math.max(this.lineHeightMap[lineIndex] || 0, textSize, iconSize.height);
    }

    return {
      legendY: legendY,
      currentLineMaxHeight: currentLineMaxHeight
    };
  },
  // 图例水平居中用的宽度
  _horizontalCenterLayout: function (style) {
    var legendX = PADDING_FUN();

    for (var i = 0, len = this.items.length; i < len; i++) {
      var item = this.items[i],
          options = item.options,
          textSize = this._getTextHeight(options.itemName, style, this.options.useHtml);

      item.legendX = legendX;
      legendX += _LegendIconFactory["default"].getLegendIconSizeAndScale(options.legendIconType, textSize).width;
      legendX += GAP_FUN();
      legendX += _BaseUtils["default"].getTextDimension(options.itemName, style, this.options.useHtml).width;
      legendX += HORIZONTAL_GAP_FUN();
    }

    return legendX + PADDING_FUN() - HORIZONTAL_GAP_FUN();
  },
  render: function () {
    if (this.invisible() || !this.items.length) {
      this.remove();
      return;
    }

    var bounds = this.bounds,
        legend = this,
        vanchart = legend.vanchart,
        renderer = vanchart.renderer,
        legendWidth = bounds.width,
        legendHeight = bounds.height;

    if (!this.legendGroup) {
      // 图例的边框在bounds内部，阴影在bounds外部，阴影会占用图例和别的组件之间的间距
      // 为了clip时只clip图例本身的元素，不影响阴影的显示，所以将背景和图例调整为同级元素，
      // 都作为vanchart.backGroup的子元素,先绘制背景，再绘制图例项
      this.backgroundGroup = renderer.group().addTo(this.getComponentParentGroup());
      this.legendGroup = renderer.vgroup().add(this.getComponentParentGroup());
      this.legendItemsGroup = this.legendGroup.append(renderer.vgroup());
      vanchart.registerInteractiveTarget(this, this.legendGroup);
    }

    this.legendGroup.attr('transform', _BaseUtils["default"].makeTranslate(bounds)); // 图例设置的最大展示区域为0%的时候，整个图例的背景还是会绘制出背景的边框，
    // 但是如果在vanchart._renderRectangleBackground中改代码的话影响到的地方比较多，
    // 所以现在在这里将borderWidth设置为0

    var position = this.options.position;

    if (position === _Constants["default"].TOP || position === _Constants["default"].BOTTOM) {
      parseFloat(this.options.maxHeight) === 0 && (this.options.borderWidth = 0);
    } else {
      parseFloat(this.options.maxWidth) === 0 && (this.options.borderWidth = 0);
    }

    var backgroundOptions = (0, _helper.fixBackgroundOptions)(vanchart, this.options);

    vanchart._renderRectangleBackground(this.backgroundGroup, backgroundOptions, bounds);

    for (var i = 0, len = this.items.length; i < len; i++) {
      this.items[i].render();
    }

    var clip = {
      x: 0,
      y: 0,
      width: legendWidth,
      height: legendHeight
    };

    legend._buildScrollbar();

    if (this._clip) {
      // #MOBILE-18902
      // 可能晕倒有滚动到没滚动的resize
      // 狗皮膏药
      if ((0, _EnvUtils.isSupportSVG)() && this._clip.rect.rawElement.height.baseVal.value !== clip.height) {
        this.resetLegendScroll();
      }
    }

    this._innerClip(this.legendGroup, clip); // 数据刷新的时候，重置图例的scrollTop


    if (vanchart._changeDataState) {
      this.resetLegendScroll();
    }
  },
  _buildScrollbar: function () {
    if (false) {}

    var legend = this;
    var legendWidth = legend.bounds.width;
    var legendHeight = legend.bounds.height;
    legend.scrollbar && legend.scrollbar.off();
    legend.scrollbar && legend.scrollbar.remove();

    if (this.vanchart.isMobileFlow()) {
      var BAR_SIZE = 4; // the same as BI

      var ON_THUMB_COLOR = 'rgba(61,77,102,0.3)',
          ON_TRACK_COLOR = 'rgba(61,77,102,0.05)',
          THUMB_COLOR = 'rgba(61,77,102,0.1)',
          TRACK_COLOR = 'rgba(61,77,102,0.03)';
      var barStyle = {
        backgroundSize: BAR_SIZE,
        backgroundColor: TRACK_COLOR,
        backgroundStroke: 'none',
        barColor: THUMB_COLOR,
        barHoverColor: ON_THUMB_COLOR,
        barSize: BAR_SIZE
      };

      if (this.isFlowBottom() && this._innerWidth > legendWidth) {
        legend.scrollbar = new _Scrollbar["default"]({
          scrollX: true,
          scrollY: false,
          view: legend,
          group: legend.legendGroup,
          width: legendWidth,
          height: legendHeight + BAR_SIZE,
          innerWidth: this._innerWidth,
          barStyle: barStyle
        });
      } else if (legend.yPanEnabled && legend.maxYPan) {
        legend.scrollbar = new _Scrollbar["default"]({
          scrollX: false,
          scrollY: true,
          view: legend,
          group: legend.legendGroup,
          width: legendWidth + BAR_SIZE,
          height: legendHeight,
          innerHeight: legendHeight - legend.maxYPan,
          barStyle: barStyle
        });
      }
    } else if (legend.yPanEnabled && legend.maxYPan) {
      legend.scrollbar = new _Scrollbar["default"]({
        scrollX: false,
        scrollY: true,
        view: legend,
        group: legend.legendGroup,
        width: legendWidth,
        height: legendHeight,
        innerHeight: legendHeight - legend.maxYPan
      });
      legend.scrollbar.on('scrollY', this.onScrollY, this);
    }
  },
  getEvents: function () {
    return {
      'wheel': this.onWheel,
      'mouseout': this.mouseOut,
      'mouseover': this.mouseOver,
      'panstart': this.onPanStart,
      'panmove': this.onPanMove,
      'panend': this.onPanEnd
    };
  },
  mouseOut: function () {
    if (this.highlighted) {
      this.vanchart.cancelLegendHighlight();
    }
  },
  mouseOver: function () {},
  onWheel: function (ev) {
    var e = ev.srcEvent;

    _DomUtils["default"].preventDefault(e);

    this.moveLegendY(_DomUtils["default"].getWheelDelta(e));
  },
  onPanStart: function (ev) {
    this.currentX = ev.containerPoint.x;
    this.currentY = ev.containerPoint.y;

    if (this.vanchart.isMobileFlow() && this.scrollbar) {
      this.scrollbar.show(true);
    }
  },
  onPanMove: function (ev) {
    var deltaX = ev.containerPoint.x - this.currentX;
    var deltaY = ev.containerPoint.y - this.currentY;

    if (this.isFlowBottom()) {
      this.moveLegendX(deltaX);
    } else {
      this.moveLegendY(deltaY);
    }

    this.currentX = ev.containerPoint.x;
    this.currentY = ev.containerPoint.y;
  },
  onPanEnd: function () {
    this.vanchart.handler.panTarget = null;

    if (this.vanchart.isMobileFlow() && this.scrollbar) {
      this.scrollbar.show(false);
    }
  },
  onScrollY: function (data) {
    var deltaY = data.y - (this.legendItemsGroup.currentY || 0);
    this.moveLegendY(deltaY);
  },
  moveLegendX: function (deltaX) {
    if (this._innerWidth > this.bounds.width) {
      var movedX = this.legendItemsGroup.__movedX || 0;
      movedX += deltaX;
      movedX = Math.max(this.bounds.width - this._innerWidth, Math.min(movedX, 0));
      this.legendItemsGroup.__movedX = movedX;
      this.legendItemsGroup.attr('transform', _BaseUtils["default"].makeTranslate([movedX, 0]));
      this.fire('innerChange', {
        x: movedX,
        y: 0
      });
    }
  },
  moveLegendY: function (deltaY) {
    var transY = 0;

    if (this.yPanEnabled) {
      transY = deltaY + (this.legendItemsGroup.currentY || 0);
      transY = Math.max(this.maxYPan, Math.min(0, transY));
    }

    this.legendItemsGroup.currentY = transY;
    this.legendItemsGroup.attr('transform', _BaseUtils["default"].makeTranslate([0, this.legendItemsGroup.currentY]));
    this.fire('innerChange', {
      x: 0,
      y: transY
    });
  },

  /**
   * 图表刷新时，重置legend的滚轮位移
   */
  resetLegendScroll: function () {
    this.legendItemsGroup.currentY = 0;
    this.legendItemsGroup.attr('transform', 'translate(0,0)');
  },
  remove: function () {
    this.legendGroup && this.legendGroup.remove();
    this.backgroundGroup && this.backgroundGroup.remove();
    this._clip && this._clip.remove && this._clip.remove();
    this.legendGroup = this.backgroundGroup = this._clip = null;
    this.items && (this.items.length = 0);
  },
  _itemBindName: function (point) {
    var sery = point.series;
    return sery.isSeriesAccumulated() ? point.name : sery.name;
  },
  reShowPoint: function (point) {
    var name = this._itemBindName(point);

    return this._stateName(name, _Constants["default"].STATE_TO_SHOW);
  },
  showSeries: function (series) {
    return this._stateName(series.name, _Constants["default"].STATE_SHOW);
  },
  toDropSeries: function (series) {
    return this._stateName(series.name, _Constants["default"].STATE_TO_DROP);
  },
  _stateName: function (name, state) {
    for (var i = 0, len = this.items.length; i < len; i++) {
      var item = this.items[i];

      if (item.state == state && item.options.bindName == name) {
        return true;
      }
    }

    return false;
  },

  /**
   * 图例在拖拽方向上是否到达边界
   * @param ev
   * @returns {boolean}
   */
  isPanMovingAtTheBoundary: function (ev) {
    return false;
  },
  // 用于检测事件对象是否位于图例上，含有滚动条时，检测区域宽度需要减去滚动条宽度
  contains: function (containerPoint) {
    var bounds = this.bounds;
    return bounds && _BaseUtils["default"].containsPoint(this.scrollbar ? {
      x: bounds.x,
      y: bounds.y,
      width: bounds.width - SCROLLBAR_WIDTH,
      height: bounds.height
    } : bounds, containerPoint);
  },
  switchSeriesItemVisible: function (name, item) {
    /**
     * 多层饼图下更新point.children里面的point的visible
     * @param parent
     * @param visible
     */
    var setMultiPieChildrenPointVisible = function (parent, visible) {
      var children = parent.children;

      if (children && children.length) {
        for (var i = 0, len = children.length; i < len; i++) {
          children[i].visible = visible;
          setMultiPieChildrenPointVisible(children[i], visible);
        }
      }
    };

    var legend = this;
    var series = this.vanchart.series;
    var calculatedMap = {};

    for (var i = 0, len = series.length; i < len; i++) {
      var sery = series[i];

      if (sery.isSeriesAccumulated()) {
        sery.points.map(function (point) {
          if (legend._itemBindName(point) == name) {
            point.visible = !point.visible;
            sery.type === _Constants["default"].MULTIPIE_CHART && setMultiPieChildrenPointVisible(point, point.visible); // @CHART-1561

            if (item) {
              item.state = point.visible ? _Constants["default"].STATE_TO_SHOW : _Constants["default"].STATE_TO_DROP;
            }
          }
        });
      } else if (sery.name === name) {
        sery.visible = !sery.visible;

        if (item) {
          item.state = sery.visible ? _Constants["default"].STATE_TO_SHOW : _Constants["default"].STATE_TO_DROP;
        }
      }
    } //如果有同名系列，值轴的计算要等所有的系列状态更新之后计算


    for (var i = 0, len = series.length; i < len; i++) {
      var sery = series[i];

      if (!sery.isSeriesAccumulated() && sery.name === name) {
        sery._getAxisTypes().forEach(function (type) {
          var axis = sery[type]; // update value/date axis

          if (axis && !axis._isBaseAxis() && !calculatedMap[_BaseUtils["default"].stamp(axis)]) {
            calculatedMap[_BaseUtils["default"].stamp(axis)] = true;
            axis.calculateDomainFromData();

            if (axis.componentType === _component.ComponentCst.X_AXIS_COMPONENT || axis.componentType === _component.ComponentCst.Y_AXIS_COMPONENT) {
              axis.adjustDomain4Radius();
            } else {
              //radiusAxis等
              axis.fixScaleAndTickData();
            }
          }
        });
      }
    }

    if (item) {
      item.options.visible = !item.options.visible;

      if (item.options.pairLegendOpt) {
        item.options.pairLegendOpt.visible = item.options.visible;
        item.options.pairLegendOpt.renderItem.render();
        item.options.pairLegendOpt.renderItem.onMouseOut();
      }
    }
  }
});

var _default = Legend;
exports["default"] = _default;

/***/ }),
/* 93 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _LegendIconFactory = _interopRequireDefault(__webpack_require__(53));

var _component = __webpack_require__(4);

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _GradualColor = __webpack_require__(31);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/8/1.
 */
// gap between legendIcon and legendText
var GAP = 4;

var GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(GAP);
};

var WORD_GAP = 0.2;

var LegendItem = _Evented["default"].extend({
  initialize: function (legend, options) {
    this.legendX = 0;
    this.legendY = 0;
    this.legend = legend;
    this.state = _Constants["default"].STATE_SHOW;
    this.refresh(options);
  },
  refresh: function (options) {
    this.options = options;
    options.renderItem = this;
  },
  render: function () {
    var legend = this.legend,
        vanchart = legend.vanchart,
        renderer = vanchart.renderer;
    var textStyle = legend.options.style;
    var useHtml = legend.useHtmlLabel();

    if (!this.graphic) {
      this.graphic = legend.legendItemsGroup.append(renderer.vgroup());

      if (!this.options.isTrendLine) {
        this.graphic.style({
          'cursor': 'pointer'
        });
      }
    }

    vanchart.registerInteractiveTarget(this, this.graphic.divG.attr({
      'pointer-events': 'auto'
    }));
    vanchart.registerInteractiveTarget(this, this.graphic.renderG);
    var g = this.graphic,
        d = this.options;
    var markerColor = d.visible ? this._getFillFilter(d.color, d) : d.hiddenColor;

    var textSize = legend._getTextHeight(d.itemName, textStyle, legend.options.useHtml);

    var iconSize = _LegendIconFactory["default"].getLegendIconSizeAndScale(d.legendIconType, textSize);

    var iconPadding = (iconSize.width - iconSize.iconWidth) / 2;
    var itemHeight = legend.lineHeightMap && legend.lineHeightMap[this.lineIndex] || Math.max(iconSize.height, textSize); //@CHART-1489

    this.graphic.attr({
      'transform': _BaseUtils["default"].makeTranslate([this.legendX, Math.round(this.legendY + itemHeight / 2)])
    });

    if (_LegendIconFactory["default"].hasIcon(d.legendIconType)) {
      g.image && g.image.remove();
      g.image = null;
      g.path = g.path || renderer.path().addTo(g);
      g.path.attr('d', _LegendIconFactory["default"].getLegendIconPath(d.legendIconType)).attr('transform', _BaseUtils["default"].makeTranslate([iconPadding, -iconSize.height / 2]) + ' scale(' + iconSize.scale + ')').style({
        'fill': markerColor,
        'fill-opacity': d.opacity
      });

      if (!this._isIntervalRangeLegend() && d.series.type == _Constants["default"].BUBBLE_CHART) {
        g.path.style({
          'stroke': markerColor,
          'stroke-width': 1,
          'stroke-opacity': d.opacity
        });
      }
    } else {
      g.path && g.path.remove();
      g.path = null;
      g.image = g.image || renderer.image().addTo(g);
      g.image.attr({
        'x': iconPadding,
        'y': -iconSize.height / 2,
        'width': iconSize.iconWidth,
        'height': iconSize.height,
        'preserveAspectRatio': 'none'
      }).imageContent(d.legendIconType);
    }

    var svgOffset = (0, _EnvUtils.isSupportSVG)() || false ? {
      'dy': '0.32em'
    } : {};
    g.text && g.text.remove(); // @Cmen：监控刷新可能导致图例内容的变化，对于多行的图例文字，判断更新不如直接清除重绘

    g.text = null;
    g.text = g.append(renderer.vtext(useHtml));
    g.text.style({
      'cursor': this.options.isTrendLine ? 'default' : 'pointer',
      'white-space': 'nowrap'
    });
    var y = 0;
    g.text.spans = this.labels.map(function (text) {
      g.text.append(renderer.vtspan(useHtml).style(textStyle).style({
        fill: d.visible ? textStyle.color : d.hiddenColor
      }).attr('y', useHtml ? y - textSize / 2 : y).attr(svgOffset).attr('x', iconSize.width + GAP_FUN()).textContent(text));
      y += textSize * (1 + WORD_GAP);
    });
  },
  _getFillFilter: function (color, d) {
    if (this._isIntervalRangeLegend() || d.isTrendLine) {
      return color;
    }

    return (0, _GradualColor.getSeriesFillFilter)(color, d.series);
  },

  /**
   * 获取当前legendItem对应的series是否设置了大数据模式
   * @returns {boolean}
   * @private
   */
  _isCorrespondingSeriesLarge: function () {
    return this.options.series.options.large;
  },

  /**
   * 获取当前legendItem对应的series的chart type。
   * @private
   */
  _getCorrespondingSeriesType: function () {
    return this.options.series.type;
  },
  _isIntervalRangeLegend: function () {
    return this.legendType === _component.ComponentCst.INTERVAL_RANGE_LEGEND;
  },
  getEvents: function () {
    var eventObj;

    if (this._isIntervalRangeLegend()) {
      return this._getIntervalLegendEvents();
    } // 如果当前legendItem对应的series设置了大数据模式，而且该series对应的图表类型也支持设置大数据模式，
    // 那么就关掉闪烁动画，也就是系列高亮的动画


    var isCancelHighlight = this._isCorrespondingSeriesLarge() && _Constants["default"].LARGE_CHART_TYPE[this._getCorrespondingSeriesType()];

    if (this.options.isTrendLine) {
      eventObj = {};
    } else if (isCancelHighlight) {
      eventObj = {
        'tap': this.onTap
      };
    } else {
      eventObj = {
        'mouseover': this.onMouseOver,
        'mouseout': this.onMouseOut,
        'tap': this.onTap
      };
    }

    return eventObj;
  },
  updateLegendItemGraphicStyle: function () {
    var item = this;
    var legendGroup = item.legend;

    if (!item.graphic) {
      return;
    }

    var graphic = item.graphic;
    var originPathOpacity = _Constants["default"].DEFAULT_OPACITY;

    if (item.options && (0, _CoreUtils.isNumber)(item.options.opacity)) {
      originPathOpacity = +item.options.opacity;
    }

    var isUseOriginOpacity = this._isUseOriginOpacityItem(item);

    var textOpacity = isUseOriginOpacity ? _Constants["default"].DEFAULT_OPACITY : _Constants["default"].HOVER_OPACITY;
    var pathOpacity = isUseOriginOpacity ? originPathOpacity : _Constants["default"].HOVER_OPACITY;

    if (legendGroup.useHtmlLabel()) {
      graphic.text && graphic.text.style({
        'opacity': textOpacity
      });
    } else {
      graphic.text && graphic.text.style({
        'fill-opacity': textOpacity
      });
    }

    graphic.path && graphic.path.style({
      'fill-opacity': pathOpacity,
      'stroke-opacity': pathOpacity
    });
  },
  _isUseOriginOpacityItem: function (item) {
    var legendGroup = item.legend;
    var target = legendGroup.vanchart.highlightTarget; // 鼠标未选中任何item

    if (target == null) {
      return true;
    }

    var legendItemName = item.options && item.options.itemName;
    var itemId = this.legendType === _component.ComponentCst.INTERVAL_RANGE_LEGEND ? item : legendItemName; // 当前item即为鼠标选中对象

    if (itemId == target) {
      return true;
    }

    if (item.options && item.options.isTrendLine) {
      var originItem = item.options.pairLegendOpt; // 当前item为鼠标选中对象派生出来的趋势线item

      if (originItem.itemName && originItem.itemName == target) {
        return true;
      }
    }
  },
  //for the onXXX functions, this points to the legendItem
  onMouseOver: function () {
    if (this.legend.options.hover) {
      _BaseUtils["default"].getFormatterFunction(this.legend.options.hover)();
    } else {
      if (this.legend.options.highlight && this.options.series.isSupportLegendHighlight()) {
        this.legend.highlighted = true;
        this.legend.vanchart.makeLegendHighlight(this.options.itemName);
      }
    }

    this.legend.fire('mouseover');
  },
  onMouseOut: function (ev) {
    this.legend.fire('mouseout');
  },
  onTap: function () {
    if (this.legend.options.click) {
      _BaseUtils["default"].getFormatterFunction(this.legend.options.click)();

      return;
    }

    this.legend.switchSeriesItemVisible(this.options.bindName, this);
    this.legend.vanchart.reRenderWholePlot();
    this.resetState();
  },
  _getIntervalLegendEvents: function () {
    var isCancelHighlight = this.legend.vanchart.chartType() === _Constants["default"].HEAT_MAP;

    if (isCancelHighlight) {
      return {
        'tap': this._onItemTap
      };
    }

    return {
      'mouseover': this._onItemMouseOver,
      'mousemove': this._onItemMouseMove,
      'mouseout': this.onMouseOut,
      'tap': this._onItemTap
    };
  },
  _onItemMouseOver: function (e) {
    var item = this;

    if (this.legend.options.highlight) {
      this.legend.highlighted = true;
      this.legend.vanchart.makeLegendHighlight(item);
    }

    this.legend.fire('mouseover');
  },
  _onItemMouseMove: function (e) {},
  _onItemTap: function (e) {
    var item = this,
        legend = item.legend,
        options = legend.options,
        vanchart = legend.vanchart;

    if (options.click) {
      _BaseUtils["default"].getFormatterFunction(options.click)();

      return;
    }

    var text = item.graphic && item.graphic.text;
    var rect = item.graphic && item.graphic.path;
    item.visible = !item.visible;
    var labelColor = options.style.color;
    var iconColor = item.visible ? item.color : item.hiddenColor;
    var textColor = item.visible ? labelColor : item.hiddenColor;
    rect.style({
      'fill': iconColor
    });

    if (legend.useHtmlLabel()) {
      text.style('color', _ColorUtils["default"].colorToHex(textColor));
    } else {
      text.style({
        'fill': textColor
      });
    }

    if (item.points && item.points.length > 0) {
      item.points.forEach(function (point) {
        point.visible = item.visible;
      });
      vanchart.filterRender();
    }
  },
  resetState: function () {
    this.state = this.state == _Constants["default"].STATE_TO_SHOW ? _Constants["default"].STATE_SHOW : this.state;
    this.state = this.state == _Constants["default"].STATE_TO_DROP ? _Constants["default"].STATE_DROPPED : this.state;
  },
  remove: function () {
    this.graphic && this.graphic.remove();
    this.graphic = null;
  }
});

var _default = LegendItem;
exports["default"] = _default;

/***/ }),
/* 94 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getCanvasPoints = getCanvasPoints;
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _component = __webpack_require__(4);

var _TouchEventHelper = _interopRequireDefault(__webpack_require__(71));

var _VanHammer = _interopRequireDefault(__webpack_require__(43));

var _EnvUtils = __webpack_require__(2);

var _validMapPoints = __webpack_require__(28);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/7/28.
 * 用hammer.js来封装我们的事件,这样可以统一处理移动端的问题
 */

/**
 * Created by eason on 16/2/19.
 * 处理事件
 */
// normalizeWheel
var PIXEL_STEP = 10;
var LINE_HEIGHT = 40;
var PAGE_HEIGHT = 800; // states

var RESIZE_END = null,
    RESIZE_START = 1,
    GANTT_PAN_END = null,
    GANTT_PAN_START = 2;

var HammerHandler = _Evented["default"].extend({
  initialize: function (vanchart, container) {
    this.vanchart = vanchart;
    this._container = container;
    this._state = null;
    this.hammer = new _VanHammer["default"].Manager(container, {
      _handler: this
    });
    this.lineMapTargetFind = false;
    this.canvasMapTargetFind = false;
    this.heatMapTargetFind = false;
    this.panTarget = null;
    this.on(this.getEvents());
    this._isPaning = false;
    this._needSimulatePanStartEvent = false;
    this.attachEvents();
  },

  /**
   * 判断事件是否可以向上冒泡
   * @param ele
   * @param type
   * @returns {boolean}
   */
  needPropagateEvent: function (ele, type) {
    // 普通图例和范围图例的滚轮事件不需要向上传播，否则可能和地图的滚轮事件冲突，渐变图例无滚轮事件
    var isLegendComponent = ele.componentType === _component.ComponentCst.LEGEND_COMPONENT || ele.componentType === _component.ComponentCst.RANGE_LEGEND_COMPONENT;
    return !(isLegendComponent && type === "wheel");
  },

  /**
   * 全局响应事件
   * @param ev
   */
  fireDOMEvent: function (ev) {
    var rootHandler = this;
    var vanchart = this.vanchart,
        container = this._container; // @CHART-1577:使用iframe嵌入图表时，全屏图表的document还是iframe的document，而这是的图表的dom已经在topWindow的里，则document.contains判断会有问题
    // 这里使用node.parentNode来判断,当node不在dom树里时node.parentNode返回null(https://developer.mozilla.org/en-US/docs/Web/API/Node/parentNode)

    if (!container.parentNode) {
      return;
    }

    var srcEvent = ev.srcEvent,
        type = ev.type || srcEvent.type; // 统一处理wheel

    type = type.indexOf('wheel') !== -1 ? 'wheel' : type; // 记录鼠标位置

    ev.containerPoint = _DomUtils["default"].getMousePos(srcEvent, container);
    var isPan = type === 'panstart' || type === 'panmove' || type === 'panend';
    var isMobile = vanchart.isMobile(); // 移动端上需要长按以后才能响应事件

    if (isMobile && vanchart.chartType() !== _Constants["default"].GANTT_CHART) {
      if (type === 'press') {
        rootHandler.pressed = true;
      } else if (type !== 'panstart' && type !== 'panmove') {
        rootHandler.pressed = false;
      }
    } else {
      rootHandler.pressed = true;
    }

    var target = isPan && rootHandler.panTarget ? rootHandler.panTarget : this.findTargetByEvent(ev);

    if (vanchart.force && !rootHandler.panTarget) {
      rootHandler.forceTarget = vanchart.force.dragFire(ev, rootHandler._container);
    }

    target && this.fireTargetEvent(target, type, ev);
    isMobile && this.handleTouchEvent(target, type, ev); // 事件接口只对移动端开放
  },

  /**
   * 寻找可响应事件的目标元素
   * @param ev
   * @returns {HammerHandler|*}
   */
  findTargetByEvent: function (ev) {
    var vanchart = this.vanchart,
        rootHandler = this,
        rootTarget = vanchart.isMap() ? vanchart : rootHandler;
    var srcEvent = ev.srcEvent,
        type = ev.type || srcEvent.type;
    var src = srcEvent.target || srcEvent.srcElement;
    var target; // CHART-1071&&CHART-1599
    // 对于使用了canvas绘制的图表,最开始尝试响应最上层的事件，如果响应成功(寻找到targetElement)，那么不必考虑下层的地图的事件。
    // 如果上层没找到可响应事件的targetElement，那么则使用之前的做法，用代理来寻找事件目标元素并响应
    // 且不在图例区域内和图例滚动条上

    if ((rootTarget._lineMapLayer || rootTarget._canvasMapLayer || rootTarget._heatMapOverlay) && !rootHandler._findLegendTargetByBounds(ev.containerPoint, true)) {
      this.fireTargetEvent(rootTarget, type, ev);
    } // 流向地图或者点地图(大数据模式)或者热力地图中任何一个寻找到目标元素，都不向下寻找了
    // 且不在图例区域


    if ((this.lineMapTargetFind || this.canvasMapTargetFind || this.heatMapTargetFind) && !rootHandler._findLegendTargetByBounds(ev.containerPoint)) {
      return;
    }

    while (src) {
      if (!(target = rootHandler._findTargetByBounds(ev.containerPoint, type))) {
        target = vanchart.findInteractiveTarget(src);
      }

      if (target && target.listens && target.listens(type, false) || src === rootHandler._container) {
        break;
      }

      src = src.parentNode;
    }

    target = target && target.listens(type, false) ? target : rootTarget;
    return target;
  },
  simulatePanStart: function () {
    this._needSimulatePanStartEvent = true;
    this._isPaning = false;
  },

  /**
   * 触发目标元素的指定事件
   * @param target
   * @param type
   * @param ev
   */
  fireTargetEvent: function (target, type, ev) {
    if (target && target.listens(type, false)) {
      if (this.vanchart.isMobile()) {
        this._isPaning = type === "panstart" ? true : type === "panend" ? false : this._isPaning;

        if (this._needSimulatePanStartEvent && target.listens("panstart", false)) {
          this._needSimulatePanStartEvent = false;
          this._isPaning = true;

          if (this.vanchart.chartType() === _Constants["default"].GANTT_CHART) {
            this._state = GANTT_PAN_END;
            ev.type = "panstart"; // 手动模拟panstart,保证事件流完整
          }

          target.fire("panstart", ev);
          return;
        }

        if (type === "panmove" && !this._isPaning) {
          return;
        }
      }

      target.fire(type, ev, this.needPropagateEvent(target, type));

      this._switchVanChartAutoTooltipStatus(target, type, ev);

      if (type === 'panstart') {
        this.removeAllChosen(ev);

        if (!this.forceTarget) {
          this.panTarget = target;
        }
      } else if (type === 'panend') {
        this.panTarget = null;
      }
    }
  },
  _switchVanChartAutoTooltipStatus: function (target, type, ev) {
    var vanchart = this.vanchart;

    if (!vanchart.autoTooltipController) {
      return;
    }

    if (vanchart.chartType() === _Constants["default"].HEAT_MAP && target === vanchart) {
      var closestPoint = this._getCanvasClosestPoint(ev.containerPoint);

      this.vanchart.switchAutoTooltipStatus(closestPoint ? "mouseover" : "mouseout");
    } else if (target.vanChartType === "point" || target.vanChartType === "series") {
      (type === "mouseover" || type === "mouseout") && this.vanchart.switchAutoTooltipStatus(type);
    }
  },

  /**
   * 事件绑定
   */
  attachEvents: function () {
    var hammer = this.hammer,
        vanchart = this.vanchart,
        fireDOMEvent = this.fireDOMEvent.bind(this);
    hammer.add(new _VanHammer["default"].Pan({
      threshold: 0
    }));
    hammer.add(new _VanHammer["default"].Tap()); // ie下不支持点击效果

    (0, _EnvUtils.isSupportSVG)() && hammer.add(new _VanHammer["default"].Press()); // 拖拽点击等事件

    hammer.on("panstart panmove panend tap press pressup", fireDOMEvent); // PC端添加鼠标事件

    !this.vanchart.isMobile() && hammer.on('mouseover mousemove mouseout wheel', fireDOMEvent); // 地图缩放事件

    if (vanchart.isMap() && vanchart._zoomEnabled()) {
      hammer.add(new _VanHammer["default"].Pinch());
      hammer.on('pinchstart pinchmove', fireDOMEvent);
    } // container相关事件


    this.on(this.getEvents());
  },

  /**
   * 触发移动端设置的手势回调函数
   * @param type
   */
  handleTouchEvent: function (target, type, ev) {
    var rootHandler = this,
        vanchart = this.vanchart;

    if (["panstart", "panmove", "panend", "pinchstart"].indexOf(type) < 0) {
      return;
    }

    var eventHandler = _TouchEventHelper["default"].getConfig(type),
        context = _TouchEventHelper["default"].getConfig("context"),
        params = [ev.srcEvent];

    var isForce = vanchart.force,
        isStructure = vanchart.chartType() === _Constants["default"].STRUCTURE_CHART;

    if (type === "panmove") {
      if (isForce && !rootHandler.panTarget || isStructure && rootHandler !== target) {
        params.push(false);
      } else {
        params.push(target && target.isPanMovingAtTheBoundary ? target.isPanMovingAtTheBoundary(ev) : false);
      }
    }

    eventHandler && eventHandler.apply(context || null, params);
  },
  isPanMovingAtTheBoundary: function (ev) {
    if (this.vanchart.chartType() === _Constants["default"].GANTT_CHART) {
      return this.vanchart._isPanMovingAtTheBoundary(ev);
    } // if(this._inChartBounds(ev.containerPoint) && this._supportCoordinateZoom()){
    //     return !this.pressed;
    // }


    return false;
  },
  _findLegendTargetByBounds: function (containerPoint, isIncludeScrollbar) {
    var vanchart = this.vanchart;
    var legend = vanchart.getComponent(_component.ComponentCst.LEGEND_COMPONENT);
    var rangeLegend = vanchart.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT);
    legend = legend || rangeLegend;

    if (legend == null || legend.bounds == null) {
      return;
    }

    if (isIncludeScrollbar && _BaseUtils["default"].containsPoint(legend.bounds, containerPoint)) {
      return legend;
    }

    if (legend.contains(containerPoint)) {
      return legend;
    }
  },
  // 通过区域来判断target
  _findTargetByBounds: function (containerPoint, type) {
    var vanchart = this.vanchart,
        plotBounds = vanchart.bounds;

    var legend = this._findLegendTargetByBounds(containerPoint); // 图例,范围图例


    if ((type === 'panstart' || type === 'wheel') && legend) {
      return legend;
    } // 只在绘图区域找仪表盘相关的对象


    if (_BaseUtils["default"].containsPoint(plotBounds, containerPoint)) {
      return;
    } // 仪表盘


    var gaugeSeries = vanchart.seriesOfType(_Constants["default"].GAUGE_CHART);

    if (gaugeSeries && gaugeSeries.length) {
      for (var i = 0, len = gaugeSeries.length; i < len; i++) {
        var gauge = gaugeSeries[i];

        if (gauge.bounds && _BaseUtils["default"].containsPoint(gauge.bounds, containerPoint)) {
          return gauge;
        }
      }
    }
  },
  cursor: function (cursor) {
    this._container.style.cursor = cursor || '';
    this.vanchart.bindIEDragCursor && this.vanchart.bindIEDragCursor(); // IE下地图的手型还需要特殊处理一下
  },
  onContainerMouseOver: function () {},
  // 鼠标在绘图区域里的操作
  onContainerMouseMove: function (ev) {
    var plotBounds = this.vanchart.bounds,
        vanchart = this.vanchart;

    if (vanchart.chartType() === _Constants["default"].GANTT_CHART) {
      if (vanchart.isResizeEnabled()) {
        if (_BaseUtils["default"].containsPoint(vanchart.resizeBounds, ev.containerPoint)) {
          this.cursor('col-resize'); // mouse

          this._state = RESIZE_START;
          this.fire('resizeStart', ev);
        } else if (this._state === RESIZE_START) {
          this.cursor();
          this._state = RESIZE_END;
          this.fire('resizeEnd', ev);
        }
      }

      this.fire('over', ev);

      if (this._state === RESIZE_START) {
        return;
      }
    }

    var legend = vanchart.getComponent(_component.ComponentCst.LEGEND_COMPONENT);

    if (legend && legend.bounds) {
      legend.fire(_BaseUtils["default"].containsPoint(legend.bounds, ev.containerPoint) ? 'mouseover' : 'mouseout', ev);
    } // 鼠标在绘图区空白区域悬浮时,需要响应一下按照范围选中的点


    if (_BaseUtils["default"].containsPoint(plotBounds, ev.containerPoint)) {
      this.cursor();

      if (!this._highlightShared(ev)) {
        this._removeHighlight(ev);

        var closestPoint;

        if (vanchart.isLargeMode() && !vanchart.hoverSeries) {
          //canvas
          closestPoint = this._getCanvasClosestPoint(ev.containerPoint);

          if (closestPoint) {
            if (!closestPoint._events) {
              closestPoint.getEvents && closestPoint.on(closestPoint.getEvents(), closestPoint);
            }

            vanchart.showTooltip(closestPoint, ev);
            vanchart.hoverPoint = closestPoint;

            if (closestPoint.options.click) {
              this.cursor('pointer');
            }
          }
        } else if (vanchart.hoverSeries) {
          closestPoint = vanchart.hoverSeries.getClosestPoint(ev.containerPoint);

          if (closestPoint) {
            vanchart.registerInteractiveTarget(closestPoint, closestPoint.series.defaultMarker);
            closestPoint.fire('mouseover', ev);
            vanchart.registerInteractiveTarget(closestPoint, closestPoint.series.defaultMarker);

            if (closestPoint.options.click) {
              this.cursor('pointer');
            }
          }
        }
      }
    } else {
      this.removeAllChosen(ev);
    }
  },
  removeAllChosen: function (ev) {
    // 移出绘图区的时候取消所有的选中状态
    var vanchart = this.vanchart,
        toolbar = vanchart.components[_component.ComponentCst.TOOLBAR_COMPONENT],
        toolbarBounds = toolbar.getToolbarBounds(),
        mouseInToolbarBounds = ev ? _BaseUtils["default"].containsPoint(toolbarBounds, ev.containerPoint) && toolbar.needTooltip() : false; // 全屏时候传进来的ev是undefined ？

    this._removeHighlight(ev);

    var hoverPoint = vanchart.hoverPoint;

    if (hoverPoint) {
      hoverPoint.fire('mouseout', ev);
      vanchart.hoverPoint = null;

      if (hoverPoint.series.type === _Constants["default"].LINE_MAP) {
        vanchart.fire('unchosen');
      }
    }

    if (vanchart.hoverSeries) {
      vanchart.hoverSeries.fire('seriesUnChosen', ev);
      vanchart.hoverSeries = null;
    }

    var tooltip = vanchart.getComponent(_component.ComponentCst.TOOLTIP_COMPONENT);

    if (tooltip && vanchart.vanChartType !== 'vanChartMap' && !mouseInToolbarBounds) {
      tooltip.immediateHide();
    }

    ev && vanchart.cancelLegendHighlight(ev.containerPoint);
  },
  _getCanvasClosestPoint: function (containerPoint) {
    var vanchart = this.vanchart;
    var plotBounds = vanchart.bounds;
    var isMap = vanchart.isMap();
    var canvasPoints = getCanvasPoints(vanchart, isMap);

    if (vanchart.chartType() === _Constants["default"].GANTT_CHART) {
      return getGanttCanvasClosestPoint(vanchart, containerPoint, canvasPoints);
    }

    for (var i = 0; i < canvasPoints.length; i++) {
      var point = canvasPoints[i];
      var pointPos = isMap && point.options.lnglat ? vanchart.latLngToContainerPoint(point.getLatLng()) : {
        x: point.posX + plotBounds.x,
        y: point.posY + plotBounds.y
      };
      var detX = pointPos.x - containerPoint.x;
      var detY = pointPos.y - containerPoint.y;
      var len = Math.sqrt(detX * detX + detY * detY);
      var radius = point.radius || point.options.marker && point.options.marker.radius || _Constants["default"].MARKER_RADIUS;

      if (len <= radius && point.visible) {
        return point;
      }
    }
  },
  onContainerMouseOut: function () {},
  onContainerTap: function (ev) {
    this.onContainerMouseMove(ev);
    var p = this.vanchart.hoverPoint;
    p && p.fire('tap', ev);
  },
  onContainerPanStart: function (ev) {
    if (this.forceTarget || this.vanchart._isEmptyDataChart()) {
      return; // 力学拖拽
    }

    var vanchart = this.vanchart,
        renderer = vanchart.renderer,
        mousePos = ev.containerPoint;
    var plotBounds = vanchart.bounds;

    if (vanchart.chartType() === _Constants["default"].GANTT_CHART) {
      if (_BaseUtils["default"].containsPoint(vanchart.resizeBounds, mousePos)) {
        this._state = RESIZE_START;
        this.fire('resizeStart', ev);
      } else if (!this._state && _BaseUtils["default"].containsPoint(vanchart.panBounds, mousePos)) {
        this._state = GANTT_PAN_START;
        this.fire('pan', ev);
      }

      return;
    } // 缩放


    if (!this.selectRect && this._supportCoordinateZoom() && _BaseUtils["default"].containsPoint(plotBounds, mousePos) && this.pressed) {
      this.selectRect = renderer.rect().style({
        'fill': 'rgb(69,114,167)',
        'fill-opacity': 0.25
      }).add();
      this.downPos = mousePos;
      vanchart.hoverPoint && vanchart.hoverPoint.fire('mouseout');
    } // 在绘图区和数据表里面拖拽也生效


    var zoom = vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT);

    if (this._zoomAsTarget(zoom, mousePos)) {
      zoom._panStart(ev, zoom.centerRect);
    }
  },
  _zoomAsTarget: function (zoom, mousePos) {
    var vanchart = this.vanchart,
        plotBounds = vanchart.bounds,
        validPos = false;
    var dataSheet = vanchart.getComponent(_component.ComponentCst.DATA_SHEET_COMPONENT);

    if (dataSheet) {
      validPos = _BaseUtils["default"].containsPoint(dataSheet.bounds, mousePos);
    }

    validPos = validPos || _BaseUtils["default"].containsPoint(plotBounds, mousePos);
    return zoom && zoom.zoomToolEnabled() && validPos;
  },
  onContainerPanMove: function (ev) {
    var vanchart = this.vanchart;
    var plotBounds = vanchart.bounds,
        options = vanchart.options;
    var mousePos = ev.containerPoint,
        downPos = this.downPos;
    var inverted = vanchart.isInverted();

    if (vanchart.chartType() === _Constants["default"].GANTT_CHART) {
      var inPanBounds = _BaseUtils["default"].containsPoint(this.vanchart.panBounds, mousePos);

      var isCanvasScrollBarPan = vanchart.ganttScrollBar && vanchart.ganttScrollBar._panState;

      if (inPanBounds && this._state === RESIZE_START) {
        this.fire('resizeMove', ev);
      }

      if (inPanBounds || isCanvasScrollBarPan) {
        if (this._state === GANTT_PAN_START) {
          this.fire('pan', ev);
        }
      }

      return;
    }

    if (this.selectRect) {
      var zoomType = options.zoom.zoomType;
      var x = Math.min(mousePos.x, downPos.x);
      var y = Math.min(mousePos.y, downPos.y);
      var width = Math.abs(mousePos.x - downPos.x);
      var height = Math.abs(mousePos.y - downPos.y);
      var isXZoom = zoomType.indexOf('x') !== -1;
      var isYZoom = zoomType.indexOf('y') !== -1;

      if (inverted) {
        isXZoom = zoomType.indexOf('y') !== -1;
        isYZoom = zoomType.indexOf('x') !== -1;
      }

      if (isXZoom && !isYZoom) {
        y = plotBounds.y;
        height = plotBounds.height;
      } else if (isYZoom && !isXZoom) {
        x = plotBounds.x;
        width = plotBounds.width;
      }

      this.selectRect.attr({
        x: x,
        y: y,
        width: width,
        height: height
      });
    }

    var zoom = vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT);

    if (zoom && zoom.zoomToolEnabled()) {
      zoom._panContainerMove(ev);
    }
  },
  onContainerPanEnd: function (ev) {
    var vanchart = this.vanchart;
    var mousePos = ev.containerPoint,
        downPos = this.downPos;
    var toolbar = vanchart.components[_component.ComponentCst.TOOLBAR_COMPONENT]; // 缩放图表的时候移除MoreLabel

    vanchart.removeMoreLabel();

    if (vanchart.chartType() === _Constants["default"].GANTT_CHART) {
      if (this._state === RESIZE_START) {
        this._state = RESIZE_END;
        this.fire('resizeEnd', ev);
      } else if (this._state === GANTT_PAN_START) {
        this._state = GANTT_PAN_END;
        this.fire('pan', ev);
      }

      return;
    }

    if (this.selectRect) {
      //兼容一些微小的误操作,14约等于10*1.414
      if (_BaseUtils["default"].distance(downPos, mousePos) > 14) {
        vanchart.clearAllEffects();
        vanchart.dealAxisZoom(downPos, mousePos);
        toolbar && toolbar.showRefreshIconWhenZoom();
      }

      this.selectRect.remove();
      this.selectRect = null;
    }

    this.panTarget = null;
    var zoom = vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT);

    if (zoom && zoom.zoomToolEnabled()) {
      zoom._panEnd();
    }
  },
  onContainerWheel: function (ev) {
    // preventDefault all wheel events ?
    var vanchart = this.vanchart;

    if (vanchart.chartType() === _Constants["default"].GANTT_CHART && _BaseUtils["default"].containsPoint(vanchart.panBounds, ev.containerPoint)) {
      // `event` is global in IE8
      var srcEvent = ev.srcEvent;
      srcEvent.preventDefault ? srcEvent.preventDefault() : event.returnValue = false;
      ev.wheel = this.normalizeWheel(ev.srcEvent);
      this.fire('wheelMove', ev);
    }
  },
  _highlightShared: function (event) {
    var axis = this.vanchart.getSharedAxis();

    if (axis && axis.getPointsInCategory) {
      var pos = event.containerPoint;
      var catePoints = axis.getPointsInCategory(pos);

      if (catePoints && catePoints.length) {
        catePoints[0]._onPointMouseOver.call(catePoints[0], event);

        axis.drawHighlightBackground(catePoints);
        this.vanchart.showSharedTooltip(catePoints[0], event);
        return true;
      }
    }

    return false;
  },
  _removeHighlight: function (ev) {
    var vanchart = this.vanchart,
        axis = vanchart.getSharedAxis(),
        hoverPoints = vanchart.hoverPoints;
    axis && axis.removeHighlightBackground && axis.removeHighlightBackground();
    hoverPoints && hoverPoints.length && hoverPoints[0]._onPointMouseOut.call(hoverPoints[0], ev);
    vanchart.hoverPoints = null;
  },
  getEvents: function () {
    return {
      'mouseover': this.onContainerMouseOver,
      'mousemove': this.onContainerMouseMove,
      'mouseout': this.onContainerMouseOut,
      'tap': this.onContainerTap,
      'panstart': this.onContainerPanStart,
      'panmove': this.onContainerPanMove,
      'panend': this.onContainerPanEnd,
      'wheel': this.onContainerWheel
    };
  },
  _supportCoordinateZoom: function () {
    var isForceBubble = this.vanchart.hoverPoint && this.vanchart.vanChartType === 'vanChartForceBubble';
    var option = this.vanchart.options;
    return (0, _EnvUtils.isSupportSVG)() && option.zoom && option.zoom.zoomType && !isForceBubble;
  },
  destroy: function () {
    this.hammer.destroy();
  },
  _inZoomBar: function (containerPoint) {
    var zoomBar = this.vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT);
    return zoomBar && zoomBar.bounds && _BaseUtils["default"].containsPoint(zoomBar.bounds, containerPoint);
  },
  _inChartBounds: function (point) {
    return _BaseUtils["default"].containsPoint(this.vanchart.bounds, point);
  },

  /**
   * 判断鼠标是否在渐变色图例中
   * @param containerPoint
   * @returns {*}
   * @private
   */
  _inGradientRangeLegend: function (containerPoint) {
    var legend = this.vanchart.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT);
    return legend && legend.options.continuous && legend.bounds && _BaseUtils["default"].containsPoint(legend.bounds, containerPoint);
  },
  //判断是否需要阻止浏览器默认行为
  //如果是pressed状态或者位置在缩放控件内，则阻止浏览器默认行为
  preventDefault: function (input) {
    var srcEvent = input.srcEvent;
    var src = srcEvent.target || srcEvent.srcElement;

    var containerPoint = _DomUtils["default"].getMousePos(srcEvent, this._container);

    var prevent = this.pressed || this._inZoomBar(containerPoint);

    var zoom = this.vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT);

    if (this.vanchart.chartType() === _Constants["default"].GANTT_CHART) {
      var levelBar = this.vanchart.getComponent(_component.ComponentCst.LEVELBAR);
      prevent = _BaseUtils["default"].containsPoint(this.vanchart.panBounds, containerPoint) || levelBar && _BaseUtils["default"].containsPoint(levelBar.thumbBounds, containerPoint);
    } // 存在缩放控件时，


    if (!prevent && zoom) {
      prevent = zoom.target || this._zoomAsTarget(zoom, containerPoint); // todo webkit下面touch-action:none已经会触发scroll，尚未找到解决方案

      prevent = prevent && (Math.abs(input.angle) < 45 || Math.abs(input.angle) > 135) && Math.abs(input.deltaX) > 0;
    }

    if (!prevent && this._inGradientRangeLegend(containerPoint)) {
      prevent = true;
    }

    if (this.vanchart.isMap()) {
      prevent = this.vanchart._zoomEnabled() && src.nodeName !== 'A' || this._inGradientRangeLegend(containerPoint);
    } // #touchActionAndriod


    if (prevent) {
      this.hammer.touchAction.setTouchActionNone();
    } else {
      this.hammer.touchAction.recoverTouchAction(); // moving and firing

      input.distance > 0 && this._defaultScroll(srcEvent);
    }

    return prevent;
  },
  _defaultScroll: function (ev) {
    var eventHandler = _TouchEventHelper["default"].getConfig("panmove"),
        context = _TouchEventHelper["default"].getConfig("context");

    eventHandler && eventHandler.apply(context || null, [ev, false, true]);
  },
  // worth reading:
  // https://github.com/facebook/fixed-data-table/blob/master/src/vendor_upstream/dom/normalizeWheel.js
  //
  normalizeWheel: function normalizeWheel(
  /*object*/
  event)
  /*object*/
  {
    var sX = 0,
        sY = 0,
        // spinX, spinY
    pX = 0,
        pY = 0; // pixelX, pixelY
    // Legacy

    if ('detail' in event) {
      sY = event.detail;
    }

    if ('wheelDelta' in event) {
      sY = -event.wheelDelta / 120;
    }

    if ('wheelDeltaY' in event) {
      sY = -event.wheelDeltaY / 120;
    }

    if ('wheelDeltaX' in event) {
      sX = -event.wheelDeltaX / 120;
    } // side scrolling on FF with DOMMouseScroll


    if ('axis' in event && event.axis === event.HORIZONTAL_AXIS) {
      sX = sY;
      sY = 0;
    }

    pX = sX * PIXEL_STEP;
    pY = sY * PIXEL_STEP;

    if ('deltaY' in event) {
      pY = event.deltaY;
    }

    if ('deltaX' in event) {
      pX = event.deltaX;
    }

    if ((pX || pY) && event.deltaMode) {
      if (event.deltaMode === 1) {
        // delta in LINE units
        pX *= LINE_HEIGHT;
        pY *= LINE_HEIGHT;
      } else {
        // delta in PAGE units
        pX *= PAGE_HEIGHT;
        pY *= PAGE_HEIGHT;
      }
    } // Fall-back if spin cannot be determined


    if (pX && !sX) {
      sX = pX < 1 ? -1 : 1;
    }

    if (pY && !sY) {
      sY = pY < 1 ? -1 : 1;
    }

    return {
      spinX: sX,
      spinY: sY,
      pixelX: pX,
      pixelY: pY
    };
  }
});

function getCanvasPoints(vanchart, isMap) {
  var canvasPoints = [];
  var canvasSeries = vanchart.seriesOfType(_Constants["default"].BUBBLE_CHART).concat(vanchart.seriesOfType(_Constants["default"].SCATTER_CHART)).concat(vanchart.seriesOfType(_Constants["default"].GANTT_CHART));
  canvasSeries.reverse();
  canvasSeries.forEach(function (ser) {
    return canvasPoints = canvasPoints.concat(ser.points);
  });
  return isMap ? canvasPoints.concat((0, _validMapPoints.getHeatMapPoints)(vanchart)) : canvasPoints;
}

function getGanttCanvasClosestPoint(vanchart, containerPoint, canvasPoints) {
  var realCanvasBounds = vanchart.realCanvasBounds;
  var timeAxisView = vanchart.getTimeAxis().view;
  var innerPosX = timeAxisView.innerPosX,
      innerPosY = timeAxisView.innerPosY;
  var startX = realCanvasBounds.x + innerPosX;
  var startY = realCanvasBounds.y + innerPosY;

  for (var i = 0; i < canvasPoints.length; i++) {
    var point = canvasPoints[i];
    var _point$rect = point.rect,
        x = _point$rect.x,
        y = _point$rect.y,
        width = _point$rect.width,
        height = _point$rect.height;
    var pointBounds = {
      x: x + startX,
      y: y + startY,
      width: width,
      height: height
    };

    if (point.isVisible() && _BaseUtils["default"].containsPoint(realCanvasBounds, containerPoint) && _BaseUtils["default"].containsPoint(pointBounds, containerPoint)) {
      return point;
    }
  }
}

var _default = HammerHandler;
exports["default"] = _default;

/***/ }),
/* 95 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Class = _interopRequireDefault(__webpack_require__(27));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/7.
 */
var Icon = _Class["default"].extend({
  initialize: function (options) {
    _BaseUtils["default"].setOptions(this, options);
  },
  // @method createIcon(oldIcon?: HTMLElement): HTMLElement
  // Called internally when the icon has to be shown, returns a `<img>` HTML element
  // styled according to the options.
  createIcon: function (oldIcon) {
    return this._createIcon('icon', oldIcon);
  },
  // @method createShadow(oldIcon?: HTMLElement): HTMLElement
  // As `createIcon`, but for the shadow beneath it.
  createShadow: function (oldIcon) {
    return this._createIcon('shadow', oldIcon);
  },
  _createIcon: function (name, oldIcon) {
    var src = this._getIconUrl(name);

    if (!src) {
      if (name === 'icon') {
        throw new Error('iconUrl not set in Icon options (see the docs).');
      }

      return null;
    }

    var img = this._createImg(src, oldIcon && oldIcon.tagName === 'IMG' ? oldIcon : null);

    this._setIconStyles(img, name);

    return img;
  },
  _setIconStyles: function (img, name) {
    var options = this.options;
    var sizeOption = options[name + 'Size'];

    if (typeof sizeOption === 'number') {
      sizeOption = [sizeOption, sizeOption];
    }

    var size = _Point2D["default"].create(sizeOption),
        anchor = _Point2D["default"].create(name === 'shadow' && options.shadowAnchor || options.iconAnchor || size && size.divideBy(2, true));

    img.className = 'leaflet-marker-' + name + ' ' + (options.className || ''); // 现在的图片点击会触发focus导致显示outline，找了一下也没找到为什么
    // 因此直接在这里设置outline为0，即使onfocus也不会显示高亮边框

    img.style.outline = "0";

    if (anchor) {
      img.style.marginLeft = -anchor.x + 'px';
      img.style.marginTop = -anchor.y + 'px';
    }

    if (size) {
      img.style.width = size.x + 'px';
      img.style.height = size.y + 'px';
    }
  },
  _createImg: function (src, el) {
    el = el || document.createElement('img');
    el.src = src;
    return el;
  },
  _getIconUrl: function (name) {
    return _Browser["default"].retina && this.options[name + 'RetinaUrl'] || this.options[name + 'Url'];
  }
});

Icon.Default = Icon.extend({
  options: {
    iconUrl: 'marker-icon.png',
    iconRetinaUrl: 'marker-icon-2x.png',
    shadowUrl: 'marker-shadow.png',
    iconSize: [25, 41],
    iconAnchor: [12, 41],
    popupAnchor: [1, -34],
    tooltipAnchor: [16, -28],
    shadowSize: [41, 41]
  },
  _getIconUrl: function (name) {
    if (!Icon.Default.imagePath) {
      // Deprecated, backwards-compatibility only
      Icon.Default.imagePath = this._detectIconPath();
    } // @option imagePath: String
    // `Icon.Default` will try to auto-detect the absolute location of the
    // blue icon images. If you are placing these images in a non-standard
    // way, set this option to point to the right absolute path.


    return (this.options.imagePath || Icon.Default.imagePath) + Icon.prototype._getIconUrl.call(this, name);
  },
  _detectIconPath: function () {
    var el = _DomUtils["default"].create('div', 'leaflet-default-icon-path', document.body);

    var path = _DomUtils["default"].getStyle(el, 'background-image') || _DomUtils["default"].getStyle(el, 'backgroundImage'); // IE8


    document.body.removeChild(el);
    return path.indexOf('url') === 0 ? path.replace(/^url\([\"\']?/, '').replace(/marker-icon\.png[\"\']?\)$/, '') : '';
  }
});
var _default = Icon;
exports["default"] = _default;

/***/ }),
/* 96 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _VanChart = _interopRequireDefault(__webpack_require__(33));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _Bounds = _interopRequireDefault(__webpack_require__(21));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

var _LatLngBounds = _interopRequireDefault(__webpack_require__(34));

var _PosAnimation = _interopRequireDefault(__webpack_require__(216));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Copyright (c) 2010-2016, Vladimir Agafonkin
 Copyright (c) 2010-2011, CloudMade
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification, are
 permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice, this list of
 conditions and the following disclaimer.

 2. Redistributions in binary form must reproduce the above copyright notice, this list
 of conditions and the following disclaimer in the documentation and/or other materials
 provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 **/

/**
 * Created by eason on 2017/1/18.
 */
var DEFAULT_ZOOM_LEVEL = 6;

var VanChartBaseMap = _VanChart["default"].extend({
  // @section Methods for modifying map state
  // @method setView(center: LatLng, zoom: Number, options?: Zoom/pan options): this
  // Sets the view of the map (geographical center and zoom) with the given
  // animation options.
  setView: function (center, zoom, options) {
    zoom = zoom === undefined ? this._zoom : this._limitZoom(zoom);
    center = this._limitCenter(_LatLng["default"].create(center), zoom, this.options.maxBounds);
    options = options || {};

    this._stop();

    if (this._loaded && !options.reset && options !== true) {
      if (options.animate !== undefined) {
        options.zoom = _BaseUtils["default"].extend({
          animate: options.animate
        }, options.zoom);
        options.pan = _BaseUtils["default"].extend({
          animate: options.animate,
          duration: options.duration
        }, options.pan);
      } // try animating pan or zoom


      var moved = this._zoom !== zoom ? this._tryAnimatedZoom(center, zoom, options.zoom) : this._tryAnimatedPan(center, options.pan);

      if (moved) {
        // prevent resize handler call, the view will refresh after animation anyway
        clearTimeout(this._sizeTimer);
        return this;
      }
    } // animation didn't start, just reset the map view


    this._resetView(center, zoom);

    return this;
  },
  // @method setZoom(zoom: Number, options: Zoom/pan options): this
  // Sets the zoom of the map.
  setZoom: function (zoom, options) {
    if (!this._loaded) {
      this._zoom = zoom;
      return this;
    }

    return this.setView(this.getCenter(), zoom, {
      zoom: options
    });
  },
  // @method zoomIn(delta?: Number, options?: Zoom options): this
  // Increases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
  zoomIn: function (delta, options) {
    delta = delta || (_Browser["default"].any3d ? this.options.zoomDelta : 1);
    return this.setZoom(this._zoom + delta, options);
  },
  // @method zoomOut(delta?: Number, options?: Zoom options): this
  // Decreases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
  zoomOut: function (delta, options) {
    delta = delta || (_Browser["default"].any3d ? this.options.zoomDelta : 1);
    return this.setZoom(this._zoom - delta, options);
  },
  // @method setZoomAround(latlng: LatLng, zoom: Number, options: Zoom options): this
  // Zooms the map while keeping a specified geographical point on the map
  // stationary (e.g. used internally for scroll zoom and double-click zoom).
  // @alternative
  // @method setZoomAround(offset: Point, zoom: Number, options: Zoom options): this
  // Zooms the map while keeping a specified pixel on the map (relative to the top-left corner) stationary.
  setZoomAround: function (latlng, zoom, options) {
    var scale = this.getZoomScale(zoom),
        viewHalf = this.getSize().divideBy(2),
        containerPoint = latlng instanceof _Point2D["default"] ? latlng : this.latLngToContainerPoint(latlng),
        centerOffset = containerPoint.subtract(viewHalf).multiplyBy(1 - 1 / scale),
        newCenter = this.containerPointToLatLng(viewHalf.add(centerOffset));
    return this.setView(newCenter, zoom, {
      zoom: options
    });
  },
  _getBoundsCenterZoom: function (bounds, options) {
    options = options || {};
    bounds = bounds.getBounds ? bounds.getBounds() : _LatLngBounds["default"].create(bounds);

    var paddingTL = _Point2D["default"].create(options.paddingTopLeft || options.padding || [0, 0]),
        paddingBR = _Point2D["default"].create(options.paddingBottomRight || options.padding || [0, 0]),
        zoom = options.zoom ? options.zoom : this.getBoundsZoom(bounds, false, paddingTL.add(paddingBR));

    zoom = isFinite(zoom) ? zoom : DEFAULT_ZOOM_LEVEL; //@Cmen:CHART-995

    zoom = typeof options.maxZoom === 'number' ? Math.min(options.maxZoom, zoom) : zoom;
    var paddingOffset = paddingBR.subtract(paddingTL).divideBy(2),
        swPoint = this.project(bounds.getSouthWest(), zoom),
        nePoint = this.project(bounds.getNorthEast(), zoom),
        center = this.unproject(swPoint.add(nePoint).divideBy(2).add(paddingOffset), zoom);
    return {
      center: center,
      zoom: zoom
    };
  },
  // @method fitBounds(bounds: LatLngBounds, options: fitBounds options): this
  // Sets a map view that contains the given geographical bounds with the
  // maximum zoom level possible.
  fitBounds: function (bounds, options) {
    var _bounds = _LatLngBounds["default"].create(bounds);

    if (!_bounds.isValid()) {
      throw new Error('Bounds are not valid.');
    }

    if (_bounds.isSame()) {
      var zoomLevel = (0, _CoreUtils.hasDefined)(options.zoom) ? options.zoom : DEFAULT_ZOOM_LEVEL;
      return this.setView(bounds[0], zoomLevel, options);
    } else {
      var target = this._getBoundsCenterZoom(_bounds, options);

      return this.setView(target.center, target.zoom, options);
    }
  },
  // @method fitWorld(options?: fitBounds options): this
  // Sets a map view that mostly contains the whole world with the maximum
  // zoom level possible.
  fitWorld: function (options) {
    return this.fitBounds([[-90, -180], [90, 180]], options);
  },
  // @method panTo(latlng: LatLng, options?: Pan options): this
  // Pans the map to a given center.
  panTo: function (center, options) {
    // (LatLng)
    return this.setView(center, this._zoom, {
      pan: options
    });
  },
  // @method panBy(offset: Point): this
  // Pans the map by a given number of pixels (animated).
  panBy: function (offset, options) {
    offset = _Point2D["default"].create(offset).round();
    options = options || {};

    if (!offset.x && !offset.y) {
      return this.fire('moveend');
    } // If we pan too far, Chrome gets issues with tiles
    // and makes them disappear or appear in the wrong place (slightly offset) #2602


    if (options.animate !== true && !this.getSize().contains(offset)) {
      this._resetView(this.unproject(this.project(this.getCenter()).add(offset)), this.getZoom());

      return this;
    }

    if (!this._panAnim) {
      this._panAnim = new _PosAnimation["default"]();

      this._panAnim.on({
        'step': this._onPanTransitionStep,
        'end': this._onPanTransitionEnd
      }, this);
    } // don't fire movestart if animating inertia


    if (!options.noMoveStart) {
      this.fire('movestart');
    } // animate pan unless animate: false specified


    if (options.animate !== false) {
      _DomUtils["default"].addClass(this._mapPane, 'leaflet-pan-anim');

      var newPos = this._getMapPanePos().subtract(offset).round();

      this._panAnim.run(this._mapPane, newPos, options.duration || 0.25, options.easeLinearity);
    } else {
      this._rawPanBy(offset);

      this.fire('move').fire('moveend');
    }

    return this;
  },
  // @method setMaxBounds(bounds: Bounds): this
  // Restricts the map view to the given bounds (see the [maxBounds](#map-maxbounds) option).
  setMaxBounds: function (bounds) {
    bounds = _LatLngBounds["default"].create(bounds);

    if (!bounds.isValid()) {
      this.options.maxBounds = null;
      return this.off('moveend', this._panInsideMaxBounds);
    } else if (this.options.maxBounds) {
      this.off('moveend', this._panInsideMaxBounds);
    }

    this.options.maxBounds = bounds;

    if (this._loaded) {
      this._panInsideMaxBounds();
    }

    return this.on('moveend', this._panInsideMaxBounds);
  },
  // @method panInsideBounds(bounds: LatLngBounds, options?: Pan options): this
  // Pans the map to the closest view that would lie inside the given bounds (if it's not already), controlling the animation using the options specific, if any.
  panInsideBounds: function (bounds, options) {
    this._enforcingBounds = true;

    var center = this.getCenter(),
        newCenter = this._limitCenter(center, this._zoom, _LatLngBounds["default"].create(bounds));

    if (!center.equals(newCenter)) {
      this.panTo(newCenter, options);
    }

    this._enforcingBounds = false;
    return this;
  },
  // @method invalidateSize(options: Zoom/Pan options): this
  // Checks if the map container size changed and updates the map if so —
  // call it after you've changed the map size dynamically, also animating
  // pan by default. If `options.pan` is `false`, panning will not occur.
  // If `options.debounceMoveend` is `true`, it will delay `moveend` event so
  // that it doesn't happen often even if the method is called many
  // times in a row.
  // @alternative
  // @method invalidateSize(animate: Boolean): this
  // Checks if the map container size changed and updates the map if so —
  // call it after you've changed the map size dynamically, also animating
  // pan by default.
  invalidateSize: function (options) {
    if (!this._loaded) {
      return this;
    }

    options = _BaseUtils["default"].extend({
      animate: false,
      pan: true
    }, options === true ? {
      animate: true
    } : options);
    var oldSize = this.getSize();
    this._sizeChanged = true;
    this._lastCenter = null;
    var newSize = this.getSize(),
        oldCenter = oldSize.divideBy(2).round(),
        newCenter = newSize.divideBy(2).round(),
        offset = oldCenter.subtract(newCenter);

    if (!offset.x && !offset.y) {
      return this;
    }

    if (options.animate && options.pan) {
      this.panBy(offset);
    } else {
      if (options.pan) {
        this._rawPanBy(offset);
      }

      this.fire('move');

      if (options.debounceMoveend) {
        clearTimeout(this._sizeTimer);
        this._sizeTimer = setTimeout(_BaseUtils["default"].bind(this.fire, this, 'moveend'), 200);
      } else {
        this.fire('moveend');
      }
    } // @section Map state change events
    // @event resize: ResizeEvent
    // Fired when the map is resized.


    return this.fire('resize', {
      oldSize: oldSize,
      newSize: newSize
    });
  },
  // @section Methods for modifying map state
  // @method stop(): this
  // Stops the currently running `panTo` or `flyTo` animation, if any.
  stop: function () {
    this.setZoom(this._limitZoom(this._zoom));

    if (!this.options.zoomSnap) {
      this.fire('viewreset');
    }

    return this._stop();
  },
  // @method remove(): this
  // Destroys the map and clears all related event listeners.
  remove: function () {
    _DomUtils["default"].remove(this._mapPane);

    _DomUtils["default"].remove(this._controlContainer);

    if (this._loaded) {
      // @section Map state change events
      // @event unload: Event
      // Fired when the map is destroyed with [remove](#map-remove) method.
      this.fire('unload');
    }

    for (var i in this._layers) {
      this._layers[i].remove();
    }

    _VanChart["default"].prototype.remove.call(this);

    return this;
  },
  // @section Other Methods
  // @method createPane(name: String, container?: HTMLElement): HTMLElement
  // Creates a new [map pane](#map-pane) with the given name if it doesn't exist already,
  // then returns it. The pane is created as a children of `container`, or
  // as a children of the main map pane if not set.
  createPane: function (name, container) {
    var className = 'leaflet-pane' + (name ? ' leaflet-' + name.replace('Pane', '') + '-pane' : ''),
        pane = _DomUtils["default"].create('div', className, container || this._mapPane);

    if (name) {
      this._panes[name] = pane;
    }

    return pane;
  },
  // @section Methods for Getting Map State
  // @method getCenter(): LatLng
  // Returns the geographical center of the map view
  getCenter: function () {
    this._checkIfLoaded();

    if (this._lastCenter && !this._moved()) {
      return this._lastCenter;
    }

    return this.layerPointToLatLng(this._getCenterLayerPoint());
  },
  // @method getZoom(): Number
  // Returns the current zoom level of the map view
  getZoom: function () {
    return this._zoom;
  },
  // @method getBounds(): LatLngBounds
  // Returns the geographical bounds visible in the current map view
  getBounds: function () {
    var bounds = this.getPixelBounds(),
        sw = this.unproject(bounds.getBottomLeft()),
        ne = this.unproject(bounds.getTopRight());
    return new _LatLngBounds["default"](sw, ne);
  },
  // @method getMinZoom(): Number
  // Returns the minimum zoom level of the map (if set in the `minZoom` option of the map or of any layers), or `0` by default.
  getMinZoom: function () {
    var opt = this.components.geo.options.tileLayerOptions;
    return opt && opt.minZoom ? opt.minZoom : this._layersMinZoom || 0;
  },
  // @method getMaxZoom(): Number
  // Returns the maximum zoom level of the map (if set in the `maxZoom` option of the map or of any layers).
  getMaxZoom: function () {
    var opt = this.components.geo.options.tileLayerOptions;
    return opt && opt.maxZoom ? opt.maxZoom : this._layersMaxZoom || Infinity;
  },
  // @method getBoundsZoom(bounds: LatLngBounds, inside?: Boolean): Number
  // Returns the maximum zoom level on which the given bounds fit to the map
  // view in its entirety. If `inside` (optional) is set to `true`, the method
  // instead returns the minimum zoom level on which the map view fits into
  // the given bounds in its entirety.
  getBoundsZoom: function (bounds, inside, padding) {
    // (LatLngBounds[, Boolean, Point]) -> Number
    bounds = _LatLngBounds["default"].create(bounds);
    padding = _Point2D["default"].create(padding || [0, 0]);
    var zoom = this.getZoom() || 0,
        min = this.getMinZoom(),
        max = this.getMaxZoom(),
        nw = bounds.getNorthWest(),
        se = bounds.getSouthEast(),
        size = this.getSize().subtract(padding),
        boundsSize = this.project(se, zoom).subtract(this.project(nw, zoom)),
        snap = _Browser["default"].any3d ? this.options.zoomSnap : 1;
    var scale = Math.min(size.x / boundsSize.x, size.y / boundsSize.y);
    zoom = this.getScaleZoom(scale, zoom);

    if (snap) {
      zoom = Math.round(zoom / (snap / 100)) * (snap / 100); // don't jump if within 1% of a snap level

      zoom = inside ? Math.ceil(zoom / snap) * snap : Math.floor(zoom / snap) * snap;
    }

    return Math.max(min, Math.min(max, zoom));
  },
  // @method getPixelBounds(): Bounds
  // Returns the bounds of the current map view in projected pixel
  // coordinates (sometimes useful in layer and overlay implementations).
  getPixelBounds: function (center, zoom) {
    var topLeftPoint = this._getTopLeftPoint(center, zoom);

    return new _Bounds["default"](topLeftPoint, topLeftPoint.add(this.getSize()));
  },
  // TODO: Check semantics - isn't the pixel origin the 0,0 coord relative to
  // the map pane? "left point of the map layer" can be confusing, specially
  // since there can be negative offsets.
  // @method getPixelOrigin(): Point
  // Returns the projected pixel coordinates of the top left point of
  // the map layer (useful in custom layer and overlay implementations).
  getPixelOrigin: function () {
    this._checkIfLoaded();

    return this._pixelOrigin;
  },
  // @method getPixelWorldBounds(zoom?: Number): Bounds
  // Returns the world's bounds in pixel coordinates for zoom level `zoom`.
  // If `zoom` is omitted, the map's current zoom level is used.
  getPixelWorldBounds: function (zoom) {
    return this.options.crs.getProjectedBounds(zoom === undefined ? this.getZoom() : zoom);
  },
  // @section Other Methods
  // @method getPane(pane: String|HTMLElement): HTMLElement
  // Returns a [map pane](#map-pane), given its name or its HTML element (its identity).
  getPane: function (pane) {
    return typeof pane === 'string' ? this._panes[pane] : pane;
  },
  // @method getPanes(): Object
  // Returns a plain object containing the names of all [panes](#map-pane) as keys and
  // the panes as values.
  getPanes: function () {
    return this._panes;
  },
  // @method getContainer: HTMLElement
  // Returns the HTML element that contains the map.
  getContainer: function () {
    return this._container;
  },
  // @section Conversion Methods
  // @method getZoomScale(toZoom: Number, fromZoom: Number): Number
  // Returns the scale factor to be applied to a map transition from zoom level
  // `fromZoom` to `toZoom`. Used internally to help with zoom animations.
  getZoomScale: function (toZoom, fromZoom) {
    // TODO replace with universal implementation after refactoring projections
    var crs = this.options.crs;
    fromZoom = fromZoom === undefined ? this._zoom : fromZoom;
    return crs.scale(toZoom) / crs.scale(fromZoom);
  },
  // @method getScaleZoom(scale: Number, fromZoom: Number): Number
  // Returns the zoom level that the map would end up at, if it is at `fromZoom`
  // level and everything is scaled by a factor of `scale`. Inverse of
  // [`getZoomScale`](#map-getZoomScale).
  getScaleZoom: function (scale, fromZoom) {
    var crs = this.options.crs;
    fromZoom = fromZoom === undefined ? this._zoom : fromZoom;
    var zoom = crs.zoom(scale * crs.scale(fromZoom));
    return isNaN(zoom) ? Infinity : zoom;
  },
  // @method project(latlng: LatLng, zoom: Number): Point
  // Projects a geographical coordinate `LatLng` according to the projection
  // of the map's CRS, then scales it according to `zoom` and the CRS's
  // `Transformation`. The result is pixel coordinate relative to
  // the CRS origin.
  project: function (latlng, zoom) {
    zoom = zoom === undefined ? this._zoom : zoom;
    return this.options.crs.latLngToPoint(_LatLng["default"].create(latlng), zoom);
  },
  // @method unproject(point: Point, zoom: Number): LatLng
  // Inverse of [`project`](#map-project).
  unproject: function (point, zoom) {
    zoom = zoom === undefined ? this._zoom : zoom;
    return this.options.crs.pointToLatLng(_Point2D["default"].create(point), zoom);
  },
  // @method layerPointToLatLng(point: Point): LatLng
  // Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
  // returns the corresponding geographical coordinate (for the current zoom level).
  layerPointToLatLng: function (point) {
    var projectedPoint = _Point2D["default"].create(point).add(this.getPixelOrigin());

    return this.unproject(projectedPoint);
  },
  // @method latLngToLayerPoint(latlng: LatLng): Point
  // Given a geographical coordinate, returns the corresponding pixel coordinate
  // relative to the [origin pixel](#map-getpixelorigin).
  latLngToLayerPoint: function (latlng) {
    var projectedPoint = this.project(_LatLng["default"].create(latlng))._round();

    return projectedPoint._subtract(this.getPixelOrigin());
  },
  // @method wrapLatLng(latlng: LatLng): LatLng
  // Returns a `LatLng` where `lat` and `lng` has been wrapped according to the
  // map's CRS's `wrapLat` and `wrapLng` properties, if they are outside the
  // CRS's bounds.
  // By default this means longitude is wrapped around the dateline so its
  // value is between -180 and +180 degrees.
  wrapLatLng: function (latlng) {
    return this.options.crs.wrapLatLng(_LatLng["default"].create(latlng));
  },
  // @method distance(latlng1: LatLng, latlng2: LatLng): Number
  // Returns the distance between two geographical coordinates according to
  // the map's CRS. By default this measures distance in meters.
  distance: function (latlng1, latlng2) {
    return this.options.crs.distance(_LatLng["default"].create(latlng1), _LatLng["default"].create(latlng2));
  },
  // @method containerPointToLayerPoint(point: Point): Point
  // Given a pixel coordinate relative to the map container, returns the corresponding
  // pixel coordinate relative to the [origin pixel](#map-getpixelorigin).
  containerPointToLayerPoint: function (point) {
    // (Point)
    return _Point2D["default"].create(point).subtract(this._getMapPanePos());
  },
  // @method layerPointToContainerPoint(point: Point): Point
  // Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
  // returns the corresponding pixel coordinate relative to the map container.
  layerPointToContainerPoint: function (point) {
    // (Point)
    return _Point2D["default"].create(point).add(this._getMapPanePos());
  },
  // @method containerPointToLatLng(point: Point): Point
  // Given a pixel coordinate relative to the map container, returns
  // the corresponding geographical coordinate (for the current zoom level).
  containerPointToLatLng: function (point) {
    var layerPoint = this.containerPointToLayerPoint(_Point2D["default"].create(point));
    return this.layerPointToLatLng(layerPoint);
  },
  // @method latLngToContainerPoint(latlng: LatLng): Point
  // Given a geographical coordinate, returns the corresponding pixel coordinate
  // relative to the map container.
  latLngToContainerPoint: function (latlng) {
    return this.layerPointToContainerPoint(this.latLngToLayerPoint(_LatLng["default"].create(latlng)));
  },
  // @method mouseEventToContainerPoint(ev: MouseEvent): Point
  // Given a MouseEvent object, returns the pixel coordinate relative to the
  // map container where the event took place.
  mouseEventToContainerPoint: function (e) {
    return _DomUtils["default"].getMousePos(e, this._container);
  },
  // @method mouseEventToLayerPoint(ev: MouseEvent): Point
  // Given a MouseEvent object, returns the pixel coordinate relative to
  // the [origin pixel](#map-getpixelorigin) where the event took place.
  mouseEventToLayerPoint: function (e) {
    return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(e));
  },
  // @method mouseEventToLatLng(ev: MouseEvent): LatLng
  // Given a MouseEvent object, returns geographical coordinate where the
  // event took place.
  mouseEventToLatLng: function (e) {
    // (MouseEvent)
    return this.layerPointToLatLng(this.mouseEventToLayerPoint(e));
  },
  _initContainer: function (id) {
    var container = this._container = _DomUtils["default"].get(id);

    !this.bindIEDragCursor() && _DomUtils["default"].addClass(container, 'leaflet-grab');
  },

  /**
   * IE下绑定地图鼠标光标drag&dragging
   * @returns {boolean}
   */
  bindIEDragCursor: function () {
    var _bind = false,
        option = this.options;

    if (_Browser["default"].ie && option.cursor) {
      var type = this._mapDragged ? "dragging" : "drag";
      this._container.style.cursor = "url(" + option.cursor[type] + "), auto";
      _bind = true;
    }

    return _bind;
  },
  // @method addControl(control: Control): this
  // Adds the given control to the map
  addControl: function (control) {
    control.addTo(this);
    return this;
  },
  // @method removeControl(control: Control): this
  // Removes the given control from the map
  removeControl: function (control) {
    control.remove();
    return this;
  },
  _initControlPos: function () {
    var corners = this._controlCorners = {},
        l = 'leaflet-',
        container = this._controlContainer = _DomUtils["default"].create('div', l + 'control-container', this._container);

    function createCorner(vSide, hSide) {
      var className = l + vSide + ' ' + l + hSide;
      corners[vSide + hSide] = _DomUtils["default"].create('div', className, container);
    }

    createCorner('top', 'left');
    createCorner('bottom', 'right');
  },
  // private methods that modify map state
  // @section Map state change events
  _resetView: function (center, zoom) {
    _DomUtils["default"].setPosition(this._mapPane, new _Point2D["default"](0, 0));

    var loading = !this._loaded;
    this._loaded = true;
    zoom = this._limitZoom(zoom);
    this.fire('viewprereset');
    var zoomChanged = this._zoom !== zoom;

    this._moveStart(zoomChanged)._move(center, zoom)._moveEnd(zoomChanged); // @event viewreset: Event
    // Fired when the map needs to redraw its content (this usually happens
    // on map zoom or load). Very useful for creating custom overlays.


    this.fire('viewreset'); // @event load: Event
    // Fired when the map is initialized (when its center and zoom are set
    // for the first time).

    if (loading) {
      this.fire('load');
    }
  },
  _moveStart: function (zoomChanged) {
    // @event zoomstart: Event
    // Fired when the map zoom is about to change (e.g. before zoom animation).
    // @event movestart: Event
    // Fired when the view of the map starts changing (e.g. user starts dragging the map).
    if (zoomChanged) {
      this.fire('zoomstart');
    }

    return this.fire('movestart');
  },
  _move: function (center, zoom, data) {
    if (zoom === undefined) {
      zoom = this._zoom;
    }

    var zoomChanged = this._zoom !== zoom;
    this._zoom = zoom;
    this._lastCenter = center;
    this._pixelOrigin = this._getNewPixelOrigin(center); // @event zoom: Event
    // Fired repeatedly during any change in zoom level, including zoom
    // and fly animations.

    if (zoomChanged || data && data.pinch) {
      // Always fire 'zoom' if pinching because #3530
      this.fire('zoom', data);
    } // @event move: Event
    // Fired repeatedly during any movement of the map, including pan and
    // fly animations.


    return this.fire('move', data);
  },
  _moveEnd: function (zoomChanged) {
    // @event zoomend: Event
    // Fired when the map has changed, after any animations.
    if (zoomChanged) {
      if (typeof this._animationStarted != "undefined") {
        this.drawAllEffects();
      }

      var vanchart = this; // 关于下面这个定时器的由来，有必要细说一下：
      // 之前地图这边的标签，为了保证不重叠，在画之前会进行一次冲突计算，对于冲突的点的标签，则不显示
      // 而每次zoom的时候，其实只是针对已有的标签进行位置更新，这就导致了最开始可能冲突的点等缩放到一定大小的zoom之后，可能就不冲突了，
      // 因此之前被隐藏的标签，就应该被重新显示出来。于是每次moveEnd即zoomChanged的时候，都会重新计算冲突标签和renderLabel
      // 2017-08-03 更新： 在地图钻取(多层级)，当一次上钻的等级差>1的时候，会连续两次zoom&setView，第二次则取消第一次动画，直接更新
      // 导致了validPoints不能及时更新(vanchartMap.layoutComponentsAndCharts里geo.doLayout原本有animateZoom的时候，这里结束validPoints应该已经更新了)，
      // 因此导致关于标签位置的计算会抛错（层级坐标改变，对应的标签尚未改变）故在这里加一个定时器，保证标签更新的时候，对应的坐标系和点都是正确的

      this.setTimeout("zoom_label_update", function () {
        vanchart._updateNormalLabel();
      }, 350);

      this._adjustMapPaneTranslateAfterZoom();

      this.fire('zoomend');
    } // @event moveend: Event
    // Fired when the center of the map stops changing (e.g. user stopped
    // dragging the map).


    return this.fire('moveend');
  },
  _stop: function () {
    _BaseUtils["default"].cancelAnimFrame(this._flyToFrame);

    if (this._panAnim) {
      this._panAnim.stop();
    }

    return this;
  },
  _rawPanBy: function (offset) {
    _DomUtils["default"].setPosition(this._mapPane, this._getMapPanePos().subtract(offset));
  },
  _getZoomSpan: function () {
    return this.getMaxZoom() - this.getMinZoom();
  },
  _panInsideMaxBounds: function () {
    if (!this._enforcingBounds) {
      this.panInsideBounds(this.options.maxBounds);
    }
  },
  _checkIfLoaded: function () {
    if (!this._loaded) {
      throw new Error('Set map center and zoom first.');
    }
  },
  _onResize: function () {
    _BaseUtils["default"].cancelAnimFrame(this._resizeRequest);

    this._resizeRequest = _BaseUtils["default"].requestAnimFrame(function () {
      this.invalidateSize({
        debounceMoveend: true
      });
    }, this);
  },
  _performZoom: function () {
    var map = this,
        zoom = map.getZoom(),
        snap = this.options.zoomSnap || 0;

    map._stop(); // stop panning and fly animations if any
    // map the delta with a sigmoid function to -4..4 range leaning on -1..1


    var d2 = this._delta / (this.options.wheelPxPerZoomLevel * 4),
        d3 = 4 * Math.log(2 / (1 + Math.exp(-Math.abs(d2)))) / Math.LN2,
        d4 = snap ? Math.ceil(d3 / snap) * snap : d3,
        delta = map._limitZoom(zoom + (this._delta > 0 ? d4 : -d4)) - zoom;
    this._delta = 0;
    this._startTime = null;

    if (!delta) {
      return;
    } // FixME 自动上钻的时候，需要判断是否为鼠标滚轮触发


    this._scrollZoom = true;

    if (map.options.scrollWheelZoom === 'center') {
      map.setZoom(zoom + delta);
    } else {
      map.setZoomAround(this._lastMousePos, zoom + delta);
    }
  },
  // @section Other Methods
  // @method whenReady(fn: Function, context?: Object): this
  // Runs the given function `fn` when the map gets initialized with
  // a view (center and zoom) and at least one layer, or immediately
  // if it's already initialized, optionally passing a function context.
  whenReady: function (callback, context) {
    if (this._loaded) {
      callback.call(context || this, {
        target: this
      });
    } else {
      this.on('load', callback, context);
    }

    return this;
  },
  _getMapPanePos: function () {
    return _DomUtils["default"].getPosition(this._mapPane) || new _Point2D["default"](0, 0);
  },
  _moved: function () {
    var pos = this._getMapPanePos();

    return pos && !pos.equals([0, 0]);
  },
  _getTopLeftPoint: function (center, zoom) {
    var pixelOrigin = center && zoom !== undefined ? this._getNewPixelOrigin(center, zoom) : this.getPixelOrigin();
    return pixelOrigin.subtract(this._getMapPanePos());
  },
  _getNewPixelOrigin: function (center, zoom) {
    var viewHalf = this.getSize()._divideBy(2);

    return this.project(center, zoom)._subtract(viewHalf)._add(this._getMapPanePos())._round();
  },
  _latLngToNewLayerPoint: function (latlng, zoom, center) {
    var topLeft = this._getNewPixelOrigin(center, zoom);

    return this.project(latlng, zoom)._subtract(topLeft);
  },
  _latLngBoundsToNewLayerBounds: function (latLngBounds, zoom, center) {
    var topLeft = this._getNewPixelOrigin(center, zoom);

    return _Bounds["default"].create([this.project(latLngBounds.getSouthWest(), zoom)._subtract(topLeft), this.project(latLngBounds.getNorthWest(), zoom)._subtract(topLeft), this.project(latLngBounds.getSouthEast(), zoom)._subtract(topLeft), this.project(latLngBounds.getNorthEast(), zoom)._subtract(topLeft)]);
  },
  // layer point of the current center
  _getCenterLayerPoint: function () {
    return this.containerPointToLayerPoint(this.getSize()._divideBy(2));
  },
  // offset of the specified place to the current center in pixels
  _getCenterOffset: function (latlng) {
    return this.latLngToLayerPoint(latlng).subtract(this._getCenterLayerPoint());
  },
  // adjust center for view to get inside bounds
  _limitCenter: function (center, zoom, bounds) {
    if (!bounds) {
      return center;
    }

    var centerPoint = this.project(center, zoom),
        viewHalf = this.getSize().divideBy(2),
        viewBounds = new _Bounds["default"](centerPoint.subtract(viewHalf), centerPoint.add(viewHalf)),
        offset = this._getBoundsOffset(viewBounds, bounds, zoom); // If offset is less than a pixel, ignore.
    // This prevents unstable projections from getting into
    // an infinite loop of tiny offsets.


    if (offset.round().equals([0, 0])) {
      return center;
    }

    return this.unproject(centerPoint.add(offset), zoom);
  },
  // adjust offset for view to get inside bounds
  _limitOffset: function (offset, bounds) {
    if (!bounds) {
      return offset;
    }

    var viewBounds = this.getPixelBounds(),
        newBounds = new _Bounds["default"](viewBounds.min.add(offset), viewBounds.max.add(offset));
    return offset.add(this._getBoundsOffset(newBounds, bounds));
  },
  // returns offset needed for pxBounds to get inside maxBounds at a specified zoom
  _getBoundsOffset: function (pxBounds, maxBounds, zoom) {
    var projectedMaxBounds = _Bounds["default"].create(this.project(maxBounds.getNorthEast(), zoom), this.project(maxBounds.getSouthWest(), zoom)),
        minOffset = projectedMaxBounds.min.subtract(pxBounds.min),
        maxOffset = projectedMaxBounds.max.subtract(pxBounds.max),
        dx = this._rebound(minOffset.x, -maxOffset.x),
        dy = this._rebound(minOffset.y, -maxOffset.y);

    return new _Point2D["default"](dx, dy);
  },
  _rebound: function (left, right) {
    return left + right > 0 ? Math.round(left - right) / 2 : Math.max(0, Math.ceil(left)) - Math.max(0, Math.floor(right));
  },
  _limitZoom: function (zoom) {
    var min = this.getMinZoom(),
        max = this.getMaxZoom(),
        snap = _Browser["default"].any3d ? this.options.zoomSnap : 1;

    if (snap) {
      if (_Browser["default"].any3d) {
        zoom = Math.round(zoom / snap) * snap;
      } else {
        zoom = zoom / snap * snap;
        zoom = zoom > this._zoom ? Math.ceil(zoom) : Math.floor(zoom); // zoom = 5.5, this._zoom = 6; IE8下snap为1，math.round(5.5) = 6，不变
      }
    }

    return Math.max(min, Math.min(max, zoom));
  },
  _onPanTransitionStep: function () {
    this.fire('move');
  },
  _onPanTransitionEnd: function () {
    _DomUtils["default"].removeClass(this._mapPane, 'leaflet-pan-anim');

    this.fire('moveend');
  },
  _tryAnimatedPan: function (center, options) {
    // difference between the new and current centers in pixels
    var offset = this._getCenterOffset(center)._floor(); // don't animate too far unless animate: true specified in options


    if ((options && options.animate) !== true && !this.getSize().contains(offset)) {
      return false;
    }

    this.panBy(offset, options);
    return true;
  },
  _nothingToAnimate: function () {
    return !this._container.getElementsByClassName('leaflet-zoom-animated').length;
  },
  _tryAnimatedZoom: function (center, zoom, options) {
    // @Cmen地图缩放的时候移除MoreLabel, 写在这个感觉不好，但除了这里也没找到好的地方
    this.removeMoreLabel();

    if (this._animatingZoom) {
      return true;
    }

    options = options || {}; // don't animate if disabled, not supported or zoom difference is too large

    if (!this._zoomAnimated || options.animate === false || this._nothingToAnimate() || Math.abs(zoom - this._zoom) > this.options.zoomAnimationThreshold) {
      return false;
    } // offset is the pixel coords of the zoom origin relative to the current center


    var scale = this.getZoomScale(zoom),
        offset = this._getCenterOffset(center)._divideBy(1 - 1 / scale); // don't animate if the zoom origin isn't within one screen from the current center, unless forced


    if (options.animate !== true && !this.getSize().contains(offset)) {
      return false;
    }

    _BaseUtils["default"].requestAnimFrame(function () {
      this._moveStart(true)._animateZoom(center, zoom, true);
    }, this);

    return true;
  },
  _animateZoom: function (center, zoom, startAnim, noUpdate) {
    if (startAnim) {
      this._animatingZoom = true; // remember what center/zoom to set after animation

      this._animateToCenter = center;
      this._animateToZoom = zoom;

      _DomUtils["default"].addClass(this._mapPane, 'leaflet-zoom-anim');
    }

    var minZoomAllowed = this._layersMinZoom;

    if (minZoomAllowed && zoom < minZoomAllowed) {
      zoom = minZoomAllowed;
      this._animateToZoom = zoom;
    } // @event zoomanim: ZoomAnimEvent
    // Fired on every frame of a zoom animation


    this.fire('zoomanim', {
      center: center,
      zoom: zoom,
      noUpdate: noUpdate
    }); // Work around webkit not firing 'transitionend', see https://github.com/Leaflet/Leaflet/issues/3689, 2693

    setTimeout(_BaseUtils["default"].bind(this._onZoomTransitionEnd, this), 250);
  },
  _onZoomTransitionEnd: function () {
    if (!this._animatingZoom) {
      return;
    }

    _DomUtils["default"].removeClass(this._mapPane, 'leaflet-zoom-anim');

    this._animatingZoom = false;

    this._move(this._animateToCenter, this._animateToZoom); // This anim frame should prevent an obscure iOS webkit tile loading race condition.


    _BaseUtils["default"].requestAnimFrame(function () {
      this._moveEnd(true);
    }, this);
  },
  addLayer: function (layer) {
    var id = _BaseUtils["default"].stamp(layer);

    if (this._layers[id]) {
      return this;
    }

    this._layers[id] = layer;
    layer._mapToAdd = this;

    if (layer.beforeAdd) {
      layer.beforeAdd(this);
    }

    this.whenReady(layer._layerAdd, layer);
    return this;
  },
  // @method removeLayer(layer: Layer): this
  // Removes the given layer from the map.
  removeLayer: function (layer) {
    var id = _BaseUtils["default"].stamp(layer);

    if (!this._layers[id]) {
      return this;
    }

    if (this._loaded) {
      layer.onRemove(this);
    }

    delete this._layers[id];

    if (this._loaded) {
      this.fire('layerremove', {
        layer: layer
      });
      layer.fire('remove');
    }

    layer._map = layer._mapToAdd = null;
    return this;
  },
  // @method hasLayer(layer: Layer): Boolean
  // Returns `true` if the given layer is currently added to the map
  hasLayer: function (layer) {
    return !!layer && _BaseUtils["default"].stamp(layer) in this._layers;
  },
  eachLayer: function (method, context) {
    for (var i in this._layers) {
      method.call(context, this._layers[i]);
    }

    return this;
  },
  _addZoomLimit: function (layer) {
    if (isNaN(layer.options.maxZoom) || !isNaN(layer.options.minZoom)) {
      this._zoomBoundLayers[_BaseUtils["default"].stamp(layer)] = layer;

      this._updateZoomLevels();
    }
  },
  _removeZoomLimit: function (layer) {
    var id = _BaseUtils["default"].stamp(layer);

    if (this._zoomBoundLayers[id]) {
      delete this._zoomBoundLayers[id];

      this._updateZoomLevels();
    }
  },
  _updateZoomLevels: function () {
    var minZoom = Infinity,
        maxZoom = -Infinity,
        oldZoomSpan = this._getZoomSpan();

    for (var i in this._zoomBoundLayers) {
      var options = this._zoomBoundLayers[i].options;
      minZoom = options.minZoom === undefined ? minZoom : Math.min(minZoom, options.minZoom);
      maxZoom = options.maxZoom === undefined ? maxZoom : Math.max(maxZoom, options.maxZoom);
    }

    this._layersMaxZoom = maxZoom === -Infinity ? undefined : maxZoom;
    this._layersMinZoom = minZoom === Infinity ? undefined : minZoom;

    if (this.options.maxZoom === undefined && this._layersMaxZoom && this.getZoom() > this._layersMaxZoom) {
      this.setZoom(this._layersMaxZoom);
    }

    if (this.options.minZoom === undefined && this._layersMinZoom && this.getZoom() < this._layersMinZoom) {
      this.setZoom(this._layersMinZoom);
    }
  }
});

var _default = VanChartBaseMap;
exports["default"] = _default;

/***/ }),
/* 97 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _quadtree = _interopRequireDefault(__webpack_require__(98));

var _Timer = _interopRequireDefault(__webpack_require__(70));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/20.
 */
var d3_layout_forceLinkDistance = 20,
    d3_layout_forceLinkStrength = 1,
    d3_layout_forceChargeDistance2 = Infinity;

var ForceLayout = function () {
  var force = {},
      size = [1, 1],
      alpha,
      friction = .9,
      linkDistance = d3_layout_forceLinkDistance,
      linkStrength = d3_layout_forceLinkStrength,
      charge = -30,
      chargeDistance2 = d3_layout_forceChargeDistance2,
      gravity = .1,
      theta2 = .64,
      nodes = [],
      links = [],
      distances,
      strengths,
      charges;

  var _scale = 1,
      _eachTick,
      _startTick,
      _endTick,
      _events,
      _targets = {};

  function repulse(node) {
    return function (quad, x1, _, x2) {
      if (quad.point !== node) {
        var dx = quad.cx - node.x,
            dy = quad.cy - node.y,
            dw = x2 - x1,
            dn = dx * dx + dy * dy;

        if (dw * dw / theta2 < dn) {
          if (dn < chargeDistance2) {
            var k = quad.charge / dn;
            node.px -= dx * k;
            node.py -= dy * k;
          }

          return true;
        }

        if (quad.point && dn && dn < chargeDistance2) {
          var k = quad.pointCharge / dn;
          node.px -= dx * k;
          node.py -= dy * k;
        }
      }

      return !quad.charge;
    };
  }

  force.tick = function () {
    if ((alpha *= .99) < .005) {
      alpha = 0;
      _endTick && _endTick();
      return true;
    }

    var n = nodes.length,
        q,
        i,
        o,
        k,
        x,
        y;

    force._distanceTick();

    if (k = alpha * gravity) {
      x = size[0] / 2;
      y = size[1] / 2;
      i = -1;

      if (k) {
        while (++i < n) {
          o = nodes[i];
          o.x += (x - o.x) * k;
          o.y += (y - o.y) * k;
        }
      }
    }

    if (charge) {
      d3_layout_forceAccumulate(q = (0, _quadtree["default"])(nodes), alpha, charges);
      i = -1;

      while (++i < n) {
        if (!(o = nodes[i]).fixed) {
          q.visit(repulse(o));
        }
      }
    }

    i = -1;

    while (++i < n) {
      o = nodes[i];

      if (o.fixed) {
        o.x = o.px;
        o.y = o.py;
      } else {
        o.x -= (o.px - (o.px = o.x)) * friction;
        o.y -= (o.py - (o.py = o.y)) * friction;
      }
    }

    _eachTick && _eachTick({
      alpha: alpha
    });
  };

  force._distanceTick = function () {
    var m = links.length,
        i,
        o,
        s,
        t,
        l,
        k,
        x,
        y;

    for (i = 0; i < m; ++i) {
      o = links[i];
      s = o.source;
      t = o.target;
      x = t.x - s.x;
      y = t.y - s.y;

      if (l = x * x + y * y) {
        l = alpha * strengths[i] * ((l = Math.sqrt(l)) - distances[i] * _scale) / l;
        x *= l;
        y *= l;
        t.x -= x * (k = s.weight / (t.weight + s.weight));
        t.y -= y * k;
        s.x += x * (k = 1 - k);
        s.y += y * k;
      }
    }
  };

  force.nodes = function (x) {
    if (!arguments.length) {
      return nodes;
    }

    nodes = x;
    return force;
  };

  force.links = function (x) {
    if (!arguments.length) {
      return links;
    }

    links = x;
    return force;
  };

  force.eachTick = function (x) {
    if (!arguments.length) {
      return _eachTick;
    }

    _eachTick = x;
    return force;
  };

  force.endTick = function (x) {
    if (!arguments.length) {
      return _endTick;
    }

    _endTick = x;
    return force;
  };

  force.size = function (x) {
    if (!arguments.length) {
      return size;
    }

    size = x;
    return force;
  };

  force.scale = function (x) {
    if (!arguments.length) {
      return _scale;
    }

    _scale = x;
    return force;
  };

  force.linkDistance = function (x) {
    if (!arguments.length) {
      return linkDistance;
    }

    linkDistance = typeof x === "function" ? x : +x;
    return force;
  };

  force.distance = force.linkDistance;

  force.linkStrength = function (x) {
    if (!arguments.length) {
      return linkStrength;
    }

    linkStrength = typeof x === "function" ? x : +x;
    return force;
  };

  force.friction = function (x) {
    if (!arguments.length) {
      return friction;
    }

    friction = +x;
    return force;
  };

  force.charge = function (x) {
    if (!arguments.length) {
      return charge;
    }

    charge = typeof x === "function" ? x : +x;
    return force;
  };

  force.chargeDistance = function (x) {
    if (!arguments.length) {
      return Math.sqrt(chargeDistance2);
    }

    chargeDistance2 = x * x;
    return force;
  };

  force.gravity = function (x) {
    if (!arguments.length) {
      return gravity;
    }

    gravity = +x;
    return force;
  };

  force.theta = function (x) {
    if (!arguments.length) {
      return Math.sqrt(theta2);
    }

    theta2 = x * x;
    return force;
  };

  force.alpha = function (x) {
    if (!arguments.length) {
      return alpha;
    }

    x = +x;

    if (alpha) {
      if (x > 0) {
        alpha = x;
      } else {
        alpha = 0;
      }
    } else if (x > 0) {
      alpha = x;
      (0, _Timer["default"])(force.tick);
    }

    return force;
  }; //有集聚动画


  force.start = function () {
    force.preparePara();
    return force.resume();
  }; //模拟集聚，没有动画


  force.simulateForce = function () {
    force.preparePara();
    force.alpha(0.1);

    while (force.alpha() >= 0.005) {
      force.tick();
    }

    _endTick && _endTick();
    return force;
  }; //ie下，简单模拟


  force.simpleSimulateForce = function () {
    force.preparePara();
    var start = 0.1,
        end = 0.005;
    var padding = 2,
        clusterPadding = 2;
    var paddingAlpha = 0.5;
    var gravity = 0.02;
    var friction = 0.9;

    for (var alpha = start; alpha >= end; alpha -= alpha > 0.07 ? 0.001 : 0.0005) {
      var n = nodes.length,
          i,
          o,
          k,
          x,
          y;

      if (k = alpha * gravity) {
        x = size[0] / 2;
        y = size[1] / 2;
        i = -1;

        if (k) {
          while (++i < n) {
            o = nodes[i];
            o.x += (x - o.x) * k;
            o.y += (y - o.y) * k;
          }
        }
      }

      i = -1;

      while (++i < n) {
        o = nodes[i];
        o.x -= (o.px - (o.px = o.x)) * friction;
        o.y -= (o.py - (o.py = o.y)) * friction;
      }

      nodes.forEach(function (d) {
        //集聚
        var cluster = d.series.cluster;

        if (cluster && cluster != d) {
          var x = d.x - cluster.x,
              y = d.y - cluster.y,
              l = Math.sqrt(x * x + y * y),
              r = d.radius + cluster.radius;

          if (l != r) {
            l = (l - r) / l * alpha;
            d.x -= x *= l;
            d.y -= y *= l;
            cluster.x += x;
            cluster.y += y;
          }
        }
      });

      for (var i = 0; i < n; i++) {
        var d = nodes[i];

        for (var j = 0; j < n; j++) {
          var point = nodes[j];

          if (point !== d) {
            var x = d.x - point.x,
                y = d.y - point.y,
                l = Math.sqrt(x * x + y * y),
                r = d.radius + point.radius + (d.series.cluster === point.series.cluster ? padding : clusterPadding);

            if (l < r) {
              l = (l - r) / l * paddingAlpha;
              d.x -= x *= l;
              d.y -= y *= l;
              point.x += x;
              point.y += y;
            }
          }
        }
      }
    }

    _endTick && _endTick();
    return force;
  };

  force.preparePara = function () {
    var i,
        n = nodes.length,
        m = links.length,
        w = size[0],
        h = size[1],
        neighbors,
        o;

    for (i = 0; i < n; ++i) {
      (o = nodes[i]).index = i;
      o.weight = 0;
    }

    for (i = 0; i < m; ++i) {
      o = links[i];

      if (typeof o.source == "number") {
        o.source = nodes[o.source];
      }

      if (typeof o.target == "number") {
        o.target = nodes[o.target];
      }

      ++o.source.weight;
      ++o.target.weight;
    }

    for (i = 0; i < n; ++i) {
      o = nodes[i];

      if (isNaN(o.x)) {
        o.x = position("x", w);
      }

      if (isNaN(o.y)) {
        o.y = position("y", h);
      }

      if (isNaN(o.px)) {
        o.px = o.x;
      }

      if (isNaN(o.py)) {
        o.py = o.y;
      }
    }

    distances = [];

    if (typeof linkDistance === "function") {
      for (i = 0; i < m; ++i) {
        distances[i] = +linkDistance.call(this, links[i], i);
      }
    } else {
      for (i = 0; i < m; ++i) {
        distances[i] = linkDistance;
      }
    }

    strengths = [];

    if (typeof linkStrength === "function") {
      for (i = 0; i < m; ++i) {
        strengths[i] = +linkStrength.call(this, links[i], i);
      }
    } else {
      for (i = 0; i < m; ++i) {
        strengths[i] = linkStrength;
      }
    }

    charges = [];

    if (typeof charge === "function") {
      for (i = 0; i < n; ++i) {
        charges[i] = +charge.call(this, nodes[i], i);
      }
    } else {
      for (i = 0; i < n; ++i) {
        charges[i] = charge;
      }
    }

    function position(dimension, size) {
      if (!neighbors) {
        neighbors = [];

        for (j = 0; j < n; ++j) {
          neighbors[j] = [];
        }

        for (j = 0; j < m; ++j) {
          var o = links[j];
          neighbors[o.source.index].push(o.target);
          neighbors[o.target.index].push(o.source);
        }
      }

      var candidates = neighbors[i],
          j = -1,
          l = candidates.length,
          x;

      while (++j < l) {
        if (!isNaN(x = candidates[j][dimension])) {
          return x;
        }
      }

      return Math.random() * size;
    }

    return force;
  };

  force.resume = function () {
    return force.alpha(.1);
  };

  force.stop = function () {
    return force.alpha(0);
  };

  force.registerDragTarget = function (data, elementWrapper) {
    if (!_events) {
      _events = getEvents();
    }

    _targets[_BaseUtils["default"].stamp(elementWrapper.node())] = data;
  };

  force.dragFire = function (ev, container) {
    if (!_events) {
      return;
    }

    var srcEvent = ev.srcEvent,
        type = ev.type || srcEvent.type;
    var isPan = type === 'panstart' || type === 'panmove' || type === 'panend';
    var target;

    if (isPan && force.panTarget) {
      target = force.panTarget;
    } else {
      var src = srcEvent.target || srcEvent.srcElement;
      target = findDragTarget(_targets, src, container);
    }

    if (target && _events[type]) {
      _events[type](target, force, ev);

      return target;
    }
  };

  return force;
};

function findDragTarget(_targets, src, container) {
  var target;

  while (src) {
    target = _targets[_BaseUtils["default"].stamp(src)];

    if (target) {
      return target;
    }

    if (src === container) {
      return null;
    }

    src = src.parentNode;
  }
}

function getEvents() {
  return {
    'mouseover': d3_layout_forceMouseover,
    'mouseout': d3_layout_forceMouseout,
    'panstart': d3_layout_forceDragstart,
    'panmove': d3_layout_forceDragmove,
    'panend': d3_layout_forceDragend
  };
}

function d3_layout_forceDragmove(d, force, ev) {
  var transX = ev.containerPoint.x - force.currentPoint.x,
      transY = ev.containerPoint.y - force.currentPoint.y;
  force.currentPoint = ev.containerPoint;
  d.px += transX;
  d.py += transY;
  force.resume();
}

function d3_layout_forceDragstart(d, force, ev) {
  d.fixed |= 2;
  force.panTarget = d;
  force.currentPoint = ev.containerPoint;
}

function d3_layout_forceDragend(d, force) {
  d.fixed &= ~6;
  force.panTarget = null;
}

function d3_layout_forceMouseover(d) {
  d.fixed |= 4;
  d.px = d.x;
  d.py = d.y;
}

function d3_layout_forceMouseout(d) {
  d.fixed &= ~4;
}

function d3_layout_forceAccumulate(quad, alpha, charges) {
  var cx = 0,
      cy = 0;
  quad.charge = 0;

  if (!quad.leaf) {
    var nodes = quad.nodes,
        n = nodes.length,
        i = -1,
        c;

    while (++i < n) {
      c = nodes[i];

      if (c == null) {
        continue;
      }

      d3_layout_forceAccumulate(c, alpha, charges);
      quad.charge += c.charge;
      cx += c.charge * c.cx;
      cy += c.charge * c.cy;
    }
  }

  if (quad.point) {
    if (!quad.leaf) {
      quad.point.x += Math.random() - .5;
      quad.point.y += Math.random() - .5;
    }

    var k = alpha * charges[quad.point.index];
    quad.charge += quad.pointCharge = k;
    cx += k * quad.point.x;
    cy += k * quad.point.y;
  }

  quad.cx = cx / quad.charge;
  quad.cy = cy / quad.charge;
}

var _default = ForceLayout;
exports["default"] = _default;

/***/ }),
/* 98 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by eason on 2017/2/20.
 */
function d3_geom_pointX(d) {
  return d[0];
}

function d3_geom_pointY(d) {
  return d[1];
}

function d3_functor(v) {
  return typeof v === "function" ? v : function () {
    return v;
  };
}

var abs = Math.abs;

function quadtree(points, x1, y1, x2, y2) {
  var x = d3_geom_pointX,
      y = d3_geom_pointY,
      compat;

  if (compat = arguments.length) {
    x = d3_geom_quadtreeCompatX;
    y = d3_geom_quadtreeCompatY;

    if (compat === 3) {
      y2 = y1;
      x2 = x1;
      y1 = x1 = 0;
    }

    return quadtree(points);
  }

  function quadtree(data) {
    var d,
        fx = d3_functor(x),
        fy = d3_functor(y),
        xs,
        ys,
        i,
        n,
        x1_,
        y1_,
        x2_,
        y2_;

    if (x1 != null) {
      x1_ = x1, y1_ = y1, x2_ = x2, y2_ = y2;
    } else {
      x2_ = y2_ = -(x1_ = y1_ = Infinity);
      xs = [], ys = [];
      n = data.length;
      if (compat) for (i = 0; i < n; ++i) {
        d = data[i];

        if (d.x < x1_) {
          x1_ = d.x;
        }

        if (d.y < y1_) {
          y1_ = d.y;
        }

        if (d.x > x2_) {
          x2_ = d.x;
        }

        if (d.y > y2_) {
          y2_ = d.y;
        }

        xs.push(d.x);
        ys.push(d.y);
      } else for (i = 0; i < n; ++i) {
        var x_ = +fx(d = data[i], i),
            y_ = +fy(d, i);

        if (x_ < x1_) {
          x1_ = x_;
        }

        if (y_ < y1_) {
          y1_ = y_;
        }

        if (x_ > x2_) {
          x2_ = x_;
        }

        if (y_ > y2_) {
          y2_ = y_;
        }

        xs.push(x_);
        ys.push(y_);
      }
    }

    var dx = x2_ - x1_,
        dy = y2_ - y1_;

    if (dx > dy) {
      y2_ = y1_ + dx;
    } else {
      x2_ = x1_ + dy;
    }

    function insert(n, d, x, y, x1, y1, x2, y2) {
      if (isNaN(x) || isNaN(y)) {
        return;
      }

      if (n.leaf) {
        var nx = n.x,
            ny = n.y;

        if (nx != null) {
          if (abs(nx - x) + abs(ny - y) < .01) {
            insertChild(n, d, x, y, x1, y1, x2, y2);
          } else {
            var nPoint = n.point;
            n.x = n.y = n.point = null;
            insertChild(n, nPoint, nx, ny, x1, y1, x2, y2);
            insertChild(n, d, x, y, x1, y1, x2, y2);
          }
        } else {
          n.x = x, n.y = y, n.point = d;
        }
      } else {
        insertChild(n, d, x, y, x1, y1, x2, y2);
      }
    }

    function insertChild(n, d, x, y, x1, y1, x2, y2) {
      var xm = (x1 + x2) * .5,
          ym = (y1 + y2) * .5,
          right = x >= xm,
          below = y >= ym,
          i = below << 1 | right;
      n.leaf = false;
      n = n.nodes[i] || (n.nodes[i] = d3_geom_quadtreeNode());

      if (right) {
        x1 = xm;
      } else {
        x2 = xm;
      }

      if (below) {
        y1 = ym;
      } else {
        y2 = ym;
      }

      insert(n, d, x, y, x1, y1, x2, y2);
    }

    var root = d3_geom_quadtreeNode();

    root.add = function (d) {
      insert(root, d, +fx(d, ++i), +fy(d, i), x1_, y1_, x2_, y2_);
    };

    root.visit = function (f) {
      d3_geom_quadtreeVisit(f, root, x1_, y1_, x2_, y2_);
    };

    root.find = function (point) {
      return d3_geom_quadtreeFind(root, point[0], point[1], x1_, y1_, x2_, y2_);
    };

    i = -1;

    if (x1 == null) {
      while (++i < n) {
        insert(root, data[i], xs[i], ys[i], x1_, y1_, x2_, y2_);
      }

      --i;
    } else {
      data.forEach(root.add);
    }

    xs = ys = data = d = null;
    return root;
  }

  quadtree.x = function (_) {
    return arguments.length ? (x = _, quadtree) : x;
  };

  quadtree.y = function (_) {
    return arguments.length ? (y = _, quadtree) : y;
  };

  quadtree.extent = function (_) {
    if (!arguments.length) {
      return x1 == null ? null : [[x1, y1], [x2, y2]];
    }

    if (_ == null) {
      x1 = y1 = x2 = y2 = null;
    } else {
      x1 = +_[0][0], y1 = +_[0][1], x2 = +_[1][0], y2 = +_[1][1];
    }

    return quadtree;
  };

  quadtree.size = function (_) {
    if (!arguments.length) {
      return x1 == null ? null : [x2 - x1, y2 - y1];
    }

    if (_ == null) {
      x1 = y1 = x2 = y2 = null;
    } else {
      x1 = y1 = 0, x2 = +_[0], y2 = +_[1];
    }

    return quadtree;
  };

  return quadtree;
}

;

function d3_geom_quadtreeCompatX(d) {
  return d.x;
}

function d3_geom_quadtreeCompatY(d) {
  return d.y;
}

function d3_geom_quadtreeNode() {
  return {
    leaf: true,
    nodes: [],
    point: null,
    x: null,
    y: null
  };
}

function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
  if (!f(node, x1, y1, x2, y2)) {
    var sx = (x1 + x2) * .5,
        sy = (y1 + y2) * .5,
        children = node.nodes;

    if (children[0]) {
      d3_geom_quadtreeVisit(f, children[0], x1, y1, sx, sy);
    }

    if (children[1]) {
      d3_geom_quadtreeVisit(f, children[1], sx, y1, x2, sy);
    }

    if (children[2]) {
      d3_geom_quadtreeVisit(f, children[2], x1, sy, sx, y2);
    }

    if (children[3]) {
      d3_geom_quadtreeVisit(f, children[3], sx, sy, x2, y2);
    }
  }
}

function d3_geom_quadtreeFind(root, x, y, x0, y0, x3, y3) {
  var minDistance2 = Infinity,
      closestPoint;

  (function find(node, x1, y1, x2, y2) {
    if (x1 > x3 || y1 > y3 || x2 < x0 || y2 < y0) {
      return;
    }

    if (point = node.point) {
      var point,
          dx = x - node.x,
          dy = y - node.y,
          distance2 = dx * dx + dy * dy;

      if (distance2 < minDistance2) {
        var distance = Math.sqrt(minDistance2 = distance2);
        x0 = x - distance, y0 = y - distance;
        x3 = x + distance, y3 = y + distance;
        closestPoint = point;
      }
    }

    var children = node.nodes,
        xm = (x1 + x2) * .5,
        ym = (y1 + y2) * .5,
        right = x >= xm,
        below = y >= ym;

    for (var i = below << 1 | right, j = i + 4; i < j; ++i) {
      if (node = children[i & 3]) {
        switch (i & 3) {
          case 0:
            find(node, x1, y1, xm, ym);
            break;

          case 1:
            find(node, xm, y1, x2, ym);
            break;

          case 2:
            find(node, x1, ym, xm, y2);
            break;

          case 3:
            find(node, xm, ym, x2, y2);
            break;
        }
      }
    }
  })(root, x0, y0, x3, y3);

  return closestPoint;
}

var _default = quadtree;
exports["default"] = _default;

/***/ }),
/* 99 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _VanCharts = _interopRequireDefault(__webpack_require__(100));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _VanHammer = _interopRequireDefault(__webpack_require__(43));

var _env = _interopRequireDefault(__webpack_require__(238));

var _util = __webpack_require__(239);

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var global = typeof window === 'object' ? window : global;
global.VanCharts = _VanCharts["default"];
global.VAN_CANVAS = (0, _EnvUtils.isSupportSVG)() ? 'canvas' : 'vancanvas';
global.VanUtils = _BaseUtils["default"];
global.ColorUtils = _ColorUtils["default"];
global.VanHammer = _VanHammer["default"];
global.env = _env["default"];
(0, _util.$override)('createCanvas', _EnvUtils.createCanvas);
var _default = _VanCharts["default"];
exports["default"] = _default;

/***/ }),
/* 100 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _LoadingUtils = _interopRequireDefault(__webpack_require__(101));

var _Carousel = _interopRequireDefault(__webpack_require__(102));

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _TouchEventHelper = _interopRequireDefault(__webpack_require__(71));

var _showEmptyDataTip = _interopRequireDefault(__webpack_require__(72));

var _vans = _interopRequireDefault(__webpack_require__(127));

var _VanChartInterface = __webpack_require__(57);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var NATIVE_HANDLE_NEXT = 'nativeHandleNext';
var PORTRAIT = 'portrait';
var LANDSCAPE = 'landscape';
var _baseIndex = 0;

var _instances = Object.create(null);

function init(dom) {
  var vanCharts;

  if (false) {} else {
    var instanceKey = dom.getAttribute(_Constants["default"].INSTANCES_KEY);

    if (!instanceKey) {
      instanceKey = _Constants["default"].INSTANCES_KEY + _baseIndex++;
      dom.setAttribute(_Constants["default"].INSTANCES_KEY, instanceKey);
    }

    vanCharts = _instances[instanceKey] || new VanCharts(dom);
    _instances[instanceKey] = vanCharts;
    (0, _VanChartInterface.hideLightBoxWithReInit)();
  }

  return vanCharts;
}

function VanCharts(dom) {
  this.dom = dom;
  this.charts = [];

  if (true) {
    this.carousel = _Carousel["default"] && (0, _Carousel["default"])(this);
    this.dom.style.cssText += ';overflow:hidden;-ms-user-select:none;-webkit-user-select:none;-moz-user-select:none;-o-user-select:none;user-select:none;';

    this.dom.onselectstart = this.dom.ondrag = function () {
      return false;
    };

    this._isMobileFlow = null; // delay the drilldown event

    this._drillDownPoint = null;
    this._drillUpPoint = null;
    this._shouldCarouselRun = true;
    this._orientation = null;

    this._setOrientationByBrowser();

    this.emitter = new _Evented["default"]();

    this._registerEvent();
  }
}

VanCharts.prototype = {
  constructor: VanCharts,
  trigger: function (eventName, event) {
    return this.emitter.fire(eventName, event);
  },
  on: function (eventName, eventHandler, context) {
    return this.emitter.on(eventName, eventHandler, context);
  },
  off: function (eventName, eventHandler) {
    return this.emitter.off(eventName, eventHandler);
  },
  getChartNow: function () {
    if (this.charts.length > 1) {
      return this.charts[this.carousel.getIndex()];
    }

    return this.charts[0];
  },
  shouldCarouselRun: function () {
    return this._shouldCarouselRun;
  },
  _interactive: function (flag) {
    this.charts.forEach(function (chart) {
      flag ? chart.handler.enable() : chart.handler.disable();
    });
  },
  // mobile event position is relative to view's top-left
  getCarouselChartOffset: function () {
    var proxy = this.getChartNow().handler.proxy;

    if (this.charts.length > 1) {
      var outer = this.dom.getBoundingClientRect();
      var inner = proxy.dom.getBoundingClientRect();
      var deltaY = inner.top - outer.top;

      if (deltaY > 0) {
        return deltaY;
      }
    }

    return 0;
  },
  _registerEvent: function () {
    var self = this;
    this.on('enable', function (pos) {
      if (!self.isMobileFlow()) {
        return;
      }

      if (self.charts.length > 1) {
        self._shouldCarouselRun = false;
        self.carousel.stop();
      }

      self._interactive(true);

      if (pos && pos.x > 0 && pos.y > 0) {
        var proxy = self.getChartNow().handler.proxy;
        pos.y -= self.getCarouselChartOffset();
        proxy.dispatch({
          type: 'touchstart',
          touches: [pos]
        });
        proxy.dispatch({
          type: 'touchend',
          touches: [pos]
        });
      }
    });
    this.on('disable', function () {
      if (!self.isMobileFlow()) {
        return;
      } // hide + unready


      self.getChartNow().handler.fire('pointCancel');

      self._interactive(false);

      if (self.charts.length > 1) {
        self._shouldCarouselRun = true;
        self.carousel.resume();
      }
    });
    this.on('pointCancel', function () {
      if (!self.isMobileFlow()) {
        return;
      }

      self._drillDownPoint = null; // hide + unready

      self.getChartNow().handler.fire('pointCancel');
    }); // todo, `resize` is enough ?

    this.on('orientationChange', function (v) {
      if (!self.isMobileFlow()) {
        return;
      } // todo, refresh all charts


      if (v) {
        v = v.toLowerCase();
        v = v.indexOf(PORTRAIT) ? PORTRAIT : LANDSCAPE;
        self._orientation = v;
      } else {
        self._setOrientationByBrowser();
      }

      self.getChartNow().changeOrientation(self.getOrientation());
    });
    this.on('carouselpanstart', function (e) {
      if (!self.isMobileFlow()) {
        return;
      } // todo, prevent exception


      e.chartIndex = self.charts.indexOf(e.chart);
      self.carousel.panstart(e);
    });
    this.on('carouselpanmove', function (e) {
      if (!self.isMobileFlow()) {
        return;
      }

      self.carousel.panmove(e);
    });
    this.on('carouselpanend', function (e) {
      if (!self.isMobileFlow()) {
        return;
      }

      self.carousel.panend(e);
    });
    this.on('drill', function (param) {
      if (!param || !param.type) {
        return;
      }

      clearTimeout(self._drillTimeout); // #MOBILE-18791
      // trigger it in next tick
      // 因为FR和移动端的事件用的回调，当回调结束，才会执行图表的下一步
      // 移动端在回调里就要trigger drill的时候，我们的点还没hold，于是bug

      self._drillTimeout = setTimeout(function () {
        if (param.type.toLowerCase() === 'down') {
          var p = self._drillDownPoint;

          if (p) {
            if (p.series.drillDown) {
              p.series.drillDown(p);
            } else if (p.series.vanchart) {
              p.series.vanchart.drillDown(p);
            }

            self._drillDownPoint = null;
          }
        } else {
          var p = self._drillUpPoint;

          if (p && p.drillUpDataPoint) {
            p.drillUpDataPoint.series.vanchart.drillUp(p);
            self._drillUpPoint = null;
          }
        }
      }, 0);
    });
    this.on('sort', function (o) {
      var order = o.order;

      switch (order) {
        case 0:
          self.eachVanChart(function (chart) {
            chart.clearAllEffects();
            chart.refreshRestore();
          });
          break;

        case 1:
        case -1:
          self.eachVanChart(function (chart) {
            chart.sortChart(order);
          });
          break;

        default: // undefined result

      }
    });
    this.on('eventsConfig', function (config) {
      self.charts.forEach(function (chart) {
        _QueryUtils["default"].merge(chart._eventsConfig, config, true);

        if (self.isMobileFlow()) {
          if (chart._eventsConfig.pan) {
            chart.handler.proxy.recoverLeafletTouchAction();
          } else {
            chart.handler.proxy.normalizeLeafletTouchAction();
          }
        } else {
          for (var k in chart._eventsConfig) {
            if (!chart._eventsConfig.hasOwnProperty(k)) {
              continue;
            }

            var rec = chart.handler.hammer.get(k);

            if (rec) {
              rec.set({
                enable: chart._eventsConfig[k]
              });
            }
          }
        }
      });
    });
  },
  holdDrillDownPoint: function (p) {
    this._drillDownPoint = p;
  },
  holdDrillUpPoint: function (p) {
    this._drillUpPoint = p;
  },
  __devZoom: function (p, z) {
    var vanchart = this.charts[0];
    p = p || {
      x: 200,
      y: 200
    };
    z = z || {
      x: 1.5,
      y: 1
    };

    vanchart.handler.__hover.onmultipointstart({
      stop: function () {},
      srcEvent: {
        touches: [{
          pageX: p.x,
          pageY: p.y
        }, {
          pageX: p.x,
          pageY: p.y
        }]
      }
    });

    vanchart.handler.__hover.onpinch({
      stop: function () {},
      srcEvent: {
        zoomX: z.x,
        zoomY: z.y
      }
    });

    vanchart.handler.__hover.onmultipointend();
  },
  // for mobile native callback
  handleTouchEnd: function (event) {
    if (!(event.direction === 'Up' || event.direction === 'Down')) {
      return;
    }

    var b = this.getScrollBounds();

    if (b.shouldNativeHandle) {
      delete b.shouldParentHandle;
      this.trigger(NATIVE_HANDLE_NEXT, b);
    }
  },
  // for mobile scroll sync
  getScrollBounds: function () {
    var options = this.options;
    var b = this.getChartNow().getScrollBounds(); // 只判断竖屏
    // 横屏用按钮切换，没有边界滚动逻辑

    if (b.shouldParentHandle && b.verticalEdge !== 'middle') {
      b.shouldNativeHandle = true;
    }

    return b;
  },
  setOptions: function (options) {
    // console.log(JSON.stringify(options));
    // once it is flow doc, deem all as flow
    // some new data (setData) have no flow flag
    if (this.isMobileFlow() == null) {
      this._isMobileFlow = this._checkMobileFlow(options);
    }

    if (this.isMobileFlow()) {
      _BaseUtils["default"].initPaddingScale(0.85);

      _BaseUtils["default"].calculateFontSizeWithScale = _BaseUtils["default"]._mutateMobileFlowFontStyle;

      if (options && options.switchStyle && options.switchStyle.type === _Constants["default"].CAROUSEL) {
        options.switchStyle.type = _Constants["default"].NO_ARROW;
      }
    }

    this.options = options || this.options;

    if (options && _BaseUtils["default"].isArray(options.options)) {
      this.charts = this.carousel.init(options, this.charts, this.dom);
    } else {
      this.charts = [this._initSingle(options, this.charts[0], this.dom)];
    }
  },
  // 你们说，只好写这种代码出来，这东西还像能维护的样子？
  _checkMobileFlow: function (options) {
    if (!options) {
      // skip, don't return boolean
      return;
    } // nested, i.e. Carousel


    options = options.options ? options.options[0] : options;

    if (!options) {
      return false;
    }

    var isMobile = options.mobile == null ? _BaseUtils["default"].hasTouch() : options.mobile;
    return isMobile && options.reportType === 'flow';
  },
  isMobileFlow: function () {
    return this._isMobileFlow;
  },
  _setOrientationByBrowser: function () {
    return this._orientation = window.orientation ? LANDSCAPE : PORTRAIT;
  },
  getOrientation: function () {
    return this._orientation;
  },
  showLightBox: function (vanchart) {
    (0, _VanChartInterface.showLightBox)(vanchart);
  },
  hideLightBox: function (container, fullScreenFather) {
    (0, _VanChartInterface.hideLightBox)(container, fullScreenFather);
  },

  /**
   * return initialized or refreshed chart object
   * @param {Object} [option]
   * @param {Object} [oldChart]
   * @param {Object} [dom]
   * @returns {Object} [chart]
   * @private
   */
  _initSingle: function (option, oldChart, dom) {
    var ChartClass = (0, _vans["default"])(option.chartType);

    if (oldChart && oldChart.vanChartType === ChartClass.prototype.vanChartType) {
      //todo 这个属性看着好想删掉
      oldChart._changeDataState = true;
      oldChart.refresh(option);
      return oldChart;
    } else {
      oldChart && oldChart.remove();
      return new ChartClass(option, dom, this);
    }
  },
  setData: function (options, i) {
    if (i != null && this.charts.length > 1) {
      // update a single chart in carousel
      this.charts[i] = this.carousel.refresh(options, i);
    } else {
      this.setOptions(options);
    }
  },
  eachVanChart: function (callBack) {
    // 又是极限情况，当图表切换中一个设置超链，点击之后，第一次each结束之后就
    this.charts && this.charts.forEach(function (chart) {
      callBack.call(null, chart);
    });
  },
  refreshRestore: function () {
    this.eachVanChart(function (chart) {
      chart.refreshRestore();
    });
  },
  resize: function (options) {
    if (this.isMobileFlow()) {
      // todo
      this._setOrientationByBrowser(); // this.setOptions(options || this.options);


      options = this.options; // if (BaseUtils.isArray(options.options)) {

      this.setOptions(options); // }

      this.charts.forEach(function (chart) {
        chart.resize();
      });
    } else {
      //不要删，删了就坑了露露了
      if (options) {
        this.setOptions(options);
      } else {
        options = this.options;

        if (_BaseUtils["default"].isArray(options.options)) {
          this.setOptions(options);
        }

        this.charts.forEach(function (chart) {
          chart.resize();

          if (chart.fullScreenChart) {
            chart.fullScreenChart.resize();
          }
        });
      }
    }
  },
  getChart: function (index) {
    return this.charts[index];
  },
  clear: function () {
    clearTimeout(this._drillTimeout);
    this.carousel && this.carousel.removeCarouselInterval();

    for (var i = 0, len = this.charts.length; i < len; i++) {
      //调用两次clear会抛错
      this.charts[i] && this.charts[i].remove();
      this.charts[i] = null;
    }

    this.charts = [];

    if (this.dom) {
      var instanceKey = this.dom.getAttribute(_Constants["default"].INSTANCES_KEY);
      instanceKey && (_instances[instanceKey] = null);
    }
  },
  startLoading: function () {
    if (this.dom) {
      _LoadingUtils["default"].startLoading(this.dom, this.dom.getAttribute(_Constants["default"].INSTANCES_KEY));
    }
  },
  endLoading: function () {
    if (this.dom && !false) {
      _LoadingUtils["default"].endLoading(this.dom, this.dom.getAttribute(_Constants["default"].INSTANCES_KEY));
    }
  }
};

function initPaddingScale(scale) {
  _BaseUtils["default"].initPaddingScale(scale);
}

function acceptPoint(obj) {
  return obj && obj.vanChartType === 'point';
}
/**
 * 绑定移动端手势响应回调
 * @param cfg
 */


function bindTouchEventListener(cfg) {
  _TouchEventHelper["default"].setConfig(cfg);

  this.touchEventListenerBinded = true;
}
/*
 * 统一切换图轮播图表
 * @param direction [轮播图表切换方向:1向右，-1向左]
 */


function unifiedSwitchCarouselChart(direction) {
  var chartIndex, vanCharts;

  for (chartIndex in getInstances()) {
    vanCharts = _instances[chartIndex];
    var options = vanCharts.options;

    if (_BaseUtils["default"].isArray(options.options) && options.switchStyle && options.switchStyle.interval) {
      vanCharts.carousel.switchChartAndRestTimer(direction);
    }
  }
}

function simulatePanStart() {
  for (var chartIndex in getInstances()) {
    var vanCharts = _instances[chartIndex];

    for (var i = 0; i < vanCharts.charts.length; i++) {
      vanCharts.charts[i].handler.simulatePanStart();
    }
  }
}

function getInstances() {
  for (var instanceKey in _instances) {
    var vanCharts = _instances[instanceKey]; //根据dom判断当前实例是否还有效

    if (!vanCharts.dom || !document.body.contains(vanCharts.dom)) {
      vanCharts && vanCharts.clear && vanCharts.clear();
      delete _instances[instanceKey];
    }
  }

  return _instances;
}

var _default = {
  version: "1.0.0",
  buildTime: "2020-11-2 17:32:05",
  commit: "e8abac43a",
  instances: _instances,
  init: init,
  resetGlobalScale: initPaddingScale,
  initPaddingScale: initPaddingScale,
  acceptPoint: acceptPoint,
  bindTouchEventListener: bindTouchEventListener,
  unifiedSwitchCarouselChart: unifiedSwitchCarouselChart,
  simulatePanStart: simulatePanStart,
  showEmptyDataTip: _showEmptyDataTip["default"],
  showLightBox: _VanChartInterface.showLightBox,
  hideLightBox: _VanChartInterface.hideLightBox,
  hideFullScreenChart: _VanChartInterface.hideFullScreenChart
};
exports["default"] = _default;

/***/ }),
/* 101 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by Mitisky on 16/7/28.
 */
var loadingMap = {};

function startLoading(dom, id) {
  id = id || 'loading-div-id';
  id = id + ' loading-div-id';

  if (loadingMap[id] || document.getElementById(id)) {
    return;
  }

  var background_div = document.createElement('div');
  var inner_div = document.createElement('div'); // @CHART-1649 去掉loading动画的白色幕布

  background_div.id = id;
  background_div.style.position = 'absolute';
  background_div.style.width = '100%';
  background_div.style.height = '100%';
  background_div.style.left = 0;
  background_div.style.top = 0;
  background_div.style.zIndex = 9999;

  if (inner_div.style.animation != undefined || inner_div.style.webkitAnimation != undefined) {
    inner_div.style.left = '50%';
    inner_div.style.top = '50%';
    inner_div.className = 'loader-inner ball-scale-ripple-multiple';
    inner_div.innerHTML = '<div></div><div></div><div></div>';
  }

  background_div.appendChild(inner_div);
  dom.appendChild(background_div);
  loadingMap[id] = background_div;
}

function endLoading(dom, id) {
  id = id || 'loading-div-id';
  id = id + ' loading-div-id';

  if (loadingMap[id]) {
    dom.removeChild(loadingMap[id]);
    loadingMap[id] = null;
  } else {
    var loadingDiv = document.getElementById(id);

    if (loadingDiv) {
      dom.removeChild(loadingDiv);
    }
  }
}

var _default = {
  startLoading: startLoading,
  endLoading: endLoading
};
exports["default"] = _default;

/***/ }),
/* 102 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _PathUtils = _interopRequireDefault(__webpack_require__(67));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _Tooltip = _interopRequireDefault(__webpack_require__(68));

var _VanHammer = _interopRequireDefault(__webpack_require__(43));

var _VmlRenderer = _interopRequireDefault(__webpack_require__(69));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 16/9/27.
 */
var SWITCH_BUTTON_HEIGHT_RATIO = 3.4375;
var DEFAULT_TOOLTIP_HIDDEN_TIME = 4000;
var defaultOpt = {
  type: _Constants["default"].BUTTON,
  color: "#7f7f7f",
  interval: 1000,
  style: {
    "fontSize": '16px',
    "color": '#ffffff'
  }
};
var ICON_SIZE = 22; // button 'text...' hint

var TOOLTIP_STYLE = {
  borderWidth: 1,
  borderColor: '#000000',
  borderRadius: 2,
  backgroundColor: 'rgba(255, 255, 255, 0.5)',
  padding: 5,
  shadow: true,
  animation: true,
  style: {
    'fontSize': '12px',
    'fontFamily': 'MicrosoftYaHei, sans-serif',
    'color': '#515151'
  }
};
var isMicrosoft = _Browser["default"].ie || _Browser["default"].edge;
/*
 * first and last chart has a wrap inside 'vanchart-chart' dom.
 * move this wrap to the empty wrap, or move back,
 * to make an infinity loop

             ┌dom┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┐
             ┆╔menu(button)╦════════════════════════════════════╗┆
             ┆║menuButton  ║                                    ║┆
             ┆║            ║                                    ║┆
             ┆╚════════════╩════════════════════════════════════╝┆
┌┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┐╔container════════════════════════════════════════╦═══════════════════┅┅┅┅┅┅┅┅┅
┆(in container)  ┆║chartDoms[0]                                     ║chartDoms[1]                ║
┆frontEmptyWrap  ┆║┌firstChartWrap┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┐║[svg...](no wrap)           ║
┆{margin-left:-x}┆║┆                                               ┆║                            ║
┆                ┆║┆ [svg, divLabelDom, calculateDom...]           ┆║                            ║
┆                ┆║┆                                               ┆║                            ║
┆                ┆║┆                                               ┆║                            ║
┆                ┆║┆                                               ┆║                            ║
┆                ┆║┆                                               ┆║                            ║
┆                ┆║┆                                               ┆║                            ║
┆                ┆║└┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┘║                            ║
└┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┘╚═════════════════════════════════════════════════╩═══════════════════┅┅┅┅┅┅┅┅┅
             ┆       ┌menu(carousel)┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┐       ┆
             ┆       ┆            o o o o o o            ┆       ┆
             ┆       └┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┘       ┆
             └┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┘

*/

function isMobileCharts(charts) {
  if (charts && charts[0]) {
    return charts[0].mobile == null ? _BaseUtils["default"].hasTouch() : charts[0].mobile;
  }

  return _BaseUtils["default"].hasTouch();
}

var Carousel = function (vanCharts) {
  var type = null,
      outerDom = null,
      menu = null,
      menuButtons = [],
      arrowWrapLeft = null,
      arrowWrapRight = null,
      container = null,
      frontEmptyWrap = null,
      lastChartWrap = null,
      rearEmptyWrap = null,
      firstChartWrap = null,
      chartDoms = [],
      onIndex = 0,
      optLength = 0,
      intervalID = null,
      animationID = null,
      fontSize = 0,
      selectedColor;
  var stopAnimation = null;
  var carouselInterval;
  var evented = {
    left: null,
    right: null,
    dom: null
  };
  var mobileTooltipTimer;
  var tooltip = new _Tooltip["default"]({}, _Constants["default"].TOOLBAR_COMPONENT, {});

  function isMobile() {
    return isMobileCharts(vanCharts.options.options);
  }

  function showTooltip() {
    tooltip._show.apply(tooltip, _BaseUtils["default"].toArray(arguments));

    if (isMobile()) {
      mobileTooltipTimer && window.clearTimeout(mobileTooltipTimer);
      mobileTooltipTimer = window.setTimeout(function () {
        tooltip.immediateHide();
      }, DEFAULT_TOOLTIP_HIDDEN_TIME);
    }
  } // IE7 in IE11


  var isIE7 = /MSIE 7/.test(navigator.userAgent);

  function refresh(option, i) {
    onlyRefreshTitle(option, i);
    return setupChart(option, vanCharts.charts[i], chartDoms[i], i);
  }

  function onlyRefreshTitle(option, i) {
    var titleText = (0, _EnvUtils.getTitleText)(option);
    var btnDom = menuButtons[i];

    if (!btnDom) {
      return;
    }

    if (btnDom.mText) {
      if (btnDom.mText.textContent) {
        btnDom.mText.textContent = titleText;
      } else {
        btnDom.mText.innerText = titleText;
      }

      checkBtnTextSpace(btnDom);
    }

    btnDom._title = titleText;
  }
  /**
   * setup carousel container and button
   * return initialized or refreshed charts Array
   * @param {Object} [option]
   * @param {Array} [charts]
   * @param {Object} [dom]
   * @returns {Array} [charts]
   */


  function init(option, charts, dom) {
    if (!option || !option.switchStyle) {
      startInterval();
    }

    var options = option.options;
    /**
     * CHART-1350
     * 这里的defaultOpt最好使用深度复制的版本，如果图表有多个container的时候，
     * 并且都使用了轮播图，那么defaultOpt就会受到影响。
     */

    var switchStyle = _QueryUtils["default"].merge(_BaseUtils["default"].clone(defaultOpt), option.switchStyle, true);

    if (!(0, _EnvUtils.isSupportSVG)()) {
      if (switchStyle.style.color) {
        switchStyle.style.color = _ColorUtils["default"].colorToHex(switchStyle.style.color);
      }
    }

    var color = switchStyle.color;
    var isMobile = isMobileCharts(options);
    outerDom = dom;
    type = switchStyle.type;
    optLength = options.length;
    selectedColor = hoverColor(color);
    menu = menu || _DomUtils["default"].create('div', 'vanchart-menu', dom);
    container = container || _DomUtils["default"].create('div', 'vanchart-cc', dom);
    dom.style.overflow = 'hidden';
    tooltip.doLayout(dom);
    charts.splice(optLength).map(function (c) {
      c.remove();
    });
    menuButtons.splice(optLength).map(function (d) {
      _DomUtils["default"].remove(d);
    });
    chartDoms.splice(optLength).map(function (d) {
      _DomUtils["default"].remove(d);
    }); // addClass(container, 'van-ani');

    onIndex = onIndex >= optLength ? 0 : onIndex;

    var chartWidth = _chartWidth(),
        chartHeight = _chartHeight();

    switch (type) {
      case _Constants["default"].CAROUSEL:
      case _Constants["default"].NO_ARROW:
        menu.style.bottom = 0;
        menu.style.height = "18px";
        menu.style.width = chartWidth + "px";
        menu.mWrap = menu.mWrap || _DomUtils["default"].create('div', 'vanchart-menu-wrap', menu);
        container.style.cssText = "top:0;bottom: " + 18 + "px;left:" + -onIndex * chartWidth + "px;width:" + optLength * chartWidth + "px;height:" + chartHeight + "px;";
        var interval = carouselInterval = switchStyle.interval;

        if (!vanCharts.isMobileFlow()) {
          if (evented.dom) {
            _VanHammer["default"].off(dom, isMobile ? "touchstart" : "mouseover", removeCarouselInterval);

            _VanHammer["default"].off(dom, isMobile ? "touchend" : "mouseout", addCarouselInterval);
          } // evented.dom && evented.dom.off(dom, 'mouseover mouseout');


          evented.dom = _VanHammer["default"].on(dom, isMobile ? "touchstart" : "mouseover", removeCarouselInterval) // @MOBILE-5740,甘特图和地图touch的时候屏蔽了浏览器默认事件，导致不会向上触发mouseover，这里判断移动端时使用touchstart来清除定时器
          .on(dom, isMobile ? "touchend" : "mouseout", addCarouselInterval); //@CHART-1693 移动端点击时重置计时器
        }

        startInterval(interval);

        if (_Constants["default"].NO_ARROW === type) {
          return carousel(options, charts);
        }

        arrowWrapLeft = arrowWrapLeft || _DomUtils["default"].create('div', 'vanchart-arrow-wrap', dom);
        arrowWrapRight = arrowWrapRight || _DomUtils["default"].create('div', 'vanchart-arrow-wrap', dom);
        arrowWrapLeft.style.left = arrowWrapRight.style.right = 0; //@CHART-1948:IE兼容模式下arrowWrap继承FR-td的text-align:center后，内部按钮位置发生偏移

        arrowWrapLeft.style.textAlign = arrowWrapRight.style.textAlign = "left";

        var left = arrowWrapLeft.arrowLeft = arrowWrapLeft.arrowLeft || _DomUtils["default"].create('div', 'vanchart-arrow vanchart-arrow-left', arrowWrapLeft);

        var right = arrowWrapRight.arrowRight = arrowWrapRight.arrowRight || _DomUtils["default"].create('div', 'vanchart-arrow vanchart-arrow-right', arrowWrapRight);

        setArrow(left, color);
        setArrow(right, color);
        evented.left && evented.left.off('tap');
        evented.left = evented.left || new _VanHammer["default"](left);
        evented.left.on('tap', function (e) {
          e.preventDefault();
          startInterval(interval);
          switchChart(-1);
        });
        evented.right && evented.right.off('tap');
        evented.right = evented.right || new _VanHammer["default"](right);
        evented.right.on('tap', function (e) {
          e.preventDefault();
          startInterval(interval);
          switchChart(1);
        });
        return carousel(options, charts);

      case _Constants["default"].BUTTON:
      default:
        var startColor = gradualColor(color);
        var cssText = 'width:100%;top:0;z-index:1;' + 'background-color:' + color + ';' + 'filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=' + startColor + ', endColorstr=' + _ColorUtils["default"].colorToHex(color) + ', GradientType=0);';
        cssText += 'background-image: -webkit-gradient(linear, left top, left bottom, from(' + startColor + '), to(' + color + '));';
        cssText += 'background-image: -moz-linear-gradient(top' + startColor + ', ' + color + ');';
        cssText += 'background-image: -webkit-linear-gradient(top' + startColor + ', ' + color + ');';
        cssText += 'background-image: linear-gradient(to bottom' + startColor + ', ' + color + ');';
        menu.style.cssText = cssText;
        setTextStyle(menu, switchStyle.style);
        fontSize = (0, _EnvUtils.getTextHeight)(switchStyle.style);

        var btnH = _btnHeight();

        container.style.cssText = "top:" + btnH + "px;bottom: 0;left:" + -onIndex * chartWidth + "px;width:" + optLength * chartWidth + "px;height:" + chartHeight + "px;";
        return button(options, charts, switchStyle.style.color, hoverColor(color));
    }
  } // 顶部按钮的高度


  function _btnHeight() {
    return fontSize * SWITCH_BUTTON_HEIGHT_RATIO;
  } // 单个的宽度


  function _chartWidth() {
    return _BaseUtils["default"].getDomWidth(outerDom);
  } // 单个图表的高度


  function _chartHeight() {
    return _BaseUtils["default"].getDomHeight(outerDom) - (type === _Constants["default"].BUTTON ? _btnHeight() : 18);
  }

  function _btnWidth() {
    var width = _chartWidth() / optLength;

    if (isIE7 && document.documentMode == 7) {
      // IE11 quirks IE7 is ... different from IE7
      // IE11 document mode 5, navigator.userAgent is also MSIE 7.0, but do not need to subtract double fontSize
      width -= 2 * fontSize + 1;
    }

    return width;
  }

  function carousel(options, oldCharts) {
    // prepare two empty doms in front and end;
    // use these doms to imitate infinity loop.
    var chartWidth = _chartWidth(),
        chartHeight = _chartHeight();

    frontEmptyWrap = frontEmptyWrap || _DomUtils["default"].create('div', 'vanchart-chart', container);
    frontEmptyWrap.style.width = chartWidth + 'px';
    frontEmptyWrap.style.marginLeft = -chartWidth + 'px';
    frontEmptyWrap.style.height = chartHeight + "px";
    var cs = options.map(function (option, i) {
      setupCarouselDoms(option, i);
      return setupChart(option, oldCharts[i], chartDoms[i], i);
    });
    rearEmptyWrap = rearEmptyWrap || _DomUtils["default"].create('div', 'vanchart-chart', container);
    rearEmptyWrap.style.width = chartWidth + 'px';
    rearEmptyWrap.style.marginRight = -chartWidth + 'px';
    rearEmptyWrap.style.height = chartHeight + "px";
    return cs;
  }

  function setupCarouselDoms(option, i) {
    var titleText = (0, _EnvUtils.getTitleText)(option);
    var btnDom = menuButtons[i];

    if (!chartDoms[i]) {
      chartDoms[i] = _DomUtils["default"].create('div', 'vanchart-chart', container);
      menuButtons[i] = btnDom = _DomUtils["default"].create('div', 'vanchart-menu-dot', menu.mWrap);
      btnDom.style.background = selectedColor;

      if (!(0, _EnvUtils.isSupportSVG)()) {
        btnDom.style.background = 'none';

        var ieDom = _DomUtils["default"].create('div', 'vanchart-menu-dot-ie', btnDom);

        setDot(ieDom);
      }

      if (!i) {
        addClass(btnDom, 'van-on');
      }
    }

    chartDoms[i].style.height = _chartHeight() + "px";
    btnDom._title = titleText;
    btnDom.i = i;

    _VanHammer["default"].on(btnDom, 'mouseover', function () {
      showCarouselTooltip(btnDom);
    });

    _VanHammer["default"].on(btnDom, 'mouseout', function () {
      tooltip.immediateHide();
    });

    new _VanHammer["default"](btnDom).on('tap', function (e) {
      e.preventDefault();
      isMobile() && showCarouselTooltip(btnDom);
      prepareCarouselDom(i);
      switchBtnDomBackground(i);
      showIndex(i);
    });
  }

  function showCarouselTooltip(btnDom) {
    var tooltipDim = tooltip.calculateTooltipDivDim(TOOLTIP_STYLE, btnDom._title);
    var pos = [outerDom.clientWidth / 2 - (optLength - 1) / 2 * 16 + btnDom.i * 16 - tooltipDim.width / 2, outerDom.clientHeight - 18 - tooltipDim.height];
    pos[0] = Math.min(Math.max(pos[0], 0), outerDom.clientWidth - tooltipDim.width);
    showTooltip(pos, TOOLTIP_STYLE, btnDom._title);
  }

  function button(options, oldCharts, textColor, hoverColor) {
    return options.map(function (option, i) {
      setupButtonDoms(option, i, textColor, hoverColor);
      return setupChart(option, oldCharts[i], chartDoms[i], i);
    });
  }

  function setupButtonDoms(option, i, textColor, hoverColor) {
    var titleText = (0, _EnvUtils.getTitleText)(option);
    var btnDom = menuButtons[i];

    if (!chartDoms[i]) {
      chartDoms[i] = _DomUtils["default"].create('div', 'vanchart-chart', container);
      chartDoms[i].style.height = _chartHeight() + "px";
      menuButtons[i] = btnDom = _DomUtils["default"].create('div', 'vanchart-menu-btn', menu);
      btnDom.mIcon = _DomUtils["default"].create('span', 'vanchart-menu-icon', btnDom);
      btnDom.mText = _DomUtils["default"].create('span', 'vanchart-menu-text', btnDom);

      if (!(0, _EnvUtils.isSupportSVG)()) {
        btnDom.insertAdjacentHTML('afterBegin', '<span class="vanchart-menu-btn_before"></span>');
      }

      if (!i) {
        btnDom.style.background = hoverColor;
      }
    }

    chartDoms[i].style.height = _chartHeight() + "px";
    setIcon(btnDom.mIcon, option.chartType, textColor);

    var btnWidth = _btnWidth();

    btnDom.style.width = btnWidth + "px";

    if (btnDom.offsetTop !== 0) {
      btnWidth -= 1;
      btnDom.style.width = btnWidth + "px";
    }
    /**
     * CHART-1364
     * 解决火狐在某些版本里不能显示切换按钮标题的问题。
     * 出现这个问题的原因是我们原先的逻辑是判断浏览器是否支持textContent或者innerText属性，然后对它们进行赋值。
     * 没毛病，说实在的，但是可怕的是浏览器如果支持某一个textContent，就会给这个属性赋上空字符串，
     * 所以我们原来的判断就错开了这个属性，而高版本的浏览器支持更多的属性，所以执行else也不会出现问题，
     * 但是低版本就可能存在问题。
     */


    btnDom.mText.textContent = titleText;
    btnDom.mText.innerText = titleText;
    btnDom._title = titleText;
    btnDom.i = i;
    checkBtnTextSpace(btnDom);

    _VanHammer["default"].on(btnDom, 'mouseover', function () {
      btnDom.style.background = hoverColor;
      showButtonTooltip(btnDom);
    });

    _VanHammer["default"].on(btnDom, 'mouseout', function () {
      onIndex !== i && (btnDom.style.background = '');
      tooltip.immediateHide();
    });

    new _VanHammer["default"](btnDom).on('tap', function (e) {
      e.preventDefault();
      isMobile() && showButtonTooltip(btnDom);
      switchBtnDomBackground(i);
      showIndex(i);
    });
  } // 暂时保留: 现在的设计是用的同一个颜色, 只是透明度不一样


  function switchBtnDomBackground(index) {
    if (menuButtons[index]) {
      // @CHART-10854&CHART-11773,  按钮时需要移除背景色, 轮播时保留selectedColor
      menuButtons[onIndex].style.background = type === 'button' ? '' : selectedColor;
      menuButtons[index].style.background = selectedColor;
    }
  }
  /**
   * @mango CHART-1809 && CHART-1623
   * IE下scrollWidth计算的不准确导致bug
   * 这里使用文本fullTextWidth和scrollWidth去比较
   * @param btnDom
   * @returns {boolean}
   */


  function isTextEllipsisInIE(btnDom) {
    var title = btnDom._title,
        textDom = btnDom.mText,
        actualStyle = _BaseUtils["default"].getComputedStyle(textDom, 'font-size font-family');

    var fulltextWidth = _BaseUtils["default"].getTextDimension(title, actualStyle, true).width;

    return fulltextWidth > textDom.scrollWidth;
  }

  function showButtonTooltip(btnDom) {
    var ellipsis = false;

    if ((0, _EnvUtils.isSupportSVG)() && !isMicrosoft) {
      ellipsis = btnDom.scrollWidth > btnDom.clientWidth;
    } else {
      ellipsis = isTextEllipsisInIE(btnDom);
    }

    if (ellipsis || btnDom.mText.innerHTML === '') {
      var tooltipDim = tooltip.calculateTooltipDivDim(TOOLTIP_STYLE, btnDom._title);
      var pos = [outerDom.clientWidth * (btnDom.i + 0.5) / optLength - tooltipDim.width / 2, btnDom.offsetHeight];
      pos[0] = Math.min(Math.max(pos[0], 0), outerDom.clientWidth - tooltipDim.width);
      showTooltip(pos, TOOLTIP_STYLE, btnDom._title);
    }
  }

  function setupChart(option, oldChart, chartDom, i) {
    chartDom.style.width = _chartWidth() + "px";
    chartDom.style.overflow = 'hidden'; // CHART-1077
    // if (!isSupportSVG() || chartDom.offsetLeft < outerDom.clientWidth * i) {
    //     var det = outerDom.clientWidth * i - chartDom.offsetLeft;
    //     chartDom.style.width = outerDom.clientWidth + det + 'px';
    // }

    var c,
        targetDom = chartDom;

    if (i === optLength - 1) {
      if (lastChartWrap) {
        lastChartWrap.style.cssText = "width:" + _chartWidth() + "px;height:" + _chartHeight() + "px;";
      } else {
        lastChartWrap = newWrap(chartDom);
      }

      targetDom = lastChartWrap;
    } else if (i === 0) {
      if (firstChartWrap) {
        firstChartWrap.style.cssText = "width:" + _chartWidth() + "px;height:" + _chartHeight() + "px;";
      } else {
        firstChartWrap = newWrap(chartDom);
      }

      targetDom = firstChartWrap;
    }

    targetDom.style.width = _chartWidth() + "px";
    targetDom.style.height = _chartHeight() + "px";
    c = vanCharts._initSingle(option, oldChart, targetDom);

    if (i !== onIndex) {
      c.set({
        enable: false
      });
    }

    return c;
  }

  function newWrap(chartDom) {
    var wrapDom = _DomUtils["default"].create('div', 'vanchart-chart-wrap', chartDom);

    wrapDom.style.cssText = "width:" + _chartWidth() + "px;height:" + _chartHeight() + "px;";
    return wrapDom;
  }

  function recoverCarouselDom() {
    chartDoms[0].appendChild(firstChartWrap);
    chartDoms[optLength - 1].appendChild(lastChartWrap);
  }

  function prepareCarouselDom(index, direction) {
    var tmp; // last -> first

    if (direction === _Constants["default"].RIGHT && onIndex === optLength - 1 && index === 0) {
      chartDoms[0].appendChild(firstChartWrap);
      frontEmptyWrap && frontEmptyWrap.appendChild(lastChartWrap); // container.style.left = "100%";

      container.style.left = _chartWidth() + "px";
      tmp = container.clientWidth; // update css
    } else // first -> last
      if (direction === _Constants["default"].LEFT && onIndex === 0 && index === optLength - 1) {
        chartDoms[optLength - 1].appendChild(lastChartWrap);
        rearEmptyWrap && rearEmptyWrap.appendChild(firstChartWrap); // container.style.left = -optLength * 100 + '%';

        container.style.left = -optLength * _chartWidth() + 'px';
        tmp = container.clientWidth;
      } else {
        // recover
        recoverCarouselDom();
      }
  }

  function showIndex(index) {
    removeClass(menuButtons[onIndex], 'van-on');
    vanCharts.charts[onIndex] && vanCharts.charts[onIndex].set({
      enable: false
    });
    addClass(menuButtons[index], 'van-on');
    vanCharts.charts[index] && vanCharts.charts[index].set({
      enable: true
    });

    var chartWidth = _chartWidth();

    var easing = _BezierEasing["default"].css['swing'];
    animation(container, 'left', -index * chartWidth + 'px', 500, easing);
    onIndex = index;
  }

  function animation(dom, attr, endValue, duration, easing) {
    _BaseUtils["default"].cancelAnimFrame(animationID);

    var from = parseFloat(dom.style[attr]) || 0,
        tmp = endValue.match(/([\d.E-]+)(.*)/i),
        to = +tmp[1],
        unit = tmp[2],
        here = from,
        now = 0;
    var startTime = +new Date();
    move(); // 0 -> duration, from -> to;

    function move() {
      now = +new Date() - startTime;

      if (now >= duration) {
        here = to;
        dom.style[attr] = here + unit;
        stopAnimation = null;
      } else {
        here = from + (to - from) * easing(now / duration);
        dom.style[attr] = here + unit;
        animationID = _BaseUtils["default"].requestAnimFrame(move);
      }
    } // 充满了内存泄露的可能……………………


    stopAnimation = function () {
      _BaseUtils["default"].cancelAnimationFrame(animationID);

      dom.style[attr] = to + unit;
    };
  }

  function removeCarouselInterval() {
    startInterval();
  }

  function addCarouselInterval() {
    startInterval(carouselInterval);
  } // start interval or cancel


  function startInterval(interval) {
    _BaseUtils["default"].clearInterval(intervalID);

    if (!vanCharts.shouldCarouselRun()) {
      return;
    }

    if (interval) {
      intervalID = _BaseUtils["default"].setInterval(function () {
        if (!document.body.contains(outerDom)) {
          _BaseUtils["default"].clearInterval(intervalID);

          return;
        }

        switchChart(1);
      }, interval);
    }
  }
  /**
   * 切换图表并重置计时器
   * @param direction 切换方向
   */


  function switchChartAndRestTimer(direction) {
    startInterval();
    switchChart(direction);
    startInterval(carouselInterval);
  }
  /**
   * 切换图表
   * @param direction 切换方向
   */


  function switchChart(direction) {
    direction = direction || 1;
    var moveDirection = direction === 1 ? _Constants["default"].RIGHT : _Constants["default"].LEFT;
    var nextIndex = onIndex + direction,
        index = (nextIndex < 0 ? nextIndex + optLength : nextIndex) % optLength;
    prepareCarouselDom(index, moveDirection);
    switchBtnDomBackground(index);
    showIndex(index);
  }
  /**
   * 展示index对应图表并重置计时器
   * @param index 图表下标
   */


  function showIndexChartAndRestTimer(index) {
    index = Math.abs(index) % optLength || 0;
    startInterval();
    prepareCarouselDom(index, index > onIndex ? _Constants["default"].RIGHT : _Constants["default"].LEFT);
    switchBtnDomBackground(index);
    showIndex(index);
    startInterval(carouselInterval);
  } // width < padding * 2 + icon + 1em
  // remove padding to prevent wrap


  function checkBtnTextSpace(btnDom) {
    if (_btnWidth() <= 22 + 3 * fontSize) {
      btnDom.mText.innerHTML = '';
      btnDom.mText.style.marginLeft = 0;

      if (!isIE7) {
        btnDom.style.padding = 0;
      }
    }
  }

  var panDomOffset = 0,
      panningIndex = -1,
      panToIndex = -1,
      lastDelta = 0;

  function _getDirectionByDelta(delta) {
    // deltaX < 0 -> next (right side) chart
    if (delta < 0) {
      return 1;
    } else if (delta > 0) {
      return -1;
    } else {
      return 0;
    }
  } // function _updatePanToIndex (direction) {
  //     var nextIndex = (panningIndex + direction);
  //     panToIndex = Math.max(0, Math.min(nextIndex, optLength - 1));
  // }


  var MIN_OFFSET = 80;

  function _updatePanToIndex() {
    var offset = panDomOffset - panningIndex * -_chartWidth();

    if (Math.abs(offset) > MIN_OFFSET) {
      panToIndex = panningIndex + _getDirectionByDelta(offset);
      panToIndex = Math.max(0, Math.min(panToIndex, optLength - 1));
    } else {
      // stay at this chart
      panToIndex = panningIndex;
    }
  }

  function panstart(e) {
    if (container) {
      panningIndex = e.chartIndex;
      panDomOffset = parseFloat(container.style.left);
      lastDelta = e.srcEvent.deltaX;
    }
  }

  function panmove(e) {
    if (panningIndex < 0) {
      return;
    }

    var delta = e.srcEvent.deltaX;

    var chartWidth = _chartWidth();

    var minOffset = -chartWidth * (optLength - 1);
    panDomOffset += delta;
    panDomOffset = Math.max(minOffset, Math.min(panDomOffset, 0));
    container.style.left = panDomOffset + 'px';

    _updatePanToIndex(panDomOffset);

    if (delta) {
      lastDelta = delta;
    }
  }

  function panend(e) {
    if (panningIndex < 0 || panToIndex < 0) {
      return;
    } // in case the last movement is the different direction to target chart;


    if (panToIndex - panningIndex !== _getDirectionByDelta(lastDelta)) {
      panToIndex = panningIndex;
    }

    switchBtnDomBackground(panToIndex);
    showIndex(panToIndex);
    panningIndex = panToIndex = -1;
  }

  return {
    init: init,
    refresh: refresh,
    onlyRefreshTitle: onlyRefreshTitle,
    switchChartAndRestTimer: switchChartAndRestTimer,
    showIndexChartAndRestTimer: showIndexChartAndRestTimer,
    getIndex: function () {
      return onIndex;
    },
    stop: function () {
      stopAnimation && stopAnimation();
      removeCarouselInterval();
      recoverCarouselDom();
    },
    resume: function () {
      addCarouselInterval();
    },
    panstart: panstart,
    panmove: panmove,
    panend: panend,
    removeCarouselInterval: removeCarouselInterval
  };
};

function setTextStyle(dom, styleObj) {
  Object.keys(styleObj).map(function (name) {
    if (typeof styleObj[name] !== 'string') {
      return;
    }

    dom.style[name] = styleObj[name];
  });
}

function gradualColor(color) {
  var rgba = _ColorUtils["default"].getRGBAColorArray(color);

  var hsb = _ColorUtils["default"].rgb2hsb(rgba[0], rgba[1], rgba[2]);

  return _ColorUtils["default"].toColor(_ColorUtils["default"].hsb2rgb(hsb[0], hsb[1] * 0.85, (hsb[2] + 0.15) * 100 / 115), 'hex');
}

function hoverColor(color) {
  var rgba = _ColorUtils["default"].getRGBAColorArray(color);

  var hsb = _ColorUtils["default"].rgb2hsb(rgba[0], rgba[1], rgba[2]);

  return _ColorUtils["default"].toColor(_ColorUtils["default"].hsb2rgb(hsb[0], hsb[1] * 0.75, (hsb[2] + 0.25) * 100 / 125), 'hex');
}

function addClass(ele, name) {
  var names = ele.className.split(' ');

  if (names.indexOf(name) === -1) {
    ele.className += ' ' + name;
  }
}

function removeClass(ele, name) {
  var names = ele.className.split(' ');
  var i = names.indexOf(name);

  if (i !== -1) {
    names.splice(i, i);
    ele.className = names.join(' ');
  }
}

function setIcon(dom, type, color) {
  if ((0, _EnvUtils.isSupportSVG)()) {
    var style = ' width=' + ICON_SIZE + ' height=' + ICON_SIZE;
    dom.innerHTML = '<svg ' + style + '><g>' + icon[type] + '</g></svg>';
    dom.querySelector('g').setAttribute('fill', color);

    if (type === _Constants["default"].RADAR_CHART) {
      dom.querySelector('g').setAttribute('stroke', color);
    }
  } else {
    var _style = ' width=' + ICON_SIZE + ' height=' + ICON_SIZE;

    dom.innerHTML = '<img ' + _style + ' src="data:image/png;base64,' + png[type] + '">';
  }
}

var icon = {};
icon[_Constants["default"].PIE_CHART] = '<path d="M12,0.266v10.041l9.519-1.314C20.642,4.339,17,0.742,12,0.266z"/> <path d="M21.744,10.061l-7.309,1.009L11,11.511V11v-0.545V9.651V0.208C5.04,0.208,0.208,5.04,0.208,11 c0,5.96,4.832,10.792,10.792,10.792c0,0,1.214,0,1.602-0.12l0.006-0.012c5.195-0.778,9.183-5.247,9.183-10.659 C21.792,10.683,21.771,10.371,21.744,10.061z"/>';
icon[_Constants["default"].BAR_CHART] = '<rect x="0.937" y="6.794" width="8.112" height="2.704"/> <rect x="0.938" y="12.502" width="13.52" height="2.704"/> <rect x="0.938" y="18.211" width="17.125" height="2.704"/> <rect x="0.937" y="1.086" width="6.309" height="2.704"/>';
icon[_Constants["default"].COLUMN_CHART] = '<rect x="0.625" y="11.943" width="2.83" height="9.432"/> <rect x="6.284" y="8.17" width="2.83" height="13.205"/> <rect x="12.886" y="4.398" width="2.83" height="16.977"/> <rect x="18.545" y="0.625" width="2.83" height="20.75"/>';
icon[_Constants["default"].LINE_CHART] = '<path d="M20.527,2.742c-0.813,0-1.473,0.659-1.473,1.473c0,0.308,0.095,0.593,0.256,0.83l-4.155,7.48 c-0.005,0-0.01-0.002-0.016-0.002c-0.296,0-0.571,0.089-0.802,0.24l-5.74-3.399c0.005-0.05,0.015-0.098,0.015-0.149 c0-0.814-0.66-1.473-1.473-1.473S5.667,8.402,5.667,9.215c0,0.154,0.03,0.299,0.074,0.439L1.987,13.84 c-0.161-0.06-0.333-0.097-0.514-0.097C0.66,13.742,0,14.402,0,15.215s0.66,1.473,1.473,1.473s1.473-0.659,1.473-1.473 c0-0.265-0.076-0.511-0.198-0.726l3.614-4.028c0.227,0.142,0.492,0.227,0.778,0.227c0.399,0,0.76-0.16,1.025-0.418l5.572,3.299 c-0.042,0.136-0.07,0.277-0.07,0.427c0,0.814,0.66,1.473,1.473,1.473s1.473-0.659,1.473-1.473c0-0.445-0.202-0.84-0.514-1.11 l4.033-7.259c0.126,0.035,0.257,0.06,0.395,0.06C21.34,5.688,22,5.029,22,4.215S21.34,2.742,20.527,2.742z"/>';
icon[_Constants["default"].AREA_CHART] = '<path d="M15.255,15.935c0.045,0.075,0.079,0.159,0.079,0.253c0,0.276-0.224,0.5-0.5,0.5s-0.5-0.224-0.5-0.5 c0-0.106,0.041-0.199,0.097-0.28l-7.79-8.953C6.571,6.993,6.493,7.021,6.406,7.021c-0.106,0-0.199-0.04-0.28-0.097L1,12.315V21h21 V9.832L15.255,15.935z"/> <path d="M6.642,6.955C6.797,6.87,6.906,6.711,6.906,6.521c0-0.276-0.224-0.5-0.5-0.5s-0.5,0.224-0.5,0.5 c0,0.17,0.09,0.313,0.22,0.403C6.208,6.981,6.3,7.021,6.406,7.021C6.493,7.021,6.571,6.993,6.642,6.955z"/> <path d="M14.834,16.688c0.276,0,0.5-0.224,0.5-0.5c0-0.094-0.033-0.178-0.079-0.253c-0.087-0.145-0.24-0.247-0.421-0.247 c-0.17,0-0.312,0.09-0.403,0.22c-0.057,0.081-0.097,0.174-0.097,0.28C14.334,16.464,14.558,16.688,14.834,16.688z"/> <polygon points="1,12.315 1,0 0,0 0,22 0.088,22 22,22 22,21 1,21 "/>';
icon[_Constants["default"].GAUGE_CHART] = '<path d="M11,1.149c-6.042,0-10.958,4.916-10.958,10.958c0,2.103,0.597,4.146,1.729,5.908l1.845-1.184 c-0.904-1.408-1.381-3.042-1.381-4.724c0-4.834,3.933-8.766,8.766-8.766s8.766,3.933,8.766,8.766c0,1.682-0.477,3.315-1.38,4.723 l1.845,1.184c1.13-1.762,1.728-3.804,1.728-5.907C21.958,6.065,17.042,1.149,11,1.149z"/> <path d="M11.49,12.11L11,4.273l-0.49,7.837c-0.236,0.16-0.4,0.417-0.4,0.724c0,0.492,0.398,0.89,0.89,0.89s0.89-0.399,0.89-0.89 C11.89,12.527,11.726,12.27,11.49,12.11z"/>';
icon[_Constants["default"].RADAR_CHART] = '<polygon fill="none" stroke-miterlimit="10" points="6.828,20.531 1.417,13.746 3.348,5.286 11.167,1.521 18.985,5.286 20.916,13.746 15.506,20.531 "/> <polyline fill="none" stroke-miterlimit="10" points="3.38,5.38 11.042,10.885 15.506,20.531 "/> <polyline fill="none" stroke-miterlimit="10" points="18.985,5.286 11.057,10.87 1.417,13.746 "/> <line fill="none" stroke-miterlimit="10" x1="11.026" y1="10.885" x2="20.916" y2="13.746"/> <line fill="none" stroke-miterlimit="10" x1="11.167" y1="1.521" x2="11.042" y2="10.901"/> <line fill="none" stroke-miterlimit="10" x1="11.042" y1="10.885" x2="6.835" y2="20.539"/>';
icon[_Constants["default"].SCATTER_CHART] = '<circle cx="14.625" cy="12.158" r="0.916"/> <circle cx="14.625" cy="7.383" r="1.291"/> <circle cx="7.958" cy="12.699" r="0.916"/> <circle cx="21.293" cy="3.702" r="0.707"/> <circle cx="2.041" cy="16.965" r="2.041"/>';
icon[_Constants["default"].BUBBLE_CHART] = icon[_Constants["default"].FORCE_BUBBLE_CHART] = '<circle cx="3.521" cy="14.938" r="3.521"/> <circle cx="11.927" cy="5.5" r="1.958"/> <circle cx="20.667" cy="10.219" r="1.333"/>';
icon[''] = icon[_Constants["default"].MULTI_CHARTS] = '<rect x="2" y="12" width="3" height="9"/> <rect x="7" y="8" width="3" height="13"/> <rect x="12" y="9" width="3" height="12"/> <rect x="17" y="5" width="3" height="16"/> <path d="M20.172,0.911c-0.507,0-0.917,0.411-0.917,0.917c0,0.056,0.022,0.105,0.032,0.158l-4.522,3.532 c-0.156-0.121-0.342-0.205-0.554-0.205c-0.404,0-0.737,0.266-0.859,0.629L8.582,5.56C8.425,5.278,8.135,5.079,7.79,5.079 c-0.507,0-0.917,0.411-0.917,0.917c0,0.053,0.021,0.1,0.031,0.151L2.395,9.78C2.238,9.654,2.046,9.567,1.828,9.567 c-0.506,0-0.917,0.411-0.917,0.917s0.411,0.917,0.917,0.917c0.507,0,0.917-0.411,0.917-0.917c0-0.121-0.026-0.236-0.069-0.342 l4.42-3.563c0.168,0.2,0.411,0.335,0.693,0.335c0.495,0,0.893-0.394,0.91-0.884l4.627,0.372c0.082,0.422,0.437,0.747,0.883,0.747 c0.507,0,0.917-0.411,0.917-0.917c0-0.127-0.026-0.248-0.073-0.358l4.428-3.457c0.168,0.197,0.41,0.329,0.689,0.329 c0.506,0,0.917-0.411,0.917-0.917C21.089,1.322,20.678,0.911,20.172,0.911z"/>';
icon[_Constants["default"].MULTIPIE_CHART] = '<path d="M5.267,10.754c0,0.009-0.002,0.018-0.002,0.028c0,2.918,2.276,5.356,5.194,5.356l0.017-0.002 C7.585,16.12,5.291,13.643,5.267,10.754z"/> <path d="M10.499,18.487l0.003,0c2.997,0,5.568-1.763,6.804-4.219C16.071,16.724,13.5,18.486,10.499,18.487z"/> <path d="M2.916,10.745c0,0.012-0.002,0.025-0.002,0.037c0,4.215,3.329,7.705,7.544,7.705 c0.008,0,0.015-0.001,0.022-0.001C6.288,18.474,2.935,14.937,2.916,10.745z"/> <path fill-opacity = "0.2" d="M18.856,10h2.233C20.546,5,16,0.396,11,0.212v2.213C15,2.604,18.326,6,18.856,10z"/> <path fill-opacity = "0.6" d="M16.104,10h2.752C18.326,6,15,2.604,11,2.424v2.724C13,5.318,15.603,8,16.104,10z"/> <path d="M11,5.149V10h5.104C15.603,8,13,5.318,11,5.149z"/> <path fill-opacity = "0.2" d="M17.752,13.176c-0.119,0.376-0.269,0.741-0.445,1.092c-1.236,2.456-3.807,4.219-6.804,4.219l-0.003,0 l-0.004,0c0,0-0.007-0.001-0.015-0.001c-0.008,0-0.015,0.001-0.022,0.001c-4.215,0-7.544-3.49-7.544-7.705 c0-0.012,0.002-0.025,0.002-0.037c0-0.012-0.002-0.024-0.002-0.036C2.914,6.708,6,3.432,10,3.109V1.2 c-5,0.329-8.994,4.454-8.994,9.509c0,5.269,4.227,9.686,9.496,9.686c5.27,0,9.497-4.395,9.497-9.395h-1.908 C18.091,11.75,17.972,12.482,17.752,13.176z"/> <path fill-opacity = "0.6" d="M2.914,10.709c0,0.012,0.002,0.024,0.002,0.036c0.019,4.192,3.372,7.729,7.564,7.741 c0.007,0,0.015,0.001,0.015,0.001l0.004,0c3-0.001,5.572-1.764,6.808-4.219c0.177-0.351,0.326-0.716,0.445-1.092 c0.22-0.694,0.339-1.426,0.339-2.176h-2.349c0,3-2.321,5.138-5.239,5.138c-0.009,0-0.019-0.001-0.028-0.002l-0.017,0.002 c-2.917,0-5.194-2.438-5.194-5.356c0-0.009,0.002-0.018,0.002-0.028c0-0.015-0.002-0.03-0.002-0.045C5.264,8.007,7,5.783,10,5.468 V3.109C6,3.432,2.914,6.708,2.914,10.709z"/> <path d="M5.264,10.709c0,0.015,0.002,0.03,0.002,0.045c0.024,2.889,2.319,5.366,5.208,5.382c0.009,0,0.019,0.002,0.028,0.002 c2.918,0,5.239-2.138,5.239-5.138H10V5.468C7,5.783,5.264,8.007,5.264,10.709z"/>';
icon[_Constants["default"].TREEMAP_CHART] = '<polygon fill-opacity = "0.6" points="11,0 11,10 11,13 11,14 11,16 11,22 22,22 22,16 22,14 22,13 22,10 22,0 "/> <rect y="14" fill-opacity = "0.2" width="10" height="8"/> <rect width="10" height="13"/>';
icon[_Constants["default"].FUNNEL_CHART] = '<polygon points="20.06,6.533 1.989,6.533 1.082,1.656 20.966,1.656 "/> <polygon points="17.949,14.412 4.005,14.412 2.051,8.409 19.888,8.409 "/> <polygon points="14.963,20.79 6.944,20.79 4.271,15.912 17.933,15.912 "/>';
icon[_Constants["default"].GANTT_CHART] = '<path d="M8.38.95V4.42h-7A.48.48,0,0,1,.83,4V1.37a.47.47,0,0,1,.5-.43ZM2.67,6.48a.47.47,0,0,0-.5.43V9.53a.47.47,0,0,0,.5.43H13.12V6.48ZM20.49,12H8.58a.47.47,0,0,0-.5.43v2.62a.47.47,0,0,0,.5.43H20.49a.47.47,0,0,0,.5-.43V12.43A.48.48,0,0,0,20.49,12ZM4,17.53a.47.47,0,0,0-.5.43v2.63A.47.47,0,0,0,4,21H14.44V17.53Z"/> <path fill-opacity="0.5" d="M11.58,1.37V4a.48.48,0,0,1-.5.43H8.38V.95h2.7A.47.47,0,0,1,11.58,1.37Zm3,5.1H13.12V10h1.46a.47.47,0,0,0,.5-.43V6.9A.48.48,0,0,0,14.58,6.48Zm4.49,11.06H14.44V21h4.63c.32,0,.6-.19.6-.43V18C19.67,17.73,19.39,17.53,19.07,17.53Z"/>';
icon[_Constants["default"].STRUCTURE_CHART] = '<path d="M20.4,18c-1,1-2.5,1-3.5,0.1c-0.7-0.6-0.9-1.6-0.7-2.4l-4-1.7c-0.1,0.1-0.2,0.2-0.3,0.3c-1.4,1.5-3.6,1.6-5.2,0.4l-1,1  c0.7,1,0.6,2.3-0.2,3.2c-1,1-2.5,1-3.5,0.1c-1-1-1-2.5-0.1-3.5c0.9-0.9,2.4-1,3.4-0.2l1-1c-1.3-1.5-1.3-3.8,0.1-5.3  c0,0,0.1-0.1,0.1-0.1l-1.5-3C4,6.3,2.8,6.2,2,5.4c-1-1-1-2.5-0.1-3.5c1-1,2.5-1,3.5-0.1c1,1,1,2.5,0.1,3.5c0,0,0,0,0,0l1.5,3  c1.4-0.9,3.4-0.8,4.7,0.4l2.1-2.1c-0.6-0.9-0.5-2.2,0.3-3.1c1-1,2.5-1,3.5-0.1s1,2.5,0.1,3.5c-0.9,1-2.4,1-3.4,0.1l-2,2  c0.9,1.2,1.1,2.8,0.4,4.2l3.8,1.6c0.1-0.2,0.2-0.3,0.4-0.5c1-1,2.5-1,3.5-0.1C21.3,15.4,21.4,17,20.4,18z"/>';
icon[_Constants["default"].WORD_CLOUD_CHART] = '<path d="M17.61,12.53H15.85v5h1.86a2.5,2.5,0,0,0,1.83-.62A2.51,2.51,0,0,0,20.16,15,2.31,2.31,0,0,0,17.61,12.53Zm-.53,1.12h.49c.88,0,1.29.45,1.31,1.37s-.4,1.43-1.3,1.43h-.5Zm-8-4.52L5,19.47H7.2l1-2.62h4l1,2.62h2.23L11.25,9.13Zm1.08,2.35,0,.07,0,.12s.16.39,1.33,3.42H8.8c1.09-2.84,1.3-3.37,1.34-3.45Zm-5,1.21c-2-.11-3.08-1.26-3.19-3.42C2.05,7,3.13,5.87,5.15,5.74A2.88,2.88,0,0,1,8,7.77l.1.29-1.5.39-.08-.26A1.37,1.37,0,0,0,5.16,7.11c-.63,0-1.52.32-1.62,2.14.07,1.8,1,2.08,1.63,2.14A1.43,1.43,0,0,0,6.63,10l.06-.3,1.48.43-.06.25A2.72,2.72,0,0,1,5.14,12.7ZM19.47,8.62v0A2.22,2.22,0,0,0,18,6.66a2.06,2.06,0,0,0,1.07-1.89c-.08-.95-.66-2.1-3-2.17H12.43v8.56h3.91C18.93,11.16,19.47,9.78,19.47,8.62Zm-1.89-.08c0,.54-.16,1.17-1.44,1.17H14.2V7.53h1.86C17.37,7.56,17.56,8.13,17.59,8.54ZM15.91,6H14.2V4.1h1.71c1.19,0,1.35.51,1.36.88S17.09,6,15.91,6Z"/>';
icon[_Constants["default"].AREA_MAP] = icon[_Constants["default"].HEAT_MAP] = icon[_Constants["default"].POINT_MAP] = icon[_Constants["default"].LINE_MAP] = '<path d="M18.7806255,3.22317926 C16.7894744,1.23303357 14.0408382,1.77635684e-15 11.002772,1.77635684e-15 C7.96457927,1.77635684e-15 5.21591781,1.23303357 3.22213387,3.22320456 C1.22822336,5.22390154 0,7.97120995 0,10.9997343 C0,14.0393413 1.22824867,16.7866244 3.22213387,18.7767954 C5.21591781,20.7722294 7.96457927,22 11.002772,22 C14.0408382,22 16.7894744,20.7722547 18.7806002,18.7767954 C20.768992,16.7866244 22,14.0393413 22,10.9997343 C22,7.97120995 20.7690173,5.22390154 18.7806255,3.22317926 Z M17.5822236,4.42349623 C19.1539758,5.9973846 20.1685632,8.12818888 20.3010383,10.4916276 L17.3393484,10.4916276 C17.2704091,10.3953995 17.1827363,10.3140783 17.0815878,10.2525409 C17.0079456,8.3922495 16.6604422,6.66679701 16.1310735,5.18688346 C16.1762889,5.10774499 16.2087446,5.02197908 16.2272464,4.93274155 C16.6158619,4.71705999 16.9948575,4.47837813 17.3549426,4.20191911 C17.4326536,4.27375254 17.5084406,4.34763767 17.5822236,4.42349623 L17.5822236,4.42349623 Z M15.207039,16.3674067 C15.1247639,16.3908633 15.0463976,16.4263142 14.9744672,16.472616 C14.8906735,16.4402536 14.807943,16.4078154 14.7253645,16.3756048 C13.7899887,16.0263242 12.8016786,15.8066448 11.7690161,15.736151 C11.7019526,15.6279661 11.6121513,15.5356534 11.5058381,15.4656128 L11.5058381,11.7298989 C11.5993512,11.668228 11.680215,11.5892677 11.7440805,11.4972644 L15.909691,11.4972644 C15.9559801,11.5640481 16.0113056,11.6240979 16.0740887,11.6757002 C16.0025476,13.4058843 15.6946627,15.0101867 15.207039,16.3674067 L15.207039,16.3674067 Z M10.2838423,15.7327098 C9.23675002,15.7996359 8.23560508,16.0210359 7.29367267,16.3756048 C7.22272181,16.4017676 7.15185542,16.4281586 7.08107461,16.4547775 C6.99170462,16.4020197 6.89358911,16.365717 6.79139141,16.3475946 C6.31065349,15.0024693 6.0064393,13.4160813 5.937531,11.70576 C6.01648853,11.6480648 6.08525375,11.5775974 6.14099022,11.4972644 L10.3066007,11.4972644 C10.3598188,11.5740026 10.424927,11.6417779 10.4994782,11.6980426 L10.4994782,15.4974691 C10.4138158,15.5620472 10.3407283,15.6417795 10.2838423,15.7327098 L10.2838423,15.7327098 Z M6.81414988,5.58816148 C6.87381267,5.56918437 6.93124902,5.54381861 6.98545865,5.51250594 C7.08651741,5.55283869 7.18610787,5.59129904 7.28020492,5.62963287 C8.23585823,5.98437894 9.23905371,6.21076361 10.2875636,6.27343878 C10.3456858,6.35502143 10.4173402,6.42606714 10.4994275,6.48350311 L10.4994275,10.3019321 C10.4285252,10.3554588 10.3661488,10.4194169 10.3144232,10.4916276 L6.13306653,10.4916276 C6.07865707,10.415712 6.01247802,10.348959 5.93702469,10.2938858 C6.00616083,8.55317568 6.31918475,6.94945524 6.81414988,5.58816148 L6.81414988,5.58816148 Z M11.7122085,6.27376772 C12.7654524,6.2115986 13.7727996,5.98506211 14.7253645,5.62963287 C14.8075356,5.59748797 14.8895915,5.5650495 14.9715306,5.53231808 C15.0435607,5.56945381 15.1204388,5.5963249 15.1999254,5.61214859 C15.6927388,6.97614976 16.003459,8.58181852 16.0745444,10.3239456 C16.0151032,10.3727169 15.962333,10.4290851 15.9175894,10.4916023 L11.7362075,10.4916023 C11.6736122,10.4042982 11.5955313,10.3292059 11.5058381,10.2700505 L11.5058381,6.47975829 C11.5856328,6.42306969 11.6553843,6.35344655 11.7122085,6.27376772 L11.7122085,6.27376772 Z M16.5486244,3.53131746 C16.3147615,3.70216236 16.0714053,3.86141855 15.8172395,4.00374712 C15.7405441,3.95815657 15.6572741,3.92465845 15.5703645,3.90443341 C15.5154556,3.79535279 15.4587746,3.68753731 15.3962711,3.57984834 C15.1634967,3.15830273 14.9173812,2.78498436 14.6630635,2.43886657 C15.3366282,2.72564916 15.972473,3.09866389 16.5486244,3.53131746 L16.5486244,3.53131746 Z M12.5394372,1.82236244 C13.2779104,2.27664995 13.9570698,3.060659 14.5089691,4.07211545 C14.549347,4.14761917 14.5896743,4.22066852 14.6288371,4.29361666 C14.5645515,4.39658406 14.5225868,4.51188293 14.5056528,4.63206769 C14.458775,4.65051317 14.412058,4.66936451 14.3655072,4.68861958 C13.5361267,4.99093813 12.6457869,5.19439841 11.7118541,5.26028705 C11.6550996,5.1808204 11.5854807,5.11137258 11.5058634,5.05480254 L11.5058634,1.70895503 C11.854911,1.71948102 12.2039586,1.76829023 12.5394372,1.82236244 Z M9.46613213,1.82236244 C9.80158543,1.77909455 10.1505065,1.71948102 10.4994275,1.70895503 L10.4994275,5.05105772 C10.4177438,5.10820019 10.3463899,5.17882589 10.2884243,5.25990751 C9.35606112,5.19363932 8.4648353,4.99040677 7.63451813,4.68861958 C7.5599392,4.6568898 7.48371477,4.62698182 7.40918647,4.59679551 C7.39512779,4.51963623 7.37066104,4.44473996 7.33645556,4.37415566 C7.38855448,4.27405755 7.44136224,4.1753258 7.49662558,4.07209014 C8.05379045,3.0606843 8.73289921,2.27664995 9.46613213,1.82236244 L9.46613213,1.82236244 Z M7.34774619,2.43889187 C7.08261885,2.78500967 6.83652863,3.15832803 6.60648832,3.57987365 C6.5487947,3.6821984 6.49507559,3.78470028 6.44168559,3.88823958 C6.33845101,3.90088941 6.2383319,3.9319834 6.14610391,3.98003835 C5.9120891,3.84380776 5.68139059,3.6927497 5.45403371,3.53134277 C6.03836191,3.09866389 6.66863743,2.72564916 7.34774619,2.43889187 Z M4.42334579,4.42349623 C4.48825427,4.34806841 4.58009825,4.27208393 4.65060141,4.20191911 C4.98051066,4.45530193 5.32657107,4.67662602 5.6840487,4.87791026 C5.70423308,5.02173612 5.76016262,5.15821148 5.84672495,5.2748615 C5.32216621,6.74311043 4.99648462,8.44771337 4.9229183,10.2828031 C4.84102152,10.3398866 4.76945963,10.4105063 4.71130755,10.4916276 L1.70979668,10.4916276 C1.82882932,8.12816358 2.84868228,5.9973846 4.42334579,4.42349623 L4.42334579,4.42349623 Z M4.42334579,17.5814378 C2.84868228,16.0131161 1.82882932,13.8823371 1.70979668,11.4972391 L4.70343448,11.4972391 C4.76304623,11.5831606 4.83753844,11.6577447 4.9233993,11.7174752 C4.99896552,13.5830043 5.33353279,15.3220444 5.87166054,16.7856882 C5.82317078,16.8733853 5.79023859,16.9688116 5.77432313,17.0677392 C5.38466973,17.2987037 5.00825625,17.5426991 4.65055078,17.8033186 L4.42334579,17.5814378 L4.42334579,17.5814378 Z M5.45403371,18.4844462 C5.70028639,18.300559 5.95707506,18.1312053 6.2230878,17.9772504 C6.28218958,18.009047 6.34477102,18.0339077 6.40958576,18.0513372 C6.47365883,18.1789648 6.5372256,18.3063394 6.60648832,18.4251363 C6.83652863,18.8361306 7.08264416,19.219975 7.34774619,19.5608045 C6.66863743,19.2687842 6.03836191,18.9171504 5.45403371,18.4844462 L5.45403371,18.4844462 Z M9.46613213,20.1881383 C8.73289921,19.7174798 8.05379045,18.9443004 7.49662558,17.9383852 C7.45248675,17.8559944 7.40897689,17.7732686 7.3660998,17.6902148 C7.42976782,17.5944242 7.47377284,17.4869513 7.49556234,17.3740303 C7.54133884,17.35849 7.58769105,17.3446984 7.63451813,17.3326854 C8.48091052,16.9995733 9.39547707,16.807474 10.3434092,16.7420661 C10.3889348,16.7988134 10.4413429,16.8496828 10.4994275,16.8935037 L10.4994275,20.279937 C10.1505065,20.274674 9.80158543,20.2422358 9.46613213,20.1881383 L9.46613213,20.1881383 Z M12.5394372,20.1881383 C12.2039586,20.2422358 11.854911,20.274674 11.5058634,20.2799623 L11.5058634,16.9254106 C11.5811066,16.8758204 11.648269,16.8149552 11.7049937,16.7449506 C12.6414327,16.8130659 13.5340761,17.0045327 14.3655072,17.3327107 C14.4437234,17.352453 14.5206362,17.3770357 14.5958006,17.4063167 C14.61318,17.4812686 14.6404559,17.5535772 14.6769109,17.6213404 C14.6231159,17.7268533 14.5661817,17.8314301 14.5089691,17.9383852 C13.9570698,18.9443004 13.2778851,19.7174798 12.5394372,20.1881383 L12.5394372,20.1881383 Z M14.6630635,19.5608045 C14.9281908,19.219975 15.1634967,18.8361306 15.3962711,18.4251363 C15.4639642,18.3123615 15.5250501,18.1917934 15.5841867,18.0706686 C15.6651585,18.0579025 15.7439123,18.0337343 15.8181002,17.9988844 C16.0719369,18.1441987 16.3150146,18.3048465 16.5485991,18.4844209 C15.972473,18.9171504 15.3366282,19.2687842 14.6630635,19.5608045 L14.6630635,19.5608045 Z M17.5822236,17.5814378 L17.3549426,17.8033439 C17.0249575,17.562992 16.6788211,17.336911 16.3171158,17.1220138 C16.3022603,16.969277 16.2471879,16.8231996 16.1575027,16.6986464 C16.6754288,15.261267 17.0083506,13.5648875 17.0811321,11.7476868 C17.1864023,11.6837676 17.2770579,11.5984497 17.3472215,11.4972644 L20.3010383,11.4972644 C20.1685632,13.8823371 19.1539758,16.0131161 17.5822236,17.5814378 L17.5822236,17.5814378 Z"></path>';
icon[_Constants["default"].BOX_CHART] = "<path d=\"M12.375,4.4408921e-15 C13.2083333,4.4408921e-15 13.2083333,1.23076923 12.375,1.23076923 L11.124,1.23 L11.124,3.282 L12.375,3.28205128 C12.72,3.28205128 13,3.55774359 13,3.8974359 L13,12.1025641 C13,12.4422564 12.72,12.7179487 12.375,12.7179487 L11.124,12.717 L11.124,14.769 L12.375,14.7692308 C13.2083333,14.7692308 13.2083333,16 12.375,16 L8.625,16 C7.79166667,16 7.79166667,14.7692308 8.625,14.7692308 L9.874,14.769 L9.874,12.717 L8.625,12.7179487 C8.28,12.7179487 8,12.4422564 8,12.1025641 L8,3.8974359 C8,3.55774359 8.28,3.28205128 8.625,3.28205128 L9.874,3.282 L9.874,1.23 L8.625,1.23076923 C7.79166667,1.23076923 7.79166667,4.4408921e-15 8.625,4.4408921e-15 L12.375,4.4408921e-15 Z\"></path>\n" + "<path d=\"M0.625,18 C-0.208333333,18 -0.208333333,16.8529412 0.625,16.8529412 L1.874,16.852 L1.874,14.941 L0.625,14.9411765 C0.28,14.9411765 0,14.6842353 0,14.3676471 L0,8.63235294 C0,8.31576471 0.28,8.05882353 0.625,8.05882353 L1.874,8.058 L1.874,6.147 L0.625,6.14705882 C-0.208333333,6.14705882 -0.208333333,5 0.625,5 L4.375,5 C5.20833333,5 5.20833333,6.14705882 4.375,6.14705882 L3.124,6.147 L3.124,8.058 L4.375,8.05882353 C4.72,8.05882353 5,8.31576471 5,8.63235294 L5,14.3676471 C5,14.6842353 4.72,14.9411765 4.375,14.9411765 L3.124,14.941 L3.124,16.852 L4.375,16.8529412 C5.20833333,16.8529412 5.20833333,18 4.375,18 L0.625,18 Z\"></path>\n" + "<path d=\"M19.375,5 C20.2083333,5 20.2083333,6.15384615 19.375,6.15384615 L18.124,6.153 L18.124,8.076 L19.375,8.07692308 C19.72,8.07692308 20,8.33538462 20,8.65384615 L20,16.3461538 C20,16.6646154 19.72,16.9230769 19.375,16.9230769 L18.124,16.923 L18.124,18.846 L19.375,18.8461538 C20.2083333,18.8461538 20.2083333,20 19.375,20 L15.625,20 C14.7916667,20 14.7916667,18.8461538 15.625,18.8461538 L16.874,18.846 L16.874,16.923 L15.625,16.9230769 C15.28,16.9230769 15,16.6646154 15,16.3461538 L15,8.65384615 C15,8.33538462 15.28,8.07692308 15.625,8.07692308 L16.874,8.076 L16.874,6.153 L15.625,6.15384615 C14.7916667,6.15384615 14.7916667,5 15.625,5 L19.375,5 Z\"></path>";

function setArrow(dom, color) {
  var isLeft = /vanchart-arrow-left/.test(dom.className);

  if ((0, _EnvUtils.isSupportSVG)()) {
    var pathString = isLeft ? 'M18.9,21.5L9.1 15 18.9 8.5M18.9,21.5z' : 'M11.1,21.5L20.9 15 11.1 8.5 M11.1,21.5z';
    dom.style.background = color;
    dom.innerHTML = '<svg width=30 height=30><path fill="none" stroke="#FFFFFF" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="' + pathString + '"></path></svg>';
  } else {
    var circle = createVml('shape');
    circle.path = _PathUtils["default"].circlePath(15, 15, 15);
    circle.stroked = 'False';
    circle.fillcolor = color;
    var fill = createVml('fill');
    fill.color = color;
    fill.opacity = 0.5;
    circle.appendChild(fill);
    dom.appendChild(circle);
    var path = createVml('shape');
    path.path = isLeft ? 'm19,22 l9,15 l19,9 e' : 'm11,22 l21,15 l11,9 e';
    path.filled = 'False';
    path.strokecolor = '#ffffff';
    dom.appendChild(path);

    _VanHammer["default"].on(dom, 'mouseover', function () {
      fill.opacity = 0.2;
    });

    _VanHammer["default"].on(dom, 'mouseout', function () {
      fill.opacity = 0.5;
    });
  }
}

function setDot(dom) {
  var circle = createVml('shape');
  circle.style.width = '100%';
  circle.style.height = '100%';
  circle.coordsize = '10 10';
  circle.path = _PathUtils["default"].circlePath(5, 5, 5);
  circle.stroked = 'False';
  circle.fillcolor = '#7f7f7f';
  var fill = createVml('fill');
  fill.color = '#7f7f7f';
  fill.opacity = 0.5;
  circle.appendChild(fill);
  dom.appendChild(circle);
}

var png = {};
png[_Constants["default"].PIE_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWBAMAAAA2mnEIAAAAMFBMVEUAAAD///////////////////////////////////////////////////////////87TQQwAAAAD3RSTlMAEM/vv4Bgr59AcFAg348jFhddAAAAjElEQVQY02MAArGSDx6JDGDAav//w//PASAmo/5/IPv/JwEgW/g/mP1fEcjWh7I/AVX/h7L/L2AQhrMvMOTD2b8Z6uHsfwz+ULZK1ByG/2B25smtLfYQ9hewLEQNRACoFwZ+AM2EgW9Au2DAkIEVzg6AuO0/xG1wRYpgv0CEBaB+/A/2I8Tv/zVAfgcA4kmspsM258YAAAAASUVORK5CYII=';
png[_Constants["default"].BAR_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWBAMAAAA2mnEIAAAAElBMVEUAAAD///////////////////8+Uq06AAAABXRSTlMAQIAgEDB5ccoAAAA+SURBVBjTY0AGoqGhgTjZBICjoKCgCFw9SAMm20hJSUkZlwFwNWAgANELBgrobEdBMDDAZQZEPRQI4GQjAwAQhxXw9o2YjgAAAABJRU5ErkJggg==';
png[_Constants["default"].COLUMN_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWBAMAAAA2mnEIAAAAG1BMVEUAAAD////////////////////////////////rTT7CAAAACHRSTlMAgEC/IGCPMNAZ/cwAAAAuSURBVBjTY4ADRSEEW6KRALvYDMHWaCbAtmgiwHZSgbOBiG5skJcDRRgcRYEMADB5J9shBWGXAAAAAElFTkSuQmCC';
png[_Constants["default"].LINE_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAMAAADzapwJAAAAM1BMVEUAAAD///////////////////////////////////////////////////////////////+3leKCAAAAEHRSTlMA74C/IM9AEN+vYDCfcFCP7HfXwgAAAG9JREFUGNPNjzsOxDAIRA0Yf+J1du5/2siKIQ1dmlA9PQ2gSa8nHznSBIo0gOgGlAPdm+M4HQuK4Qn8jEU88QdoZw6MZ0+lQ/Li5muDFpYGrokpu9UbJjUmtqaqdQeqAN2aYln7hx41nbwzLDN9Yi4tRQMa2y+S7gAAAABJRU5ErkJggg==';
png[_Constants["default"].AREA_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAAgklEQVR42mL4DwQMtACjBg8zg4FCBhRbiMPg+f8hIIFqBiMZCgMGFBuMxVAQeE+q4UD1AnCDgVT/f9zgPlgxcYaC4uc8Ayws/xMG5wkZDjX0Pdix/0kD8/EY6gAzlByDsRqOzcfkGIySDHEFIyMFGWEClC7AJslIqyw9avAQNhggwABVPsGVrLOsUQAAAABJRU5ErkJggg==';
png[_Constants["default"].GAUGE_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWBAMAAAA2mnEIAAAAMFBMVEUAAAD///////////////////////////////////////////////////////////87TQQwAAAAD3RSTlMAgL9A3zAQn89wII/vr2A5/8HrAAAAnUlEQVQY02NAA5kq/52mQZjZ/0FgG4jJ6v/fXbDk/5cAIDvmvzJDKIPR/6MMDGz+HxkYjBkY5L8kMLD/FwCzGf8XMKz/xABmM+j/Ytj/GUjPBGL73wz9DUBaEIg5fjAAlYPYIA0M/ydA2ZxA9gMgfQaI+f5D1NyFqOm/AHUh7w+G/b+g7PXfGeK/Q9n1XxmYtKDsRQoMbHAvJTAQAQCj4DRASabatgAAAABJRU5ErkJggg==';
png[_Constants["default"].RADAR_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAMAAADzapwJAAAAM1BMVEUAAAD///////////////////////////////////////////////////////////////+3leKCAAAAEHRSTlMAEO+A32DPr7+fQFAwIHCP1A0rdQAAAMpJREFUGNOFUFlyRCEIlEXcfdz/tAHxVSr5mOmyQJu2UdI39Mob/pOjcuOK9KeQmbPJbd3CS3oqblWQVpiqnEx00tYnjlXqemlo+ISqZHhwBN25AOih0aQDGxhNuI2QbmGh16ByKSLT9w/FAw6aar0v89zItKMhqzJan3tf8i4qe3aWvHxLE81LQ5IKZU7nImu2Y3gvhcQjvBGsLHTat9srTZ0n+V8Ap4fuYd+h4rxCMkNp6YIEwhZwNfkdeWG+fxIfxQsQfdHTB/wA4h0GZUKWX6QAAAAASUVORK5CYII=';
png[_Constants["default"].SCATTER_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAAgUlEQVR42mJgGAVA8P//fwFaGFoAxP8ZaWCwAZByGHRhCPYuEKyntsH7oQb/x6WGhUyzF0LpCyMnoRtAkw+6uAMQnwdFIrlhfB5Ko6d3BSA2IDuMgS6aD8T9eDICeV6mNBzn/0eA+dQ0GB1QxeVMtExSDTQJCljBDMQKI7t6AggwAFyzgSCZYutPAAAAAElFTkSuQmCC';
png[_Constants["default"].BUBBLE_CHART] = png[_Constants["default"].FORCE_BUBBLE_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAAnUlEQVR42mJgGAVQwEiswv///ysAqQQodwIjI+MHqrgAaPD7/wiwn1qGOvxHA1QLM1JdzEKC2YbIYUz31AANNgFqG9oPDar3TFR2sAGUFoCnUSCeD4oUKG1AposNgHg9ECdgTUpQEEBpuNzHYfB9Sg3GBwzINZdQ5H0YlEFhgJZd/0P5BhQXm9CckgBNfyDvbwAWiw9GaxWqAIAAAwA2evfwKvysMwAAAABJRU5ErkJggg==';
png[''] = png[_Constants["default"].MULTI_CHARTS] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAMAAADzapwJAAAAM1BMVEUAAAD///////////////////////////////////////////////////////////////+3leKCAAAAEHRSTlMAQL/PMBBwgCDvn49gUN+vfvzE8AAAAGJJREFUGNPdjUEOgDAIBFkordpW+f9rNdqUQ3mBeyBhMiwURBNFYQu4HsK60E1aUNAlA+7sUgpQmdXMZh/vDORyPs8cJ+l4T7dEjhsPB8DE+bh0LD4IJkRO3K7Agj/xTzjKDUJoCsaJEKt8AAAAAElFTkSuQmCC';
png[_Constants["default"].MULTIPIE_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAMAAADzapwJAAAAe1BMVEUAAAD////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////NgkbwAAAAKHRSTlMAMpkDn0AnIBSz24Dmv4dKOhoQCuzKrJqMLfnyuaZ5dGZaUkIN0pRsCVisMQAAAOZJREFUGNN90dtygyAUhWHWEhA0Gg8xappz0pb3f8LKdkrTXvS/45s9DHtQL8G6TP0qcxYKS3n2gm0UVX9ugblPatFca63IsX4AfdLtB0nF2BbIhHPcNVkV6jBo8Txqj2bkfheCCmG3eA08ZfhC/RYii483GZ9BDkF4qSBLYGE8NDeJw4mUx+DGlU2ssdY9ZeWrFl7bkHcI48gicUHdCFt4+sRHTrCRHcoT33+GL3Cy+wxPVvHlh4Hcfy/fwXi9nL0ntTfo1JqDmSrGqglxxeQw57Iszwbx4lSWYy3/+2td27ad4D99Ae8gE70h03waAAAAAElFTkSuQmCC';
png[_Constants["default"].TREEMAP_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAAOUlEQVR42mL8DwQMRABGIAAqnclAJGBioBEYNXjU4FGDh5XBLEDMRyuD1YhUe3Y08kYNHqQGAwQYAL9YCMfrIWhGAAAAAElFTkSuQmCC';
png[_Constants["default"].FUNNEL_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABcAAAAXBAMAAAASBMmTAAAAKlBMVEUAAAD///////////////////////////////////////////////////+Gu8ovAAAADXRSTlMAQMCAIGAw0FAQ8HCwS1BQUgAAAHVJREFUGNNjwA2Y78LAZQYGDjjnKgMDC5xzDahuLYxzAcjRhXEKgJxEQShIAHIcYRwHIGcvTFkAkOML40wActih7DsgJ3Aj7ETYehPsuloIRwHT3UlKYNAAZMKMuzUBzGFEGAZxKkJ/LojjAOWwGhsbW2CYCwC1z2uuESf9qgAAAABJRU5ErkJggg==';
png[_Constants["default"].GANTT_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAMAAADzapwJAAAAeFBMVEUAAAD////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////GqOSsAAAAJ3RSTlMABOgQCPvZzN3OhMOofnrCZD03jzDs0ryWiXNsXyUjDd9TUkQqHhgfRKpZAAAAmElEQVQY043P2Q6DIBRF0SsiKMrgXKfamf//w1qxQJo0uh73y8kBmEMDYxyA9SI1WrGB310+R9o4ie7mZW1zeXU5bBuaLKhQfQ4HBB7bgKOGbOJuqL45007G8p3MahJvLmVfLcXAjtncE8BEE3NrZXOhfXv5gXxgzaEH/nu2qZQyXUiajUqNavpdQ5wxVuafXEWWJoJzwYo3Z10TfT0w3LEAAAAASUVORK5CYII=';
png[_Constants["default"].STRUCTURE_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAMAAADzapwJAAAAhFBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8g2+bRAAAAK3RSTlMAA/v3JXcSB9yNRSycF/Dsu7akmJSCTTMOC9HEwKWIWTof4taqoH1wZ1Ydf35d9gAAAO1JREFUGNNVUAlygzAMlA+wMZAQroTc6d3q///rYkHcahikWe+sdkVSitbhOQ2vOyu4/KUyZj4+0ft+gc9sNJdCnBrmSuCCNfuDkDPMHCIlbzS/k1MoUIzhG+D5s/UlKjr6wp6XHJhsHysVxh8K1b3vxJV4bTfM277LV5fSc88aywqalORZHRiGiW2UTfAFGErP9pVbnhz1wvZxT7rSnhEVS6+WqMzGiE7h8TiBzV1Z+fYTUwHcejan2mZDmCN/MPQ2NVEbu+g5oiPkNLQauaBTEvkKtR2mm/R0/3MR7/n9Nhz+xPifP0GL93SGVL8LLRIgop0Y4gAAAABJRU5ErkJggg==';
png[_Constants["default"].WORD_CLOUD_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAACMUlEQVRIS7VUQXLaQBCckcRBXEAXqnY4YP8AvyDJD8IL4rwgzgvivCD2D+AFkBeYvCD4BSEHraq4gE+6UJpUU1plAYkCV3lPQhp6erp7lumNDr8RLl0MnGXZeyJ65wgVRbEIguDZGLP0SV4MnKbpPTN/q5n0q4g8uPevBmbmD8aY+Wq1Gm632xkRDUSkwjsCzrLsKgzDbq/XW9Tp7xg74PV63c3z/DcRJSLSPWJcFkyJCBriLKMoGh02aJLCNToCttaOiegTEY2iKFpiPFVd9/v9G5+5BzxR1SUzg+WtqmoQBDfOxEoKa+2GiOYi8hFAcD8Mw00TY5+h16wy0AdWInoUkTsAQxrHNM9zSITzqKrDMhV3zLwoigJ1SMoQ04oIjPyf4zRNF8zcEZFrfLDWIjpfVPW7i5eqwtCfDXGrSO0BY3RVfYJpRAQASDIpzRwQ0QsRdcCKmSGbO8vD5dgDxo8yk7dEhHHHqgqAqao+E9GsZDoREdTAh6vS8F2KjDEgsjsnF8QlhZk/w1hV/YNm7Xb7OkmSjTflL5AhoicRGZ0ELnO9RlEcxwmArLVz3BNoZIwZO2BsnLUW0k1dbSNjay3S8cPPsHuGici3D+yezwGGiQPoe2AWRu4gx2gEw5n5XlWh+18R2W1uLePSROz/i7//fgyRGAAWRbEzEs3jOB5DskZgb733suklB00r7evkqmUMfVW1GwTBuC6j7nur1Zo13YIX38d17M5mfO6fT9X9A37JPSaAohB+AAAAAElFTkSuQmCC';
png[_Constants["default"].AREA_MAP] = png[_Constants["default"].HEAT_MAP] = png[_Constants["default"].POINT_MAP] = png[_Constants["default"].LINE_MAP] = 'iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QA/wD/AP+gvaeTAAACW0lEQVQ4jY3VS2+NURQG4KenjbYSoXTgNnFJ3P6ASERIxyXhF4j4B3UfYIAwkUgkwpyopJdxg3SoBia0qipFY8TRJoIWNVjr069He1jJyVl7Xd797XevtXaDpaUNh3AQ27Ex7e8xgj70oloHY4G04gw+Yy5/b/Aa46kX9s84nTl1ZQOeZtLbTHyAFpzHBTSjG1MZM4ehzF0S9F0GPsNxvMTy9BfA0jaCYxk7Jyj6A14pHb83HacwjVsYyK+tlVYM4nZ++UmsR09t/Jnc9VKu9+YX9GbiKCbzN5q23ozZkzmXE+NUAbpacDkm+IOzuJ76MuzAXdxLfVn6ruNc6s3igqtoq4hyWomr+J5BB5IGmMGw4Hsk9Zn0DWB/6t9xDavQWUEnfojbL2RrAvxLnmNLad2dWJ0V7BL1+SmdjVgr+PuXTGIdmnL9UdT5rqYEqeJKOleIarkoLqOQfWmvrZIG3BAXSvC/uthp1t+tOZ3HUopprIkryvVLyT5b7PYyDdtKwV/FhX4rgZyv+ScqYVo0zM+0jeJnBS+wGWvS8Qsf1GnRkmzI2AK0HZvwooJ+Qf7hUsIYdv4H8E68Kq2PJFZ/RYy/KZww3yAP0ZF60SDbRAWVG6QDj1JvQZdotv5ip9qW3p1H7MlNX4kBNZn6VPrei/YnqmpBSxNDZUjw24XHGXRH8MbC6daOmxkzmDm/8MQiQ6t2bB4VLbzU2BxWZ2wuBj6UgROCr27BfQHcjPtJx4T/GPSFtAiequafoHHzT9N4yV7N2L+O31BngzYx+TpFJZQf02Fx832WeEx/AyS1tWlcsFv6AAAAAElFTkSuQmCC';
png[_Constants["default"].BOX_CHART] = 'iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAAFKADAAQAAAABAAAAFAAAAACRFdLHAAABPElEQVQ4Ea2UQU7DMBBFkyoXYNHuKqUFeoEeoIgrcDvgMHCEsigSalddIoEEgm14H82UxHEdI3Wkr++ZP/NjR3GKYiCaptmBduwGRtIyTgtwY47iRXoiQ8WkNsM6oz3dgtEdeDBD8W1qokyJ0mQU9pREWPN8RP9WQ63YujjEzPRnKY7BlRmKx20jq3fIdYoTcG2iePKrsaitWHuzs9U75Jq4N0thAz5sQrwJBkz6I9eprMGbKeJ1qcQbnNsvPaXHtJGbnIpPblhl7OyenkuwAo/gBRwPvYcwwm706FcQzinXkZ/Bp5mIlR+CHv0MllZYWn7QowuaojtQM9rR3xdaLyoquhkze9KM/IvP5tXygvW5ryP8RG0KzsA72GsH/fuIkhvMd05XsYOL3OGwDzPd3bnV5+TfYc+/8tjpfgB7wsX9DEvcDgAAAABJRU5ErkJggg==';
var CSS = "position:absolute;width:1px;height:1px;behavior:url(#default#VML);";

function createVml(type) {
  var shape = _VmlRenderer["default"].prototype.create(type);

  shape.style.cssText = CSS;
  shape.coordsize = '1 1';
  return shape;
}

var _default = Carousel;
exports["default"] = _default;

/***/ }),
/* 103 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _FormattedText = __webpack_require__(41);

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _GradualColor = __webpack_require__(31);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function valid(point) {
  var tooltip = point.options.tooltip;
  return tooltip && tooltip.enabled && point.isVisible();
}

function shareValid(point) {
  var tooltip = point.options.tooltip;
  return valid(point) && tooltip.shared;
}

var TOOLTIP_CATEGORY_STYLE = '<span style="font-size:' + ((0, _EnvUtils.isSupportSVG)() ? '1rem' : '16px') + ';font-family:Verdana;color:white;">';
var TOOLTIP_SERIES_STYLE = '<span style="font-size:' + ((0, _EnvUtils.isSupportSVG)() ? '0.875rem' : '14px') + ';font-family:Verdana;color:white">';
var TOOLTIP_VALUE_STYLE = '<span style="font-size:' + ((0, _EnvUtils.isSupportSVG)() ? '0.875rem' : '14px') + ';font-family:Verdana;font-weight:bold;color:white">';

function calculateTooltipContent(point) {
  var series = point.series,
      type = series.type,
      tooltip = point.options.tooltip,
      formatter = tooltip.formatter;
  var isMobileFlow = series.vanchart.isMobileFlow();

  if (!isMobileFlow && !(valid(point) || tooltip.shared)) {
    return '';
  }

  if (typeof formatter !== 'object' && isMobileFlow) {
    tooltip.formatter = series.getDefaultTooltipFormatter();
  } else if (typeof formatter !== 'object') {
    try {
      // 用户自定义的，里面极有可能有抛错，如window.FR.contentFormat
      return _BaseUtils["default"].getFormatterFunction(formatter).call(point);
    } catch (e) {
      return '';
    }
  }

  var contentFn;

  switch (type) {
    case _Constants["default"].BUBBLE_CHART:
    case _Constants["default"].SCATTER_CHART:
      contentFn = series.vanchart.isMap() ? defaultTooltipContent : bubbleTooltipContent;
      break;

    case _Constants["default"].TREEMAP_CHART:
      contentFn = treeMapTooltipContent;
      break;

    case _Constants["default"].GANTT_CHART:
      contentFn = ganttTooltipContent;
      break;

    case _Constants["default"].LINE_MAP:
      contentFn = lineMapTooltipContent;
      break;

    case _Constants["default"].BOX_CHART:
      contentFn = boxTooltipContent;
      break;

    default:
      contentFn = defaultTooltipContent;
  }

  return contentFn(point, tooltip);
}

function bubbleTooltipContent(point, tooltip) {
  var series = point.series,
      formatter = tooltip.formatter;
  var style = tooltip.style,
      identifier = formatter.identifier;
  var content = '';
  content += _createBubbleTooltipSeriesLine(point, identifier, style, formatter);
  content += _createBubbleTooltipXYSizeLine(point, identifier, style, formatter);
  return content;
} // 提示的第一行：气泡的系列


function _createBubbleTooltipSeriesLine(data, identifier, style, formatter) {
  var content = '';

  if (identifier.indexOf(_FormattedText.SERIES) != -1) {
    var seriesString = _BaseUtils["default"].format(data.seriesName, formatter.seriesFormat);

    seriesString = _escapeString(seriesString);
    content += (style ? '<span >' : TOOLTIP_SERIES_STYLE) + seriesString + '</span>';
    content += '<br />';
  }

  return content;
} // //提示的第二行：气泡的X、Y、SIZE


function _createBubbleTooltipXYSizeLine(data, identifier, style, formatter) {
  var content = '';

  if (identifier.indexOf(_FormattedText.X) != -1 || identifier.indexOf(_FormattedText.Y) != -1 || identifier.indexOf(_FormattedText.SIZE) != -1) {
    var text = (0, _FormattedText.getXYSizeString)(data, formatter, identifier);
    content += (style ? '<span>' : TOOLTIP_VALUE_STYLE) + text + '</span>';
  }

  return content;
}

function treeMapTooltipContent(point, tooltip) {
  var style = tooltip.style,
      formatter = tooltip.formatter,
      identifier = formatter.identifier;
  var content = '';

  if (tooltip.shared) {
    if (identifier.indexOf(_FormattedText.NAME) != -1) {
      var p,
          d = point,
          points = [point.name];

      while ((p = d.parent) && p.depth) {
        d = p;
        points.unshift(p.name);
      }

      content += (style ? '<span>' : TOOLTIP_CATEGORY_STYLE) + points.join(' / ') + '</span><br>';
    }

    content += _createSeriesLine(point, identifier, style, formatter);
  } else {
    content += _createCategoryLine(point, identifier, style, formatter);
    content += _createSeriesLine(point, identifier, style, formatter);
  }

  return content;
}

function ganttTooltipContent(point, tooltip) {
  var style = tooltip.style,
      formatter = tooltip.formatter,
      identifier = formatter.identifier;
  var series = point.series;
  var names = [_FormattedText.PROCESSES, _FormattedText.SERIES, _FormattedText.STARTTIME, _FormattedText.FINISHTIME, _FormattedText.DURATION, _FormattedText.PROGRESS];
  var content = '';

  function fmtStr(item) {
    if (identifier.indexOf(item) !== -1) {
      var propKey = _FormattedText.propMap[item][0];
      var fmtKey = _FormattedText.propMap[item][1];
      var value = series._formatValue ? series._formatValue(point, propKey) : point[propKey];

      var fmt = formatter[fmtKey] || series._getTooltipFormatFn && series._getTooltipFormatFn(propKey);

      var str = _BaseUtils["default"].format(value, fmt);

      return series._postTooltip ? series._postTooltip(str, propKey) : str;
    }

    return null;
  }

  names.map(function (item) {
    var str = fmtStr(item);

    if (str != null) {
      content += (style ? '<span>' : TOOLTIP_SERIES_STYLE) + str + '</span><br>';
    }
  });
  return content;
}

function defaultTooltipContent(point, tooltip) {
  var series = point.series,
      vanchart = series.vanchart,
      points = point.points;
  var formatter = tooltip.formatter,
      identifier = formatter.identifier,
      style = tooltip.style;
  var content = '',
      visiblePoints = [];

  if (tooltip.shared && points && points.length) {
    //当有地图的时候,不可见的点的数据点提示也要展示
    var hasMap = vanchart.isMap(),
        hasRangeLegend = vanchart.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT);
    content += _createCategoryLine(point, identifier, style, formatter);

    if (hasMap && point.series.type !== _Constants["default"].LINE_MAP) {
      var visible = point.visible && point.series.visible;
      visiblePoints = point.options.drilldown || visible ? points : [];
    } else {
      visiblePoints = points.filter(shareValid);
    }

    visiblePoints.forEach(function (p) {
      var dotColor = hasMap && hasRangeLegend ? points[0].color : (0, _GradualColor.notSupportGradualColor)(p.options, p.color);
      var tooltip = p.options.tooltip;
      content += _getDotMarkerContent(dotColor, p.opacity); // CHART-867
      // 共享设置只有formatter不同
      // 其他取第一个系列

      content += _createSeriesLine(p, identifier, style, tooltip.formatter);
      content += '<br />';
    });
  } else {
    content += _createCategoryLine(point, identifier, style, formatter);
    content += _createSeriesLine(point, identifier, style, formatter);
  }

  return content;
}

function _createCategoryLine(point, label, style, formatter) {
  var content = '',
      type = point.series.type;

  if (type === _Constants["default"].MULTIPIE_CHART) {
    if (label.indexOf(_FormattedText.SERIES) != -1) {
      content = _BaseUtils["default"].format(point.seriesName, formatter.seriesFormat);
    }
  } else {
    if (label.indexOf(_FormattedText.CATEGORY) != -1) {
      content = _BaseUtils["default"].format(point.category, formatter.categoryFormat);
    }

    if (label.indexOf(_FormattedText.NAME) != -1 && type !== _Constants["default"].WORD_CLOUD_CHART) {
      var format = point.series.vanchart.isMap() ? formatter.areaNameFormat : formatter.nameFormat;
      content = _BaseUtils["default"].format(point.name, format);
    }
  }

  if (content) {
    content = _escapeString(content);
    content = (style ? '<span>' : TOOLTIP_CATEGORY_STYLE) + content + '</span>';
    content += '<br />';
  }

  return content;
} // IE不支持ES6模板字符串，不要改成模板字符串


function _getDotMarkerContent(color, opacity) {
  return '<span style="width:' + ((0, _EnvUtils.isSupportSVG)() ? '0.75rem' : '12px') + ';height:' + ((0, _EnvUtils.isSupportSVG)() ? '0.75rem' : '12px') + ';display: inline-block; overflow: hidden; position: relative; border-radius: 50%; text-align: left;  margin-right: 5px">' + '<span style="border:' + ((0, _EnvUtils.isSupportSVG)() ? '0.75rem' : '12px') + ' dotted ' + color + ';opacity: ' + opacity + ';width: 100%; height: 100%; position: absolute;"></span>' + '</span>';
}

function _escapeString(string) {
  if (string) {
    return (string + '').replace(/</g, "&lt").replace(/>/g, "&gt");
  }

  return string;
}

function _createSeriesLine(point, label, style, formatter) {
  var content = '',
      type = point.series.type;
  var pointValue = point.isNull ? "" : point.originalValue,
      pointPercent = point.isNull ? "" : point.percentage; //@chart-1091:对于为Null且需要显示的数据点，其对应的数据点提示中的value和percent应该为""

  if (type === _Constants["default"].STRUCTURE_CHART && pointValue === "-") {
    pointValue = ""; // @CHART-1379
  }

  var valueString = _BaseUtils["default"].format(pointValue, formatter.valueFormat);

  var percentString = _BaseUtils["default"].format(pointPercent, formatter.percentFormat);

  var levelString = _BaseUtils["default"].format(point.level, formatter.levelFormat);

  var textString;
  var valuesMap = {};
  valuesMap[_FormattedText.SIZE] = valueString;
  valuesMap[_FormattedText.VALUE] = valueString;
  valuesMap[_FormattedText.PERCENT] = percentString;
  valuesMap[_FormattedText.LEVEL] = levelString;

  if (type === _Constants["default"].MULTIPIE_CHART || type === _Constants["default"].WORD_CLOUD_CHART) {
    if (label.indexOf(_FormattedText.NAME) != -1) {
      textString = _BaseUtils["default"].format(point.name, formatter.nameFormat);
    }
  } else {
    if (label.indexOf(_FormattedText.SERIES) != -1) {
      textString = _BaseUtils["default"].format(point.seriesName, formatter.seriesFormat);
    }
  }

  var valueArray = [_FormattedText.VALUE, _FormattedText.PERCENT, _FormattedText.LEVEL];

  if (type == _Constants["default"].BUBBLE_CHART || type == _Constants["default"].SCATTER_CHART) {
    valueArray = [_FormattedText.SIZE, _FormattedText.PERCENT, _FormattedText.LEVEL];
  }

  var valuesString = valueArray.filter(function (k) {
    return label.indexOf(k) !== -1 && !(0, _CoreUtils.isEmpty)(valuesMap[k]);
  }).map(function (k) {
    return valuesMap[k];
  }).join('  ');

  if (textString && valuesString) {
    textString += ':';
  }

  textString = _escapeString(textString);

  if (textString) {
    content += (style ? '<span >' : TOOLTIP_SERIES_STYLE) + textString + '</span>';
  }

  if (valuesString) {
    content += (style ? '<span>' : TOOLTIP_VALUE_STYLE) + valuesString + '</span>';
  }

  return content;
}

function lineMapTooltipContent(point, tooltip) {
  if (!tooltip || !tooltip.enabled) {
    return;
  }

  var formatter = tooltip.formatter,
      content = '';

  if (typeof formatter == 'object') {
    var style = tooltip.style,
        label = formatter.identifier;
    content += _lineMapCreateCategoryLine(point, label, style, formatter);
    content += _lineMapCreateSeriesLine(point, label, style, formatter);
  } else {
    content = _BaseUtils["default"].getFormatterFunction(formatter).call(point);
  }

  return content;
}

function boxTooltipContent(point, tooltip) {
  var style = tooltip.style;
  var formatter = tooltip.formatter;
  var identifier = formatter.identifier;
  var result = point.dataResult;
  var options = point.options;
  var content = '';

  if (point.outlierData == null) {
    if (identifier.indexOf(_FormattedText.CATEGORY) !== -1) {
      content += _createBoxTooltipLine(style, "", point.category, formatter.categoryFormat);
    }

    if (identifier.indexOf(_FormattedText.SERIES) !== -1) {
      content += _createSeriesLine(point, identifier, style, formatter);
      content += '<br />';
    }

    var labelGroup = [options.numberLabel, options.maxLabel, options.q3Label, options.medianLabel, options.q1Label, options.minLabel];
    var valueGroup = [result.number, result.max, result.q3, result.median, result.q1, result.min];
    var formatterGroup = [formatter.dataNumberFormat, formatter.dataMaxFormat, formatter.dataQ3Format, formatter.dataMedianFormat, formatter.dataQ1Format, formatter.dataMinFormat];
    [_FormattedText.DATA_NUMBER, _FormattedText.DATA_MAX, _FormattedText.DATA_Q3, _FormattedText.DATA_MEDIAN, _FormattedText.DATA_Q1, _FormattedText.DATA_MIN].forEach(function (item, index) {
      if (identifier.indexOf(item) !== -1 && (0, _CoreUtils.hasDefined)(valueGroup[index])) {
        content += _createBoxTooltipLine(style, labelGroup[index] + ": ", valueGroup[index], formatterGroup[index]);
      }
    });
  } else {
    var outlier = point.outlierData.outlier;

    if (identifier.indexOf(_FormattedText.DATA_OUTLIER) !== -1 && (0, _CoreUtils.hasDefined)(outlier)) {
      content += _getDotMarkerContent(options.outlierMarker.fillColor, 1);
      content += _createBoxTooltipLine(style, options.outlierLabel + ": ", outlier, formatter.dataOutlierFormat);
    }
  }

  return content;
}

function _createBoxTooltipLine(style, label, value, formatter) {
  var content = _BaseUtils["default"].format(value, formatter);

  if ((0, _CoreUtils.hasDefined)(content)) {
    content = _escapeString(content);
    content = (style ? '<span>' : TOOLTIP_SERIES_STYLE) + label + content + '</span>';
    content += '<br />';
  }

  return content;
}

function _lineMapCreateCategoryLine(point, label, style, formatter) {
  var content = '';

  if (label.indexOf(_FormattedText.SERIES) != -1) {
    var seriesString = _BaseUtils["default"].format(point.seriesName, formatter.seriesFormat);

    content += (style ? '<span >' : TOOLTIP_SERIES_STYLE) + seriesString + '</span>';
    content += '<br />';
  }

  return content;
}

function _lineMapCreateSeriesLine(point, label, style, formatter) {
  var content = '';

  var hasTag = function (tag) {
    return label.indexOf(tag) !== -1;
  };

  var names = [];
  var options = point.options;

  if (hasTag(_FormattedText.FROM) && (0, _CoreUtils.hasDefined)(options.from.name)) {
    var fromNameString = _BaseUtils["default"].format(options.from.name, formatter.fromFormat);

    names.push(fromNameString);
  }

  if (hasTag(_FormattedText.TO) && (0, _CoreUtils.hasDefined)(options.to.name)) {
    var toNameString = _BaseUtils["default"].format(options.to.name, formatter.toFormat);

    names.push(toNameString);
  }

  if (names.length) {
    content += (style ? '<span>' : TOOLTIP_SERIES_STYLE) + names.join('→') + '</span>&nbsp;';
  }

  var values = [];

  if (hasTag(_FormattedText.VALUE)) {
    var valueString = _BaseUtils["default"].format(point[point.series.getTargetKey()], formatter.valueFormat);

    valueString && values.push(valueString);
  }

  if (hasTag(_FormattedText.PERCENT)) {
    var percentString = _BaseUtils["default"].format(point.percentage, formatter.percentFormat);

    percentString && values.push(percentString);
  }

  if (values.length) {
    content += (style ? '<span>' : TOOLTIP_VALUE_STYLE) + values.join('&nbsp;&nbsp;') + '</span>';
  }

  return content;
}

var _default = calculateTooltipContent;
exports["default"] = _default;

/***/ }),
/* 104 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.initState = initState;
exports.htmlDecode = htmlDecode;
exports.getFontStyle = getFontStyle;
exports.parseCssText = parseCssText;
exports.matchCssStyle = matchCssStyle;
exports.matchFontTag = matchFontTag;
exports.matchStyleAttr = matchStyleAttr;
exports.matchColorAttr = matchColorAttr;
exports.matchFontWeightTag = matchFontWeightTag;
exports.parseEndTag = parseEndTag;
exports.convert = convert;
exports.richTextParse = richTextParse;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var START_TAG_PATTERN = /<([-\w\d_]+)\s*([^>]*)\s*(\/?)>/;
var END_TAG_PATTERN = /^<\/([-\w\d_]+)[^>]*>/;
var ATTR_PATTERN = /([-\w\d_]+)\s*=[\s\\"']*([^\\"']*)[\\"']*/g;
var FILED_PATTERN = /([-\w\d_]+)\s*=[\s\\"']*([^\\"']*)[\\"']*/g;
var COLOR_PATTERN = /rgb\s*\(\s*([0-9]+),\s*([0-9]+),\s*([0-9]+)\)/;
var END_TAG = "</";
var START_TAG = "<";
var PARAMETER = "data-id";
var SIZE_MAP = {
  "1": 10,
  "2": 13,
  "3": 16,
  "4": 18,
  "5": 24,
  "6": 32
};
var INITIAL_STYLE = {
  textAlign: '',
  textDecoration: '',
  fontFamily: '',
  fontSize: '',
  fontWeight: '',
  fontStyle: '',
  color: ''
};
var rowIndex = 0;
var styleId = 0;
var tags = [];
var styleList = [];
var content = [];
var styleMap = {};

var defaultFont = _BaseUtils["default"].extend({}, INITIAL_STYLE);

function initState() {
  rowIndex = 0;
  styleId = 0;
  content = [];
  tags = [];
  styleList = [];
  styleMap = {};
  defaultFont = _BaseUtils["default"].extend({}, INITIAL_STYLE);
}

function getFontStyle() {
  var style = _BaseUtils["default"].extend({}, defaultFont);

  for (var i = 0, len = styleList.length; i < len; i++) {
    var _styleList$i = styleList[i],
        textAlign = _styleList$i.textAlign,
        textDecoration = _styleList$i.textDecoration,
        fontFamily = _styleList$i.fontFamily,
        fontSize = _styleList$i.fontSize,
        fontWeight = _styleList$i.fontWeight,
        fontStyle = _styleList$i.fontStyle,
        color = _styleList$i.color;

    if (!(0, _CoreUtils.isEmpty)(textAlign)) {
      style.textAlign = textAlign;
    }

    if (!(0, _CoreUtils.isEmpty)(textDecoration)) {
      style.textDecoration = textDecoration;
    }

    if (!(0, _CoreUtils.isEmpty)(fontFamily)) {
      style.fontFamily = fontFamily;
    }

    if (!(0, _CoreUtils.isEmpty)(fontSize)) {
      style.fontSize = fontSize;
    }

    if (!(0, _CoreUtils.isEmpty)(fontWeight)) {
      style.fontWeight = fontWeight;
    }

    if (!(0, _CoreUtils.isEmpty)(fontStyle)) {
      style.fontStyle = fontStyle;
    }

    if (!(0, _CoreUtils.isEmpty)(color)) {
      style.color = parseTextFill(color);
    }
  }

  return style;
}

function dealTagStart(tagName, attr) {
  var isRowElement = false;

  if (tagName === "img") {
    parseField(attr);
  } else {
    isRowElement = tagName === "div" || tagName === "p" || tagName === "br";

    if (isRowElement && content && content.length) {
      autoAddLineIndex();
    }

    parseStartTag(tagName, attr);
  }
}

function parseField(attr) {
  var prop = {};
  var match = FILED_PATTERN.exec(attr);

  while (match && match.length) {
    prop[match[1]] = match[2];
    match = FILED_PATTERN.exec(attr);
  }

  autoAddStyleId();
  styleMap[styleId + ""] = getFontStyle();
  content.push({
    rowIndex: rowIndex,
    styleId: styleId,
    text: prop[PARAMETER] || '',
    isField: true
  });
}

function parseTextFill(color) {
  if (color === "" || color === "inherit") {
    return "";
  }

  return color;
}

function parseCssText(cssText, style) {
  if (cssText === "") {
    return;
  }

  cssText = cssText.toLowerCase().replace(/&apos;/g, "'").replace(/&quot;/g, "\"").replace(/\\s/g, "");
  var cssStyleGroup = cssText.split(";");

  for (var i = 0, len = cssStyleGroup.length; i < len; i++) {
    var cssStyle = cssStyleGroup[i].split(":");

    if (cssStyle && cssStyle.length === 2) {
      matchCssStyle(cssStyle[0], cssStyle[1], style);
    }
  }
}

function matchCssStyle(key, value, style) {
  if (key == null || value == null) {
    return;
  }

  key = _BaseUtils["default"].trim(key);
  value = _BaseUtils["default"].trim(value);

  if (key === "text-align") {
    style.textAlign = value;
  }

  if (key === "font-family") {
    style.fontFamily = value;
  }

  if (key === "font-size") {
    style.fontSize = value;
  }

  if (key === "font-weight") {
    if (value === "italic") {
      style.fontStyle = value;
    } else if (value === "bold") {
      style.fontWeight = value;
    }
  }

  if (key === "color") {
    style.color = value;
  }
}

function matchFontTag(tagName, attr, style) {
  if (tagName === "font") {
    var match = ATTR_PATTERN.exec(attr);

    while (match && match.length) {
      if (match[1] === "face") {
        style.fontFamily = match[2];
      }

      if (match[1] === "size") {
        style.fontSize = SIZE_MAP[match[2]] + 'px';
      }

      if (match[1] === "color") {
        style.color = match[2];
      }

      match = ATTR_PATTERN.exec(attr);
    }
  }
}

function matchStyleAttr(attr, style) {
  var match = ATTR_PATTERN.exec(attr);

  while (match && match.length) {
    if (match[1] === "style") {
      var cssText = match[2];
      parseCssText(cssText, style);
    }

    match = ATTR_PATTERN.exec(attr);
  }
}

function matchColorAttr(attr, style) {
  var match = attr.match(COLOR_PATTERN);

  if (!(match && match.length)) {
    return;
  }

  style.color = "rgb(" + match[1] + ', ' + match[2] + ', ' + match[3] + ')';
}

function matchFontWeightTag(tagName, style) {
  if (tagName === "i" || tagName === "em") {
    style.fontStyle = "italic";
  }

  if (tagName === "b" || tagName === "strong") {
    style.fontWeight = "bold";
  }
}

function matchDecorationTag(tagName, style) {
  if (tagName === "u") {
    style.textDecoration = "underline";
  }
}

function parseStartTag(tagName, attr) {
  tags.push(tagName);

  var style = _BaseUtils["default"].extend({}, INITIAL_STYLE);

  matchFontTag(tagName, attr, style);
  matchStyleAttr(attr, style);
  matchColorAttr(attr, style);
  matchFontWeightTag(tagName, style);
  matchDecorationTag(tagName, style);
  styleList.push(style);
}

function parseEndTag(tagName) {
  if (styleList.length === 0) {
    return;
  }

  var newTags = [];
  var newStyles = [];
  var matched = false;

  for (var i = tags.length - 1; i >= 0; i--) {
    var curTagName = tags[i];

    if (!matched) {
      if (curTagName === tagName) {
        matched = true;
      }
    } else {
      newTags.unshift(curTagName);
      newStyles.unshift(styleList[i]);
    }
  }

  tags = newTags;
  styleList = newStyles;
}

function parseText(text) {
  autoAddStyleId();
  styleMap[styleId + ""] = getFontStyle();
  content.push({
    rowIndex: rowIndex,
    styleId: styleId,
    text: htmlDecode(text),
    isField: false
  });
}

function htmlDecode(text) {
  if (text === "") {
    return text;
  }

  return text.replace(/&amp;/g, "&").replace(/&dollar;/g, "$").replace(/&lcub;/g, "{").replace(/&rcub;/g, "}").replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&nbsp;/g, " ");
}

function autoAddLineIndex() {
  ++rowIndex;
}

function autoAddStyleId() {
  ++styleId;
}

function convert(content, styleMap) {
  var result = [];

  if (content && content.length) {
    for (var i = 0, len = content.length; i < len; i++) {
      var _content$i = content[i],
          _rowIndex = _content$i.rowIndex,
          _styleId = _content$i.styleId,
          text = _content$i.text,
          isField = _content$i.isField;
      var style = styleMap[_styleId];
      var row = result[_rowIndex] || [];

      if (style && style.textAlign === '') {
        style.textAlign = 'left';
      }

      row.push({
        text: text,
        isField: isField,
        style: style
      });
      result[_rowIndex] = row;
    }
  }

  return result.filter(function (row) {
    return !(0, _CoreUtils.isEmpty)(row) && row.length;
  });
}

function richTextParse(richText) {
  if (richText === void 0) {
    richText = "";
  }

  initState();

  while (richText !== "") {
    var isTextNode = true;

    if (richText.length > 1 && richText.substring(0, 2) === END_TAG) {
      var match = richText.match(END_TAG_PATTERN);

      if (match && match.length) {
        isTextNode = false;
        parseEndTag(match[1]);
        richText = richText.substring(match.index + match[0].length);
      }
    } else if (richText.substring(0, 1) === START_TAG) {
      var _match = richText.match(START_TAG_PATTERN);

      if (_match && _match.length) {
        isTextNode = false;
        dealTagStart(_match[1], _match[2]);
        richText = richText.substring(_match.index + _match[0].length);
      }
    }

    if (isTextNode) {
      var index = richText.indexOf(START_TAG);
      var textNode = index < 0 ? richText : richText.substring(0, index);
      parseText(textNode);
      richText = index < 0 ? "" : richText.substring(index);
    }
  }

  return convert(content, styleMap);
}

/***/ }),
/* 105 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.dialogBorderGenerator = dialogBorderGenerator;
exports.rectBorderGenerator = rectBorderGenerator;
exports.parallelogramBorderGenerator = parallelogramBorderGenerator;
exports.ellipseBorderGenerator = ellipseBorderGenerator;
exports.lineTriangleGenerator = lineTriangleGenerator;

/**
 * 边框Path生成器
 */
var DIRECTION_TOP = "top",
    DIRECTION_LEFT = "left",
    DIRECTION_BOTTOM = "bottom",
    DIRECTION_RIGHT = "right",
    DIRECTION_LEFT_TOP = "left_top",
    DIRECTION_RIGHT_TOP = "right_top",
    DIRECTION_LEFT_BOTTOM = "left_bottom",
    DIRECTION_RIGHT_BOTTOM = "right_bottom";
/**
 * 对话框形边框
 * @param width 边框宽度
 * @param height 边框高度
 * @param direction 提示框所在方向
 * @param borderSize 边框宽度
 * @param borderRadius 圆角大小
 * @param triangleSize 三角大小
 * @param shift 水平方向偏移大小
 * @returns {string} 计算得到的path
 */

function dialogBorderGenerator(width, height, direction, borderSize, borderRadius, triangleSize, shift) {
  if (shift === void 0) {
    shift = 0;
  }

  width += borderSize;
  height += borderSize;
  var r = borderRadius;
  var triangleDirectionMap = {
    "top": "bottom",
    "left": "right",
    "bottom": "top",
    "right": "left"
  };
  var hasTriangle = !!triangleDirectionMap[direction];
  var triangleDirection = hasTriangle && triangleDirectionMap[direction];
  var maxBorderRadius;

  if (hasTriangle) {
    // 圆角，不能大于最小宽高的一半（去掉凸出三角后的宽高）
    var isVertical = direction === "top" || direction === "bottom";
    maxBorderRadius = Math.min(width - (isVertical ? triangleSize * 2 : 0), height - (isVertical ? 0 : triangleSize * 2)) / 2;
  } else {
    maxBorderRadius = Math.min(width, height) / 2;
  }

  if (r > maxBorderRadius) {
    r = maxBorderRadius;
  }

  var endPoints = [[shift, 0], [width, 0], [width - shift, height], [0, height]],
      curvePoints = [[shift, r], [r + shift, 0], [width - r, 0], [width, r], [width - shift, height - r], [width - shift - r, height], [r, height], [0, height - r], [shift, r]]; // 依次连接4个点和四条边

  var path = 'M' + points(curvePoints[0]) + angle(0) + line(0) + angle(1) + line(1) + angle(2) + line(2) + angle(3) + line(3);
  return path;

  function points(arr) {
    return arr.join(',');
  } // 画圆角


  function angle(index) {
    var trianglePosMap = [DIRECTION_RIGHT_BOTTOM, DIRECTION_LEFT_BOTTOM, DIRECTION_LEFT_TOP, DIRECTION_RIGHT_TOP];
    var p1 = endPoints[index],
        p2 = curvePoints[index * 2 + 1]; // 画直角

    if (trianglePosMap[index] === direction) {
      return "L" + points(p1) + "L" + points(p2);
    }

    return 'Q' + points(p1) + ',' + points(p2);
  } // 画边框，对于有三角的那个边，要特殊对待


  function line(index) {
    var trianglePosMap = [DIRECTION_TOP, DIRECTION_RIGHT, DIRECTION_BOTTOM, DIRECTION_LEFT];
    var p1 = curvePoints[index * 2 + 1],
        p2 = curvePoints[index * 2 + 2]; // 存在triangle

    if (trianglePosMap[index] === triangleDirection) {
      // 存在三角的那条边框
      var centerPoints = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
      var centerX = centerPoints[0],
          centerY = centerPoints[1];
      var x1, x2, y1, y2;

      switch (index) {
        case 0:
          x1 = -1;
          y1 = 0;
          x2 = 0;
          y2 = -1;
          break;

        case 1:
          x1 = 0;
          y1 = -1;
          x2 = 1;
          y2 = 0;
          break;

        case 2:
          x1 = 1;
          y1 = 0;
          x2 = 0;
          y2 = 1;
          break;

        case 3:
          x1 = 0;
          y1 = 1;
          x2 = -1;
          y2 = 0;
          break;
      }

      var m1 = [centerX + x1 * triangleSize, centerY + y1 * triangleSize];
      var m2 = [centerX + x2 * triangleSize, centerY + y2 * triangleSize];
      var m3 = [centerX - x1 * triangleSize, centerY - y1 * triangleSize];
      return 'L' + points(m1) + 'L' + points(m2) + 'L' + points(m3) + 'L' + points(p2);
    }

    return 'L' + points(p2);
  }
}
/**
 * 矩形形边框：即三角大小为0的对话框形边框
 * @param width 边框宽度
 * @param height 边框高度
 * @param borderSize 边框宽度
 * @param borderRadius 圆角大小
 * @returns {string} 计算得到的path
 */


function rectBorderGenerator(width, height, borderSize, borderRadius) {
  return dialogBorderGenerator(width, height, 'top', borderSize, borderRadius, 0);
}
/**
 * 平行四边形边框
 * @param width
 * @param height
 * @param borderRadius
 * @param shift
 * @returns {string}
 */


function parallelogramBorderGenerator(width, height, borderRadius, shift) {
  return dialogBorderGenerator(width, height, 'top', 0, borderRadius, 0, shift);
}
/**
 * 椭圆形边框
 * @param width
 * @param height
 * @returns {string}
 */


function ellipseBorderGenerator(width, height) {
  var cx = width / 2,
      cy = height / 2,
      rx = width / 2,
      ry = height / 2;
  return 'M' + (cx - rx) + ' ' + cy + 'a' + rx + ' ' + ry + ' 0 1 0 ' + 2 * rx + ' 0' + 'a' + rx + ' ' + ry + ' 0 1 0 ' + -2 * rx + ' 0' + 'z';
}

function lineTriangleGenerator(width, height, direction) {
  function points(arr) {
    return arr.join(',');
  }

  var trianglePoints;
  var linePoints = [[0, 0], [width, 0], [width, height], [0, height]];
  var linePath = 'M' + points(linePoints[0]) + 'L' + points(linePoints[1]) + 'Z' + 'M' + points(linePoints[2]) + 'L' + points(linePoints[3]) + 'Z';

  switch (direction) {
    case 'right':
      trianglePoints = [[-2, height / 2 - 1], [-3, height / 2], [-2, height / 2 + 1]];
      break;

    case 'left':
      trianglePoints = [[width + 2, height / 2 - 1], [width + 3, height / 2], [width + 2, height / 2 + 1]];
      break;

    case 'bottom':
      trianglePoints = [[width / 2 - 1, -2], [width / 2, -3], [width / 2 + 1, -2]];
      break;

    default:
      trianglePoints = [[width / 2 - 1, height + 2], [width / 2, height + 3], [width / 2 + 1, height + 2]];
      break;
  }

  var trianglePath = 'M' + points(trianglePoints[0]) + 'L' + points(trianglePoints[1]) + 'L' + points(trianglePoints[2]) + 'Z';
  var rectPath = 'M' + points(linePoints[0]) + 'L' + points(linePoints[1]) + 'L' + points(linePoints[2]) + 'L' + points(linePoints[3]) + 'Z';
  return [linePath + trianglePath, rectPath];
}

/***/ }),
/* 106 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _ElementWrapper = _interopRequireWildcard(__webpack_require__(38));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

var SvgElementWrapper = _ElementWrapper["default"].extend({
  imageContent: function (url) {
    this.node().setAttributeNS("http://www.w3.org/1999/xlink", "href", url);
    return this;
  },
  textContent: function (text) {
    this.type === 'div' ? this.node().innerHTML = text : this.node().textContent = text;
    return this;
  },
  attr: function () {
    if (this.type === 'div') {
      this.style.apply(this, arguments);
    } else {
      _DomUtils["default"].attr.apply(null, [this.node()].concat(_BaseUtils["default"].objectToArray(arguments)));
    }

    return this;
  },
  style: function () {
    var styles;

    if (arguments.length === 2) {
      styles = {};
      styles[arguments[0]] = arguments[1];
    } else {
      styles = arguments[0];
    }

    var oldStyles = this.styles,
        newStyles = {},
        elem = this.node(),
        serializedCss = '',
        hasNew = !oldStyles,
        styleName; // convert legacy

    if (styles && styles.color) {
      styles.fill = styles.color;
    }

    if (styles && styles.fill && this.type === 'div') {
      styles.color = styles.fill;
    } // Filter out existing styles to increase performance (#2640)


    if (oldStyles) {
      for (styleName in styles) {
        if (styles[styleName] !== oldStyles[styleName]) {
          newStyles[styleName] = styles[styleName];
          hasNew = true;
        }
      }
    }

    if (hasNew) {
      if (this.type === 'div') {
        // some problems:
        // 1. rotate
        // 2. default, here add 'px' to attributes
        var map = {
          'x': 'left',
          'y': 'top',
          'dx': 'margin-left' // 'dy': 'margin-top'

        };

        for (var name in map) {
          var s;

          if ((s = newStyles[name]) != null) {
            // em or +'px' suffix
            newStyles[map[name]] = /em/gi.test(s) ? s : s + 'px';
            delete newStyles[name];
          }
        }

        if (newStyles['transform']) {
          var trans = (0, _ElementWrapper.transformParser)(newStyles['transform'].replace(/px/gi, ''));

          if (trans.translate) {
            newStyles[(0, _EnvUtils.getTransPrefix)() + 'transform'] = 'translate(' + trans.translate[0] + 'px,' + trans.translate[1] + 'px)';
          }
        }
      } // Merge the new styles with the old ones


      if (oldStyles) {
        styles = _BaseUtils["default"].extend(oldStyles, newStyles);
      }

      this.styles = styles;

      var hyphenate = function (a, b) {
        return '-' + b.toLowerCase();
      };

      for (styleName in styles) {
        serializedCss += styleName.replace(/([A-Z])/g, hyphenate) + ':' + styles[styleName] + ';';
      }

      elem.style.cssText = serializedCss; // todo fireFox下面style会多一个'none'
      // http://stackoverflow.com/questions/15123953/svg-fill-url-behaving-strangely-in-firefox

      if (styles.fill) {
        elem.style.fill = styles.fill;
      }
    }

    return this;
  }
});

var _default = SvgElementWrapper;
exports["default"] = _default;

/***/ }),
/* 107 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _ElementWrapper = _interopRequireDefault(__webpack_require__(38));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var VmlElementWrapper = _ElementWrapper["default"].extend({
  imageContent: function (url) {
    this.style({
      'src': url
    });
    return this;
  },
  textContent: function (text) {
    this.type === 'div' ? this.node().innerHTML = text : this.node().textContent = text;
    return this;
  },
  attr: function () {
    if (this.type === 'div') {
      this.style.apply(this, arguments);
    } else {
      this.renderer.attr(this, arguments);
    }

    return this;
  },
  style: function () {
    var styles;

    if (arguments.length === 2) {
      styles = {};
      styles[arguments[0]] = arguments[1];
    } else {
      styles = arguments[0];
    }

    this.renderer.style(this, styles);
    return this;
  }
});

var _default = VmlElementWrapper;
exports["default"] = _default;

/***/ }),
/* 108 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _enUs = _interopRequireDefault(__webpack_require__(109));

var _jaJp = _interopRequireDefault(__webpack_require__(110));

var _ptPt = _interopRequireDefault(__webpack_require__(111));

var _zhCn = _interopRequireDefault(__webpack_require__(112));

var _zhTw = _interopRequireDefault(__webpack_require__(113));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var _language = {
  'en-us': _enUs["default"],
  'ja-jp': _jaJp["default"],
  'pt-pt': _ptPt["default"],
  'zh-cn': _zhCn["default"],
  'zh-tw': _zhTw["default"]
};

var _default = function _default(name) {
  return _language[name] ? _language[name] : _enUs["default"];
};

exports["default"] = _default;

/***/ }),
/* 109 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _default = {
  ganttLevels: [// 0
  // 2017年 | __上__
  ['yyyy', 'N'], // 1
  // 2017年 | 上
  ['yyyy', 'N'], // 2
  // 2017年 | 一季度
  ['yyyy', 'QQQ'], // 3
  // 2017,上 | 01
  ['N[,]yyyy', 'MMM'], // 4
  // 2017,一季度 | 1月
  ['QQQ[,]yyyy', 'MMM'], // 5
  // 2017,一季度 | 1月
  ['QQQ[,]yyyy', 'MMM'], // 6
  // 2017年1月 | 01周
  ['MMM[,]yyyy', 'www'], // 7
  // 2017年1月2日 | 一...日
  ['d[,]MMM[,]yyyy', 'eee'], // 8
  // 2017年1月 | 1...30
  ['MMM[,]yyyy', 'd'], // 9
  // 1月 | 1...30
  ['MMM', 'd'], // 10
  // 1月1日 | 上午
  ['d[,]MMM', 'a'], // 11
  // 1月1日 | 0~6点
  ['d[,]MMM', 'I'], // 12
  // 1月1日 | 1...24
  ['d[,]MMM', 'HHH'], // 13
  // 上午 | 1...11
  ['a', 'H'], // 14
  // 1 | 1:00 1:30
  ['H', 'H:mm'], // 15
  // 1 | 0 10 20...50
  ['H', 'm'], // 16
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 17
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 18
  // 10:00 | 0 1...29
  ['H:mm', 'm'], // 19
  // 10:10 | 0 1...9
  ['H:mm', 'm'], // 20
  // 10:01 | 0 30
  ['H:mm', 's'], // 21
  // 10:01 | 0 10...50
  ['H:mm', 's']],
  _locale: "en_US",
  startTime: "start",
  finishTime: "finish",
  duration: "duration",
  progress: "progress",
  // 空数据提示
  emptyDataTip: "No data",
  // 工具栏提示
  fullScreenClose: "Close full screen",
  fullScreenOpen: "Full screen",
  menuClose: "Collapse toolbar",
  menuOpen: "Expand toolbar",
  refresh: "Refresh",
  sort: "Sort",
  toImage: "Export to image"
};
exports["default"] = _default;

/***/ }),
/* 110 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by Yuqian on 2017/6/7.
 */
var _default = {
  _locale: 'ja_JP',
  'startTime': '開始時間',
  'finishTime': '終了時間',
  'duration': '続ける時間',
  'progress': '進捗',
  ganttLevels: [// 0
  ['yyyy[年]', 'N'], // 1
  ['yyyy[年]', 'N'], // 2
  ['yyyy[年]', 'QQQ'], // 3
  ['yyyy[、]N', 'MMM'], // 4
  ['yyyy[、]QQQ', 'MMM'], // 5
  ['yyyy[、]QQQ', 'MMM'], // 6
  ['yyyy[年]MM[月]', 'www'], // 7
  ['yyyy[年]MM[月]dd[日]', 'eeeeee'], // 8
  ['yyyy[年]MM[月]', 'd'], // 9
  ['MMM', 'd'], // 10
  ['MM[月]dd[日]', 'a'], // 11
  ['MM[月]dd[日]', 'I'], // 12
  ['MM[月]dd[日]', 'H'], // 13
  // 上午 | 1...11
  ['a', 'H'], // 14
  // 1 | 1:00 1:30
  ['H', 'H:mm'], // 15
  // 1 | 0 10 20...50
  ['H', 'm'], // 16
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 17
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 18
  // 10:00 | 0 1...29
  ['H:mm', 'm'], // 19
  // 10:10 | 0 1...9
  ['H:mm', 'm'], // 20
  // 10:01 | 0 30
  ['H:mm', 's'], // 21
  // 10:01 | 0 10...50
  ['H:mm', 's']],
  // 空数据提示
  emptyDataTip: "タイトルデータは空欄",
  // 工具栏提示
  fullScreenClose: "フルスクリーン表示取り消す",
  fullScreenOpen: "フルスクリーン表示",
  menuClose: "ツールバー隠す",
  menuOpen: "ツールバー展開",
  refresh: "リフレッシュ",
  sort: "ソート",
  toImage: "エクスポート"
};
exports["default"] = _default;

/***/ }),
/* 111 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by shine on 2018/12/7.
 */
var _default = {
  _locale: "pt-PT",
  ganttLevels: [// 0
  // 2017年 | __上__
  ['yyyy', 'N'], // 1
  // 2017年 | 上
  ['yyyy', 'N'], // 2
  // 2017年 | 一季度
  ['yyyy', 'QQQ'], // 3
  // 2017,上 | 01
  ['N[,]yyyy', 'MMM'], // 4
  // 2017,一季度 | 1月
  ['QQQ[,]yyyy', 'MMM'], // 5
  // 2017,一季度 | 1月
  ['QQQ[,]yyyy', 'MMM'], // 6
  // 2017年1月 | 01周
  ['MMM[,]yyyy', 'www'], // 7
  // 2017年1月2日 | 一...日
  ['d[,]MMM[,]yyyy', 'eee'], // 8
  // 2017年1月 | 1...30
  ['MMM[,]yyyy', 'd'], // 9
  // 1月 | 1...30
  ['MMM', 'd'], // 10
  // 1月1日 | 上午
  ['d[,]MMM', 'a'], // 11
  // 1月1日 | 0~6点
  ['d[,]MMM', 'I'], // 12
  // 1月1日 | 1...24
  ['d[,]MMM', 'HHH'], // 13
  // 上午 | 1...11
  ['a', 'H'], // 14
  // 1 | 1:00 1:30
  ['H', 'H:mm'], // 15
  // 1 | 0 10 20...50
  ['H', 'm'], // 16
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 17
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 18
  // 10:00 | 0 1...29
  ['H:mm', 'm'], // 19
  // 10:10 | 0 1...9
  ['H:mm', 'm'], // 20
  // 10:01 | 0 30
  ['H:mm', 's'], // 21
  // 10:01 | 0 10...50
  ['H:mm', 's']],
  startTime: "start",
  finishTime: "finish",
  duration: "duration",
  progress: "progress",
  // 工具栏提示
  fullScreenClose: "Desativar a exibição em tela cheia",
  fullScreenOpen: "Exibição em tela cheia",
  menuClose: "Encolher a barra de ferramentas",
  menuOpen: "Expandir a barra de ferramentas",
  refresh: "Refrescar",
  sort: "Ordenar",
  toImage: "Exportar imagem"
};
exports["default"] = _default;

/***/ }),
/* 112 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by Yuqian on 2017/3/28.
 */
var _default = {
  _locale: 'zh_CN',
  'startTime': '开始',
  'finishTime': '结束',
  'duration': '持续',
  'progress': '进度',
  // used by gantt levelText
  ganttLevels: [// 0
  // 2017年 | __上__
  ['yyyy[年]', 'N'], // 1
  // 2017年 | 上
  ['yyyy[年]', 'N'], // 2
  // 2017年 | 一季度
  ['yyyy[年]', 'QQQ'], // 3
  // 2017,上 | 01
  ['yyyy[,]N', 'MM'], // 4
  // 2017,一季度 | 1月
  ['yyyy[,]QQQ', 'MMM'], // 5
  // 2017,一季度 | 1月
  ['yyyy[,]QQQ', 'MMM'], // 6
  // 2017年1月 | 01周
  ['yyyy[年]MM[月]', 'www'], // 7
  // 2017年1月2日 | 一...日
  ['yyyy[年]MM[月]dd[日]', 'eeeeee'], // 8
  // 2017年1月 | 1...30
  ['yyyy[年]MM[月]', 'd'], // 9
  // 1月 | 1...30
  ['MMM', 'd'], // 10
  // 1月1日 | 上午
  ['MM[月]dd[日]', 'a'], // 11
  // 1月1日 | 0~6点
  ['MM[月]dd[日]', 'I'], // 12
  // 1月1日 | 1...24
  ['MM[月]dd[日]', 'H'], // 13
  // 上午 | 1...11
  ['a', 'H'], // 14
  // 1 | 1:00 1:30
  ['H', 'H:mm'], // 15
  // 1 | 0 10 20...50
  ['H', 'm'], // 16
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 17
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 18
  // 10:00 | 0 1...29
  ['H:mm', 'm'], // 19
  // 10:10 | 0 1...9
  ['H:mm', 'm'], // 20
  // 10:01 | 0 30
  ['H:mm', 's'], // 21
  // 10:01 | 0 10...50
  ['H:mm', 's']],
  emptyDataTip: "数据没有内容",
  // 工具栏提示
  fullScreenClose: "关闭全屏展示",
  fullScreenOpen: "全屏展示",
  menuClose: "收缩工具栏",
  menuOpen: "展开工具栏",
  refresh: "刷新",
  sort: "排序",
  toImage: "导出"
};
exports["default"] = _default;

/***/ }),
/* 113 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _default = {
  _locale: 'zh_TW',
  startTime: '開始',
  finishTime: '結束',
  duration: '持續',
  progress: '進度',
  // used by gantt levelText
  ganttLevels: [// 0
  // 2017年 | __上__
  ['yyyy[年]', 'N'], // 1
  // 2017年 | 上
  ['yyyy[年]', 'N'], // 2
  // 2017年 | 一季度
  ['yyyy[年]', 'QQQ'], // 3
  // 2017,上 | 01
  ['yyyy[,]N', 'MM'], // 4
  // 2017,一季度 | 1月
  ['yyyy[,]QQQ', 'MMM'], // 5
  // 2017,一季度 | 1月
  ['yyyy[,]QQQ', 'MMM'], // 6
  // 2017年1月 | 01周
  ['yyyy[年]MM[月]', 'www'], // 7
  // 2017年1月2日 | 一...日
  ['yyyy[年]MM[月]dd[日]', 'eeeeee'], // 8
  // 2017年1月 | 1...30
  ['yyyy[年]MM[月]', 'd'], // 9
  // 1月 | 1...30
  ['MMM', 'd'], // 10
  // 1月1日 | 上午
  ['MM[月]dd[日]', 'a'], // 11
  // 1月1日 | 0~6点
  ['MM[月]dd[日]', 'I'], // 12
  // 1月1日 | 1...24
  ['MM[月]dd[日]', 'H'], // 13
  // 上午 | 1...11
  ['a', 'H'], // 14
  // 1 | 1:00 1:30
  ['H', 'H:mm'], // 15
  // 1 | 0 10 20...50
  ['H', 'm'], // 16
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 17
  // 10:00 | 0 5...25
  ['H:mm', 'm'], // 18
  // 10:00 | 0 1...29
  ['H:mm', 'm'], // 19
  // 10:10 | 0 1...9
  ['H:mm', 'm'], // 20
  // 10:01 | 0 30
  ['H:mm', 's'], // 21
  // 10:01 | 0 10...50
  ['H:mm', 's']],
  emptyDataTip: "數據沒有內容",
  fullScreenClose: "縮小圖表",
  fullScreenOpen: "放大圖表",
  menuClose: "收縮工具欄",
  menuOpen: "展開工具欄",
  refresh: "重新整理",
  sort: "排序",
  toImage: "匯出"
};
exports["default"] = _default;

/***/ }),
/* 114 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Renderer = _interopRequireDefault(__webpack_require__(56));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _wrapper = _interopRequireDefault(__webpack_require__(37));

var _types = __webpack_require__(45);

var _ElementWrapper = __webpack_require__(38);

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/6/1.
 */
var SvgRenderer = _Renderer["default"].extend({
  type: _types.SVG_RENDERER,
  _initContainer: function () {
    this._container = (0, _wrapper["default"])(this.create('svg'), this);
    this.defs = (0, _wrapper["default"])(this.create('defs'), this).addTo(this._container); //svg的divContainer要单独拿出来

    this._divContainer = this.div().style({
      'white-space': 'nowrap',
      'pointer-events': 'none'
    });
  },
  resize: function () {
    var width = this.vanchart.width,
        height = this.vanchart.height;

    this._container.style({
      width: width + 'px',
      height: height + 'px'
    });
  },
  _update: function () {
    if (this._map && this._map._animatingZoom && this._bounds) {
      return;
    }

    _Renderer["default"].prototype._update.call(this);

    var b = this._bounds,
        size = b.getSize(),
        container = this._container.node(); // set size of svg-container if changed


    if (!this._svgSize || !this._svgSize.equals(size)) {
      this._svgSize = size;
      container.setAttribute('width', size.x);
      container.setAttribute('height', size.y);
    } // movement: update container viewBox so that we don't have to change coordinates of individual layers


    _DomUtils["default"].setPosition(container, b.min);

    if (this._map) {
      container.setAttribute('viewBox', [b.min.x, b.min.y, size.x, size.y].join(' '));
    }

    this.fire('update');
  },
  line: function (attrs) {
    return (0, _wrapper["default"])(this.create('line'), this).attr(attrs);
  },
  rect: function (attrs) {
    return (0, _wrapper["default"])(this.create('rect'), this).attr(attrs);
  },
  circle: function (attrs) {
    return (0, _wrapper["default"])(this.create('circle'), this).attr(attrs);
  },
  path: function (attrs) {
    return (0, _wrapper["default"])(this.create('path'), this).attr(attrs);
  },
  text: function (attrs) {
    return (0, _wrapper["default"])(this.create('text'), this).attr(attrs);
  },
  tspan: function (attrs) {
    return (0, _wrapper["default"])(this.create('tspan'), this).attr(attrs);
  },
  image: function (attrs) {
    return (0, _wrapper["default"])(this.create('image'), this).attr(attrs);
  },
  group: function (attrs) {
    return (0, _wrapper["default"])(this.create('g'), this).attr(attrs);
  },
  mask: function (attrs) {
    return (0, _wrapper["default"])(this.create('mask'), this).attr(attrs);
  },
  colorGradient: function (attrs, stops, type) {
    type = type || 'linearGradient';
    var fillFilter = (0, _wrapper["default"])(this.create(type), this);
    attrs.id = _BaseUtils["default"].stamp(fillFilter);
    fillFilter.attr(attrs); // colorAttr支持两种结构：{'stop-color':color, 'stop-opacity':opacity} && {'stop-color':rgba}

    var colorToHexAlpha = function (colorAttr) {
      if (isNaN(colorAttr['stop-opacity'])) {
        //只需要处理rgba这种
        var formatColor = _ColorUtils["default"].colorToHexAlpha(colorAttr['stop-color']);

        colorAttr['stop-color'] = formatColor.hex;
        colorAttr['stop-opacity'] = formatColor.alpha;
      }

      return colorAttr;
    };

    fillFilter.stops = [];

    for (var i = 0, len = stops.length; i < len; i++) {
      fillFilter.stops[i] = (0, _wrapper["default"])(this.create('stop'), this).attr(colorToHexAlpha(stops[i])).addTo(fillFilter);
    }

    return fillFilter.addTo(this.defs);
  },
  toPatternProperty: function (patternEl) {
    return "url(#" + _BaseUtils["default"].stamp(patternEl) + ")";
  },
  updateColorGradient: function (gradient, attrs, stops) {
    gradient.attr(attrs);

    for (var i = 0, len = stops.length; i < len; i++) {
      gradient.stops[i].attr(stops[i]);
    }
  },
  createClip: function (attrs, type) {
    type = type || 'rect';
    var clip = (0, _wrapper["default"])(this.create('clipPath'), this);
    clip.attr('id', _BaseUtils["default"].stamp(clip));
    clip.setType(type);
    clip[type] = (0, _wrapper["default"])(this.create(type), this).attr(attrs).addTo(clip);
    clip.addTo(this.defs);
    return clip;
  },
  clip: function (elementWrapper, clipWrapper) {
    elementWrapper.attr('clip-path', "url(#" + _BaseUtils["default"].stamp(clipWrapper) + ")");
  },
  updateClip: function (clipWrapper, attrs) {
    if (clipWrapper) {
      clipWrapper[clipWrapper.type].attr(attrs);
    }
  },
  imagePattern: function (patterAttr, imageAttr, url) {
    var pattern = (0, _wrapper["default"])(this.create('pattern'), this);
    patterAttr.id = _BaseUtils["default"].stamp(pattern);
    pattern.attr(patterAttr);
    pattern.image = (0, _wrapper["default"])(this.create('image'), this).addTo(pattern);
    pattern.image.attr(imageAttr);
    pattern.image.imageContent(url);
    pattern.image._imageUrl = url;
    pattern.addTo(this.defs);
    return pattern;
  },
  updateImagePattern: function (imagePattern, patterAttr, imageAttr, url) {
    imagePattern.attr(patterAttr);
    imagePattern.image.attr(imageAttr); //避免重复请求图片

    if (imagePattern.image._imageUrl != url) {
      imagePattern.image.imageContent(url);
      imagePattern.image._imageUrl = url;
    }
  },
  // 创建外描边滤镜
  createOuterLineFilter: function (color, width) {
    var outerLineFilter = (0, _wrapper["default"])(this.create('filter'), this);
    outerLineFilter.attr({
      'id': _BaseUtils["default"].stamp(outerLineFilter)
    });
    this.updateOuterLineFilter(outerLineFilter, color, width); // 将feMorphology和feFlood叠加，实现为底图上色

    outerLineFilter.feComposite = outerLineFilter.feComposite || (0, _wrapper["default"])(this.create('feComposite'), this).addTo(outerLineFilter);
    outerLineFilter.feComposite.attr({
      "in": 'COLOR',
      'in2': 'DILATED',
      'operator': 'in',
      'result': 'OUTLINE'
    }); // 将原始的shape放到上色后的shape底图上，形成外描边效果

    outerLineFilter.feMerge = outerLineFilter.feMerge || (0, _wrapper["default"])(this.create('feMerge'), this).addTo(outerLineFilter);
    outerLineFilter.feMerge.feMergeNode_OuterLine = outerLineFilter.feMerge.feMergeNode_OuterLine || (0, _wrapper["default"])(this.create('feMergeNode'), this).addTo(outerLineFilter.feMerge);
    outerLineFilter.feMerge.feMergeNode_SourceGraphic = outerLineFilter.feMerge.feMergeNode_SourceGraphic || (0, _wrapper["default"])(this.create('feMergeNode'), this).addTo(outerLineFilter.feMerge);
    outerLineFilter.feMerge.feMergeNode_OuterLine.attr({
      'in': 'OUTLINE'
    });
    outerLineFilter.feMerge.feMergeNode_SourceGraphic.attr({
      'in': 'SourceGraphic'
    });
    outerLineFilter.addTo(this.defs);
    return outerLineFilter;
  },
  updateOuterLineFilter: function (outerLineFilter, color, width) {
    var colorToHexAlpha = _ColorUtils["default"].colorToHexAlpha(color); // feMorphology扩展原始的shape，形成底图，底图初始颜色为黑色


    outerLineFilter.feMorphology = outerLineFilter.feMorphology || (0, _wrapper["default"])(this.create('feMorphology'), this).addTo(outerLineFilter);
    outerLineFilter.feMorphology.attr({
      "in": 'SourceAlpha',
      'operator': 'dilate',
      'radius': width,
      'result': 'DILATED'
    }); // feFlood为元素上色

    outerLineFilter.feFlood = outerLineFilter.feFlood || (0, _wrapper["default"])(this.create('feFlood'), this).addTo(outerLineFilter);
    outerLineFilter.feFlood.attr({
      "flood-color": colorToHexAlpha.hex,
      'flood-opacity': colorToHexAlpha.alpha,
      'result': 'COLOR'
    });
  },
  createDropShadowFilter: function (dx, dy, alpha, deviation, r, g, b) {
    r = r || 0;
    g = g || 0;
    b = b || 0;
    var dropFilter = (0, _wrapper["default"])(this.create('filter'), this);

    var id = _BaseUtils["default"].stamp(dropFilter);

    dropFilter.attr({
      'id': id,
      'x': '-50%',
      'y': '-50%',
      'width': '200%',
      'height': '200%'
    });
    this.updateDropShadowFilter(dropFilter, dx, dy, alpha, deviation, r, g, b);
    dropFilter.feBlend = dropFilter.feBlend || (0, _wrapper["default"])(this.create('feBlend'), this).addTo(dropFilter);
    dropFilter.feBlend.attr({
      "in": 'SourceGraphic',
      'in2': 'blurOut',
      'mode': 'normal'
    });
    dropFilter.addTo(this.defs);
    return dropFilter;
  },
  updateDropShadowFilter: function (dropFilter, dx, dy, alpha, deviation, r, g, b) {
    r = r || 0;
    g = g || 0;
    b = b || 0;
    dropFilter.feOffset = dropFilter.feOffset || (0, _wrapper["default"])(this.create('feOffset'), this).addTo(dropFilter);
    dropFilter.feOffset.attr({
      'in': 'SourceGraphic',
      'dx': dx,
      'dy': dy,
      'result': 'offOut'
    });
    dropFilter.feColorMatrix = dropFilter.feColorMatrix || (0, _wrapper["default"])(this.create('feColorMatrix'), this).addTo(dropFilter);
    dropFilter.feColorMatrix.attr({
      'in': 'offOut',
      'type': 'matrix',
      'values': r + ' 0 0 0 0 0 ' + g + ' 0 0 0 0 0 ' + b + ' 0 0 0 0 0 ' + alpha + ' 0',
      'result': 'matrixOut'
    });
    dropFilter.feGaussianBlur = dropFilter.feGaussianBlur || (0, _wrapper["default"])(this.create('feGaussianBlur'), this).addTo(dropFilter);
    dropFilter.feGaussianBlur.attr({
      'in': 'matrixOut',
      'stdDeviation': deviation,
      'result': 'blurOut'
    });
  },
  createInnerShadowFilter: function (dx, dy, alpha, deviation) {
    var innerFilter = (0, _wrapper["default"])(this.create('filter'), this);

    var id = _BaseUtils["default"].stamp(innerFilter);

    innerFilter.attr({
      'id': id,
      'x': '-50%',
      'y': '-50%',
      'width': '200%',
      'height': '200%'
    });
    innerFilter.feComponentTransfer = innerFilter.feComponentTransfer || (0, _wrapper["default"])(this.create('feComponentTransfer'), this).attr({
      'in': 'SourceAlpha'
    }).addTo(innerFilter);
    innerFilter.feComponentTransfer.feFuncA = innerFilter.feComponentTransfer.feFuncA || (0, _wrapper["default"])(this.create('feFuncA'), this).attr({
      'type': 'table',
      'tableValues': '1 0'
    }).addTo(innerFilter.feComponentTransfer);
    innerFilter.feGaussianBlur = innerFilter.feGaussianBlur || (0, _wrapper["default"])(this.create('feGaussianBlur'), this).addTo(innerFilter);
    innerFilter.feGaussianBlur.attr('stdDeviation', deviation);
    innerFilter.feOffset = innerFilter.feOffset || (0, _wrapper["default"])(this.create('feOffset'), this).addTo(innerFilter);
    innerFilter.feOffset.attr({
      'dx': dx,
      'dy': dy,
      'result': 'offsetblur'
    });
    innerFilter.feFlood = innerFilter.feFlood || (0, _wrapper["default"])(this.create('feFlood'), this).addTo(innerFilter);
    innerFilter.feFlood.attr({
      'flood-color': 'black',
      'flood-opacity': alpha,
      'result': 'color'
    });
    innerFilter.feComposite1 = innerFilter.feComposite1 || (0, _wrapper["default"])(this.create('feComposite'), this).attr({
      'in2': 'offsetblur',
      'operator': 'in'
    }).addTo(innerFilter);
    innerFilter.feComposite2 = innerFilter.feComposite2 || (0, _wrapper["default"])(this.create('feComposite'), this).attr({
      'in2': 'SourceAlpha',
      'operator': 'in'
    }).addTo(innerFilter);
    innerFilter.merge = innerFilter.merge || (0, _wrapper["default"])(this.create('feMerge'), this).addTo(innerFilter);
    innerFilter.merge.feMergeNode1 = innerFilter.merge.feMergeNode1 || (0, _wrapper["default"])(this.create('feMergeNode'), this).attr('in', 'SourceGraphic').addTo(innerFilter.merge);
    innerFilter.merge.feMergeNode2 = innerFilter.merge.feMergeNode2 || (0, _wrapper["default"])(this.create('feMergeNode'), this).addTo(innerFilter.merge);
    innerFilter.addTo(this.defs);
    return innerFilter;
  },
  create: function (name) {
    return document.createElementNS('http://www.w3.org/2000/svg', name);
  },
  // rotate text(div, svg) according to center
  // for less dom operation, set textContent & style first
  // then rotate
  // delayMove for animation
  vRotate: function (domWrapper, deg, delayMove) {
    var trans,
        transform,
        rotateStr,
        dom = domWrapper.node();

    if (domWrapper.type === 'div') {
      transform = domWrapper.styles[(0, _EnvUtils.getTransPrefix)() + 'transform'] || '';

      if (transform) {
        trans = (0, _ElementWrapper.transformParser)(transform.replace(/px/gi, ''));
        transform = '';

        if (trans.translate) {
          transform = 'translate(' + trans.translate[0] + 'px,' + trans.translate[1] + 'px) ';
        }
      }

      rotateStr = 'rotate(' + deg + 'deg)';
      transform += rotateStr;
      var t = (0, _EnvUtils.getTransPrefix)() + 'transform';
      domWrapper.styles[t] = transform;
      dom.style[t] = transform;
    } else {
      // Note 暂时用到vRotate的都是textNode
      var dim = _BaseUtils["default"].getTextBBoxWithRotation(domWrapper, 0);

      var centerX = dim.width / 2; // firefox has no scroll size
      // IE 11 height > text height; result in a wrong position
      // ios设备的文字旋转后会有一点往左偏，因此将旋转中心下移1px，旋转后，接近居中

      var centerY = _Browser["default"].ios ? dim.height / 2 + 1 : dim.height / 2 - 1;
      centerX += +dom.getAttribute('x') || 0;
      centerY += +dom.getAttribute('y') || 0; // centerX += (+dom.getAttribute('x') || 0);
      // centerY += (+dom.getAttribute('y') || 0);

      transform = dom.getAttribute('transform') || '';

      if (transform) {
        trans = (0, _ElementWrapper.transformParser)(transform);
        transform = '';

        if (trans.translate) {
          transform = 'translate(' + trans.translate[0] + ' ' + trans.translate[1] + ') ';
        }
      }

      rotateStr = 'rotate(' + deg + ' ' + centerX + ' ' + centerY + ')';
      transform += rotateStr;

      if (!delayMove) {
        domWrapper.attr('transform', transform);
      }
    }

    domWrapper.rotateStr = rotateStr;
    return this;
  },
  vMiddle: function (domWrapper) {
    if (domWrapper.type === 'div') {
      var dom = domWrapper.node();
      var ow = dom.offsetWidth;
      dom.style.marginLeft = -ow / 2 + 'px';
    } else {
      domWrapper.attr('text-anchor', 'middle');
    }

    return this;
  }
}); //map specific func


SvgRenderer.include({
  getEvents: function () {
    var events = _Renderer["default"].prototype.getEvents.call(this);

    events.zoomstart = this._onZoomStart;
    return events;
  },
  _onZoomStart: function () {
    // Drag-then-pinch interactions might mess up the center and zoom.
    // In this case, the easiest way to prevent this is re-do the renderer
    //   bounds and padding when the zooming starts.
    this._update();
  }
});
var _default = SvgRenderer;
exports["default"] = _default;

/***/ }),
/* 115 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Renderer = _interopRequireDefault(__webpack_require__(56));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Animation = _interopRequireDefault(__webpack_require__(116));

var _canvasShape = _interopRequireDefault(__webpack_require__(73));

var _wrapper = _interopRequireDefault(__webpack_require__(37));

var _types = __webpack_require__(45);

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/6/1.
 */
var count = 0;
var FILTER_SIZE = 2;
var BATCH = 4000;
var BATCH_TIME = 50; // ms

var ARRAY_CONSTRUCTOR = window['Uint8Array'] || window['Array'];

var CanvasRenderer = _Renderer["default"].extend({
  type: _types.CANVAS_RENDERER,
  _initContainer: function () {
    var dom = this.dom;
    var vanchart = this.vanchart;
    var config = this.config;
    var plotBounds = config || vanchart.bounds;
    this.dpr = config && config.dpr || 1;
    this._container = (0, _wrapper["default"])(this._createCanvas(dom, plotBounds), this);
    this.ctx = this._container.node().getContext("2d");
    this.ctx.scale(this.dpr, this.dpr);
    this.elements = [];
    this.ctx.lineCap = "round"; // todo,

    this.resetFilter();
    this.animation = new _Animation["default"]().frame(this.flush.bind(this)); // if (config.frameAlpha) {
    //     this.frameAlpha = config.frameAlpha;
    //     this.backContainer = new ElementWrapper(this._createCanvas(dom, plotBounds, dpr), this);
    //     this.backCtx = this.backContainer.node().getContext("2d");
    //     this.backCtx.scale(dpr, dpr);
    //     this.backCtx.globalCompositeOperation = 'copy';
    //     this.clearAll = this._clearWithAlpha;
    // }

    this._needToPaint = false;
    this._nowFillStyle = null;
    this._nowStrokeStyle = null;
    this._nowLineWidth = null;
    this._nextFillStyle = null;
    this._nextStrokeStyle = null;
    this._nextLineWidth = null;
  },
  resize: function () {
    this._setSize({
      x: this.left,
      y: this.top,
      width: this.vanchart.width,
      height: this.vanchart.height
    }, this._container.node());

    this.ctx.scale(this.dpr, this.dpr);
    this.needFill = this.needStroke = true;
  },
  marker: function (name, s) {
    switch (name) {
      case _Constants["default"].LOCATION:
        return this.iconLocation({
          x: s.x,
          y: s.y,
          size: s.radius * 2,
          fillStyle: s.color
        });

      case _Constants["default"].SQUARE_HOLLOW:
        return this.rect({
          x: s.x - s.radius,
          y: s.y - s.radius,
          width: s.radius * 2,
          height: s.radius * 2,
          fillStyle: null,
          lineWidth: 2,
          strokeStyle: s.color
        });

      case _Constants["default"].SQUARE:
        return this.rect({
          x: s.x - s.radius,
          y: s.y - s.radius,
          width: s.radius * 2,
          height: s.radius * 2,
          fillStyle: s.color
        });

      case _Constants["default"].DIAMOND_HOLLOW:
        return this.diamond({
          x: s.x,
          y: s.y,
          size: s.radius,
          fillStyle: null,
          lineWidth: 2,
          strokeStyle: s.color
        });

      case _Constants["default"].DIAMOND:
        return this.diamond({
          x: s.x,
          y: s.y,
          size: s.radius,
          fillStyle: s.color
        });

      case _Constants["default"].TRIANGLE_HOLLOW:
        return this.triangle({
          x: s.x,
          y: s.y,
          size: s.radius,
          fillStyle: null,
          lineWidth: 2,
          strokeStyle: s.color
        });

      case _Constants["default"].TRIANGLE:
        return this.triangle({
          x: s.x,
          y: s.y,
          size: s.radius,
          fillStyle: s.color
        });

      case _Constants["default"].CIRCLE_HOLLOW:
        return this.circle({
          x: s.x,
          y: s.y,
          r: s.radius,
          fillStyle: null,
          lineWidth: 2,
          strokeStyle: s.color
        });

      default:
      case _Constants["default"].CIRCLE:
        return this.circle({
          x: s.x,
          y: s.y,
          r: s.radius,
          fillStyle: s.color
        });
    }
  },
  _create: function (Shape, style) {
    var el = new Shape(this); // el.point = style; // tmp for hover event

    el.rawElement = el; // tmp for hover event

    this.elements.push(el);
    style && el.setStyle(style);
    return el;
  },
  _setSize: function (plotBounds, canvas) {
    var left = this.left = plotBounds.x,
        top = this.top = plotBounds.y,
        width = this.width = plotBounds.width,
        height = this.height = plotBounds.height,
        dpr = this.dpr;
    canvas.style.position = 'absolute';
    canvas.style.left = left + 'px';
    canvas.style.top = top + 'px';
    canvas.style.width = width + 'px';
    canvas.style.height = height + 'px';
    canvas.width = width * dpr;
    canvas.height = height * dpr;
  },
  _createCanvas: function (dom, plotBounds) {
    var canvas = (0, _EnvUtils.createCanvas)();

    this._setSize(plotBounds, canvas);

    canvas.onselectstart = function () {
      return false;
    };

    canvas.style['-webkit-user-select'] = 'none';
    canvas.style['user-select'] = 'none';
    canvas.style['pointer-events'] = 'none';
    canvas.style['-webkit-touch-callout'] = 'none';
    canvas.style['transform'] = 'translateZ(0)';
    dom.appendChild(canvas); //excanvas

    window.VanCanvasManager && VanCanvasManager.initElement(canvas);
    return canvas;
  },
  shouldFilter: function (x, y) {
    if (x < 0 || this.width < x || y < 0 || this.height < y) {
      ++count;
      return true;
    }

    x = x / FILTER_SIZE | 0;
    y = y / FILTER_SIZE | 0;
    var pos = y * this.width / FILTER_SIZE + x;

    if (this._cache[pos]) {
      ++count;
      return true;
    }

    this._cache[pos] = 1;
    return false;
  },
  resetFilter: function () {
    // console.log('filtered:', count);
    count = 0;
    this._cache = new ARRAY_CONSTRUCTOR(Math.floor(this.width / FILTER_SIZE * this.height / FILTER_SIZE)); // IE下面用Array需要传整数
  },
  flush: function () {
    _BaseUtils["default"].cancelAnimFrame(this._frame);

    this.clearAll();
    var elements = this.elements;
    var len = elements.length;
    var exists = [];

    for (var i = 0; i < len; i++) {
      if (!elements[i].needToRemove) {
        exists.push(elements[i]); // elements[i].drawStyle().draw();
      }
    }

    this.elements = exists; // console.log('to draw:', exists.length);

    this.flushIdx = 0;

    this._adaptFlush();
  },
  _nextBatch: function () {
    if (this.flushIdx < this.elements.length) {
      this._frame = _BaseUtils["default"].requestAnimFrame(this._adaptFlush, this);
    }
  },
  // @deprecated
  _flush: function () {
    // console.time('flush');
    this.ctx.beginPath();
    var elements = this.elements;
    var len = elements.length;
    var i = this.flushIdx;
    var to = Math.min(this.flushIdx + BATCH, len);

    for (; i < to; i++) {
      elements[i].drawStyle().draw();
    }

    this._fillStyle && this.ctx.fill();
    this._strokeStyle && this.ctx.stroke();
    this.flushIdx = i;

    this._nextBatch(); // console.timeEnd('flush');

  },
  _adaptFlush: function () {
    // console.time('flush');
    this._time = +new Date();
    this.ctx.beginPath();
    var elements = this.elements;
    var len = elements.length;
    var i = this.flushIdx - 1;

    while (++i < len) {
      elements[i].drawStyle().draw();

      if (i && !(i % 500)) {
        var t = +new Date();

        if (t - this._time > BATCH_TIME) {
          break;
        }
      }
    }

    this._fill();

    this._stroke();

    this.flushIdx = i;

    this._nextBatch(); // console.timeEnd('flush');

  },
  _clearWithAlpha: function () {
    var width = this.width,
        height = this.height;
    this.backCtx.drawImage(this._container.node(), 0, 0, width, height);
    this.ctx.clearRect(0, 0, width, height);
    var domBack = this.backContainer.node();
    var ctx = this.ctx;
    ctx.save();
    ctx.globalAlpha = this.frameAlpha;
    ctx.drawImage(domBack, 0, 0, width, height);
    ctx.restore();
  },
  clearAll: function () {
    this.ctx.clearRect(0, 0, this.width, this.height);
  },
  beginNewPath: function () {
    if (this._needToPaint) {
      this._fill();

      this._stroke();

      this.ctx.beginPath();
      this._needToPaint = false;
    }
  },
  // 直接拿ctx.fillStyle对比
  // 会因为小数点不一样得到错误的结果
  // 不获取ctx.fillStyle，而获取缓存的_nowFillStyle对比
  // 也不设置ctx.fillStyle，而存入将被读取的_nextFillStyle
  _fill: function () {
    if (this._nowFillStyle) {
      this.ctx.fillStyle = this._nowFillStyle;
      this.ctx.fill();
    }

    this._nowFillStyle = this._nextFillStyle;
  },
  _stroke: function () {
    if (this._nowStrokeStyle) {
      this.ctx.strokeStyle = this._nowStrokeStyle;
      this.ctx.lineWidth = this._nowLineWidth;
      this.ctx.stroke();
    }

    this._nowStrokeStyle = this._nextStrokeStyle;
    this._nowLineWidth = this._nextLineWidth;
  },
  lineWidth: function (lineWidth) {
    // lineWidth: Zero, negative, Infinity and NaN values are ignored.
    if (lineWidth && lineWidth !== this._nowLineWidth) {
      this._nextLineWidth = lineWidth;
      this._needToPaint = true;
    }
  },
  strokeStyle: function (strokeStyle) {
    if (strokeStyle !== this._nowStrokeStyle) {
      this._nextStrokeStyle = strokeStyle;
      this._needToPaint = true;
    }
  },
  fillStyle: function (fillStyle) {
    if (fillStyle !== this._nowFillStyle) {
      this._nextFillStyle = fillStyle;
      this._needToPaint = true;
    }
  },
  remove: function () {
    this.animation.clear();
    this.ctx = null;

    this._container.remove();
  },
  addBubbleSeries: function (series) {
    var ctx = this.ctx;
    ctx.save();

    for (var i = 0, len = series.points.length; i < len; i++) {
      var point = series.points[i];

      if (point.visible && !point.isNull) {
        ctx.fillStyle = point.color;
        ctx.globalAlpha = this.getPointOpacity(point);
        ctx.beginPath();
        ctx.arc(point.posX, point.posY, point.radius, 0, 2 * Math.PI);
        ctx.fill();
      }
    }

    ctx.restore();
  },
  getPointOpacity: function (point) {
    var series = point.series,
        target = series.vanchart.highlightTarget;

    if (target) {
      var key = series.name;
      return key == target || point._rangeItem == target ? 1 : _Constants["default"].HOVER_OPACITY;
    }

    return point.opacity;
  },
  addScatterSeries: function (series) {
    var ctx = this.ctx;
    ctx.save();

    for (var i = 0, len = series.points.length; i < len; i++) {
      var point = series.points[i];

      if (point.visible && !point.isNull) {
        var marker = point.options.marker,
            markerType = marker.symbol;
        var radius = isNaN(marker.radius) ? _Constants["default"].MARKER_RADIUS : marker.radius;
        var color = marker.fillColor || point.color;
        ctx.translate(point.posX, point.posY);
        ctx.fillStyle = color;
        ctx.strokeStyle = color;
        ctx.globalAlpha = this.getPointOpacity(point);

        this._drawMarker(ctx, markerType, radius);

        ctx.translate(-point.posX, -point.posY);
      }
    }

    ctx.restore();
  },
  addSeries: function (series, canvasIndex) {
    if (series.visible) {
      switch (series.type) {
        case _Constants["default"].SCATTER_CHART:
          return this.addScatterSeries(series);

        case _Constants["default"].GANTT_CHART:
          return this.addGanttSeries(series, canvasIndex);

        default:
          return this.addBubbleSeries(series);
      }
    }
  },
  addGanttSeries: function (series, canvasIndex) {
    var render = this;
    var ctx = this.ctx;
    var startX = _Constants["default"].GANTT_CANVAS_WIDTH * canvasIndex;
    var endX = startX + _Constants["default"].GANTT_CANVAS_WIDTH;
    var pointsToDraw = series.getCanvasPointsToDraw(startX, endX);

    var rectBounds = function (rect) {
      var rectEndX = rect.x + rect.width;

      if (rect.x > endX) {
        return {
          x: 0,
          width: 0
        };
      }

      if (rect.x > startX) {
        return {
          x: rect.x % _Constants["default"].GANTT_CANVAS_WIDTH,
          width: rectEndX > endX ? endX - rect.x : rect.width
        };
      }

      return {
        x: 0,
        width: rectEndX > endX ? _Constants["default"].GANTT_CANVAS_WIDTH : rectEndX - startX
      };
    };

    ctx.save();
    pointsToDraw.forEach(function (point) {
      var leftRect = point.leftRect,
          rightRect = point.rightRect;
      var opacity = render.getPointOpacity(point);
      var leftBounds = rectBounds(leftRect);
      var rightBounds = rectBounds(rightRect);
      ctx.fillStyle = point.color;
      ctx.globalAlpha = opacity;
      ctx.fillRect(leftBounds.x, leftRect.y, leftBounds.width, leftRect.height);
      ctx.fillStyle = point.color;
      ctx.globalAlpha = opacity * 0.5;
      ctx.fillRect(rightBounds.x, rightRect.y, rightBounds.width, rightRect.height);
    });
    ctx.restore();
  },
  _drawMarker: function (ctx, markerType, R) {
    if (markerType.indexOf(_Constants["default"].CIRCLE) != -1) {
      ctx.beginPath();
      ctx.arc(0, 0, R, 0, 2 * Math.PI);
    } else if (markerType.indexOf(_Constants["default"].SQUARE) != -1) {
      ctx.beginPath();
      ctx.moveTo(-R, -R);
      ctx.lineTo(R, -R);
      ctx.lineTo(R, R);
      ctx.lineTo(-R, R);
      ctx.closePath();
    } else if (markerType.indexOf(_Constants["default"].DIAMOND) != -1) {
      R = R * 2 / Math.sqrt(2);
      ctx.beginPath();
      ctx.moveTo(-R, 0);
      ctx.lineTo(0, -R);
      ctx.lineTo(R, 0);
      ctx.lineTo(0, R);
      ctx.closePath();
    } else if (markerType.indexOf(_Constants["default"].TRIANGLE) != -1) {
      ctx.beginPath();
      ctx.moveTo(-R, R / Math.sqrt(3));
      ctx.lineTo(0, -(2 * Math.sqrt(3) / 3) * R);
      ctx.lineTo(R, R / Math.sqrt(3));
      ctx.closePath();
    } else {
      ctx.beginPath();
      ctx.arc(0, 0, R, 0, 2 * Math.PI);
    }

    if (markerType.indexOf('hollow') == -1) {
      //满填充
      ctx.fill();
    } else {
      ctx.fillStyle = 'white';
      ctx.lineWidth = 2;
      ctx.fill();
      ctx.stroke();
    }
  },

  /**
   * 根据鼠标位置寻找目标元素
   * @param pos
   * @returns {*}
   */
  findTargetByMousePosition: function (pos) {
    var elements = this.elements,
        len = elements.length,
        el;

    while (el = elements[--len]) {
      if (el.contain(pos)) {
        return el;
      }
    }
  }
});

CanvasRenderer.addShape = function (name, Shape) {
  CanvasRenderer.prototype[name] = function (style) {
    return this._create(Shape, style);
  };
};

for (var name in _canvasShape["default"]) {
  if (_canvasShape["default"].hasOwnProperty(name)) {
    CanvasRenderer.addShape(name, _canvasShape["default"][name]);
  }
}

var _default = CanvasRenderer;
exports["default"] = _default;

/***/ }),
/* 116 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Cut = _interopRequireDefault(__webpack_require__(117));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2016/12/5.
 */
var requestAnimationFrame = _BaseUtils["default"].requestAnimFrame; // targets {Array}

var Animation = function () {
  this._initTime = null;
  this._running = false;
  this._cuts = [];
  this._callback = [];
  this.onframe = null;
  this.onend = null;
};

Animation.prototype = {
  _update: function () {
    var time = new Date().getTime(); // now

    var cuts = this._cuts;
    var len = cuts.length;

    if (!cuts.length) {
      return false;
    } // think: remove before/after step


    for (var i = 0; i < len;) {
      if (cuts[i]._needsRemove) {
        cuts[i] = cuts[len - 1];
        cuts.pop();
        len--;
      } else {
        i++;
      }
    }

    for (var i = 0; i < len; i++) {
      var e = cuts[i].step(time);

      if (e && cuts[i]['on' + e]) {
        this._callback.push(cuts[i]['on' + e]);
      }
    }

    this.onframe && this.onframe();
    var i = -1,
        cb;

    while (cb = this._callback[++i]) {
      cb();
    }

    this._callback = [];
    return true;
  },
  _startLoop: function () {
    var self = this;

    function loop() {
      if (self._running) {
        self._running = self._update();
        requestAnimationFrame(loop);
      }
    }

    requestAnimationFrame(loop);
  },
  frame: function (f) {
    this.onframe = f;
    return this;
  },
  start: function () {
    if (!this._running) {
      this._running = true;

      this._startLoop();
    }

    return this;
  },
  stop: function () {
    this._running = false;
    return this;
  },
  clear: function () {
    this._running = false;
    this._cuts = [];
    return this;
  },
  animate: function (targets) {
    var cut = new _Cut["default"](targets);
    cut.animation = this;

    this._cuts.push(cut);

    this.start();
    return cut;
  }
};
var _default = Animation;
exports["default"] = _default;

/***/ }),
/* 117 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2016/12/7.
 */
var interpolateNumber = function (a, b) {
  return function (pct) {
    return +a + (+b - +a) * pct;
  };
}; // todo, remove or revise


var defaultTweenFun = function (target, key, value) {
  var interpolate = interpolateNumber(target[key], value);
  return function (pct) {
    target[key] = interpolate(pct);
  };
};

var Cut = function (targets) {
  if (!targets) {
    throw 'animation "targets" empty';
  } else if (targets.length == null) {
    this.targets = [targets];
  } else {
    this.targets = targets;
  }

  this._needsRemove = false;
  this._lastSectionTime = null; // a section's time length is a duration

  this._sections = [];
  this.onend = null;
};

Cut.prototype = {
  step: function (time) {
    if (!this._lastSectionTime) {
      this._lastSectionTime = time;
    }

    var t = time - this._lastSectionTime;
    var targets = this.targets;
    var section = this._sections[0];
    var pct = Math.min(t / section.time, 1);

    if (!pct > 0) {
      return;
    }

    if (section.easing) {
      pct = section.easing(pct);
    }

    var tweens = section.tweens;
    var len = targets.length;

    for (var i = 0; i < len; i++) {
      for (var k in tweens) {
        if (!tweens.hasOwnProperty(k)) {
          continue;
        }

        tweens[k][i](pct);
      }
    }

    if (pct === 1) {
      this._lastSectionTime = time;

      this._sections.shift(); // one loop only


      if (this._sections.length === 0) {
        this._needsRemove = true;
        return 'end';
      }
    }
  },
  _fillTweens: function (f) {
    return this.targets.map(function (target, i) {
      return f(target, i);
    });
  },
  // TODO
  // empty loop now,
  // pause the animation
  delay: function (time) {
    this._sections.push({
      time: time,
      tweens: {}
    });

    return this;
  },
  // set section time length
  duration: function (time) {
    this._sections.push({
      time: time,
      tweens: {}
    });

    return this;
  },
  tween: function (key, f) {
    var len = this._sections.length;
    var tweens = this._sections[len - 1].tweens;

    if (typeof f === 'function') {
      tweens[key] = this._fillTweens(f);
    } // todo, remove or revise
    // f is plain value
    else {
        tweens[key] = this._fillTweens(function (target, i) {
          return defaultTweenFun(target, key, f);
        });
      }

    return this;
  },
  attrTween: function (attrKey, f) {
    this.tween('attr' + attrKey, function (target, i) {
      // FIXME, it's not the init value
      var a = +target.getAttribute(attrKey);
      var interpolate = f(target, i, a);
      return function (pct) {
        target.setAttribute(attrKey, interpolate(pct));
      };
    });
    return this;
  },
  attr: function (attrKey, v) {
    this.attrTween(attrKey, function (target, i, a) {
      if (typeof v === 'function') {
        return interpolateNumber(a, v.call(null, target, i, a));
      }

      return interpolateNumber(a, v);
    });
    return this;
  },
  // callback when animation finished
  end: function (f) {
    this.onend = f;
    return this;
  },
  stop: function () {
    this._needsRemove = true;
    return this;
  },
  ease: function (easing) {
    var len = this._sections.length;
    this._sections[len - 1].easing = typeof easing == 'string' ? _BezierEasing["default"].css[easing] : easing;
    return this;
  }
};
var _default = Cut;
exports["default"] = _default;

/***/ }),
/* 118 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractShape = _interopRequireDefault(__webpack_require__(23));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Browser = _interopRequireDefault(__webpack_require__(8));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2016/12/7.
 */
var isTouch = _Browser["default"].touch;
var MIN_HOVER_LINE_WIDTH = isTouch ? 10 : 2;
var DOUBLE_PI = Math.PI * 2;
var max = Math.max;
var atan2 = Math.atan2;
var abs = Math.abs;
var sqrt = Math.sqrt;
var normalRadian = _BaseUtils["default"].normalRadian;

var Arc = _AbstractShape["default"].extend({
  _initialize: function () {
    this.style = {
      x: null,
      y: null,
      r: null,
      startAngle: null,
      endAngle: null,
      lineWidth: null,
      strokeStyle: null,
      // color
      fillStyle: null
    };
  },
  draw: function () {
    var ctx = this.ctx;
    var s = this.style;

    if (!s.lineWidth) {
      return this;
    }

    ctx.moveTo(s.x + s.r * Math.cos(s.startAngle), s.y + s.r * Math.sin(s.startAngle));
    ctx.arc(s.x, s.y, s.r, s.startAngle, s.endAngle);
    return this;
  },
  contain: function (pos) {
    var x = pos.x;
    var y = pos.y;
    var s = this.style;
    var width = max(s.lineWidth, MIN_HOVER_LINE_WIDTH);
    var dx = x - s.x;
    var dy = y - s.y;
    var delta = abs(sqrt(dx * dx + dy * dy) - s.r);

    if (delta > width) {
      return false;
    }

    var th = normalRadian(atan2(dy, dx));
    return (th + DOUBLE_PI - s.startAngle) % DOUBLE_PI <= s.endAngle - s.startAngle;
  }
});

var _default = Arc;
exports["default"] = _default;

/***/ }),
/* 119 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractShape = _interopRequireDefault(__webpack_require__(23));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2016/12/8.
 */
var DOUBLE_PI = 2 * Math.PI;

var Circle = _AbstractShape["default"].extend({
  _initialize: function () {
    this.style = {
      x: null,
      y: null,
      r: null,
      lineWidth: null,
      strokeStyle: null,
      fillStyle: null
    };
  },
  draw: function () {
    var ctx = this.ctx;
    var s = this.style;
    ctx.moveTo(s.r + s.x, s.y);
    ctx.arc(s.x, s.y, s.r, 0, DOUBLE_PI);
    return this;
  },
  contain: function (pos) {
    var x = pos.x;
    var y = pos.y;
    var s = this.style;
    var dx = x - s.x;
    var dy = y - s.y;
    return s.r > Math.sqrt(dx * dx + dy * dy);
  }
});

var _default = Circle;
exports["default"] = _default;

/***/ }),
/* 120 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractShape = _interopRequireDefault(__webpack_require__(23));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var abs = Math.abs;

var Diamond = _AbstractShape["default"].extend({
  _initialize: function () {
    this.style = {
      x: null,
      y: null,
      size: null,
      // marker's R
      lineWidth: null,
      strokeStyle: null,
      fillStyle: null
    };
  },
  draw: function () {
    var ctx = this.ctx;
    var s = this.style;
    var R = s.size * Math.SQRT2;
    var x = s.x,
        y = s.y;
    ctx.moveTo(x - R, y);
    ctx.lineTo(x, y - R);
    ctx.lineTo(x + R, y);
    ctx.lineTo(x, y + R);
    ctx.lineTo(x - R, y);
    return this;
  },
  contain: function (pos) {
    var s = this.style;
    var x = s.x,
        y = s.y;
    var w = (s.size + s.lineWidth / 2) * Math.SQRT2,
        h = w;
    var px = pos.x - x,
        py = pos.y - y;
    return abs(px * h) + abs(py * w) < h * w;
  }
});

var _default = Diamond;
exports["default"] = _default;

/***/ }),
/* 121 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractShape = _interopRequireDefault(__webpack_require__(23));

var _icons = _interopRequireDefault(__webpack_require__(122));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2016/12/22.
 */
var ImageCollection = {};

var ImageShape = _AbstractShape["default"].extend({
  _initialize: function () {
    this.style = {
      url: null,
      x: null,
      // image center x
      y: null,
      // image center y
      width: 0,
      height: 0,
      radian: 0,
      // rotation center is IMAGE's center
      color: '' // for icon

    };
  },
  _load: function () {
    var s = this.style;
    var url = s.url;
    var key = url + s.color;

    if (!ImageCollection[key]) {
      if (_icons["default"].all[url]) {
        ImageCollection[key] = this._loadIcon(url);
      } else {
        ImageCollection[key] = this._loadImage(url);
      }
    }

    this._img = ImageCollection[key];
  },
  _loadImage: function (url) {
    var self = this;
    var img = {
      el: null,
      ready: false
    };
    img.el = new Image();
    img.el.crossOrigin = "Anonymous";

    img.el.onload = function () {
      img.ready = true;
      self.renderer.flush();
    };

    img.el.src = url;
    return img;
  },
  _loadIcon: function (url) {
    var s = this.style;
    var width = s.width;
    var height = s.height;
    var dpr = this.renderer.dpr;
    var canvas = (0, _EnvUtils.createCanvas)(); // document.body.append(canvas);
    // canvas.style.position = 'absolute';
    // canvas.style.right = '100px';
    // canvas.style.top = '100px';
    // canvas.style.background = '#888';
    // canvas.style.border = '1px solid #000';

    canvas.style.width = width + 'px';
    canvas.style.height = height + 'px';
    canvas.width = width * dpr;
    canvas.height = height * dpr;
    var ctx = canvas.getContext("2d");
    ctx.scale(dpr, dpr);
    var fakeRenderer = {
      el: canvas,
      ctx: ctx,
      ready: false
    };

    _icons["default"].render(url, fakeRenderer, s);

    return fakeRenderer;
  },
  setStyle: function (style) {
    for (var prop in this.style) {
      if (style.hasOwnProperty(prop)) {
        this.style[prop] = style[prop];
      }
    }

    !this._img && this._load();
    return this;
  },
  drawStyle: function () {
    return this;
  },
  draw: function () {
    var s = this.style;
    var x = s.x,
        y = s.y,
        width = s.width,
        height = s.height,
        radian = s.radian;

    if (this._img && this._img.ready && x != null && y != null) {
      if (radian) {
        this.ctx.save();
        this.ctx.translate(x, y);
        this.ctx.rotate(radian);
        this.ctx.drawImage(this._img.el, -width / 2, -height / 2, width, height);
        this.ctx.restore();
      } else {
        this.ctx.drawImage(this._img.el, x - width / 2, y - height / 2, width, height);
      }
    }

    return this;
  },
  contain: function (pos) {
    var s = this.style;
    var dx = pos.x - s.x + s.width / 2;
    var dy = pos.y - s.y + s.height / 2; // todo, rotate

    return 0 < dx && dx < s.width && 0 < dy && dy < s.height;
  }
});

var _default = ImageShape;
exports["default"] = _default;

/***/ }),
/* 122 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _index = _interopRequireDefault(__webpack_require__(73));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * make icon shapes as images
 */
var Attrs = ['lineWidth', 'strokeStyle', 'fillStyle'];
var _icons = {};
_icons[_Constants["default"].LOCATION] = 'iconLocation';

function getShape(name) {
  return _index["default"][_icons[name]];
}

function render(name, fakeRenderer, s) {
  var Shape = getShape(name);

  if (!Shape) {
    return;
  }

  var shape = new Shape(fakeRenderer);
  shape.setStyle({
    x: 0,
    y: 0,
    size: s.width,
    fillStyle: s.color
  });
  var ctx = fakeRenderer.ctx;
  var i = -1,
      k;

  while (k = Attrs[++i]) {
    ctx[k] = shape.style[k];
  }

  shape.draw();
  ctx.fill();
  ctx.stroke();
  fakeRenderer.shape = shape;
  fakeRenderer.ready = true;
}

var _default = {
  render: render,
  all: _icons
};
exports["default"] = _default;

/***/ }),
/* 123 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractShape = _interopRequireDefault(__webpack_require__(23));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2017/9/26.
 */
var sin = Math.sin;
var cos = Math.cos;
var asin = Math.asin;

var LineEffect = _AbstractShape["default"].extend({
  _initialize: function () {
    this.style = {
      ox: 0,
      oy: 0,
      startAngle: 0,
      endAngle: 0,
      r: 0,
      d: 0,
      fillStyle: null
    };
  },
  draw: function () {
    var ctx = this.ctx;
    var s = this.style;
    var ox = s.ox,
        oy = s.oy,
        sa = s.startAngle,
        ea = s.endAngle,
        R = s.r,
        d = s.d;
    var al = ea - sa,
        sinAl = sin(al),
        cosAl = cos(al);
    var j0 = R - d,
        // 0 inner
    j1 = R + d,
        // 1 outer
    k0 = j0 * sinAl,
        b0 = j0 * cosAl,
        n0 = b0 - R,
        k1 = j1 * sinAl,
        b1 = j1 * cosAl,
        n1 = b1 - R;
    var cxsa = R * cos(sa) + ox;
    var cysa = R * sin(sa) + oy;
    var cxea = R * cos(ea) + ox;
    var cyea = R * sin(ea) + oy; // too small

    if (k0 < d) {
      return;
    } // outer may exceed


    if (n1 >= 0) {
      ctx.moveTo(cxsa, cysa);
      ctx.arc(cxea, cyea, d, ea, ea + Math.PI); // head

      ctx.lineTo(cxsa, cysa);
      return;
    }

    var r0 = (k0 * k0 + n0 * n0) * 0.5 / -n0;
    var r1 = (k1 * k1 + n1 * n1) * 0.5 / -n1;
    var cosSa = cos(sa),
        sinSa = sin(sa);
    var dr0 = R - r0,
        cx0 = dr0 * cosSa + ox,
        cy0 = dr0 * sinSa + oy,
        th0 = asin(k0 / r0),
        ea0 = sa + th0;

    if (ea0 < ea) {
      ea0 = sa + Math.PI - th0;
    }

    var dr1 = R - r1,
        cx1 = dr1 * cosSa + ox,
        cy1 = dr1 * sinSa + oy,
        th1 = asin(k1 / r1),
        ea1 = sa + th1; // if (ea1 > ea) {
    //     console.error('outer err');
    // }

    ctx.moveTo(cxsa, cysa);
    ctx.arc(cx1, cy1, r1, sa, ea1); // outer

    ctx.arc(cxea, cyea, d, ea, ea + Math.PI); // head

    ctx.arc(cx0, cy0, r0, ea0, sa, true); // inner anti-clockwise

    return this;
  }
});

var _default = LineEffect;
exports["default"] = _default;

/***/ }),
/* 124 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractShape = _interopRequireDefault(__webpack_require__(23));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var Rect = _AbstractShape["default"].extend({
  _initialize: function () {
    this.style = {
      x: null,
      y: null,
      width: null,
      height: null,
      lineWidth: null,
      strokeStyle: null,
      fillStyle: null
    };
  },
  draw: function () {
    var ctx = this.ctx;
    var s = this.style;
    ctx.rect(s.x, s.y, s.width, s.height);
    return this;
  },
  contain: function (pos) {
    var s = this.style;
    var dx = pos.x - s.x;
    var dy = pos.y - s.y;
    return 0 < dx && dx < s.width && 0 < dy && dy < s.height;
  }
});

var _default = Rect;
exports["default"] = _default;

/***/ }),
/* 125 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractShape = _interopRequireDefault(__webpack_require__(23));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var SQRT3 = Math.sqrt(3);

var Triangle = _AbstractShape["default"].extend({
  _initialize: function () {
    this.style = {
      x: null,
      y: null,
      size: null,
      // marker's R
      lineWidth: null,
      strokeStyle: null,
      fillStyle: null
    };
  },
  draw: function () {
    var ctx = this.ctx;
    var s = this.style;
    var R = s.size,
        x = s.x,
        y = s.y;
    var d = R / SQRT3;
    ctx.moveTo(x - R, y + d);
    ctx.lineTo(x, y - 2 * d);
    ctx.lineTo(x + R, y + d);
    ctx.lineTo(x - R, y + d);
    return this;
  },
  contain: function (pos) {
    var s = this.style;
    var R = s.size + s.lineWidth / 2,
        x = s.x,
        y = s.y;
    var d = R / SQRT3;
    var ax = x - R,
        ay = y + d,
        bx = x + R,
        by = y + d,
        cx = x,
        cy = y - 2 * d;
    var px = pos.x,
        py = pos.y;
    var v0 = [cx - ax, cy - ay];
    var v1 = [bx - ax, by - ay];
    var v2 = [px - ax, py - ay];
    var dot00 = v0[0] * v0[0] + v0[1] * v0[1];
    var dot01 = v0[0] * v1[0] + v0[1] * v1[1];
    var dot02 = v0[0] * v2[0] + v0[1] * v2[1];
    var dot11 = v1[0] * v1[0] + v1[1] * v1[1];
    var dot12 = v1[0] * v2[0] + v1[1] * v2[1];
    var invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
    var u = (dot11 * dot02 - dot01 * dot12) * invDenom;
    var v = (dot00 * dot12 - dot01 * dot02) * invDenom;
    return u >= 0 && v >= 0 && u + v < 1;
  }
});

var _default = Triangle;
exports["default"] = _default;

/***/ }),
/* 126 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractShape = _interopRequireDefault(__webpack_require__(23));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function t(num) {
  return +num.toFixed(3);
}

var IconLocation = _AbstractShape["default"].extend({
  _initialize: function () {
    this.style = {
      x: null,
      y: null,
      size: null,
      fillStyle: null,
      // color
      lineWidth: 1,
      strokeStyle: '#ffffff'
    };
  },
  setStyle: function (style) {
    _AbstractShape["default"].prototype.setStyle.apply(this, arguments);

    if (style.size) {
      var f = style.size / 40;
      this.R = 14.5 * f;
      this.r = 5.5 * f;
      this.ix = 20 * f;
      this.iy = this.R + 1;
      this.l = style.size - this.iy;
      this.a = Math.acos(this.R / this.l);
      this.dx = t(this.R * Math.sin(this.a));
      this.dy = t(this.R * Math.cos(this.a));
    }

    return this;
  },
  draw: function () {
    var ctx = this.ctx;
    var s = this.style;
    var x = s.x,
        y = s.y;
    var R = this.R,
        r = this.r,
        ix = this.ix,
        iy = this.iy,
        l = this.l,
        a = this.a,
        dx = this.dx,
        dy = this.dy;

    var _x = x + ix,
        _y = y + iy;

    ctx.moveTo(_x, _y + l);
    ctx.lineTo(_x - dx, _y + dy);
    ctx.arc(_x, _y, R, Math.PI / 2 + a, Math.PI / 2 - a);
    ctx.lineTo(_x, _y + l);
    ctx.moveTo(_x + r, _y);
    ctx.arc(_x, _y, r, Math.PI * 2, 0, true);
    this.renderer.dirty = true;
    return this;
  },
  contain: function (pos) {
    var s = this.style;
    var dx = pos.x - s.x + s.size / 2;
    var dy = pos.y - s.y + s.size / 2;
    return 0 < dx && dx < s.size && 0 < dy && dy < s.size;
  }
});

var _default = IconLocation;
exports["default"] = _default;

/***/ }),
/* 127 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _VanChart = _interopRequireDefault(__webpack_require__(33));

var _VanChartMap = _interopRequireDefault(__webpack_require__(207));

var _VanChartForceBubble = _interopRequireDefault(__webpack_require__(223));

var _VanChartWordCloud = _interopRequireDefault(__webpack_require__(224));

var _VanChartStructure = _interopRequireDefault(__webpack_require__(226));

var _Gantt = _interopRequireDefault(__webpack_require__(227));

var _VanPreprocess = _interopRequireDefault(__webpack_require__(236));

var _VanChartInterface = _interopRequireDefault(__webpack_require__(57));

var _TrendLine = _interopRequireDefault(__webpack_require__(237));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

// import VanChartMapExport from "../../map/VanChartMapExport";
_VanChart["default"].include(_TrendLine["default"]);

_VanChart["default"].include(_VanPreprocess["default"]);

_VanChart["default"].include(_VanChartInterface["default"]);

var _vans = {};
_vans[_Constants["default"].VANCHART] = _VanChart["default"];
_vans[_Constants["default"].POINT_MAP] = _VanChartMap["default"];
_vans[_Constants["default"].AREA_MAP] = _VanChartMap["default"];
_vans[_Constants["default"].LINE_MAP] = _VanChartMap["default"];
_vans[_Constants["default"].HEAT_MAP] = _VanChartMap["default"]; // if(__export__) {
//     _vans[Constants.POINT_MAP] = VanChartMapExport;
//     _vans[Constants.AREA_MAP] = VanChartMapExport;
//     _vans[Constants.LINE_MAP] = VanChartMapExport;
//     _vans[Constants.HEAT_MAP] = VanChartMapExport;
// }

_vans[_Constants["default"].FORCE_BUBBLE_CHART] = _VanChartForceBubble["default"];
_vans[_Constants["default"].WORD_CLOUD_CHART] = _VanChartWordCloud["default"];
_vans[_Constants["default"].STRUCTURE_CHART] = _VanChartStructure["default"];
_vans[_Constants["default"].GANTT_CHART] = _Gantt["default"];

var _default = function _default(name) {
  return _vans[name] || _vans[_Constants["default"].VANCHART];
};

exports["default"] = _default;

/***/ }),
/* 128 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _Series = _interopRequireDefault(__webpack_require__(13));

var _component = __webpack_require__(4);

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _GradualColorUtils = __webpack_require__(42);

var _GradualColor = __webpack_require__(31);

var _dataLabelFormatter = _interopRequireDefault(__webpack_require__(24));

var _VanChartLabelBorder = __webpack_require__(36);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/4.
 */
var INIT_ANIMATION_TIME = 1200; //初始（刷新）

var INIT_EASE = _BezierEasing["default"].css["ease-out-cubic"];
var EXIT_ANIMATION_TIME = 150; //点击图例消失

var EXIT_EASE = _BezierEasing["default"].css["ease-in-back"];
var UPDATE_ANIMATION_TIME = 250; //点击图例其他系列更新位置、大小

var UPDATE_EASE = _BezierEasing["default"].custom["ease-out"];
var RE_SHOW_ANIMATION_TIME = 900; //点击图例重新出现

var RE_SHOW_EASE = _BezierEasing["default"].custom["ease-out-quint"];
var STACK_ANIMATION_TIME = 600; //堆积柱形图，点击图例消失、更新、重新出现时间

var STACK_EASE = _BezierEasing["default"].css["ease-out-cubic"]; //堆积柱形图，点击图例消失、更新、重新出现缓动函数

var CHOSEN_TIME = 100;
var CHOSEN_EASE = 'ease-out-in';
var CHOSEN_STROKE_WIDTH = 6;
var CHOSEN_STROKE_OPACITY = 0.35;
var TOOLTIP_GAP = 1;
var LABEL_GAP = 3;
var MIN_BAR_WIDTH = 1;
var MIN_BAR_HEIGHT = 1;

var Bar = _Series["default"].extend({
  doLayout: function () {
    var ow = this.getSeriesOffsetAndWidth();
    var series = this,
        vanchart = series.vanchart;
    var isColumn = series.type == _Constants["default"].COLUMN_CHART,
        inverted = vanchart.isInverted();
    var startKey = 'x',
        stackKey = 'y';

    if (!isColumn) {
      startKey = 'y';
      stackKey = 'x';
    }

    var showAsColumn = isColumn && !inverted || !isColumn && inverted;
    var baseAxis = series[startKey + 'Axis'];
    var stackAxis = series[stackKey + 'Axis'];
    var basePos = stackAxis.getZeroPos();
    var axisLineWith = 0;

    if (baseAxis.isOnZero()) {
      axisLineWith = baseAxis.options.lineWidth;
    }

    var xAxisLineWidth = this.getAxisLineWidth(_component.ComponentCst.X_AXIS_COMPONENT);
    var yAxisLineWidth = this.getAxisLineWidth(_component.ComponentCst.Y_AXIS_COMPONENT);
    this.points.forEach(function (point) {
      var options = point.options;
      var startPos = baseAxis.scale(baseAxis.getAxisValue(options[startKey], point));

      if (isNaN(startPos)) {
        return;
      } // @CHART-1012
      // 对数坐标时。stackPrePos,第一根柱子需要的value是1(即y0),其他上面堆积的柱子需要的是y0 - 1;


      var preValue = options[stackKey + '0'];
      preValue = stackAxis.isLog() && preValue > 1 ? preValue - 1 : preValue;
      var stackPrePos = stackAxis.scale(preValue); // 8.5.0的时候改错的，柱形图计算的时候不需要减去startPosValue，折线图需要
      // 对数坐标时。stackCurrentPos需要的value是 y + y0 - 1;

      var stackCurrentPos = stackAxis.scale(stackAxis.getAxisValue(options[stackKey], point) + options[stackKey + '0'] - (stackAxis.isLog() ? 1 : 0));

      if (stackPrePos === Infinity) {
        stackPrePos = stackAxis.scale.range()[0];
      }

      stackPrePos = _BaseUtils["default"].lineSubPixelOpt(stackPrePos, options.borderWidth);
      var rectX, rectY, rectWidth, rectHeight;
      rectX = startPos + ow.offset - ow.width / 2;
      rectY = Math.min(stackPrePos, stackCurrentPos);
      rectWidth = ow.width;
      rectHeight = Math.abs(stackPrePos - stackCurrentPos); // direction.

      var toBottomRight = rectY === basePos;

      if (toBottomRight) {
        rectY += axisLineWith / 2;
        rectHeight -= axisLineWith / 2;
      } else if (rectY + rectHeight === basePos) {
        rectHeight -= axisLineWith / 2;
      } //当柱子高度小于1时，展示高度为1
      //堆积图，最后一个系列高度小于1时，展示高度为1
      // @CHART-9252 柱形图最小高度考虑轴线宽度影响


      var minHeight = MIN_BAR_HEIGHT + (showAsColumn ? xAxisLineWidth : yAxisLineWidth) / 2; // @CHART-11035, 柱子的生长方向为左上时才需要调整rectY

      rectY = rectHeight > minHeight || toBottomRight ? rectY : rectY + rectHeight - minHeight;
      rectHeight = Math.max(rectHeight, minHeight);
      var rect = {};

      if (showAsColumn) {
        rect.x = rectX;
        rect.y = rectY;
        rect.width = rectWidth;
        rect.height = rectHeight;
      } else {
        rect.x = rectY;
        rect.y = rectX;
        rect.width = rectHeight;
        rect.height = rectWidth;
      }

      point.rect = _BaseUtils["default"].rectSubPixelOpt(rect, options.borderWidth);
      point.rect.rx = point.rect.ry = point.options.borderRadius;

      if (!point.isNull) {
        series._calculateAnimationInitRect(point, isColumn, inverted);
      }
    });
  },
  getSeriesOffsetAndWidth: function () {
    var series = this,
        options = series.options;
    var columnCount = 0,
        stackedMap = {};
    var columnIndex = 0; //start from 0

    var allPointsCount = 0;
    var chartSeries = this.vanchart.seriesOfType(this.type);
    var baseAxisType = this.getBaseAxisType();
    chartSeries.forEach(function (otherSeries) {
      if (otherSeries[baseAxisType] == series[baseAxisType] && otherSeries.visible) {
        if (otherSeries.stack && !stackedMap[otherSeries.stack]) {
          columnCount++;
          stackedMap[otherSeries.stack] = true;

          if (series.stack && series.stack == otherSeries.stack) {
            columnIndex = columnCount - 1;
          }
        } else if (!otherSeries.stack) {
          columnCount++;

          if (series == otherSeries) {
            columnIndex = columnCount - 1;
          }
        }
      }

      if (otherSeries[baseAxisType] == series[baseAxisType]) {
        allPointsCount += otherSeries.points.length;
      }
    });
    var categoryAxis = series[baseAxisType];
    var width = 0,
        offset = 0;

    if (categoryAxis.isCategory()) {
      var categoryGap = options.categoryGap,
          gap = options.gap,
          tickLength = categoryAxis.getTickLength();
      categoryGap = _BaseUtils["default"].getPercentValue(categoryGap, tickLength);
      var seriesGap; // @Cmen:CHART-889

      var defaultWidth = (tickLength - categoryGap) / columnCount; // 默认的系列宽度

      var defaultOffset = categoryGap / 2 + defaultWidth * (columnIndex + 0.5); // 默认的系列中心点位置

      if (parseFloat(gap) >= 0) {
        // 系列不堆叠
        seriesGap = _BaseUtils["default"].getPercentValue(gap, defaultWidth);
        offset = defaultOffset;
        width = defaultWidth - seriesGap;
      } else {
        // 系列堆叠
        seriesGap = Math.abs(_BaseUtils["default"].getPercentValue(gap, tickLength - categoryGap));
        width = (tickLength - categoryGap - seriesGap) / columnCount;
        offset = categoryGap / 2 + width * (columnIndex + 0.5) + seriesGap * 0.5; // 这里系列堆叠时，不需要均匀分布，因此offset直接使用计算的即可

        width += seriesGap;
      }
    } else {
      var rangeLength = categoryAxis._getRange();

      rangeLength = Math.abs(rangeLength[1] - rangeLength[0]);
      width = rangeLength / allPointsCount / 3;
      offset = 0;
    }

    return {
      width: (0, _CoreUtils.hasDefined)(options.width) ? options.width : Math.max(width, MIN_BAR_WIDTH),
      offset: offset
    };
  },
  _getPointKey: function (point) {
    if (this.isMultiCategoryAxisBased()) {
      return _BaseUtils["default"].encodeCategoryArray(point.categoryArray);
    }

    return this.type === _Constants["default"].BAR_CHART ? point.y : point.x;
  },
  getTargetKey: function () {
    return this.type === _Constants["default"].BAR_CHART ? 'x' : 'y';
  },
  //图形坐在的那个坐标轴的key
  getBaseAxisType: function () {
    return this.type === _Constants["default"].COLUMN_CHART ? 'xAxis' : 'yAxis';
  },
  getTrendLineXYValues: function (sery) {
    var xValues = [];
    var yValues = [];
    var points = sery.points;
    var valueAxis = sery.type === _Constants["default"].COLUMN_CHART ? sery.yAxis : sery.xAxis;
    var baseAxis = sery.type === _Constants["default"].COLUMN_CHART ? sery.xAxis : sery.yAxis;
    var isHorizontal = baseAxis.isHorizontal(),
        isAxisReversed = valueAxis.isAxisReversed();
    var bars = [];

    for (var i = 0, len = points.length; i < len; i++) {
      var point = points[i];

      if (!point.isNull && point.rect) {
        bars.push(point.rect);
      }
    }

    bars.sort(function (a, b) {
      return isHorizontal ? a.x - b.x : a.y - b.y;
    });
    bars.forEach(function (barShape) {
      var x, y;

      if (isHorizontal) {
        x = barShape.x + barShape.width / 2;
        y = isAxisReversed ? barShape.y + barShape.height : barShape.y;
      } else {
        x = isAxisReversed ? barShape.x : barShape.x + barShape.width;
        y = barShape.y + barShape.height / 2;
      }

      xValues.push(x);
      yValues.push(y);
    });
    return [xValues, yValues, baseAxis.getPosition(), baseAxis.isAxisReversed()];
  },
  _calculateAnimationInitRect: function (point, isColumn, inverted) {
    var key = isColumn ? 'y' : 'x',
        options = point.options;
    var valueAxis = point.series[key + 'Axis'],
        value = valueAxis.getAxisValue(options[key], point);
    var startPos = valueAxis.getStartPos(),
        isPositive = value >= 0;
    var showAsColumn = isColumn && !inverted || !isColumn && inverted;
    var location, initRect;

    if (showAsColumn) {
      if (isPositive ^ valueAxis.isAxisReversed()) {
        location = _Constants["default"].BOTTOM_TO_TOP;
        initRect = {
          x: point.rect.x,
          y: startPos,
          width: point.rect.width,
          height: 0
        };
      } else {
        location = _Constants["default"].TOP_TO_BOTTOM;
        initRect = {
          x: point.rect.x,
          y: point.rect.y,
          width: point.rect.width,
          height: 0
        };
      }
    } else {
      if (isPositive ^ valueAxis.isAxisReversed()) {
        location = _Constants["default"].LEFT_TO_RIGHT;
        initRect = {
          x: point.rect.x,
          y: point.rect.y,
          width: 0,
          height: point.rect.height
        };
      } else {
        location = _Constants["default"].RIGHT_TO_LEFT;
        initRect = {
          x: point.rect.x + point.rect.width,
          y: point.rect.y,
          width: 0,
          height: point.rect.height
        };
      }
    }

    point.location = location;
    point.initRect = initRect;
  },
  //计算标签的位置
  _calculateLabelPos: function () {
    var series = this;
    series.points.forEach(function (point) {
      if (point.isVisible()) {
        var dataLabels = point.options.dataLabels;

        if (dataLabels && dataLabels.enabled) {
          var align = dataLabels.align !== _Constants["default"].AUTO ? dataLabels.align : series.type === _Constants["default"].BAR_CHART ? _Constants["default"].INSIDE : _Constants["default"].OUTSIDE;
          point.labelPos = series._calculateAlignLabelPos(point, align);
          point.labelAlign = align;
        }
      }
    });
  },
  _calculateAlignLabelPos: function (point, align) {
    var labelDim = point.labelDim,
        rect = point.rect;
    var isVertical = point.location === _Constants["default"].TOP_TO_BOTTOM || point.location === _Constants["default"].BOTTOM_TO_TOP;
    var isPositive = point.location === _Constants["default"].BOTTOM_TO_TOP || point.location === _Constants["default"].LEFT_TO_RIGHT;
    var centerX = rect.x + rect.width / 2,
        centerY = rect.y + rect.height / 2;

    if (!labelDim) {
      return;
    }

    var x, y;

    switch (align) {
      case _Constants["default"].CENTER:
        x = centerX - labelDim.width / 2;
        y = centerY - labelDim.height / 2;
        break;

      case _Constants["default"].INSIDE:
        if (isVertical) {
          x = centerX - labelDim.width / 2;
          y = isPositive ? rect.y + LABEL_GAP : rect.y + rect.height - LABEL_GAP - labelDim.height;
        } else {
          y = centerY - labelDim.height / 2;
          x = isPositive ? rect.x + rect.width - LABEL_GAP - labelDim.width : rect.x + LABEL_GAP;
        }

        break;

      case _Constants["default"].OUTSIDE:
        if (isVertical) {
          x = centerX - labelDim.width / 2;
          y = isPositive ? rect.y - LABEL_GAP - labelDim.height : rect.y + rect.height + LABEL_GAP;
        } else {
          y = centerY - labelDim.height / 2;
          x = isPositive ? rect.x + rect.width + LABEL_GAP : rect.x - LABEL_GAP - labelDim.width;
        }

        break;
    }

    return {
      x: x,
      y: y
    };
  },

  /**
   * 计算MoreLabel的起始位置和朝向：@OverRide Series.calcMoreLabelPosition
   * @param  {[type]} point            [description]
   * @param  {[type]} moreLabelDim [description]
   * @return {{startY: *, startX: *, direction: string}}              [description]
   */
  calcMoreLabelPosition: function (point, moreLabelDim) {
    var isColumn = this.type === _Constants["default"].COLUMN_CHART,
        inverted = this.vanchart.isInverted();
    var chartBounds = this.vanchart.bounds;
    var startX = 0,
        startY = 0,
        direction = "top";

    if (isColumn && !inverted || !isColumn && inverted) {
      startX = point.rect.x + point.rect.width / 2;
      startY = point.rect.y;
    } else {
      startX = point.rect.x + point.rect.width;
      startY = point.rect.y + point.rect.height / 2;
      direction = "right";
    }

    return {
      startX: startX + chartBounds.x,
      startY: startY + chartBounds.y,
      direction: direction
    };
  },
  calculateLabelInfo: function (point) {
    (0, _dataLabelFormatter["default"])(point);
    (0, _VanChartLabelBorder.fixLabelDimWithBorder)(point);
  }
}); //view related


Bar.include({
  _getFixedPos: function (point, divDim) {
    var plotBounds = this.vanchart.bounds;
    var x,
        y,
        rect = point.rect;
    /**
     * CHART-1296
     * 让堆积柱状图与未堆积柱状图的tooltip相对于柱子的位置相同。
     * 下面说的高低左右都是指人肉眼看屏幕的坐标系的方向。
     * BOTTOM_TO_TOP：tooltip的最高边与柱子的最高边平齐，而tooltip的最左边与柱子的最右边平齐。
     * TOP_TO_BOTTOM：tooltip的最高边与柱子的最低边平齐,而tooltip的最左边与柱子的最右边平齐。
     * LEFT_TO_RIGHT：tooltip最高边与柱子的最低边平齐，而tooltip的最右边与柱子的最右边平齐。
     * RIGHT_TO_LEFT：tooltip最高边与柱子的最低边平齐，而tooltip的最右边与柱子的最左边平齐。
     */

    var drawingFlow = this._findMostFarthestStackColumn(point);

    if (point.initRect.height === 0) {
      //柱形图
      x = plotBounds.x + rect.x + rect.width + TOOLTIP_GAP;

      if (point.location === _Constants["default"].BOTTOM_TO_TOP) {
        rect = drawingFlow.BOTTOM_TO_TOP;
        y = plotBounds.y + rect.y;
      } else {
        rect = drawingFlow.TOP_TO_BOTTOM;
        y = plotBounds.y + rect.y + rect.height;
      }
    } else {
      //条形图
      y = plotBounds.y + rect.y + rect.height + TOOLTIP_GAP;

      if (point.location === _Constants["default"].LEFT_TO_RIGHT) {
        rect = drawingFlow.LEFT_TO_RIGHT;
        x = plotBounds.x + rect.x + rect.width - divDim.width;
      } else {
        rect = drawingFlow.RIGHT_TO_LEFT;
        x = plotBounds.x + rect.x - divDim.width;
      }
    }

    return [x, y];
  },

  /**
   * CHART-1296
   * 柱状堆积图显示tooltip的时候需要找到当前可视的所有point中离坐标轴最远的柱子，
   * 然后根据这个最远的柱子来显示tooltip，这样就跟没有堆积的时候tooltip显示规则是一样的。
   * @param point
   * @returns
   * @private
   */
  _findMostFarthestStackColumn: function (point) {
    var rect = point.rect,
        self = this,
        // 因为柱状图有可能从上下左右这个四个方向开始绘制，
    // 所以要对应着四种绘制方向,默认就是point的rect，
    // 是为了防止当前图形不堆叠的情况
    drawingFlow = {
      RIGHT_TO_LEFT: rect,
      LEFT_TO_RIGHT: rect,
      BOTTOM_TO_TOP: rect,
      TOP_TO_BOTTOM: rect
    };
    var visiblePoints = point.points.filter(function (p, index) {
      //CHART-10931 设计器数据形态使用数据字典时 会使得不同实际分类名 拥有相同显示分类名。从而会存在相同分类、系列名有多个点的情况。
      return self.vanchart.series[index] && self.vanchart.series[index].visible && p.rect;
    }); // 如果图形没有堆叠在一起，那么就使用传递进来的point的rect，
    // 否则使用堆叠系列中离坐标轴最远的那一个图形的rect

    if (!this.stack || visiblePoints.length < 2 || !point.isPointSupportTooltipShared()) {
      return drawingFlow;
    } // 将所有可视的points按照point.rect.x进行升序排序


    var ascentByX = visiblePoints.map(function (item) {
      return item;
    }).sort(function (a, b) {
      return a.rect.x - b.rect.x;
    }),
        // 将所有可视的points按照point.rect.y进行升序排序
    ascentByY = visiblePoints.map(function (item) {
      return item;
    }).sort(function (a, b) {
      return a.rect.y - b.rect.y;
    });
    drawingFlow = {
      RIGHT_TO_LEFT: ascentByX.shift().rect,
      LEFT_TO_RIGHT: ascentByX.pop().rect,
      BOTTOM_TO_TOP: ascentByY.shift().rect,
      TOP_TO_BOTTOM: ascentByY.pop().rect
    };
    return drawingFlow;
  },
  getPointGraphicKey: function () {
    return 'rect';
  },
  getFillFilter: function (color, p) {
    if ((0, _EnvUtils.supportFillFilter)()) {
      var series = this;
      var vanchart = series.vanchart;
      var renderer = vanchart.renderer;
      var options = p.options;
      var gradualStyle = options.gradualStyle;

      if (options.image) {
        return this._getImageFill(p, renderer);
      } else if (gradualStyle !== _Constants["default"].STYLE_NORMAL) {
        return this._getGradualColorFill(color, p, renderer);
      }
    }

    return (0, _GradualColor.notSupportGradualColor)(p.options, color);
  },
  _getImageFill: function (p, renderer) {
    var options = p.options,
        rect = p.rect,
        location = p.location;
    var imageX, imageY;

    switch (location) {
      case _Constants["default"].BOTTOM_TO_TOP:
        imageX = rect.x;
        imageY = rect.y + rect.height % options.imageHeight;
        break;

      case _Constants["default"].TOP_TO_BOTTOM:
      case _Constants["default"].LEFT_TO_RIGHT:
        imageX = rect.x;
        imageY = rect.y;
        break;

      case _Constants["default"].RIGHT_TO_LEFT:
        imageX = rect.x + rect.width % options.imageWidth;
        imageY = rect.y;
        break;
    }

    var patterAttr = {
      'x': imageX,
      'y': imageY,
      'width': options.imageWidth,
      'height': options.imageHeight,
      'patternUnits': 'userSpaceOnUse'
    };
    var imageAttr = {
      'x': 0,
      'y': 0,
      'width': options.imageWidth,
      'height': options.imageHeight
    };

    if (!p.imagePattern) {
      p.imagePattern = renderer.imagePattern(patterAttr, imageAttr, p.options.image, p);
    } else {
      renderer.updateImagePattern(p.imagePattern, patterAttr, imageAttr, p.options.image);
    }

    return renderer.toPatternProperty(p.imagePattern);
  },
  _getGradualColorFill: function (color, p, renderer) {
    var options = p.options;
    var gradualStyle = options.gradualStyle,
        gradualColorsOpt = options.gradualColors;
    var gradualColors = gradualStyle === _Constants["default"].STYLE_CUSTOM ? gradualColorsOpt : [color, _ColorUtils["default"].getColorWithDivider(color, 0.9)];
    var stop1 = {
      'offset': '0%',
      'stop-color': gradualColors[0]
    };
    var stop2 = {
      'offset': '100%',
      'stop-color': gradualColors[1]
    };
    var attrs = (0, _GradualColorUtils.gradualLocation)(p.location);

    if (p.colorGradient) {
      renderer.updateColorGradient(p.colorGradient, attrs, [stop1, stop2]);
    } else {
      p.colorGradient = renderer.colorGradient(attrs, [stop1, stop2]);
    }

    return renderer.toPatternProperty(p.colorGradient);
  },
  _calculateAnimationDelay: function () {
    if (this.stack) {
      return 0;
    }

    return this.updateDelay(EXIT_ANIMATION_TIME);
  },
  _getStackExitPointDropRect: function (point) {
    var points = point.getStackPointPreSufPoint(point),
        preP = points.pre,
        sufP = points.suf;

    if (!preP && !sufP) {
      return point.initRect;
    }

    var rect = (preP ? preP : sufP).rect;

    switch (point.location) {
      case _Constants["default"].BOTTOM_TO_TOP:
        return {
          x: rect.x,
          y: preP ? rect.y : rect.y + rect.height,
          width: rect.width,
          height: 0
        };

      case _Constants["default"].TOP_TO_BOTTOM:
        return {
          x: rect.x,
          y: preP ? rect.y + rect.height : rect.y,
          width: rect.width,
          height: 0
        };

      case _Constants["default"].LEFT_TO_RIGHT:
        return {
          x: preP ? rect.x + rect.width : rect.x,
          y: rect.y,
          width: 0,
          height: rect.height
        };

      case _Constants["default"].RIGHT_TO_LEFT:
        return {
          x: preP ? rect.x : rect.x + rect.width,
          y: rect.y,
          width: 0,
          height: rect.height
        };
    }
  },
  _getStackReShowPointInitRect: function (point) {
    var points = point.getStackPointPreSufPoint(point),
        preP = points.pre,
        sufP = points.suf;

    if (!preP && !sufP) {
      return point.initRect;
    }

    var element = (preP ? preP : sufP).graphic.node();
    var x = parseFloat(element.getAttribute("x")),
        y = parseFloat(element.getAttribute("y")),
        width = parseFloat(element.getAttribute("width")),
        height = parseFloat(element.getAttribute("height"));

    switch (point.location) {
      case _Constants["default"].BOTTOM_TO_TOP:
        return {
          x: x,
          y: preP ? y : y + height,
          width: width,
          height: 0
        };

      case _Constants["default"].TOP_TO_BOTTOM:
        return {
          x: x,
          y: preP ? y + height : y,
          width: width,
          height: 0
        };

      case _Constants["default"].LEFT_TO_RIGHT:
        return {
          x: preP ? x + width : x,
          y: y,
          width: 0,
          height: height
        };

      case _Constants["default"].RIGHT_TO_LEFT:
        return {
          x: preP ? x : x + width,
          y: y,
          width: 0,
          height: height
        };
    }
  },
  getPointInitAttr: function (point) {
    return point.initRect;
  },
  getPointReShowAttr: function (point) {
    var series = point.series;
    return series.stack ? series._getStackReShowPointInitRect(point) : point.initRect;
  },
  getPointInitAnimationAttr: function (point) {
    return {
      ease: INIT_EASE,
      duration: INIT_ANIMATION_TIME,
      attr: point.rect
    };
  },
  getPointReShowAnimationAttr: function (point) {
    return point.series.stack ? {
      ease: STACK_EASE,
      duration: STACK_ANIMATION_TIME,
      attr: point.rect
    } : {
      ease: RE_SHOW_EASE,
      duration: RE_SHOW_ANIMATION_TIME,
      attr: point.rect
    };
  },
  getPointUpdateAnimationAttr: function (point, delay) {
    return point.series.stack ? {
      ease: STACK_EASE,
      duration: STACK_ANIMATION_TIME,
      attr: point.rect
    } : {
      delay: delay,
      ease: UPDATE_EASE,
      duration: UPDATE_ANIMATION_TIME,
      attr: point.rect
    };
  },
  getPointDropAnimationAttr: function (point) {
    var series = point.series;
    return series.stack ? {
      ease: STACK_EASE,
      duration: STACK_ANIMATION_TIME,
      attr: series._getStackExitPointDropRect(point)
    } : {
      ease: EXIT_EASE,
      duration: EXIT_ANIMATION_TIME,
      attr: point.initRect
    };
  },
  _onPointMouseOver: function (point) {
    var series = point.series,
        style = series.getHighLightStyle(point);

    series._onState(point, style, true);
  },
  _onPointMouseOut: function (point) {
    var series = point.series,
        style = series.getStyle(point);

    series._onState(point, style, false);
  },
  _onState: function (point, style, isChosen) {
    var series = point.series;
    point.graphic && point.graphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      'duration': CHOSEN_TIME,
      'ease': CHOSEN_EASE,
      'style': style
    });

    if (point.labelAlign === _Constants["default"].OUTSIDE) {
      var diffX = 0,
          diffY = 0;

      if (isChosen) {
        switch (point.location) {
          case _Constants["default"].BOTTOM_TO_TOP:
            diffY -= 3;
            break;

          case _Constants["default"].TOP_TO_BOTTOM:
            diffY += 3;
            break;

          case _Constants["default"].LEFT_TO_RIGHT:
            diffX += 3;
            break;

          case _Constants["default"].RIGHT_TO_LEFT:
            diffX -= 3;
            break;
        }
      }

      series._labelTransformState(point, diffX, diffY, isChosen, CHOSEN_TIME, CHOSEN_EASE);
    } else {
      series._labelFontSizeState(point, isChosen, CHOSEN_TIME, _BezierEasing["default"].css["ease"]);
    }
  },
  effectAnimation: function (point) {
    var options = point.options,
        series = point.series,
        vanchart = series.vanchart,
        renderer = vanchart.renderer;

    if (options.image) {
      return;
    }

    var group = series._getPointEffectGroup(point),
        rect = point.rect;

    var style = {
      'fill': 'none',
      'stroke': point.series.getFillFilter(point.color, point),
      'stroke-opacity': 0,
      'stroke-width': 0
    };
    var width = point.location === _Constants["default"].BOTTOM_TO_TOP || point.location === _Constants["default"].TOP_TO_BOTTOM ? rect.width : rect.height;

    function createEffectG() {
      return renderer.rect().addTo(group).attr(rect).style(style);
    }

    function borderWidth(t) {
      return 0.5 * width * t;
    }

    function getPositiveNumber(num) {
      return num < 0 ? 0 : num;
    }

    function ani(graphic, delay, time) {
      graphic.style(style).effectTransition().delay(delay).ease('linear').duration(time).styleTween('stroke-opacity', function () {
        return function (t) {
          return 0.8 * (1 - t);
        };
      }).styleTween('stroke-width', function () {
        return borderWidth;
      }).attrTween('x', function () {
        return function (t) {
          return rect.x - borderWidth(t) / 2 + 1;
        };
      }).attrTween('y', function () {
        return function (t) {
          return rect.y - borderWidth(t) / 2 + 1;
        };
      }).attrTween('width', function () {
        return function (t) {
          return getPositiveNumber(rect.width + borderWidth(t) - 2);
        };
      }).attrTween('height', function () {
        return function (t) {
          return getPositiveNumber(rect.height + borderWidth(t) - 2);
        };
      });
    }

    var firstG = group.firstG = group.firstG || createEffectG(),
        secondG = group.secondG = group.secondG || createEffectG(),
        thirdG = group.thirdG = group.thirdG || createEffectG();

    var period = series._getEffectTime(point),
        scale = period / series.getDefaultEffectTime();

    ani(firstG, 0, 1600 * scale);
    ani(secondG, 600 * scale, 1600 * scale);
    ani(thirdG, 1200 * scale, 1600 * scale);
  },
  getDefaultEffectTime: function () {
    return 2800;
  },
  getHighLightStyle: function (p) {
    var mouseOverStroke = this._getStrokeMouseOverColor(p);

    var mouseOverColorCondition = p.options.mouseOverColor;
    var mouseOverFill = mouseOverColorCondition || p.series.getFillFilter(p.mouseOverColor, p);
    return {
      'stroke': mouseOverStroke,
      'fill': mouseOverFill,
      'fill-opacity': p.opacity,
      'stroke-width': CHOSEN_STROKE_WIDTH,
      'stroke-opacity': p.opacity === 0 ? 0 : CHOSEN_STROKE_OPACITY
    };
  },
  _getStrokeMouseOverColor: function (p) {
    var options = p.options;
    var mouseOverStrokeCondition = options.mouseOverColor; // 条件属性中的配色为纯色时已经在refreshPointColor中处理过了，
    // 这边只需要判断条件属性中的悬浮颜色是否生效和根据gradualStyle判断使用纯色还是渐变色

    return mouseOverStrokeCondition || (0, _GradualColor.notSupportGradualColor)(options, p.mouseOverColor);
  },
  getPressedStyle: function (p) {
    return {
      'stroke': p.clickColor,
      'fill': p.series.getFillFilter(p.clickColor, p),
      'fill-opacity': p.clickOpacity,
      'stroke-width': CHOSEN_STROKE_WIDTH,
      'stroke-opacity': p.opacity === 0 ? 0 : CHOSEN_STROKE_OPACITY
    };
  },
  getAxisLineWidth: function (name) {
    var axis = this.vanchart.getComponent(name);
    return axis.options[0].lineWidth;
  },
  isSupportVerticalLabel: function () {
    return this.type === _Constants["default"].COLUMN_CHART;
  }
});
var _default = Bar;
exports["default"] = _default;

/***/ }),
/* 129 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isPointMap = isPointMap;

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function isPointMap(type) {
  return type === _Constants["default"].POINT_MAP || type === _Constants["default"].SCATTER_CHART || type === _Constants["default"].BUBBLE_CHART;
}

/***/ }),
/* 130 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.defaultCategoryStyle = defaultCategoryStyle;
exports.defaultValueStyle = defaultValueStyle;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function defaultCategoryStyle(point, dataLabels) {
  // var shadowOpacity = position === Constants.OUTSIDE ? 0.1 : 0.15;
  dataLabels = dataLabels || point.options.dataLabels;
  return dataLabels.style || _BaseUtils["default"].calculateFontSizeWithScale({
    color: point.autoLabelColor(dataLabels),
    fontSize: '0.75rem',
    fontFamily: 'Verdana',
    textShadow: '1px 1px 1px rgba(0,0,0, 0.15)',
    fontWeight: 'bold'
  });
}

function defaultValueStyle(point, dataLabels) {
  dataLabels = dataLabels || point.options.dataLabels;
  return dataLabels.style || _BaseUtils["default"].calculateFontSizeWithScale({
    fontSize: '0.75rem',
    fontFamily: 'Verdana',
    textShadow: '1px 1px 1px rgba(0,0,0,0.15)',
    color: point.autoLabelColor(dataLabels)
  });
}

/***/ }),
/* 131 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Series = _interopRequireDefault(__webpack_require__(13));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _state = __webpack_require__(132);

var _animate = __webpack_require__(133);

var _helper = __webpack_require__(47);

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _CoreUtils = __webpack_require__(3);

var _component = __webpack_require__(4);

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var DEFAULT_EASE = _BezierEasing["default"].css["ease-out-cubic"];
var INIT_TIME = 500;
var LEGEND_DROP = 150;
var LEGEND_UPDATE = 250;
var CHOSEN_TIME = 100;
var CHOSEN_EASE = "ease-out-in";
var CATEGORY_GAP = '20%';
var SERIES_GAP = '20%';
var EDGE_WIDTH = 0.65;
var VALUE_AXIS_GAP = 1 / 3;

var Box = _Series["default"].extend({
  doLayout: function () {
    var series = this;
    var vanchart = series.vanchart;
    var isInverted = vanchart.isInverted();
    var baseAxis = series.xAxis;
    var valueAxis = series.yAxis;

    var _this$getSeriesOffset = this.getSeriesOffsetAndWidth(),
        offset = _this$getSeriesOffset.offset,
        width = _this$getSeriesOffset.width;

    this.points.forEach(function (point) {
      var result = (0, _helper.getBoxDataResult)(point.y, point.options.isDetailed);
      var isDateAxis = baseAxis.type === _component.ComponentCst.DATE_AXIS_COMPONENT;
      var startPos = baseAxis.scale(isDateAxis ? _BaseUtils["default"].date2int(point.x) : point.x);
      point.dataResult = result;

      if (this.isValidPointResult(result)) {
        var props = {
          point: point,
          offset: offset,
          width: width,
          startPos: startPos,
          isInverted: isInverted,
          scale: valueAxis.scale,
          result: result
        };

        series._calculateRectProps(props);

        series._calculateLineProps(props);

        series._calculateMarkerProps(props);

        series._calculateBoxBounds(props);
      }
    }, this);
  },
  getSeriesOffsetAndWidth: function () {
    var baseAxis = this.xAxis;

    if (baseAxis.isCategory()) {
      return this.getCategoryOffsetAndWidth(baseAxis);
    }

    var series = this.vanchart.seriesOfType(this.type);

    var axisRange = baseAxis._getRange();

    var axisSize = Math.abs(axisRange[1] - axisRange[0]);
    var count = 0;
    series.forEach(function (sery) {
      if (sery.points && sery.points.length) {
        count += sery.points.length;
      }
    });
    var average = axisSize / count;
    return {
      width: average * VALUE_AXIS_GAP,
      offset: 0
    };
  },
  getCategoryOffsetAndWidth: function (baseAxis) {
    var series = this.vanchart.seriesOfType(this.type);
    var tickLength = baseAxis.getTickLength();

    var categoryGap = _BaseUtils["default"].getPercentValue(CATEGORY_GAP, tickLength);

    var currentIndex = this.index;
    var count = 0;
    series.forEach(function (sery, index) {
      if (sery.visible) {
        count++;
      }

      if (currentIndex === index) {
        currentIndex = count - 1;
      }
    });
    var seryWidth = (tickLength - categoryGap) / count;
    var seryOffset = categoryGap / 2 + seryWidth * (currentIndex + 0.5);
    seryWidth -= _BaseUtils["default"].getPercentValue(SERIES_GAP, seryWidth) / 2;
    return {
      offset: seryOffset,
      width: seryWidth
    };
  },
  isNullValue: function (point) {
    if (point == null || point.options.y == null) {
      return true;
    }

    return !this.isValidPointValue(point.options.y, point.options.isDetailed);
  },
  isValidPointValue: function (value, isDetailed) {
    if (isDetailed) {
      return _BaseUtils["default"].isArray(value) && value.length;
    }

    return this.isValidPointResult(value);
  },
  isValidPointResult: function (result) {
    if (result == null) {
      return false;
    }

    var max = result.max,
        q3 = result.q3,
        median = result.median,
        q1 = result.q1,
        min = result.min;
    return (0, _CoreUtils.isNumberValue)(max) || (0, _CoreUtils.isNumberValue)(q3) || (0, _CoreUtils.isNumberValue)(median) || (0, _CoreUtils.isNumberValue)(q1) || (0, _CoreUtils.isNumberValue)(min);
  },
  _calculateRectProps: function (props) {
    var point = props.point,
        offset = props.offset,
        width = props.width,
        startPos = props.startPos,
        isInverted = props.isInverted,
        scale = props.scale,
        result = props.result;
    point.initBoxRect = (0, _helper.getBoxInitRect)({
      offset: offset,
      width: width,
      startPos: startPos,
      isInverted: isInverted,
      midPos: scale(result.mid)
    });
    point.boxRect = (0, _helper.getBoxRect)({
      offset: offset,
      width: width,
      startPos: startPos,
      isInverted: isInverted,
      scale: scale,
      result: result
    });
  },
  _calculateLineProps: function (props) {
    var point = props.point,
        offset = props.offset,
        width = props.width,
        startPos = props.startPos,
        isInverted = props.isInverted,
        scale = props.scale,
        result = props.result;
    point.initMaxLine = (0, _helper.getBoxLine)({
      offset: offset,
      startPos: startPos,
      isInverted: isInverted,
      width: width * EDGE_WIDTH,
      valuePos: scale(result.mid)
    });
    point.maxLine = (0, _helper.getBoxLine)({
      offset: offset,
      startPos: startPos,
      isInverted: isInverted,
      width: width * EDGE_WIDTH,
      valuePos: scale(result.max)
    });
    point.initQ3Line = (0, _helper.getBoxLine)({
      offset: offset,
      width: width,
      startPos: startPos,
      isInverted: isInverted,
      valuePos: scale(result.mid)
    });
    point.q3Line = (0, _helper.getBoxLine)({
      offset: offset,
      width: width,
      startPos: startPos,
      isInverted: isInverted,
      valuePos: scale(result.q3)
    });

    if ((0, _CoreUtils.isNumberValue)(result.median)) {
      point.initMedianLine = point.initQ3Line;
      point.medianLine = (0, _helper.getBoxLine)({
        offset: offset,
        width: width,
        startPos: startPos,
        isInverted: isInverted,
        valuePos: scale(result.median)
      });
    }

    point.initQ1Line = point.initQ3Line;
    point.q1Line = (0, _helper.getBoxLine)({
      offset: offset,
      width: width,
      startPos: startPos,
      isInverted: isInverted,
      valuePos: scale(result.q1)
    });
    point.initMinLine = point.initMaxLine;
    point.minLine = (0, _helper.getBoxLine)({
      offset: offset,
      startPos: startPos,
      isInverted: isInverted,
      width: width * EDGE_WIDTH,
      valuePos: scale(result.min)
    });
    point.initQ3MaxLink = (0, _helper.getLinkLine)({
      offset: offset,
      startPos: startPos,
      isInverted: isInverted,
      downPos: scale(result.mid),
      upPos: scale(result.mid)
    });
    point.q3MaxLink = (0, _helper.getLinkLine)({
      offset: offset,
      startPos: startPos,
      isInverted: isInverted,
      downPos: scale(result.q3),
      upPos: scale(result.max)
    });
    point.initQ1MinLink = point.initQ3MaxLink;
    point.q1MinLink = (0, _helper.getLinkLine)({
      offset: offset,
      startPos: startPos,
      isInverted: isInverted,
      downPos: scale(result.min),
      upPos: scale(result.q1)
    });
  },
  _calculateMarkerProps: function (props) {
    var point = props.point,
        offset = props.offset,
        startPos = props.startPos,
        isInverted = props.isInverted,
        scale = props.scale,
        result = props.result;

    if (result == null) {
      return;
    }

    var getMarkerGroup = function (items, isInitState) {
      if (!((0, _CoreUtils.hasDefined)(items) && items.length)) {
        return [];
      }

      var markerGroup = [];

      if (isInverted) {
        items.forEach(function (item) {
          markerGroup.push({
            x: scale(isInitState ? result.mid : item),
            y: startPos + offset
          });
        });
      } else {
        items.forEach(function (item) {
          markerGroup.push({
            x: startPos + offset,
            y: scale(isInitState ? result.mid : item)
          });
        });
      }

      return markerGroup;
    };

    if ((0, _helper.hasValidNormalMarker)(point)) {
      point.normalMarkerGroup = getMarkerGroup(result.normal, false);
    }

    if ((0, _helper.hasValidOutlierMarker)(point)) {
      point.outlierMarkerGroup = getMarkerGroup(result.outlier, false);
    }
  },
  _calculateBoxBounds: function (props) {
    var point = props.point;
    var _this$vanchart$bounds = this.vanchart.bounds,
        x = _this$vanchart$bounds.x,
        y = _this$vanchart$bounds.y;
    var bounds = (0, _helper.getBoxBounds)(props);
    point.bounds = {
      x: x + bounds.x,
      y: y + bounds.y,
      width: bounds.width,
      height: bounds.height
    };

    point.contains = function (containerPoint) {
      return this.bounds && _BaseUtils["default"].containsPoint(this.bounds, containerPoint);
    };
  }
});

Box.include({
  _drawEnterPoints: function (point) {
    var series = this;

    var group = series._getPointGraphicGroup();

    var graphic = point.graphic = series._createPointGraphic(point);

    series._updatePointGraphicStyle(point);

    point.hasEffect() ? graphic.addTo(group) : graphic.addToBack(group);
    (0, _state.pointGraphicInitAttr)(point);
    var config = {
      ease: DEFAULT_EASE,
      duration: INIT_TIME
    };
    (0, _animate.pointGraphicInitAnimate)(point, config);
    series.registerOutlierInteractive(graphic.markerGroup, point);
    series.vanchart.registerInteractiveTarget(point, graphic);
  },
  _drawUpdatePoints: function (point, delay) {
    var config = {
      ease: DEFAULT_EASE,
      delay: delay,
      duration: LEGEND_UPDATE
    },
        series = this;
    (0, _helper.updateMarker)(point);
    series.registerOutlierInteractive(point.graphic.markerGroup, point); // CHART-15801 监控刷新，更新点样式

    series._updatePointGraphicStyle(point);

    (0, _animate.pointGraphicUpdateAnimate)(point, config);
  },
  _drawExitPoints: function (point) {
    var config = {
      ease: DEFAULT_EASE,
      duration: LEGEND_DROP
    };
    (0, _animate.pointGraphicDropAnimate)(point, config);
  },
  _createPointGraphic: function (point) {
    var renderer = this.vanchart.renderer;
    var group = renderer.group();
    group.boxGroup = renderer.group().addTo(group);
    group.markerGroup = renderer.group().addTo(group);

    this._createPointRect(group.boxGroup, point);

    this._createPointLine(group.boxGroup, point);

    this._createPointMarker(group.markerGroup, point);

    return group;
  },
  _createPointRect: function (group) {
    var renderer = this.vanchart.renderer;
    group.boxRect = renderer.rect().addTo(group);
  },
  _createPointLine: function (group) {
    var renderer = this.vanchart.renderer;
    group.maxLine = renderer.line().addTo(group);
    group.q3Line = renderer.line().addTo(group);
    group.medianLine = renderer.line().addTo(group);
    group.q1Line = renderer.line().addTo(group);
    group.minLine = renderer.line().addTo(group);
    group.q3MaxLink = renderer.line().addTo(group);
    group.q1MinLink = renderer.line().addTo(group);
  },
  _createPointMarker: function (group, point) {
    var series = this;
    var _point$options = point.options,
        normalMarker = _point$options.normalMarker,
        outlierMarker = _point$options.outlierMarker;

    if (point.normalMarkerGroup && point.normalMarkerGroup.length) {
      point.normalMarkerGroup.forEach(function (_ref, index) {
        var x = _ref.x,
            y = _ref.y;

        var markerGroup = series._createMarker(normalMarker);

        markerGroup.attr({
          'transform': 'translate(' + x + ',' + y + ') scale(1)'
        });
        group["normalMarker_" + index] = markerGroup.addTo(group);
      });
    }

    if (point.outlierMarkerGroup && point.outlierMarkerGroup.length) {
      point.outlierMarkerGroup.forEach(function (_ref2, index) {
        var x = _ref2.x,
            y = _ref2.y;

        var markerGroup = series._createMarker(outlierMarker);

        markerGroup.attr({
          'transform': 'translate(' + x + ',' + y + ') scale(1)'
        });
        group["outlierMarker_" + index] = markerGroup.addTo(group);
      });
    }
  },
  _getFixedPos: function (point) {
    var plotBounds = this.vanchart.bounds;

    if (point.outlierData == null) {
      var boxBounds = point.boxRect;
      return [plotBounds.x + boxBounds.x + boxBounds.width, plotBounds.y + boxBounds.y];
    }

    var index = point.outlierData.index;

    if (point.outlierMarkerGroup && point.outlierMarkerGroup.length) {
      var pos = point.outlierMarkerGroup[index];
      return [plotBounds.x + pos.x, plotBounds.y + pos.y];
    }
  },
  getStyle: function (point) {
    var options = point.options;
    return {
      'fill': point.color,
      'fill-opacity': point.opacity,
      'stroke': point.borderColor,
      'stroke-opacity': point.borderOpacity,
      'stroke-width': options.borderWidth,
      'filter': 'none'
    };
  },
  getHighLightStyle: function (point) {
    var options = point.options;
    return {
      'fill': point.color,
      'fill-opacity': point.opacity,
      'stroke': point.borderColor,
      'stroke-opacity': point.borderOpacity,
      'stroke-width': options.borderWidth + 1,
      'filter': 'none'
    };
  },
  _onPointMouseOver: function (point) {
    var series = point.series;
    var style = series.getHighLightStyle(point);

    if (point.outlierData == null) {
      (0, _animate.pointBoxGraphicSelectAnimate)(point, {
        'duration': CHOSEN_TIME,
        'ease': CHOSEN_EASE,
        'style': style
      });
      (0, _animate.pointNormalMarkerGraphicSelectAnimate)(point, {
        'duration': CHOSEN_TIME,
        'ease': CHOSEN_EASE
      }, true);
    } else {
      (0, _animate.pointOutlierMarkerGraphicSelectAnimate)(point, {
        'duration': CHOSEN_TIME,
        'ease': CHOSEN_EASE
      }, true);
    }
  },
  _onPointMouseOut: function (point) {
    var series = point.series;
    var style = series.getStyle(point);
    (0, _animate.pointBoxGraphicSelectAnimate)(point, {
      'duration': CHOSEN_TIME,
      'ease': CHOSEN_EASE,
      'style': style
    });
    (0, _animate.pointNormalMarkerGraphicSelectAnimate)(point, {
      'duration': CHOSEN_TIME,
      'ease': CHOSEN_EASE
    }, false);
    (0, _animate.pointOutlierMarkerGraphicSelectAnimate)(point, {
      'duration': CHOSEN_TIME,
      'ease': CHOSEN_EASE
    }, false);
  },
  onPointPress: function () {},
  onPointPressUp: function () {
    var point = this;
    var series = point.series;
    var style = series.getHighLightStyle(point);

    series._updatePointGraphicStyle(point, style);
  },
  _calculateAnimationDelay: function () {
    var series = this;
    return series.updateDelay(LEGEND_DROP);
  },
  _updatePointGraphicStyle: function (point, style) {
    this._updatePointBoxGraphicStyle(point, style);

    this._updatePointMarkerGraphicStyle(point, style);
  },
  _updatePointBoxGraphicStyle: function (point, style) {
    style = style || point.series._getDynamicStyle(point);

    if (point.graphic && point.graphic.boxGroup) {
      var boxGroup = point.graphic.boxGroup;
      var elementGroup = [boxGroup.boxRect, boxGroup.maxLine, boxGroup.q3Line, boxGroup.medianLine, boxGroup.q1Line, boxGroup.minLine, boxGroup.q3MaxLink, boxGroup.q1MinLink];
      elementGroup.forEach(function (element) {
        element && element.style(_BaseUtils["default"].extend({}, style));
      });
    }
  },
  _updateHighLightOpacity: function (point, style) {
    var target = this.vanchart.highlightTarget;

    if (target != null && this.isSupportLegendHighlight()) {
      var key = this.getLegendKey(point);

      if (key === target || point._rangeItem === target) {
        style['fill-opacity'] = point.opacity;
        style['stroke-opacity'] = point.borderOpacity;
      } else {
        style['fill-opacity'] = style['stroke-opacity'] = _Constants["default"].HOVER_OPACITY;
      }
    }
  },
  _updatePointMarkerGraphicStyle: function (point) {
    var series = this;

    if (!(point.graphic && point.graphic.markerGroup)) {
      return;
    }

    var group = point.graphic.markerGroup;
    var _point$options2 = point.options,
        normalMarker = _point$options2.normalMarker,
        outlierMarker = _point$options2.outlierMarker;

    if (point.normalMarkerGroup && point.normalMarkerGroup.length) {
      point.normalMarkerGroup.forEach(function (_, index) {
        var markerGroup = group["normalMarker_" + index];

        series._updateMarker(point, markerGroup, normalMarker);
      });
    }

    if (point.outlierMarkerGroup && point.outlierMarkerGroup.length) {
      point.outlierMarkerGroup.forEach(function (_, index) {
        var markerGroup = group["outlierMarker_" + index];

        series._updateMarker(point, markerGroup, outlierMarker);
      });
    }
  },
  registerOutlierInteractive: function (group, point) {
    var vanchart = this.vanchart;

    if (point.dataResult && point.dataResult.outlier && (0, _helper.hasValidOutlierMarker)(point)) {
      point.dataResult.outlier.forEach(function (value, index) {
        var marker = group["outlierMarker_" + index];
        var target = {
          outlier: value,
          _events: null,
          index: index
        };

        if (marker && marker.image) {
          vanchart._targets[_BaseUtils["default"].stamp(marker.image.node())] = target;
        }

        if (marker && marker.markerPath) {
          vanchart._targets[_BaseUtils["default"].stamp(marker.markerPath.node())] = target;
        }
      });
    }
  },
  getDefaultTooltipFormatter: function () {
    return {
      identifier: "{CATEGORY}{SERIES}{DATA_NUMBER}{DATA_MAX}{DATA_Q3}{DATA_MEDIAN}{DATA_Q1}{DATA_MIN}{DATA_OUTLIER}",
      categoryFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      dataNumberFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      dataMaxFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      dataQ3Format: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      dataMedianFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      dataQ1Format: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      dataMinFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      dataOutlierFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});
var _default = Box;
exports["default"] = _default;

/***/ }),
/* 132 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.pointGraphicInitAttr = pointGraphicInitAttr;

function pointBoxGraphicInitAttr(point) {
  var boxGroup = point.graphic.boxGroup;
  point.initBoxRect && boxGroup.boxRect.attr(point.initBoxRect);
  point.initMaxLine && boxGroup.maxLine.attr(point.initMaxLine);
  point.initQ3Line && boxGroup.q3Line.attr(point.initQ3Line);
  point.initMedianLine && boxGroup.medianLine.attr(point.initMedianLine);
  point.initQ1Line && boxGroup.q1Line.attr(point.initQ1Line);
  point.initMinLine && boxGroup.minLine.attr(point.initMinLine);
  point.initQ3MaxLink && boxGroup.q3MaxLink.attr(point.initQ3MaxLink);
  point.initQ1MinLink && boxGroup.q1MinLink.attr(point.initQ1MinLink);
}

function pointMarkerGraphicInitAttr(point) {
  var markerGroup = point.graphic.markerGroup;

  if (point.normalMarkerGroup && point.normalMarkerGroup.length) {
    point.normalMarkerGroup.forEach(function (_ref, index) {
      var x = _ref.x,
          y = _ref.y;

      if (markerGroup["normalMarker_" + index]) {
        markerGroup["normalMarker_" + index].attr({
          'transform': 'translate(' + x + ',' + y + ') scale(0.01)'
        });
      }
    });
  }

  if (point.outlierMarkerGroup && point.outlierMarkerGroup.length) {
    point.outlierMarkerGroup.forEach(function (_ref2, index) {
      var x = _ref2.x,
          y = _ref2.y;

      if (markerGroup["outlierMarker_" + index]) {
        markerGroup["outlierMarker_" + index].attr({
          'transform': 'translate(' + x + ',' + y + ') scale(0.01)'
        });
      }
    });
  }
}

function pointGraphicInitAttr(point) {
  pointBoxGraphicInitAttr(point);
  pointMarkerGraphicInitAttr(point);
}

/***/ }),
/* 133 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.pointGraphicInitAnimate = pointGraphicInitAnimate;
exports.pointGraphicUpdateAnimate = pointGraphicUpdateAnimate;
exports.pointGraphicDropAnimate = pointGraphicDropAnimate;
exports.pointBoxGraphicSelectAnimate = pointBoxGraphicSelectAnimate;
exports.pointNormalMarkerGraphicSelectAnimate = pointNormalMarkerGraphicSelectAnimate;
exports.pointOutlierMarkerGraphicSelectAnimate = pointOutlierMarkerGraphicSelectAnimate;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _helper = __webpack_require__(47);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var SELECT_MARKER_SCALE = 1.5;

function pointGraphicInitAnimate(point, config) {
  pointBoxGraphicAnimate(point, config);
  pointMarkerGraphicAnimate(point, config);
}

function pointGraphicUpdateAnimate(point, config) {
  pointBoxGraphicAnimate(point, config);
  pointMarkerGraphicAnimate(point, config);
}

function pointGraphicDropAnimate(point, config) {
  var graphic = point.graphic;
  graphic.boxGroup && pointBoxGraphicDropAnimate(point, config);
  graphic.markerGroup && pointMarkerGraphicDropAnimate(point, config);
}

function pointBoxGraphicAnimate(point, config) {
  var boxGroup = point.graphic.boxGroup;
  boxGroup.boxRect.animate(_BaseUtils["default"].extend({
    attr: point.boxRect
  }, config));
  boxGroup.maxLine.animate(_BaseUtils["default"].extend({
    attr: point.maxLine
  }, config));
  boxGroup.q3Line.animate(_BaseUtils["default"].extend({
    attr: point.q3Line
  }, config));
  boxGroup.medianLine.animate(_BaseUtils["default"].extend({
    attr: point.medianLine
  }, config));
  boxGroup.q1Line.animate(_BaseUtils["default"].extend({
    attr: point.q1Line
  }, config));
  boxGroup.minLine.animate(_BaseUtils["default"].extend({
    attr: point.minLine
  }, config));
  boxGroup.q3MaxLink.animate(_BaseUtils["default"].extend({
    attr: point.q3MaxLink
  }, config));
  boxGroup.q1MinLink.animate(_BaseUtils["default"].extend({
    attr: point.q1MinLink
  }, config));
}

function pointMarkerGraphicAnimate(point, config) {
  var markerGroup = point.graphic.markerGroup;

  if (point.normalMarkerGroup && point.normalMarkerGroup.length) {
    point.normalMarkerGroup.forEach(function (_ref, index) {
      var x = _ref.x,
          y = _ref.y;

      if (markerGroup["normalMarker_" + index]) {
        markerGroup["normalMarker_" + index].animate(_BaseUtils["default"].extend({
          attr: {
            'transform': 'translate(' + x + ',' + y + ') scale(1)'
          }
        }, config));
      }
    });
  }

  if (point.outlierMarkerGroup && point.outlierMarkerGroup.length) {
    point.outlierMarkerGroup.forEach(function (_ref2, index) {
      var x = _ref2.x,
          y = _ref2.y;

      if (markerGroup["outlierMarker_" + index]) {
        markerGroup["outlierMarker_" + index].animate(_BaseUtils["default"].extend({
          attr: {
            'transform': 'translate(' + x + ',' + y + ') scale(1)'
          }
        }, config));
      }
    });
  }
}

function pointBoxGraphicDropAnimate(point, config) {
  var graphic = point.graphic;
  var boxGroup = graphic.boxGroup;
  boxGroup.boxRect.animate(_BaseUtils["default"].extend({
    attr: point.initBoxRect
  }, config)).each('end', function () {
    if (point.isVisible()) {
      return;
    } // 消失动画后，只清理rawElement，不删除事件对象


    _DomUtils["default"].remove(boxGroup.boxRect.node());

    _DomUtils["default"].remove(graphic.boxGroup.node());

    _DomUtils["default"].remove(graphic.markerGroup.node());

    _DomUtils["default"].remove(graphic.node());
  });
  boxGroup.maxLine.animate(_BaseUtils["default"].extend({
    attr: point.initMaxLine
  }, config)).remove();
  boxGroup.q3Line.animate(_BaseUtils["default"].extend({
    attr: point.initQ3Line
  }, config)).remove();
  boxGroup.medianLine.animate(_BaseUtils["default"].extend({
    attr: point.initMedianLine
  }, config)).remove();
  boxGroup.q1Line.animate(_BaseUtils["default"].extend({
    attr: point.initQ1Line
  }, config)).remove();
  boxGroup.minLine.animate(_BaseUtils["default"].extend({
    attr: point.initMinLine
  }, config)).remove();
  boxGroup.q3MaxLink.animate(_BaseUtils["default"].extend({
    attr: point.initQ3MaxLink
  }, config)).remove();
  boxGroup.q1MinLink.animate(_BaseUtils["default"].extend({
    attr: point.initQ1MinLink
  }, config)).remove();
}

function pointMarkerGraphicDropAnimate(point, config) {
  var markerGroup = point.graphic.markerGroup;

  if (point.normalMarkerGroup && point.normalMarkerGroup.length) {
    point.normalMarkerGroup.forEach(function (_ref3, index) {
      var x = _ref3.x,
          y = _ref3.y;

      if (markerGroup["normalMarker_" + index]) {
        markerGroup["normalMarker_" + index].animate(_BaseUtils["default"].extend({
          attr: {
            'transform': 'translate(' + x + ',' + y + ') scale(0.01)'
          }
        }, config)).remove();
      }
    });
  }

  if (point.outlierMarkerGroup && point.outlierMarkerGroup.length) {
    point.outlierMarkerGroup.forEach(function (_ref4, index) {
      var x = _ref4.x,
          y = _ref4.y;

      if (markerGroup["outlierMarker_" + index]) {
        markerGroup["outlierMarker_" + index].animate(_BaseUtils["default"].extend({
          attr: {
            'transform': 'translate(' + x + ',' + y + ') scale(0.01)'
          }
        }, config)).remove();
      }
    });
  }
}

function pointBoxGraphicSelectAnimate(point, config) {
  var boxGroup = point.graphic.boxGroup;
  var elementGroup = [boxGroup.boxRect, boxGroup.maxLine, boxGroup.q3Line, boxGroup.medianLine, boxGroup.q1Line, boxGroup.minLine, boxGroup.q3MaxLink, boxGroup.q1MinLink];
  elementGroup.forEach(function (element) {
    if (element) {
      element.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate(config);
    }
  });
}

function pointNormalMarkerGraphicSelectAnimate(point, config, isChosen) {
  var markerGroup = point.graphic.markerGroup;

  if (point.normalMarkerGroup && point.normalMarkerGroup.length) {
    point.normalMarkerGroup.forEach(function (_ref5, index) {
      var x = _ref5.x,
          y = _ref5.y;
      var scale = isChosen ? SELECT_MARKER_SCALE : 1;
      var para = {
        attr: {
          'transform': 'translate(' + x + ',' + y + ') scale(' + scale + ')'
        }
      };

      if (markerGroup["normalMarker_" + index]) {
        markerGroup["normalMarker_" + index].interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate(_BaseUtils["default"].extend(para, config));
      }
    });
  }
}

function pointOutlierMarkerGraphicSelectAnimate(point, config, isChosen) {
  var markerGroup = point.graphic.markerGroup;

  if (point.outlierData && (0, _helper.hasValidOutlierMarker)(point)) {
    var index = point.outlierData.index;
    var scale = isChosen ? SELECT_MARKER_SCALE : 1;
    var pos = point.outlierMarkerGroup[index];
    var para = {
      attr: {
        'transform': 'translate(' + pos.x + ',' + pos.y + ') scale(' + scale + ')'
      }
    };

    if (markerGroup["outlierMarker_" + index]) {
      markerGroup["outlierMarker_" + index].interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate(_BaseUtils["default"].extend(para, config));
    }
  }
}

/***/ }),
/* 134 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _Radar = _interopRequireDefault(__webpack_require__(78));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/8/22.
 */
var STACK_ANIMATION_TIME = 600; //堆积柱形图，点击图例消失、更新、重新出现时间

var STACK_EASE = "cubic-out"; //堆积柱形图，点击图例消失、更新、重新出现缓动函数

var ANIMATION_TIME = 500;
var EASE = 'back-out';
var CHOSEN_TIME = 100;
var CHOSEN_EASE = 'ease-out-in';
var CHOSEN_STROKE_WIDTH = 6;
var CHOSEN_STROKE_OPACITY = 0.35;
var TOP = 'radar-top';
var BOTTOM = 'radar-bottom';
var LEFT = 'radar-left';
var RIGHT = 'radar-right';
var LABEL_BORDER_GAP = 8;

var ColumnRadar = _Radar["default"].extend({
  columnType: true,
  _calcLabelPos: function (point) {
    var position = this.polar.angleAxis._getPolarPosition(point.category);

    var pos = this._getArcPoint(point.outerRadius - LABEL_BORDER_GAP, point.radian);

    var labelDim = point.labelDim;

    switch (position) {
      case TOP:
        point.labelPos = {
          x: -labelDim.width / 2,
          y: pos[1]
        };
        break;

      case RIGHT:
        point.labelPos = {
          x: pos[0] - labelDim.width,
          y: pos[1] - labelDim.height / 2
        };
        break;

      case BOTTOM:
        point.labelPos = {
          x: -labelDim.width / 2,
          y: pos[1] - labelDim.height
        };
        break;

      case LEFT:
        point.labelPos = {
          x: pos[0],
          y: pos[1] - labelDim.height / 2
        };
        break;
    }
  },
  effectAnimation: function (d) {
    _EffectHelper["default"].areaStyleEffectAnimation(d);
  },
  getDefaultEffectTime: function () {
    return _EffectHelper["default"].AREA_STYLE_EFFECT_TIME;
  },
  getStyle: function (p) {
    var borderColor = p.getPointBorderColor(p.borderColor);
    return {
      'fill': p.color,
      'fill-opacity': p.opacity,
      'stroke': borderColor,
      'stroke-width': p.options.borderWidth,
      'stroke-opacity': 1
    };
  },
  getHighLightStyle: function (p) {
    return {
      'stroke': p.mouseOverColor || p.color,
      'fill': p.color,
      'fill-opacity': 1,
      'stroke-width': CHOSEN_STROKE_WIDTH,
      'stroke-opacity': CHOSEN_STROKE_OPACITY
    };
  },
  getPressedStyle: function (p) {
    return {
      'fill': p.clickColor,
      'fill-opacity': p.clickOpacity
    };
  },
  getPointGraphicKey: function () {
    return 'path';
  },
  _getRadarColumnPath: function (innerRadius, radius, radian) {
    var halfSize = this.polar.angleAxis.piece * 0.375;
    var startRadian = radian - halfSize;
    var endRadian = radian + halfSize;

    var arc = _PathGenerator["default"].arc().innerRadius(innerRadius).outerRadius(radius).startAngle(startRadian).endAngle(endRadian);

    return arc();
  },
  getPointInitAnimationAttr: function (point) {
    var series = point.series;
    var innerInterpolate = (0, _interpolator["default"])(point.animateInitRadius, point.innerRadius);
    var outerInterpolate = (0, _interpolator["default"])(point.animateInitRadius, point.outerRadius);
    return series._pointAnimateAttr(EASE, ANIMATION_TIME, point, innerInterpolate, outerInterpolate);
  },
  getPointReShowAnimationAttr: function (point) {
    var series = point.series;
    var points = point.getStackPointPreSufPoint(point),
        preP = points.pre,
        sufP = points.suf;
    var start = point.animateInitRadius;

    if (preP) {
      start = preP._lastOuterRadius_;
    } else if (sufP) {
      start = sufP._lastInnerRadius_;
    }

    var innerInterpolate = (0, _interpolator["default"])(start, point.innerRadius);
    var outerInterpolate = (0, _interpolator["default"])(start, point.outerRadius);
    return series._pointAnimateAttr(STACK_EASE, STACK_ANIMATION_TIME, point, innerInterpolate, outerInterpolate);
  },
  getPointUpdateAnimationAttr: function (point) {
    var series = this; // 现在的设计器里面，会先initChart然后又initPaddingScale，使得initAnimation还没开始就又开始updateAnimation,
    // 接着导致point._lastInnerRadius的值undefined，所以应该有一个默认的值

    var innerInterpolate = (0, _interpolator["default"])(point._lastInnerRadius_ || point.animateInitRadius, point.innerRadius);
    var outerInterpolate = (0, _interpolator["default"])(point._lastOuterRadius_ || point.animateInitRadius, point.outerRadius);
    return series._pointAnimateAttr(STACK_EASE, STACK_ANIMATION_TIME, point, innerInterpolate, outerInterpolate);
  },
  getPointDropAnimationAttr: function (point) {
    var series = this;
    var points = point.getStackPointPreSufPoint(point),
        preP = points.pre,
        sufP = points.suf;
    var end = point.animateInitRadius;

    if (preP) {
      //里面一个
      end = preP.outerRadius;
    } else if (sufP) {
      end = sufP.innerRadius;
    }

    var innerInterpolate = (0, _interpolator["default"])(point.innerRadius, end);
    var outerInterpolate = (0, _interpolator["default"])(point.outerRadius, end);
    return series._pointAnimateAttr(STACK_EASE, STACK_ANIMATION_TIME, point, innerInterpolate, outerInterpolate);
  },
  _pointAnimateAttr: function (ease, duration, point, innerInterpolate, outerInterpolate) {
    var series = point.series;
    return {
      ease: ease,
      duration: duration,
      attrTween: {
        'd': function () {
          return function (t) {
            point._lastInnerRadius_ = innerInterpolate(t);
            point._lastOuterRadius_ = outerInterpolate(t);
            return series._getRadarColumnPath(point._lastInnerRadius_, point._lastOuterRadius_, point.radian);
          };
        }
      }
    };
  },
  _onPointMouseOver: function (point) {
    var series = point.series,
        style = series.getHighLightStyle(point);

    series._onState(point, true, style);
  },
  _onPointMouseOut: function (point) {
    var series = point.series,
        style = series.getStyle(point);

    series._onState(point, false, style);
  },
  _onState: function (point, isChosen, style) {
    var series = point.series;
    point.graphic.animate({
      duration: CHOSEN_TIME,
      ease: CHOSEN_EASE,
      style: style
    });

    series._labelFontSizeState(point, isChosen, CHOSEN_TIME, CHOSEN_EASE);
  },
  _getFixedPos: function (datum, divDim) {
    var centerAngle = datum.radian,
        center = this.getCenter();
    var x = datum.posX + center[0];
    var y = datum.posY + center[1];

    if (centerAngle < Math.PI / 2) {
      y -= divDim.height;
    } else if (centerAngle >= Math.PI && centerAngle < 3 * Math.PI / 2) {
      x -= divDim.width;
    } else if (centerAngle >= 3 * Math.PI / 2 && centerAngle < Math.PI * 2) {
      y -= divDim.height;
      x -= divDim.width;
    }

    return [x, y];
  },

  /**
   * @override Series.calcMoreLabelPosition
   * @param  {[type]} point        [description]
   * @param  {[type]} moreLabelDim [description]
   * @return {[type]}              [description]
   */
  calcMoreLabelPosition: function (point, moreLabelDim) {
    var toCenterRadius = point.innerRadius + (point.outerRadius - point.innerRadius) / 2;

    var pointCenter = this._getArcPoint(toCenterRadius, point.radian),
        chartCenter = this.getCenter();

    var startX = pointCenter[0] + chartCenter[0],
        startY = pointCenter[1] + chartCenter[1];
    return {
      startX: startX,
      startY: startY,
      direction: "top"
    };
  }
});

var _default = ColumnRadar;
exports["default"] = _default;

/***/ }),
/* 135 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Bubble = _interopRequireDefault(__webpack_require__(77));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/8/16.
 */
var ForceBubble = _Bubble["default"].extend({
  _calculateBubblePosition: function () {},
  _getFixedPos: function (datum) {
    var radius = datum.radius || 0;
    var plotBounds = this.vanchart.bounds;
    var x = plotBounds.x + datum.x + radius;
    var y = plotBounds.y + datum.y + radius;
    return [x, y];
  },
  _getAxisTypes: function () {
    return [];
  },
  getTargetKey: function () {
    return 'y';
  },

  /**
   * @override Series.calcMoreLabelPosition
   * @param  {[type]} point [description]
   * @return {[type]}       [description]
   */
  calcMoreLabelPosition: function (point) {
    var chartBounds = this.vanchart.bounds;
    var startX = point.x + chartBounds.x,
        startY = point.y + chartBounds.y;
    return {
      startX: startX,
      startY: startY,
      direction: "top"
    };
  },
  isNullValue: function (point) {
    var options = point.options;
    return options.x == '-' || options.y == '-';
  },
  _getPointKey: function (point) {
    //point.options ? refreshOptions : init
    return '' + (point.options ? point.options.x : point.x);
  },
  effectAnimation: function (d) {
    _EffectHelper["default"].forceBubbleEffectAnimation(d, d);
  },
  getPointInitAttr: function (node) {
    return {
      'r': node.radius,
      'transform': _BaseUtils["default"].makeTranslate({
        x: 0,
        y: 0
      })
    };
  },
  getPointInitAnimationAttr: function (point) {
    return {};
  },
  getPointReShowAnimationAttr: function (point) {
    return {};
  },
  getPointUpdateAnimationAttr: function (point) {
    return {
      'r': point.radius,
      'transform': _BaseUtils["default"].makeTranslate({
        x: point.x,
        y: point.y
      })
    };
  },
  remove: function () {
    this.points.forEach(function (point) {
      if (point.graphic) {
        point.graphic.remove();
        point.graphic = null;
      }
    });
    this.textGraphicGroup && this.textGraphicGroup.remove();
    this.group && this.group.remove();
    this.textGraphicGroup = this._canvas = this.group = null;
  }
});

var _default = ForceBubble;
exports["default"] = _default;

/***/ }),
/* 136 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Series = _interopRequireDefault(__webpack_require__(13));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _dataLabelFormatter = _interopRequireDefault(__webpack_require__(24));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Mitisky on 16/10/10.
 * 所有的xy都是相对绘图区的左上角偏移0.03和0.05倍宽高的值
 */
var WIDTH_GAP = 0.03;
var HEIGHT_GAP = 0.05;
var FUNNEL_CONNECTOR_GAP = 0.03;
var CONNECTOR_LABEL_GAP = 0.05;
var FUNNEL_LABEL_GAP = FUNNEL_CONNECTOR_GAP + CONNECTOR_LABEL_GAP;
var LABEL_MAX_WIDTH = 0.4;
var CHOSEN_STROKE_WIDTH = 6;
var CHOSEN_STROKE_OPACITY = 0.35;
var FUNNEL_SHOW_TIME = 400; //delay

var FUNNEL_INIT_TIME = 400;
var INIT_EASE = _BezierEasing["default"].css["ease-out-quart"];
var FUNNEL_UPDATE_TIME = 500;
var UPDATE_EASE = _BezierEasing["default"].css.swing;
var FUNNEL_RE_SHOW_TIME = 500;
var RE_SHOW_EASE = _BezierEasing["default"].css.swing;
var CHOSEN_EASE = _BezierEasing["default"].css['ease'];
var CHOSEN_TIME = 300;

var Funnel = _Series["default"].extend({
  _getAxisTypes: function () {
    return [];
  },
  //用来计算百分比的指标的名字,相当于value的含义
  getTargetKey: function () {
    return 'value';
  },
  _getPointKey: function (point) {
    return point.name;
  },
  _calculatePercentage: function () {
    var validPoints = this.points.filter(function (point) {
      point._bottomPoint = null; //把最后一个点 点掉，倒数第二个的bottomPoint为null

      return !point.isNull && point.visible;
    });
    var pointCount = validPoints.length;
    var topPoint;
    validPoints.forEach(function (point, i) {
      if (topPoint) {
        topPoint._bottomPoint = point;
        point.percentage = Math.abs(point.value / (topPoint.value || 1));
        point.arrivalRate = Math.abs(point.value / (validPoints[0].value || 1));
      } else {
        point.percentage = point.arrivalRate = 1;
      }

      point.delayTime = FUNNEL_SHOW_TIME * Math.sqrt(i / pointCount);
      topPoint = point;
    });
  },
  //series dolayout的时候在计算label，因为计算label需要用到plotBounds
  calculateLabelInfo: function () {},
  _outSideSpecialLabel: function (point) {
    var content = point.labelContent;
    return content && (content.nameLabelContent || content.valueLabelContent);
  },
  doLayout: function () {
    var funnel = this;
    funnel.points.forEach(function (point) {
      (0, _dataLabelFormatter["default"])(point);
    });

    this._calculatePosAndSize();
  },
  _calculateTotalValue: function (filterFun, valueKey) {
    var totalValue = 0;
    this.points.filter(filterFun).forEach(function (point) {
      totalValue += Math.abs(point[valueKey]);
    });
    return totalValue;
  },
  _calculateSeriesMaxValue: function (filterFun, valueKey) {
    var seriesMaxValue = 0;
    this.points.filter(filterFun).forEach(function (point) {
      seriesMaxValue = Math.max(seriesMaxValue, Math.abs(point[valueKey]));
    });
    return seriesMaxValue;
  },
  //标签的计算逻辑：
  //inside: 和点的位置大小信息一起计算出来
  //outSide:
  // 第一遍循环：计算所有标签占用的宽高。
  // 第二遍循环：计算点的posXY和宽高，同时利用高度得出牵引线是直的还是弯的。
  // 第三遍循环：根据所有标签占用的高和牵引线是否是直的计算出标签位置，并重置标签内容和宽度
  _calculatePosAndSize: function () {
    var funnel = this,
        vanchart = funnel.vanchart,
        plotBounds = vanchart.bounds,
        filterFun = function (point) {
      return !point.isNull && point.visible;
    };

    var valueKey = funnel.getTargetKey();
    var width = plotBounds.width,
        height = plotBounds.height,
        totalWidth = width * (1 - 2 * WIDTH_GAP),
        totalHeight = height * (1 - 2 * HEIGHT_GAP);

    var labelUseSize = funnel._calculateTotalLabelSize();

    totalWidth -= labelUseSize.useWidth > 0 ? labelUseSize.useWidth + plotBounds.width * FUNNEL_LABEL_GAP : 0; //使用弯的牵引线，默认是直线，有重叠才会用弯的

    funnel.useCurveConnectorLine = false;
    var topPoint;
    var validPoints = funnel.points.filter(filterFun);
    var pointCount = validPoints.length;

    if (pointCount < 1) {
      return;
    }

    var firstPoint = validPoints[0],
        lastPoint = validPoints[pointCount - 1],
        firstLabelHeight = firstPoint.labelDim ? firstPoint.labelDim.height : 0,
        lastLabelHeight = lastPoint.labelDim ? lastPoint.labelDim.height : 0;

    if (funnel.options.useSameSlantAngle) {
      // totalValue作为除数不能等于0#CHART-13530
      var totalValue = funnel._calculateTotalValue(filterFun, valueKey) || 1;
      var firstHeight = Math.abs(firstPoint[valueKey]) * totalHeight / totalValue,
          lastHeight = Math.abs(lastPoint[valueKey]) * totalHeight / totalValue;
      var posY = Math.max(0, firstLabelHeight - firstHeight) / 2;
      totalHeight -= posY;
      totalHeight -= Math.max(0, lastLabelHeight - lastHeight) / 2;
      validPoints.forEach(function (point) {
        point.posX = Math.round(posY * totalWidth / 2 / totalHeight);
        point.width = Math.round(totalWidth - point.posX * 2);
        point.posY = Math.round(posY);
        point.height = Math.round(Math.abs(point[valueKey]) * totalHeight / totalValue);
        posY += point.height;

        funnel._calculateInsideLabelPos(point, topPoint);

        topPoint = point;
      });
    } else {
      var seriesMaxValue = funnel._calculateSeriesMaxValue(filterFun, valueKey);

      var unitHeight = totalHeight / pointCount;
      var startY = Math.max(0, firstLabelHeight - unitHeight) / 2;
      totalHeight -= startY;
      totalHeight -= Math.max(0, lastLabelHeight - unitHeight) / 2;
      validPoints.forEach(function (point, i) {
        point.width = Math.round(totalWidth * Math.abs(point[valueKey]) / seriesMaxValue);
        point.posX = Math.round((totalWidth - point.width) / 2);
        point.posY = Math.round(startY + i * unitHeight);
        point.height = Math.round(unitHeight);

        funnel._calculateInsideLabelPos(point, topPoint);

        topPoint = point;
      });
    }

    funnel._calculateOutSideLabelPos(filterFun, labelUseSize.useWidth, labelUseSize.useHeight);
  },
  _calculateInsideLabelPos: function (point, topPoint) {
    var dataLabels = point.options.dataLabels;

    if (dataLabels && dataLabels.enabled) {
      if (dataLabels.align == _Constants["default"].INSIDE) {
        point.labelPos = {
          x: point.posX + point.width / 2 - point.labelDim.width / 2,
          y: point.posY + point.height / 2 - point.labelDim.height / 2
        };
      } else if (topPoint) {
        //两个点的标签有重叠
        this.useCurveConnectorLine = this.useCurveConnectorLine || point.height + topPoint.height < point.labelDim.height + topPoint.labelDim.height;
      }
    }
  },
  _calculateOutSideLabelPos: function (filterFun, labelUseWidth, labelUseHeight) {
    var funnel = this,
        vanchart = funnel.vanchart,
        plotBounds = vanchart.bounds;
    var gap2 = plotBounds.width * CONNECTOR_LABEL_GAP;
    var totalHeight = plotBounds.height * (1 - 2 * HEIGHT_GAP);
    var pointCount = Math.max(1, this.points.filter(filterFun).length - 1);
    var label_label_gap = Math.max(0, (totalHeight - labelUseHeight) / pointCount);
    var startX = plotBounds.width * (1 - 2 * WIDTH_GAP) - labelUseWidth;
    var startY = 0;
    this.points.filter(filterFun).forEach(function (point) {
      var dataLabels = point.options.dataLabels;

      if (dataLabels && dataLabels.enabled && dataLabels.align == _Constants["default"].OUTSIDE && startY < totalHeight) {
        var content = point.labelContent;
        var labelDim = point.labelDim,
            labelHeight = labelDim.height;
        var labelY = funnel.useCurveConnectorLine ? startY : point.posY + point.height / 2 - labelHeight / 2;
        var bottomPoint = point._bottomPoint,
            gapWidth = ((bottomPoint ? bottomPoint.width : 0) - point.width) / 4;
        var endPos = {
          x: startX,
          y: labelY + labelHeight / 2
        },
            midPos = {
          x: startX - gap2,
          y: labelY + labelHeight / 2
        },
            startPos = {
          x: point.posX + point.width + gapWidth,
          y: point.posY + point.height / 2
        };
        point.labelPos = {
          x: startX,
          y: labelY,
          endPos: endPos,
          midPos: midPos,
          startPos: startPos
        };
        startY += point.labelDim.height + label_label_gap;

        if (funnel._outSideSpecialLabel(point)) {
          //外侧自定义就不用走下边了
          var nameLabelContent = content.nameLabelContent,
              valueLabelContent = content.valueLabelContent; //处理省略和对齐

          var nameValueGap = labelDim.nameValueGap,
              valueLabelWidth = Math.min(labelUseWidth, funnel.maxValueLabelWidth);

          if (nameLabelContent) {
            var nameLabelDim = nameLabelContent.dim,
                nameLabelText = nameLabelContent.text;
            var nameLabelWidth = labelUseWidth - nameValueGap - valueLabelWidth;
            nameLabelText = funnel._omitLabel(nameLabelText, nameLabelWidth, nameLabelContent.style);
            nameLabelContent.text = nameLabelText;
            nameLabelContent.x = 0;
            nameLabelContent.y = (labelHeight - nameLabelDim.height) / 2;
          }

          if (valueLabelContent) {
            var valueLabelDim = valueLabelContent.dim,
                valueLabelText = valueLabelContent.text;
            valueLabelText = funnel._omitLabel(valueLabelText, valueLabelWidth, valueLabelContent.style);
            valueLabelContent.text = valueLabelText;
            valueLabelContent.x = labelUseWidth - valueLabelWidth;
            valueLabelContent.y = (labelHeight - valueLabelDim.height) / 2;
          }
        }
      }
    });
  },
  _omitLabel: function (text, width, style) {
    var tmpDim = _BaseUtils["default"].getTextDimension(text, style, false);

    var hasClip = false;

    while (tmpDim.width - width > 1e-6 && text.length) {
      text = text.substr(0, Math.floor(text.length * 0.9));
      tmpDim = _BaseUtils["default"].getTextDimension(text + '...', style, false);
      hasClip = true;
    }

    if (hasClip && text) {
      text += '...';
    }

    return text;
  },
  _calculateTotalLabelSize: function () {
    var funnel = this,
        vanchart = funnel.vanchart,
        plotBounds = vanchart.bounds;
    var useWidth = 0,
        useHeight = 0;
    funnel.points.filter(function (point) {
      return !point.isNull && point.visible && point.options.dataLabels && point.options.dataLabels.enabled;
    }).forEach(function (point) {
      if (point.options.dataLabels.align == _Constants["default"].OUTSIDE) {
        if (+funnel.maxNameLabelWidth || +funnel.maxValueLabelWidth) {
          //系列标签最大值、值标签最大值相加
          useWidth = Math.max(useWidth, (funnel.maxNameLabelWidth || 0) + (funnel.maxValueLabelWidth || 0) + point.labelDim.nameValueGap);
        } else {
          //外侧自定义标签
          useWidth = Math.max(useWidth, point.labelDim.width);
        }

        useHeight += point.labelDim.height;
      }
    });
    useWidth = Math.min(useWidth, plotBounds.width * LABEL_MAX_WIDTH);
    return {
      useWidth: useWidth,
      useHeight: useHeight
    };
  },
  //dolayout的时候已经算好了
  _calculateLabelPos: function () {},
  _getFixedPos: function (point) {
    var translate = point.series._getTranslate();

    return [translate[0] + point.posX + point.width / 2, translate[1] + point.posY + point.height / 2];
  },

  /**
   * @override Series.calcMoreLabelPosition
   * @param  {[type]} point [description]
   * @return {[type]}       [description]
   */
  calcMoreLabelPosition: function (point, moreLabelDim) {
    var translate = point.series._getTranslate();

    var startX = point.posX + point.width / 2,
        startY = point.posY + point.height / 2;
    return {
      startX: translate[0] + startX,
      startY: translate[1] + startY,
      direction: "top"
    };
  },
  getFillFilter: function (color, p) {
    var series = p.series,
        vanchart = series.vanchart,
        options = series.options;

    if (options.gradualStyle == _Constants["default"].STYLE_GRADUAL && (0, _EnvUtils.supportFillFilter)()) {
      var renderer = vanchart.renderer;
      var attrs = {
        'x1': '0%',
        'y1': '0%',
        'x2': '100%',
        'y2': '0%'
      };
      var stop1 = {
        'offset': '0%',
        'stop-color': _ColorUtils["default"].getColorWithDivider(color, 0.9),
        'stop-opacity': p.opacity
      };
      var stop2 = {
        'offset': '100%',
        'stop-color': color,
        'stop-opacity': p.opacity
      };

      if (p.colorGradient) {
        renderer.updateColorGradient(p.colorGradient, attrs, [stop1, stop2]);
      } else {
        p.colorGradient = renderer.colorGradient(attrs, [stop1, stop2]);
      }

      return renderer.toPatternProperty(p.colorGradient);
    }

    return color;
  },
  //选中状态长宽扩大2px
  _getPointPath: function (p, isChosen) {
    var bottomPoint = p._bottomPoint,
        diff = isChosen ? 1 : 0;
    var top_left = -p.width / 2 - diff + ',' + (-p.height / 2 - diff);
    var top_right = p.width / 2 + diff + ',' + (-p.height / 2 - diff);

    if (bottomPoint) {
      var bottom_right = bottomPoint.width / 2 + diff + ',' + (p.height / 2 + diff);
      var bottom_left = -bottomPoint.width / 2 - diff + ',' + (p.height / 2 + diff);
      return 'M' + top_left + 'L' + top_right + 'L' + bottom_right + 'L' + bottom_left + 'Z';
    } else {
      var bottom = '0,' + (p.height / 2 + diff);
      return 'M' + top_left + 'L' + top_right + 'L' + bottom + 'L' + bottom + 'Z';
    }
  },
  getPointGraphicKey: function () {
    return 'path';
  },
  getHighLightStyle: function (p) {
    return {
      'stroke': p.mouseOverColor,
      'fill': p.series.getFillFilter(p.mouseOverColor || p.color, p),
      'fill-opacity': p.opacity,
      'stroke-width': (p.options.borderWidth || 0) + CHOSEN_STROKE_WIDTH,
      'stroke-opacity': p.opacity === 0 ? 0 : p.borderOpacity || 0 + CHOSEN_STROKE_OPACITY
    };
  },
  getPressedStyle: function (p) {
    return {
      'stroke': p.clickColor || p.color,
      'fill': p.series.getFillFilter(p.clickColor, p),
      'fill-opacity': p.clickOpacity,
      'stroke-width': CHOSEN_STROKE_WIDTH,
      'stroke-opacity': p.opacity === 0 ? 0 : CHOSEN_STROKE_OPACITY
    };
  },
  effectAnimation: function (d) {
    _EffectHelper["default"].areaStyleEffectAnimation(d, d.posX + d.width / 2, d.posY + d.height / 2);
  },
  getDefaultEffectTime: function () {
    return _EffectHelper["default"].AREA_STYLE_EFFECT_TIME;
  },
  getPointInitAttr: function (d) {
    return {
      'transform': 'translate(' + (d.posX + d.width / 2) + ',' + (d.posY + d.height / 2) + ') scale(0.01)'
    };
  },
  _pointNormalAttr: function (d) {
    return {
      'd': d.series._getPointPath(d),
      'transform': 'translate(' + (d.posX + d.width / 2) + ',' + (d.posY + d.height / 2) + ') scale(1)'
    };
  },
  getPointInitAnimationAttr: function (d) {
    var series = d.series;
    return {
      delay: d.delayTime,
      ease: INIT_EASE,
      duration: FUNNEL_INIT_TIME,
      attr: series._pointNormalAttr(d)
    };
  },
  getPointReShowAnimationAttr: function (d) {
    var series = d.series;
    return {
      ease: RE_SHOW_EASE,
      duration: FUNNEL_RE_SHOW_TIME,
      attr: series._pointNormalAttr(d)
    };
  },
  getPointUpdateAnimationAttr: function (d) {
    var series = d.series;
    return {
      ease: UPDATE_EASE,
      duration: FUNNEL_UPDATE_TIME,
      attr: series._pointNormalAttr(d)
    };
  },
  _onPointMouseOver: function (point) {
    var series = point.series,
        style = series.getHighLightStyle(point);

    series._onState(point, true, style);
  },
  _onPointMouseOut: function (point) {
    var series = point.series,
        style = series.getStyle(point);

    series._onState(point, false, style);
  },
  _onState: function (point, isChosen, style) {
    var series = point.series;
    point.graphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      duration: CHOSEN_TIME,
      ease: CHOSEN_EASE,
      style: style,
      attr: {
        'd': series._getPointPath(point, isChosen)
      }
    });
    var options = point.options,
        dataLabels = options.dataLabels,
        align = dataLabels.align;

    if (align == _Constants["default"].INSIDE) {
      series._labelFontSizeState(point, isChosen, CHOSEN_TIME, CHOSEN_EASE);
    } else {
      series._leadLineState(point, 2, 0, isChosen, CHOSEN_TIME, CHOSEN_EASE);

      series._labelTransformState(point, 2, 0, isChosen, CHOSEN_TIME, CHOSEN_EASE);

      series._outSideSpecialLabel(point) ? series._specialLabelColorState(point, isChosen, CHOSEN_TIME, CHOSEN_EASE) : series._outSideLabelColorState(point, isChosen, CHOSEN_TIME, CHOSEN_EASE);
    }
  },
  _getTranslate: function () {
    var plotBounds = this.vanchart.bounds;
    return [plotBounds.x + plotBounds.width * WIDTH_GAP, plotBounds.y + plotBounds.height * HEIGHT_GAP];
  },
  _updateDataLabels: function () {
    var series = this;
    series.getTextDataToDraw().forEach(function (point) {
      series._outSideSpecialLabel(point) ? series._createOutSideTextGraphic(point) : series._createTextGraphic(point);
    });
  },
  _createOutSideTextGraphic: function (point) {
    var series = point.series,
        dataLabels = point.options.dataLabels;

    var hasText = function (d) {
      return series.visible && !d.isNull && d.visible && d.labelPos && !isNaN(d.labelPos.x) && !isNaN(d.labelPos.y) && dataLabels && dataLabels.enabled;
    };

    if (hasText(point)) {
      var vanchart = series.vanchart,
          renderer = vanchart.renderer;
      var labelContent = point.labelContent,
          useHtml = dataLabels.useHtml;

      var textLabelGroup = this._getPointTextLabelGroup();

      var text = renderer.vtext(useHtml).attr('transform', _BaseUtils["default"].makeTranslate(series._labelTrans(point))).style({
        'pointer-events': 'none'
      });
      var halfWidth = point.labelDim.width / 2,
          halfHeight = point.labelDim.height / 2;

      var createSpanGraphic = function (label) {
        if (label) {
          var labelDim = label.dim,
              labelText = label.text,
              labelStyle = label.style;
          return renderer.vtspan(useHtml).style({
            'width': dataLabels.labelWidth + 'px',
            height: dataLabels.labelHeight + 'px'
          }).attr('y', label.y).attr('x', label.x).attr('dy', labelDim.height * .85 - halfHeight).attr('dx', -halfWidth).style(labelStyle).textContent(labelText).addTo(text);
        }
      };

      text.nameSpan = createSpanGraphic(labelContent.nameLabelContent);
      text.valueSpan = createSpanGraphic(labelContent.valueLabelContent);
      point.textGraphic = textLabelGroup.append(text);

      if (point.labelPos.startPos) {
        //leadLine
        point.leadLine = textLabelGroup.append(this._getLeadLine(point));
      }
    }
  },
  _specialLabelColorState: function (point, isChosen, duration, ease) {
    var labelContent = point.labelContent;

    function spanColorState(span, label) {
      if (label && span) {
        var style = label.style;
        span.animate({
          duration: duration,
          ease: ease,
          style: {
            'color': style.color,
            'fill': style.color
          }
        });
      }
    }

    point.textGraphic && spanColorState(point.textGraphic.nameSpan, labelContent.nameLabelContent);
    point.textGraphic && spanColorState(point.textGraphic.valueSpan, labelContent.valueLabelContent);
  },
  isSeriesAccumulated: function () {
    return true;
  },
  getDefaultTooltipFormatter: function () {
    return {
      categoryFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{NAME}{VALUE}",
      nameFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = Funnel;
exports["default"] = _default;

/***/ }),
/* 137 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Series = _interopRequireDefault(__webpack_require__(13));

var _Class = _interopRequireDefault(__webpack_require__(27));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _StyleUtils = __webpack_require__(29);

var _dataLabelFormatter = _interopRequireDefault(__webpack_require__(24));

var _VanChartLabelBorder = __webpack_require__(36);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/7/17.
 */
var LABEL_GAP = 2;
var LINE_SHOW_TIME = 1200;
var LINE_SHOW_EASE = _BezierEasing["default"].css['ease-out-cubic'];
var LINE_UPDATE_TIME = 250;
var CHOSEN_AREA_ADD_ALPHA = 0.35;
var UPDATE_EASE = _BezierEasing["default"].css.swing; //path里面点如果非常小，整个path不展示。ps：非常大没有问题

var VERTICAL_ANGLE = Math.tan(1e-2);
var BADN_MOUSE_OVER = "band_mouse_over";
var GRADIENT_AREA_OPACITY = [0, 0.3]; // 渐变风格时面积的不透明度
//for ease-out-cubic

var calculateT = function (point) {
  var det = point.indexFromLeft / (point.series.points.length - 1) || 0; //考虑系列下只有一个点的情况

  return LINE_SHOW_TIME * _BezierEasing["default"].calculateCubicOutT(det);
};

var isValidNumber = function (num) {
  return isFinite(num) && !isNaN(num);
};

var Line = _Series["default"].extend({
  doLayout: function () {
    var series = this,
        vanchart = series.vanchart,
        options;
    var xAxis = series.xAxis,
        yAxis = series.yAxis,
        connectNulls = series.options.connectNulls;
    var det = xAxis.scale.rangeBand ? xAxis.scale.rangeBand() / 2 : 0;
    var inverted = vanchart.isInverted(),
        orderKey = inverted ? 'posY' : 'posX';
    var startValue = yAxis.getStartPosValue();
    var MIN_MAX = [-Math.max(vanchart.width, vanchart.height) / VERTICAL_ANGLE, undefined];
    xAxis.scale.minMax && xAxis.scale.minMax(MIN_MAX);
    yAxis.scale.minMax && yAxis.scale.minMax(MIN_MAX);
    var validPoints = [];

    if (this.options.large) {
      var xMap = {},
          yMap = {};
      series.points.forEach(function (point) {
        options = point.options;
        var x = xAxis.scale(xAxis.getAxisValue(options.x, point)) + det;
        var y = yAxis.scale(yAxis.getAxisValue(options.y, point) + options.y0 - startValue),
            y0 = yAxis.scale(options.y0); // todo 对数值轴的时候，取0计算出Infinity，导致折线中断，后面正常的point连不起来。

        if (!isValidNumber(y)) {
          point.isNull = true;
        }

        if (inverted) {
          point.posX = y;
          point.posY = x;
          point.posX0 = y0;
        } else {
          point.posX = x;
          point.posY = y;
          point.posY0 = y0;
        }

        if (!xMap[parseInt(point.posX)] || !yMap[parseInt(point.posY)]) {
          xMap[parseInt(point.posX)] = true;
          yMap[parseInt(point.posY)] = true;
          validPoints.push(point);
        }
      }, this);
    } else {
      validPoints = series.points;
    }

    var inOrder = true,
        points = []; //计算系列最值,面积图渐变时用得到

    series.y0 = Number.MAX_VALUE;
    series.y = -Number.MAX_VALUE;
    validPoints.forEach(function (point, i) {
      options = point.options;

      if (this.options.large) {
        x = point.posX;
        y = point.posY;
      } else {
        var x = xAxis.scale(xAxis.getAxisValue(options.x, point)) + det;
        var y = yAxis.scale(yAxis.getAxisValue(options.y, point) + options.y0 - startValue),
            y0 = yAxis.scale(options.y0);

        if (!isValidNumber(y)) {
          point.isNull = true;
        }

        if (inverted) {
          point.posX = y;
          point.posY = x;
          point.posX0 = y0;
        } else {
          point.posX = x;
          point.posY = y;
          point.posY0 = y0;
        }
      }

      point.indexFromLeft = i; //用来计算delay

      if (!connectNulls || connectNulls && !point.isNull) {
        if (points.length > 0) {
          inOrder = inOrder && points[points.length - 1][orderKey] <= x;
        }

        points.push(point);
      }

      if (Math.abs(options.y0) < Math.abs(series.y0)) {
        series.y0 = Math.abs(options.y0);
      }

      if (Math.abs(options.y + options.y0) > series.y) {
        series.y = Math.abs(options.y + options.y0);
      }
    }, this);

    if (!inOrder) {
      points.sort(function (p1, p2) {
        return p1[orderKey] - p2[orderKey];
      });
      points.forEach(function (point, i) {
        point.indexFromLeft = i;
      });
    }

    var lineGenerator = _PathGenerator["default"].line(inverted).interpolate(series.interpolate).x(function (d) {
      return d.posX;
    }).y(function (d) {
      return d.posY;
    }).defined(function (d) {
      return !d.isNull;
    });

    var areaGenerator = _PathGenerator["default"].area().interpolate(series.interpolate);

    if (inverted) {
      areaGenerator = areaGenerator.y(function (d) {
        return d.posY;
      }).x0(function (d) {
        var pre = series._getPreviousStackingPoint(d);

        return pre ? pre.posX : d.posX0;
      }).x1(function (d) {
        return d.posX;
      });
    } else {
      areaGenerator = areaGenerator.x(function (d) {
        return d.posX;
      }).y0(function (d) {
        var pre = series._getPreviousStackingPoint(d);

        return pre ? pre.posY : d.posY0;
      }).y1(function (d) {
        return d.posY;
      });
    }

    areaGenerator = areaGenerator.defined(function (d) {
      return !d.isNull;
    });
    this.linePath = lineGenerator(points);
    this.areaPath = areaGenerator(points);
    this.dataBands = this._calculateDataBands();
  },
  _getPreviousStackingPoint: function (point) {
    var stack = point.series.stack,
        isStackedSeries = (0, _CoreUtils.hasDefined)(stack) && stack !== false; // @CHART-1469: 当stack未定义或者为false的时候为非堆积，其他的情况都可能为堆积

    if (isStackedSeries) {
      var points = point.points;

      for (var i = 0, len = points.length; i < len; i++) {
        var preSeries = points[i].series;

        if (preSeries.stack == point.series.stack && preSeries.visible && points[i + 1] == point) {
          return points[i];
        }
      }
    }
  },
  _calculateDataBands: function () {
    var plotBounds = this.vanchart.bounds,
        series = this,
        bands = this.options.bands || [];
    var dColor = series.color,
        dOpacity = series.opacity;
    var dFillColor = series.fillColor,
        dFillColorOpacity = series.fillColorOpacity;
    var yAxis = series.yAxis,
        domain = yAxis.scale.domain(),
        isHorizontal = yAxis.isHorizontal();
    var width = plotBounds.width,
        height = plotBounds.height;
    var resultRanges = [];
    var isLineChart = this.type === _Constants["default"].LINE_CHART;
    var isInverted = this.vanchart.isInverted();
    var left = 0,
        right = width,
        top = 0,
        bottom = height,
        positionPoints,
        len; // 面积图不用考虑以点的范围来做裁剪

    if (isLineChart) {
      // 坐标系反转按Y轴坐标计算
      if (isInverted) {
        positionPoints = series.points.sort(function (p1, p2) {
          return p1.posY - p2.posY;
        }), len = positionPoints.length;
        left = 0;
        right = width;
        top = positionPoints[0] ? positionPoints[0].posY - 1 : 0;
        bottom = positionPoints[len - 1] ? positionPoints[len - 1].posY + 1 : width;
      } else {
        // 正常坐标系按X轴坐标计算
        positionPoints = series.points.sort(function (p1, p2) {
          return p1.posX - p2.posX;
        }), len = positionPoints.length;
        left = positionPoints[0] ? positionPoints[0].posX - 1 : 0;
        right = positionPoints[len - 1] ? positionPoints[len - 1].posX + 1 : width;
        top = 0;
        bottom = height;
      }
    }

    resultRanges.push({
      clipBounds: {
        x: left,
        y: top,
        width: right - left,
        height: bottom - top
      },
      color: dColor,
      fillColor: dFillColor,
      fillColorOpacity: dFillColorOpacity
    });

    if (!bands || !bands.length) {
      return resultRanges;
    }

    for (var i = 0, len = bands.length; i < len; i++) {
      var from = Math.max(domain[0], bands[i].from);
      var to = Math.min(domain[1], bands[i].to);
      from = yAxis.scale(from);
      to = yAxis.scale(to);
      var clipBounds = {
        x: 0,
        y: Math.min(from, to),
        width: width,
        height: Math.abs(from - to)
      };

      if (isHorizontal) {
        clipBounds = {
          x: Math.min(from, to),
          y: 0,
          width: Math.abs(from - to),
          height: height
        };
      }

      resultRanges.push({
        clipBounds: clipBounds,
        color: bands[i].color || dColor,
        opacity: bands[i].opacity || dOpacity,
        fillColor: bands[i].fillColor || dFillColor,
        fillColorOpacity: bands[i].fillColorOpacity || dFillColorOpacity
      });
    }

    return resultRanges;
  },
  _getFixedPos: function (datum) {
    var radius = datum.options.marker.radius || _Constants["default"].MARKER_RADIUS;
    var plotBounds = this.vanchart.bounds;
    var x = plotBounds.x + datum.posX + radius;
    var y = plotBounds.y + datum.posY + radius;
    return [x, y];
  },
  _calculateLabelPosAuto: function (point) {
    var isInverted = this.vanchart.isInverted();
    var labelDim = point.labelDim;

    if (!labelDim) {
      return;
    }

    var labelPosAtTop = this._labelPos(point, isInverted, true);

    var labelBoundsAtTop = {
      x: labelPosAtTop.x,
      y: labelPosAtTop.y,
      width: labelDim.width,
      height: labelDim.height
    };

    var isIntersectLabelAtTop = this._hasIntersect(labelBoundsAtTop);

    if (!isIntersectLabelAtTop) {
      point.labelPos = {
        x: labelBoundsAtTop.x,
        y: labelPosAtTop.y
      };
      return;
    }

    var labelPosAtBottom = this._labelPos(point, isInverted, false);

    var labelBoundsAtBottom = {
      x: labelPosAtBottom.x,
      y: labelPosAtBottom.y,
      width: labelDim.width,
      height: labelDim.height
    };

    var isIntersectLabelAtBottom = this._hasIntersect(labelBoundsAtBottom);

    point.labelAlign = isIntersectLabelAtBottom ? _Constants["default"].TOP : _Constants["default"].BOTTOM;
    point.labelPos = isIntersectLabelAtBottom ? {
      x: labelBoundsAtTop.x,
      y: labelBoundsAtTop.y
    } : {
      x: labelBoundsAtBottom.x,
      y: labelBoundsAtBottom.y
    };
  },
  _hasIntersect: function (labelBounds) {
    var series = this.vanchart.series.filter(function (ser) {
      return ser.visible && (ser.type === _Constants["default"].LINE_CHART || ser.type === _Constants["default"].AREA_CHART);
    });
    var isIntersect = false;

    for (var i = 0; i < series.length; i++) {
      var ser = series[i];
      var points = ser.points,
          options = ser.options;

      if (options.step) {
        isIntersect = this._hasIntersectWithStep(points, labelBounds);

        if (isIntersect) {
          break;
        }
      } else {
        for (var j = 0; j < points.length - 1; j++) {
          var firstPoint = points[j];
          var secondPoint = points[j + 1];
          var firstPointPos = {
            x: firstPoint.posX,
            y: firstPoint.posY
          };
          var secondPointPos = {
            x: secondPoint.posX,
            y: secondPoint.posY
          };
          isIntersect = _BaseUtils["default"].lineRect(firstPointPos, secondPointPos, labelBounds);

          if (isIntersect) {
            return isIntersect;
          }
        }
      }
    }

    return isIntersect;
  },
  // 线形态为垂直时判断线是否与标签重叠
  _hasIntersectWithStep: function (points, labelBounds) {
    var isIntersect = false;

    for (var i = 0; i < points.length - 1; i++) {
      var firstPoint = points[i];
      var secondPoint = points[i + 1];
      var firstPointPos = {
        x: firstPoint.posX,
        y: firstPoint.posY
      };
      var midPointPos = {
        x: secondPoint.posX,
        y: firstPoint.posY
      };
      var secondPointPos = {
        x: secondPoint.posX,
        y: secondPoint.posY
      };
      isIntersect = _BaseUtils["default"].lineRect(firstPointPos, midPointPos, labelBounds);

      if (isIntersect) {
        return isIntersect;
      }

      isIntersect = _BaseUtils["default"].lineRect(midPointPos, secondPointPos, labelBounds);

      if (isIntersect) {
        return isIntersect;
      }
    }

    return isIntersect;
  },
  _labelPos: function (point, isInverted, isAlignTop) {
    var x,
        y,
        gap = LABEL_GAP;
    var labelDim = point.labelDim;

    if (!labelDim) {
      return;
    }

    var marker = point.options.marker;

    if (marker && marker.symbol) {
      gap += marker.radius || _Constants["default"].MARKER_RADIUS;
    }

    if (isInverted) {
      x = isAlignTop ? point.posX + gap : point.posX - gap - labelDim.width;
      y = point.posY - labelDim.height / 2;
    } else {
      x = point.posX - labelDim.width / 2;
      y = isAlignTop ? point.posY - gap - labelDim.height : point.posY + gap;
    }

    return this._adjustBoundaryLabelPos({
      x: x,
      y: y
    }, point);
  },
  _adjustBoundaryLabelPos: function (pos, point) {
    var isNeedLabelBorder = (0, _VanChartLabelBorder.isNeedBorder)(point);

    if (isNeedLabelBorder) {
      return pos;
    }

    var x = pos.x,
        y = pos.y;
    var labelDim = point.labelDim;
    var plotBounds = this.vanchart.bounds;

    if (y <= 0) {
      y = point.posY;
    } else if (y + labelDim.height >= plotBounds.height) {
      y = point.posY - labelDim.height;
    }

    if (x <= 0) {
      x = point.posX;
    } else if (x + labelDim.width >= plotBounds.width) {
      x = point.posX - labelDim.width;
    }

    return {
      x: x,
      y: y
    };
  },
  //计算点的位置的时候就能确定标签的位置
  _calculateLabelPos: function () {
    var series = this,
        isInverted = this.vanchart.isInverted(),
        count = series.points.length;
    series.points.forEach(function (point, i) {
      var dataLabels = point.options.dataLabels;

      if (dataLabels && dataLabels.enabled) {
        if (dataLabels.align === _Constants["default"].AUTO) {
          series._calculateLabelPosAuto(point);

          point.location = series._calculatePointLocation(point, point.labelAlign);
          return;
        }

        var isAlignTop = dataLabels.align === _Constants["default"].TOP;
        point.labelAlign = dataLabels.align;
        point.labelPos = series._labelPos(point, isInverted, isAlignTop);
        point.location = series._calculatePointLocation(point, point.labelAlign);
      }
    });
  },
  _calculatePointLocation: function (point, labelAlign) {
    var isInverted = this.vanchart.isInverted();

    if (labelAlign === _Constants["default"].BOTTOM) {
      return isInverted ? _Constants["default"].RIGHT_TO_LEFT : _Constants["default"].TOP_TO_BOTTOM;
    } else {
      return isInverted ? _Constants["default"].LEFT_TO_RIGHT : _Constants["default"].BOTTOM_TO_TOP;
    }
  },
  getTrendLineXYValues: function (sery) {
    return this._getNormalTrendLineXYValues(sery);
  },
  getAttrs: function (point) {
    return {
      'transform': _BaseUtils["default"].makeTranslate([point.posX, point.posY])
    };
  },

  /**
   * @override Series.calcMoreLabelPosition
   * @param  {[type]} point [description]
   * @return {[type]}       [description]
   */
  calcMoreLabelPosition: function (point) {
    var chartBounds = this.vanchart.bounds;
    return {
      startX: point.posX + chartBounds.x,
      startY: point.posY + chartBounds.y,
      direction: "top"
    };
  },
  calcMoreLabelStartPosition: function (startX, startY, moreLabelWidth, moreLabelHeight) {
    var direction = "top";

    if (startY - moreLabelHeight < 0) {
      direction = "bottom";
    }

    return {
      startX: startX,
      startY: startY,
      direction: direction
    };
  },
  effectAnimation: function (d) {
    _EffectHelper["default"].markerEffectAnimation(d);
  },
  getDefaultEffectTime: function () {
    return _EffectHelper["default"].MARKER_EFFECT_TIME;
  },
  getHighLightStyle: function () {},
  getDataToDraw: function () {
    var series = this;
    return this.points.filter(function (p) {
      var hasMarker = p.options.marker && p.options.marker.symbol; // drawPoints只处理了有标记点的点。这里处理所有options无标记点，实际上却有图形对象的点。
      // 自动刷新，options无标记点更新之前options有标记点的点，要把之前的标记点删掉

      !hasMarker && p.graphic && series._drawExitPoints(p);
      return hasMarker;
    });
  },
  getTextDataToDraw: function () {
    return this.points;
  },
  _updatePointGraphicStyle: function (point) {
    this._updateMarkerPointGraphic(point);

    this._updateMarker(point);
  },
  updatePointGraphic: function (point) {
    this._updateMarkerPointGraphic(point);
  },
  _createPointGraphic: function (point) {
    return point.graphic = this._createMarker(point.options.marker);
  },
  onPointPress: function () {
    var point = this,
        series = point.series;

    series._onMarkerPressed(point);
  },
  onPointPressUp: function () {
    var point = this,
        series = point.series;

    series._updateMarker(point);
  },
  _onPointMouseOver: function (point) {
    point.series._onMarkerMouseOver(point);
  },
  _onPointMouseOut: function (point) {
    point.series._onMarkerMouseOut(point);
  },
  getPointInitAttr: function (point) {
    return {
      'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(0.01)'
    };
  },
  getPointInitAnimationAttr: function (point) {
    var getTranslate = function () {
      return 'translate(' + point.posX + ',' + point.posY + ') ';
    };

    return [{
      delay: this.initialAnimationMoving ? calculateT(point) : 0,
      ease: 'swing',
      duration: 150,
      attrTween: {
        'transform': function () {
          return function (t) {
            return getTranslate() + 'scale(' + t * 1.5 + ')';
          };
        }
      }
    }, {
      duration: 150,
      ease: 'swing',
      attrTween: {
        'transform': function () {
          return function (t) {
            return getTranslate() + 'scale(' + (1.5 - 0.5 * t) + ')';
          };
        }
      }
    }];
  },
  getPointUpdateAnimationAttr: function (point) {
    return {
      ease: UPDATE_EASE,
      duration: LINE_UPDATE_TIME,
      attr: {
        'transform': 'translate(' + point.posX + ',' + point.posY + ')'
      }
    };
  },
  getClosestPoint: function (pos) {
    var isInverted = this.vanchart.isInverted();
    var key = isInverted ? 'y' : 'x',
        posKey = isInverted ? 'posY' : 'posX';
    var selectedPoint,
        minDistance = Number.MAX_VALUE;
    var series = this.vanchart.hoverSeries,
        plotBounds = this.vanchart.bounds;
    var rePos = plotBounds[key] - (isInverted ? pos.y : pos.x);
    series.points.forEach(function (point) {
      var dis = Math.abs(point[posKey] + rePos);

      if (dis < minDistance && !point.isNull) {
        selectedPoint = point;
        minDistance = dis;
      }
    });
    return selectedPoint;
  },
  _onSeriesMouseOver: function (ev) {
    _Series["default"].prototype._onSeriesMouseOver.call(this, ev);

    this.dataBandsGraphic.forEach(function (band) {
      band._onSeriesMouseOver();
    });
    this.toFrontPosition();
  },
  //dom event do nothing
  _onSeriesMouseOut: function (ev) {},
  //point.series.fire
  _seriesUnChosen: function (ev) {
    // FIXME @CHART-1967:IE下移除选中后判断切换自动数据点提示状态
    this.vanchart.switchAutoTooltipStatus("mouseout");
    this.resetPosition(); //这里只负责撤销系列的选中效果...

    this.dataBandsGraphic.forEach(function (band) {
      band._onSeriesMouseOut();
    });
  },
  drawPoints: function () {
    _Series["default"].prototype.drawPoints.call(this);

    for (var i = this.dataBandsGraphic.length - 1; i >= 0; i--) {
      this.dataBandsGraphic[i].toBack();
    }
  },
  drawSeries: function () {
    var series = this,
        vanchart = this.vanchart;
    var dataBands = this.dataBands,
        i,
        len;
    series.removeDefaultMarker();
    this.dataBandsGraphic = this.dataBandsGraphic || [];

    for (i = dataBands.length, len = this.dataBandsGraphic.length; i < len; i++) {
      this.dataBandsGraphic[i].remove();
      this.dataBandsGraphic[i] = null;
    }

    for (i = 0, len = dataBands.length; i < len; i++) {
      if (this.dataBandsGraphic[i]) {
        this.dataBandsGraphic[i].refresh(dataBands[i]);
      } else {
        this.dataBandsGraphic[i] = new DataBand(dataBands[i], series);
      }
    }

    this.dataBandsGraphic.length = dataBands.length;
  },
  calculateLabelInfo: function (point) {
    (0, _dataLabelFormatter["default"])(point);
    (0, _VanChartLabelBorder.fixLabelDimWithBorder)(point);
  }
}); //dataBand that draw part of the series


var DataBand = _Class["default"].extend({
  initialize: function (options, series) {
    this.series = series;
    this.refresh(options);
  },
  refresh: function (options) {
    this.options = options;
    this.render();
  },
  render: function () {
    var options = this.options,
        series = this.series,
        self = this;
    var group = series.group,
        vanchart = series.vanchart,
        renderer = vanchart.renderer;

    var lineStyle = this._getLineStyle(series, options);

    var style = this._getAreaStyle(series, options);

    var clipBounds = options.clipBounds,
        isArea = series.type === _Constants["default"].AREA_CHART,
        isInit = !this.linePath || this.linePath.removed();

    if (!this.clipRect) {
      this.clipRect = renderer.createClip({
        x: clipBounds.x,
        y: clipBounds.y,
        width: clipBounds.width,
        height: clipBounds.height
      });
    } else {
      renderer.updateClip(this.clipRect, clipBounds);
    }

    if (!series.visible) {
      this.linePath && this.linePath.remove();
      this.areaPath && this.areaPath.remove();
      this.linePath = this.areaPath = null;
      return;
    }

    this.linePath = this.linePath || renderer.path().attr('d', series.linePath).addTo(group);
    this.linePath.style(lineStyle);
    this.linePath.isLineChart = true;
    renderer.clip(this.linePath, this.clipRect);

    if (isArea) {
      this.areaPath = this.areaPath || renderer.path().attr('d', series.areaPath);
      this.areaPath.style(style).addTo(group);
      this.areaPath.isLineChart = true;
      renderer.clip(this.areaPath, this.clipRect);
    }

    if (true) {
      // 判断当前的series是否支持动画
      var isAnimation = this._isSetAnimation();

      if (isInit) {
        this.linePath.attr('d', series.linePath);
        this.areaPath && this.areaPath.attr('d', series.areaPath);
        (0, _EnvUtils.isSupportSVG)() && this.clipRect.rect.attr(vanchart.isInverted() ? 'height' : 'width', 0).animate({
          'ease': LINE_SHOW_EASE,
          'duration': isAnimation ? LINE_SHOW_TIME : 0,
          'attr': clipBounds
        });
      } // update with animation
      else if ((0, _EnvUtils.isSupportSVG)()) {
          this.linePath.animate({
            'ease': UPDATE_EASE,
            'duration': LINE_UPDATE_TIME,
            'attr': {
              'd': series.linePath
            }
          });

          if (this.areaPath) {
            this.areaPath.animate({
              'ease': UPDATE_EASE,
              'duration': LINE_UPDATE_TIME,
              'attr': {
                'd': series.areaPath
              }
            });
          }

          this.clipRect.rect.animate({
            'ease': UPDATE_EASE,
            'duration': isAnimation ? LINE_SHOW_TIME : 0,
            'attr': clipBounds
          });
        } // update with no animation
        else {
            this.linePath.attr("d", series.linePath);
            renderer.clip(this.linePath, this.clipRect); // reclip

            if (this.areaPath) {
              this.areaPath.attr("d", series.areaPath);
              renderer.clip(this.areaPath, this.clipRect);
            }
          }
    }
  },
  toBack: function () {
    this.linePath && this.linePath.toBack();
    this.areaPath && this.areaPath.toBack();
  },

  /**
   * 判断当前series是否设置了动画
   * @private
   */
  _isSetAnimation: function () {
    return this.series.options.animation;
  },
  _getAreaStyle: function (series, options) {
    var target = series.vanchart.highlightTarget;
    var fill, fillOpacity;

    if ((0, _CoreUtils.hasDefined)(target)) {
      fill = options.fillColor;
      fillOpacity = target == series.name ? 1 : _Constants["default"].HOVER_OPACITY;
    } else {
      fill = this._getFillFilter(options.fillColor, series);
      fillOpacity = series.options.gradualStyle == _Constants["default"].STYLE_GRADUAL ? 1.0 : options.fillColorOpacity;
    }

    return {
      'fill': fill,
      'fill-opacity': fillOpacity
    };
  },
  _getLineStyle: function (series, options) {
    var target = series.vanchart.highlightTarget;
    var _series$options = series.options,
        lineWidth = _series$options.lineWidth,
        lineType = _series$options.lineType;
    var opacity = options.opacity;

    if ((0, _CoreUtils.hasDefined)(target)) {
      opacity = target == series.name ? 1 : _Constants["default"].HOVER_OPACITY;
    }

    return (0, _StyleUtils.getLineStyle)({
      color: options.color,
      lineWidth: lineWidth,
      lineType: lineType,
      opacity: opacity
    });
  },
  _getFillFilter: function (color, series) {
    if ((0, _EnvUtils.supportFillFilter)()) {
      var vanchart = series.vanchart,
          renderer = vanchart.renderer;
      var options = series.options;

      if (options.gradualStyle == _Constants["default"].STYLE_GRADUAL) {
        //翻转情况
        var x1, y1, x2, y2;
        x1 = y1 = x2 = y2 = '0%';
        var percent = Math.abs(series.y) / Math.abs(series.y - series.y0) || 1;

        if (vanchart.isInverted() === true) {
          x1 = (1 - percent) * 100 + '%';
          x2 = '100%';
        } else {
          y1 = percent * 100 + '%';
        }

        var attrs = {
          'x1': x1,
          'y1': y1,
          'x2': x2,
          'y2': y2
        };
        var stop1 = {
          'offset': '0%',
          'stop-color': color,
          'stop-opacity': GRADIENT_AREA_OPACITY[0]
        };
        var stop2 = {
          'offset': '100%',
          'stop-color': color,
          'stop-opacity': GRADIENT_AREA_OPACITY[1]
        };

        if (this.colorGradient) {
          renderer.updateColorGradient(this.colorGradient, attrs, [stop1, stop2]);
        } else {
          this.colorGradient = renderer.colorGradient(attrs, [stop1, stop2]);
        }

        return renderer.toPatternProperty(this.colorGradient);
      }
    }

    return color;
  },
  _onSeriesMouseOver: function () {
    var lineWidth = this.series.options.lineWidth;
    this.linePath && this.linePath.style({
      'stroke': _ColorUtils["default"].getHighLightColor(this.options.color),
      'stroke-width': lineWidth === 0 ? 0 : lineWidth + 1 // @CHART-4852: lineWidth = 0即不显示线

    });

    if (this.series.type == _Constants["default"].AREA_CHART) {
      this.areaPath.interrupt(BADN_MOUSE_OVER).transition(BADN_MOUSE_OVER).animate({
        duration: 200,
        ease: _BezierEasing["default"].custom["ease-out-back"],
        style: {
          'fill': this._getFillFilter(_ColorUtils["default"].getHighLightColor(this.options.fillColor), this.series),
          'fill-opacity': this.options.fillColorOpacity === 0 ? 0 : this.options.fillColorOpacity + CHOSEN_AREA_ADD_ALPHA
        },
        attr: {
          "d": this.series.areaPath
        }
      });
    }
  },
  _onSeriesMouseOut: function () {
    if (this.linePath) {
      this.linePath.style(this._getLineStyle(this.series, this.options));
    }

    if (this.areaPath) {
      this.areaPath.animate({
        duration: 200,
        ease: _BezierEasing["default"].custom["ease-out-back"],
        style: this._getAreaStyle(this.series, this.options),
        attr: {
          "d": this.series.areaPath
        }
      });
    }
  },
  remove: function () {
    this.linePath && this.linePath.remove();
    this.areaPath && this.areaPath.remove();
    this.clipRect && this.clipRect.remove();
    this.linePath = this.areaPath = this.clipRect = null;
  }
});

var _default = Line;
exports["default"] = _default;

/***/ }),
/* 138 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _component = __webpack_require__(4);

var _Series = _interopRequireDefault(__webpack_require__(13));

var _LineMapDataNormalizer = _interopRequireDefault(__webpack_require__(139));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2016/12/14.
 */
var TOOLTIP_GAP = 6;
var PI = Math.PI;

var LineMap = _Series["default"].extend({
  doLayout: _BaseUtils["default"].emptyFn,
  _calculateLabelPos: _BaseUtils["default"].emptyFn,
  _loadData: function (data) {
    var geo = this.vanchart.getComponent(_component.ComponentCst.GEO_COMPONENT);
    return (0, _LineMapDataNormalizer["default"])(data, geo);
  },
  // here is obscure...
  // other charts use one canvas per series,
  // lineMap uses only one.
  // it's different...
  useCanvas: _BaseUtils["default"].trueFn,
  getTargetKey: function () {
    return 'value';
  },
  _getPointKey: function (point) {
    point = point.options || point;
    return point.from.lnglat.join() + point.to.lnglat.join();
  },
  _getFixedPos: function (point, divDim) {
    var arc = _BaseUtils["default"].computeArc(point.ax, point.ay, point.bx, point.by, point.curveness);

    var th = (arc[3] + arc[4]) / 2;
    th %= 2 * PI;
    var r = arc[2] + TOOLTIP_GAP;
    var x = r * Math.cos(th) + arc[0];
    var y = r * Math.sin(th) + arc[1];

    if (th <= PI / 2) {// original
    } else if (th <= PI) {
      x -= divDim.width;
    } else if (th <= 3 / 2 * PI) {
      x -= divDim.width;
      y -= divDim.height;
    } else {
      y -= divDim.height;
    }

    return [x, y];
  },
  remove: function () {
    _Series["default"].prototype.remove.call(this);

    this.points = [];
  },
  getDefaultTooltipFormatter: function () {
    return {
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      fromFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{FROM.NAME}{TO.NAME}{SERIES}{VALUE}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      toFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = LineMap;
exports["default"] = _default;

/***/ }),
/* 139 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = _default;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2016/12/23.
 */
var extend = _BaseUtils["default"].extend;

function normalSingle(p, geo) {
  var name = p.name || p;
  var features = geo.getFeaturesByName(name, _Constants["default"].LINE_MAP);

  if (features && features.length) {
    return features.map(function (f) {
      return {
        name: name,
        lnglat: f.geometry.coordinates
      };
    });
  }
}

function normalDatum(froms, tos, d, normalData) {
  if (!froms || !tos) {
    return;
  }

  var i = 0,
      f = froms[0] || froms;

  do {
    var j = 0,
        t = tos[0] || tos;

    do {
      var datum = {};
      extend(datum, d);
      datum.from = f;
      datum.to = t;
      normalData.push(datum);
    } while (t = tos[++j]);
  } while (f = froms[++i]);
}
/*
  1 ->
  from: "place",

  2 ->
  from: {
    name: "place"
  }
  (Get lnglats from geoJson with the same name. Return Points Array or null.)

  3 (correct) ->
  from: {
    name: "place",
    lnglat: [1,0]
  }

*/


function _default(data, geo) {
  geo._loadGeo(); // have to get json first


  var normalData = [];
  var i = -1,
      d;

  while (d = data[++i]) {
    var froms, tos;
    var isF = d.from && d.from.lnglat;
    var isT = d.to && d.to.lnglat;

    if (isF && isT) {
      normalData.push(d);
    } else {
      froms = isF ? d.from : normalSingle(d.from, geo);
      tos = isT ? d.to : normalSingle(d.to, geo);
      normalDatum(froms, tos, d, normalData);
    }
  }

  return normalData;
}

/***/ }),
/* 140 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _Radar = _interopRequireDefault(__webpack_require__(78));

var _CoreUtils = __webpack_require__(3);

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _StyleUtils = __webpack_require__(29);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/8/22.
 */
var LINE_SHOW_TIME = 400;
var LINE_SHOW_EASE = 'back-out';
var MARKER_INIT_TIME = 200;
var MARKER_INIT_EASE = 'back-out';
var EXIT_TIME = 250;
var EXIT_EASE = 'back-in';
var TOP = 'radar-top';
var BOTTOM = 'radar-bottom';
var LEFT = 'radar-left';
var RIGHT = 'radar-right';
var LABEL_BORDER_GAP = 8;

var LineRadar = _Radar["default"].extend({
  columnType: false,
  _calcLabelPos: function (point) {
    var position = this.polar.angleAxis._getPolarPosition(point.category);

    var pos = this._getArcPoint(point.outerRadius + LABEL_BORDER_GAP, point.radian);

    var labelDim = point.labelDim;

    switch (position) {
      case TOP:
        point.labelPos = {
          x: -labelDim.width / 2,
          y: pos[1] - labelDim.height
        };
        break;

      case RIGHT:
        point.labelPos = {
          x: pos[0],
          y: pos[1] - labelDim.height / 2
        };
        break;

      case BOTTOM:
        point.labelPos = {
          x: -labelDim.width / 2,
          y: pos[1]
        };
        break;

      case LEFT:
        point.labelPos = {
          x: pos[0] - labelDim.width,
          y: pos[1] - labelDim.height / 2
        };
        break;
    }
  },
  drawPoints: function () {
    _Radar["default"].prototype.drawPoints.call(this);

    this.radarPath && this.radarPath.toBack();
  },
  drawSeries: function () {
    var series = this,
        vanchart = series.vanchart,
        renderer = vanchart.renderer;
    series.removeDefaultMarker();
    var toCenter = series.fillColor && series.fillColorOpacity;

    var pathStyle = this._getRadarPathStyle();

    if (series.visible) {
      this.radarPath = this.radarPath || renderer.path().addTo(series.group);
      this.radarPath.style(pathStyle);
      this.radarPath.animate({
        duration: LINE_SHOW_TIME,
        ease: LINE_SHOW_EASE,
        attrTween: {
          'd': function () {
            var useLastPathSeg = this._pathSegment_ && series.pathSegment && this._pathSegment_.length === series.pathSegment.length;
            var last = this._pathSegment_;

            for (var i = 0, count = last ? last.length : 0; i < count && useLastPathSeg; i++) {
              if (last[i].length !== series.pathSegment[i].length) {
                useLastPathSeg = false;
              }
            }

            var initPathSeg = useLastPathSeg ? this._pathSegment_ : series._getInitPathSegment(series.pathSegment);

            var interpolate = _interpolator["default"].interpolateArray(initPathSeg, series.pathSegment);

            this._pathSegment_ = series.pathSegment;
            return function (t) {
              return series._getRadarSeriesPath(interpolate(t), series.options.connectNulls, toCenter);
            };
          }
        }
      });
    } else {
      if (this.radarPath) {
        this.radarPath.animate({
          duration: EXIT_TIME,
          ease: EXIT_EASE,
          attrTween: {
            'd': function () {
              var initPathSeg = series._getInitPathSegment(series.pathSegment);

              var interpolate = _interpolator["default"].interpolateArray(series.pathSegment, initPathSeg);

              return function (t) {
                return series._getRadarSeriesPath(interpolate(t), series.options.connectNulls, toCenter);
              };
            }
          }
        }).remove();
      }

      this.radarPath = null;
    }
  },
  _getRadarPathStyle: function () {
    var series = this,
        hasFill = series.fillColor && series.fillColorOpacity,
        target = series.vanchart.highlightTarget;
    var fillOpacity = series.fillColorOpacity,
        strokeOpacity = series.opacity; // target为""也可触发高亮

    if ((0, _CoreUtils.hasDefined)(target)) {
      fillOpacity = target == series.name ? 1 : _Constants["default"].HOVER_OPACITY;
      strokeOpacity = target == series.name ? 1 : _Constants["default"].HOVER_OPACITY;
    }

    var _series$options = series.options,
        lineWidth = _series$options.lineWidth,
        lineType = _series$options.lineType;
    var lineStyle = (0, _StyleUtils.getLineStyle)({
      color: series.color,
      lineWidth: lineWidth,
      lineType: lineType,
      opacity: strokeOpacity
    });
    var fillStyle = {
      'fill': hasFill ? series.fillColor : 'none',
      'fill-opacity': fillOpacity
    };
    return _BaseUtils["default"].extend({}, lineStyle, fillStyle);
  },
  _getFillHighLightStyle: function () {
    var series = this,
        hasFill = series.fillColor && series.fillColorOpacity;
    return {
      'fill': hasFill ? _ColorUtils["default"].getHighLightColor(series.fillColor) : 'none',
      'fill-opacity': series.fillColorOpacity === 0 ? 0 : series.fillColorOpacity + 0.35
    };
  },
  _getStrokeStyle: function (isOnHighLight) {
    var series = this;
    var color = series.color,
        opacity = series.opacity,
        options = series.options;
    var lineWidth = options.lineWidth,
        lineType = options.lineType;
    var width = _Constants["default"].DASH_ARRAY[lineType] == null ? 0 : lineWidth;
    var stroke = isOnHighLight ? _ColorUtils["default"].getHighLightColor(color) : color;
    return {
      'stroke': stroke,
      'stroke-width': width,
      'stroke-opacity': opacity
    };
  },
  getStyle: function () {
    return {};
  },
  effectAnimation: function (d) {
    _EffectHelper["default"].markerEffectAnimation(d);
  },
  getDefaultEffectTime: function () {
    return _EffectHelper["default"].MARKER_EFFECT_TIME;
  },
  _createPointGraphic: function (point) {
    return point.graphic = this._createMarker(point.options.marker);
  },
  _updatePointGraphicStyle: function (point) {
    this._updateMarkerPointGraphic(point);

    this._updateMarker(point);
  },
  // todo 拆分这个方法（还有折线图）
  getDataToDraw: function () {
    var series = this;
    return this.points.filter(function (p) {
      var hasMarker = p.options.marker && p.options.marker.symbol; // drawPoints只处理了有标记点的点。这里处理所有options无标记点，实际上却有图形对象的点。
      // 自动刷新，options无标记点更新之前options有标记点的点，要把之前的标记点删掉

      !hasMarker && p.graphic && series._drawExitPoints(p);
      return hasMarker;
    });
  },
  getTextDataToDraw: function () {
    return this.points;
  },
  onPointPress: function () {
    var point = this,
        series = point.series;

    series._onMarkerPressed(point);
  },
  onPointPressUp: function () {
    var point = this,
        series = point.series;

    series._updateMarker(point);
  },
  _calculateLabelPos: function () {},
  _getFixedPos: function (datum) {
    var radius = isNaN(datum.options.marker.radius) ? _Constants["default"].MARKER_RADIUS : datum.options.marker.radius,
        center = this.getCenter();
    var x, y;
    x = center[0] + datum.posX + radius;
    y = center[1] + datum.posY + radius;
    return [x, y];
  },

  /**
   * @override Series.calcMoreLabelPosition
   * @param  {[type]} point        [description]
   * @param  {[type]} moreLabelDim [description]
   * @return {[type]}              [description]
   */
  calcMoreLabelPosition: function (point, moreLabelDim) {
    var chartCenter = this.getCenter();
    var startX = point.posX + chartCenter[0],
        startY = point.posY + chartCenter[1];
    return {
      startX: startX,
      startY: startY,
      direction: "top"
    };
  },
  _onSeriesMouseOver: function (ev) {
    _Radar["default"].prototype._onSeriesMouseOver.call(this, ev);

    var series = this;
    var toCenter = series.fillColor && series.fillColorOpacity;

    if (series.radarPath) {
      series.radarPath.style(series._getStrokeStyle(true)).animate({
        duration: 200,
        ease: _BezierEasing["default"].custom["ease-out-back"],
        style: series._getFillHighLightStyle()
      }).attr({
        "d": series._getRadarSeriesPath(series.pathSegment, series.options.connectNulls, toCenter)
      });
    }

    this.toFrontPosition();
  },
  _onSeriesMouseOut: function () {
    var series = this;

    if (series.radarPath) {
      series.radarPath.style(series._getStrokeStyle()).animate({
        duration: 200,
        ease: _BezierEasing["default"].custom["ease-out-back"],
        style: series._getRadarPathStyle()
      });
    }
  },
  _seriesUnChosen: function () {
    this.resetPosition();
  },
  _onPointMouseOver: function (point) {
    point.series._onMarkerMouseOver(point);
  },
  _onPointMouseOut: function (point) {
    point.series._onMarkerMouseOut(point);
  },
  getPointInitAttr: function (point) {
    return {
      'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(0.01)'
    };
  },
  getPointInitAnimationAttr: function (point) {
    return {
      delay: LINE_SHOW_TIME,
      duration: MARKER_INIT_TIME,
      ease: MARKER_INIT_EASE,
      attr: {
        'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(1)'
      }
    };
  },
  getPointUpdateAnimationAttr: function (point) {
    return {
      ease: LINE_SHOW_EASE,
      duration: LINE_SHOW_TIME,
      attr: {
        'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(1)'
      }
    };
  },
  getPointDropAnimationAttr: function () {
    return {
      ease: EXIT_EASE,
      duration: EXIT_TIME,
      attr: {
        'transform': 'translate(' + 0 + ',' + 0 + ') scale(0.01)'
      }
    };
  },
  updatePointGraphic: function (point) {
    this._updateMarkerPointGraphic(point);
  },
  getClosestPoint: function (pos) {
    var center = this.getCenter(),
        minDistance = Number.MAX_VALUE;
    var selectedPoint;
    this.points.forEach(function (point) {
      var detX = point.posX + center[0] - pos.x;
      var detY = point.posY + center[1] - pos.y;
      var dis = Math.sqrt(detX * detX + detY * detY);

      if (dis < minDistance && !point.isNull) {
        selectedPoint = point;
        minDistance = dis;
      }
    });
    return selectedPoint;
  }
});

var _default = LineRadar;
exports["default"] = _default;

/***/ }),
/* 141 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Series = _interopRequireDefault(__webpack_require__(13));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _wrapper = _interopRequireDefault(__webpack_require__(37));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/5/9.
 */
var CHOSEN_TIME = 300;
var CHOSEN_EASE = 'ease';

var Map = _Series["default"].extend({
  initialize: function (options, vanchart, index) {
    _Series["default"].prototype.initialize.call(this, options, vanchart, index);

    this.on(this.getEvents(), this);
  },
  getTargetKey: function () {
    return 'value';
  },
  _getPointKey: function (point) {
    if (point.lnglat) {
      return point.lnglat.join('-');
    }

    return point.name;
  },
  effectAnimation: function (d) {
    var effectFun = this.type === _Constants["default"].POINT_MAP ? _EffectHelper["default"].pointMapEffectAnimation : _EffectHelper["default"].areaMapEffectAnimation;
    d.layers && d.layers.forEach(function (layer) {
      effectFun(layer, d);
    });
  },
  clearPointEffect: function (point) {
    var layers = point.layers;
    point.clearPointEffect();
    var isPointMap = this.type === _Constants["default"].POINT_MAP;
    layers && layers.forEach(function (layer) {
      // FixME: 理论上这个icon也应该是ElementWrapper
      var el = isPointMap ? (0, _wrapper["default"])(layer._icon) : layer._path;
      el && el.removeEffectTransition();
    });
  },
  getDefaultEffectTime: function () {
    return this.type === _Constants["default"].POINT_MAP ? _EffectHelper["default"].POINT_MAP_EFFECT_TIME : _EffectHelper["default"].AREA_STYLE_EFFECT_TIME;
  },
  _getFixedPos: function (point) {
    var vanchart = point.series.vanchart,
        type = point.series.type;
    var latlng = point.getLatLng();

    if (!latlng) {
      return;
    }

    var pos = vanchart.latLngToContainerPoint(latlng);

    if (type === _Constants["default"].AREA_MAP) {
      var detX = 0,
          detY = 0;

      if (point.options.dataLabels && point.labelDim && point.labelPos) {
        detX = point.labelDim.width / 2;
        detY = point.labelDim.height / 2;
      }

      return [pos.x + detX, pos.y + detY];
    }

    return [pos.x, pos.y];
  },
  getHighLightStyle: function (point) {
    return {
      'stroke': point.borderColor,
      'fill': point.mouseOverColor,
      'fill-opacity': point.opacity,
      'stroke-width': point.options.borderWidth + 1,
      'stroke-opacity': point.borderOpacity,
      'filter': this._getShadowFilter()
    };
  },
  getStyle: function (point) {
    var geo = point.series.vanchart.getCurrentGeo();

    if (point.isNull) {
      return geo.defaultAreaStyle();
    }

    return _Series["default"].prototype.getStyle.call(this, point);
  },
  _getShadowFilter: function () {
    var series = this,
        vanchart = series.vanchart,
        renderer = vanchart.mapRenderer;
    vanchart.mapShadowFilter = vanchart.mapShadowFilter || renderer.createDropShadowFilter(0, 1, 0.5, 2);
    return renderer.toPatternProperty(vanchart.mapShadowFilter);
  },
  _onPointMouseOver: function (point) {
    var style = this.getHighLightStyle(point);

    this._onState(point, true, style);
  },
  _onPointMouseOut: function (point) {
    var style = this.getStyle(point);

    this._onState(point, false, style);
  },
  _onState: function (point, isChosen, style) {
    var series = point.series;

    point._mapPointOnMouseState(isChosen, CHOSEN_TIME, CHOSEN_EASE, style);

    point.textLayers && point.textLayers.forEach(function (layer) {
      series.type === _Constants["default"].POINT_MAP ? layer._transformState(isChosen) : layer._fontSizeState(isChosen, CHOSEN_TIME, CHOSEN_EASE);
    });
  },
  getDefaultTooltipFormatter: function () {
    return {
      areaNameFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{NAME}{SERIES}{VALUE}{SIZE}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = Map;
exports["default"] = _default;

/***/ }),
/* 142 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _TreeSeries = _interopRequireDefault(__webpack_require__(79));

var _PieSeries = _interopRequireDefault(__webpack_require__(80));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 16/6/15.
 */
var INNER_RADIUS_PCT = 2 / 3;
var INNER_RING_RADIUS = 15;
var INNER_RING_STROKE_WIDTH = 5;
var CIRCLE = 2 * Math.PI;
var HOVER_PERCENT = 1.1;
var VIS_MIN = 1E-10;
var ANIMATION_TIME = 1000;
var INNER_HOVER_TIME = 300;
var SORT_TIME = 400;
var EASE = 'bounce';
var INNER_HOVER_EASE = _BezierEasing["default"].css.swing;
var SORT_EASE = _BezierEasing["default"].css.swing;

var MultiPie = _TreeSeries["default"].extend(_PieSeries["default"]).extend({
  isFlowTouch: function () {
    return false;
  },
  // prop list
  //
  // nodes: [],
  //
  // root: null,
  //
  // ordered: null,
  //
  // drilldownNow: null,
  //
  // // for convenient
  // center: [],
  // innerRadius: null,
  // radius: null,
  // startAngle: null,
  // endAngle: null,
  // drilldown: null,
  // rotatable: null,
  //
  // chartInfo: {},
  arc: _PathGenerator["default"].arc().startAngle(function (d) {
    return d.x;
  }).endAngle(function (d) {
    return d.x + d.dx;
  }).innerRadius(function (d) {
    return d.y;
  }).outerRadius(function (d) {
    return d.y + d.dy;
  }),
  _refresh: function () {
    var rotate = this.chartInfo && this.chartInfo.rotate || 0;
    this.chartInfo = {
      rotate: rotate
    };
    this.sx = _Scale["default"].linear();
    this.sy = _Scale["default"].linear();
  },
  visitAfter: function (node) {
    var c = node.children;
    var _value = node.options.value;
    _value = isNaN(_value) ? 0 : _value;
    node.chSum = _value;

    if (c && (n = c.length)) {
      var chSum = 0,
          i = -1,
          n;

      this._calculatePercentage(c, 'value');

      while (++i < n) {
        chSum += Math.abs(c[i].chSum);
      }

      var orderType = this.orderType; // #orderData

      c.sort(function (a, b) {
        if (orderType && a.value != null && b.value != null) {
          return orderType * (Math.abs(a.value) - Math.abs(b.value));
        } else {
          return a.index - b.index;
        }
      });
      node.chSum = Math.max(chSum, Math.abs(_value || 0));
    }

    node.value = _value || node.chSum || 0;

    if (!node.visible) {
      // value is visible size
      // chSum is hold size(include blank)
      node.value = 0;
      node.chSum = 0;
    }
  },
  _visitBefore: function (node) {
    node.isNull = false;

    if (!node.depth) {
      return;
    }

    if (node.depth === 1) {
      node.points = [node];
    } else {
      node.points = node.parent.points.slice();
      node.points.push(node);
    }
  },
  doLayout: function () {
    var series = this;
    var center = [],
        bounds;
    var plotBounds = this.vanchart.bounds;
    var options = series.options;

    if (!options.center || options.center.length === 0) {
      center = [plotBounds.width / 2 + plotBounds.x, plotBounds.height / 2 + plotBounds.y];
    } else {
      center[0] = this._getPercentValue(options.center[0], this.vanchart.width);
      center[1] = this._getPercentValue(options.center[1], this.vanchart.height);
    }

    bounds = {
      x: plotBounds.x,
      y: plotBounds.y,
      width: plotBounds.width,
      height: plotBounds.height
    };
    series.chartInfo.innerRadius = options.innerRadius;
    series.chartInfo.center = center;
    series.chartInfo.bounds = bounds;
    this.traverseData(this.root, this._visitBefore, this.visitAfter);

    this._initData(series); // recover when series dis/hide,


    this.drilldownNow = this.root;
  },
  _initData: function (series) {
    series.nodes = series._bfsTraverseData(series.root); // #orderData

    var oldGraphics = series.graphics;

    if (this._isOrderChanged() && oldGraphics && oldGraphics.length === series.nodes.length) {
      series.nodes.map(function (node, i) {
        // exchange the displayed graphic
        node._view = oldGraphics[i];
      });
    }

    var chartInfo = series.chartInfo;
    var options = series.options;
    var radius = chartInfo.radius || options.radius;

    if (radius) {
      series._calcData(series.root);

      series._calculateLabelPos();
    } else {
      // if no radius
      // calculated radius
      // thus calc only once
      var bounds = chartInfo.bounds;
      var center = chartInfo.center;
      chartInfo.radius = Math.min(center[0] - bounds.x, bounds.x + bounds.width - center[0], center[1] - bounds.y, bounds.y + bounds.height - center[1]);

      series._calcData(series.root);

      var outPoints = series.nodes.filter(function (node) {
        return node.depth && node.dx && node.options.dataLabels && node.options.dataLabels.enabled && node.options.dataLabels.align === _Constants["default"].OUTSIDE;
      });

      if (outPoints.length) {
        chartInfo.radius = series.calcOutsideLabel(outPoints, chartInfo.bounds, chartInfo.center);
      } else {
        chartInfo.radius = Math.round(chartInfo.radius / HOVER_PERCENT);
      }

      series._calcData(series.root);

      series._calculateLabelPos();
    }

    series.sx = this.sx.range([this.startAngle, this.endAngle]).domain([this.startAngle, this.endAngle]);
    series.sy = this.sy.range([0, this.innerRadius, this.radius]).domain([0, this.innerRadius, this.radius]);
  },
  getDataToDraw: function () {
    return this.nodes;
  },
  orderData: function (para) {
    // #orderData
    // search '#orderData' in this file to get hint
    // some explain:
    // http://www.finedevelop.com/pages/viewpage.action?pageId=11243711
    this.orderType = para === true ? 1 : para === false ? -1 : null;

    this._saveLastView();
  },
  _saveLastView: function () {
    this.graphics = this.nodes.map(function (node) {
      return node._view;
    });
  },
  _bfsTraverseData: function (root) {
    var queue = [];
    var stack = [];
    queue.push(root);

    while (node = queue.shift()) {
      var node;
      stack.push(node);
      var children = node.children;

      if (children && (n = children.length)) {
        var i = -1,
            n;

        while (++i < n) {
          queue.push(children[i]);
        }
      }
    }

    return stack;
  },
  _calcData: function (root) {
    var series = this;

    if (series.chartInfo.radius && series.options.innerRadius) {
      series.chartInfo.innerRadius = this._getPercentValue(series.options.innerRadius, series.chartInfo.radius);
    }

    var height = root.height;
    var radius = series.chartInfo.radius;
    var innerRadius = series.chartInfo.innerRadius;
    var gradual = series.options.gradual;
    var startAngle = series.startAngle;
    var endAngle = series.endAngle;
    var arc = endAngle - startAngle;
    var dRadius, innerPieR; // display !== options value
    // the first ring (depth = 1) radius depends on innerRadius

    if (innerRadius) {
      dRadius = height ? (radius - innerRadius) / height : 0;
      innerPieR = dRadius;
    } else {
      dRadius = height > 1 ? radius * (1 - INNER_RADIUS_PCT) / (height - 1) : 0;
      innerPieR = height > 1 ? radius * INNER_RADIUS_PCT : radius;
    } // hdx is 'hold dx', hdx >= dx, may leave blank.


    function dfsData(node, x, dx, hdx, dy, ir, iPr) {
      var children = node.children; // save last value for enter (dx 0)
      // note: if calculate twice,
      // it has no meaning

      node.x1 = node.x;
      node.y1 = node.y;
      node.dx1 = node.dx;
      node.dy1 = node.dy; // going to display

      node.x = x;
      node.y = (node.depth - 2) * dy + ir + iPr;
      node.dx = dx;
      node.hdx = hdx;
      node.dy = dy; // adjust values

      if (node.depth) {
        if (node.depth === 1 && !ir) {
          node.y = 0;
          node.dy = iPr;
        } // outside label may be revised to inside,
        // otherwise do nothing


        var options = node.options;

        if (options.dataLabels && options.dataLabels.enabled) {
          // clone once only
          if (!options.dataLabels._align && options.dataLabels.align === _Constants["default"].OUTSIDE) {
            options.dataLabels = _BaseUtils["default"].clone(options.dataLabels);
            options.dataLabels._align = options.dataLabels._align || options.dataLabels.align;
          }

          if (options.dataLabels._align === _Constants["default"].OUTSIDE) {
            if (node.depth === height) {
              options.dataLabels.align = _Constants["default"].OUTSIDE;
            } else {
              options.dataLabels.align = _Constants["default"].INSIDE;
            }
          }
        }

        series._setColor(node, gradual, height);

        series.calculateLabelInfo(node);
      } else {
        // -1 to avoid dy=0, thus invalidate drill down scale
        node.y = -1;
        node.dy = ir + 1;
      } // save origin for drillDown


      node._x = node.x;
      node._dx = node.dx;
      node._hdx = node.hdx;
      node._y = node.y;
      node._dy = node.dy;

      if (children && (n = children.length)) {
        var i = -1,
            n,
            c,
            d,
            hd;
        dx = node.value ? dx / (Math.abs(node.value) || 1) : 0;
        hdx = node.chSum ? hdx / (Math.abs(node.chSum) || 1) : 0;

        while (++i < n) {
          c = children[i];
          d = Math.abs(c.value) * dx;
          hd = Math.abs(c.chSum) * hdx;
          dfsData(c, x, d, hd, dy, ir, iPr);
          x += hd;
        }
      }
    }

    dfsData(root, startAngle, arc, arc, dRadius, innerRadius, innerPieR);
  },
  _setColor: function (node, gradual, height) {
    if (!(node && gradual && height)) {
      return;
    }

    if (node.options.color) {
      node.color = node.options.color;
    } else {
      var rgba = _ColorUtils["default"].getRGBAColorArray(node.ancestor.color);

      var hsb = _ColorUtils["default"].rgb2hsb(rgba[0], rgba[1], rgba[2]);

      var detS, detB;
      var ratio = (node.depth - 1) / height;

      if (gradual === _Constants["default"].GRADUAL_LIGHTER) {
        detS = -hsb[1] * ratio;
        detB = (1 - hsb[2]) * ratio;
      } else {
        detS = (1 - hsb[1]) * ratio;
        detB = -hsb[2] * ratio;
      }

      node.color = _ColorUtils["default"].mixColorWithHSB(node.ancestor.color, 0, detS, detB);
    }

    if (node.options.mouseOverColor) {
      node.mouseOverColor = node.options.mouseOverColor;
    } else {
      var detS, detB;

      if (gradual === _Constants["default"].GRADUAL_LIGHTER) {
        detS = +0.1;
        detB = -0.05;
      } else {
        detS = -0.1;
        detB = +0.05;
      }

      node.mouseOverColor = _ColorUtils["default"].mixColorWithHSB(node.options.tooltip && node.options.tooltip.enabled && node.options.tooltip.shared ? node.ancestor.color : node.color, 0, detS, detB);
    }

    var hexAlpha = _ColorUtils["default"].getStandardColorAndOpacity(node.color, node.options.opacity);

    node.color = hexAlpha.hex;
    node.opacity = hexAlpha.alpha;
  },
  _calculateLabelPos: function () {
    var series = this;
    var outPoints = [];
    var inPoints = [];
    series.nodes.map(function (node) {
      node.labelPos = null;
      var option = node.options,
          drillDownNow = series.drilldownNow; // CHART-1218
      // 设置标签牵引线，需要显示value等于0的时候的的标签

      if (node.name && node.depth && (drillDownNow ? node !== drillDownNow.parent : true) && option.dataLabels && option.dataLabels.enabled) {
        if (option.dataLabels.align === _Constants["default"].OUTSIDE) {
          this.needShowOutsidePointDataLabel(node) && outPoints.push(node);
        } else {
          node.dx && node.dy && node.dx >= VIS_MIN && inPoints.push(node); //标签在内部时,弧度为0即不显示标签
        }
      }
    }, series);
    var chartInfo = series.chartInfo;
    series.calcOutsideLabel(outPoints, chartInfo.bounds, chartInfo.center, chartInfo.radius);
    series.calculateLeadLineStartPos(outPoints);
    series.calculateInsideLabelBounds(inPoints);
  },

  /**
   * 当dataLabel的标签在外侧时，判断是否需要显示标签，判断条件大致如下：
   * 默认情况下值为0时，在外需要显示标签的
   * 钻取的时候，如果不属于drillDownNow的后代node，那么就不需要显示标签
   * @param node
   */
  needShowOutsidePointDataLabel: function (node) {
    var drillDownNow = this.drilldownNow;

    if (!drillDownNow) {
      return true;
    }

    if (node === drillDownNow) {
      return true;
    }

    var find = false;

    while (node.parent) {
      node = node.parent;

      if (node === drillDownNow) {
        find = true;
        break;
      }
    }

    return find;
  },
  _getInnerRadius: function (d) {
    return d.y;
  },
  _getOuterRadius: function (d) {
    return d.y + d.dy;
  },
  _getStartAngle: function (d) {
    return d.x;
  },
  _getEndAngle: function (d) {
    return d.x + d.dx;
  },
  _getPositionInPie: function (absPos) {
    var x = absPos.x - this.chartInfo.center[0];
    var y = absPos.y - this.chartInfo.center[1];
    return {
      x: x,
      y: y
    };
  },
  _getFixedPos: function (datum, divDim) {
    var translateX = this.chartInfo.center[0];
    var translateY = this.chartInfo.center[1];
    var centerAngle = this.getCenterAngle(datum);
    var radius = (datum.y + datum.dy) * HOVER_PERCENT;
    var centerX = radius * Math.sin(centerAngle) + translateX;
    var centerY = radius * Math.cos(centerAngle + Math.PI) + translateY;

    if (centerAngle < Math.PI / 2) {
      centerY -= divDim.height;
    } else if (centerAngle >= Math.PI && centerAngle < 3 * Math.PI / 2) {
      centerX -= divDim.width;
    } else if (centerAngle >= 3 * Math.PI / 2 && centerAngle < CIRCLE) {
      centerY -= divDim.height;
      centerX -= divDim.width;
    }

    return [centerX, centerY];
  },
  drillDown: function (d) {
    this.vanchart.clearAllEffects();
    this.drilldownNow = d;
    var radius = this.chartInfo.radius;
    var innerRadius = this.chartInfo.innerRadius;

    function deepest(node) {
      var children = node.children;
      var dc = node;

      if (children && (n = children.length)) {
        var i = -1,
            n;

        while (++i < n) {
          var c = deepest(children[i]);

          if (c.depth > dc.depth) {
            dc = c;
          }
        }
      }

      return dc;
    }

    var yDomain, yRange;

    if (d.depth) {
      var rootHeight = d.ancestor.parent.height; // outer ring

      if (d.height === 0) {
        yDomain = [d.parent._y, d._y, d._y + d._dy];
        yRange = [0, INNER_RING_RADIUS, radius];
      } else // deepest child is not outer ring
        if (d.height + d.depth !== rootHeight) {
          var dc = deepest(d);
          yDomain = [d.parent._y, d._y, d._y + d._dy, dc._y + dc._dy, radius];
          yRange = [0, INNER_RING_RADIUS, radius / 2, radius, radius];
        } else {
          yDomain = [d.parent._y, d._y, d._y + d._dy, radius];
          yRange = [0, INNER_RING_RADIUS, radius / 2, radius];
        }
    } else {
      yDomain = [0, innerRadius, radius];
      yRange = [0, innerRadius, radius];
    }

    var h = d.depth + d.height;
    this.sx.domain([d._x, d._x + d._dx]);
    this.sy.domain(yDomain).range(yRange);
    this.nodes.map(function (node) {
      if (node.depth && node.dataLabels && node.dataLabels.enabled && node.dataLabels._align === _Constants["default"].OUTSIDE) {
        if (node.depth === h) {
          node.dataLabels.align = _Constants["default"].OUTSIDE;
        } else {
          node.dataLabels.align = _Constants["default"].INSIDE;
        }

        _QueryUtils["default"].merge(node, this.calculateLabelInfo(node), true);
      }

      node.x = this.safeAngle(node._x);
      node.dx = this.safeAngle(node._x + node._dx) - node.x;
      node.y = this.safeRadius(node._y);
      node.dy = this.safeRadius(node._y + node._dy) - node.y;

      if (node === this.drilldownNow.parent) {
        node.dx = this.safeAngle(7); // to ensure inner pie fill the circle.
      }
    }, this);

    this._calculateLabelPos();

    this.drawDrillDown(d);
  },
  safeAngle: function (x) {
    return Math.max(this.startAngle, Math.min(this.endAngle, this.sx(x)));
  },
  safeRadius: function (y) {
    return Math.max(0, this.sy(y));
  },
  _getTranslate: function () {
    return this.chartInfo.center;
  },

  /**
   * @override Series.calcMoreLabelPosition
   * @param  {[type]} point [description]
   * @return {[type]}       [description]
   */
  calcMoreLabelPosition: function (point) {
    var translateX = this.chartInfo.center[0];
    var translateY = this.chartInfo.center[1];
    var rotate = point.rotate || 0;
    var angle = rotate + point.x + point.dx / 2;
    var r = point.y + point.dy / 2;

    var center = this._getArcPoint(r, angle);

    return {
      startX: center[0] + translateX,
      startY: center[1] + translateY,
      direction: "top"
    };
  },
  effectAnimation: function (dom, d) {
    _EffectHelper["default"].areaStyleEffectAnimation(dom, d);
  },
  getDefaultEffectTime: function () {
    return _EffectHelper["default"].AREA_STYLE_EFFECT_TIME;
  },
  getStyle: function (p) {
    return {
      'display': p.name || !p.depth ? '' : 'none',
      'fill': p.color,
      'fill-opacity': p.depth ? p.opacity : 0,
      'stroke': p.options.borderColor,
      'stroke-opacity': p.depth ? p.options.borderOpacity : 0,
      'stroke-width': p.options.borderWidth
    };
  },
  getAttrs: function (p) {
    return {
      'd': this.arc(p)
    };
  },
  getPointGraphicKey: function () {
    return 'path';
  },
  getChartNodes: function () {
    return this.nodes;
  },
  getCenter: function () {
    return this.center;
  },
  getRadius: function () {
    return this.radius;
  },
  getDrilldown: function () {
    return this.options.drilldown;
  },
  _getPointGraphicGroup: function () {
    if (!this.wrapGroup) {
      this.wrapGroup = this.group.append(this.vanchart.renderer.group());
      this.drawRing();
    }

    return this.wrapGroup;
  },
  // don't know why here ...
  // _getPointTextLabelGroup:function(){
  //     if(!this.textLabelGroup){
  //         this.textLabelGroup = this.group.append(this.vanchart.renderer.group());
  //     }
  //     return this.textLabelGroup;
  // },
  drawRing: function () {
    if (this.ringPath || false) {
      return;
    }

    this.ringPath = this.group.append(this.vanchart.renderer.path());
    this.ringPath.attr({
      'd': _PathGenerator["default"].arc().startAngle(0).endAngle(Math.PI * 2).innerRadius(INNER_RING_RADIUS).outerRadius(INNER_RING_RADIUS + INNER_RING_STROKE_WIDTH)()
    }).style({
      'display': 'none',
      'fill': 'rgba(0,0,0,0.1)',
      'pointer-events': 'none'
    });
  },
  drawDrillDown: function (target) {
    var series = this;
    var supportAnimation = series.vanchart.renderer.isAnimation;

    series._removeDataLabels();

    var arc = series.arc;

    if (supportAnimation) {
      var n = 0;
      series.nodes.filter(function (node) {
        return node.graphic;
      }).map(function (p) {
        p.graphic.transition().ease('cubic-in-out').each('start', function () {
          ++n;
        }).duration(ANIMATION_TIME).style('fill', p.color).attrTween("d", function () {
          var i = (0, _interpolator["default"])(p._view, {
            x: p.x,
            y: p.y,
            dx: p.dx,
            dy: p.dy
          });
          return function (t) {
            var b = i(t);
            p._view = b;
            return arc(b);
          };
        }) // following handle the small edge things,
        // doesn't matter to the main animation...
        .attrTween('opacity', function () {
          return function (t) {
            return p.depth && p._view.y + p._view.dy >= INNER_RING_RADIUS ? 1 : 0;
          };
        }).each('end', function () {
          p.graphic && p.graphic.attr('opacity', p.depth && p.dx && p.y + p.dy > INNER_RING_RADIUS ? 1 : 0);

          if (! --n) {
            series._animateEnd();

            series.ringPath.style('display', target && target.depth ? '' : 'none');
          }
        });
      });

      if (!target.depth) {
        series.ringPath.transition().style('display', 'none');
      }
    } else {
      series.nodes.map(function (d) {
        d.graphic.attr({
          'd': arc(d),
          'opacity': d.depth && d.dx && d.y + d.dy > INNER_RING_RADIUS ? 1 : 0
        });
      });

      series._animateEnd(target);

      if (!(0, _EnvUtils.isSupportSVG)()) {
        series.root.graphic.style({
          'fill': 'rgba(0,0,0,0)'
        });
      }

      series.ringPath.style('display', target.depth ? '' : 'none');
    }
  },
  _animateEnd: function () {
    if (!this.vanchart.renderer) {
      return; //has been removed
    } // for mPie's order animation


    this.ordered = this.orderType;

    this._showLabels();

    this._drawEffectPoints();
  },
  _isOrderChanged: function () {
    return this.ordered !== this.orderType;
  },
  // animation
  initialAnimation: function () {
    this.wrapGroup.animate({
      duration: ANIMATION_TIME,
      ease: _BezierEasing["default"].css["ease-out-cubic"],
      attrTween: {
        transform: function () {
          var i = (0, _interpolator["default"])(-360, 0);
          var j = (0, _interpolator["default"])(0, 1);
          return function (t) {
            var rotate = i(t),
                scale = j(t);
            return 'rotate(' + rotate + ')' + 'scale(' + scale + ')';
          };
        }
      }
    });
  },
  getPointUpdateAnimationAttr: function (p) {
    var arc = this.arc;

    var isChanged = this._isOrderChanged();

    var ease = isChanged ? SORT_EASE : EASE;
    var aTime = isChanged ? SORT_TIME : ANIMATION_TIME;
    p.graphic.attr("opacity", p.depth ? 1 : 0); // hide inner circle

    this.ringPath.style('display', this.drilldownNow.depth ? '' : 'none');
    return {
      ease: ease,
      duration: aTime,
      attrTween: {
        d: function () {
          var self = this;
          var i = (0, _interpolator["default"])(p._view, {
            x: p.x,
            y: p.y,
            dx: p.dx,
            dy: p.dy
          });
          return function (t) {
            var b = i(t);
            p._view = b;
            return arc(b);
          };
        }
      }
    };
  },
  getPointInitAnimationAttr: function (p) {
    var arc,
        data,
        series = p.series;

    if (series.initialAnimationMoving) {
      // this.initialAnimation();
      // Interpolator will check every key in b,
      // so give it a simple object is better
      data = {
        x: p.x,
        y: p.y,
        dx: p.dx,
        dy: p.dy
      };
    } else {
      data = {
        x: p.x1,
        y: p.y1,
        dx: p.dx1,
        dy: p.dy1
      };
    }

    arc = series.arc(data); // for animation calc and #orderData

    p._view = data;
    var attr = {
      d: arc,
      opacity: p.depth ? 1 : 0 // hide inner circle

    };

    if (!series.initialAnimationMoving) {
      p.graphic.attr(attr);
      return series.getPointUpdateAnimationAttr(p);
    }

    return {
      attr: attr
    };
  },
  getPointDropAnimationAttr: function (d) {
    return this.getPointUpdateAnimationAttr(d);
  },
  // event
  onPointMouseOver: function (point) {
    this._onState(point, true);
  },
  onPointMouseOut: function (point) {
    this._onState(point, false);
  },
  _onState: function (point, isChosen) {
    if (point.options.tooltip && point.options.tooltip.shared) {
      var p,
          node = point;

      while ((p = node.parent) && p.depth && p.y + p.dy !== INNER_RING_RADIUS) {
        node = p;

        p.series._onSingleState(p, isChosen);
      }
    }

    point.series._onSingleState(point, isChosen);
  },
  _onSingleState: function (point, isChosen) {
    var series = point.series,
        animation = series.options.animation; // var pathNode = point.graphic.rawElement;

    var style = {},
        attr = {};

    if (point.depth && point._view.y1 + point._view.dy1 === INNER_RING_RADIUS) {
      attr = {
        'opacity': isChosen ? 1 : 0
      };
    } else {
      style = {
        'fill-opacity': isChosen ? 1 : point.opacity,
        'fill': isChosen ? point.mouseOverColor : point.color
      };
    }

    if (animation) {
      series._onPointState(point, isChosen, style, attr);

      series._onTextState(point, isChosen);
    } else {
      point.graphic.attr(attr).style(style);

      if (!point.depth && !(0, _EnvUtils.isSupportSVG)()) {
        point.graphic.style('fill', 'rgba(0,0,0,0)');
      }
    }
  },
  allowDrillDown: function (point) {
    if (!this.getDrilldown()) {
      return false;
    }

    if (this.drilldownNow === point) {
      return false;
    }

    var p,
        node = point;

    while ((p = node.parent) && p.depth) {
      node = p;

      if (!p.name) {
        return false;
      }
    }

    return true;
  },
  onPointTap: function (point) {
    // check in point._onPointTap
    // if (this.allowDrillDown(point)) {
    this.drillDown(point); // }
  },
  isSupportLegendHighlight: function () {
    return false;
  },
  getDefaultTooltipFormatter: function () {
    return {
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{NAME}{SERIES}{VALUE}",
      nameFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

MultiPie.prototype._calculateLabelPosWhenRadiusFixed = MultiPie.prototype._calculateLabelPos;
var _default = MultiPie;
exports["default"] = _default;

/***/ }),
/* 143 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _Series = _interopRequireDefault(__webpack_require__(13));

var _PieSeries = _interopRequireDefault(__webpack_require__(80));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/7/13.
 */
var CIRCLE = 2 * Math.PI;
var HOVER_PERCENT = 1.1;
var MAGIC_DET = 3; //很奇怪的3px

var ANIMATION_TIME = 1000;
var EASE = 'bounce';
var SORT_EASE = _BezierEasing["default"].css.swing;
var SORT_TIME = 400;
var LIMIT_MIN_ANGLE = 1e-7;

var Pie = _Series["default"].extend({
  // 10.0 流式布局，单个普通饼图
  isFlowTouch: function () {
    return this.vanchart.isFlowTouchPie();
  },
  _getAxisTypes: function () {
    return [];
  },
  doLayout: function () {
    //计算整个圆的位置和大小
    var seriesBounds = this._calculateSeriesBounds(),
        pie = this;

    if (!seriesBounds && !this.options.radius && !this.options.center) {
      throw new Error('pie has no bounds');
    }

    var centerX, centerY, radius;

    if (seriesBounds) {
      radius = this.options.radius || Math.min(seriesBounds.width / 2, seriesBounds.height / 2);
      centerX = seriesBounds.x + seriesBounds.width / 2;
      centerY = seriesBounds.y + seriesBounds.height / 2;
      this.bounds = seriesBounds;
    } else {
      radius = this.options.radius;
      centerX = this._getPercentValue(this.options.center[0], this.vanchart.width);
      centerY = this._getPercentValue(this.options.center[1], this.vanchart.height);
    }

    var rotate = this.chartInfo && this.chartInfo.rotate || 0;
    this.chartInfo = {
      radius: radius,
      centerX: centerX,
      centerY: centerY,
      rotate: rotate
    }; //计算每个扇形的大小

    var pieLayout = PieLayout().value(function (d) {
      return pie.options.roseType == _Constants["default"].SAME_ARC ? 1 : Math.abs(d.getTargetValue());
    }).startAngle(pie.startAngle).endAngle(pie.endAngle);
    var points = this.points.filter(function (p) {
      return p.isVisible();
    });
    var series = this;
    points.forEach(function (point) {
      point.lastShape = series._getArcData(point);
    });
    pieLayout(points);
  },
  _getFixedPos: function (datum, divDim) {
    var plotBounds = this.vanchart.bounds;
    var pieConfig = datum.series.chartInfo;
    var translateX = pieConfig.centerX;
    var translateY = pieConfig.centerY;
    var centerAngle = this.getCenterAngle(datum);
    var radius = datum.outerRadius * HOVER_PERCENT;
    var centerX = radius * Math.sin(centerAngle) + translateX;
    var centerY = radius * Math.cos(centerAngle + Math.PI) + translateY;

    if (centerAngle < Math.PI / 2) {
      centerY -= divDim.height;
    } else if (centerAngle >= Math.PI && centerAngle < 3 * Math.PI / 2) {
      centerX -= divDim.width;
    } else if (centerAngle >= 3 * Math.PI / 2 && centerAngle < CIRCLE) {
      centerY -= divDim.height;
      centerX -= divDim.width;
    }

    return [centerX, centerY];
  },
  // 12345，我们数一数：到底有多少种radius？
  // chartInfo.radius - 计算结果，来源：
  // 1. options.radius: 定义radius, 用户要什么给什么，省心省力；
  //    据此判断是否需要计算调整
  // 2. bounds/2 : 未定义radius，平分剩余区域
  // 3. chartInfo.seriesMinRadius: 多个系列自动计算取最小的radius (CHART-947)
  _calculateLabelPos: function () {
    var roseType = this.options.roseType,
        points = this.points.filter(function (d) {
      return d.visible;
    });
    var outPoints = [],
        inPoints = [];

    for (var i = 0, len = points.length; i < len; i++) {
      var point = points[i];
      var dataLabels = point.options.dataLabels;

      if (point.visible && dataLabels && dataLabels.enabled) {
        dataLabels.align == _Constants["default"].OUTSIDE ? outPoints.push(point) : inPoints.push(point);
      }
    } //这步会改变半径


    this._calculateOutsideLabelBounds(outPoints);

    if (this._shouldCalcRadius()) {
      //有标签在里面,没有标签在外面或者不显示标签
      if (inPoints.length && !outPoints.length || !inPoints.length && !outPoints.length) {
        this.chartInfo.radius = this.chartInfo.radius / HOVER_PERCENT - MAGIC_DET;
      }
    } //内径可能是半径的占比


    var innerRadius = this.options.innerRadius || 0,
        radius = this.chartInfo.radius;

    if (innerRadius) {
      if (typeof innerRadius == 'string' && innerRadius.indexOf('%') != -1) {
        innerRadius = parseFloat(innerRadius) * radius / 100;
      } else {
        innerRadius = parseFloat(innerRadius);
      }
    }

    this.chartInfo.innerRadius = innerRadius;
    this.points.forEach(function (d) {
      d.innerRadius = innerRadius;
    }); //玫瑰图根据最后的半径值来确定不同扇形的半径

    if (roseType) {
      var radiusGap = radius - innerRadius;
      var maxValue = 0;
      points.forEach(function (d) {
        maxValue = Math.max(maxValue, Math.abs(d.getTargetValue()));
      });
      var sizePerValue = radiusGap / maxValue; //maxValue为0之类的情况

      if (isNaN(sizePerValue) || !isFinite(sizePerValue)) {
        sizePerValue = 0;
      }

      points.forEach(function (d) {
        d.outerRadius = innerRadius + sizePerValue * Math.abs(d.getTargetValue());
      });
    } else {
      this.points.forEach(function (d) {
        d.outerRadius = radius;
      }); //inVisible也要给最新的out，动画需要
    }

    this.calculateLeadLineStartPos(outPoints); //确定半径以后计算标签在内的标签

    this.calculateInsideLabelBounds(inPoints);
  },
  // in fact, seriesMinRadius is like a flag
  // chartInfo.radius is the value key
  // see _calculateOutsideLabelBounds
  adjustRadius: function (radius) {
    if (this.chartInfo.radius !== radius) {
      this.chartInfo.seriesMinRadius = radius;
      this.chartInfo.radius = radius;

      this._calculateLabelPos();
    }
  },
  _calculateLabelPosWhenRadiusFixed: function () {
    var points = this.points.filter(function (d) {
      return d.visible;
    });
    var outPoints = [],
        inPoints = [];

    for (var i = 0, len = points.length; i < len; i++) {
      var point = points[i];
      var dataLabels = point.options.dataLabels;

      if (dataLabels && dataLabels.enabled) {
        dataLabels.align == _Constants["default"].OUTSIDE ? outPoints.push(point) : inPoints.push(point);
      }
    }

    this._calculateLabelBoundsForFixed([this.chartInfo.centerX, this.chartInfo.centerY], this.chartInfo.radius, outPoints);

    this.calculateLeadLineStartPos(outPoints); //确定半径以后计算标签在内的标签

    this.calculateInsideLabelBounds(inPoints);
  },
  _calculateOutsideLabelBounds: function (outPoints) {
    if (!outPoints.length) {
      return;
    } //清空计算结果


    outPoints.forEach(function (arc) {
      arc.labelPos = null;
    });
    var chartInfo = this.chartInfo;
    var radius = chartInfo.radius;
    var center = [chartInfo.centerX, chartInfo.centerY];

    if (this._shouldCalcRadius()) {
      this.chartInfo.radius = this.calcOutsideLabel(outPoints, this.bounds, center);
    } else {
      this.calcOutsideLabel(outPoints, this.bounds, center, radius);
    }
  },
  _shouldCalcRadius: function () {
    return !this.options.radius && !this.chartInfo.seriesMinRadius;
  },
  //对于固定半径和圆心,计算牵引线的位置
  _calculateLabelBoundsForFixed: function (center, radius, outPoints) {
    var chartInfo = this.chartInfo;
    var radius = chartInfo.radius;
    var center = [chartInfo.centerX, chartInfo.centerY];
    this.calcOutsideLabel(outPoints, this.bounds, center, radius);
  },
  //计算每个系列的边界,要么定义了圆心和半径,作为悬浮元素处理,要么两者都不定义,自定平分区域
  //只定义半径没定义圆心,或者只定义了圆心没有定义半径,效果都是未知的
  _calculateSeriesBounds: function () {
    var series = this.vanchart.seriesOfType(_Constants["default"].PIE_CHART);
    var plotBounds = this.vanchart.bounds;
    var fixedSize = 0;

    for (var i = 0, len = series.length; i < len; i++) {
      if (series[i].options.center && series[i].options.radius) {
        fixedSize++;
      }
    } //平均半径


    var averageSize = plotBounds.width / Math.max(1, series.length - fixedSize);

    for (var i = 0, len = series.length; i < len; i++) {
      if (series[i] == this) {
        if (!this.options.center) {
          return {
            x: plotBounds.x + i * averageSize,
            y: plotBounds.y,
            width: averageSize,
            height: plotBounds.height
          };
        }
      }
    }
  },
  _getTranslate: function () {
    return [this.chartInfo.centerX, this.chartInfo.centerY];
  },
  _getArcData: function (d) {
    if ((0, _CoreUtils.hasDefined)(d.startAngle)) {
      return {
        startAngle: d.startAngle,
        endAngle: d.endAngle,
        outerRadius: d.outerRadius,
        innerRadius: d.series.chartInfo.innerRadius
      };
    }
  },

  /**
   * @override Series.calcMoreLabelPosition
   * @param  {[type]} point  [description]
   * @param  {[type]} divDim [description]
   * @return {[type]}        [description]
   */
  calcMoreLabelPosition: function (point, moreLabelDim) {
    var pieConfig = point.series.chartInfo;
    var translateX = pieConfig.centerX;
    var translateY = pieConfig.centerY;
    var centerAngle = this.getCenterAngle(point);
    var tmpR = point.series.chartInfo.innerRadius + (point.outerRadius - point.series.chartInfo.innerRadius) / 2;

    var pos = this._getArcPoint(tmpR, centerAngle);

    return {
      startX: translateX + pos[0],
      startY: translateY + pos[1],
      direction: "top"
    };
  },
  effectAnimation: function (d) {
    _EffectHelper["default"].areaStyleEffectAnimation(d);
  },
  getDefaultEffectTime: function () {
    return _EffectHelper["default"].AREA_STYLE_EFFECT_TIME;
  },
  getHighLightStyle: function (p) {
    var borderColor = p.getPointBorderColor(p.borderColor);
    return {
      'fill': p.series.getFillFilter(p.mouseOverColor || p.color, p),
      'fill-opacity': p.opacity,
      'stroke': borderColor,
      'stroke-width': p.options.borderWidth,
      'stroke-opacity': p.borderOpacity
    };
  },
  getPressedStyle: function (p) {
    var borderColor = p.getPointBorderColor(p.borderColor);
    return {
      'fill': p.series.getFillFilter(p.clickColor, p),
      'fill-opacity': p.clickOpacity,
      'stroke': borderColor,
      'stroke-width': p.options.borderWidth,
      'stroke-opacity': p.borderOpacity
    };
  },
  getAttrs: function (p) {
    var arc = _PathGenerator["default"].arc().innerRadius(p.innerRadius);

    return {
      'd': arc(this._getArcData(p))
    };
  },
  getPointGraphicKey: function () {
    return 'path';
  },
  _calculateAnimationDelay: function () {
    var visiblePoint = 0,
        graphicCount = 0;

    for (var i = 0, len = this.points.length; i < len; i++) {
      var point = this.points[i];

      if (point.visible && point.series.visible) {
        visiblePoint++;
      }

      if (point.graphic) {
        graphicCount++;
      }
    }

    return graphicCount == visiblePoint ? 0 : 1;
  },
  _createGroup: function (renderer, vanchart) {
    return renderer.group().addTo(vanchart.seriesGroup);
  },
  getPointInitAnimationAttr: function (point) {
    var series = point.series;

    var arc = _PathGenerator["default"].arc();

    return {
      ease: series.initialAnimationMoving ? _BezierEasing["default"].css["ease-out-cubic"] : EASE,
      duration: ANIMATION_TIME,
      attrTween: {
        'd': function () {
          var currentArc;

          if (series.initialAnimationMoving) {
            currentArc = {
              startAngle: point.startAngle - CIRCLE,
              endAngle: point.endAngle - CIRCLE,
              outerRadius: 0,
              innerRadius: 0
            };
          } else {
            var prePoint = series.getPreVisiblePoint(point);

            if (prePoint == 'first') {
              currentArc = {
                startAngle: series.startAngle,
                endAngle: series.startAngle,
                outerRadius: point.outerRadius
              };
            } else if (prePoint.lastShape) {
              var preGap = Math.abs(prePoint.lastShape.endAngle - prePoint.endAngle);
              var sliceStart = point.startAngle + preGap;
              currentArc = {
                startAngle: sliceStart,
                endAngle: sliceStart,
                outerRadius: point.outerRadius
              };
            } else {
              currentArc = {
                startAngle: point.startAngle,
                endAngle: point.endAngle,
                outerRadius: point.outerRadius,
                innerRadius: point.innerRadius
              };
            }
          }

          var interpolate = (0, _interpolator["default"])(currentArc, series._getArcData(point));
          this._current_ = interpolate(1);
          return function (t) {
            return arc(interpolate(t));
          };
        }
      }
    };
  },
  getPointUpdateAnimationAttr: function (point, delay) {
    var series = point.series,
        vanchart = series.vanchart;

    var arc = _PathGenerator["default"].arc();

    var easeFunc = EASE,
        animationTime = ANIMATION_TIME;

    if (vanchart.orderType === _Constants["default"].DESCENDING || vanchart.orderType == _Constants["default"].ASCENDING) {
      //排序的动画
      easeFunc = SORT_EASE;
      animationTime = SORT_TIME;
    }

    return {
      ease: easeFunc,
      duration: animationTime,
      attrTween: {
        'd': function () {
          var arcData = series._getArcData(point),
              currentArc = this._current_ || arcData;

          var interpolate = (0, _interpolator["default"])(currentArc, arcData);
          this._current_ = interpolate(1);
          return function (t) {
            return arc(interpolate(t));
          };
        }
      }
    };
  },
  getPointDropAnimationAttr: function (point) {
    var series = point.series,
        options = series.options,
        startAngle = series.startAngle;

    var arc = _PathGenerator["default"].arc();

    return {
      ease: EASE,
      duration: ANIMATION_TIME,
      attrTween: {
        'd': function () {
          var current = this._current_;
          var prePoint = series.getPreVisiblePoint(point);
          var terminateAngle = startAngle;

          if (prePoint != 'first' && prePoint.lastShape) {
            var preGap = Math.abs(prePoint.lastShape.endAngle - prePoint.endAngle);
            terminateAngle = point.startAngle + preGap;
          }

          var end = series._getArcData(point);

          end.startAngle = end.endAngle = terminateAngle;
          var interpolate = (0, _interpolator["default"])(current, end);
          this._current_ = interpolate(1);
          return function (t) {
            return arc(interpolate(t));
          };
        }
      }
    };
  },
  getPreVisiblePoint: function (point) {
    var points = point.series.points,
        prePoint = 'first';

    for (var i = 0, len = points.length; i < len; i++) {
      if (points[i] != point) {
        if (points[i].visible) {
          prePoint = points[i];
        }
      } else {
        return prePoint;
      }
    }

    return prePoint;
  },
  getFillFilter: function (color, p) {
    var series = this,
        options = series.options;

    if (options.gradualStyle == _Constants["default"].STYLE_GRADUAL && (0, _EnvUtils.supportFillFilter)()) {
      var series = this,
          vanchart = series.vanchart,
          renderer = vanchart.renderer;
      var attrs = {
        'cx': "0%",
        'cy': "0%",
        'r': Math.max(p.outerRadius, 0) + 'px',
        "gradientUnits": "userSpaceOnUse"
      };
      var stop1 = {
        'offset': p.innerRadius / Math.max(p.outerRadius, 1) * 100 + '%',
        'stop-color': _ColorUtils["default"].getColorWithDivider(color, 0.8),
        'stop-opacity': p.opacity
      };
      var stop2 = {
        'offset': '100%',
        'stop-color': color
      };

      if (p.colorGradient) {
        renderer.updateColorGradient(p.colorGradient, attrs, [stop1, stop2]);
      } else {
        p.colorGradient = renderer.colorGradient(attrs, [stop1, stop2], 'radialGradient');
      }

      return renderer.toPatternProperty(p.colorGradient);
    }

    return color;
  },
  _onPointMouseOver: function (point) {
    this._onState(point, true);
  },
  _onPointMouseOut: function (point) {
    this._onState(point, false);
  },
  _onState: function (point, isChosen) {
    var series = this;
    var style = isChosen ? series.getHighLightStyle(point) : series.getStyle(point);

    series._onPointState(point, isChosen, style);

    series._onTextState(point, isChosen);
  },
  _getPointGraphicGroup: function () {
    if (!this.pathGroup) {
      this.pathGroup = this.vanchart.renderer.group().addTo(this.group);
    }

    return this.pathGroup;
  },
  _getPointTextLabelGroup: function () {
    if (!this.textLabelGroup) {
      this.textLabelGroup = this.vanchart.renderer.vgroup().add();
      this.group.append(this.textLabelGroup.renderG);
    }

    this.textLabelGroup.divG.attr('transform', _BaseUtils["default"].makeTranslate(this._getTranslate()));
    return this.textLabelGroup;
  },
  isSeriesAccumulated: function () {
    return true;
  },
  getDefaultTooltipFormatter: function () {
    return {
      categoryFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{SERIES}{VALUE}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  },
  getGroupTrans: function () {
    return [this.chartInfo.centerX, this.chartInfo.centerY];
  }
});

function PieLayout() {
  var value = Number,
      startAngle = 0,
      endAngle = 2 * Math.PI,
      sum = 0;

  function pie(points) {
    var values = points.map(function (point, i) {
      var v = +value.call(pie, point, i);
      sum += v;
      return v;
    });
    var a = startAngle,
        da = endAngle - a,
        k = da / sum;
    points.forEach(function (point, i) {
      point.startAngle = isNaN(a) ? 0 : a;
      point.endAngle = a += isNaN(values[i] * k) ? 0 : values[i] * k; // 这里k可能为Infinity，从而导致startAngle和endAngle为NaN
      //@BI-15301 安卓下扇形角度小于一定值时会渲染出错显示为整圆

      if (Math.abs(point.endAngle - point.startAngle) < LIMIT_MIN_ANGLE) {
        point.endAngle = point.startAngle;
      }
    });
  }

  pie.value = function (_) {
    if (!arguments.length) {
      return value;
    }

    value = _;
    return pie;
  };

  pie.startAngle = function (_) {
    if (!arguments.length) {
      return startAngle;
    }

    startAngle = _;
    return pie;
  };

  pie.endAngle = function (_) {
    if (!arguments.length) {
      return endAngle;
    }

    endAngle = _;
    return pie;
  };

  return pie;
}

Pie.include(_PieSeries["default"]);
var _default = Pie;
exports["default"] = _default;

/***/ }),
/* 144 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _BoundsManager = _interopRequireDefault(__webpack_require__(25));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _Gauge = _interopRequireDefault(__webpack_require__(50));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _pointer = __webpack_require__(145);

var _ThemeConfig = __webpack_require__(17);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/8/9.
 * 指针类型的仪表盘
 */
var POINTER_ANGLE = 150;
var POINTER_SEMI_ANGLE = 90;
var LABEL_EXIT_DURATION = 900; // 监控刷新最快的是1000ms刷新一次，这边移除的速度比刷新的稍微快一些

var POINTER_HINGE = 0.07,
    // 360度指针仪表盘枢纽半径占仪表盘半径比例
POINTER_HINGE_BACKGROUND = 0.16,
    // 360度指针仪表盘枢纽背景半径占仪表盘半径比例
POINTER_SEMI_HINGE = 0.055,
    // 180度指针仪表盘枢纽半径占仪表盘半径比例
POINTER_SEMI_HINGE_BACKGROUND = 0.11; // 180度指针仪表盘枢纽背景半径占仪表盘半径比例

var TICK_LABEL_AUTO_SIZE = 0.036; // 轴标签自动时，字体占仪表盘直径的比例

var TICK_MIN_FONTSIZE = 8; // 轴标签自动时的最小字体

var TICK_FONT_SPACING = 0.3; // 轴标签左右间距占字体大小的比例

var TICK_LENGTH = 0.033; // 主刻度长度占直径的比例

var TICK_WIDTH = 1.5; // 主副刻度粗细

var MINOR_TICK_LENGTH = 0.5; // 副刻度长度占主刻度长度的比例

var LABEL_BACKGROUND_GAP = 0.01; // 标签与枢纽背景下边缘的间隔占直径的比例

var LABEL_AUTO_SIZE = 0.046; // 标签自动时，标签字体占仪表盘的直径的比例

var LABEL_MIN_FONTSIZE = 10; // 标签最小字体

var LABEL_POINTER_GAP = 1; //指针仪表盘 分类标签距离表盘一倍分类标签字高

var PointerGauge = _Gauge["default"].extend({
  gaugeType: _Constants["default"].POINTER_GAUGE,
  _doLayout: function () {
    (0, _pointer.dealSeriesLabel)(this);
    this.isGaugeSeriesStylePointer() ? this._fixPointerCenter() : this._fixPointerSemiCenter();
  },
  isGaugeSeriesStylePointer: function () {
    return this.options.style === _Constants["default"].POINTER_GAUGE;
  },
  //默认的是ring and slot 其他要重写这个方法
  _drawDiffMoreLabels: function () {
    var series = this,
        points = series.points;
    points.forEach(function (point) {
      series._showMoreLabel(point, series.centerX, series.centerY);
    });
  },
  getDataToDraw: function () {
    return this.points;
  },
  _fixPointerCenter: function () {
    var gauge = this,
        options = gauge.options,
        radius = options.radius,
        center = gauge.center;
    var align = options.seriesLabel.align || _Constants["default"].BOTTOM;

    if (!center) {
      var bounds = gauge.bounds;
      var labelHeight = (1 + LABEL_POINTER_GAP) * gauge.seriesLabelDim.height;
      var usedHeight = bounds.height - labelHeight;
      var centerX = bounds.x + bounds.width / 2;
      var centerY = bounds.y + bounds.height / 2;
      var gap;
      radius = radius || Math.min(bounds.width, usedHeight) / 2 - gauge.DEFAULT_PADDING;

      if (align === _Constants["default"].BOTTOM) {
        if (centerY + radius + labelHeight > bounds.y + bounds.height) {
          gap = bounds.height - (radius * 2 + labelHeight);

          if (gap >= 0) {
            centerY = bounds.y + radius + gap / 2;
          }
        } else {
          centerY -= labelHeight / 2; // 考虑标签在内，整体居中
        }
      } else {
        if (centerY - radius - labelHeight < bounds.y) {
          gap = bounds.height - (radius * 2 + labelHeight);

          if (gap >= 0) {
            centerY = bounds.y + radius + labelHeight + gap / 2;
          }
        } else {
          centerY += labelHeight / 2; // 考虑标签在内，整体居中
        }
      }

      gauge.centerX = centerX;
      gauge.centerY = centerY;
      gauge.radius = radius;
    } else {
      gauge.centerX = center[0];
      gauge.centerY = center[1];
      gauge.radius = radius;
    }

    if (gauge.seriesLabelContent) {
      var dim = gauge.seriesLabelDim;
      gauge.seriesLabelPos = {
        x: -dim.width / 2,
        y: align === _Constants["default"].BOTTOM ? radius + LABEL_POINTER_GAP * dim.height : -radius - (1 + LABEL_POINTER_GAP) * dim.height
      };
    }

    (0, _pointer.dealPointerValueLabel)(gauge, radius);
  },
  _fixPointerSemiCenter: function () {
    var gauge = this,
        options = gauge.options,
        radius = options.radius,
        align = options.seriesLabel.align;

    if (!gauge.center) {
      var bounds = gauge.bounds;
      var labelHeight = (1 + LABEL_POINTER_GAP) * gauge.seriesLabelDim.height;
      var usedHeight = bounds.height - labelHeight;
      radius = radius || Math.min(bounds.width / 2, usedHeight / 1.14) - gauge.DEFAULT_PADDING;
      var centerX = bounds.x + bounds.width / 2;
      var centerY = bounds.y + bounds.height / 2 + radius / 2;
      var gap;

      if (align === _Constants["default"].BOTTOM) {
        if (centerY + 0.14 * radius + labelHeight > bounds.y + bounds.height) {
          gap = bounds.height - (radius * 1.14 + labelHeight);

          if (gap >= 0) {
            centerY = bounds.y + radius + gap / 2; // 此时计算的centerY，已经把标签和0.14*radius考虑在内了,
          }
        } else {
          centerY -= labelHeight / 2 + radius * 0.07; // @Cmen:CHART-798,半圆仪表盘还得考虑圆心到底边即radius*0.14的距离
        }
      } else {
        if (centerY - radius - labelHeight < bounds.y) {
          gap = bounds.height - (radius * 1.14 + labelHeight);

          if (gap >= 0) {
            centerY = bounds.y + radius + labelHeight + gap / 2;
          }
        } else {
          centerY += labelHeight / 2 - radius * 0.07; // @Cmen:CHART-798 半圆仪表盘还得考虑圆心到底边即radius*0.14的距离
        }
      }

      gauge.centerX = centerX;
      gauge.centerY = centerY;
      gauge.radius = radius;
    } else {
      gauge.centerX = gauge.center[0];
      gauge.centerY = gauge.center[1];
      gauge.radius = radius;
    }

    if (gauge.seriesLabelContent) {
      var dim = gauge.seriesLabelDim;
      gauge.seriesLabelPos = {
        x: -dim.width / 2,
        y: align === _Constants["default"].BOTTOM ? radius * 0.14 + LABEL_POINTER_GAP * dim.height : -radius - (1 + LABEL_POINTER_GAP) * dim.height
      };
    }

    (0, _pointer.dealPointerSemiValueLabel)(gauge, radius);
  },
  _dealValueLabelContent: function (gauge, radius) {
    var options = gauge.options,
        gaugeAxis = gauge.gaugeAxis;
    var domain = gaugeAxis.scale.domain();

    var scale = _Scale["default"].linear().domain(domain).range([_BaseUtils["default"].toRadian(-150), _BaseUtils["default"].toRadian(150)]);

    var tickHeight = this._calculateTickHeight(radius);

    var startY = POINTER_HINGE_BACKGROUND * radius + radius * 2 * LABEL_BACKGROUND_GAP,
        startPos = startY;

    var valueLabelStyle = _BaseUtils["default"].clone(options.valueLabel.style);

    valueLabelStyle.fontSize = this._getValueLabelFontSize(gauge, radius, tickHeight);
    valueLabelStyle.color = this.getThemeLabelColor(valueLabelStyle);
    var useHtml = options.valueLabel.useHtml; // @CHART-9135 consider useHtml & browser minFontSize

    var valueLabelHeight = (0, _pointer.calculateLabelHeight)(valueLabelStyle, useHtml);

    var boundsManager = this._getPointerTickBoundsManager(gaugeAxis, radius, scale),
        heightBoundsManager = boundsManager.heightBoundsManager,
        widthBoundsManager = boundsManager.widthBoundsManager;

    var visibleCount = 0;
    var valueBackgroundY = startY;
    var valueBackgroundX = Number.MAX_VALUE;
    var labelR = this.calculateLabelR(radius);
    var valueBackgroundXArr = [];
    startY += valueLabelHeight / 2;

    for (var i = 0, totalCount = gauge.valueLabelContent.length; i < totalCount; i++) {
      var singleLabel = gauge.valueLabelContent[i];
      var singleLabelContent = singleLabel.labelContent;
      singleLabel.labelDim = _BaseUtils["default"].getTextDimension(singleLabelContent, valueLabelStyle, useHtml);
      var tmpX = Math.min(-singleLabel.labelDim.width / 2 - valueLabelHeight / 4, valueBackgroundX);
      var tmpBounds = {
        x: tmpX,
        y: valueBackgroundY,
        width: 2 * Math.abs(tmpX),
        height: startY + valueLabelHeight * (1 + this.LINE_GAP) - valueBackgroundY
      };
      var hasClipped = false;

      while (widthBoundsManager.isOverlapped(tmpBounds) && singleLabelContent.length) {
        singleLabelContent = singleLabelContent.substr(0, Math.floor(singleLabelContent.length * 0.9));

        var tmpDim = _BaseUtils["default"].getTextDimension(singleLabelContent + '...', valueLabelStyle, useHtml);

        tmpX = -tmpDim.width / 2 - valueLabelHeight / 4;
        tmpBounds = {
          x: tmpX,
          y: valueBackgroundY,
          width: 2 * Math.abs(tmpX),
          height: startY + valueLabelHeight * (1 + this.LINE_GAP) - valueBackgroundY
        };
        hasClipped = true;
      }

      if ((0, _CoreUtils.isEmpty)(singleLabelContent) || startY + valueLabelHeight * (1 + this.LINE_GAP) > labelR) {
        break;
      }

      if (hasClipped) {
        //宽度上截断，省略处理
        singleLabel.labelContent = singleLabelContent + '...';
        singleLabel.labelDim = _BaseUtils["default"].getTextDimension(singleLabel.labelContent, valueLabelStyle, useHtml);
      }

      valueBackgroundXArr.push(-singleLabel.labelDim.width / 2 - valueLabelHeight / 4);
      singleLabel.labelPos = {
        x: -singleLabel.labelDim.width / 2,
        y: startY
      };
      singleLabel.labelStyle = valueLabelStyle;
      startY += valueLabelHeight * (1 + this.LINE_GAP);
      visibleCount++;
    }

    valueBackgroundX = Math.min.apply(null, valueBackgroundXArr);
    gauge.valueLabelContent.length = visibleCount;

    var backgroundColorOpacity = _ColorUtils["default"].getColorOpacity(options.valueLabel.backgroundColor);

    var valueLabelBackgroundHeight = valueLabelHeight * (visibleCount + 1 + this.LINE_GAP * (visibleCount - 1));

    var maxValueLabelBackgroundHeight = this._calculateMaxBackgroundHeight(widthBoundsManager.addedBounds, Math.abs(valueBackgroundX), startPos); // 标签背景为透明时，背景高度为可见标签数加行间距总的高度；不为透明时，根据标签最大宽度计算出来的最大可用高度,高度为标签总高度与最大可用高度的最小值。


    valueLabelBackgroundHeight = backgroundColorOpacity !== 0 ? Math.min(maxValueLabelBackgroundHeight - startPos, valueLabelBackgroundHeight) : valueLabelBackgroundHeight;
    var yTranslate = Math.max((maxValueLabelBackgroundHeight - startPos - valueLabelBackgroundHeight) / 2, 0);

    for (i = 0; i < visibleCount; i++) {
      singleLabel = gauge.valueLabelContent[i];
      singleLabel.labelPos.y += yTranslate;
    }

    gauge.valueLabelBackground = {
      x: valueBackgroundX,
      y: valueBackgroundY + yTranslate,
      width: 2 * Math.abs(valueBackgroundX),
      height: valueLabelBackgroundHeight // (可见标签数+1)*lineHeight + (可见标签数-1)*行间距

    };
  },
  _getValueLabelFontSize: function (gauge, radius, tickHeight) {
    var options = gauge.options,
        valueLabel = options.valueLabel,
        useHtml = valueLabel.useHtml,
        valueLabelStyle = _BaseUtils["default"].clone(valueLabel.style);

    if (!valueLabelStyle.autoSize) {
      return valueLabelStyle.fontSize;
    }

    var fontSizeArr = [];
    var autoFontSize = Math.max(LABEL_AUTO_SIZE * radius * 2, LABEL_MIN_FONTSIZE);
    var labelInnerR = this.calculateLabelR(radius, true);
    var startY = POINTER_HINGE_BACKGROUND * radius + radius * 2 * LABEL_BACKGROUND_GAP;
    var maxLabelBackgroundWidth = 2 * Math.sqrt(labelInnerR * labelInnerR - startY * startY);

    for (var i = 0, totalCount = gauge.valueLabelContent.length; i < totalCount; i++) {
      var singleLabel = gauge.valueLabelContent[i];
      var singleLabelContent = singleLabel.labelContent;

      var fontSize = _BaseUtils["default"].shrinkText(singleLabelContent, LABEL_MIN_FONTSIZE, autoFontSize, maxLabelBackgroundWidth, valueLabelStyle, useHtml).fontSize;

      fontSize = parseFloat(fontSize);
      fontSizeArr.push(fontSize);
    }

    return fontSizeArr.length > 0 ? Math.min.apply(null, fontSizeArr) + 'px' : '0px';
  },

  /**
   * 移除valueLabel
   * @return {[type]} [description]
   */
  _drawExitValueLabel: function () {
    var series = this,
        vanchart = series.vanchart;
    series.valueLabels = series.valueLabels || [];
    var useHtml = series.options.valueLabel && series.options.valueLabel.useHtml; // todo html的移除动画
    // 有发生值变化的点时，向右移出LastValueLabel

    if (series.hasChangedPointWithChangeDataState() && !useHtml && series.valueLabels.length > 0) {
      var backgroundWidth = _BaseUtils["default"].rectSubPixelOpt(series.valueLabelBackground, 0).width;

      series.valueLabels.forEach(function (text) {
        text.animate({
          ease: series.EASE_TYPE,
          duration: LABEL_EXIT_DURATION,
          style: {
            'opacity': 1,
            'transform': _BaseUtils["default"].makeTranslateWithPX({
              x: backgroundWidth,
              y: 0
            })
          },
          attr: {
            'transform': _BaseUtils["default"].makeTranslate({
              x: backgroundWidth,
              y: 0
            })
          }
        }).each("end", function () {
          removeLastValueLabelGroup(series);
        });
      });
    } // 没有点发生值变化的话，直接移除
    else {
        series.valueLabels.forEach(function (text) {
          text.remove();
        });
        removeLastValueLabelGroup(series);
      }

    series.valueLabels = []; // animation.end似乎概率性不能正常触发, 先全部存起来, 每次都遍历删除, 确保没漏掉

    function removeLastValueLabelGroup(series) {
      var labelGroups = series.labelGroups || [];
      labelGroups.forEach(function (labelG) {
        labelG && labelG.remove();
      });
      series.labelGroups = [];
    }
  },
  isPointerGauge: function () {
    return true;
  },
  _parseAxisLabelStyle: function (radius) {
    var gaugeAxis = this.gaugeAxis;
    var axisOption = gaugeAxis.options;

    var tickLabelStyle = _BaseUtils["default"].clone(axisOption.labelStyle);

    var autoAdjustFontSize = TICK_LABEL_AUTO_SIZE * 2 * radius > TICK_MIN_FONTSIZE ? TICK_LABEL_AUTO_SIZE * 2 * radius : TICK_MIN_FONTSIZE;
    tickLabelStyle.fontSize = tickLabelStyle.autoSize ? autoAdjustFontSize + 'px' : tickLabelStyle.fontSize;
    return tickLabelStyle;
  },
  _calculateTickHeight: function (radius) {
    var tickLabelStyle = this._parseAxisLabelStyle(radius);

    return (0, _EnvUtils.getTextHeight)(tickLabelStyle);
  },
  calculateLabelR: function (radius, isInner) {
    var tickR = (1 - 0.05) * radius;
    var tickLength = TICK_LENGTH * 2 * tickR;

    var tickHeight = this._calculateTickHeight(radius);

    var outerLabelR = (1 - 0.05 - 0.01) * radius - tickLength - TICK_FONT_SPACING * tickHeight;
    return isInner ? outerLabelR - tickHeight : outerLabelR;
  },
  _dealSemiValueLabelContent: function (gauge, radius) {
    var options = gauge.options,
        gaugeAxis = gauge.gaugeAxis;
    var domain = gaugeAxis.scale.domain();

    var scale = _Scale["default"].linear().domain(domain).range([_BaseUtils["default"].toRadian(-90), _BaseUtils["default"].toRadian(90)]);

    var tickHeight = this._calculateTickHeight(radius);

    var valueLabelStyle = _BaseUtils["default"].clone(options.valueLabel.style);

    valueLabelStyle.fontSize = this._getValueLabelFontSize(gauge, radius, tickHeight);
    var useHtml = options.valueLabel.useHtml;
    var valueLabelHeight = (0, _pointer.calculateLabelHeight)(valueLabelStyle, useHtml);
    var startPos = -(POINTER_SEMI_HINGE_BACKGROUND * radius + radius * 2 * LABEL_BACKGROUND_GAP),
        endY = startPos - valueLabelHeight * (1 + 0.5);

    var boundsManager = this._getPointerTickBoundsManager(gaugeAxis, radius, scale),
        heightBoundsManager = boundsManager.heightBoundsManager,
        widthBoundsManager = boundsManager.widthBoundsManager;

    var visibleCount = 0;
    var valueBackgroundX = Number.MAX_VALUE;
    var i,
        singleLabel,
        valueBackgroundXArr = [],
        totalCount = gauge.valueLabelContent.length;

    for (i = totalCount - 1; i >= 0; i--) {
      singleLabel = gauge.valueLabelContent[i];
      var singleLabelContent = singleLabel.labelContent;
      singleLabel.labelStyle = valueLabelStyle;
      singleLabel.labelDim = _BaseUtils["default"].getTextDimension(singleLabelContent, valueLabelStyle, useHtml);
      var tmpX = Math.min(-singleLabel.labelDim.width / 2 - valueLabelHeight / 4, valueBackgroundX);
      var tmpBounds = {
        x: tmpX,
        y: endY,
        width: 2 * Math.abs(tmpX),
        height: startPos - endY
      };
      var hasClipped = false;

      while (widthBoundsManager.isOverlapped(tmpBounds) && singleLabelContent.length) {
        singleLabelContent = singleLabelContent.substr(0, Math.floor(singleLabelContent.length * 0.9));

        var tmpDim = _BaseUtils["default"].getTextDimension(singleLabelContent + '...', valueLabelStyle, useHtml);

        tmpX = -tmpDim.width / 2 - valueLabelHeight / 4;
        tmpBounds = {
          x: tmpX,
          y: endY,
          width: 2 * Math.abs(tmpX),
          height: startPos - endY
        };
        hasClipped = true;
      }

      if ((0, _CoreUtils.isEmpty)(singleLabelContent)) {
        break;
      }

      if (hasClipped) {
        //宽度上截断，省略处理
        singleLabel.labelContent = singleLabelContent + '...';
        singleLabel.labelDim = _BaseUtils["default"].getTextDimension(singleLabel.labelContent, valueLabelStyle, useHtml);
      }

      valueBackgroundXArr.push(-singleLabel.labelDim.width / 2 - valueLabelHeight / 4);
      singleLabel.labelPos = {
        x: -singleLabel.labelDim.width / 2,
        y: endY
      };
      endY -= valueLabelHeight * (1 + this.LINE_GAP);
      visibleCount++;
    }

    valueBackgroundX = valueBackgroundXArr.length > 0 ? Math.min.apply(null, valueBackgroundXArr) : 0;

    var backgroundColorOpacity = _ColorUtils["default"].getColorOpacity(options.valueLabel.backgroundColor);

    var valueLabelBackgroundHeight = valueLabelHeight * (visibleCount + 1 + this.LINE_GAP * (visibleCount - 1));

    var maxValueLabelBackgroundHeight = this._calculateMaxBackgroundHeight(widthBoundsManager.addedBounds, Math.abs(valueBackgroundX), startPos); // 标签背景为透明时，背景高度为可见标签数加行间距总的高度；不为透明时，根据标签最大宽度计算出来的最大可用高度,高度为标签总高度与最大可用高度的最小值。


    valueLabelBackgroundHeight = backgroundColorOpacity !== 0 ? Math.min(maxValueLabelBackgroundHeight + startPos, valueLabelBackgroundHeight) : valueLabelBackgroundHeight;
    var valueBackgroundY = startPos - valueLabelBackgroundHeight;
    var yTranslate = maxValueLabelBackgroundHeight + startPos > valueLabelBackgroundHeight ? -(maxValueLabelBackgroundHeight + startPos - valueLabelBackgroundHeight) / 2 : 0;

    for (i = totalCount - 1; i >= totalCount - visibleCount; i--) {
      singleLabel = gauge.valueLabelContent[i];
      singleLabel.labelPos.y += yTranslate;
    }

    gauge.valueLabelBackground = {
      x: valueBackgroundX,
      y: valueBackgroundY + yTranslate,
      width: 2 * Math.abs(valueBackgroundX),
      height: valueLabelBackgroundHeight
    };
  },

  /**
   * 计算最大的可用背景高度
   */
  _calculateMaxBackgroundHeight: function (boundsArray, valueBackgroundX, startPos) {
    var isGaugeSeriesStylePointer = this.isGaugeSeriesStylePointer(); // 360度只需要考虑下面的刻度和标签bounds，180度只需要考虑上面的刻度和标签,
    // 仪表盘的刻度是左右对称的，但标签不是左右对称的，右侧数据较大故应该考虑右侧bounds

    boundsArray = boundsArray.filter(function (bounds) {
      if (isGaugeSeriesStylePointer) {
        return bounds.y >= startPos && bounds.x + bounds.width >= 0;
      } else {
        return bounds.y + bounds.height <= startPos && bounds.x + bounds.width >= 0;
      }
    }); // 360度的根据坐标y正向排序，180度的根据bounds.y + bound.height反向排序

    boundsArray = isGaugeSeriesStylePointer ? boundsArray.sort(function (a, b) {
      return a.y - b.y;
    }) : boundsArray.sort(function (a, b) {
      return b.y + b.height - (a.y + a.height);
    }); // 最大的可用的矩形，应该是不和刻度线或者标签bounds重叠的最大的高度矩形
    // 如何来确定这个矩形呢，首先这个矩形的宽度最小应该等于valueBackgroundWidth，在这个基础上去寻找最大高度，
    // 至于最大高度如何确定呢，通过观察我们知道，boundsManager里面的bounds应该是围成一个大圆弧形状，那么以当前背景宽度的矩形，在高度增长的过程中
    // 肯定会碰到其中的某一个bounds，这个bounds的边缘到矩形起始位置的距离即可理解为背景矩形所在区间的最大高度
    // 那么现在的问题时如何找到这个高度增长过程中可能会碰到的bounds，然后根据这个bounds计算高度，再取左右的最小值即可

    var bounds,
        niceBoundsRight = boundsArray[boundsArray.length - 1];

    for (var i = 0; i < boundsArray.length; i++) {
      bounds = boundsArray[i];

      if (valueBackgroundX < bounds.x) {
        continue;
      } // 当矩形的最右边界刚好在一个bounds的x~x+width之间或者bounds的x+width还要大，那么这个bounds即为会碰到的bounds


      niceBoundsRight = bounds;
      break;
    }

    return niceBoundsRight ? isGaugeSeriesStylePointer ? niceBoundsRight.y : -niceBoundsRight.height - niceBoundsRight.y : startPos;
  },
  _boundsInCircle: function (bounds) {
    var radius = this.radius,
        points = [{
      x: bounds.x,
      y: bounds.y
    }, {
      x: bounds.x + bounds.width,
      y: bounds.y
    }, {
      x: bounds.x,
      y: bounds.y + bounds.height
    }, {
      x: bounds.x + bounds.width,
      y: bounds.y + bounds.height
    }];

    for (var i = 0; i < 4; i++) {
      var point = points[i],
          diffX = Math.abs(point.x),
          diffY = Math.abs(point.y);

      if (Math.pow(diffX * diffX + diffY * diffY, 0.5) > radius) {
        return false;
      }
    }

    return true;
  },
  _getPointerTickBoundsManager: function (gaugeAxis, radius, scale) {
    var labelStyle = this._parseAxisLabelStyle(radius);

    var tickHeight = this._calculateTickHeight(radius);

    var widthBoundsManager = new _BoundsManager["default"]();
    var heightBoundsManager = new _BoundsManager["default"]();
    var tickR = (1 - 0.05) * radius,
        tickLength = TICK_LENGTH * 2 * tickR,
        labelR = this.calculateLabelR(radius);
    var tickData = gaugeAxis.tickData;
    var gauge = this,
        gap = tickHeight * TICK_FONT_SPACING;
    tickData.forEach(function (tick) {
      var tickObj = _BaseUtils["default"].clone(tick);

      tickObj.tickDim = _BaseUtils["default"].getTextDimension(tick.tickContent, labelStyle, false);
      var radian = scale(tick.tickValue);

      var tickPos = gauge._getPointerTickPos(tickObj, labelR, scale);

      gauge._addToBoundsManager(radian, {
        x: tickPos.x - gap,
        y: tickPos.y - gap,
        width: tickObj.tickDim.width + gap * 2,
        // 轴标签字体宽度 + 左右间距
        height: tickObj.tickDim.height + gap * 2 // 轴标签字体宽度 + 上下间距

      }, widthBoundsManager, heightBoundsManager);
    });
    var minorTickR = tickR;
    var minorTickSize = MINOR_TICK_LENGTH * tickLength;
    var minorTickData = (0, _pointer.fixMinorTickData)(gaugeAxis, minorTickR, scale);
    minorTickData.forEach(function (minorTickValue) {
      var radian = scale(minorTickValue);

      var startPos = gauge._getArcPoint(minorTickR, radian);

      var endPos = gauge._getArcPoint(minorTickR - minorTickSize, radian);

      var minorTickBound = (0, _pointer.getMinorTickBound)(radian, startPos, endPos, gap);

      gauge._addToBoundsManager(radian, minorTickBound, widthBoundsManager, heightBoundsManager);
    });
    return {
      widthBoundsManager: widthBoundsManager,
      heightBoundsManager: heightBoundsManager
    };
  },
  //-45to45 -135to-180 135to180 控制高
  _addToBoundsManager: function (radian, bounds, widthBoundsManager, heightBoundsManager) {
    if (radian > -Math.PI / 4 && radian < Math.PI / 4) {
      heightBoundsManager.addBounds(bounds);
    }

    if (radian < -Math.PI * 3 / 4 || radian > Math.PI * 3 / 4) {
      heightBoundsManager.addBounds(bounds);
    }

    widthBoundsManager.addBounds(bounds);
  },
  // 多指针仪表盘轴标签相对圆心的位置
  _getPointerTickPos: function (tick, labelR, scale) {
    var radian = scale(tick.tickValue);

    var joinPoint = this._getArcPoint(labelR, radian);

    var x = joinPoint[0];
    var y = joinPoint[1];
    var tickDim = tick.tickDim;

    if (-Math.PI < radian && radian < 0) {
      return {
        x: x,
        y: y - tickDim.height / 2
      };
    }

    if (0 < radian && radian < Math.PI) {
      return {
        x: x - tickDim.width,
        y: y - tickDim.height / 2
      };
    }

    if (radian === 0) {
      return {
        x: x - tickDim.width / 2,
        y: y
      };
    }

    if (radian === Math.PI || radian === -Math.PI) {
      return {
        x: x - tickDim.width / 2,
        y: y - tickDim.height
      };
    }
  },
  animateLabelPara: function () {
    var series = this;
    return {
      enabled: true,
      initStyle: {
        'transform': _BaseUtils["default"].makeTranslateWithPX({
          x: -series.valueLabelBackground.width,
          y: 0
        })
      },
      initAttr: {
        'transform': _BaseUtils["default"].makeTranslate({
          x: -series.valueLabelBackground.width,
          y: 0
        })
      }
    };
  },
  drawSeries: function () {
    var series = this,
        vanchart = series.vanchart,
        renderer = vanchart.renderer,
        group = series.group;

    if (!this.backgruondPath) {
      this.backgruondPath = renderer.path().addTo(group);
      this.hingePath = renderer.path().addTo(group);
      this.labelGroup = this._getPointTextLabelGroup();
      this.axisGroup = this.labelGroup;
      this.needleGroup = renderer.group().addTo(group);
      this.pointerHingePath = renderer.path().addTo(group);
    } // 注册series的events


    vanchart.registerInteractiveTarget(this, group);
    this.labelGroup = this._getPointTextLabelGroup();

    if (!this.dropFilter) {
      this.dropFilter = renderer.createDropShadowFilter(0, 2, 0.1, 2);
      this.innerFilter = renderer.createInnerShadowFilter(0, 2, 0.1, 2);
    }

    this.isGaugeSeriesStylePointer() ? this._drawPointer(180, POINTER_HINGE_BACKGROUND, POINTER_HINGE) : this._drawPointer(98, POINTER_SEMI_HINGE_BACKGROUND, POINTER_SEMI_HINGE);
  },
  onSeriesPress: function () {
    var circle = _PathGenerator["default"].arc().startAngle(0).endAngle(2 * Math.PI).innerRadius(0);

    var isGaugeSeriesStylePointer = this.isGaugeSeriesStylePointer();
    var hBackground = isGaugeSeriesStylePointer ? POINTER_HINGE_BACKGROUND : POINTER_SEMI_HINGE_BACKGROUND;
    var hinge = isGaugeSeriesStylePointer ? POINTER_HINGE : POINTER_SEMI_HINGE;
    circle.outerRadius(hBackground * this.radius * 1.25);
    this.hingePath.attr('d', circle()); //枢纽

    circle.outerRadius(hinge * this.radius * 1.25);
    this.pointerHingePath.attr('d', circle());
  },
  onSeriesPressUp: function () {
    var circle = _PathGenerator["default"].arc().startAngle(0).endAngle(2 * Math.PI).innerRadius(0);

    var isGaugeSeriesStylePointer = this.isGaugeSeriesStylePointer();
    var hBackground = isGaugeSeriesStylePointer ? POINTER_HINGE_BACKGROUND : POINTER_SEMI_HINGE_BACKGROUND;
    var hinge = isGaugeSeriesStylePointer ? POINTER_HINGE : POINTER_SEMI_HINGE;
    circle.outerRadius(hBackground * this.radius);
    this.hingePath.attr('d', circle()); //枢纽

    circle.outerRadius(hinge * this.radius);
    this.pointerHingePath.attr('d', circle());
  },
  _getScale: function () {
    var series = this,
        scaleAngle = this.isGaugeSeriesStylePointer() ? POINTER_ANGLE : POINTER_SEMI_ANGLE;
    var domain = series.gaugeAxis.scale.domain();
    return _Scale["default"].linear().domain(domain).range([_BaseUtils["default"].toRadian(-scaleAngle), _BaseUtils["default"].toRadian(scaleAngle)]);
  },
  getStyle: function (point) {
    var options = point.options;
    return {
      'fill': options.needle,
      'fill-opacity': _ColorUtils["default"].getColorOpacity(options.needle)
    };
  },
  getHighLightStyle: function (point) {
    var options = point.options;
    return {
      'fill': _ColorUtils["default"].getHighLightColor(options.needle)
    };
  },
  getPointGraphicKey: function () {
    return 'path';
  },
  _getPointGraphicGroup: function () {
    return this.needleGroup;
  },
  getPointInitAnimationAttr: function (point) {
    var series = point.series,
        scale = series._getScale();

    return {
      duration: series.ANIMATION_TIME,
      ease: series.EASE_TYPE,
      attrTween: {
        'd': function () {
          var domain = scale.domain();
          var startValue = domain[0];
          this._current_ = _BaseUtils["default"].getValueInDomain(point.value, domain);
          var interpolate = (0, _interpolator["default"])(startValue, this._current_);
          return function (t) {
            return series._getArrowPath(interpolate(t));
          };
        }
      }
    };
  },
  getPointUpdateAnimationAttr: function (point) {
    return this.getPointInitAnimationAttr(point);
  },
  _getArrowPath: function (y) {
    var initRadian = this._getScale()(y);

    var radius = this.radius;

    var p0 = this._getArcPoint(0.9 * radius, initRadian);

    var p1 = this._getArcPoint(0.02 * radius, initRadian + Math.PI / 2);

    var p2 = this._getArcPoint(0.02 * radius, initRadian - Math.PI / 2);

    return 'M' + p0[0] + ',' + p0[1] + 'L' + p1[0] + ',' + p1[1] + 'L' + p2[0] + ',' + p2[1] + 'Z';
  },
  _drawPointer: function (baseAngle, hBackground, hinge) {
    var series = this,
        options = series.options,
        radius = series.radius;

    var circle = _PathGenerator["default"].arc().startAngle(0).endAngle(2 * Math.PI).innerRadius(0);

    var arc = _PathGenerator["default"].arc().startAngle(_BaseUtils["default"].toRadian(-baseAngle)).endAngle(_BaseUtils["default"].toRadian(baseAngle)).innerRadius(0).outerRadius(radius).toCenter(false);

    var isDarkTheme = this.vanchart.isDarkTheme();
    var hingeColor = (0, _ThemeConfig.getThemeAutoValue)(options.hinge, 'hinge', isDarkTheme);
    var paneBackgroundColor = (0, _ThemeConfig.getThemeAutoValue)(options.paneBackgroundColor, 'pointerPaneBackgroundColor', isDarkTheme);
    series.backgruondPath.attr('d', arc()).style({
      'fill': paneBackgroundColor,
      'fill-opacity': _ColorUtils["default"].getColorOpacity(paneBackgroundColor),
      'filter': 'url(#' + _BaseUtils["default"].stamp(series.dropFilter) + ')'
    }); // 枢纽背景

    circle.outerRadius(hBackground * radius);
    series.hingePath.attr('d', circle()).style({
      'fill': options.hingeBackgroundColor,
      'fill-opacity': _ColorUtils["default"].getColorOpacity(options.hingeBackgroundColor),
      'filter': 'url(#' + _BaseUtils["default"].stamp(series.innerFilter) + ')'
    });

    this._drawPointerTicks();

    this._drawGaugeLabels(series.labelGroup); // 枢纽


    circle.outerRadius(hinge * radius);
    series.pointerHingePath.attr('d', circle()).style({
      'fill': hingeColor,
      'fill-opacity': _ColorUtils["default"].getColorOpacity(hingeColor),
      'filter': 'url(#' + _BaseUtils["default"].stamp(series.dropFilter) + ')'
    });
  },
  _drawPointerTicks: function () {
    var series = this,
        bands = series.defaultBands,
        vanchart = series.vanchart,
        gaugeAxis = series.gaugeAxis,
        renderer = vanchart.renderer;
    var axisG = this.axisGroup,
        tickData = gaugeAxis.getTickData();

    var axisOption = gaugeAxis.options,
        labelStyle = _BaseUtils["default"].clone(axisOption.labelStyle),
        useHtml = axisOption.useHtml,
        fontSizeAutoAdjust = labelStyle.autoSize,
        fontColorAutoAdjust = labelStyle.autoColor;

    var autoAdjustFontSize = TICK_LABEL_AUTO_SIZE * 2 * series.radius > TICK_MIN_FONTSIZE ? TICK_LABEL_AUTO_SIZE * 2 * series.radius : TICK_MIN_FONTSIZE;
    labelStyle.fontSize = fontSizeAutoAdjust ? autoAdjustFontSize + 'px' : labelStyle.fontSize;
    var tickR = (1 - 0.05) * series.radius,
        tickLength = TICK_LENGTH * 2 * tickR,
        tickWidth = TICK_WIDTH,
        labelR = this.calculateLabelR(series.radius);

    var scale = this._getScale();

    this.ticks = this.ticks || [];

    var selection = gaugeAxis._bindData(this.ticks, tickData, function (d) {
      return scale(d.tickValue);
    });

    var currentTickLines, i, len;
    selection.exit.map(function (layer) {
      layer.text && layer.text.remove();
      layer.remove();
    });
    currentTickLines = selection.enter.map(function (d) {
      var line = axisG.append(renderer.line().datum(d));

      if ((0, _CoreUtils.hasDefined)(d.tickContent)) {
        line.text = axisG.append(renderer.vtext(useHtml));
      }

      return line;
    });
    this.ticks = currentTickLines = currentTickLines.concat(selection.update);
    var radian, start, end, color;

    for (i = 0, len = currentTickLines.length; i < len; i++) {
      var tick = currentTickLines[i],
          tickD = tick.datum();
      tickD.tickDim = _BaseUtils["default"].getTextDimension(tickD.tickContent, labelStyle, useHtml);
      radian = scale(tickD.tickValue);
      start = series._getArcPoint(tickR, radian);
      end = series._getArcPoint(tickR - tickLength, radian);
      color = series._getColorFromBands(tickD.tickValue, bands);
      tick.attr('x1', start[0]).attr('y1', start[1]).attr('x2', end[0]).attr('y2', end[1]).style({
        'stroke': color,
        'stroke-width': tickWidth
      });

      var tickLabelStyle = _BaseUtils["default"].clone(labelStyle);

      var tickPos = series._getPointerTickPos(tickD, labelR, scale);

      tickLabelStyle.color = fontColorAutoAdjust ? color : tickLabelStyle.color;
      tick.text && tick.text.style(tickLabelStyle).attr({
        x: tickPos.x,
        y: tickPos.y,
        dy: '.85em'
      }).textContent(tickD.tickContent);
    }

    var minorTickData = (0, _pointer.fixMinorTickData)(gaugeAxis, tickR, scale);
    this.minorTics = this.minorTics || [];
    selection = gaugeAxis._bindData(this.minorTics, minorTickData);
    currentTickLines = [];

    for (i = 0, len = selection.exit.length; i < len; i++) {
      selection.exit[i].remove();
    }

    for (i = 0, len = selection.enter.length; i < len; i++) {
      currentTickLines.push(axisG.append(renderer.line().datum(selection.enter[i])));
    }

    this.minorTics = currentTickLines = currentTickLines.concat(selection.update);

    for (i = 0, len = currentTickLines.length; i < len; i++) {
      var tickLine = currentTickLines[i],
          value = tickLine.datum();
      radian = scale(value);
      start = series._getArcPoint(tickR, radian);
      end = series._getArcPoint(tickR - MINOR_TICK_LENGTH * tickLength, radian);
      color = series._getColorFromBands(value, bands);
      tickLine.attr('x1', start[0]).attr('y1', start[1]).attr('x2', end[0]).attr('y2', end[1]).style({
        'stroke': color,
        'stroke-width': tickWidth
      });
    }
  },
  _onPointMouseOver: function (point) {
    var series = point.series,
        style = series.getHighLightStyle(point);

    series._onState(point.graphic, true, style);
  },
  _onPointMouseOut: function (point) {
    var series = point.series,
        style = series.getStyle(point); //arguments[1]主要是控制ease && duration.指针类型的over out都是0.2 ease，所以第二个参数也用true

    series._onState(point.graphic, true, style);
  }
});

var _default = PointerGauge;
exports["default"] = _default;

/***/ }),
/* 145 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.calculateLabelHeight = calculateLabelHeight;
exports.fixMinorTickData = fixMinorTickData;
exports.getMinorTickBound = getMinorTickBound;
exports.dealPointerValueLabel = dealPointerValueLabel;
exports.dealPointerSemiValueLabel = dealPointerSemiValueLabel;
exports.dealSeriesLabel = dealSeriesLabel;

var _customLabel = __webpack_require__(58);

var _gaugeTextFormatter = __webpack_require__(59);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var MINOR_TICK_INTERVAL_WIDTH = 6; // 副刻度之间最小间距

var MINOR_TICK_NUM = 10; // 副刻度数

var LABEL_AUTO_SIZE = 0.046; // 标签自动时，标签字体占仪表盘的直径的比例

var LABEL_MIN_FONTSIZE = 10; // 标签最小字体

var POINTER_HINGE_BACKGROUND = 0.16,
    // 360度指针仪表盘枢纽背景半径占仪表盘半径比例
POINTER_SEMI_HINGE_BACKGROUND = 0.11; // 180度指针仪表盘枢纽背景半径占仪表盘半径比例

var LABEL_BACKGROUND_GAP = 0.01; // 标签与枢纽背景下边缘的间隔占直径的比例

function calculateLabelHeight(labelStyle, useHtml) {
  return _BaseUtils["default"].getTextDimension('m', labelStyle, useHtml).height;
}

function fixMinorTickData(gaugeAxis, minorTickR, scale) {
  var originMinorTickData = gaugeAxis.getMinorTickData();
  var minorIntervalRadian = Math.abs(scale(originMinorTickData[1]) - scale(originMinorTickData[0]));

  if (minorIntervalRadian > MINOR_TICK_INTERVAL_WIDTH / minorTickR) {
    return gaugeAxis.getMinorTickData(MINOR_TICK_NUM);
  }

  return originMinorTickData;
}

function getMinorTickBound(radian, startPos, endPos, gap) {
  // 左下角
  if (-Math.PI <= radian && radian < -Math.PI / 2) {
    return {
      x: startPos[0] - gap,
      y: endPos[1] - gap,
      width: endPos[0] - startPos[0] + gap * 2,
      height: startPos[1] - endPos[1] + gap * 2
    };
  } // 左上角


  if (-Math.PI / 2 <= radian && radian < 0) {
    return {
      x: startPos[0] - gap,
      y: startPos[1] - gap,
      width: endPos[0] - startPos[0] + gap * 2,
      height: endPos[1] - startPos[1] + gap * 2
    };
  } // 右上角


  if (0 <= radian && radian < Math.PI / 2) {
    return {
      x: endPos[0] - gap,
      y: startPos[1] - gap,
      width: startPos[0] - endPos[0] + gap * 2,
      height: endPos[1] - startPos[1] + gap * 2
    };
  } // 右下角


  return {
    x: endPos[0] - gap,
    y: endPos[1] - gap,
    width: startPos[0] - endPos[0] + gap * 2,
    height: startPos[1] - endPos[1] + gap * 2
  };
}

function getCustomLabelContent(points, valueLabel, autoFontSize) {
  var valueLabelContent = [];

  for (var i = 0; i < points.length; i++) {
    var point = points[i];

    if (point.isNull) {
      continue;
    }

    var singleLabel = (0, _customLabel.customLabel)(point, valueLabel, autoFontSize);
    valueLabelContent.push(singleLabel);
  }

  return valueLabelContent;
}

function dealCustomLabelContent(series, radius) {
  var valueLabelContent = series.valueLabelContent;

  if (valueLabelContent.length === 0) {
    series.valueLabelBackground = {
      x: 0,
      y: 0,
      width: 0,
      height: 0
    };
    return;
  }

  var startY = POINTER_HINGE_BACKGROUND * radius + radius * 2 * LABEL_BACKGROUND_GAP,
      startPos = startY;
  var valueLabelStyle = valueLabelContent[0].labelStyle;
  var useHtml = series.options.valueLabel.useHtml; // @CHART-9135 consider useHtml & browser minFontSize

  var valueLabelHeight = calculateLabelHeight(valueLabelStyle, useHtml);
  var valueBackgroundXArr = [];
  startY += valueLabelHeight / 2;
  valueLabelContent.forEach(function (singleLabel) {
    var labelPosX = -singleLabel.labelDim.width / 2;
    var labelHeight = singleLabel.labelDim.height;
    singleLabel.labelPos = {
      x: labelPosX,
      y: startY
    };
    valueBackgroundXArr.push(labelPosX - valueLabelHeight / 4);
    startY += labelHeight;
  });
  startY += valueLabelHeight / 2;
  var valueBackgroundX = Math.min.apply(Math, valueBackgroundXArr);
  var valueBackgroundHeight = startY - startPos;
  var maxValueBackgroundHeight = series.calculateLabelR(radius, true) - startPos;
  var yTranslate = Math.max(maxValueBackgroundHeight - valueBackgroundHeight, 0) / 2;
  valueLabelContent.forEach(function (singleLabel) {
    singleLabel.labelPos.y += yTranslate;
  });
  return {
    x: valueBackgroundX,
    y: startPos + yTranslate,
    width: 2 * Math.abs(valueBackgroundX),
    height: valueBackgroundHeight
  };
}

function getNormalLabelContent(points, valueLabel) {
  var valueLabelContent = [];

  for (var i = 0; i < points.length; i++) {
    var point = points[i];

    if (point.isNull) {
      continue;
    }

    var singleLabelContent = (0, _gaugeTextFormatter.calculateSingleLineLabelContent)(valueLabel.formatter, point);
    valueLabelContent.push({
      labelContent: singleLabelContent
    });
  }

  return valueLabelContent;
}

function dealSemiCustomLabelContent(series, radius) {
  var valueLabelContent = series.valueLabelContent;

  if (valueLabelContent.length === 0) {
    series.valueLabelBackground = {
      x: 0,
      y: 0,
      width: 0,
      height: 0
    };
    return;
  }

  var valueLabelStyle = valueLabelContent[0].labelStyle;
  var useHtml = series.options.valueLabel.useHtml; // @CHART-9135 consider useHtml & browser minFontSize

  var valueLabelHeight = calculateLabelHeight(valueLabelStyle, useHtml);
  var startPos = -(POINTER_SEMI_HINGE_BACKGROUND * radius + radius * 2 * LABEL_BACKGROUND_GAP),
      endY = startPos;
  var valueBackgroundXArr = [];
  endY -= valueLabelHeight / 2;

  for (var i = valueLabelContent.length - 1; i >= 0; i--) {
    var singleLabel = valueLabelContent[i];
    var labelPosX = -singleLabel.labelDim.width / 2;
    var labelHeight = singleLabel.labelDim.height;
    endY -= labelHeight;
    singleLabel.labelPos = {
      x: labelPosX,
      y: endY
    };
    valueBackgroundXArr.push(labelPosX - valueLabelHeight / 4);
  }

  endY -= valueLabelHeight / 2;
  var valueBackgroundX = Math.min.apply(Math, valueBackgroundXArr);
  var valueBackgroundHeight = startPos - endY;
  var maxValueBackgroundHeight = series.calculateLabelR(radius, true) + startPos;
  var yTranslate = Math.max(maxValueBackgroundHeight - valueBackgroundHeight, 0) / 2;
  valueLabelContent.forEach(function (singleLabel) {
    singleLabel.labelPos.y -= yTranslate;
  });
  return {
    x: valueBackgroundX,
    y: endY - yTranslate,
    width: 2 * Math.abs(valueBackgroundX),
    height: startPos - endY
  };
}

function dealPointerValueLabel(series, radius) {
  var options = series.options,
      points = series.points;
  var valueLabel = options.valueLabel;
  var autoFontSize = Math.max(LABEL_AUTO_SIZE * radius * 2, LABEL_MIN_FONTSIZE);

  if (!(valueLabel && valueLabel.enabled)) {
    series.valueLabelContent = [];
    return;
  }

  if ((0, _customLabel.isCustomLabel)(valueLabel.formatter)) {
    series.valueLabelContent = getCustomLabelContent(points, valueLabel, autoFontSize);
    series.valueLabelBackground = dealCustomLabelContent(series, radius);
    return;
  }

  series.valueLabelContent = getNormalLabelContent(points, valueLabel);

  series._dealValueLabelContent(series, radius);
}

function dealPointerSemiValueLabel(series, radius) {
  var options = series.options,
      points = series.points;
  var valueLabel = options.valueLabel;
  var autoFontSize = Math.max(LABEL_AUTO_SIZE * radius * 2, LABEL_MIN_FONTSIZE);

  if (!(valueLabel && valueLabel.enabled)) {
    series.valueLabelContent = [];
    return;
  }

  if ((0, _customLabel.isCustomLabel)(valueLabel.formatter)) {
    series.valueLabelContent = getCustomLabelContent(points, valueLabel, autoFontSize);
    series.valueLabelBackground = dealSemiCustomLabelContent(series, radius);
    return;
  }

  series.valueLabelContent = getNormalLabelContent(points, valueLabel);

  series._dealSemiValueLabelContent(series, radius);
}

function normalSeriesLabel(point, seriesLabel) {
  var style = seriesLabel.style,
      formatter = seriesLabel.formatter;
  var labelContent = (0, _gaugeTextFormatter.calculateSingleLineLabelContent)(formatter, point);

  var labelDim = _BaseUtils["default"].getTextDimension(labelContent, style, false);

  return {
    labelContent: labelContent,
    labelDim: labelDim,
    labelStyle: style
  };
}

function dealSeriesLabel(series) {
  var seriesLabel = series.options.seriesLabel;

  if (!(seriesLabel && seriesLabel.enabled)) {
    series.seriesLabelContent = '';
    series.seriesLabelDim = {
      width: 0,
      height: 0
    };
    return;
  }

  var label;

  var point = series._validPoint();

  if ((0, _customLabel.isCustomLabel)(seriesLabel.formatter)) {
    label = (0, _customLabel.customLabel)(point, seriesLabel);
  } else {
    label = normalSeriesLabel(point, seriesLabel);
  }

  var _label = label,
      labelStyle = _label.labelStyle,
      labelDim = _label.labelDim,
      labelContent = _label.labelContent;

  if (!seriesLabel.useHtml && labelContent === '') {
    labelContent = ' '; // CHART-12997:当分类名为空字符串时，计算的labelDim的width、height为0，会导致多个仪表盘时该仪表盘计算出的半径偏大

    labelDim = _BaseUtils["default"].getTextDimension(labelContent, labelStyle, false);
  }

  labelStyle.color = series.getThemeLabelColor(labelStyle);
  series.seriesLabelContent = labelContent;
  series.seriesLabelStyle = labelStyle;
  series.seriesLabelDim = labelDim;
}

/***/ }),
/* 146 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Series = _interopRequireDefault(__webpack_require__(13));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Mitisky on 16/11/30.
 */
var INIT_TIME = 400;
var INIT_EASE = _BezierEasing["default"].css['ease-out-back'];
var UPDATE_TIME = 600;
var UPDATE_EASE = _BezierEasing["default"].css["ease-out-quart"];
var DROP_TIME = 1000;
var DROP_EASE = _BezierEasing["default"].css["ease-out-cubic"];
var RE_SHOW_TIME = 1200;
var RE_SHOW_EASE = _BezierEasing["default"].css["ease-out-cubic"];
var CHOSEN_TIME = 300;
var CHOSEN_EASE = _BezierEasing["default"].css["ease-out-quart"];

var WordCloud = _Series["default"].extend({
  isNullValue: function (point) {
    var targetValue = point.options.value;
    return targetValue == '-' || (0, _CoreUtils.hasNotDefined)(targetValue) || (0, _CoreUtils.hasNotDefined)(point.name);
  },
  //用来计算百分比的指标的名字,相当于value的含义
  getTargetKey: function () {
    return 'value';
  },
  _getPointKey: function (point) {
    return point.name;
  },
  doLayout: function () {},
  //没有标签
  _calculateLabelPos: function () {},
  _getFixedPos: function (point, divDim) {
    var word = point.word,
        dim = point.labelDim;

    var translate = point.series._getTranslate();

    var w = dim.width / 2,
        h = dim.height / 2,
        rotate = _BaseUtils["default"].toRadian(word.rotate);

    var ww = rotate === Math.PI / 2 ? h : w * Math.cos(rotate) - h * Math.sin(rotate);
    var hh = w * Math.sin(rotate) + h * Math.cos(rotate);
    var dy = dim.height * .35 * Math.cos(rotate);
    var dx = dim.height * .35 * Math.sin(rotate);
    return (0, _EnvUtils.isSupportSVG)() ? [translate[0] + word.x + ww + dx, translate[1] + word.y + hh - dy] : [translate[0] + word.x + dim.width, translate[1] + word.y + dim.height];
  },
  _getTranslate: function () {
    var plotBounds = this.vanchart.bounds;
    return [plotBounds.x + plotBounds.width / 2, plotBounds.y + plotBounds.height / 2];
  },
  effectAnimation: function (d) {
    var word = d.word,
        series = d.series,
        period = series._getEffectTime(d);

    d.graphic.style('text-shadow', 'rgba(91,91,91,0.75) 0px 0px 0px').effectTransition().ease(_BezierEasing["default"].css["ease-out-quint"]).duration(0.5 * period).style('font-size', 1.2 * word.size + "px").style('text-shadow', 'rgba(91,91,91,0.75) 3px 3px 5px').transition().ease(_BezierEasing["default"].css["ease-in-quint"]).duration(0.5 * period).style('font-size', word.size + "px").style('text-shadow', 'rgba(91,91,91,0.75) 0px 0px 0px');
  },
  getDefaultEffectTime: function () {
    return 2000;
  },
  // _showLabels: function () {
  // },

  /**
   * @override Series.calcMoreLabelPosition.
   * @param  {[type]} point [description]
   * @return {[type]}       [description]
   */
  calcMoreLabelPosition: function (point, moreLabelDim) {
    var translate = point.series._getTranslate();

    var word = point.word,
        textDim = point.labelDim;
    var direction = "top";

    var bestPoints = this._calcNiceMoreLabelPos(point, word.rotate);

    var bestPos = bestPoints.top; // 向上超出则使用下面的点

    if (bestPos.y - moreLabelDim.height < 0) {
      bestPos = bestPoints.bottom;
      direction = "bottom";
    } // IE下不支持旋转，使用的DIV渲染，因此这里的位置要单独计算


    var ie8PosX = translate[0] + word.x + textDim.width / 2,
        ie8PosY = translate[1] + word.y; // IE8 下高度溢出，同样反向

    if (ie8PosY - moreLabelDim.height < 0) {
      ie8PosY = translate[1] + word.y + textDim.height;
      direction = "bottom";
    }

    return {
      startX: (0, _EnvUtils.isSupportSVG)() ? bestPos.x : ie8PosX,
      startY: (0, _EnvUtils.isSupportSVG)() ? bestPos.y : ie8PosY,
      direction: direction
    };
  },

  /**
   * 现在的问题是，词云的刷新数据提示应该在词的上面，当超出的时候，则反向放在词的下面，
   * 而且要考虑到词的旋转角度问题，保证词在旋转一定角度之后，提示和词不重叠且在词的上面
   * 这里就涉及到一个最高点的计算问题，每一个词在画布中就是一个矩形，这里根据词的大小和角度及中心位置，算出词（矩形）的四个端点的坐标
   * 然后取一个topPos和bottomPos返回，优先使用topPos，如果使用topPos时提示超出，则使用bottomPos
   * 这里topPos并不一定指的是词的四个端点之一，比如词的rotate为0，那么y轴方向就有两个比较高的点，
   * 这时则取他们的中心点，当比较高的两点之间的y方向的差值超过一定界限（20px ?），这时才以最高的那个点作为返回的topPos
   * 对于bottomPos则以相同的逻辑计算
   * @private
   */
  _calcNiceMoreLabelPos: function (point, rotate) {
    var translate = point.series._getTranslate();

    var word = point.word,
        textDim = point.labelDim,
        height = textDim.height * 0.86,
        width = textDim.width;
    var wordX = word.x + translate[0],
        wordY = word.y + translate[1];

    if (height === 0 || width === 0) {
      return {
        top: {
          x: wordX,
          y: wordY
        },
        bottom: {
          x: wordX,
          y: wordY
        }
      };
    }

    var PI = Math.PI,
        toRadin = function (deg) {
      return deg * PI / 180;
    };

    var measure = 20;
    rotate = toRadin(rotate); // 旋转发生transform-origin为相对文字的(50%,100%)

    var _angle = Math.atan(height / width * 2) || 0;

    var _angles = [0, _angle, PI - _angle, PI];
    var r1 = width / 2,
        r2 = Math.sqrt(height * height + width * width / 4);

    var points = _angles.map(function (angle, index) {
      var r = index % 3 ? r2 : r1;
      angle -= rotate;
      return {
        x: Math.round(r * Math.cos(angle)),
        y: Math.round(r * Math.sin(angle))
      };
    }).sort(function (a, b) {
      return b.y - a.y;
    });

    var centerPoint = function (p1, p2) {
      return {
        x: (p1.x + p2.x) / 2,
        y: (p1.y + p2.y) / 2
      };
    };

    var endPos = function (pos) {
      return {
        x: pos.x + wordX,
        y: wordY - pos.y
      };
    };

    var topPos = points[0].y - points[1].y > measure ? points[0] : centerPoint(points[0], points[1]),
        bottomPos = points[3].y - points[2].y < -measure ? points[3] : centerPoint(points[3], points[2]);
    return {
      top: endPos(topPos),
      bottom: endPos(bottomPos)
    };
  },
  _getPointGraphicGroup: function () {
    return this.vanchart.group;
  },
  _createPointGraphic: function (point) {
    var graphicKey = this.getPointGraphicKey(point),
        renderer = this.vanchart.renderer;
    point.graphic = renderer[graphicKey]();
    point.graphic.textContent(point.word.text);
    return point.graphic;
  },
  getPointGraphicKey: function () {
    return 'text';
  },
  getStyle: function (p) {
    var word = p.word;
    return word ? {
      "font-size": word.size + "px",
      "font-family": word.fontFamily,
      'fill': p.color,
      'text-shadow': '',
      'stroke-width': 0,
      'stroke-opacity': 1,
      'fill-opacity': p.opacity,
      'filter': ''
    } : {};
  },
  getHighLightStyle: function (p) {
    var word = p.word,
        size = parseFloat(word.size) * 1.15;
    return {
      "font-size": size + "px",
      'fill': p.mouseOverColor
    };
  },
  _onPointMouseOver: function (point) {
    _Series["default"].prototype._onPointMouseOver.call(this, point); // 超链鼠标悬浮变手


    var series = point.series,
        style = series.getHighLightStyle(point),
        vanchart = series.vanchart,
        renderer = vanchart.renderer;

    if (point.effectInterval) {
      _BaseUtils["default"].clearInterval(point.effectInterval);

      point.graphic.interrupt();
    }

    point.graphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      'duration': CHOSEN_TIME,
      'ease': CHOSEN_EASE,
      'style': style
    });
  },
  _onPointMouseOut: function (point) {
    var series = point.series,
        style = series.getStyle(point);
    point.graphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      'duration': CHOSEN_TIME,
      'ease': CHOSEN_EASE,
      'style': style
    });
    series.drawPointEffect(point);
  },
  getPointInitAttr: function (p) {
    var word = p.word;
    return word ? {
      'text-anchor': 'middle',
      'transform': "translate(" + [word.x, word.y] + ")rotate(" + word.rotate + ")"
    } : {};
  },
  getPointInitStyle: function (p) {
    return {
      'font-size': '0.1px',
      'fill-opacity': p.opacity
    };
  },
  getPointReShowStyle: function (p) {
    return {
      'font-size': '0.1px',
      'fill-opacity': p.opacity
    };
  },
  getPointInitAnimationAttr: function (d) {
    var word = d.word;
    return {
      delay: d.delayTime || 0,
      // 这里的word如果不显示，给出的delayTime为undefined，导致transition不能触发end,animateCount因此不能归为0，也就无法执行series._animateEnd
      ease: INIT_EASE,
      duration: INIT_TIME,
      style: {
        'font-size': word.size + "px",
        'fill-opacity': d.opacity
      }
    };
  },
  getPointReShowAnimationAttr: function (d) {
    var word = d.word;
    return {
      ease: RE_SHOW_EASE,
      duration: RE_SHOW_TIME,
      style: {
        'font-size': word.size + "px",
        'fill-opacity': d.opacity
      }
    };
  },
  getPointUpdateAnimationAttr: function (d) {
    var word = d.word;
    return {
      ease: UPDATE_EASE,
      duration: UPDATE_TIME,
      style: {
        'font-size': word.size + "px",
        'fill-opacity': d.opacity
      },
      attr: {
        'transform': "translate(" + [word.x, word.y] + ")rotate(" + word.rotate + ")"
      }
    };
  },
  getPointDropAnimationAttr: function (d) {
    return {
      ease: DROP_EASE,
      duration: DROP_TIME,
      style: {
        'fill-opacity': 0
      }
    };
  },
  isSeriesAccumulated: function () {
    return true;
  },
  getDefaultTooltipFormatter: function () {
    return {
      categoryFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{CATEGORY}{NAME}{VALUE}",
      nameFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = WordCloud;
exports["default"] = _default;

/***/ }),
/* 147 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _TreeSeries = _interopRequireDefault(__webpack_require__(79));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _TreeMapLayout = __webpack_require__(81);

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Scale = _interopRequireDefault(__webpack_require__(10));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 16/7/19.
 */
var TOPLABELGAP = 6;
var ANIMATION_TIME = 800;
var INIT_EASE = 'out-bounce';
var CHANGE_TIME = 1000;
var VANISH_TIME = 800;
var CHOSEN_TIME = 100;

var TreeMap = _TreeSeries["default"].extend({
  nodes: [],
  root: null,
  zoomNow: null,
  sx: null,
  sy: null,
  zoom: null,
  _refresh: function () {
    this.sx = _Scale["default"].linear();
    this.sy = _Scale["default"].linear();
  },
  visitBefore: function (node) {
    this._setColor(node);
  },
  visitAfter: function (node) {
    var c = node.children;
    var _value = node.options.value;
    _value = isNaN(_value) ? 0 : _value;
    node.chSum = _value;

    if (c && (n = c.length)) {
      var chSum = 0,
          i = -1,
          n;

      this._calculatePercentage(c, 'value');

      while (++i < n) {
        chSum += Math.abs(c[i].chSum);
      }

      node.chSum = chSum;
    }

    node.value = _value || node.chSum || 0;

    if (node.ancestor && !node.ancestor.visible) {
      node.value = 0;
    }
  },
  doLayout: function () {
    this.traverseData(this.root, null, this.visitAfter);
    var plotBounds = this.vanchart.bounds;
    this.sx.range([0, plotBounds.width]).domain([0, plotBounds.width]);
    this.sy.range([0, plotBounds.height]).domain([0, plotBounds.height]);
    var treeMap = (0, _TreeMapLayout.treemapLayout)().value(function (d) {
      return Math.abs(d.value);
    }).size([plotBounds.width, plotBounds.height]);
    this.nodes = treeMap.nodes(this.root).filter(function (d) {
      return !d.children && d.depth;
    }).map(function (d) {
      d.value = d.chSum; // for negative value

      d.visible = d.ancestor.visible;

      if (d.visible) {
        this._setVanishPos(d, plotBounds);
      }

      this.calculateLabelInfo(d);

      this._calcLabelPos(d);

      stash(d);
      return d;
    }, this);

    function stash(d) {
      d._dx = d.dx;
      d._dy = d.dy;
      d._x = d.x;
      d._y = d.y;
    }
  },
  getDataToDraw: function () {
    return this.nodes;
  },
  _setVanishPos: function (d, plotBounds) {
    d.vanishPos = [Math.round((d.ancestor.x + d.ancestor.dx / 2) / plotBounds.width) * plotBounds.width, Math.round((d.ancestor.y + d.ancestor.dy / 2) / plotBounds.height) * plotBounds.height];
  },
  _setColor: function (node) {
    if (node.depth === 1) {
      node.color = node.options.color || this.vanchart.getDefaultSeriesColor(node.name);
      node.mouseOverColor = node.options.mouseOverColor || _ColorUtils["default"].getHighLightColor(node.color);
      node.clickColor = node.options.clickColor || _ColorUtils["default"].getClickColor(node.color);
    }

    if (node.depth > 1 && !node.options.children) {
      if (node.options.color) {
        node.color = node.options.color;
      } else {
        node.color = node.ancestor.color;
      }

      if (node.options.mouseOverColor) {
        node.mouseOverColor = node.options.mouseOverColor;
      } else {
        if (node.options.color) {
          node.mouseOverColor = _ColorUtils["default"].getHighLightColor(node.options.color);
        } else {
          node.mouseOverColor = node.ancestor.mouseOverColor;
        }
      }

      if (node.options.clickColor) {
        node.clickColor = node.options.clickColor;
      } else {
        if (node.options.color) {
          node.clickColor = _ColorUtils["default"].getClickColor(node.options.color);
        } else {
          node.clickColor = node.ancestor.clickColor;
        }
      }
    }

    var hexAlpha = _ColorUtils["default"].getStandardColorAndOpacity(node.color, node.options.opacity);

    node.color = hexAlpha.hex;
    node.opacity = hexAlpha.alpha;
    node.borderColor = node.getPointBorderColor(node.options.borderColor);
    node.borderOpacity = node.options.borderOpacity;
  },
  _calculateLabelPos: function () {},
  //
  _calcLabelPos: function (d) {
    var lbl = d.options.dataLabels;

    if (lbl && lbl.enabled) {
      switch (lbl.align) {
        case _Constants["default"].CENTER:
          lbl._align = _Constants["default"].CENTER;
          d.labelPos = {
            x: d.x + (d.dx - d.labelDim.width) / 2,
            y: d.y + (d.dy - d.labelDim.height) / 2
          };
          break;

        case _Constants["default"].TOP:
        default:
          lbl._align = _Constants["default"].LEFT;
          d.labelPos = {
            x: d.x + TOPLABELGAP,
            y: d.y + TOPLABELGAP
          };
      }

      var rectBound = {
        x: d.x,
        y: d.y,
        width: d.dx,
        height: d.dy
      };
      var dataBound = {
        x: d.labelPos.x,
        y: d.labelPos.y,
        width: d.labelDim.width,
        height: d.labelDim.height
      };

      if (!_BaseUtils["default"].containsRect(rectBound, dataBound)) {
        d.labelPos = null;
      }
    }
  },

  /**
   * @override Series.calcMoreLabelPosition.
   * @param  {[type]} point [description]
   * @return {[type]}       [description]
   */
  calcMoreLabelPosition: function (point) {
    var chartBounds = this.vanchart.bounds;
    var startX = point.x + point.dx / 2 + chartBounds.x,
        startY = point.y + point.dy / 2 + chartBounds.y;
    return {
      startX: startX,
      startY: startY,
      direction: "top"
    };
  },

  /**
   * 判断node是否在绘图区内
   * @param node
   * @returns {boolean|*}
   * @private
   */
  _isNodeWithinChartBounds: function (node) {
    var chartBounds = this.vanchart.bounds;
    var cx = node.x + node.dx / 2 + chartBounds.x,
        cy = node.y + node.dy / 2 + chartBounds.y;
    return _BaseUtils["default"].containsPoint(chartBounds, [cx, cy]);
  },
  effectAnimation: function (d) {
    if (!this._isNodeWithinChartBounds(d)) return;

    _EffectHelper["default"].areaStyleEffectAnimation(d, d.x + d.dx / 2, d.y + d.dy / 2);
  },
  getDefaultEffectTime: function () {
    return _EffectHelper["default"].AREA_STYLE_EFFECT_TIME;
  },
  getPointGraphicKey: function () {
    return 'rect';
  },
  _getFixedPos: function (datum) {
    var plotBounds = this.vanchart.bounds;
    var x = plotBounds.x + datum.x + datum.dx;
    var y = plotBounds.y + datum.y;
    return [x, y];
  },
  zoomTo: function (d) {
    d = this.zoomNow === d.parent ? this.root : d.parent;
    var sx = this.sx.domain([d.x, d.x + d.dx]);
    var sy = this.sy.domain([d.y, d.y + d.dy]);
    var plotBounds = this.vanchart.bounds;
    var kx = plotBounds.width / d.dx,
        ky = plotBounds.height / d.dy;
    this.nodes.map(function (node) {
      node.dx = kx * node._dx;
      node.dy = ky * node._dy;
      node.x = sx(node._x);
      node.y = sy(node._y);

      this._calcLabelPos(node);

      node.clearPointEffect();
    }, this); // 钻取时，kx > 1 || ky > 1，可见的node都提升到dom的最前面

    (kx > 1 || ky > 1) && d.children && d.children.forEach(function (node) {
      _DomUtils["default"].toFront(node.graphic.node());
    }); // this.render();

    this.vanchart.fire('animationStart');
    this.zoomNow = d;
  },
  getChartNodes: function () {
    return this.nodes;
  },
  getZoom: function () {
    return this.options.zoom;
  },
  _getPointGraphicGroup: function () {
    if (!this.pathGroup) {
      this.pathGroup = this.group.append(this.vanchart.renderer.group());
    }

    return this.pathGroup;
  },
  // animation
  initialAnimation: function () {
    var series = this;

    var node = this._getPointGraphicGroup();

    var plotBounds = this.vanchart.bounds;
    var cx = plotBounds.width / 2;
    var cy = plotBounds.height / 2;
    node.animate({
      duration: ANIMATION_TIME,
      ease: INIT_EASE,
      attrTween: {
        transform: function () {
          var i = (0, _interpolator["default"])(0, 1);
          return function (t) {
            var inter = i(t);
            return 'matrix(' + inter + ',' + 0 + ',' + 0 + ',' + inter + ',' + (cx - inter * cx) + ',' + (cy - inter * cy) + ')';
          };
        }
      }
    });
  },
  _pointExpandAttr: function (d) {
    return {
      'x': -d.dx / 2,
      'y': -d.dy / 2,
      'width': d.dx,
      'height': d.dy,
      'transform': "translate(" + (d.x + d.dx / 2) + "," + (d.y + d.dy / 2) + ")"
    };
  },
  _pointContractAttr: function (d) {
    return {
      'x': 0,
      'y': 0,
      'width': 0,
      'height': 0,
      'transform': "translate(" + d.vanishPos[0] + "," + d.vanishPos[1] + ")"
    };
  },
  getPointInitAttr: function (d) {
    return this.initialAnimationMoving ? this._pointExpandAttr(d) : this._pointContractAttr(d);
  },
  getPointUpdateAnimationAttr: function (d) {
    var series = this;

    if (d.visible) {
      return {
        ease: 'quad-in-out',
        duration: CHANGE_TIME,
        attr: this._pointExpandAttr(d)
      };
    } else {
      return series.getPointDropAnimationAttr(d);
    }
  },
  getPointInitAnimationAttr: function (d) {
    if (this.initialAnimationMoving) {
      return {};
    }

    return this.getPointUpdateAnimationAttr(d);
  },
  getPointDropAnimationAttr: function (d) {
    return {
      ease: 'quad-in-out',
      duration: VANISH_TIME,
      attr: {
        width: 0,
        height: 0,
        transform: "translate(" + d.vanishPos[0] + "," + d.vanishPos[1] + ")"
      }
    };
  },
  // event
  onPointMouseOver: function (point) {
    point.series._onState.call(point, true);
  },
  onPointMouseOut: function (point) {
    point.series._onState.call(point, false);
  },
  _onState: function (isChosen) {
    var point = this,
        series = point.series;
    var style = {
      'fill': isChosen ? point.mouseOverColor : point.color,
      'stroke-width': point.options.borderWidth + (isChosen ? 1 : 0)
    };

    var attr = series._pointExpandAttr(point);

    if (isChosen) {
      attr = {
        x: attr.x - 1,
        y: attr.y - 1,
        width: attr.width + 2,
        height: attr.height + 2
      };
    }

    _DomUtils["default"].toFront(point.graphic.node());

    point.graphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      duration: CHOSEN_TIME,
      ease: 'ease',
      style: style,
      attr: attr
    });

    series._labelFontSizeState(point, isChosen, CHOSEN_TIME, 'ease');
  },
  allowDrillDown: function (point) {
    return point.series.getZoom();
  },
  drillDown: function (p) {
    this.onPointTap(p);
  },
  onPointTap: function (point) {
    // check in point._onPointTap
    // if (this.allowDrillDown(point)) {
    point.series.zoomTo(point); // }
  },
  getDefaultTooltipFormatter: function () {
    return {
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{NAME}{SERIES}{VALUE}",
      nameFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = TreeMap;
exports["default"] = _default;

/***/ }),
/* 148 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _Gauge = _interopRequireDefault(__webpack_require__(50));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _thermometer = __webpack_require__(149);

var _ThemeConfig = __webpack_require__(17);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/8/9.
 *
 */
var TICK_SIZE = 6;
var MINOR_TICK_SIZE = 4;
var TICK_LABEL_GAP = 4;
var DEFAULT_RADIUS = 100;
var MAGIC_DET = 0.001;
var DEFAULT_BLANK = 4;
var TICK_LABEL_FONTSIZE = '12px';
var NEEDLE = 0.3; // 指针半径占滑槽宽度的比例

var lastLabelShiftLength; // 上一次标签绘制时距离端点的长度

var ThermometerGauge = _Gauge["default"].extend({
  gaugeType: _Constants["default"].THERMOMETER_GAUGE,
  _doLayout: function () {
    (0, _thermometer.dealPercentLabel)(this);
    (0, _thermometer.dealValueLabel)(this);

    this._fixCenterAndRadius();
  },
  thermometerValueLabelWithPercent: function (labelContent, valueLabel, limitWidth, series) {
    var label = _BaseUtils["default"].clone(valueLabel);

    var style = _BaseUtils["default"].clone(label.style);

    style.fontSize = style.autoSize ? this.LABEL_AUTO_FONTSIZE : style.fontSize;
    style.color = series.getThemeLabelColor(style);
    label.style = style;

    this._valueLabelWithPercent(labelContent, label, limitWidth, series, true);
  },
  //默认的是ring and slot 其他要重写这个方法
  _drawDiffMoreLabels: function () {
    var point = this.points[0];

    if (!point || point.isNull) {
      return;
    }

    var domain = this.gaugeAxis.scale.domain();
    var vertical = this.options.thermometerLayout === _Constants["default"].VERTICAL_LAYOUT;

    var scale = _Scale["default"].linear().domain(domain).range(vertical ? [this.radius, -this.radius] : [-this.radius, this.radius]);

    var index = scale(point.y);
    var thermometerLayoutWidth = this.options.thermometerWidth;
    var centerX = vertical ? 0 - thermometerLayoutWidth + 10 : index;
    var centerY = vertical ? index : 0 - thermometerLayoutWidth + 10;

    function f(a, b) {
      return a - b / 2;
    }

    var gauge = this;
    var baseX = gauge.centerX;
    var baseY = gauge.centerY;

    this._showMoreLabel(point, centerX + baseX, centerY + baseY, f, f);
  },
  _fixCenterAndRadius: function () {
    var gauge = this,
        gaugeAxis = gauge.gaugeAxis,
        axisOption = gaugeAxis.options;
    var showValueLabel = gauge.valueLabelContent ? gauge.valueLabelContent[0] : null; //如果刻度是透明的，那么刻度的6px和与试管的间隔4px都没有

    gauge.tickUsedWidth = axisOption.tickColor ? TICK_LABEL_GAP + TICK_SIZE : axisOption.minorTickColor ? TICK_LABEL_GAP + MINOR_TICK_SIZE : 0; //如果标签和刻度都没有，那么之间的4px也没有

    gauge.axisTickLabelGap = gauge.tickUsedWidth || gaugeAxis.getTickHeight() ? TICK_LABEL_GAP : 0; //0.8倍字高不包括行间距

    gauge.percentageOneLineHeight = 0;
    gauge.valueOneLineHeight = 0;

    if (gauge.percentageLabelContent) {
      gauge.percentageOneLineHeight = (0, _EnvUtils.getTextHeight)(gauge.percentageLabelStyle);
    }

    if (showValueLabel) {
      gauge.valueOneLineHeight = (0, _EnvUtils.getTextHeight)(showValueLabel.labelStyle);
    }

    var para = gauge.options.thermometerLayout === _Constants["default"].HORIZONTAL_LAYOUT ? this._fixHorizontalThermometerCenter() : this._fixVerticalThermometerCenter();
    var centerX = para.centerX;
    var centerY = para.centerY;
    var radius = para.radius;

    if (gauge.percentageLabelContent) {
      gauge.percentageLabelPos.x -= centerX;
      gauge.percentageLabelPos.y -= centerY; //方向为vertical时，与底边对齐

      gauge.percentageLabelPos.y = gauge.options.thermometerLayout === _Constants["default"].VERTICAL_LAYOUT && !showValueLabel ? Math.min(gauge.percentageLabelPos.y, radius - gauge.percentageLabelDim.height) : gauge.percentageLabelPos.y;
    }

    if (showValueLabel) {
      for (var i = 0; i < gauge.valueLabelContent.length; i++) {
        gauge.valueLabelContent[i].labelPos.x -= centerX;
        gauge.valueLabelContent[i].labelPos.y -= centerY;
      }

      var gap = radius - showValueLabel.labelDim.height - showValueLabel.labelPos.y; //方向为vertical时，与底边对齐

      if (gap < 0 && gauge.options.thermometerLayout === _Constants["default"].VERTICAL_LAYOUT) {
        showValueLabel.labelPos.y += gap;

        if (gauge.percentageLabelContent) {
          gauge.percentageLabelPos.y += gap;
        }
      }
    }

    gauge.centerX = centerX;
    gauge.centerY = centerY;
    gauge.radius = radius;
  },
  _getTickAllHeight: function (width) {
    var gaugeAxis = this.gaugeAxis,
        tickUsedWidth = this.tickUsedWidth,
        axisTickLabelGap = this.axisTickLabelGap;
    return gaugeAxis.getTickHeight() + tickUsedWidth + axisTickLabelGap + width;
  },
  _adjustSameAlignLabelPos: function (initY, radius, centerX) {
    var _this = this;

    var gauge = this;
    var options = gauge.options;
    var percentageLabel = options.percentageLabel,
        valueLabel = options.valueLabel;
    var showValueLabel = gauge.valueLabelContent ? gauge.valueLabelContent[0] : null;
    var startY = initY;
    var valueAndPercentLabelPos, percentageLabelDimWidth;

    if (percentageLabel.labelPosition === valueLabel.labelPosition) {
      valueAndPercentLabelPos = this._valueAndPercentLabelPos(showValueLabel, gauge, radius, startY, centerX);
      showValueLabel.labelPos = valueAndPercentLabelPos.valueLabelPos;
      gauge.percentageLabelPos = valueAndPercentLabelPos.percentageLabelPos;
      startY = valueAndPercentLabelPos.startY;
    } else {
      percentageLabelDimWidth = gauge.percentageLabelDim.width;
      gauge.percentageLabelPos = this._labelPosition(percentageLabel.labelPosition, percentageLabelDimWidth, radius, centerX, startY);
      gauge.valueLabelContent.forEach(function (singleLabelContent) {
        var valueLabelDimWidth = singleLabelContent.labelDim.width;
        singleLabelContent.labelPos = _this._labelPosition(valueLabel.labelPosition, valueLabelDimWidth, radius, centerX, startY);
        startY += gauge.valueOneLineHeight * (1 + gauge.HORIZONTAL_GAP);
      });
    }

    return startY;
  },
  _fixHorizontalThermometerCenter: function () {
    var _this2 = this;

    var gauge = this,
        options = gauge.options,
        gaugeAxis = gauge.gaugeAxis,
        thermometerWidth = options.thermometerWidth;
    var percentageLabel = options.percentageLabel,
        valueLabel = options.valueLabel;
    var showValueLabel = gauge.valueLabelContent ? gauge.valueLabelContent[0] : null;
    var centerX,
        centerY,
        radius = gauge.options.radius;

    var totalHeight = this._getThermometerSize();

    var startY, maxOneLineHeight, percentageLabelDimWidth;

    if (gauge.center) {
      centerX = gauge.center[0];
      centerY = gauge.center[1];
      startY = centerY;
    } else {
      var bounds = gauge.bounds;
      startY = bounds.y + (bounds.height - totalHeight) / 2;
      centerX = bounds.x + bounds.width / 2;
      radius = (0, _thermometer.fixThermometerRadius)(gauge);
    }

    if (gauge.percentageLabelContent || showValueLabel) {
      if (gauge.percentageLabelContent && showValueLabel && percentageLabel.align === _Constants["default"].TOP && valueLabel.align === _Constants["default"].TOP) {
        maxOneLineHeight = Math.max(gauge.percentageOneLineHeight, gauge.valueOneLineHeight);

        if (gauge.center) {
          startY -= maxOneLineHeight * (1 + gauge.LINE_GAP);
          startY -= gauge.valueLabelContent.length > 1 ? gauge.valueOneLineHeight * (1 + gauge.HORIZONTAL_GAP) : 0;
          startY -= this._getTickAllHeight(thermometerWidth / 2);
        }

        startY = this._adjustSameAlignLabelPos(startY, radius, centerX);
      } else {
        if (gauge.percentageLabelContent && percentageLabel.align === _Constants["default"].TOP) {
          if (gauge.center) {
            startY -= gauge.percentageOneLineHeight * (1 + gauge.HORIZONTAL_GAP);
            startY -= this._getTickAllHeight(thermometerWidth / 2);
          }

          percentageLabelDimWidth = gauge.percentageLabelDim.width;
          gauge.percentageLabelPos = this._labelPosition(percentageLabel.labelPosition, percentageLabelDimWidth, radius, centerX, startY);
          startY += gauge.percentageOneLineHeight * (1 + gauge.HORIZONTAL_GAP);
        }

        if (showValueLabel && valueLabel.align === _Constants["default"].TOP) {
          if (gauge.center) {
            startY -= gauge.valueOneLineHeight * (1 + gauge.HORIZONTAL_GAP);
            startY -= gaugeAxis.getTickHeight() + gauge.tickUsedWidth + gauge.axisTickLabelGap + thermometerWidth / 2;
          }

          gauge.valueLabelContent.forEach(function (singleLabelContent) {
            var valueLabelDimWidth = singleLabelContent.labelDim.width;
            singleLabelContent.labelPos = _this2._labelPosition(valueLabel.labelPosition, valueLabelDimWidth, radius, centerX, startY);
            startY += gauge.valueOneLineHeight * (1 + gauge.HORIZONTAL_GAP);
          });
        }
      }
    }

    if (gauge.center) {
      startY = centerY + thermometerWidth / 2;
    } else {
      startY += this._getTickAllHeight(thermometerWidth);
      centerY = startY - thermometerWidth / 2;
    }

    if (gauge.percentageLabelContent || showValueLabel) {
      if (gauge.percentageLabelContent && showValueLabel && percentageLabel.align === _Constants["default"].BOTTOM && valueLabel.align === _Constants["default"].BOTTOM) {
        maxOneLineHeight = Math.max(gauge.percentageOneLineHeight, gauge.valueOneLineHeight);
        startY += maxOneLineHeight * gauge.HORIZONTAL_GAP;
        startY = this._adjustSameAlignLabelPos(startY, radius, centerX);
      } else {
        if (gauge.percentageLabelContent && percentageLabel.align === _Constants["default"].BOTTOM) {
          startY += gauge.percentageOneLineHeight * gauge.HORIZONTAL_GAP;
          percentageLabelDimWidth = gauge.percentageLabelDim.width;
          gauge.percentageLabelPos = this._labelPosition(percentageLabel.labelPosition, percentageLabelDimWidth, radius, centerX, startY);
        }

        if (showValueLabel && valueLabel.align === _Constants["default"].BOTTOM) {
          startY += gauge.valueOneLineHeight * gauge.HORIZONTAL_GAP;
          gauge.valueLabelContent.forEach(function (singleLabelContent) {
            var valueLabelDimWidth = singleLabelContent.labelDim.width;
            singleLabelContent.labelPos = _this2._labelPosition(valueLabel.labelPosition, valueLabelDimWidth, radius, centerX, startY);
            startY += gauge.valueOneLineHeight * (1 + gauge.HORIZONTAL_GAP);
          });
        }
      }
    }

    return {
      centerX: centerX,
      centerY: centerY,
      radius: radius
    };
  },
  _labelPosition: function (labelAlign, labelDimWidth, radius, centerX, startY) {
    var gauge = this,
        gaugeAxis = gauge.gaugeAxis;
    var domain = gaugeAxis.scale.domain(),
        point = gauge.points[0];

    var scale = _Scale["default"].linear().domain(domain).range([-radius, radius]);

    var valueInDomain = _BaseUtils["default"].getValueInDomain(point.value, domain),
        endX = scale(valueInDomain);

    if (labelAlign === _Constants["default"].AUTO) {
      return {
        x: centerX + endX - labelDimWidth,
        y: startY
      };
    } else if (labelAlign === _Constants["default"].LEFT) {
      return {
        x: centerX - radius,
        y: startY
      };
    } else {
      return {
        x: centerX + radius - labelDimWidth,
        y: startY
      };
    }
  },
  _valueAndPercentLabelPos: function (showValueLabel, gauge, radius, startY, centerX) {
    var valueLabelPos, percentageLabelPos;
    var options = gauge.options,
        valueLabelPosition = options.valueLabel.labelPosition,
        percentageLabelPosition = valueLabelPosition;
    var showValueLabelDimWidth = showValueLabel.labelDim.width,
        percentageLabelDimWidth = gauge.percentageLabelDim.width;
    var valueAndPercentageWidth = showValueLabelDimWidth + percentageLabelDimWidth + DEFAULT_BLANK;
    var maxOneLineHeight = Math.max(gauge.percentageOneLineHeight, gauge.valueOneLineHeight);

    if (valueAndPercentageWidth < 2 * radius && gauge.valueLabelContent.length < 2) {
      var labelPos = this._singleLineValueAndPercentLabelPos(showValueLabel, gauge, startY, centerX, radius);

      valueLabelPos = labelPos.valueLabelPos;
      percentageLabelPos = labelPos.percentageLabelPos;
    } else {
      valueLabelPos = this._labelPosition(valueLabelPosition, showValueLabelDimWidth, radius, centerX, startY);
      startY += gauge.valueOneLineHeight * (1 + gauge.LINE_GAP);
      percentageLabelPos = this._labelPosition(percentageLabelPosition, gauge.percentageLabelDim.width, radius, centerX, startY);

      if (gauge.valueLabelContent.length > 1) {
        var valueString = gauge.valueLabelContent[1];

        var valueAndPercentLabelPos = this._singleLineValueAndPercentLabelPos(valueString, gauge, startY, centerX, radius);

        gauge.valueLabelContent[1].labelPos = valueAndPercentLabelPos.valueLabelPos;
        percentageLabelPos = valueAndPercentLabelPos.percentageLabelPos;
      }
    }

    return {
      valueLabelPos: valueLabelPos,
      percentageLabelPos: percentageLabelPos,
      startY: startY + maxOneLineHeight * (1 + gauge.HORIZONTAL_GAP)
    };
  },
  _singleLineValueAndPercentLabelPos: function (showValueLabel, gauge, startY, centerX, radius) {
    var valueLabelPos, percentageLabelPos;
    var valueAndPercentageWidth = showValueLabel.labelDim.width + gauge.percentageLabelDim.width + DEFAULT_BLANK;
    var options = gauge.options,
        valueLabelPosition = options.valueLabel.labelPosition;
    valueLabelPos = this._labelPosition(valueLabelPosition, valueAndPercentageWidth, radius, centerX, startY);
    percentageLabelPos = {
      x: valueLabelPos.x + showValueLabel.labelDim.width + DEFAULT_BLANK,
      y: startY
    };
    return {
      valueLabelPos: valueLabelPos,
      percentageLabelPos: percentageLabelPos
    };
  },
  _fixVerticalThermometerCenter: function () {
    var gauge = this,
        options = gauge.options,
        gaugeAxis = gauge.gaugeAxis;
    var percentageLabel = options.percentageLabel,
        valueLabel = options.valueLabel;
    var centerX,
        centerY,
        radius = options.radius,
        thermometerWidth = options.thermometerWidth;
    var showValueLabel = gauge.valueLabelContent ? gauge.valueLabelContent[0] : null; // 纵向布局

    var totalWidth = this._getThermometerSize();

    var startX;

    if (gauge.center) {
      centerX = gauge.center[0];
      centerY = gauge.center[1];
      startX = centerX - thermometerWidth;
    } else {
      var bounds = gauge.bounds;
      startX = bounds.x + (bounds.width - totalWidth) / 2;
      centerY = bounds.y + bounds.height / 2;
      radius = (0, _thermometer.fixThermometerRadius)(gauge, true);
    }

    var posYObj;
    var labelY = (0, _thermometer.verticalThermometerLabelY)(gauge, radius, centerY);

    if (gauge.percentageLabelContent || showValueLabel) {
      if (gauge.percentageLabelContent && showValueLabel && percentageLabel.align === _Constants["default"].LEFT && valueLabel.align === _Constants["default"].LEFT) {
        if (!gauge.center) {
          startX += Math.max(gauge.percentageLabelDim.width, showValueLabel.labelDim.width);
        }

        posYObj = (0, _thermometer.fixSameAlignLabelsPosY)(gauge, labelY);
        gauge.percentageLabelPos = {
          x: startX - gauge.percentageLabelDim.width,
          y: posYObj.percentageLabelPosY
        };
        showValueLabel.labelPos = {
          x: startX - showValueLabel.labelDim.width,
          y: posYObj.valueLabelY
        };
        startX += gauge.LINE_GAP * Math.max(gauge.percentageOneLineHeight, gauge.valueOneLineHeight);
      } else {
        if (gauge.percentageLabelContent && percentageLabel.align === _Constants["default"].LEFT) {
          if (gauge.center) {
            startX -= gauge.percentageLabelDim.width + gauge.LINE_GAP * gauge.percentageOneLineHeight;
          }

          gauge.percentageLabelPos = {
            x: startX,
            y: labelY
          };
          startX += gauge.percentageLabelDim.width + gauge.LINE_GAP * gauge.percentageOneLineHeight;
        }

        if (showValueLabel && valueLabel.align === _Constants["default"].LEFT) {
          if (gauge.center) {
            startX -= showValueLabel.labelDim.width + gauge.LINE_GAP * gauge.valueOneLineHeight;
          }

          showValueLabel.labelPos = {
            x: startX,
            y: labelY
          };
          startX += showValueLabel.labelDim.width + gauge.LINE_GAP * gauge.valueOneLineHeight;
        }
      }
    }

    if (gauge.center) {
      startX = centerX - thermometerWidth / 2;
    } else {
      centerX = startX + thermometerWidth / 2;
    }

    startX += thermometerWidth + gauge.tickUsedWidth + gauge.axisTickLabelGap + gaugeAxis.getMaxTickWidth();

    if (gauge.percentageLabelContent || showValueLabel) {
      if (gauge.percentageLabelContent && showValueLabel && percentageLabel.align === _Constants["default"].RIGHT && valueLabel.align === _Constants["default"].RIGHT) {
        startX += gauge.LINE_GAP * Math.max(gauge.percentageOneLineHeight, gauge.valueOneLineHeight);
        posYObj = (0, _thermometer.fixSameAlignLabelsPosY)(gauge, labelY);
        gauge.percentageLabelPos = {
          x: startX,
          y: posYObj.percentageLabelPosY
        };
        showValueLabel.labelPos = {
          x: startX,
          y: posYObj.valueLabelY
        };
      } else {
        if (gauge.percentageLabelContent && percentageLabel.align === _Constants["default"].RIGHT) {
          gauge.percentageLabelPos = {
            x: startX + gauge.LINE_GAP * gauge.percentageOneLineHeight,
            y: labelY
          };
        }

        if (showValueLabel && valueLabel.align === _Constants["default"].RIGHT) {
          showValueLabel.labelPos = {
            x: startX + gauge.LINE_GAP * gauge.valueOneLineHeight,
            y: labelY
          };
        }
      }
    }

    return {
      centerX: centerX,
      centerY: centerY,
      radius: radius
    };
  },
  //试管仪表盘占据的大小,不算间隔
  _getThermometerSize: function () {
    var gauge = this,
        options = gauge.options,
        valueLabel = options.valueLabel,
        gaugeAxis = gauge.gaugeAxis;
    var showValueLabel = gauge.valueLabelContent ? gauge.valueLabelContent[0] : null;
    var percentageLabel = options.percentageLabel,
        thermometerWidth = options.thermometerWidth;

    if (gauge.options.thermometerLayout == _Constants["default"].HORIZONTAL_LAYOUT) {
      var totalHeight = 0;

      if (gauge.percentageLabelContent && showValueLabel) {
        if (percentageLabel.align == valueLabel.align) {
          var maxOneLineHeight = Math.max(gauge.percentageOneLineHeight, gauge.valueOneLineHeight);

          if (percentageLabel.labelPosition == valueLabel.labelPosition && gauge.valueLabelContent.length > 1) {
            totalHeight += gauge.LINE_GAP * gauge.valueOneLineHeight;
          }

          totalHeight += gauge.HORIZONTAL_GAP * maxOneLineHeight;
        }
      } else if (gauge.percentageLabelContent) {
        totalHeight += (1 + gauge.HORIZONTAL_GAP) * gauge.percentageOneLineHeight;
      } else if (showValueLabel) {
        var valueLabelLineHeight = gauge.valueLabelContent.length === 2 ? gauge.valueOneLineHeight * 2 : gauge.valueOneLineHeight;
        totalHeight += (1 + gauge.HORIZONTAL_GAP) * valueLabelLineHeight;
      }

      totalHeight += thermometerWidth + gauge.tickUsedWidth + gauge.axisTickLabelGap + gaugeAxis.getTickHeight();
      return totalHeight;
    } else {
      var totalWidth = 0;

      if (gauge.percentageLabelContent && showValueLabel) {
        if (percentageLabel.align == valueLabel.align) {
          totalWidth += Math.max(gauge.percentageLabelDim.width, showValueLabel.labelDim.width);
          totalWidth += gauge.VERTICAL_GAP * Math.max(gauge.percentageOneLineHeight, gauge.valueOneLineHeight);
        } else {
          totalWidth += gauge.percentageLabelDim.width + showValueLabel.labelDim.width;
          totalWidth += gauge.VERTICAL_GAP * (gauge.percentageOneLineHeight + gauge.valueOneLineHeight);
        }
      } else if (gauge.percentageLabelContent) {
        totalWidth += gauge.percentageLabelDim.width + gauge.VERTICAL_GAP * gauge.percentageOneLineHeight;
      } else if (showValueLabel) {
        totalWidth += showValueLabel.labelDim.width + gauge.VERTICAL_GAP * gauge.valueOneLineHeight;
      }

      totalWidth += gaugeAxis.getMaxTickWidth();
      totalWidth += thermometerWidth + gauge.tickUsedWidth + gauge.axisTickLabelGap;
      return totalWidth;
    }
  },

  /**
   * 在绘制标签的过程中，我们需要计算标签相对当前位置的偏移位置，来作为标签数是动画初始的位置
   * 在试管横放的时候，标签的位置为试管长度的一半，即试管中心位置，
   * 试管竖放的时候，标签的位置与当前的数据点高度齐平。
   * 而默认的标签起始位置为试管的最小的一端端点，这样就可以计算出相对于当前位置的动画初始偏移位置
   * 这里值得一提的是，数据刷新时，标签的位置，应该从上次的位置开始，而非试管的端点，
   * 由于该方法可能会被seriesLabel和valueLabel调用，因此只在绘制标签后更新lastShiftLength（上一次的标签距离端点的偏移长度）
   * @returns {{enabled: boolean, initAttr: {transform: *}, initStyle: {opacity: number}}}
   */
  animateLabelPara: function () {
    var series = this,
        point = series.points[0];
    var gaugeAxis = series.gaugeAxis,
        domain = gaugeAxis.scale.domain(),
        isVertical = series.options.thermometerLayout === _Constants["default"].VERTICAL_LAYOUT;

    var valueInDomain = _BaseUtils["default"].getValueInDomain(point.value, domain),
        radius = series.radius;

    var scale = _Scale["default"].linear().domain(domain).range([0, 2 * radius]); // 标签位置距离端点的长度


    var shiftLength = isVertical ? scale(valueInDomain) : -radius; // 实时更新lastLabelShiftLength

    lastLabelShiftLength = shiftLength; // 使用和上一次偏移距离的差值，作为drawLabel动画的initAttr

    shiftLength -= this._lastShiftLength || 0; // 摆放方向不同，对应的偏移属性也不一样

    var pos = isVertical ? {
      x: 0,
      y: shiftLength
    } : {
      x: shiftLength,
      y: 0
    };
    return {
      enabled: true,
      initAttr: {
        'transform': _BaseUtils["default"].makeTranslate(pos)
      },
      initStyle: {
        'opacity': 0
      }
    };
  },
  // 标签绘制结束时，更新lastLabelPos
  updateLastLabelPos: function () {
    this._lastShiftLength = lastLabelShiftLength;
  },
  _fillFilter: function (color, useAlpha) {
    var series = this,
        vanchart = series.vanchart,
        renderer = vanchart.renderer,
        isVertical = series.options.thermometerLayout === _Constants["default"].VERTICAL_LAYOUT;

    if ((0, _EnvUtils.supportFillFilter)()) {
      var endColor = color;

      var startColor = _ColorUtils["default"].mixColorWithHSB(endColor, 0, -0.1, 0.1);

      if (useAlpha) {
        var alpha = _ColorUtils["default"].getStandardColorAndOpacity(endColor).alpha;

        if (alpha < 1) {
          startColor = _ColorUtils["default"].mixColorWithAlpha(startColor, alpha);
        }
      }

      var x2 = '0%',
          y2 = '0%';
      isVertical ? y2 = '100%' : x2 = '100%';
      var stop1 = {
        'offset': '0%',
        'stop-color': isVertical ? endColor : startColor
      };
      var stop2 = {
        'offset': '100%',
        'stop-color': isVertical ? startColor : endColor
      };
      var attr = {
        'x1': '0%',
        'y1': '0%',
        'x2': x2,
        'y2': y2
      };

      if (this.colorGradient) {
        renderer.updateColorGradient(this.colorGradient, attr, [stop1, stop2]);
      } else {
        this.colorGradient = renderer.colorGradient(attr, [stop1, stop2]);
      }

      return renderer.toPatternProperty(this.colorGradient);
    }

    return color;
  },
  _clickEndColor: function (point) {
    return _ColorUtils["default"].getColorWithDivider(point.color, 1 / 0.95);
  },
  _mouseOverEndColor: function (point) {
    return _ColorUtils["default"].getColorWithDivider(point.mouseOverColor, 1 / 0.95);
  },
  drawSeries: function () {
    var series = this,
        options = series.options,
        point = series.points[0],
        thermometerWidth = options.thermometerWidth,
        vanchart = series.vanchart,
        renderer = vanchart.renderer,
        group = series.group;
    var gaugeAxis = series.gaugeAxis,
        domain = gaugeAxis.scale.domain(),
        isVertical = series.options.thermometerLayout === _Constants["default"].VERTICAL_LAYOUT;

    var valueInDomain = _BaseUtils["default"].getValueInDomain(point.value, domain),
        radius = series.radius;

    if (!this.backgruondLine) {
      this.backgruondLine = renderer.line().addTo(group);
      this.axisGroup = renderer.group().addTo(group);
    }

    if (!this.thermometerLine) {
      this.thermometerLine = renderer.line().addTo(group);
      this.needlePath = renderer.circle().addTo(group);
    }

    this.labelGroup = this._getPointTextLabelGroup();

    var scale = _Scale["default"].linear().domain(domain).range([-radius, radius]);

    var x1 = 'x1',
        y1 = 'y1',
        x2 = 'x2',
        y2 = 'y2',
        cx = 'cx',
        cy = 'cy';
    var endX = scale(valueInDomain);
    var initX = -radius;

    if (isVertical) {
      x1 = 'y1';
      y1 = 'x1';
      x2 = 'y2';
      y2 = 'x2';
      cx = 'cy';
      cy = 'cx';
      initX = radius;
      endX = scale.range([radius, -radius])(valueInDomain);
    }

    var lastX = _BaseUtils["default"].pick(series.thermometerLine.node()._lastX_, initX);

    series.thermometerLine.node()._lastX_ = endX;
    var slotBackgroundColor = (0, _ThemeConfig.getThemeAutoValue)(options.slotBackgroundColor, 'paneBackgroundColor', vanchart.isDarkTheme());
    series.backgruondLine.attr(x1, -radius).attr(y1, 0).attr(x2, radius).attr(y2, MAGIC_DET).style({
      'fill': 'none',
      'stroke': slotBackgroundColor,
      'stroke-width': Math.max(thermometerWidth - 1, 0),
      'stroke-linecap': 'round'
    }); // CHART-12839

    if (point.isNull) {
      if (this.thermometerLine) {
        this.thermometerLine.remove();
        this.needlePath.remove();
        this.thermometerLine = this.needlePath = null;
      }
    } else {
      //为空的时候不画指针
      series.thermometerLine.attr(x1, initX).attr(y1, 0).attr(y2, MAGIC_DET).attr(x2, lastX).style({
        'stroke': series._fillFilter(point.color, true),
        'stroke-width': thermometerWidth,
        'stroke-linecap': 'round'
      });
      series.needlePath.attr('r', thermometerWidth * NEEDLE).attr(cx, lastX).attr(cy, 0).style({
        'fill': options.needle,
        'fill-opacity': _ColorUtils["default"].getColorOpacity(options.needle)
      });
      var attr = {};
      attr[x2] = endX;
      series.thermometerLine.animate({
        duration: series.ANIMATION_TIME,
        ease: series.EASE_TYPE,
        attr: attr,
        style: {
          'stroke-linecap': 'round'
        }
      });
      attr = {};
      attr[cx] = endX;
      series.needlePath.animate({
        duration: series.ANIMATION_TIME,
        ease: series.EASE_TYPE,
        attr: attr
      });
    }

    this._drawGaugeLabels(this.labelGroup);

    this._drawThermometerTicks(scale);
  },
  _drawThermometerTicks: function (scale) {
    var series = this,
        bands = series.options.bands,
        vanchart = series.vanchart,
        gaugeAxis = series.gaugeAxis,
        renderer = vanchart.renderer,
        thermometerWidth = series.options.thermometerWidth;
    var axisG = this.labelGroup,
        tickData = gaugeAxis.getTickData(),
        minorTickData = gaugeAxis.getMinorTickData();

    var axisOption = gaugeAxis.options,
        labelStyle = _BaseUtils["default"].clone(axisOption.labelStyle),
        useHtml = axisOption.useHtml;

    labelStyle.fontSize = labelStyle.autoSize ? TICK_LABEL_FONTSIZE : labelStyle.fontSize;
    var x1 = 'x1',
        y1 = 'y1',
        x2 = 'x2',
        y2 = 'y2';
    var startY = -thermometerWidth / 2 - TICK_LABEL_GAP,
        endY = -thermometerWidth / 2 - (TICK_LABEL_GAP + TICK_SIZE),
        endMinorY = -thermometerWidth / 2 - (TICK_LABEL_GAP + MINOR_TICK_SIZE);
    var textY = -(thermometerWidth / 2 + series.tickUsedWidth + series.axisTickLabelGap);
    var selection, i, len, posX, currentTickLines;

    var attrFunc = function (tickD, posX) {
      return {
        x: posX - tickD.tickDim.width / 2,
        y: textY - tickD.tickDim.height * 0.85,
        dy: '0.85em'
      };
    };

    if (series.options.thermometerLayout === _Constants["default"].VERTICAL_LAYOUT) {
      x1 = 'y1';
      y1 = 'x1';
      x2 = 'y2';
      y2 = 'x2';
      startY = thermometerWidth / 2 + TICK_LABEL_GAP;
      endY = thermometerWidth / 2 + TICK_LABEL_GAP + TICK_SIZE;
      endMinorY = thermometerWidth / 2 + TICK_LABEL_GAP + MINOR_TICK_SIZE;
      textY = -textY;

      attrFunc = function (tickD, posX) {
        return {
          x: textY,
          y: posX - tickD.tickDim.height / 2,
          dy: '.85em'
        };
      };
    }

    this.ticks = this.ticks || [];
    selection = gaugeAxis._bindData(this.ticks, tickData, function (d) {
      return scale(d.tickValue);
    });
    selection.exit.map(function (layer) {
      layer.text && layer.text.remove();
      layer.remove();
    });
    currentTickLines = selection.enter.map(function (d) {
      var line = axisG.append(renderer.line().datum(d));

      if ((0, _CoreUtils.hasDefined)(d.tickContent)) {
        line.text = axisG.append(renderer.vtext(useHtml));
      }

      return line;
    });
    this.ticks = currentTickLines = currentTickLines.concat(selection.update);

    for (i = 0, len = currentTickLines.length; i < len; i++) {
      var tick = currentTickLines[i],
          tickD = tick.datum();
      posX = _BaseUtils["default"].lineSubPixelOpt(scale(tickD.tickValue), 1);
      tick.attr(x1, posX).attr(y1, startY).attr(x2, posX).attr(y2, endY).style({
        'stroke': axisOption.tickColor,
        'stroke-width': axisOption.tickColor ? axisOption.tickWidth : 0
      }); // CHART-1910 IE兼容模式下无颜色绘制灰色stroke，这边判断无颜色的时候，tickWidth用0

      tick.text && tick.text.style(labelStyle).attr(attrFunc(tickD, posX)).textContent(tickD.tickContent);
    }

    this.minorTics = this.minorTics || [];
    selection = gaugeAxis._bindData(this.minorTics, minorTickData);
    currentTickLines = [];

    for (i = 0, len = selection.exit.length; i < len; i++) {
      selection.exit[i].remove();
    }

    for (i = 0, len = selection.enter.length; i < len; i++) {
      currentTickLines.push(axisG.append(renderer.line().datum(selection.enter[i])));
    }

    this.minorTics = currentTickLines = currentTickLines.concat(selection.update);

    for (i = 0, len = currentTickLines.length; i < len; i++) {
      var tickLine = currentTickLines[i],
          value = tickLine.datum();
      posX = _BaseUtils["default"].lineSubPixelOpt(scale(value), 1);
      tickLine.attr(x1, posX).attr(y1, startY).attr(x2, posX).attr(y2, endMinorY).style({
        'stroke': axisOption.minorTickColor,
        'stroke-width': axisOption.minorTickColor ? axisOption.minorTickWidth : 0
      });
    }
  },
  _getFixedPos: function (datum, divDim) {
    var gauge = datum.series,
        options = gauge.options,
        thermometerWidth = options.thermometerWidth;
    var thermometerLayout = gauge.options.thermometerLayout;
    var percentContent = gauge.percentageLabelContent,
        valueContent = gauge.valueLabelContent;
    var x, y, valueLabel;

    if (thermometerLayout === _Constants["default"].HORIZONTAL_LAYOUT) {
      x = gauge.centerX - divDim.width / 2;
      var baseY = gauge.centerY;
      y = baseY + thermometerWidth / 2 + 10;

      if (percentContent && percentContent.length && options.percentageLabel.align === _Constants["default"].BOTTOM) {
        y = baseY + gauge.percentageLabelPos.y + gauge.percentageLabelDim.height + 10;
      }

      if (valueContent && valueContent.length && options.valueLabel.align === _Constants["default"].BOTTOM) {
        valueLabel = gauge.valueLabelContent[0];
        y = baseY + valueLabel.labelPos.y + valueLabel.labelDim.height + 10;
      }
    } else {
      y = gauge.centerY - divDim.height / 2;
      var tickWidth = gauge.gaugeAxis.getMaxTickWidth();
      var baseX = gauge.centerX;
      x = baseX + thermometerWidth / 2 + TICK_LABEL_GAP + TICK_SIZE + TICK_LABEL_GAP + tickWidth + 10;

      if (percentContent && percentContent.length && options.percentageLabel.align === _Constants["default"].RIGHT) {
        x = baseX + gauge.percentageLabelPos.x + gauge.percentageLabelDim.width + 10;
      }

      if (valueContent && valueContent.length && options.valueLabel.align === _Constants["default"].RIGHT) {
        valueLabel = gauge.valueLabelContent[0];
        x = Math.max(x, baseX + valueLabel.labelPos.x + valueLabel.labelDim.width + 10);
      }
    }

    return [x, y];
  },
  _onSeriesMouseOver: function (ev) {
    _Gauge["default"].prototype._onSeriesMouseOver.call(this, ev);

    var series = this,
        point = this.points[0];

    if (point) {
      series._onState(series.thermometerLine, true, {
        'stroke': series._fillFilter(series._mouseOverEndColor(point))
      });

      series._onState(series.needlePath, true, {
        'fill': _ColorUtils["default"].getHighLightColor(series.options.needle)
      });
    }
  },
  _onSeriesMouseOut: function (ev) {
    _Gauge["default"].prototype._onSeriesMouseOut.call(this, ev);

    var series = this,
        point = series.points[0];

    if (point) {
      series._onState(series.thermometerLine, false, {
        'stroke': series._fillFilter(point.color, true)
      });

      series._onState(series.needlePath, false, {
        'fill': this.options.needle
      });
    }
  },
  onSeriesPress: function () {
    var point = this.points[0];

    if (point) {
      this.thermometerLine.style('stroke', this._fillFilter(this._clickEndColor(point)));
      this.needlePath.style({
        'fill': _ColorUtils["default"].getClickColor(this.options.needle)
      });
    }
  },
  onSeriesPressUp: function () {
    this._onSeriesMouseOver();
  },
  getDefaultTooltipFormatter: function () {
    return {
      categoryFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{CATEGORY}{VALUE}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = ThermometerGauge;
exports["default"] = _default;

/***/ }),
/* 149 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.fixThermometerRadius = fixThermometerRadius;
exports.dealPercentLabel = dealPercentLabel;
exports.dealValueLabel = dealValueLabel;
exports.verticalThermometerLabelY = verticalThermometerLabelY;
exports.fixSameAlignLabelsPosY = fixSameAlignLabelsPosY;

var _customLabel = __webpack_require__(58);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _dataLabelFormatter = __webpack_require__(24);

var _gaugeTextFormatter = __webpack_require__(59);

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _CoreUtils = __webpack_require__(3);

var _Scale = _interopRequireDefault(__webpack_require__(10));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

var WRITING_MODE = {
  'writing-mode': 'tb-rl',
  '-webkit-writing-mode': 'vertical-rl'
};

function fixLabelStyle(series, labelOpt) {
  var style = labelOpt.style;
  var fontSize = style.autoSize ? series.LABEL_AUTO_FONTSIZE : style.fontSize;
  var color = series.getThemeLabelColor(style);

  var labelStyle = _extends({}, style, {
    fontSize: fontSize,
    color: color
  });

  return series.isSupportVerticalLabel() ? _extends({}, labelStyle, WRITING_MODE) : labelStyle;
}

function thermometerCustomLabel(series, labelOpt, autoSize) {
  var point = series.points[0];
  var style = fixLabelStyle(series, labelOpt);

  var label = _extends({}, labelOpt, {
    style: style
  });

  return (0, _customLabel.customLabel)(point, label, autoSize);
}

function fixThermometerRadius(series, isVertical) {
  var bounds = series.bounds,
      gaugeAxis = series.gaugeAxis,
      options = series.options;
  var size = isVertical ? bounds.height : bounds.width;
  return (0, _CoreUtils.hasDefined)(options.radius) ? options.radius : size / 2 - gaugeAxis.getMaxTickWidth() - series.DEFAULT_PADDING;
}

function normalPercentLabel(series, percentageLabelOpt) {
  var labelStyle = fixLabelStyle(series, percentageLabelOpt);

  var percentageLabel = _extends({}, percentageLabelOpt, {
    style: labelStyle
  });

  var point = series.points[0];
  var labelArr = (0, _dataLabelFormatter.defaultLabelContent)(point, percentageLabel);

  if (!(labelArr && labelArr[0])) {
    return {
      labelContent: '',
      labelStyle: labelStyle,
      labelDim: {
        width: 0,
        height: 0
      }
    };
  }

  var _labelArr$ = labelArr[0],
      labelContent = _labelArr$.text,
      labelDim = _labelArr$.dim;
  return {
    labelContent: labelContent,
    labelStyle: labelStyle,
    labelDim: labelDim
  };
}

function dealPercentLabel(series) {
  var label;
  var options = series.options,
      points = series.points;
  var percentageLabel = options.percentageLabel;
  var point = points[0];

  if (!series.isValidDataLabel(point, percentageLabel)) {
    series.percentageLabelContent = '';
    series.percentageLabelDim = {
      width: 0,
      height: 0
    };
    return;
  }

  if ((0, _customLabel.isCustomLabel)(percentageLabel.formatter)) {
    label = thermometerCustomLabel(series, percentageLabel, series.LABEL_AUTO_FONTSIZE);
  } else {
    label = normalPercentLabel(series, percentageLabel);
  }

  var _label = label,
      labelContent = _label.labelContent,
      labelStyle = _label.labelStyle,
      labelDim = _label.labelDim;
  series.percentageLabelContent = labelContent;
  series.percentageLabelDim = labelDim;
  series.percentageLabelStyle = labelStyle;
}

function verticalNormalValueLabel(series) {
  var valueLabelContent = [];
  var options = series.options,
      bounds = series.bounds,
      points = series.points,
      center = series.center;
  var valueLabel = options.valueLabel;
  var point = points[0];
  var formatter = valueLabel.formatter;
  var style = fixLabelStyle(series, valueLabel);
  var limitWidth = center ? 2 * options.radius : (1 - series.DEFAULT_LABEL_WIDTH) * bounds.width;
  var labelContent = (0, _gaugeTextFormatter.calculateSingleLineLabelContent)(formatter, point);
  labelContent = _BaseUtils["default"].getEllipsisText(labelContent, limitWidth, style, false);

  var labelDim = _BaseUtils["default"].getTextDimension(labelContent, style, false);

  valueLabelContent.push({
    labelContent: labelContent,
    labelDim: labelDim,
    labelStyle: _BaseUtils["default"].extend({}, style) // CHART-1698

  });
  return valueLabelContent;
}

function horizontalNormalValueLabel(series) {
  var options = series.options,
      points = series.points;
  var valueLabel = options.valueLabel;
  var limitWidth = 2 * fixThermometerRadius(series);
  var initLabelContent = (0, _gaugeTextFormatter.createMultiLineLabelContent)(valueLabel.formatter, points[0]);
  series.thermometerValueLabelWithPercent(initLabelContent, valueLabel, limitWidth, series);
}

function dealValueLabel(series) {
  var options = series.options,
      points = series.points;
  var valueLabel = options.valueLabel,
      thermometerLayout = options.thermometerLayout;
  var point = points[0];

  if (!series.isValidDataLabel(point, valueLabel)) {
    series.valueLabelContent = [];
    return;
  }

  if ((0, _customLabel.isCustomLabel)(valueLabel.formatter)) {
    var label = thermometerCustomLabel(series, valueLabel, series.LABEL_AUTO_FONTSIZE);
    series.valueLabelContent = [label];
    return;
  }

  if (thermometerLayout === _Constants["default"].VERTICAL_LAYOUT) {
    series.valueLabelContent = verticalNormalValueLabel(series);
    return;
  }

  horizontalNormalValueLabel(series);
}

function verticalThermometerLabelY(series, radius, centerY) {
  var point = series.points[0];
  var gaugeAxis = series.gaugeAxis;
  var domain = gaugeAxis.scale.domain();

  var scale = _Scale["default"].linear().domain(domain).range([radius, -radius]);

  var valueY = centerY + scale(_BaseUtils["default"].getValueInDomain(point.value, domain));
  var percentageOneLineHeight = series.percentageOneLineHeight,
      valueOneLineHeight = series.valueOneLineHeight;
  var offsetY = (percentageOneLineHeight || valueOneLineHeight) / 3; // 差不多居中的位置

  return valueY - offsetY;
}

function fixSameAlignLabelsPosY(series, labelY) {
  var isVerticalText = series.isSupportVerticalLabel();

  if (isVerticalText) {
    return {
      valueLabelY: labelY,
      percentageLabelPosY: labelY + series.valueLabelContent[0].labelDim.height + 0.5 * series.valueOneLineHeight
    };
  }

  return {
    percentageLabelPosY: labelY,
    valueLabelY: labelY + series.percentageLabelDim.height * (1 + series.LINE_GAP)
  };
}

/***/ }),
/* 150 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Gauge = _interopRequireDefault(__webpack_require__(50));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _EnvUtils = __webpack_require__(2);

var _slotAndRing = __webpack_require__(82);

var _ThemeConfig = __webpack_require__(17);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/8/9.
 * 环形仪表盘
 */
var RING_PADDING_PERCENT = 0.08; //圆环仪表盘内边距占比

var RING_PANE_BACKGROUND_OPACITY = 1; //圆环仪表盘底盘颜色不透明度

var RingGauge = _Gauge["default"].extend({
  gaugeType: _Constants["default"].RING_GAUGE,
  _doLayout: function () {
    (0, _slotAndRing.dealSlotAndRingPercentLabel)(this, RING_PADDING_PERCENT);
    (0, _slotAndRing.dealSlotAndRingValueLabel)(this, RING_PADDING_PERCENT);

    this._fixCenterAndRadius(RING_PADDING_PERCENT);
  },
  drawSeries: function () {
    var series = this,
        options = series.options,
        vanchart = series.vanchart,
        renderer = vanchart.renderer,
        group = series.group;

    if (!this.backgruondPath) {
      this.backgruondPath = renderer.path().addTo(group);
    }

    if (!this.ringPath) {
      this.ringPath = renderer.path().addTo(group);
    }

    if (!this.innerBackgroundPath) {
      this.innerBackgroundPath = renderer.path().addTo(group);
    }

    this.labelGroup = this._getPointTextLabelGroup();

    if (!this.colorGradient) {
      if ((0, _EnvUtils.supportFillFilter)()) {
        var attrs = {
          'x1': '0%',
          'y1': "0%",
          'x2': "0%",
          'y2': "100%"
        };
        var stop1 = {
          'offset': '0%',
          'stop-color': '#ffffff'
        };
        var stop2 = {
          'offset': '100%',
          'stop-color': '#dddddd'
        };
        this.colorGradient = renderer.colorGradient(attrs, [stop1, stop2]);
      } else {
        this.colorGradient = '#ffffff';
      }
    }

    var ringPercent = options.circleWidth;
    var ringRadius = series.radius * (1 - ringPercent); // CHART-12839:两个相同弧形重叠时会出现边缘锯齿，将底层弧形宽度缩小1

    var backgroundPathInnerR = Math.min(ringRadius + 0.5, series.radius);
    var backgroundPathOuterR = backgroundPathInnerR === series.radius ? series.radius : Math.max(series.radius - 0.5, 0);

    var circle = _PathGenerator["default"].arc().startAngle(0).endAngle(2 * Math.PI).innerRadius(backgroundPathInnerR).outerRadius(backgroundPathOuterR);

    var innerCircle = _PathGenerator["default"].arc().startAngle(0).endAngle(2 * Math.PI).innerRadius(0);

    var domain = series.gaugeAxis.scale.domain();

    var startFill = series._getColorFromBands(domain[0], series.defaultBands);

    var innerR = series.radius * (1 - ringPercent - RING_PADDING_PERCENT);
    var paneBackgroundColor = (0, _ThemeConfig.getThemeAutoValue)(options.paneBackgroundColor, 'paneBackgroundColor', vanchart.isDarkTheme());
    this.backgruondPath.attr('d', circle()).style({
      'fill': paneBackgroundColor,
      'fill-opacity': RING_PANE_BACKGROUND_OPACITY
    });
    var point = series.points[0];

    if (point && !point.isNull) {
      var arc = _PathGenerator["default"].arc().startAngle(0).innerRadius(ringRadius).outerRadius(series.radius);

      var endFill = point.color,
          arcPercentage = _BaseUtils["default"].getValueInDomain(point.percentage, [0, 1]);

      var endRadian = 2 * Math.PI * arcPercentage * (options.clockwise ? 1 : -1);
      this.ringPath.style({
        'fill': _ColorUtils["default"].colorToHex(endFill)
      });
      this.ringPath.animate({
        duration: series.ANIMATION_TIME,
        ease: series.EASE_TYPE,
        attrTween: {
          'd': function () {
            this._lastRadian_ = this._lastRadian_ || 0;
            var interpolate = (0, _interpolator["default"])(this._lastRadian_, endRadian);
            this._lastRadian_ = endRadian;
            return function (t) {
              return arc.endAngle(interpolate(t))();
            };
          }
        }
      });
    } else {
      if (this.ringPath) {
        this.ringPath.remove();
        this.ringPath = null;
      }
    }

    this.innerBackgroundPath.attr('d', innerCircle.outerRadius(innerR)()).style({
      'fill': options.innerPaneBackgroundColor,
      'fill-opacity': _ColorUtils["default"].getColorOpacity(options.innerPaneBackgroundColor)
    });

    this._drawGaugeLabels(this.labelGroup);
  },
  _onSeriesMouseOver: function (ev) {
    _Gauge["default"].prototype._onSeriesMouseOver.call(this, ev);

    var point = this.points[0];

    if (point) {
      this._onState(this.ringPath, true, {
        'fill': point.mouseOverColor
      });
    }
  },
  _onSeriesMouseOut: function (ev) {
    _Gauge["default"].prototype._onSeriesMouseOut.call(this, ev);

    var point = this.points[0];

    if (point) {
      this._onState(this.ringPath, false, {
        'fill': point.color
      });
    }
  },
  onSeriesPress: function () {
    var point = this.points[0];

    if (point) {
      this.ringPath.style({
        'fill': point.clickColor
      });
    }
  },
  onSeriesPressUp: function () {
    this._onSeriesMouseOver();
  },
  getDefaultTooltipFormatter: function () {
    return {
      categoryFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{CATEGORY}{VALUE}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = RingGauge;
exports["default"] = _default;

/***/ }),
/* 151 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _localeText = _interopRequireDefault(__webpack_require__(32));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Series = _interopRequireDefault(__webpack_require__(13));

var _EnvUtils = __webpack_require__(2);

var _renderer = __webpack_require__(22);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/1/11.
 */
var BORDER_RADIUS = 2;
var GAP_PCT = 0.1;
var TOOLTIP_GAP = 1;
var LABEL_GAP = 3;
var INIT_ANIMATION_TIME = 1200; //初始（刷新）

var INIT_EASE = _BezierEasing["default"].css["ease-out-cubic"];
var EXIT_ANIMATION_TIME = 150; //点击图例消失

var EXIT_EASE = _BezierEasing["default"].css["ease-in-back"];
var UPDATE_ANIMATION_TIME = 250; //点击图例其他系列更新位置、大小

var UPDATE_EASE = _BezierEasing["default"].custom["ease-out-quint"];
var RE_SHOW_ANIMATION_TIME = 900; //点击图例重新出现

var RE_SHOW_EASE = _BezierEasing["default"].custom["ease-out-quint"];
var CHOSEN_TIME = 100;
var CHOSEN_EASE = 'ease-out-in';
var LEVEL_DIVIDE = 7; // 0-6 is low, 7-12 is high

var shallowEqual = function (a, b) {
  for (var key in a) {
    if (a[key] !== b[key]) return false;
  }

  for (var key in b) {
    if (!(key in a)) return false;
  }

  return true;
};

function fmtYYYYMMdd(d) {
  return d.format('YYYY-MM-dd');
}

function fmtYYYYMMddHHmm(d) {
  return d.format('YYYY-MM-dd HH:mm');
}

function fmtProgress(v) {
  return v * 100 + '%';
}

function fmtProcesses(ps) {
  return ps.map(function (obj) {
    return obj.name;
  }).join(' ');
}

var fmtFns = {};

function genTimeFormatter(prefix, dateFmtStr) {
  var str = prefix + dateFmtStr;

  if (!fmtFns[str]) {
    fmtFns[str] = function (d) {
      return prefix + d.format(dateFmtStr);
    };
  }

  return fmtFns[str];
}

var Gantt = _Series["default"].extend({
  doLayout: function () {
    var series = this,
        vanchart = series.vanchart;
    var timeAxis = vanchart.getTimeAxis();
    var scale = timeAxis.scale;
    var processes = vanchart.getProcesses();
    var procMap = processes.procMap;
    var cateMap = processes.cateMap;
    var rowHeight = processes.tableDims.rowHeight;
    var newLine = vanchart.options.plotOptions.newLine;

    var oh = this._getSeriesOffsetAndHeight(rowHeight, newLine);

    this.updateMovePos();
    this.getDataToDraw().forEach(function (point) {
      var options = point.options,
          borderWidth = options.borderWidth;
      var pId = options.processesId;
      var x1 = scale(+point.startTime);
      var x2 = scale(+point.finishTime);
      var rect = {};
      rect.x = x1;
      rect.y = cateMap[pId] * rowHeight + oh.offset;
      rect.width = x2 - x1;
      rect.height = oh.height;
      rect = _BaseUtils["default"].rectSubPixelOpt(rect, borderWidth);
      rect.rx = rect.ry = BORDER_RADIUS;
      point.rect = rect;
      point.initRect = {
        x: rect.x,
        y: rect.y,
        width: 0,
        height: rect.height
      };
      point.leftRect = {
        x: rect.x,
        y: rect.y,
        width: rect.width * point.progress,
        height: rect.height
      };
      point.rightRect = {
        x: rect.x + point.leftRect.width,
        y: rect.y,
        width: rect.width * (1 - point.progress),
        height: rect.height
      };
    });
  },
  useCanvas: function () {
    return this.vanchart.useCanvas();
  },
  _createGanttCanvas: function () {
    var vanchart = this.vanchart;
    var canvasBounds = vanchart.canvasBounds;
    var length = Math.ceil(canvasBounds.width / _Constants["default"].GANTT_CANVAS_WIDTH);
    length = Math.min(length, _Constants["default"].GANTT_MAX_CANVAS_NUM);
    vanchart.ganttCanvasArr = [];

    for (var i = 0; i < length; i++) {
      var bounds = {
        x: canvasBounds.x,
        y: canvasBounds.y,
        width: _Constants["default"].GANTT_CANVAS_WIDTH,
        height: canvasBounds.height
      };
      vanchart.ganttCanvasArr[i] = (0, _renderer.createCanvasRenderer)(vanchart.dom, vanchart, bounds);
      vanchart.ganttCanvasArr[i].onAdd();
      vanchart.ganttCanvasArr[i].ctx.canvas.style.display = 'none';
    }
  },
  _canvasRender: function () {
    var series = this;
    var vanchart = this.vanchart;

    if (!vanchart.ganttCanvasArr) {
      this._createGanttCanvas();
    }

    vanchart.ganttCanvasArr.forEach(function (ganttCanvas, index) {
      ganttCanvas.addSeries(series, index);
    });
  },
  getCanvasPointsToDraw: function (startX, endX) {
    return this.points.filter(function (point) {
      var _ref = point.rect || {},
          x = _ref.x,
          width = _ref.width;

      var isVisible = point.visible && !point.isNull;
      var isInCanvasBounds = x + width > startX && x < endX;
      return isVisible && isInCanvasBounds;
    });
  },
  // pos -> move offset
  // bounds -> no offset visible area
  //
  // return true if updated
  //
  updateMovePos: function () {
    var timeAxis = this.vanchart.getTimeAxis();
    var m = timeAxis.getMovePos();
    var updated = false; // 'cause only horizontal virtual

    if (!this._pos || this._pos.x !== m.pos.x) {
      updated = true;
    }

    if (!this._pos || !shallowEqual(this._pos, m.pos)) {
      this._pos = m.pos;
    }

    if (!this._bounds || !shallowEqual(this._bounds, m.bounds)) {
      this._bounds = m.bounds;
      updated = true;
    }

    return updated;
  },
  _getSeriesOffsetAndHeight: function (rowHeight, newLine) {
    var height = 0;
    var offset = rowHeight * GAP_PCT;

    var visibles = this._getVisibles();

    var total = newLine ? visibles.length : 1;
    var index = newLine ? visibles.indexOf(this.index) : 0;
    height = rowHeight * (1 - GAP_PCT * (total + 1)) / total; // what does 25% mean? F**k

    offset += index * (height + rowHeight * GAP_PCT);
    return {
      height: height,
      offset: offset
    };
  },
  _getVisibles: function () {
    return this.vanchart.seriesOfType(this.type).filter(function (s) {
      return s.visible;
    }).map(function (s) {
      return s.index;
    });
  },
  getDataToDraw: function () {
    // console.log(arguments.callee.caller);
    var procMap = this.vanchart.getProcesses().procMap;
    var points = this.points.filter(function (p) {
      return procMap[p.options.processesId] && !p.isNull;
    }); // console.log(this.name, points);

    return points;
  },
  // gantt's points are so different from others
  isNullValue: _BaseUtils["default"].falseFn,
  _getTranslate: function () {
    return [0, 0];
  },
  _labelTrans: function (point) {
    return {
      x: point.labelPos.x + point.labelDim.width / 2,
      y: point.labelPos.y + point.labelDim.height / 2
    };
  },
  _calculateLabelPos: function () {
    this.getDataToDraw().forEach(function (point) {
      var dataLabels = point.options.dataLabels;

      if (dataLabels && dataLabels.enabled) {
        var rect = point.rect,
            labelDim = point.labelDim; // pct bar width

        var width = rect.width * point.progress;
        var pos = {
          y: rect.y + rect.height / 2 - labelDim.height / 2
        };

        if (dataLabels.align === _Constants["default"].RIGHT) {
          pos.x = rect.x + width - labelDim.width - LABEL_GAP;
        } else {
          pos.x = rect.x + width / 2 - labelDim.width / 2;
        }

        point.labelPos = pos;
      }
    });
  },
  getFillFilter: function (color, p) {
    var R = this.vanchart.renderer;
    var attrs = {
      'x1': 0,
      'y1': 0,
      'x2': 1,
      'y2': 0
    };
    var leftRect = this.cullRect(p.leftRect);
    var rightRect = this.cullRect(p.rightRect);
    var pct;

    if (leftRect.width + rightRect.width) {
      pct = leftRect.width / (leftRect.width + rightRect.width);
    } else {
      pct = 1; // invisible, whatever value
    }

    var stops = [{
      'offset': 0,
      'stop-color': color,
      'stop-opacity': p.opacity
    }, {
      'offset': pct,
      'stop-color': color,
      'stop-opacity': p.opacity
    }, {
      'offset': pct,
      'stop-color': color,
      'stop-opacity': 0.5 * p.opacity
    }, {
      'offset': 1,
      'stop-color': color,
      'stop-opacity': 0.5 * p.opacity
    }];

    if (p.colorGradient) {
      R.updateColorGradient(p.colorGradient, attrs, stops);
    } else {
      p.colorGradient = R.colorGradient(attrs, stops);
    }

    return R.toPatternProperty(p.colorGradient);
  },
  getPointGraphicKey: function () {
    return 'rect';
  },
  getPointInitAttr: function (point) {
    return this.cullRect(point.initRect);
  },
  _calculateAnimationDelay: function () {
    return this.updateDelay(EXIT_ANIMATION_TIME);
  },
  getPointInitAnimationAttr: function (point) {
    return {
      ease: INIT_EASE,
      duration: INIT_ANIMATION_TIME,
      attr: this.cullRect(point.rect)
    };
  },
  getPointReShowAnimationAttr: function (point) {
    return {
      ease: RE_SHOW_EASE,
      duration: RE_SHOW_ANIMATION_TIME,
      attr: this.cullRect(point.rect)
    };
  },
  getPointUpdateAnimationAttr: function (point, delay) {
    return {
      delay: delay || 0,
      ease: UPDATE_EASE,
      duration: UPDATE_ANIMATION_TIME,
      attr: this.cullRect(point.rect)
    };
  },
  getPointDropAnimationAttr: function (point) {
    return {
      ease: EXIT_EASE,
      duration: EXIT_ANIMATION_TIME,
      attr: this.cullRect(point.initRect)
    };
  },
  _onPointMouseOver: function (point) {
    var series = point.series,
        style = series.getHighLightStyle(point);

    series._onState(point, style, true);
  },
  _onPointMouseOut: function (point) {
    var series = point.series,
        style = series.getStyle(point);

    series._onState(point, style, false);
  },
  _onState: function (point, style, isChosen) {
    var series = point.series;
    point.graphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      'duration': CHOSEN_TIME,
      'ease': CHOSEN_EASE,
      'style': style
    });

    series._labelFontSizeState(point, isChosen, CHOSEN_TIME, _BezierEasing["default"].css["ease"]);
  },
  getHighLightStyle: function (p) {
    return {
      'stroke': p.mouseOverColor,
      'fill': p.series.getFillFilter(p.mouseOverColor, p),
      'fill-opacity': p.opacity,
      'stroke-width': 6,
      'stroke-opacity': p.opacity === 0 ? 0 : 0.35
    };
  },
  getPressedStyle: function (p) {
    return {
      'stroke': p.clickColor,
      'fill': p.series.getFillFilter(p.clickColor, p),
      'fill-opacity': p.clickOpacity
    };
  },
  _formatFn: function (key) {
    switch (key) {
      case 'processes':
        return fmtProcesses;

      case 'startTime':
      case 'finishTime':
        return this.vanchart.getTimeAxis().initLevel < LEVEL_DIVIDE ? fmtYYYYMMdd : fmtYYYYMMddHHmm;

      case 'progress':
        return fmtProgress;

      default:
        return null;
    }
  },
  _postLabel: function (str, key) {
    switch (key) {
      case 'duration':
      case 'progress':
      case 'startTime':
      case 'finishTime':
        return (0, _localeText["default"])(key) + str;

      default:
        return str;
    }
  },
  _postTooltip: function (str, key) {
    switch (key) {
      case 'duration':
      case 'progress':
      case 'startTime':
      case 'finishTime':
        return (0, _localeText["default"])(key).trim() + ': ' + str;

      default:
        return str;
    }
  },

  /**
   * 甘特图默认数据点提示鼠标跟随，这里增加这个方法，主要是数据点提示轮播接口调用时，
   * 通过该方法来计算数据点提示的位置
   * @param point
   * @returns {*[]}
   * @private
   */
  _getFixedPos: function (point) {
    var rect = this.cullRect(point.rect);
    return [rect.x + rect.width / 2, rect.y + rect.height / 2];
  },
  movePoint: function (point) {
    if (point.graphic) {
      point.graphic.style({
        'fill': this.getFillFilter(point.color, point)
      });
      var rect = this.cullRect(point.rect);
      point.graphic.attr(rect);
    }

    if (point.textGraphic) {
      point.textGraphic.attr('transform', _BaseUtils["default"].makeTranslate(this._labelTrans(point)));
    }
  },
  cullRect: function (rect) {
    var left = rect.x;
    var right = left + rect.width;
    var x, width;

    if (left > right) {
      // prevent quite large values
      x = -1;
      width = 0;
    } else {
      x = left;
      width = right - left;
    }

    return {
      x: x,
      y: rect.y,
      width: width,
      height: rect.height,
      rx: rect.rx || 0,
      ry: rect.ry || 0
    };
  }
});

Gantt.prototype._getLabelFormatFn = Gantt.prototype._formatFn;
Gantt.prototype._getTooltipFormatFn = Gantt.prototype._formatFn; //
// VML patch
//

if (!(0, _EnvUtils.supportFillFilter)()) {
  BORDER_RADIUS = 0;
  Gantt.include({
    getFillFilter: function (color) {
      return color;
    },
    movePoint: function (point) {
      if (point.graphic) {
        this._updateAttr(point);
      }

      if (point.textGraphic) {
        point.textGraphic.attr('transform', _BaseUtils["default"].makeTranslate(this._labelTrans(point)));
      }
    },
    _drawUpdatePoints: function (point) {
      this._updatePointGraphicStyle(point); // 更新颜色


      this._updateAttr(point);

      this.vanchart.registerInteractiveTarget(point, point.graphic); // 更新映射关系
    },
    _drawEnterPoints: function (point) {
      var series = this,
          group = series._getPointGraphicGroup();

      var R = this.vanchart.renderer;
      var graphic = point.graphic = R.group();
      graphic.outerRect = R.rect();
      graphic.leftRect = R.rect();
      graphic.rightRect = R.rect();

      this._updateAttr(point);

      var s = series.getStyle(point);

      this._updatePointGraphicStyle(point, s);

      graphic.append(graphic.outerRect);
      graphic.append(graphic.leftRect);
      graphic.append(graphic.rightRect);
      group.append(graphic);
      series.vanchart.registerInteractiveTarget(point, graphic);
    },
    _updateAttr: function (point) {
      var graphic = point.graphic;
      graphic.outerRect.attr(this.cullRect(point.rect));
      graphic.leftRect.attr(this.cullRect(point.leftRect));
      graphic.rightRect.attr(this.cullRect(point.rightRect));
    },
    _drawExitPoints: function (point) {
      point.graphic.remove();
    },
    _updatePointGraphicStyle: function (point, style) {
      var s = style || point.series._getDynamicStyle(point);

      point.graphic.outerRect.style({
        'stroke-width': (s['stroke-width'] || 0) + 1,
        'stroke': s['stroke']
      });
      s['stroke-width'] = 0;
      point.graphic.leftRect.style(_BaseUtils["default"].clone(s));
      s['fill-opacity'] = s['fill-opacity'] || 1;
      s['fill-opacity'] *= 0.5;
      point.graphic.rightRect.style(s);
    },
    _onPointMouseOver: function (point) {
      var series = point.series,
          style = series.getHighLightStyle(point);

      series._updatePointGraphicStyle(point, style);
    },
    _onPointMouseOut: function (point) {
      var series = point.series,
          style = series.getStyle(point);

      series._updatePointGraphicStyle(point, style);
    }
  });
}

var _default = Gantt;
exports["default"] = _default;

/***/ }),
/* 152 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _defaultValues = _interopRequireDefault(__webpack_require__(39));

var _EventObject = _interopRequireDefault(__webpack_require__(83));

var _levelDomain = _interopRequireDefault(__webpack_require__(84));

var _helper = _interopRequireDefault(__webpack_require__(30));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/3/2.
 */
var LEN = _levelDomain["default"].LEN;
var Rect = _helper["default"].rect;
var HEIGHT = 24;
var MINUS_PATH = _defaultValues["default"].MINUS_PATH,
    PLUS_PATH = _defaultValues["default"].PLUS_PATH,
    THUMB_WIDTH = _defaultValues["default"].THUMB_WIDTH,
    THUMB_FILTER = _defaultValues["default"].THUMB_FILTER,
    SLIDER_STYLE = _defaultValues["default"].SLIDER_STYLE,
    SLIDER_BACKGROUND_WIDTH = _defaultValues["default"].SLIDER_BACKGROUND_WIDTH,
    SLIDER_BACKGROUND_STYLE = _defaultValues["default"].SLIDER_BACKGROUND_STYLE,
    MOUSE_EVENT_PATH = _defaultValues["default"].MOUSE_EVENT_PATH;

var LevelBar = _Base["default"].extend({
  doLayout: function () {
    if (!this.isVisible()) {
      return;
    }

    this._setComponentBounds(_Constants["default"].BOTTOM, HEIGHT);

    var chartBounds = this.vanchart.bounds;
    this.bounds = {
      x: chartBounds.x,
      y: chartBounds.y + chartBounds.height,
      height: HEIGHT,
      width: chartBounds.width
    };
  },
  render: function () {
    if (!this.isVisible()) {
      return;
    } // render once


    if (!this.group) {
      var R = this.vanchart.renderer;
      this.group = R.group().add();
      this.group.attr('transform', _BaseUtils["default"].makeTranslate(this.bounds)).attr('class', 'level-bar');

      this._slider(R);
    }
  },
  isVisible: function () {
    return this.vanchart.getTimeAxis().isZoomEnabled();
  },
  // in case of empty data
  isEnabled: function () {
    return this.enabled && this.vanchart.getTimeAxis().isZoomEnabled();
  },
  setLevel: function (level) {
    if (level == null) {
      return;
    } // invalid if never set the level


    this.enabled = true;

    this._setThumbLevel(level);
  },
  _setThumbLevel: function (level) {
    var x = THUMB_WIDTH / 2 + this._getStep() * level;
    this.thumbG.attr('transform', _BaseUtils["default"].makeTranslate({
      x: x,
      y: 0
    }));
    this.slider.attr({
      width: x
    });
    this.updateThumbBounds(x);
  },

  /**
   * 更新levelBar里面的thumb的bounds
   * @param x
   */
  updateThumbBounds: function (x) {
    var bounds = this.bounds;
    var _w = THUMB_WIDTH,
        _h = THUMB_WIDTH;
    this.thumbBounds = {
      x: bounds.x + this._getLineStartX() + x - _w / 2,
      y: bounds.y + (HEIGHT - _h) / 2,
      width: _w,
      height: _h
    };
  },
  _slider: function (R) {
    var thumbStyle = {
      cursor: 'pointer',
      fill: '#FFF',
      filter: this._getThumbShadowFilter()
    };

    var sliderBackgroundWidth = this._sliderBackgroundWidth();

    var g = this.group.append(R.group());
    g.attr('transform', _BaseUtils["default"].makeTranslate({
      x: this._getLineStartX(),
      y: HEIGHT / 2
    }));
    this.sliderBackground = Rect(R, g, SLIDER_BACKGROUND_STYLE, 0, -SLIDER_BACKGROUND_STYLE.height / 2, sliderBackgroundWidth, SLIDER_BACKGROUND_STYLE.height);
    this.slider = Rect(R, g, SLIDER_STYLE, 0, -SLIDER_STYLE.height / 2, 0, SLIDER_STYLE.height);
    this.minusG = this._getIconGroup(R, MINUS_PATH, -MINUS_PATH.size[0], -MINUS_PATH.size[1] / 2);
    this.plusG = this._getIconGroup(R, PLUS_PATH, sliderBackgroundWidth, -PLUS_PATH.size[1] / 2);
    this.thumbG = this._getThumbGroup(R, thumbStyle);
    ['minus', 'plus', 'thumb'].map(function (name) {
      var graphic = this[name + 'G'];
      g.append(graphic);
      var evObj = new _EventObject["default"](this.iconEvents(name));
      evObj.control = this;
      this.vanchart.registerInteractiveTarget(evObj, graphic);
    }, this);
  },
  _sliderBackgroundWidth: function () {
    var width = this.bounds.width;
    var limitWidth = width - MINUS_PATH.size[0] - PLUS_PATH.size[0];
    return _BaseUtils["default"].getValueInDomain(limitWidth, SLIDER_BACKGROUND_WIDTH);
  },
  _moveWidth: function () {
    return this._sliderBackgroundWidth() - THUMB_WIDTH;
  },
  _getStep: function () {
    return this._moveWidth() / (LEN - 1);
  },
  _getThumbShadowFilter: function () {
    var bar = this,
        vanchart = bar.vanchart,
        renderer = vanchart.renderer;
    var dx = THUMB_FILTER.dx,
        dy = THUMB_FILTER.dy,
        opacity = THUMB_FILTER.opacity,
        deviation = THUMB_FILTER.deviation,
        r = THUMB_FILTER.r,
        g = THUMB_FILTER.g,
        b = THUMB_FILTER.b;
    vanchart.gradientBarThumbShadowFilter = renderer.createDropShadowFilter(dx, dy, opacity, deviation, r, g, b);
    return renderer.toPatternProperty(vanchart.gradientBarThumbShadowFilter);
  },
  // relative to bounds
  _getLineStartX: function () {
    var sliderBackgroundWidth = this._sliderBackgroundWidth();

    return this.bounds.width - sliderBackgroundWidth - PLUS_PATH.size[0];
  },
  eventsMap: {
    minus: ['tap'],
    plus: ['tap'],
    thumb: ['panstart', 'panmove', 'panend']
  },
  iconEvents: function (name) {
    var types = this.eventsMap[name];
    var events = {};
    types.map(function (type) {
      events[type] = this['on' + name + type];
    }, this);
    return events;
  },
  onminustap: function (ev) {
    this.control._changeLevel(-1);
  },
  onplustap: function (ev) {
    this.control._changeLevel(1);
  },
  onthumbpanstart: function (ev) {},
  onthumbpanmove: function (ev) {
    var bar = this.control;
    var bounds = bar.bounds;
    var pos = ev.containerPoint; // adjust to [0, MOVE_WIDTH]

    var v = pos.x - bounds.x - bar._getLineStartX() - THUMB_WIDTH / 2;
    v = Math.min(Math.max(0, v), bar._moveWidth());
    var level = Math.round(v / bar._getStep());

    bar._changeToLevel(level);
  },
  onthumbpanend: function (ev) {},
  _changeToLevel: function (level) {
    if (!this.isEnabled()) {
      return;
    }

    this.vanchart.changeToLevel(level);

    this._setThumbLevel(this.vanchart.getTimeAxis().getLevel());
  },
  _changeLevel: function (c) {
    var level = this.vanchart.getTimeAxis().getLevel() + c;

    this._changeToLevel(level);
  },
  _getIconGroup: function (R, paths, x, y) {
    var g = R.group();
    g.attr('transform', _BaseUtils["default"].makeTranslate({
      x: x,
      y: y
    }));
    g.append(R.path().attr(MOUSE_EVENT_PATH.graphic));
    g.append(R.path().attr(paths.graphic));
    return g;
  },
  _getThumbGroup: function (R, style) {
    var g = R.group();
    g.append(R.path().attr(MOUSE_EVENT_PATH.graphic).style({
      transform: _BaseUtils["default"].makeTranslate({
        x: -MOUSE_EVENT_PATH.size[0] / 2 + 'px',
        y: -MOUSE_EVENT_PATH.size[1] / 2 + 'px'
      })
    }));
    g.append(R.circle().attr('r', THUMB_WIDTH / 2).style(style));
    return g;
  }
});

var _default = LevelBar;
exports["default"] = _default;

/***/ }),
/* 153 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Table = _interopRequireDefault(__webpack_require__(85));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ProcessesView = _interopRequireDefault(__webpack_require__(154));

var _helper = _interopRequireDefault(__webpack_require__(30));

var _defaultValues = _interopRequireDefault(__webpack_require__(39));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/1/12.
 */
var traverse = _helper["default"].traverse;
var sum = _helper["default"].sum;
var distribValues = _helper["default"].distribValues;
var _PADDING = _defaultValues["default"].PADDING;
var PADDING = 0; // get from font-size

var LINE_HEIGHT = 3;
var getTextDimension = _BaseUtils["default"].getTextDimension;
var Max = Math.max;

var Processes = _Table["default"].extend({
  _refresh: function () {
    PADDING = _BaseUtils["default"].paddingConvertWithScale(_PADDING);
  },
  doLayout: function () {},
  // get the outline dim
  getInitPanelDims: function () {
    this.tableDims = this._calcTableDims();
    return {
      width: this._calcPanelWidth(),
      headerHeight: this.tableDims.headerHeight,
      // may change
      rowHeight: this.tableDims.rowHeight,
      rowNum: this.tableDims.rowNum
    };
  },
  setPanelDims: function (panelDims) {
    // set the real dim for render
    this.tableDims.headerHeight = panelDims.headerHeight;
    this.tableDims.rowNum = panelDims.rowNum;
    this.bounds = {
      x: panelDims.x,
      y: panelDims.y,
      width: panelDims.pWidth,
      height: panelDims.height
    };
  },
  _calcPanelWidth: function () {
    var ratio, width;
    var originWidth = sum(this.tableDims.widths);

    if (ratio = this.options.width) {
      var bounds = this.vanchart.bounds;
      width = bounds.width * ratio; // may have to expand table width

      if (width > originWidth) {
        this.expandPanelWidth(width);
      }
    } else {
      width = originWidth;
    } // visible width


    return width;
  },
  expandPanelWidth: function (width) {
    if (width <= sum(this.tightWidths)) {
      return;
    }

    this.tableDims.widths = distribValues(this.tableDims.widths, width);
  },
  _calcTableDims: function () {
    var header = this._getHeader();

    var body = this._getBody();

    var root = this._getCateRoot();

    var headerDim = this._calcHeaderDim(header);

    var rowDim = this._calcRowDim(headerDim.widths, body, root);

    return {
      headerHeight: headerDim.height,
      rowHeight: rowDim.height,
      widths: rowDim.widths,
      rowNum: rowDim.num
    };
  },
  _calcHeaderDim: function (header) {
    if (!header || !header.length) {
      return {
        height: 0,
        widths: []
      };
    }

    var height = 0;
    var widths = header.map(function (h) {
      var dim = getTextDimension(h.text, h.style, false);
      height = Max(height, dim.height * LINE_HEIGHT);
      return dim.width + PADDING * 2;
    });
    return {
      height: height,
      widths: widths
    };
  },
  _calcRowDim: function (widths, body, root) {
    var procMap = this.procMap = {}; // store node & parent

    var cateMap = this.cateMap = {}; // for row

    var height = 0,
        num = 0;
    traverse(root, 'categories', function (node, depth, len, i, parent) {
      if (!depth) {
        return;
      }

      var col = depth - 1;
      var dim = getTextDimension(node.name, body[col].style, false);
      widths[col] = Max(widths[col], dim.width);
      var c = node.categories;

      if (!(c && c.length > 1)) {
        // check node has 1/no child's height (:= 1 line height)
        height = Max(height, dim.height * LINE_HEIGHT);
        cateMap[node.processesId] = num;
      }

      if (!(c && c.length)) {
        // leaf
        ++num;
      }

      procMap[node.processesId] = {
        options: node,
        parent: procMap[parent.processesId]
      };
    });
    widths = widths.map(function (w) {
      return w + PADDING * 2;
    });
    this.tightWidths = widths.slice();
    return {
      num: num,
      height: height,
      widths: widths
    };
  },
  _getCateRoot: function () {
    return this.options;
  },
  // move view to xxxView
  render: function () {
    if (!Object.keys(this.procMap).length) {
      return;
    }

    if (!this.view) {
      this.view = new _ProcessesView["default"](this, this.vanchart);
    }

    this.view.render();
  }
});

var _default = Processes;
exports["default"] = _default;

/***/ }),
/* 154 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _TableView = _interopRequireDefault(__webpack_require__(86));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Scrollbar = _interopRequireDefault(__webpack_require__(60));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _helper = _interopRequireDefault(__webpack_require__(30));

var _defaultValues = _interopRequireDefault(__webpack_require__(39));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/2/3.
 */
var LineV = _helper["default"].lineV;
var LineH = _helper["default"].lineH;
var Rect = _helper["default"].rect;
var traverse = _helper["default"].traverse;
var sum = _helper["default"].sum;
var OUTLINE = _defaultValues["default"].OUTLINE,
    INNERLINE = _defaultValues["default"].INNERLINE,
    TWEENLINE = _defaultValues["default"].TWEENLINE;

var _default = _TableView["default"].extend({
  className: 'processesGroup',
  update: function () {
    var renderer = this.renderer,
        bounds = this.model.bounds;
    renderer.updateClip(this.clip, {
      width: bounds.width,
      height: bounds.height
    });

    this._header();

    this._body();

    this._outline();
  },
  _getInnerWidth: function () {
    return sum(this.model.tableDims.widths);
  },
  _header: function () {
    var R = this.renderer,
        group = this._getGroup();

    var widths = this.model.tableDims.widths,
        height = this.model.tableDims.headerHeight;

    var header = this.model._getHeader();

    var G = this._getGroup('header');

    if (!G) {
      G = this._addGroup('header', group);
      this._headerEles = {};
      this._headerEles.gs = [];
    }

    var lineV = LineV.bind(null, R, G);
    var lineH = LineH.bind(null, R, G);
    var rect = Rect.bind(null, R, G);

    var gs = this._headerEles.gs,
        _p = -1;

    var width = 0;
    widths.map(function (w, i) {
      gs[++_p] = rect({
        fill: this._getOptionsColor(header[i])
      }, width, 0, w, height, gs[_p]);

      if (i) {
        gs[++_p] = lineV(TWEENLINE, 0, height, width, gs[_p]);
      }

      gs[++_p] = this._drawText(G, header[i].style, height / 2, width + w / 2, header[i].text, gs[_p]);
      width += w;
    }, this);
    var lineAdj = TWEENLINE['stroke-width'] / 2;
    gs[++_p] = lineH(TWEENLINE, 0, width, height - lineAdj, gs[_p]);
  },
  _body: function () {
    if (!this._bodyEles) {
      this._prepareBody();
    }

    var R = this.renderer;

    var G = this._getGroup('inner-body-back');

    var gs = this._bodyEles.gs,
        _p = -1;

    var lineV = LineV.bind(null, R, G);
    var lineH = LineH.bind(null, R, G);
    var rect = Rect.bind(null, R, G);

    var body = this.model._getBody();

    var widths = this.model.tableDims.widths,
        accWidths = [],
        width = widths.reduce(function (acc, w, i) {
      accWidths[i] = acc;
      return acc + w;
    }, 0),
        rowNum = this.model.tableDims.rowNum,
        rowHeight = this.model.tableDims.rowHeight;
    var lineIdx = 0,
        colsIdxes = widths.map(function () {
      return 0;
    });

    var _drawText = this._drawText.bind(this);

    traverse(this.model._getCateRoot(), 'categories', null, function (node, depth, len, i) {
      if (!depth) {
        return;
      }

      var col = depth - 1,
          // col no.
      lastColIdx = colsIdxes[col],
          // save up bound
      nextLineIdx = lineIdx + 1; // down bound
      // skip merged cell's last child
      // needn't to draw every single cell outline

      if (i < len - 1) {
        ++lineIdx;
        var style = depth === 1 ? TWEENLINE : INNERLINE;
        gs[++_p] = lineH(style, accWidths[col], width, rowHeight * lineIdx, gs[_p]); // when a line is drawn,
        // the cell's last child drawn as well.

        var n = colsIdxes.length;

        while (--n >= col) {
          colsIdxes[n] = lineIdx;
        }
      }

      var text = node.name;

      if (text == null || text === '') {
        return;
      }

      gs[++_p] = _drawText(G, body[col].style, rowHeight * (lastColIdx + nextLineIdx) / 2, accWidths[col] + widths[col] / 2, text, gs[_p]);
    });
    ++lineIdx; // last line height

    var additionIdx = lineIdx;

    while (additionIdx <= rowNum) {
      var style = additionIdx === lineIdx ? TWEENLINE : INNERLINE;
      gs[++_p] = lineH(style, 0, width, rowHeight * additionIdx, gs[_p]);
      ++additionIdx;
    } // vertical line


    var acc = 0;
    var height = this.innerBodyHeight;
    widths.map(function (w, i) {
      if (body[i]) {
        ++_p;

        if (!gs[_p]) {
          gs[_p] = R.rect().addToBack(G);

          gs[_p].style({
            fill: this._getOptionsColor(body[i])
          });
        }

        rect(null, acc, 0, w, height, gs[_p]);
      }

      if (i) {
        gs[++_p] = lineV(TWEENLINE, 0, height, acc, gs[_p]);
      }

      acc += w;
    }, this);
  },
  _outline: function () {
    var R = this.renderer,
        G = this._getGroup();

    var bounds = this.model.bounds;

    if (!this._outlineEles) {
      var lineAdj = OUTLINE['stroke-width'] / 2;
      var lineV = LineV.bind(null, R, G, OUTLINE);
      var lineH = LineH.bind(null, R, G, OUTLINE);
      lineV(0, bounds.height, lineAdj); // left

      lineH(0, this.vanchart.bounds.width, lineAdj); // top

      lineH(0, this.vanchart.bounds.width, bounds.height - lineAdj); // bottom
    }

    this._outlineEles = LineV(R, G, INNERLINE, 0, bounds.height, bounds.width - INNERLINE['stroke-width'] / 2, this._outlineEles); // right
  },
  _scrollbar: function () {
    this._buildScrollbar({
      scrollX: true,
      scrollY: false
    });
  },
  _drawText: function (G, style, y, x, content, old) {
    if (!old) {
      old = G.append(this.renderer.text().style(style).textContent(content));
    }

    old.attr({
      x: x,
      y: y,
      dy: '.35em',
      'margin-top': '-0.5em'
    }).vMiddle();
    return old;
  },
  onresizeMove: function (ev) {
    var bounds = this.model.bounds;
    var delta = ev.containerPoint.x - this._initPointX;
    bounds.width = this._initWidth + delta || 0;
    this.model.expandPanelWidth(bounds.width);

    _TableView["default"].prototype.onresizeMove.call(this);
  }
});

exports["default"] = _default;

/***/ }),
/* 155 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _ScrollbarItem = _interopRequireDefault(__webpack_require__(61));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _renderer = __webpack_require__(22);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

var BG_SIZE = 12;
var BG_COLOR = 'rgba(233, 233, 233, 0.6)';
var BG_STROKE = 'rgba(207, 207, 207, 0.6)';
var BAR_SIZE = 6;
var BAR_COLOR = 'rgba(160, 160, 160, 0.6)';

var ScrollbarItemCanvas = _ScrollbarItem["default"].extend({
  initialize: function (cfg) {
    var opt = this.opt = _QueryUtils["default"].merge(cfg, {
      backgroundSize: BG_SIZE,
      backgroundColor: BG_COLOR,
      backgroundStroke: BG_STROKE,
      barColor: BAR_COLOR,
      barSize: BAR_SIZE
    });

    opt.length = Math.max(0, opt.length);
    opt.barLength = Math.max(0, opt.barLength);
    var vanchart = opt.manager.vanchart;
    var realCanvasBounds = vanchart.realCanvasBounds;
    var barSize = opt.barSize;
    var backgroundSize = opt.backgroundSize;
    var width, height, barWidth, barHeight, bgPos, barPos;

    if (opt.dir === 'x') {
      width = opt.length;
      height = backgroundSize;
      barWidth = opt.barLength;
      barHeight = barSize;
      bgPos = {
        x: 0,
        y: realCanvasBounds.height - height
      };
      barPos = {
        x: 0,
        y: realCanvasBounds.height - height + (height - barHeight) / 2
      };
    } else {
      width = backgroundSize;
      height = opt.length;
      barWidth = barSize;
      barHeight = opt.barLength;
      bgPos = {
        x: realCanvasBounds.width - width,
        y: 0
      };
      barPos = {
        x: realCanvasBounds.width - width + (width - barWidth) / 2,
        y: 0
      };
    }

    if (!vanchart.ganttScrollBar) {
      vanchart.ganttScrollBar = (0, _renderer.createCanvasRenderer)(vanchart.dom, vanchart, realCanvasBounds);
      vanchart.ganttScrollBar.onAdd();
      vanchart.ganttScrollBar._panState = null;
    }

    this.backgroundBounds = {
      x: bgPos.x,
      y: bgPos.y,
      width: width,
      height: height
    };
    this.barBounds = {
      x: barPos.x,
      y: barPos.y,
      width: barWidth,
      height: barHeight
    };
    vanchart.ganttScrollBar['bar' + opt.dir + 'Bounds'] = {
      x: barPos.x + realCanvasBounds.x,
      y: barPos.y + realCanvasBounds.y,
      width: barWidth,
      height: barHeight
    };
    this.renderScrollBar();
  },
  renderScrollBar: function () {
    var _this$opt = this.opt,
        manager = _this$opt.manager,
        barColor = _this$opt.barColor,
        barSize = _this$opt.barSize;
    var vanchart = manager.vanchart;
    var ctx = vanchart.ganttScrollBar.ctx;
    var backgroundBounds = this.backgroundBounds,
        barBounds = this.barBounds;
    var x = backgroundBounds.x,
        y = backgroundBounds.y,
        width = backgroundBounds.width,
        height = backgroundBounds.height;
    ctx.save();
    ctx.fillStyle = BG_COLOR;
    ctx.strokeStyle = BG_STROKE;
    ctx.fillRect(x, y, width, height);
    ctx.strokeRect(x, y, width, height);
    this.drawBarShape(ctx, _extends({}, barBounds, {
      r: barSize / 2,
      barColor: barColor
    }));
    ctx.restore();
  },
  drawBarShape: function (ctx, style) {
    var x = style.x,
        y = style.y,
        w = style.width,
        h = style.height,
        r = style.r,
        barColor = style.barColor;
    ctx.beginPath();
    ctx.moveTo(x + r, y);
    ctx.arcTo(x + w, y, x + w, y + h, r);
    ctx.arcTo(x + w, y + h, x, y + h, r);
    ctx.arcTo(x, y + h, x, y, r);
    ctx.arcTo(x, y, x + w, y, r);
    ctx.closePath();
    ctx.fillStyle = barColor;
    ctx.fill();
  },
  updateScrollBar: function () {
    var vanchart = this.opt.manager.vanchart;
    var ctx = vanchart.ganttScrollBar.ctx;
    var backgroundBounds = this.backgroundBounds;
    var x = backgroundBounds.x,
        y = backgroundBounds.y,
        width = backgroundBounds.width,
        height = backgroundBounds.height;
    ctx.clearRect(x, y, width, height);
    this.renderScrollBar();
  },
  show: function (d) {
    var vanchart = this.opt.manager.vanchart;

    if (d !== this._showed) {
      this._showed = d;
      vanchart.ganttScrollBar.ctx.canvas.style.display = d ? '' : 'none';
    }
  },
  remove: function () {
    var vanchart = this.opt.manager.vanchart;
    vanchart.ganttScrollBar && vanchart.ganttScrollBar.remove();
    vanchart.ganttScrollBar = null;
  },
  getBarPos: function () {
    return this.barBounds[this.opt.dir];
  },
  setBarPos: function (value) {
    value = _BaseUtils["default"].getValueInDomain(this._getRemainLength(), [0, value]);

    if (this.getBarPos() === value) {
      return;
    }

    var dir = this.opt.dir;
    this.barBounds[dir] = value;
    var vanchart = this.opt.manager.vanchart;
    var realCanvasBounds = vanchart.realCanvasBounds;
    vanchart.ganttScrollBar['bar' + dir + 'Bounds'][dir] = realCanvasBounds[dir] + value;
    this.updateScrollBar();
  },
  setPos: function (x, y) {},
  setSize: function (length, barLength) {
    if (length === this.opt.length && barLength === this.opt.barLength) {
      return;
    }

    if (length < barLength || length < 0 || barLength < 0) {
      length = barLength = 0;
    }

    this.opt.length = length;
    this.opt.barLength = barLength;

    if (length === 0) {
      this.show(false);
    } else {
      var key = this.opt.dir === 'x' ? 'width' : 'height';
      this.backgroundBounds[key] = length;
      this.barBounds[key] = barLength;
      this.updateScrollBar();
    }
  }
});

var _default = ScrollbarItemCanvas;
exports["default"] = _default;

/***/ }),
/* 156 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _defaultValues = _interopRequireDefault(__webpack_require__(39));

var _Table = _interopRequireDefault(__webpack_require__(85));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _TimeAxisView = _interopRequireDefault(__webpack_require__(157));

var _levelDomain = _interopRequireDefault(__webpack_require__(84));

var _dateUnits = _interopRequireDefault(__webpack_require__(87));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _helper = _interopRequireDefault(__webpack_require__(30));

var _levelText = _interopRequireDefault(__webpack_require__(159));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/1/12.
 */
var sum = _helper["default"].sum;
var distribValues = _helper["default"].distribValues;
var getUpText = _levelText["default"].getUpText;
var getSubText = _levelText["default"].getSubText;
var _PADDING = _defaultValues["default"].PADDING,
    PADDING = 0,
    LINE_HEIGHT = 3;
var upUnit = _levelDomain["default"].upUnit,
    subUnit = _levelDomain["default"].subUnit,
    LEVEL_LEN = _levelDomain["default"].LEN,
    Ratio = _levelDomain["default"].Ratio;
var getTextDimension = _BaseUtils["default"].getTextDimension;
var object2date = _BaseUtils["default"].object2date;
var Max = Math.max;
var Min = Math.min;

function moveToNext(ratio, unit, ref, datetime) {
  datetime.add(1, unit);
  var pos = (datetime - ref) * ratio;
  return pos;
}

var TimeAxis = _Table["default"].extend({
  _refresh: function () {
    PADDING = _BaseUtils["default"].paddingConvertWithScale(_PADDING);
    this.lastScale = this.scale;
    this.scale = _Scale["default"].linear();
  },
  doLayout: function () {},
  // get the outline dim
  getInitPanelDims: function () {
    this.tableDims = this._calcTableDims();
    return {
      headerHeight: sum(this.tableDims.heights) // , rowHeight: this.tableDims.rowHeight

    };
  },
  // tablesDims.heights are header heights
  setPanelDims: function (panelDims) {
    // set the real dim for render
    var headerHeight = panelDims.headerHeight;
    this.tableDims.headerHeight = headerHeight; // distribute to two

    this.tableDims.rowHeight = panelDims.rowHeight;
    this.tableDims.rowNum = panelDims.rowNum;
    var heightNow = sum(this.tableDims.heights);

    if (headerHeight > heightNow) {
      this.tableDims.heights = distribValues(this.tableDims.heights, headerHeight);
    }

    this.bounds = {
      x: panelDims.x + panelDims.pWidth,
      y: panelDims.y,
      width: panelDims.tWidth,
      height: panelDims.height
    };
  },
  _calcTableDims: function () {
    var heights = this._getHeaderHeights();

    return {
      heights: heights // , rowHeight: 0 // according to P

    };
  },
  _getHeaderHeights: function () {
    return this._getHeader().map(function (h) {
      return (0, _EnvUtils.getTextHeight)(h.style) * LINE_HEIGHT;
    });
  },
  calcSeries: function (series, procMap, cateMap) {
    // get time range
    var min = Number.MAX_VALUE,
        max = 0;
    var domainMap = {};
    var idMap = {};
    var rowMap = {};
    var markArray = [];
    series.map(function (item) {
      item.points.map(function (p) {
        var options = p.options;
        var st = object2date(options.startTime),
            ft = object2date(options.finishTime),
            mt = object2date(options.markTime);

        if (isNaN(st.getTime()) || isNaN(ft.getTime())) {
          p.isNull = true;
          return;
        }

        var pid = p.options.processesId;

        if (procMap[pid] != null) {
          var rowNum = cateMap[pid];
          rowMap[rowNum] = rowMap[rowNum] || [];
          rowMap[rowNum].push(p);
          p.rowNum = rowNum; // wonder about where to deal default value
          // debug first...

          p.progress = _helper["default"].getValidProgress(options.progress);
          options.tooltip.follow = true; // problem: [A, B, C, D]; pId -> C

          if (!p.processes) {
            var id = pid,
                node = procMap[id];
            p.processes = [node.options];

            while (node = node.parent) {
              p.processes.unshift(node.options);
            }
          }

          if (!(0, _CoreUtils.isEmpty)(p.options.id)) {
            idMap[options.id] = p;
          }

          var thisMap = domainMap[pid] = domainMap[pid] || {
            min: Number.MAX_VALUE,
            max: 0
          };

          if (mt && !isNaN(mt.getTime())) {
            markArray.push(p);
            thisMap.min = Min(thisMap.min, mt);
            thisMap.max = Max(thisMap.max, mt);
          }

          thisMap.min = Min(thisMap.min, st, ft);
          thisMap.max = Max(thisMap.max, st, ft);
          min = Min(thisMap.min, min);
          max = Max(thisMap.max, max);
          p.startTime = (0, _dateUnits["default"])(st);
          p.finishTime = (0, _dateUnits["default"])(ft);
          p.markTime = (0, _dateUnits["default"])(mt);
          p.duration = _dateUnits["default"].duration(ft - st);
        }
      });
    });
    this.domainMap = domainMap; // seems useless →_→

    this.dateDomain = [min, max];
    this.idMap = idMap;
    this.rowMap = rowMap;
    this.markArray = markArray;

    if (min > max) {
      this.dateDomain = [];
    }
  },
  render: function () {
    if (!this.dateDomain.length) {
      return;
    }

    if (!this.view) {
      this.view = new _TimeAxisView["default"](this, this.vanchart);
      this.view.render();

      var m = this._calcFirstViewMovement();

      this.view.moveInner({
        x: m
      });
    } else {
      this.view.render();
    }
  },
  // for series/label/link/marker
  getMovePos: function () {
    var view = this.view;
    var pos;

    if (!view) {
      // May want to know view movement before render.
      // It is exactly `first view movement`.
      // Yes it's dirty...
      // as the whole windowing logic is dirty...
      var x = this._calcFirstViewMovement();

      x = Math.min(Math.max(this.bounds.width - this.innerWidth, x), 0);
      pos = {
        x: x,
        y: 0
      };
    } else {
      pos = {
        x: view.innerPosX,
        y: view.innerPosY
      };
    }

    return {
      pos: pos,
      // bounds x,y are insignificant
      // the wrap has been translated
      // deem x,y to be 0
      bounds: this.bounds
    };
  },
  _calcFirstViewMovement: function () {
    var oFrom = (0, _dateUnits["default"])(this.dateDomain[0]);
    var su = subUnit(this.level);
    var barFrom = +oFrom.startOf(su);
    var from = +oFrom.add(-1, su);
    return this.scale(from) - this.scale(barFrom);
  },
  // level change
  renderContent: function () {
    if (!this.dateDomain.length) {
      return;
    }

    this.view.updateInner();
  },
  calcScale: function () {
    if (!this.dateDomain.length) {
      return;
    }

    var dateDomain = this.dateDomain;

    var em = this._getEm();

    var level = this.getLevel();
    var ratio = Ratio(em, level); // prepare date stuff
    // get units

    var uu = upUnit(level),
        su = subUnit(level); // dateUnits Objects

    var oFrom = (0, _dateUnits["default"])(dateDomain[0]),
        oTo = (0, _dateUnits["default"])(dateDomain[1]); // round the date

    var sFrom = (0, _dateUnits["default"])(oFrom).startOf(su).add(-1, su),
        sTo = (0, _dateUnits["default"])(oTo).endOf(su).add(1, su);
    var uFrom = (0, _dateUnits["default"])(sFrom).startOf(uu); // according to sub

    var timeRangeWidth = (sTo - sFrom) * ratio;
    this.scale.domain([sFrom, sTo]).range([0, timeRangeWidth]); // time range width < bounds.width

    this.innerWidth = Math.max(timeRangeWidth, this.bounds.width);
    this.ratio = ratio;
    this.uu = uu;
    this.su = su; // log init left side time

    this.uInit = uFrom;
    this.sInit = sFrom;
  },
  // left, right是真实范围值，如[1000000, 1001000]
  // 返回是可视范围[0, 1000]
  getHeaderViewModel: function (left, right) {
    var headerVM = {
      upLines: [],
      upTexts: [],
      subLines: [],
      subTexts: [],
      weekendsWidths: []
    };
    var heights = this.tableDims.heights;
    var height = sum(heights);

    var header = this._getHeader();

    var shouldCheckWeekends = this.shouldShowWeekends();
    var level = this.getLevel();
    var ratio = this.ratio;
    var uu = this.uu;
    var su = this.su; // var uInit = this.uInit;

    var sInit = this.sInit;
    var oFrom = this.scale.invert(left);
    var oTo = this.scale.invert(right); // round the date

    var sFrom = (0, _dateUnits["default"])(oFrom).startOf(su),
        sTo = (0, _dateUnits["default"])(oTo).add(1, su).startOf(su);
    var uFrom = (0, _dateUnits["default"])(sFrom).startOf(uu); // according to sub
    // accumulators

    var upDatetime = (0, _dateUnits["default"])(uFrom);
    var subDatetime = (0, _dateUnits["default"])(sFrom);
    var upW = (upDatetime - sInit) * ratio - left; // first cell

    var subW = (subDatetime - sInit) * ratio - left; // first cell

    var moveToNextUp = moveToNext.bind(null, ratio, uu, sInit, upDatetime);
    var moveToNextSub = moveToNext.bind(null, ratio, su, sInit, subDatetime); // var rangeWidth = (sTo - sInit) * ratio;
    // store weekend background (width from, to)

    var ww = headerVM.weekendsWidths = [];

    while (subDatetime <= sTo) {
      checkWeekend();
      var content, pos;

      if (upDatetime <= subDatetime) {
        // should draw up
        headerVM.upLines.push({
          x1: upW,
          y1: 0,
          x2: upW,
          y2: heights[0]
        }); // text means left bound date, save it now

        content = getUpText(upDatetime, level);
        pos = moveToNextUp() - left;
        headerVM.upTexts.push({
          style: header[0].style,
          left: upW,
          // left & right bounds for adjust
          right: pos,
          x: (pos + upW) / 2,
          y: heights[0] / 2,
          content: content
        });
        upW = pos;
      }

      headerVM.subLines.push({
        x1: subW,
        y1: heights[0],
        x2: subW,
        y2: height
      });
      content = getSubText(subDatetime, level);
      pos = moveToNextSub() - left;
      headerVM.subTexts.push({
        style: header[1].style,
        left: subW,
        right: pos,
        x: (pos + subW) / 2,
        y: heights[0] + heights[1] / 2,
        content: content
      });
      subW = pos;
    }

    checkWeekend(true); // to end up right bounds
    // helper

    function checkWeekend(isEnd) {
      if (!shouldCheckWeekends) {
        return;
      }

      var last = ww[ww.length - 1];

      if (subDatetime.isWeekend() && !isEnd) {
        if (!last || last && last.finish) {
          ww.push({
            from: subW,
            finish: false
          });
        }
      } else {
        if (last && !last.finish) {
          last.to = subW;
          last.finish = true;
        }
      }
    } // console.log(left, right, headerVM);


    return headerVM;
  },
  getLevel: function () {
    if (this.level == null) {
      if (this.dateDomain.length) {
        // get from options
        var isLegal = this.setLevel(this.options.zoomLevel); // options' illegal

        if (!isLegal) {
          this.setLevel(this._guessLevel());
        }

        this.initLevel = this.level;
      } else {
        return;
      }
    }

    return this.level;
  },
  setLevel: function (level) {
    if (level == null || level < 0 || level > LEVEL_LEN - 1) {
      return false;
    } else {
      this.level = level;
      return true;
    }
  },
  _guessLevel: function () {
    var dateDomain = this.dateDomain;

    var em = this._getEm();

    var width = this.bounds.width;
    var ratio = width / (dateDomain[1] - dateDomain[0]);
    var l = LEVEL_LEN;

    while (--l > -1) {
      var r = Ratio(em, l);

      if (r < ratio) {
        break;
      }
    }

    return Math.max(0, l);
  },
  // the problem here:
  // did not consider the up header width.
  // thus when the up exceed the sub...
  // adjust em. (do not seem as the true font em)
  // em = width / 6;
  _getEm: function () {
    var header = this._getHeader();

    var tmpDate = (0, _dateUnits["default"])();
    var upWidth = getTextDimension(getUpText(tmpDate, 0), header[0].style).width + 2 * PADDING; // seem sub as one char

    var subWidth = 6 * getTextDimension(getSubText(tmpDate, 0), header[1].style).width;
    var sub = subWidth / 6;

    if (upWidth > subWidth) {
      sub = upWidth / 6;
    }

    return sub;
  },
  isZoomEnabled: function () {
    return this.options.zoom;
  },
  shouldShowWeekends: function () {
    return this.level > 6 && this.options.showWeekends;
  }
});

var _default = TimeAxis;
exports["default"] = _default;

/***/ }),
/* 157 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _TableView = _interopRequireDefault(__webpack_require__(86));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _helper = _interopRequireDefault(__webpack_require__(30));

var _defaultValues = _interopRequireDefault(__webpack_require__(39));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/2/3.
 */
var LineV = _helper["default"].lineV;
var LineH = _helper["default"].lineH;
var Rect = _helper["default"].rect;
var sum = _helper["default"].sum;
var OUTLINE = _defaultValues["default"].OUTLINE,
    INNERLINE = _defaultValues["default"].INNERLINE,
    TWEENLINE = _defaultValues["default"].TWEENLINE,
    getTextDimension = _BaseUtils["default"].getTextDimension,
    bindData = _BaseUtils["default"].bindData;

var _default = _TableView["default"].extend({
  className: 'timeaxisGroup',
  initialize: function () {
    _TableView["default"].prototype.initialize.apply(this, arguments);

    var vanchart = this.vanchart;
    this.on('innerChange', function (v) {
      vanchart.fire('moveSeries', v);
    });
    this.on('resize', function () {
      vanchart.fire('updateSeries');
    });
  },
  update: function () {
    var renderer = this.renderer,
        bounds = this.model.bounds;

    this._getGroup().attr('transform', _BaseUtils["default"].makeTranslate(bounds));

    renderer.updateClip(this.clip, {
      width: bounds.width,
      height: bounds.height
    });
    this.moveInner();

    this._outline();
  },
  updateInner: function () {
    this.moveInner();

    this._fireResize();
  },

  /**
   * move inner pos, update viewModel, view
   * @param [pos] - move & update or just update
   */
  moveInner: function (pos) {
    this._setInnerPos(pos);

    var leftBound = -this.innerPosX;
    var rightBound = -this.innerPosX + this.model.bounds.width;

    var headerVM = this._getHeaderViewModel(leftBound, rightBound);

    this._header(headerVM);

    this._body(headerVM);
  },
  _canMoveX: function () {
    return false;
  },
  _getHeaderViewModel: function (leftBound, rightBound) {
    return this._centerEdgeText(this.model.getHeaderViewModel(leftBound, rightBound));
  },
  _centerEdgeText: function (headerVM) {
    this._checkTextBounds('left', headerVM.upTexts);

    this._checkTextBounds('left', headerVM.subTexts);

    this._checkTextBounds('right', headerVM.upTexts);

    this._checkTextBounds('right', headerVM.subTexts);

    return headerVM;
  },
  _checkTextBounds: function (side, texts) {
    if (!(texts && texts.length)) {
      return;
    }

    var px, left, right, d;
    var leftBound = 0;
    var rightBound = this.model.bounds.width;

    if (side === 'left') {
      d = texts[0];

      if (d.right <= leftBound) {
        d = texts[1];
      }

      if (!d) {
        return;
      }

      px = leftBound;
      left = px;
      right = Math.min(d.right, rightBound);
    } else {
      d = texts[texts.length - 1];

      if (d.left >= rightBound) {
        d = texts[texts.length - 2];
      }

      if (!d) {
        return;
      }

      px = rightBound;
      left = Math.max(d.left, leftBound);
      right = px;
    }

    if (d.left <= px && px <= d.right) {
      // adjust label pos
      if (!d.width) {
        // text width
        d.width = getTextDimension(d.content, d.style).width;
      }

      if (right - left >= d.width) {
        // cell wider than text
        // d.ele && d.ele.attr('x', (left + right) / 2).vMiddle();
        d.x = (left + right) / 2;
      } else {
        // hide this text
        // d.ele && d.ele.attr('x', -100);
        d.x = -100;
      }
    }
  },
  _header: function (vm) {
    var R = this.renderer,
        group = this._getGroup();

    var model = this.model;
    var tWidth = model.bounds.width;
    var heights = model.tableDims.heights;
    var height = sum(heights);

    var header = model._getHeader();

    if (!this._headerEles) {
      this._headerEles = {
        upLines: [],
        upTexts: [],
        subLines: [],
        subTexts: []
      };
      this._headerEles.gs = [];
    }

    var gs = this._headerEles.gs,
        _p = -1;

    var eles = this._headerEles; // var data = this.model._headerData;
    // add the background on the parent group
    // so, unrelated with innerWidth

    gs[++_p] = Rect(R, group, {
      fill: this._getOptionsColor(header[0])
    }, 0, 0, tWidth, heights[0], gs[_p]);
    gs[++_p] = Rect(R, group, {
      fill: this._getOptionsColor(header[1])
    }, 0, heights[0], tWidth, heights[1], gs[_p]);
    var lineAdj = TWEENLINE['stroke-width'] / 2;
    gs[++_p] = LineH(R, group, TWEENLINE, 0, tWidth, heights[0] - lineAdj, gs[_p]);
    gs[++_p] = LineH(R, group, TWEENLINE, 0, tWidth, height - lineAdj, gs[_p]);

    var G = this._getGroup('header') || this._addGroup('header', group);

    if (!vm) {
      return;
    }

    ['upLines', 'subLines'].map(function (type) {
      var selection = bindData(eles[type], vm[type]);
      selection.exit.map(function (d) {
        d.remove();
      });
      var enter = selection.enter.map(function (d) {
        return G.append(R.line().datum(d).style(INNERLINE));
      });
      eles[type] = enter.concat(selection.update).map(function (ele) {
        return ele.attr(ele.datum());
      });
    });
    ['upTexts', 'subTexts'].map(function (type) {
      var selection = bindData(eles[type], vm[type]);
      selection.exit.map(function (d) {
        d.remove();
      });
      var enter = selection.enter.map(function (d) {
        return G.append(R.text().datum(d).style(d.style));
      });
      eles[type] = enter.concat(selection.update).map(function (ele) {
        var d = ele.datum();
        d.ele = ele;
        ele.textContent(d.content).attr({
          x: d.x,
          y: d.y,
          dy: '.35em',
          'margin-top': '-0.5em'
        }).vMiddle();
        return ele;
      });
    });
  },
  _body: function (vm) {
    if (!this._bodyEles) {
      this._prepareBody();

      this._shadow();
    }

    if (!vm) {
      return;
    }

    this._bodyData = {
      hLines: [],
      vLines: vm.subLines,
      rects: vm.weekendsWidths // weekend bg

    };
    var eles = this._bodyEles,
        data = this._bodyData;
    var R = this.renderer;

    var G = this._getGroup('inner-body-back');

    var rowHeight = this.model.tableDims.rowHeight;
    var rowNum = this.model.tableDims.rowNum;
    var height = this.innerBodyHeight;
    var selection = bindData(eles.rects, data.rects);
    selection.exit.map(function (d) {
      d.remove();
    });
    var enter = selection.enter.map(function (d) {
      return G.append(R.rect().datum(d).style({
        fill: _defaultValues["default"].WEEKEND_COLOR
      }));
    });
    eles.rects = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();
      return ele.attr({
        x: d.from,
        y: 0,
        width: d.to - d.from,
        height: height
      });
    });
    var selection = bindData(eles.vLines, data.vLines);
    selection.exit.map(function (d) {
      d.remove();
    });
    var enter = selection.enter.map(function (d) {
      return G.append(R.line().datum(d).style(INNERLINE));
    });
    eles.vLines = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();
      return ele.attr({
        x1: d.x1,
        y1: 0,
        x2: d.x2,
        y2: height
      });
    }); // horizontal lines

    var i = 0;

    while (++i <= rowNum) {
      data.hLines.push({
        x1: 0,
        y1: i * rowHeight,
        // bound width is enough
        x2: this.vanchart.bounds.width,
        y2: i * rowHeight
      });
    }

    var selection = bindData(eles.hLines, data.hLines);
    selection.exit.map(function (d) {
      d.remove();
    });
    var enter = selection.enter.map(function (d) {
      return G.append(R.line().datum(d).style(INNERLINE));
    });
    eles.hLines = enter.concat(selection.update).map(function (ele) {
      return ele.attr(ele.datum());
    });
  },
  _outline: function () {
    var R = this.renderer,
        G = this._getGroup();

    var bounds = this.model.bounds;
    var lineV = LineV.bind(null, R, G, OUTLINE);
    var lineAdj = OUTLINE['stroke-width'] / 2;

    if (!this._outlineEles) {
      var lineH = LineH.bind(null, R, G, OUTLINE);
      lineH(0, this.vanchart.bounds.width, lineAdj); // top

      lineH(0, this.vanchart.bounds.width, bounds.height - lineAdj); // bottom
    } // VML bug


    var right = bounds.width - lineAdj;

    if (!(0, _EnvUtils.isSupportSVG)()) {
      right = Math.floor(right);
    }

    this._outlineEles = lineV(0, bounds.height, right, this._outlineEles); // right
  },
  _scrollbar: function () {
    this._buildScrollbar({
      scrollX: true,
      scrollY: true
    });
  },
  _shadow: function () {
    var attrs = {
      'x1': 0,
      'y1': 0,
      'x2': 1,
      'y2': 0
    };
    var stops = [{
      'offset': '0%',
      'stop-color': 'rgb(0, 0, 0)',
      'stop-opacity': '0.05'
    }, {
      'offset': '100%',
      'stop-color': 'rgb(0, 0, 0)',
      'stop-opacity': '0'
    }];
    var gradient = this.renderer.colorGradient(attrs, stops);
    this._shadowRect = this._getGroup('body').append(this.renderer.rect()).style({
      'transition': 'opacity 0.2s',
      'fill': this.renderer.toPatternProperty(gradient)
    }).attr({
      x: 0,
      y: 0,
      width: 10,
      height: this.model.bounds.height
    });

    this._showShadow(false);
  },
  _showShadow: function (d) {
    if (d !== this._shadowShowed) {
      this._shadowShowed = d;

      this._shadowRect.style('opacity', d ? '1' : '0');
    }
  },
  onresizeMove: function (ev) {
    var bounds = this.model.bounds;
    var delta = this._initPointX - ev.containerPoint.x;
    bounds.x = this._initX - delta;
    bounds.width = this._initWidth + delta || 0;

    _TableView["default"].prototype.onresizeMove.call(this);
  }
});

exports["default"] = _default;

/***/ }),
/* 158 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _dateFormat = _interopRequireDefault(__webpack_require__(88));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/3/2.
 */
var formatDuration = _dateFormat["default"].formatDuration;
var SECOND = 1000,
    MINUTE = 60 * SECOND,
    HOUR = 60 * MINUTE,
    DAY = 24 * HOUR,
    WEEK = 7 * DAY,
    // not accurate
YEAR = 365 * DAY,
    MONTH = 30 * DAY,
    QUARTER = 3 * MONTH;
/**
 * read a millisecond, get x unit duration
 * @param dur
 * @constructor
 */

var Duration = function (dur) {
  this._ms = +dur;
};

var proto = Duration.prototype = {
  valueOf: function () {
    return this._ms;
  },
  as: function (units) {
    return formatDuration(this, units);
  },
  get: function (units) {
    var result = this._ms;

    switch (units) {
      case 'millisecond':
        break;

      case 'second':
        result /= SECOND;
        break;

      case 'hour':
        result /= HOUR;
        break;

      case 'minute':
        result /= MINUTE;
        break;

      case 'day':
        result /= DAY;
        break;

      case 'month':
        result /= MONTH;
        break;

      case 'year':
        result /= YEAR;
        break;

      default:
        throw new Error('Unknown unit ' + units);
    }

    return result;
  }
};

var duration = function (dur) {
  return new Duration(dur);
};

var _default = duration;
exports["default"] = _default;

/***/ }),
/* 159 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _localeText = _interopRequireDefault(__webpack_require__(32));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/2/6.
 */
function getKeys() {
  return _localeText["default"].getTextMap()['ganttLevels'];
}

function getUpText(date, level) {
  return date.format(getKeys()[level][0]);
}

function getSubText(date, level) {
  return date.format(getKeys()[level][1]);
}

var _default = {
  getUpText: getUpText,
  getSubText: getSubText
};
exports["default"] = _default;

/***/ }),
/* 160 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Point = __webpack_require__(46);

var _GradualColor = __webpack_require__(31);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var BAR_LABEL_GAP = 3;

function calculateLabelPos(vanchart) {
  // 针对特定的图表类型首先检测是否含有标签自动的point
  // 再去划分自动和不自动标签的points，最后分别处理两组points
  if (hasAutoAlignLabelPoint(vanchart, _Constants["default"].COLUMN_CHART)) {
    dealChartLabelsWithAutoAlignPoint(vanchart, _Constants["default"].COLUMN_CHART);
    return;
  }

  if (hasAutoAlignLabelPoint(vanchart, _Constants["default"].BAR_CHART)) {
    dealChartLabelsWithAutoAlignPoint(vanchart, _Constants["default"].BAR_CHART);
    return;
  }

  calculateNormalLabelProps(vanchart);
  adjustSeriesColor(vanchart);
}

function dealChartLabelsWithAutoAlignPoint(vanchart, chartType) {
  // 对于柱形图或条形图，将series中全部的points分为标签自动和标签不自动两组
  // 标签自动的points走自动的判断逻辑，非自动的走默认的处理逻辑
  var _dividePointsWithLabe = dividePointsWithLabelAlign(vanchart, chartType),
      autoPoints = _dividePointsWithLabe[0],
      unAutoPoints = _dividePointsWithLabe[1];

  if (chartType === _Constants["default"].COLUMN_CHART) {
    calculateColumnAutoLabelProps(vanchart, autoPoints);
  } else {
    calculateBarAutoLabelProps(vanchart, autoPoints);
  }

  calculateUnAutoLabelProps(unAutoPoints);
}

function dividePointsWithLabelAlign(vanchart, chartType) {
  var autoPoints = [];
  var unAutoPoints = [];

  for (var i = 0, len = vanchart.series.length; i < len; i++) {
    var ser = vanchart.series[i];

    if (ser.visible && ser.type === chartType && ser.points) {
      ser.points.forEach(function (point) {
        if (isValidAutoLabel(point)) {
          autoPoints.push(point);
        } else {
          unAutoPoints.push(point);
        }
      });
    }
  }

  return [autoPoints, unAutoPoints];
}

function hasAutoAlignLabelPoint(vanchart, chartType) {
  // todo 组合图自动时使用默认效果，将来可能会改
  if (vanchart.options.chartType === _Constants["default"].MULTI_CHARTS || !vanchart.series) {
    return false;
  } // 检测是否含有符合chartType的标签自动条件的point


  for (var i = 0, seriesLen = vanchart.series.length; i < seriesLen; i++) {
    var ser = vanchart.series[i];

    if (ser.visible && ser.type === chartType && ser.points) {
      for (var j = 0, pointsLen = ser.points.length; j < pointsLen; j++) {
        if (isValidAutoLabel(ser.points[j])) {
          return true;
        }
      }
    }
  }

  return false;
}

function isValidAutoLabel(point) {
  var dataLabels = point.options.dataLabels; // point无标签属性或point不可见

  if (!dataLabels || !point.isVisible()) {
    return false;
  }

  if (dataLabels.useRichText) {
    return false;
  } // point的label使用html解析或自定义了宽高


  if (dataLabels.useHtml || dataLabels.labelWidth || dataLabels.labelHeight) {
    return false;
  }

  return dataLabels.align === _Constants["default"].AUTO;
}

function calculateNormalLabelProps(vanchart) {
  for (var i = 0, len = vanchart.series.length; i < len; i++) {
    var ser = vanchart.series[i];

    if (ser.visible && ser._calculateLabelPos) {
      ser._calculateLabelPos();
    }
  }
}

function calculateUnAutoLabelProps(points) {
  if (!(points && points.length)) {
    return;
  }

  points.forEach(function (point) {
    if (point.isVisible() && point.options && point.series) {
      var dataLabels = point.options.dataLabels;
      var defaultAlign = getDefaultLabelAlign(point.series.type);

      if (dataLabels && dataLabels.enabled) {
        var align = dataLabels.align === _Constants["default"].AUTO ? defaultAlign : dataLabels.align;
        point.labelPos = point.series._calculateAlignLabelPos(point, align);
        point.labelAlign = align;
      }
    }
  });
  var useSeriesColorPoints = points.filter(function (point) {
    return point.isVisible() && (0, _Point.isUseSeriesColorPoint)(point.labelAlign, point.series.type, point.series.columnType);
  });
  adjustLabelColorToSeriesColor(useSeriesColorPoints);
}

function getDefaultLabelAlign(chartType) {
  // 获取标签默认的align，暂时只需处理柱形图和条形图
  switch (chartType) {
    case _Constants["default"].COLUMN_CHART:
      return _Constants["default"].OUTSIDE;

    case _Constants["default"].BAR_CHART:
      return _Constants["default"].INSIDE;

    default:
      return _Constants["default"].OUTSIDE;
  }
}

function isStackChart(points) {
  if (!(points && points.length)) {
    return false;
  } // points中若含有属于堆积系列的point，走堆积图形的标签自动逻辑


  for (var i = 0, len = points.length; i < len; i++) {
    if (points[i].series && points[i].series.stack) {
      return true;
    }
  }

  return false;
}

function calculateColumnAutoLabelProps(vanchart, points) {
  if (!(points && points.length)) {
    return;
  }

  if (isStackChart(points)) {
    calculateStackAutoLabelProps(vanchart, points, _Constants["default"].COLUMN_CHART);
    return;
  }

  for (var i = 0, len = points.length; i < len; i++) {
    points[i].labelPos = points[i].series._calculateAlignLabelPos(points[i], _Constants["default"].OUTSIDE);
    points[i].labelAlign = _Constants["default"].OUTSIDE;
  }

  adjustLabelColorToSeriesColor(points);
}

function calculateStackAutoLabelProps(vanchart, points, chartType) {
  if (!(points && points.length)) {
    return;
  }

  var exceed = 0;
  var isExceed = chartType === _Constants["default"].COLUMN_CHART ? function (dim, rect) {
    return dim.width > rect.width || dim.height + BAR_LABEL_GAP > rect.height;
  } : function (dim, rect) {
    return dim.width + BAR_LABEL_GAP > rect.width || dim.height > rect.height;
  };

  function distributeLabelPos(points, align) {
    for (var i = 0, len = points.length; i < len; i++) {
      points[i].labelPos = points[i].series._calculateAlignLabelPos(points[i], align);
      points[i].labelAlign = align;
    }
  }

  for (var i = 0, len = points.length; i < len; i++) {
    isExceed(points[i].labelDim, points[i].rect) && exceed++;
  }

  if (exceed / points.length < _Constants["default"].EXCEED_RATE) {
    distributeLabelPos(points, _Constants["default"].INSIDE);
    return;
  } // todo 标签居外时，重叠需隐藏，此版本不做


  distributeLabelPos(points, _Constants["default"].OUTSIDE);
  adjustLabelColorToSeriesColor(points);
}

function calculateBarAutoLabelProps(vanchart, points) {
  if (!(points && points.length)) {
    return;
  }

  var pos,
      display,
      pointPosArray = [];

  if (isStackChart(points)) {
    calculateStackAutoLabelProps(vanchart, points, _Constants["default"].BAR_CHART);
    return;
  }

  function distributeInsideLabelPos(points, pointPosArray) {
    for (var i = 0, len = points.length; i < len; i++) {
      points[i].labelPos = pointPosArray[i];
      points[i].labelAlign = _Constants["default"].INSIDE;
    }
  }

  for (var i = 0, len = points.length; i < len; i++) {
    pos = points[i].series._calculateAlignLabelPos(points[i], _Constants["default"].INSIDE);
    pointPosArray.push(pos);
  }

  display = getBarLabelDistribute(points);

  if (!display.isExceed && !display.isMultiLine) {
    distributeInsideLabelPos(points, pointPosArray);
    return;
  }

  if (!display.isExceed && display.isMultiLine) {
    calculateMultiLineBarLabel(points);
    return;
  }

  calculateOutsideBarLabel(points);
  adjustLabelColorToSeriesColor(points);
}

function getBarLabelDistribute(points) {
  var dim,
      rect,
      width,
      height,
      style,
      isExceed = false,
      isMultiLine = false,
      labelItems = [];

  for (var i = 0, len = points.length; i < len; i++) {
    rect = points[i].rect;
    dim = points[i].labelDim;

    if (dim.height > rect.height) {
      isExceed = true;
      break;
    }

    if (dim.width + BAR_LABEL_GAP > rect.width) {
      if (points[i].labelContent.length === 1) {
        labelItems = points[i].labelContent[0].text.split(_Constants["default"].BLANK_VALUE_PERCENTAGE);
        style = points[i].labelContent[0].style;

        if (labelItems.length > 1) {
          width = 0;
          height = 0;
          labelItems.forEach(function (item) {
            dim = _BaseUtils["default"].getTextDimension(item, style, false);
            width = Math.max(width, dim.width);
            height += dim.height;
          });

          if (width + BAR_LABEL_GAP < rect.width && height < rect.height) {
            isMultiLine = true;
            continue;
          }
        }
      }

      isExceed = true;
      break;
    }
  }

  return {
    isExceed: isExceed,
    isMultiLine: isMultiLine
  };
}

function calculateMultiLineBarLabel(points) {
  if (!(points && points.length)) {
    return;
  }

  var dim,
      rect,
      style,
      width,
      height,
      content,
      labelItems = [],
      isPositive;

  for (var i = 0, len = points.length; i < len; i++) {
    rect = points[i].rect;
    dim = points[i].labelDim;

    if (points[i].labelContent && points[i].labelContent.length === 1) {
      labelItems = points[i].labelContent[0].text.split(_Constants["default"].BLANK_VALUE_PERCENTAGE);
      style = points[i].labelContent[0].style;
      isPositive = points[i].location === _Constants["default"].LEFT_TO_RIGHT;

      if (labelItems.length > 1) {
        width = 0;
        height = 0;
        content = [];
        labelItems.forEach(function (item) {
          dim = _BaseUtils["default"].getTextDimension(item, style, false);
          width = Math.max(width, dim.width);
          height += dim.height;
          content.push({
            dim: _BaseUtils["default"].clone(dim),
            text: item,
            style: style
          });
        });
        points[i].labelDim = {
          width: width,
          height: height
        };
        points[i].labelContent = _BaseUtils["default"].clone(content);
        points[i].labelPos = isPositive ? {
          x: rect.x + rect.width - BAR_LABEL_GAP - width,
          y: rect.y + rect.height / 2 - height / 2
        } : {
          x: rect.x + BAR_LABEL_GAP,
          y: rect.y + rect.height / 2 - height / 2
        };
      } else {
        points[i].labelPos = isPositive ? {
          x: rect.x + rect.width - BAR_LABEL_GAP - dim.width,
          y: rect.y + rect.height / 2 - dim.height / 2
        } : {
          x: rect.x + BAR_LABEL_GAP,
          y: rect.y + rect.height / 2 - dim.height / 2
        };
      }
    }

    points[i].labelAlign = _Constants["default"].INSIDE;
  }
}

function calculateOutsideBarLabel(points) {
  var dim, rect, isPositive;

  for (var i = 0, len = points.length; i < len; i++) {
    rect = points[i].rect;
    dim = points[i].labelDim;
    isPositive = points[i].location === _Constants["default"].LEFT_TO_RIGHT;
    points[i].labelPos = isPositive ? {
      x: rect.x + rect.width + BAR_LABEL_GAP,
      y: rect.y + rect.height / 2 - dim.height / 2
    } : {
      x: rect.x - BAR_LABEL_GAP - dim.width,
      y: rect.y + rect.height / 2 - dim.height / 2
    };
    points[i].labelAlign = _Constants["default"].OUTSIDE;
  }
}

function adjustSeriesColor(vanchart) {
  if (!(vanchart.series && vanchart.series.length)) {
    return;
  }

  var _loop = function (i, len) {
    var ser = vanchart.series[i];

    if (ser.visible && isAutoLabelChart(ser.type)) {
      var points = ser.points.filter(function (point) {
        return point.isVisible() && (0, _Point.isUseSeriesColorPoint)(point.labelAlign, ser.type, ser.columnType);
      });
      adjustLabelColorToSeriesColor(points);
    }
  };

  for (var i = 0, len = vanchart.series.length; i < len; i++) {
    _loop(i, len);
  }
}

function isAutoLabelChart(type) {
  return type === _Constants["default"].COLUMN_CHART || type === _Constants["default"].BAR_CHART || type === _Constants["default"].LINE_CHART || type === _Constants["default"].AREA_CHART;
}

function adjustLabelColorToSeriesColor(points) {
  if (!(points && points.length)) {
    return;
  }

  for (var i = 0, pointsLen = points.length; i < pointsLen; i++) {
    var dataLabels = points[i].options.dataLabels;
    var content = points[i].labelContent;
    var opt = points[i].options;
    var hasCustomStyle = opt.dataLabels && opt.dataLabels.style;

    if (dataLabels && dataLabels.useRichText) {
      adjustRichTextContentColorToSeriesColor(points[i]);
    } else if (content && content.length && !hasCustomStyle) {
      var seriesColor = opt.color || (0, _GradualColor.notSupportGradualColor)(opt, points[i].getSeriesColor());

      for (var j = 0, contentsLen = content.length; j < contentsLen; j++) {
        points[i].labelContent[j].style = _BaseUtils["default"].extend({}, points[i].labelContent[j].style, {
          color: seriesColor
        });
      }
    }
  }
}

function adjustRichTextContentColorToSeriesColor(point) {
  var opt = point.options;
  var content = point.labelContent;
  var dataLabels = point.options.dataLabels;
  var seriesColor = opt.color || (0, _GradualColor.notSupportGradualColor)(opt, point.getSeriesColor());

  if (dataLabels.autoStyle) {
    for (var rowIndex = 0, rowLen = content.length; rowIndex < rowLen; rowIndex++) {
      var row = content[rowIndex];

      if (row && row.length) {
        for (var fieldIndex = 0, fieldLen = row.length; fieldIndex < fieldLen; fieldIndex++) {
          row[fieldIndex].style = _BaseUtils["default"].extend({}, row[fieldIndex].style, {
            color: seriesColor
          });
        }
      }
    }
  }
}

var _default = calculateLabelPos;
exports["default"] = _default;

/***/ }),
/* 161 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _LegendIconFactory = _interopRequireDefault(__webpack_require__(53));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _component = __webpack_require__(4);

var _EnvUtils = __webpack_require__(2);

var _GradualColor = __webpack_require__(31);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/4.
 * 数据表
 */
var TIME = 400;
var EASE = _BezierEasing["default"].css.swing;
var PADDING_GAP = 8;

var PADDING_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING_GAP);
}; // CHART-2860


var TEXT_PADDING_GAP = 4;

var TEXT_PADDING_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(TEXT_PADDING_GAP);
};

var ICON_GAP = 2;

var ICON_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(ICON_GAP);
};

var MAX_ICON_SIZE = 18;
var STYLE = {
  color: "#666666",
  fontSize: "14px",
  fontFamily: "Verdana"
};

var DataSheet = _Base["default"].extend({
  /**
   *数据表的对象要先于坐标轴存在，但是大小需要最后确定
   */
  doLayout: function () {
    this._recordForPlotBounds(_Constants["default"].LEFT, Math.round(this.getSeriesNameLength()));
  },
  reCalculateSize: function () {
    this.doLayout();
  },
  updateAxisSizeAndBounds: function () {
    this.maxCateLineHeight = this.maxSeriesLineHeight = null;

    this._setComponentBounds(_Constants["default"].BOTTOM, this._calculateLineHeight());
    /**
     * CHART-1192
     * 缩放控件的高度的计算逻辑中不应该包含数据表的高度（是高度还是宽度取决于缩放控件的绘制方式——横向or纵向），
     * 所以这里在更新了dataSheet的bounds之后才对缩放控件Zoom的bounds进行计算赋值，
     * 这样获取到的绘图区的高度就不会包含数据表的高度了。
     * 如果没有数据表这个组件怎么办？那Zoom的高度就会在Zoom.js的oLayout函数中进行计算。
     */


    this.vanchart.components[_component.ComponentCst.ZOOM_COMPONENT] && this.vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT).calcZoomControlsSize();
  },
  //只有重新布局的时候才会重新计算每行的高度
  // 计算每一行的高度，和整个数据表占的总高度
  _calculateLineHeight: function () {
    this.calculateShowText(); //开始计算高度

    var cateStyle = this._categoryStyle(),
        valueHeight = 0;

    var seriesLineHeight = Math.ceil((0, _EnvUtils.getTextHeight)(this._seriesStyle())); // 计算字体大小时候取整,防止绘制表格线时出现很细小的间距

    var borderWidth = this.options.borderWidth;
    this.maxCateLineHeight = this._getTextPadding() * (this.maxCateLine + 1) + this.maxCateLine * Math.ceil((0, _EnvUtils.getTextHeight)(cateStyle)) + borderWidth * 2;
    this.maxSeriesLineHeight = []; // 计算每个系列文字的高度，然后个对应的正文行高比较，得出最大值即是当前行的行高

    for (var sIndex = 0, sCount = this.seriesNames.length; sIndex < sCount; sIndex++) {
      var s_count = this.maxSeriesLine[sIndex];
      var s_height = s_count * seriesLineHeight + (s_count + 1) * this._getTextPadding() + borderWidth * 2;
      this.maxSeriesLineHeight[sIndex] = Math.max(s_height, this.maxValueLineHeight[sIndex]);
      valueHeight += this.maxSeriesLineHeight[sIndex];
    }

    this.sheetHeight = Math.ceil(this.maxCateLineHeight + valueHeight) + borderWidth * 2;
    return this.sheetHeight;
  },

  /**
   * 计算需要显示的文字：分类和正文，及其对应的尺寸
   * @return {[type]} [description]
   */
  calculateShowText: function () {
    var textPadding = this._getTextPadding();

    this.maxCateLine = 0;
    this.maxValueLineHeight = [];
    this.showTextMap = this.showTextMap || {};
    var axis = this.vanchart.xAxis(),
        categories = axis._dataDomain,
        showCategories = axis._domain;

    var cateStyle = this._categoryStyle(),
        cateHeight = (0, _EnvUtils.getTextHeight)(cateStyle) + textPadding;

    var unitLength = this.vanchart.bounds.width / showCategories.length;
    var self = this;
    var borderWidth = this.options.borderWidth;
    categories.forEach(function (category) {
      //CHART-3363 将x坐标轴标签格式加到数据表的分类名上。
      var sCateName = _BaseUtils["default"].splitText(self._getTickContent(category, axis.options.formatter), cateStyle, unitLength - 2 * borderWidth, textPadding);

      if (self.maxCateLineHeight) {
        var endIndex = Math.min(parseInt(self.maxCateLineHeight / cateHeight, 10), sCateName.length);
        sCateName = sCateName.slice(0, endIndex);
      }

      if (_BaseUtils["default"].indexOf(showCategories, category) != -1) {
        self.maxCateLine = Math.max(self.maxCateLine, sCateName.length);
      }

      self.showTextMap[category] = self.showTextMap[category] || {};
      self.showTextMap[category].categoryArray = sCateName;
    });
    var series = this.vanchart.series;
    series.forEach(function (sery, index) {
      var points = sery.points,
          dataSheetCfg;

      for (var dIndex = 0, len = points.length; dIndex < len; dIndex++) {
        var point = points[dIndex],
            value = point.options[sery.getTargetKey()],
            category = point.category; //获取当前点的dataSheet信息,并且和DataSheet.options合并一下，保证里面的属性是全的

        dataSheetCfg = point.options.dataSheet || {}; // @CHART-9077

        _BaseUtils["default"].calculateFontSizeWithScale(dataSheetCfg.style);

        dataSheetCfg = _QueryUtils["default"].merge(dataSheetCfg, self.options);
        var pointFormat = dataSheetCfg.formatter;

        var pointStyle = self._valueStyle(dataSheetCfg.style);

        var pointBorderWidth = dataSheetCfg.borderWidth; //单独计算每个点的字体行高

        var valueHeight = Math.ceil((0, _EnvUtils.getTextHeight)(pointStyle)) + textPadding;
        var f_value = point.isNull ? '-' : self._getTickContent(value, pointFormat);

        var sValue = _BaseUtils["default"].splitText(f_value, pointStyle, unitLength - 2 * borderWidth, textPadding);

        if (self.maxSeriesLineHeight && self.maxSeriesLineHeight[index]) {
          var endIndex = Math.min(parseInt(self.maxSeriesLineHeight[index] / valueHeight, 10), sValue.length);
          sValue = sValue.slice(0, endIndex);
        }

        self.showTextMap[category].value = self.showTextMap[category].value || [];
        self.showTextMap[category].value[index] = self.showTextMap[category].value[index] || {};
        self.showTextMap[category].value[index].valueArray = sValue; //将dataSheet存起来，方便draw的时候使用

        self.showTextMap[category].value[index].dataSheet = dataSheetCfg; // 对于组合图一类，即使分类移除，其下方的点，也是应该用于计算系列高度的

        var curLineHeight = sValue.length * valueHeight + textPadding + pointBorderWidth * 2;
        self.maxValueLineHeight[index] = Math.max(self.maxValueLineHeight[index] || 0, curLineHeight);
      }
    }); // 数据补位

    for (var j = -1; ++j < categories.length;) {
      var cate = categories[j],
          showCate = self.showTextMap[cate];

      for (var i = -1; ++i < series.length;) {
        showCate.value = showCate.value || [];

        if (!showCate.value[i]) {
          showCate.value[i] = {
            "dataSheet": this.options,
            "valueArray": ['-']
          };
        }
      }
    }
  },
  fixBoundsByPlot: function () {
    var plotBounds = this.vanchart.bounds;
    var xAxisComponent = this.vanchart.getComponent(_component.ComponentCst.X_AXIS_COMPONENT);
    var posY = plotBounds.y + plotBounds.height + this.options.borderWidth / 2;

    if (xAxisComponent && xAxisComponent._axisList.length) {
      xAxisComponent._axisList.forEach(function (axis) {
        if (axis.getPosition() == _Constants["default"].BOTTOM) {
          posY = Math.max(posY, axis.bounds.y + axis.bounds.height);
        }
      });
    }

    this.bounds = {
      x: plotBounds.x - this.maxSeriesWidth,
      y: posY,
      width: this.maxSeriesWidth + plotBounds.width,
      height: this.sheetHeight
    };
  },
  //最长的系列名
  getSeriesNameLength: function () {
    this.seriesNames = [];
    this.maxSeriesLine = [];
    this.seriesIconType = [];
    var borderWidth = this.options.borderWidth;
    var dataSheet = this,
        vanchart = dataSheet.vanchart,
        series = vanchart.series;

    var style = this._seriesStyle(),
        legendTextSize = parseFloat(style.fontSize);

    var limitedWidth = vanchart.getChartBounds().width / 4 - (MAX_ICON_SIZE + ICON_GAP_FUN() * 2) - borderWidth * 2;
    var maxWidth = 0;
    var iconSize = 0;

    var textPadding = this._getTextPadding();

    series.forEach(function (sery) {
      //icon距离左边竖线PADDING_GAP_FUN && 系列名距离右边细线PADDING_GAP_FUN
      var width = _BaseUtils["default"].getTextDimension(sery.name, style, false).width + PADDING_GAP_FUN() * 2;

      if (width > limitedWidth) {
        var s_names = _BaseUtils["default"].splitText(sery.name, style, limitedWidth, textPadding);

        dataSheet.maxSeriesLine.push(s_names.length);
        dataSheet.seriesNames.push(s_names);
        maxWidth = limitedWidth;
      } else {
        dataSheet.maxSeriesLine.push(1);
        dataSheet.seriesNames.push([sery.name]);
        maxWidth = Math.max(width + borderWidth * 2, maxWidth);
      }

      var iconType = dataSheet._getLegendType(sery);

      dataSheet.seriesIconType.push(iconType);
      iconSize = Math.max(iconSize, _LegendIconFactory["default"].getLegendIconSizeAndScale(iconType, legendTextSize).width);
    });
    this.maxSeriesWidth = Math.ceil(maxWidth + ICON_GAP_FUN() * 2 + iconSize); //数据表外边框PADDING_GAP_FUN

    return this.maxSeriesWidth + PADDING_GAP_FUN();
  },
  _categoryStyle: function () {
    var cateAxis = this.vanchart.xAxis();
    var style = cateAxis ? cateAxis.options.labelStyle : STYLE;
    return _BaseUtils["default"].calculateFontSizeWithScale(style);
  },
  _seriesStyle: function () {
    var legend = this.vanchart.getComponent(_component.ComponentCst.LEGEND_COMPONENT);
    var style = legend ? legend.options.style : STYLE;
    return _BaseUtils["default"].calculateFontSizeWithScale(style);
  },
  _valueStyle: function (style) {
    return _BaseUtils["default"].calculateFontSizeWithScale(style || this.options.style);
  },
  _getTextPadding: function () {
    return TEXT_PADDING_GAP_FUN();
  },
  render: function () {
    this.remove();

    if (!this.vanchart.series.length) {
      return;
    }

    this.calculateShowText();
    var vanchart = this.vanchart,
        bounds = this.bounds,
        renderer = vanchart.renderer;
    var clipBounds = {
      x: this.maxSeriesWidth,
      y: 0,
      width: bounds.width - this.maxSeriesWidth,
      height: bounds.height
    };
    this.animationClip = renderer.createClip(clipBounds);
    this.dataSheetGroup = this.createComponentGroup().attr('transform', _BaseUtils["default"].makeTranslate(this.bounds));
    this.borderGroup = renderer.group().addTo(this.dataSheetGroup);
    this.animationGroup = renderer.group().addTo(this.dataSheetGroup);
    renderer.clip(this.animationGroup, this.animationClip);
    renderer.clip(this.borderGroup, this.animationClip);

    this._drawBaseTable();

    this._drawTableContent();
  },

  /**
   * 绘制表格外边框
   * @return {[type]} [description]
   */
  _drawBaseTable: function () {
    var cfg = this.options,
        seriesWidth = this.maxSeriesWidth,
        categoryHeight = this.maxCateLineHeight;
    var vanchart = this.vanchart,
        renderer = vanchart.renderer,
        group = this.dataSheetGroup;
    var borderWidth = cfg.borderWidth;
    var endX = this.bounds.width,
        endY = this.bounds.height - borderWidth;
    var styles = {
      'fill': 'none',
      'stroke': cfg.borderColor,
      'stroke-width': cfg.borderWidth
    };
    var baseTableBorderPath = 'M' + seriesWidth + ',0' + 'L' + endX + ',0' + 'L' + endX + ' ' + endY + 'L0' + ',' + endY + 'L0' + ',' + categoryHeight + "L" + seriesWidth + "," + categoryHeight + "Z";
    renderer.path().attr('d', baseTableBorderPath).style(styles).addTo(group);

    this._drawSeries();
  },

  /**
   * 绘制表格内容：绘制分类文字+绘制表格主体列表文字
   * @return {[type]} [description]
   */
  _drawTableContent: function () {
    var vanchart = this.vanchart,
        axis = vanchart.xAxis();
    var domain = axis._domain,
        dataDomain = axis._dataDomain,
        rangeLength = this.getPlotBounds().width;
    var unitLength = rangeLength / domain.length;

    if (axis.isAxisReversed()) {
      dataDomain = dataDomain.slice().reverse();
      domain = domain.slice().reverse();
    }

    var startX = -_BaseUtils["default"].indexOf(dataDomain, domain[0]) * unitLength + this.maxSeriesWidth;

    for (var i = 0, len = dataDomain.length; i < len; i++) {
      var text = this.showTextMap[dataDomain[i]]; // 之前考虑轴逆序的时候，位置不对，所以改用scale，结果在缩放拖拽的时候，算出来的位置还是不对
      // 因此这里还是改用unitLength*i的方式，只不过逆序的时候，倒过来计算
      // CHART-4180 轴逆序时 以倒置dataDomain和domain的方式 按同一个正的逻辑计算 使数据表分类名对应

      var x = startX + unitLength * i;

      this._drawCategory(text, x, unitLength);

      this._drawValues(text, x, unitLength);
    }
  },

  /**
   * 缩放控件改变缩放后刷新
   * @return {[type]} [description]
   */
  zoomRefresh: function () {
    this.calculateShowText();

    this._drawTableContent();
  },

  /**
   * 绘制分类：文字+边框
   * @param  {[type]} text       [description]
   * @param  {[type]} x          [description]
   * @param  {[type]} unitLength [description]
   * @return {[type]}            [description]
   */
  _drawCategory: function (text, x, unitLength) {
    var categoryArray = text.categoryArray,
        renderer = this.vanchart.renderer;
    text._category = text._category || [];

    var categoryStyle = this._categoryStyle(),
        categoryLineHeight = (0, _EnvUtils.getTextHeight)(categoryStyle),
        textPadding = this._getTextPadding();

    var option = this.options;

    var startY = this._getStartY(categoryArray, categoryStyle, this.maxCateLineHeight);

    var textX, textY;
    var borderWidth = option.borderWidth,
        borderX = x + borderWidth / 2,
        borderY = borderWidth;

    for (var i = 0; i < categoryArray.length; i++) {
      textX = x + unitLength / 2;
      textY = startY + (categoryLineHeight + textPadding) * i + categoryLineHeight / 2 + borderWidth / 2;
      text._category[i] = text._category[i] || renderer.text().attr({
        'text-anchor': 'middle',
        'dy': '.32em',
        'x': textX,
        'y': textY
      }).style('margin-top', '-0.53em').style(categoryStyle).addTo(this.animationGroup);

      text._category[i].textContent(categoryArray[i]).animate({
        'attr': {
          'x': textX,
          'y': textY
        },
        'duration': TIME,
        'ease': EASE
      });

      text._category[i].textContent(categoryArray[i]).vMiddle();
    }

    var borderAttr = {
      "width": unitLength - borderWidth,
      "height": this.maxCateLineHeight - borderWidth,
      "transform": "translate(" + borderX + "," + borderY + ")"
    };
    text.border = text.border || this._drawTableElementBorder(this.borderGroup);
    text.border.attr(borderAttr);

    for (var i = categoryArray.length; i < text._category.length; i++) {
      text._category[i].remove();
    }

    text._category.length = categoryArray.length;
  },

  /**
   * 绘制表格正文：文字+边框
   * @param  {[type]} text       [description]
   * @param  {[type]} x          [description]
   * @param  {[type]} unitLength [description]
   * @return {[type]}            [description]
   */
  _drawValues: function (text, x, unitLength) {
    var renderer = this.vanchart.renderer,
        valueStyle = this._valueStyle();

    var textPadding = this._getTextPadding();

    var startY = this.maxCateLineHeight;

    if (!text.value) {
      text.value = [];

      for (var i = 0, len = this.vanchart.series.length; i < len; i++) {
        text.value.push({
          valueArray: ['']
        });
      }
    }

    var textX, textY;

    for (var seriesIndex = 0; seriesIndex < text.value.length; seriesIndex++) {
      var value = text.value[seriesIndex],
          valueHeight = this.maxSeriesLineHeight[seriesIndex];
      var valueArray = value.valueArray;
      value._value = value._value || [];
      var pointStyle = value.dataSheet.style;
      var valueLineHeight = (0, _EnvUtils.getTextHeight)(pointStyle);

      var firstY = startY + this._getStartY(valueArray, pointStyle, valueHeight);

      var valueOption = value.dataSheet,
          borderWidth = valueOption.borderWidth,
          defaultBorderWidth = this.options.borderWidth;

      for (var i = 0; i < valueArray.length; i++) {
        textX = x + unitLength / 2;
        textY = firstY + (valueLineHeight + textPadding) * i + valueLineHeight / 2 + defaultBorderWidth / 2;
        value._value[i] = value._value[i] || renderer.text().attr({
          'text-anchor': 'middle',
          'dy': '.32em',
          'x': textX,
          'y': textY
        }).style('margin-top', '-0.53em').style(pointStyle).addTo(this.animationGroup);

        value._value[i].textContent(valueArray[i]).animate({
          'duration': TIME,
          'ease': EASE,
          'attr': {
            'x': textX,
            'y': textY
          }
        });

        value._value[i].textContent(valueArray[i]).vMiddle();
      }

      value.border = value.border || this._drawTableElementBorder(this.borderGroup);
      var borderStyle = {
        "fill": "none",
        "stroke-width": borderWidth,
        "stroke": valueOption.borderColor
      };
      var borderAttr = {
        "width": unitLength - borderWidth,
        "height": valueHeight - borderWidth,
        "transform": "translate(" + (x + borderWidth / 2) + "," + (startY + (borderWidth + defaultBorderWidth) / 2) + ")"
      };
      value.border.style(borderStyle).attr(borderAttr);

      for (var i = valueArray.length; i < value._value.length; i++) {
        value._value[i].remove();
      }

      value._value.length = valueArray.length;
      startY += valueHeight;
    }
  },

  /**
   * 绘制系列：文字+边框
   * @return {[type]} [description]
   */
  _drawSeries: function () {
    var renderer = this.vanchart.renderer,
        seriesG = renderer.group().addTo(this.dataSheetGroup);
    var seriesNames = this.seriesNames,
        seriesWidth = this.maxSeriesWidth,
        categoryHeight = this.maxCateLineHeight;
    var option = this.options,
        borderWidth = option.borderWidth;

    var seriesStyle = this._seriesStyle(),
        legendTextSize = parseFloat(seriesStyle.fontSize);

    var startX = legendTextSize + borderWidth,
        startY = categoryHeight;
    var seriesLineHeight = (0, _EnvUtils.getTextHeight)(seriesStyle);

    var textPadding = this._getTextPadding();

    var series = this.vanchart.series;
    var textMiddleX = (seriesWidth + startX) / 2;

    for (var index = 0, sCount = seriesNames.length; index < sCount; index++) {
      var singleName = seriesNames[index];
      var seriesHeight = this.maxSeriesLineHeight[index];
      var firstY = startY + this._getStartY(singleName, seriesStyle, seriesHeight) + seriesLineHeight * 0.85 + borderWidth / 2;
      var _series = series[index];

      for (var i = 0; i < singleName.length; i++) {
        renderer.text().attr('x', textMiddleX).attr('text-anchor', 'middle').attr('y', firstY + (seriesLineHeight + textPadding) * i).style(seriesStyle).style('margin-top', '-1em') // ie
        .textContent(singleName[i]).addTo(seriesG).vMiddle();
      }

      var seriesBorder = this._drawTableElementBorder(seriesG);

      seriesBorder.attr({
        "width": seriesWidth - borderWidth,
        "height": seriesHeight - borderWidth,
        "transform": "translate(" + borderWidth + "," + (startY + borderWidth) + ")"
      }); //画前面的色块

      var iconType = this.seriesIconType[index];

      var icon = _LegendIconFactory["default"].getLegendIconSizeAndScale(iconType, legendTextSize);

      var iconHeight = icon.height; //icon距离左边竖线PADDING_GAP_FUN

      var iconX = PADDING_GAP_FUN() + this.options.borderWidth * 1.5 + (icon.width - icon.iconWidth) / 2,
          iconY = (seriesHeight - iconHeight) / 2 + startY + borderWidth / 2;

      if (_LegendIconFactory["default"].hasIcon(iconType)) {
        renderer.path().addTo(seriesG).attr('d', _LegendIconFactory["default"].getLegendIconPath(iconType)).attr('transform', _BaseUtils["default"].makeTranslate([iconX, iconY]) + ' scale(' + icon.scale + ')').style({
          'fill': this._getFillFilter(_series.color, _series),
          'fill-opacity': _series.options.opacity
        });
      } else {
        renderer.image({
          'preserveAspectRatio': 'none',
          'x': iconX,
          'y': iconY,
          'width': icon.iconWidth,
          'height': icon.height
        }).imageContent(iconType).addTo(seriesG);
      }

      startY += seriesHeight;
    }
  },
  _getFillFilter: function (color, ser) {
    return (0, _GradualColor.getSeriesFillFilter)(color, ser);
  },
  _getStartY: function (textArray, style, boxHeight) {
    var textPadding = this._getTextPadding();

    var textCount = textArray.length;
    var textHeight = (0, _EnvUtils.getTextHeight)(style) * textCount + (textCount - 1) * textPadding;
    return (boxHeight - textHeight) / 2;
  },

  /**
   * 绘制表格元素对应的边框
   * @param  {[type]} group [所属的group：必填]
   * @param  {[type]} style [所拥有的样式：非必填]
   * @return {[type]}       [description]
   */
  _drawTableElementBorder: function (group, attr, style) {
    var renderer = this.vanchart.renderer;
    var border = renderer.rect().addTo(group);
    border.style(style || this._getTableElementBorderStyle());
    return border;
  },

  /**
   * 获取默认的表格元素的边框样式
   * @return {[type]} [description]
   */
  _getTableElementBorderStyle: function () {
    var option = this.options;
    return {
      "stroke": option.borderColor,
      "stroke-width": option.borderWidth,
      "fill": "none"
    };
  },
  remove: function () {
    this.dataSheetGroup && this.dataSheetGroup.remove();
    this.dataSheetGroup = null;
    this.showTextMap = null;
  }
});

var _default = DataSheet;
exports["default"] = _default;

/***/ }),
/* 162 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _ThemeConfig = __webpack_require__(17);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/5/17.
 */
var FIRST_LEFT_PADDING = 0.417;
var LEFT_PADDING = 0.583;
var RIGHT_PADDING = 0.25;
var ARROW_SIZE = 0.333;
var TOP_PADDING = 0.1665;
var PADDING = 8;

var PADDING_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING);
};

var DrillTools = _Base["default"].extend({
  _refresh: function () {
    this.iconData = [];
  },
  doLayout: function () {
    _BaseUtils["default"].calculateFontSizeWithScale(this.options && this.options.style);

    var dim = _BaseUtils["default"].getTextDimension('test', this.options.style);

    var height = dim.height * (TOP_PADDING * 2 + 1);

    this._setComponentBounds(_Constants["default"].TOP, height + PADDING_FUN());

    this.bounds.height = height;
  },
  getBookMarkPath: function (d) {
    var style = this.options.style,
        index = d.layerIndex;

    var dim = _BaseUtils["default"].getTextDimension(d.geo.geoName(), style);

    var rectWidth = (index === 0 ? FIRST_LEFT_PADDING : LEFT_PADDING) + RIGHT_PADDING;
    rectWidth = dim.height * rectWidth + dim.width;
    var arrowWidth = dim.height * ARROW_SIZE;
    var rectHeight = (1 + TOP_PADDING * 2) * dim.height;
    var ltop = [0, 0],
        rtop = [rectWidth, 0],
        cp = [rectWidth + arrowWidth, rectHeight / 2];
    var rbottom = [rectWidth, rectHeight],
        lbottom = [0, rectHeight];
    return 'M' + ltop + 'L' + rtop + 'L' + cp + 'L' + rbottom + 'L' + lbottom + 'Z';
  },
  isCurrent: function (d) {
    var currentD = this.iconData[this.iconData.length - 1];
    return currentD.series == d.series;
  },
  textColor: function (d) {
    return this.isCurrent(d) ? this.options.currentColor : this.options.style.color;
  },
  mouseOverColor: function (d) {
    var mouseOverColor;

    if (!(mouseOverColor = this.options.mouseOverColor)) {
      var textColor = this.textColor(d);

      var rgba = _ColorUtils["default"].getRGBAColorArray(textColor);

      var hsb = _ColorUtils["default"].rgb2hsb(rgba[0], rgba[1], rgba[2]);

      var rgb = _ColorUtils["default"].hsb2rgb(hsb[0], hsb[1] / 2, (hsb[2] + 1) / 2);

      mouseOverColor = _ColorUtils["default"].toColor(rgb, 'rgb');
    }

    return mouseOverColor;
  },
  leftPadding: function (d) {
    return d.layerIndex === 0 ? FIRST_LEFT_PADDING : LEFT_PADDING;
  },
  calculateExitAnimation: function (exitData) {
    var time = 600;
    var i = 0,
        len = exitData.length;

    for (; i < len; i++) {
      exitData[i].time = time;
      time = Math.max(time - 100, 0);
    }

    var delay = 0;

    for (i = len - 1; i >= 0; i--) {
      if (exitData[i].time) {
        exitData[i].delay = delay;
        delay += 200;
      } else {
        exitData[i].delay = 0;
      }
    }
  },
  getMarkPos: function (d) {
    var x = 0;

    for (var i = 0; i < d.layerIndex; i++) {
      x += this.getBookMarkLength(this.iconData[i], i);
    }

    return x;
  },
  getMarkAnimationStartPos: function (d) {
    var index = d.layerIndex;
    return index === 0 ? 0 : this.getMarkPos(this.iconData[index - 1]) - this.getBookMarkLength(d, index);
  },
  getBookMarkLength: function (data, index) {
    var textHeight = _BaseUtils["default"].getTextDimension(data.geo.geoName(), this.options.style).height;

    var length = _BaseUtils["default"].getTextDimension(data.geo.geoName(), this.options.style).width;

    var padding = (index === 0 ? FIRST_LEFT_PADDING : LEFT_PADDING) + RIGHT_PADDING;
    return length + padding * textHeight;
  },
  render: function () {
    var dTools = this,
        vanchart = dTools.vanchart,
        renderer = vanchart.renderer;
    var clipBounds = {
      'x': 0,
      'y': 0,
      'width': this.bounds.width,
      'height': this.bounds.height + PADDING_FUN()
    };

    if (!this.dToolsGroup) {
      this.dToolsGroup = this.createComponentGroup();
      this.clip = renderer.createClip(clipBounds);
      this.shadow = renderer.createDropShadowFilter(0, 0, 0.15, 1);
      renderer.clip(this.dToolsGroup, this.clip);
      this.drillItems = [];
      vanchart.registerInteractiveTarget(this, this.dToolsGroup);
    }

    this.iconData = this.vanchart.layerMap;
    this.dToolsGroup.attr('transform', _BaseUtils["default"].makeTranslate([this.bounds.x, this.bounds.y + PADDING_FUN()]));
    renderer.updateClip(this.clip, clipBounds);

    for (var i = this.iconData.length - 1; i >= 0; i--) {
      var d = this.iconData[i];

      if (!this.drillItems[i]) {
        d.aniStart = this.getMarkAnimationStartPos(d);
        d.aniEnd = this.getMarkPos(d);
        this.drillItems[i] = this._createItem(d);
      } else {
        var item = this.drillItems[i];
        item.datum(d);
        item.path.attr({
          'd': dTools.getBookMarkPath(d)
        });
        item.text.style(_BaseUtils["default"].extend({}, this.options.style)).attr(dTools._getTextAttr(d)).style({
          'fill': this.textColor(d)
        }).textContent(d.geo.geoName());
      }
    }

    var exitItems = this.drillItems.splice(this.iconData.length, this.drillItems.length);
    this.calculateExitAnimation(exitItems);

    for (var i = 0, len = exitItems.length; i < len; i++) {
      var d = exitItems[i];
      d.animate({
        duration: d.time,
        delay: d.delay,
        ease: 'quad-in',
        attr: {
          transform: _BaseUtils["default"].makeTranslate([d.datum().aniStart, 0]),
          opacity: 0
        }
      }).remove();
    }

    this.drillItems.length = this.iconData.length;
  },
  _createItem: function (d) {
    var dTools = this,
        vanchart = dTools.vanchart,
        renderer = vanchart.renderer;
    var cfg = this.options;
    var item = renderer.group().style({
      'cursor': 'pointer'
    }).datum(d);
    var backgroundColor = (0, _ThemeConfig.getThemeAutoValue)(cfg.backgroundColor, 'dToolItemBackground', vanchart.isDarkTheme());
    item.path = renderer.path({
      'd': dTools.getBookMarkPath(d)
    }).style({
      'fill': backgroundColor,
      "filter": renderer.toPatternProperty(this.shadow)
    }).addTo(item);
    item.text = renderer.text().attr(dTools._getTextAttr(d)).style(cfg.style).style({
      'fill': this.textColor(d)
    }).textContent(d.geo.geoName()).addTo(item);
    item.attr('transform', _BaseUtils["default"].makeTranslate([d.aniStart, 0])).addTo(this.dToolsGroup).animate({
      duration: 500,
      ease: 'cubic-out',
      attr: {
        transform: _BaseUtils["default"].makeTranslate([d.aniEnd, 0])
      }
    });

    _BaseUtils["default"].toBack(item.node());

    return item;
  },
  _findDrillTarget: function (ev) {
    var event = ev.srcEvent,
        src = event.target || event.srcElement;
    var target;

    while (src) {
      for (var i = this.drillItems.length - 1; i >= 0; i--) {
        if (this.drillItems[i].node() == src) {
          target = this.drillItems[i];
        }
      }

      if (target || src == this.dToolsGroup.node()) {
        break;
      }

      src = src.parentNode;
    }

    return target;
  },
  onTap: function (ev) {
    var vanchart = this.vanchart,
        vancharts = vanchart.vancharts;

    var target = this._findDrillTarget(ev);

    var index = this.drillItems.indexOf(target);
    var iconData = this.vanchart.layerMap[index];
    var srcEvent = ev.srcEvent;
    var touch = srcEvent.touches && (srcEvent.touches.length ? srcEvent.touches[0] : srcEvent.changedTouches[0]);

    if (touch) {
      //移动端clientY，clientX不在event上
      srcEvent.clientX = touch.clientX;
      srcEvent.clientY = touch.clientY;
    }

    if (target && iconData) {
      iconData = target.datum();

      if (iconData.geo) {
        var hyperlinkFunc = vancharts.doHyperlink;

        if (hyperlinkFunc) {
          var params = {
            event: ev.srcEvent,
            linkKey: _component.ComponentCst.DRILL_TOOLS,
            vanchart: vanchart,
            name: iconData.geo.geoName()
          };

          _BaseUtils["default"].getFormatterFunction(hyperlinkFunc)(params);
        }
      }

      if (iconData.drillUpDataPoint) {
        var click = _BaseUtils["default"].getFormatterFunction(this.options.click);

        click && click(_BaseUtils["default"].extend({
          allowDrillType: 'up'
        }, iconData.drillUpDataPoint, {
          event: ev.srcEvent,
          linkKey: _component.ComponentCst.DRILL_TOOLS,
          vanchart: vanchart,
          name: iconData.geo.geoName()
        }), ev.srcEvent); // flow: prevent `forceHide` in container manager

        ev.stop && ev.stop();
        vanchart.handler.fire('delayHide', 'dTools');
      }

      if (vanchart.isMobileFlow()) {
        vancharts.holdDrillUpPoint(iconData);
      } else {
        vanchart.drillUp(iconData);
      }
    }
  },
  onMouseOver: function (ev) {
    var target = this._findDrillTarget(ev);

    if (target) {
      target.text.style({
        'fill': this.mouseOverColor(target.datum())
      });
    }
  },
  onMouseOut: function (ev) {
    var target = this._findDrillTarget(ev);

    if (target) {
      target.text.style({
        'fill': this.textColor(target.datum())
      });
    }
  },
  getEvents: function () {
    return {
      "tap": this.onTap,
      'mouseover': this.onMouseOver,
      'mouseout': this.onMouseOut
    };
  },
  remove: function () {
    this.dToolsGroup && this.dToolsGroup.remove();
    this.dToolsGroup = null;
    this.iconData = this.drillItems = [];
  },
  _getTextAttr: function (d) {
    var cfg = this.options,
        textHeight = _BaseUtils["default"].getTextDimension(d.geo.geoName(), cfg.style).height;

    return {
      'x': this.leftPadding(d) * textHeight,
      'y': TOP_PADDING * textHeight,
      'dy': "0.85em"
    };
  }
});

var _default = DrillTools;
exports["default"] = _default;

/***/ }),
/* 163 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Axis = _interopRequireDefault(__webpack_require__(62));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _AxisUtils = __webpack_require__(40);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/15.
 * 仪表盘坐标轴属性的定义
 */
function _getDomainFromData(axis, vanchart) {
  var options = vanchart.options,
      series = vanchart.series;
  var chartType = options.chartType;

  if (chartType !== _Constants["default"].GAUGE_CHART) {
    axis.calculateDomainFromData();
    return axis._domain;
  }

  var dataMap = {};
  series.forEach(function (ser) {
    var serName = ser.name || '';
    dataMap[serName] = [];
    ser.points.forEach(function (point) {
      if (!point.isNull) {
        dataMap[serName].push(point.options.y);
      }
    });
  });
  var minValue = Number.MAX_VALUE,
      maxValue = -minValue,
      emptyData = true;

  for (var key in dataMap) {
    var dataArr = dataMap[key];
    dataArr.forEach(function (data) {
      if (!isNaN(data)) {
        minValue = Math.min(minValue, data);
        maxValue = Math.max(maxValue, data);
        emptyData = false;
      }
    });
  }

  if (emptyData) {
    return (0, _AxisUtils.getEmptyDataDomain)(axis.options.tickInterval);
  }

  var customDomain = [axis.options.min, axis.options.max];

  axis._calculateValueNiceDomain(minValue, maxValue, customDomain[0], customDomain[1]);

  return axis._domain;
}

var GaugeAxis = _Axis["default"].extend({
  initAttributesWithSeries: function () {
    var axisCount = this._axisList.length;

    for (var i = axisCount - 1; i >= 0; i--) {
      var axis = this._axisList[i];

      var domain = _getDomainFromData(axis, this.vanchart);

      axis.scale.domain(domain);

      axis._updateOriginTickData();

      if (!axis.options.showLabel) {
        axis.tickData.forEach(function (t) {
          t.tickContent = '';
        });
      }
    }
  },
  doLayout: function () {},
  render: function () {}
});

var _default = GaugeAxis;
exports["default"] = _default;

/***/ }),
/* 164 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _GeoUtils = _interopRequireDefault(__webpack_require__(165));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _MapMatch = _interopRequireDefault(__webpack_require__(166));

var _Control = _interopRequireDefault(__webpack_require__(168));

var _getJson = _interopRequireDefault(__webpack_require__(169));

var _CRS = _interopRequireDefault(__webpack_require__(65));

var _LatLngBounds = _interopRequireDefault(__webpack_require__(34));

var _CoreUtils = __webpack_require__(3);

var _GeoJSON = _interopRequireDefault(__webpack_require__(172));

var _ImageOverlay = _interopRequireDefault(__webpack_require__(175));

var _TileLayer = _interopRequireDefault(__webpack_require__(176));

var _validMapPoints = __webpack_require__(28);

var _ThemeConfig = __webpack_require__(17);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/5/23.
 * 地理坐标系的定义
 */
var _loadedLayerMap = {}; //避免创建重复的tileLayer

var POINT = 'Point';
var LINE_STRING = 'LineString';
var MULTI_LINE_STRING = 'MultiLineString';

function get(resource) {
  var mapData;

  if (resource && typeof resource === 'object') {
    mapData = resource;
  } else {
    if (window.FR && window.FR.ajax) {
      FR.ajax({
        type: 'POST',
        url: resource,
        dataType: 'json',
        async: false,
        cache: false,
        success: function (result) {
          mapData = result;
        }
      });
    } else {
      (0, _getJson["default"])(resource, function (result) {
        mapData = result;
      });
    }
  }

  return mapData;
}

var Geo = _Base["default"].extend({
  _refresh: function () {
    this._loaded = false;

    var vanchartsID = _BaseUtils["default"].stamp(this.vanchart);

    _loadedLayerMap[vanchartsID] = _loadedLayerMap[vanchartsID] || {};
  },
  doLayout: function () {
    this._loadGeo();

    var map = this.vanchart;
    var level = this.getZoomLevelConfig();
    var center = this.getCenterConfig();
    var isValidLevel = !isNaN(+level);

    if (isValidLevel && center) {
      // has level, has center
      map.setView(center, level);
    } else {
      var _fitBounds = this._getFitBounds();

      if (isValidLevel) {
        // has level, no center
        // get center
        map.fitBounds(_fitBounds, {
          animate: false,
          zoom: level
        }); // than set level

        center = map.getCenter();
        map.setView(center, level);
        center = map.getCenter();
      } else if (center) {
        // no level, has center
        map.fitBounds(_fitBounds, {
          animate: false
        });
      } else {
        // no level, no center
        map.fitBounds(_fitBounds, {
          animate: false
        });
        center = map.getCenter();
      } // force refresh background in case of blank


      if (center) {
        map.panTo(center, {
          animate: false
        });
      }
    }

    this._topLeft = {
      x: 0,
      y: map.bounds.y
    };
  },
  render: function () {
    var options = this.options,
        json = this.jsonData,
        vanchartsID = _BaseUtils["default"].stamp(this.vanchart);

    var url = this.vanchart.getTileLayerUrl(options);
    var attribution = options.attribution || this.vanchart.options.geo.attribution || '';
    var wmsUrl = options.wmsUrl || this.vanchart.options.geo.wmsUrl;
    var wmsLayer = options.wmsLayer || this.vanchart.options.geo.wmsLayer;
    var lastLayer = this._imageBackgroundLayer || this._tileLayer || this._wmsLayer;
    this._imageBackgroundLayer = this._tileLayer = this._wmsLayer = null;

    if (this._isImageMap() && (options.imageUrl || json.imageString)) {
      var imageUrl = options.imageUrl || "data:image/" + json.imageSuffix + ";base64," + json.imageString;
      var imageWidth = json.imageWidth,
          imageHeight = json.imageHeight;
      var bounds = [[0, 0], [imageHeight * this.scale, imageWidth * this.scale]];
      var sameUrl = lastLayer && lastLayer._url === imageUrl;
      var sameSize = this._imageBackgroundSize && imageWidth === this._imageBackgroundSize[0] && imageHeight === this._imageBackgroundSize[1]; // @CHART-2424: 打开多个iframe时，浏览器不会缓存iamge，每次都会reloadImage导致闪烁，这边判断图片地址&宽高未改变时使用lastLayer，不重新创建

      if (sameSize && sameUrl) {
        this._imageBackgroundLayer = lastLayer;
      } else {
        this._imageBackgroundSize = [imageWidth, imageHeight];
        this._imageBackgroundLayer = new _ImageOverlay["default"](imageUrl, bounds).addTo(this.vanchart);
      }
    } else if (url) {
      if (true) {
        this._attribution = _loadedLayerMap[vanchartsID][attribution] || new _Control["default"].Attribution().addAttribution(attribution);
        _loadedLayerMap[vanchartsID][attribution] = this._attribution;

        _loadedLayerMap[vanchartsID][attribution].addTo(this.vanchart);
      }

      this._tileLayer = _loadedLayerMap[vanchartsID][url] || new _TileLayer["default"](url, options.tileLayerOptions || {});
      _loadedLayerMap[vanchartsID][url] = this._tileLayer;

      _loadedLayerMap[vanchartsID][url].addTo(this.vanchart);
    } else if (wmsUrl) {
      this._wmsLayer = _loadedLayerMap[vanchartsID][wmsUrl] || new _TileLayer["default"].WMS(wmsUrl, {
        layers: wmsLayer.join(',')
      });
      _loadedLayerMap[vanchartsID][wmsUrl] = this._wmsLayer;

      _loadedLayerMap[vanchartsID][wmsUrl].addTo(this.vanchart);
    }

    this.renderAreaFeatures();

    if (options.control && !false) {
      options._topLeft = this._topLeft;
      this._zoomControl = this._zoomControl || new _Control["default"].Zoom(options).addTo(this.vanchart); // @CHART-990
    } //updateLayer


    var currentLayer = this._imageBackgroundLayer || this._tileLayer || this._wmsLayer;

    if (lastLayer && lastLayer != currentLayer) {
      this.vanchart.removeLayer(lastLayer);
    }
  },
  needsNullArea: function () {
    var vanchart = this.vanchart;
    return vanchart.isAreaMap() || vanchart.isHeatMap() || vanchart.seriesOfType(_Constants["default"].AREA_MAP).length;
  },
  renderAreaFeatures: function () {
    if (this.needsNullArea()) {
      var options = this.defaultAreaStyle();
      this.geoJsonLayer = this.geoJsonLayer || new _GeoJSON["default"](this.jsonData, options);
      this.geoJsonLayer.addTo(this.vanchart);
    }
  },
  getLayerByFeature: function (feature) {
    return this.geoJsonLayer.getLayerByFeature(feature);
  },
  defaultAreaStyle: function () {
    var plotOptions = this.vanchart.options.plotOptions;
    var queryList = [plotOptions[_Constants["default"].AREA_MAP], plotOptions];

    var nullColorOpt = _BaseUtils["default"].pick(_QueryUtils["default"].queryList(queryList, 'nullColor'), '#cccccc');

    var borderColorOpt = _BaseUtils["default"].pick(_QueryUtils["default"].queryList(queryList, 'borderColor'), '#ffffff');

    var isDarkTheme = this.vanchart.isDarkTheme();
    var nullColor = (0, _ThemeConfig.getThemeAutoValue)(nullColorOpt, 'nullColor', isDarkTheme);
    var borderColor = (0, _ThemeConfig.getThemeAutoValue)(borderColorOpt, 'mapBorderColor', isDarkTheme);
    return {
      'fill': nullColor,
      'fill-opacity': _BaseUtils["default"].pick(_QueryUtils["default"].queryList(queryList, 'opacity'), 0.75),
      'stroke-width': _BaseUtils["default"].pick(_QueryUtils["default"].queryList(queryList, 'borderWidth'), 1),
      'stroke': borderColor,
      'stroke-opacity': _BaseUtils["default"].pick(_QueryUtils["default"].queryList(queryList, 'borderOpacity'), 1)
    };
  },
  geoName: function () {
    return this.options.name;
  },
  getZoomLevelConfig: function () {
    var options = this.options;
    var level;

    if ((0, _CoreUtils.hasDefined)(options.zoomListener)) {
      level = options.zoomListener;
    } else if ((0, _CoreUtils.hasDefined)(options.zoomLevel)) {
      level = options.zoomLevel;
    }

    return level;
  },
  getCenterConfig: function () {
    var options = this.options;
    return options.viewCenter ? [options.viewCenter[1], options.viewCenter[0]] : null;
  },
  _loadGeo: function () {
    if (this._loaded || this._dataUrl == this.options.data) {
      this._loaded = true;

      this._checkCRS();

      return;
    }

    this._loaded = true;
    this._dataUrl = this.options.data;
    this.geoJsonLayer && this.geoJsonLayer.remove();
    this.geoJsonLayer = null; //新的data进来才置空

    var options = this.options,
        geo = this,
        vanchart = this.vanchart;
    geo._validPointName = {}, geo._validAreaName = {}, geo._extendedLineFeature = [];
    geo._areaGeoNames = [];
    geo._pointGeoNames = [];
    geo.jsonData = options.data ? get(options.data) || {} : {};
    geo.jsonData.features = geo.jsonData.features || [];
    var features = geo.jsonData.features;

    for (var i = 0, len = features.length; i < len; i++) {
      var feature = features[i];
      var featureName = feature.properties && feature.properties.name;
      featureName += '';
      var geometry = feature.geometry;

      if (geometry.type == POINT) {
        //点地图
        geo._pointGeoNames.push(featureName);

        geo._validPointName[featureName] = geo._validPointName[featureName] || [];

        geo._validPointName[featureName].push(feature);
      } else if (geometry.type == LINE_STRING || geometry.type == MULTI_LINE_STRING) {
        geo._extendedLineFeature.push(feature);
      } else {
        //区域地图
        geo._areaGeoNames.push(featureName);

        geo._validAreaName[featureName] = geo._validAreaName[featureName] || [];

        geo._validAreaName[featureName].push(feature);
      }
    }

    this.scale = 1;

    if (this._isImageMap()) {
      var chartWidth = vanchart.width,
          chartHeight = vanchart.height;
      var wR = chartWidth / geo.jsonData.imageWidth,
          wH = chartHeight / geo.jsonData.imageHeight;
      this.scale = Math.min(wR, wH);

      _GeoUtils["default"].scaleGeo(geo.jsonData, geo.scale);
    }

    this._checkCRS();
  },
  getDataPointLngLat: function (point, feature) {
    if (!feature || point.options.lnglat) {
      return point.options.lnglat;
    }

    var lnglat = point.series && point.series.type == _Constants["default"].AREA_MAP ? feature.properties.center : feature.geometry.coordinates;

    if (!lnglat) {
      if (this._isImageMap()) {
        var lngMin = this.jsonData.imageWidth * this.scale,
            lngMax = 0;
        var latMin = this.jsonData.imageHeight * this.scale,
            latMax = 0;

        var points = _GeoUtils["default"].getAllPoints(feature);

        points.forEach(function (point) {
          if (isNaN(point[0]) || isNaN(point[1])) {
            return;
          }

          lngMin = Math.min(lngMin, point[0]);
          lngMax = Math.max(lngMax, point[0]);
          latMin = Math.min(latMin, point[1]);
          latMax = Math.max(latMax, point[1]);
        });
        lnglat = [(lngMax + lngMin) / 2, (latMax + latMin) / 2];
      } else {
        var bounds = _GeoUtils["default"].bounds(feature);

        var lng = (bounds[0][0] + bounds[1][0]) / 2;
        var lat = (bounds[0][1] + bounds[1][1]) / 2;
        lnglat = [lng, lat];
      }
    }

    return lnglat;
  },
  getZoomListener: function () {
    return this.options.zoomListener || this.options.zoomLevel;
  },
  getFeaturesByName: function (name, type) {
    this._loadGeo();

    if (!this._validAreaName || !this._validPointName) {
      return; //data为空
    }

    var geoNames = type == _Constants["default"].AREA_MAP ? this._areaGeoNames : this._pointGeoNames;
    var mapping = this.options.mapping || {};
    mapping = mapping[type] || mapping;
    var result = (0, _MapMatch["default"])(name, geoNames, mapping);
    return type == _Constants["default"].AREA_MAP ? this._validAreaName[result] : this._validPointName[result];
  },
  _isImageMap: function () {
    return this.jsonData && this.jsonData.imageWidth;
  },
  _checkCRS: function () {
    var customCRS = this.vanchart.options.customCRS;
    this.vanchart.options.crs = this._isImageMap() ? _CRS["default"].Simple : customCRS ? _CRS["default"][customCRS] : _CRS["default"].EPSG3857;
  },
  //这个fitbounds既需要考虑json文件,还要考虑点地图的时候的在数据里写死了经纬度
  _getFitBounds: function () {
    //先统计数据里写死的经纬度信息,已写死的经纬度信息为准
    var byJson = true,
        geo = this;
    var lngMin = 180,
        lngMax = -180,
        latMin = 90,
        latMax = -90;

    if (this._isImageMap()) {
      lngMin = this.jsonData.imageWidth * this.scale;
      lngMax = 0;
      latMin = this.jsonData.imageHeight * this.scale;
      latMax = 0;
    } else {
      var series = this.vanchart.series;

      for (var i = 0, len = series.length; i < len; i++) {
        if (series[i].visible && series[i].type != _Constants["default"].AREA_MAP) {
          if (series[i].type === _Constants["default"].LINE_MAP) {
            series[i].points.forEach(function (item) {
              getLngLatMinMax(item.options.from);
              getLngLatMinMax(item.options.to);
            });
          } else {
            series[i].points.forEach(getLngLatMinMax);
          }
        }
      }

      if (byJson && this.jsonData && this.jsonData.features.length) {
        var fitBounds = _GeoUtils["default"].bounds(this.jsonData);

        var southWest = fitBounds[0];
        var northEast = fitBounds[1];
        return [[southWest[1], southWest[0]], [northEast[1], northEast[0]]];
      }
    }

    function getLngLatMinMax(point) {
      // lineMap:
      // from.lnglat, from.name;
      // others:
      // p.options.lnglat, p.name
      //
      // lineMap from,to get lnglat in Normalizer.
      //
      var lnglat = point.lnglat || point.options.lnglat;

      if (!lnglat) {
        var features = geo.getFeaturesByName(point.name, point.series.type);
        lnglat = geo.getDataPointLngLat(point, features && features[0]);
      }

      if (lnglat) {
        //只有写死在数据里的经纬度才能按照经纬度来定位
        byJson = false;
        lngMin = Math.min(lngMin, lnglat[0]);
        lngMax = Math.max(lngMax, lnglat[0]);
        latMin = Math.min(latMin, lnglat[1]);
        latMax = Math.max(latMax, lnglat[1]);
      }
    }

    return [[Math.min(latMin, latMax), Math.min(lngMin, lngMax)], [Math.max(latMax, latMin), Math.max(lngMax, lngMin)]];
  },
  remove: function () {
    this.geoJsonLayer && this.geoJsonLayer.remove(); //不能置空

    if (this.geoJsonLayer) {
      var defaultOptions = this.geoJsonLayer.options; // 这边remove的时候，将所有的layer的option重置为默认.否则下次addTo(vanchart)，使用的样式就不对了

      this.geoJsonLayer.eachLayer(function (layer) {
        layer.options = _BaseUtils["default"].extend({}, defaultOptions);
      }, this);
    }

    this._imageBackgroundLayer && this.vanchart.removeLayer(this._imageBackgroundLayer);
    this._attribution && this._attribution.remove();
    this._tileLayer && this._tileLayer.remove();
    this._wmsLayer && this._wmsLayer.remove();
    this._imageBackgroundLayer = this._attribution = this._tileLayer = this._wmsLayer;
  },
  resize: function () {
    if (!this._isImageMap()) {
      return;
    }

    var options = this.options,
        json = this.jsonData,
        lastScale = this.scale;
    var vanchart = this.vanchart,
        chartWidth = vanchart.width,
        chartHeight = vanchart.height;
    var wR = chartWidth / json.imageWidth,
        wH = chartHeight / json.imageHeight;
    this.scale = Math.min(wR, wH);

    _GeoUtils["default"].scaleGeo(json, this.scale / lastScale);

    if (this._imageBackgroundLayer) {
      var bounds = [[0, 0], [json.imageHeight * this.scale, json.imageWidth * this.scale]];

      this._imageBackgroundLayer.setBounds(_LatLngBounds["default"].create(bounds));
    }

    if (this.geoJsonLayer) {
      this.geoJsonLayer.remove();
      this.geoJsonLayer = null;
      var validMapPoints = (0, _validMapPoints.areaPointMapValidPoints)(vanchart);
      validMapPoints.forEach(function (point) {
        if (point.series.type == _Constants["default"].AREA_MAP) {
          point.layers = null;
        }
      });
    }
  }
});

var _default = Geo;
exports["default"] = _default;

/***/ }),
/* 165 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Bounds = _interopRequireDefault(__webpack_require__(21));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/9.
 */

/**
 * 判断经纬度点是否在经纬度界限bbox内
 * @param lngLat    经纬度 [经度, 纬度]
 * @param bbox      经纬度边界[ 西, 南, 东, 北 ]
 * @returns {boolean}
 */
var lngLatInBBox = function (lngLat, bbox) {
  if (!bbox) {
    return true;
  } // @CHART-10479


  if (typeof bbox === 'string') {
    bbox = bbox.split(',');
  }

  var lng = lngLat[0],
      lat = lngLat[1];
  var west = bbox[0],
      south = bbox[1],
      east = bbox[2],
      north = bbox[3];
  return west <= lng && lng <= east && south <= lat && lat <= north;
};

var d3_geo_streamObjectType = {
  Feature: function (feature, pointsArray, ignoreOutOfBBox) {
    var bbox = ignoreOutOfBBox && feature.properties && feature.properties.bbox;
    d3_geo_streamGeometry(feature.geometry, pointsArray, bbox);
  },
  FeatureCollection: function (object, pointsArray, ignoreOutOfBBox) {
    var features = object.features,
        i = -1,
        n = features.length;

    while (++i < n) {
      var bbox = ignoreOutOfBBox && features[i].properties && features[i].properties.bbox;
      d3_geo_streamGeometry(features[i].geometry, pointsArray, bbox);
    }
  }
};

function d3_geo_streamGeometry(geometry, pointsArray, bbox) {
  if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
    d3_geo_streamGeometryType[geometry.type](geometry, pointsArray, bbox);
  }
}

var d3_geo_streamGeometryType = {
  Point: function (object, pointsArray) {
    pointsArray.push(object.coordinates);
  },
  MultiPoint: function (object, pointsArray, bbox) {
    var coordinates = object.coordinates,
        i = -1,
        n = coordinates.length;

    while (++i < n) {
      object = coordinates[i];
      lngLatInBBox(object, bbox) && pointsArray.push(object);
    }
  },
  LineString: function (object, pointsArray, bbox) {
    d3_geo_streamLine(object.coordinates, pointsArray, bbox);
  },
  MultiLineString: function (object, pointsArray, bbox) {
    var coordinates = object.coordinates,
        i = -1,
        n = coordinates.length;

    while (++i < n) {
      d3_geo_streamLine(coordinates[i], pointsArray, bbox);
    }
  },
  Polygon: function (object, pointsArray, bbox) {
    d3_geo_streamPolygon(object.coordinates, pointsArray, bbox);
  },
  MultiPolygon: function (object, pointsArray, bbox) {
    var coordinates = object.coordinates,
        i = -1,
        n = coordinates.length;

    while (++i < n) {
      d3_geo_streamPolygon(coordinates[i], pointsArray, bbox);
    }
  },
  GeometryCollection: function (object, pointsArray, bbox) {
    var geometries = object.geometries,
        i = -1,
        n = geometries.length;

    while (++i < n) {
      d3_geo_streamGeometry(geometries[i], pointsArray, bbox);
    }
  }
};

function d3_geo_streamLine(coordinates, pointsArray, bbox) {
  var i = -1,
      n = coordinates.length,
      coordinate;

  while (++i < n) {
    coordinate = coordinates[i];
    lngLatInBBox(coordinate, bbox) && pointsArray.push(coordinate);
  }
}

function d3_geo_streamPolygon(coordinates, pointsArray, bbox) {
  var i = -1,
      n = coordinates.length;

  while (++i < n) {
    d3_geo_streamLine(coordinates[i], pointsArray, bbox);
  }
}

function getAllPoints(object, ignoreOutOfBBox) {
  var allPoints = [];

  if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
    d3_geo_streamObjectType[object.type](object, allPoints, ignoreOutOfBBox);
  } else {
    d3_geo_streamGeometry(object, allPoints);
  }

  return allPoints;
}

function scaleGeo(geoJson, scale) {
  var features = geoJson.features,
      i,
      len;

  for (i = 0, len = features.length; i < len; i++) {
    var center = features[i].properties.center;

    if (center) {
      center[0] *= scale;
      center[1] *= scale;
    }
  }

  var points = getAllPoints(geoJson);

  for (i = 0, len = points.length; i < len; i++) {
    points[i][0] *= scale;
    points[i][1] *= scale;
  }
}
/**
 * 计算GeoJSON的边界
 * @param geoJson           GeoJSON数据
 * @param ignoreOutOfBBox   是否考虑JSON中的BBox, default True
 * @returns {*[][]}
 */


function bounds(geoJson, ignoreOutOfBBox) {
  if (ignoreOutOfBBox == void 0) {
    ignoreOutOfBBox = true;
  }

  var bounds = new _Bounds["default"](getAllPoints(geoJson, ignoreOutOfBBox));
  return [[bounds.min.x, bounds.min.y], [bounds.max.x, bounds.max.y]];
}

var _default = {
  'getAllPoints': getAllPoints,
  'scaleGeo': scaleGeo,
  'bounds': bounds
};
exports["default"] = _default;

/***/ }),
/* 166 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _MapConstants = _interopRequireDefault(__webpack_require__(167));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var endsWith = _BaseUtils["default"].endsWith;

var calculateSimpleName = function (geoArea) {
  if (_MapConstants["default"].ABBREVIATION_NAME_MAP[geoArea]) {
    return _MapConstants["default"].ABBREVIATION_NAME_MAP[geoArea];
  }

  var subAreaName;

  if (endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.specialAdminRegion)) {
    subAreaName = geoArea.substring(0, geoArea.length - _MapConstants["default"].REGION_SUFFIX.specialAdminRegion.length);
  } else if (endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.region)) {
    subAreaName = geoArea.substring(0, geoArea.length - _MapConstants["default"].REGION_SUFFIX.region.length);
  } else if (endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.province) || endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.city) || endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.league) || endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.adminArea) || endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.county) || endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.flag)) {
    subAreaName = geoArea.substring(0, geoArea.length - _MapConstants["default"].REGION_SUFFIX.province.length);
  } else {
    subAreaName = geoArea;
  }

  _MapConstants["default"].ABBREVIATION_NAME_MAP[geoArea] = subAreaName;
  return subAreaName;
};

var matchOtherName = function (areaName, geoArea) {
  var simpleName = _MapConstants["default"].ABBREVIATION_NAME_MAP[geoArea];

  if (!simpleName) {
    return false;
  } // 地区换成市，自治县换成县，自治洲换成洲


  if (endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.region)) {
    return endsWith(areaName, simpleName + _MapConstants["default"].REGION_SUFFIX.city);
  } else if (endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.autonomousCounty)) {
    return endsWith(areaName, simpleName + _MapConstants["default"].REGION_SUFFIX.county);
  } else if (endsWith(geoArea, _MapConstants["default"].REGION_SUFFIX.autonomousPrefecture)) {
    return endsWith(areaName, simpleName + _MapConstants["default"].REGION_SUFFIX.prefecture);
  }
};

var matchArea = function (seriesData, geoAreas, customResult) {
  //先匹配自定义，在匹配同名、然后匹配简称，最后按规则匹配
  if (customResult && customResult[seriesData] && geoAreas.indexOf(customResult[seriesData]) >= 0) {
    return customResult[seriesData];
  }

  if (geoAreas.indexOf(seriesData) >= 0) {
    return seriesData;
  } // 省、直辖市、自治区、特区简称直接转换为对应全称


  if (_MapConstants["default"].PROVINCE_SHORT_NAME_MAP[seriesData]) {
    seriesData = _MapConstants["default"].PROVINCE_SHORT_NAME_MAP[seriesData];
  }

  for (var j = 0, geoLen = geoAreas.length; j < geoLen; j++) {
    if (!geoAreas[j]) {
      continue;
    }

    var geoArea = geoAreas[j]; // 1.包含匹配，区域名需要最后几位匹配到行政区域名，例如江苏省南京市，只能匹配南京市，但是不能匹配江苏省
    // 2.用简称包含匹配，计算简称后用最后几位匹配。
    // 3.部分地区也叫市，比如毕节地区，有时也叫毕业市，部分自治州和自治县，有时候也叫洲和县，比如恩施土家族苗族自治州也叫恩施州，互助土族自治县也叫互助县。

    if (endsWith(seriesData, geoArea) || endsWith(seriesData, calculateSimpleName(geoArea)) || matchOtherName(seriesData, geoArea)) {
      return geoArea;
    }
  }
};

var matchAreaList = function (seriesDataList, geoAreas, customResult) {
  var resultMap = {};

  for (var i = 0, seriesLen = seriesDataList.length; i < seriesLen; i++) {
    var result = matchArea(seriesDataList[i], geoAreas, customResult);

    if (result) {
      resultMap[seriesDataList[i]] = result;
    }
  }

  return resultMap;
};

var _default = matchArea;
exports["default"] = _default;

/***/ }),
/* 167 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _default = {
  //各个省、自治区、直辖市的行政简称
  PROVINCE_SHORT_NAME_MAP: {
    京: "北京市",
    津: "天津市",
    冀: "河北省",
    晋: "山西省",
    内: "内蒙古自治区",
    辽: "辽宁省",
    吉: "吉林省",
    黑: "黑龙江省",
    沪: "上海市",
    苏: "江苏省",
    浙: "浙江省",
    皖: "安徽省",
    闽: "福建省",
    赣: "江西省",
    鲁: "山东省",
    豫: "河南省",
    鄂: "湖北省",
    湘: "湖南省",
    粤: "广东省",
    桂: "广西壮族自治区",
    琼: "海南省",
    蜀: "四川省",
    川: "四川省",
    贵: "贵州省",
    黔: "贵州省",
    云: "云南省",
    滇: "云南省",
    渝: "重庆市",
    藏: "西藏自治区",
    秦: "陕西省",
    陕: "陕西省",
    甘: "甘肃省",
    陇: "甘肃省",
    青: "青海省",
    宁: "宁夏回族自治区",
    新: "新疆维吾尔自治区",
    港: "香港特别行政区",
    澳: "澳门特别行政区",
    台: "台湾省"
  },
  //行政区域的简称（如江苏省→江苏，无锡市→无锡，新疆维吾尔自治区→新疆，昌吉回族自治州→昌吉，青龙满族自治县→青龙）
  ABBREVIATION_NAME_MAP: {
    新疆维吾尔自治区: "新疆",
    内蒙古自治区: "内蒙古",
    西藏自治区: "西藏",
    宁夏回族自治区: "宁夏",
    广西壮族自治区: "广西",
    克孜勒苏柯尔克孜自治州: "克孜勒苏柯尔克孜",
    博尔塔拉蒙古自治州: "博尔塔拉",
    巴音郭楞蒙古自治州: "巴音郭楞",
    昌吉回族自治州: "昌吉",
    伊犁哈萨克自治州: "伊犁",
    海南藏族自治州: "海南",
    果洛藏族自治州: "果洛",
    海西蒙古族藏族自治州: "海西",
    黄南藏族自治州: "黄南",
    玉树藏族自治州: "玉树",
    海北藏族自治州: "海北",
    临夏回族自治州: "临夏",
    甘南藏族自治州: "甘南",
    楚雄彝族自治州: "楚雄",
    怒江傈僳族自治州: "怒江",
    迪庆藏族自治州: "迪庆",
    德宏傣族景颇族自治州: "德宏",
    文山壮族苗族自治州: "文山",
    红河哈尼族彝族自治州: "红河",
    西双版纳傣族自治州: "西双版纳",
    大理白族自治州: "大理",
    黔西南布依族苗族自治州: "黔西南",
    黔东南苗族侗族自治州: "黔东南",
    黔南布依族苗族自治州: "黔南",
    阿坝藏族羌族自治州: "阿坝",
    甘孜藏族自治州: "甘孜",
    凉山彝族自治州: "凉山",
    湘西土家族苗族自治州: "湘西",
    恩施土家族苗族自治州: "恩施",
    延边朝鲜族自治州: "延边",
    青龙满族自治县: "青龙",
    大厂回族自治县: "大厂",
    孟村回族自治县: "孟村",
    宽城满族自治县: "宽城",
    围场满族蒙古族自治县: "围场",
    丰宁满族自治县: "丰宁",
    桓仁满族自治县: "桓仁",
    本溪满族自治县: "本溪",
    新宾满族自治县: "新宾",
    清原满族自治县: "清原",
    岫岩满族自治县: "岫岩",
    宽甸满族自治县: "宽甸",
    阜新蒙古族自治县: "阜新",
    喀喇沁左翼蒙古族自治县: "喀喇沁左翼",
    伊通满族自治县: "伊通",
    长白朝鲜族自治县: "长白",
    前郭尔罗斯蒙古族自治县: "前郭尔罗斯",
    杜尔伯特蒙古族自治县: "杜尔伯特",
    景宁畲族自治县: "景宁",
    长阳土家族自治县: "长阳",
    五峰土家族自治县: "五峰",
    城步苗族自治县: "城步",
    江华瑶族自治县: "江华",
    通道侗族自治县: "通道",
    芷江侗族自治县: "芷江",
    新晃侗族自治县: "新晃",
    麻阳苗族自治县: "麻阳",
    靖州苗族侗族自治县: "靖州",
    乳源瑶族自治县: "乳源",
    连山壮族瑶族自治县: "连山",
    连南瑶族自治县: "连南",
    隆林各族自治县: "隆林",
    富川瑶族自治县: "富川",
    金秀瑶族自治县: "金秀",
    龙胜各族自治县: "龙胜",
    恭城瑶族自治县: "恭城",
    融水苗族自治县: "融水",
    三江侗族自治县: "三江",
    环江毛南族自治县: "环江",
    大化瑶族自治县: "大化",
    罗城仫佬族自治县: "罗城",
    巴马瑶族自治县: "巴马",
    都安瑶族自治县: "都安",
    昌江黎族自治县: "昌江",
    琼中黎族苗族自治县: "琼中",
    陵水黎族自治县: "陵水",
    保亭黎族苗族自治县: "保亭",
    白沙黎族自治县: "白沙",
    乐东黎族自治县: "乐东",
    石柱土家族自治县: "石柱",
    彭水苗族土家族自治县: "彭水",
    酉阳土家族苗族自治县: "酉阳",
    秀山土家族苗族自治县: "秀山",
    马边彝族自治县: "马边",
    峨边彝族自治县: "峨边",
    北川羌族自治县: "北川",
    木里藏族自治县: "木里",
    三都水族自治县: "三都",
    沿河土家族自治县: "沿河",
    印江土家族苗族自治县: "印江",
    玉屏侗族自治县: "玉屏",
    松桃苗族自治县: "松桃",
    关岭布依族苗族自治县: "关岭",
    紫云苗族布依族自治县: "紫云",
    镇宁布依族苗族自治县: "镇宁",
    务川仡佬族苗族自治县: "务川",
    道真仡佬族苗族自治县: "道真",
    威宁彝族回族苗族自治县: "威宁",
    宁蒗彝族自治县: "宁蒗",
    玉龙纳西族自治县: "玉龙",
    石林彝族自治县: "石林",
    禄劝彝族苗族自治县: "禄劝",
    寻甸回族彝族自治县: "寻甸",
    峨山彝族自治县: "峨山",
    新平彝族傣族自治县: "新平",
    元江哈尼族彝族傣族自治县: "元江",
    沧源佤族自治县: "沧源",
    耿马傣族佤族自治县: "耿马",
    双江拉祜族佤族布朗族傣族自治县: "双江",
    江城哈尼族彝族自治县: "江城",
    墨江哈尼族自治县: "墨江",
    宁洱哈尼族彝族自治县: "宁洱",
    景东彝族自治县: "景东",
    镇沅彝族哈尼族拉祜族自治县: "镇沅",
    景谷傣族彝族自治县: "景谷",
    孟连傣族拉祜族佤族自治县: "孟连",
    澜沧拉祜族自治县: "澜沧",
    西盟佤族自治县: "西盟",
    维西傈僳族自治县: "维西",
    兰坪白族普米族自治县: "兰坪",
    贡山独龙族怒族自治县: "贡山",
    南涧彝族自治县: "南涧",
    漾濞彝族自治县: "漾濞",
    巍山彝族回族自治县: "巍山",
    屏边苗族自治县: "屏边",
    河口瑶族自治县: "河口",
    金平苗族瑶族傣族自治县: "金平",
    天祝藏族自治县: "天祝",
    张家川回族自治县: "张家川",
    肃南裕固族自治县: "肃南",
    肃北蒙古族自治县: "肃北",
    阿克塞哈萨克族自治县: "阿克塞",
    东乡族自治县: "东乡",
    积石山保安族东乡族撒拉族自治县: "积石山",
    大通回族土族自治县: "大通",
    互助土族自治县: "互助",
    循化撒拉族自治县: "循化",
    化隆回族自治县: "化隆",
    民和回族土族自治县: "民和",
    门源回族自治县: "门源",
    河南蒙古族自治县: "河南",
    塔什库尔干塔吉克自治县: "塔什库尔干",
    和布克赛尔蒙古自治县: "和布克赛尔",
    巴里坤哈萨克自治县: "巴里坤",
    察布查尔锡伯自治县: "察布查尔",
    木垒哈萨克自治县: "木垒",
    焉耆回族自治县: "焉耆",
    莫力达瓦达斡尔族自治旗: "莫力达瓦",
    鄂伦春自治旗: "鄂伦春",
    鄂温克族自治旗: "鄂温克",
    六枝特区: "六枝",
    神农架林区: "神农架"
  },
  //行政区域后缀
  REGION_SUFFIX: {
    province: "省",
    specialAdminRegion: "特别行政区",
    city: "市",
    region: "地区",
    prefecture: "州",
    autonomousPrefecture: "自治州",
    league: "盟",
    adminArea: "区",
    county: "县",
    autonomousCounty: "自治县",
    flag: "旗"
  }
};
exports["default"] = _default;

/***/ }),
/* 168 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Class = _interopRequireDefault(__webpack_require__(27));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/6.
 */
var Control = _Class["default"].extend({
  options: {
    position: 'bottomleft'
  },
  initialize: function (options) {
    _BaseUtils["default"].setOptions(this, options);
  },
  getPosition: function () {
    return this.options.position;
  },
  // @method setPosition(position: string): this
  // Sets the position of the control.
  setPosition: function (position) {
    var map = this._map;

    if (map) {
      map.removeControl(this);
    }

    this.options.position = position;

    if (map) {
      map.addControl(this);
    }

    return this;
  },
  // @method getContainer: HTMLElement
  // Returns the HTMLElement that contains the control.
  getContainer: function () {
    return this._container;
  },
  // @method addTo(map: Map): this
  // Adds the control to the given map.
  addTo: function (map) {
    this.remove();
    this._map = map;
    var container = this._container = this.onAdd(map),
        pos = this.getPosition(),
        corner = map._controlCorners[pos];

    _DomUtils["default"].addClass(container, 'leaflet-control');

    if (pos.indexOf('bottom') !== -1) {
      corner.insertBefore(container, corner.firstChild);
    } else {
      corner.appendChild(container);
    }

    return this;
  },
  // @method remove: this
  // Removes the control from the map it is currently active on.
  remove: function () {
    if (!this._map) {
      return this;
    }

    _DomUtils["default"].remove(this._container);

    if (this.onRemove) {
      this.onRemove(this._map);
    }

    this._map = null;
    return this;
  },
  _refocusOnMap: function (e) {
    // if map exists and event is not a keyboard event
    if (this._map && e && e.screenX > 0 && e.screenY > 0) {
      this._map.getContainer().focus();
    }
  }
});

Control.Attribution = Control.extend({
  // @section
  // @aka Control.Attribution options
  options: {
    position: 'bottomright',
    // @option prefix: String = 'Leaflet'
    // The HTML text shown before the attributions. Pass `false` to disable.
    prefix: ''
  },
  initialize: function (options) {
    _BaseUtils["default"].setOptions(this, options);

    this._attributions = {};
  },
  onAdd: function (map) {
    map.attributionControl = this;
    this._container = _DomUtils["default"].create('div', 'leaflet-control-attribution');

    this._update();

    return this._container;
  },
  // @method setPrefix(prefix: String): this
  // Sets the text before the attributions.
  setPrefix: function (prefix) {
    this.options.prefix = prefix;

    this._update();

    return this;
  },
  // @method addAttribution(text: String): this
  // Adds an attribution text (e.g. `'Vector data &copy; Mapbox'`).
  addAttribution: function (text) {
    if (!text) {
      return this;
    }

    if (!this._attributions[text]) {
      this._attributions[text] = 0;
    }

    this._attributions[text]++;

    this._update();

    return this;
  },
  // @method removeAttribution(text: String): this
  // Removes an attribution text.
  removeAttribution: function (text) {
    if (!text) {
      return this;
    }

    if (this._attributions[text]) {
      this._attributions[text]--;

      this._update();
    }

    return this;
  },
  _update: function () {
    if (!this._map) {
      return;
    }

    var attribs = [];

    for (var i in this._attributions) {
      if (this._attributions[i]) {
        attribs.push(i);
      }
    }

    var prefixAndAttribs = [];

    if (this.options.prefix) {
      prefixAndAttribs.push(this.options.prefix);
    }

    if (attribs.length) {
      prefixAndAttribs.push(attribs.join(', '));
    }

    this._container.innerHTML = prefixAndAttribs.join(' | ');
  }
});
Control.Zoom = Control.extend({
  // @section
  // @aka Control.Zoom options
  options: {
    position: 'topleft',
    // @option zoomInText: String = '+'
    // The text set on the 'zoom in' button.
    zoomInText: '+',
    // @option zoomInTitle: String = 'Zoom in'
    // The title set on the 'zoom in' button.
    zoomInTitle: 'Zoom in',
    // @option zoomOutText: String = '-'
    // The text set on the 'zoom out' button.
    zoomOutText: '-',
    // @option zoomOutTitle: String = 'Zoom out'
    // The title set on the 'zoom out' button.
    zoomOutTitle: 'Zoom out'
  },
  onAdd: function (map) {
    var zoomName = 'leaflet-control-zoom',
        container = _DomUtils["default"].create('div', zoomName + ' leaflet-bar'),
        options = this.options;

    this._zoomInButton = this._createButton(options.zoomInText, options.zoomInTitle, zoomName + '-in', container, this._zoomIn);
    this._zoomOutButton = this._createButton(options.zoomOutText, options.zoomOutTitle, zoomName + '-out', container, this._zoomOut);

    this._updateDisabled();

    map.on('zoomend zoomlevelschange', this._updateDisabled, this);
    container.style.position = 'absolute';
    container.style.left = options._topLeft.x + 'px';
    container.style.top = options._topLeft.y + 'px';
    container.style['z-index'] = 800;
    container.style['pointer-events'] = 'auto';
    return container;
  },
  onRemove: function (map) {
    map.off('zoomend zoomlevelschange', this._updateDisabled, this);
  },
  disable: function () {
    this._disabled = true;

    this._updateDisabled();

    return this;
  },
  enable: function () {
    this._disabled = false;

    this._updateDisabled();

    return this;
  },
  _zoomIn: function (e) {
    if (!this._disabled && this._map._zoom < this._map.getMaxZoom()) {
      this._map.zoomIn(this._map.options.zoomDelta * (e.shiftKey ? 3 : 1));
    }
  },
  _zoomOut: function (e) {
    if (!this._disabled && this._map._zoom > this._map.getMinZoom()) {
      this._map.zoomOut(this._map.options.zoomDelta * (e.shiftKey ? 3 : 1));
    }
  },
  _createButton: function (html, title, className, container, fn) {
    var link = _DomUtils["default"].create('a', className, container);

    link.innerHTML = html;
    link.href = '#';
    link.title = title;
    /*
     * Will force screen readers like VoiceOver to read this as "Zoom in - button"
     */

    link.setAttribute('role', 'button');
    link.setAttribute('aria-label', title);
    VanHammer.on(link, 'mousedown dblclick', _DomUtils["default"].stopPropagation).on(link, 'click', _DomUtils["default"].stop).on(link, 'click', fn.bind(this)).on(link, 'click', this._refocusOnMap.bind(this));
    return link;
  },
  _updateDisabled: function () {
    var map = this._map,
        className = 'leaflet-disabled';

    _DomUtils["default"].removeClass(this._zoomInButton, className);

    _DomUtils["default"].removeClass(this._zoomOutButton, className);

    if (this._disabled || map._zoom === map.getMinZoom()) {
      _DomUtils["default"].addClass(this._zoomOutButton, className);
    }

    if (this._disabled || map._zoom === map.getMaxZoom()) {
      _DomUtils["default"].addClass(this._zoomInButton, className);
    }
  }
});
var _default = Control;
exports["default"] = _default;

/***/ }),
/* 169 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = _default;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/3/17.
 */
function d3_xhrHasResponse(request) {
  var type = request.responseType;
  return type && type !== "text" ? request.response : request.responseText;
}

function d3_xhr_fixCallback(callback) {
  return callback.length === 1 ? function (error, request) {
    callback(error == null ? request : null);
  } : callback;
}

function d3_xhr(url, mimeType, response, callback) {
  var xhr = {},
      dispatch = _BaseUtils["default"].dispatch("beforesend", "progress", "load", "error"),
      headers = {},
      request = new XMLHttpRequest(),
      responseType = null;

  if (typeof XDomainRequest != "undefined" && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) {
    request = new XDomainRequest();
  }

  "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function () {
    request.readyState > 3 && respond();
  };

  function respond() {
    var status = request.status,
        result;

    if (!status && d3_xhrHasResponse(request) || status >= 200 && status < 300 || status === 304) {
      result = response.call(xhr, request);
      callback(result);
    }
  }

  xhr.header = function (name, value) {
    name = (name + "").toLowerCase();

    if (arguments.length < 2) {
      return headers[name];
    }

    if (value == null) {
      delete headers[name];
    } else {
      headers[name] = value + "";
    }

    return xhr;
  };

  xhr.mimeType = function (value) {
    if (!arguments.length) {
      return mimeType;
    }

    mimeType = value == null ? null : value + "";
    return xhr;
  };

  xhr.responseType = function (value) {
    if (!arguments.length) {
      return responseType;
    }

    responseType = value;
    return xhr;
  };

  xhr.response = function (value) {
    response = value;
    return xhr;
  };

  ["get", "post"].forEach(function (method) {
    xhr[method] = function () {
      return xhr.send.apply(xhr, [method].concat(_BaseUtils["default"].toArray(arguments)));
    };
  });

  xhr.send = function (method, data, callback) {
    if (arguments.length === 2 && typeof data === "function") {
      callback = data;
      data = null;
    }

    request.open(method, url, false);

    if (mimeType != null && !("accept" in headers)) {
      headers["accept"] = mimeType + ",*/*";
    }

    if (request.setRequestHeader) {
      for (var name in headers) {
        request.setRequestHeader(name, headers[name]);
      }
    }

    if (mimeType != null && request.overrideMimeType) {
      request.overrideMimeType(mimeType);
    }

    if (responseType != null) {
      request.responseType = responseType;
    }

    if (callback != null) {
      xhr.on("error", callback).on("load", function (request) {
        callback(null, request);
      });
    }

    dispatch.beforesend.call(xhr, request);
    request.send(data == null ? null : data);
    return xhr;
  };

  xhr.abort = function () {
    request.abort();
    return xhr;
  };

  _BaseUtils["default"].rebind(xhr, dispatch, "on");

  return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));
}

function d3_json(request) {
  return JSON['parse'](request.responseText);
}

function _default(url, callback) {
  return d3_xhr(url, "application/json", d3_json, callback);
}

;

/***/ }),
/* 170 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _Bounds = _interopRequireDefault(__webpack_require__(21));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/19.
 */
var Projection = {};
Projection.LonLat = {
  project: function (latlng) {
    return new _Point2D["default"](latlng.lng, latlng.lat);
  },
  unproject: function (point) {
    return new _LatLng["default"](point.y, point.x);
  },
  bounds: _Bounds["default"].create([-180, -90], [180, 90])
};
Projection.SphericalMercator = {
  R: 6378137,
  MAX_LATITUDE: 85.0511287798,
  project: function (latlng) {
    var d = Math.PI / 180,
        max = this.MAX_LATITUDE,
        lat = Math.max(Math.min(max, latlng.lat), -max),
        sin = Math.sin(lat * d);
    return new _Point2D["default"](this.R * latlng.lng * d, this.R * Math.log((1 + sin) / (1 - sin)) / 2);
  },
  unproject: function (point) {
    var d = 180 / Math.PI;
    return new _LatLng["default"]((2 * Math.atan(Math.exp(point.y / this.R)) - Math.PI / 2) * d, point.x * d / this.R);
  },
  bounds: function () {
    var d = 6378137 * Math.PI;
    return _Bounds["default"].create([-d, -d], [d, d]);
  }()
};
Projection.Mercator = {
  R: 6378137,
  R_MINOR: 6356752.314245179,
  bounds: _Bounds["default"].create([-20037508.34279, -15496570.73972], [20037508.34279, 18764656.23138]),
  project: function (latlng) {
    var d = Math.PI / 180,
        r = this.R,
        y = latlng.lat * d,
        tmp = this.R_MINOR / r,
        e = Math.sqrt(1 - tmp * tmp),
        con = e * Math.sin(y);
    var ts = Math.tan(Math.PI / 4 - y / 2) / Math.pow((1 - con) / (1 + con), e / 2);
    y = -r * Math.log(Math.max(ts, 1E-10));
    return new _Point2D["default"](latlng.lng * d * r, y);
  },
  unproject: function (point) {
    var d = 180 / Math.PI,
        r = this.R,
        tmp = this.R_MINOR / r,
        e = Math.sqrt(1 - tmp * tmp),
        ts = Math.exp(-point.y / r),
        phi = Math.PI / 2 - 2 * Math.atan(ts);

    for (var i = 0, dphi = 0.1, con; i < 15 && Math.abs(dphi) > 1e-7; i++) {
      con = e * Math.sin(phi);
      con = Math.pow((1 - con) / (1 + con), e / 2);
      dphi = Math.PI / 2 - 2 * Math.atan(ts * con) - phi;
      phi += dphi;
    }

    return new _LatLng["default"](phi * d, point.x * d / r);
  }
};
var _default = Projection;
exports["default"] = _default;

/***/ }),
/* 171 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Point2D = _interopRequireDefault(__webpack_require__(15));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/4.
 */
var Transformation = function (a, b, c, d) {
  this._a = a;
  this._b = b;
  this._c = c;
  this._d = d;
};

Transformation.prototype = {
  // @method transform(point: Point, scale?: Number)
  // Returns a transformed point, optionally multiplied by the given scale.
  // Only accepts real `L.Point` instances, not arrays.
  transform: function (point, scale) {
    // (Point, Number) -> Point
    return this._transform(point.clone(), scale);
  },
  // destructive transform (faster)
  _transform: function (point, scale) {
    scale = scale || 1;
    point.x = scale * (this._a * point.x + this._b);
    point.y = scale * (this._c * point.y + this._d);
    return point;
  },
  // @method untransform(point: Point, scale?: Number)
  // Returns the reverse transformation of the given point, optionally divided
  // by the given scale. Only accepts real `L.Point` instances, not arrays.
  untransform: function (point, scale) {
    scale = scale || 1;
    return new _Point2D["default"]((point.x / scale - this._b) / this._a, (point.y / scale - this._d) / this._c);
  }
};
var _default = Transformation;
exports["default"] = _default;

/***/ }),
/* 172 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _FeatureGroup = _interopRequireDefault(__webpack_require__(173));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _Bounds = _interopRequireDefault(__webpack_require__(21));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

var _LatLngBounds = _interopRequireDefault(__webpack_require__(34));

var _Path = _interopRequireDefault(__webpack_require__(48));

var _LineUtils = _interopRequireDefault(__webpack_require__(174));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/20.
 */
var GeoJSON = _FeatureGroup["default"].extend({
  initialize: function (geojson, options) {
    _BaseUtils["default"].setOptions(this, options);

    this._layers = {};
    this._featureLayerMap = {};

    if (geojson) {
      this.addData(geojson);
    }
  },
  // @method addData( <GeoJSON> data ): this
  // Adds a GeoJSON object to the layer.
  addData: function (geojson) {
    var features = _BaseUtils["default"].isArray(geojson) ? geojson : geojson.features,
        i,
        len,
        feature;

    if (features) {
      for (i = 0, len = features.length; i < len; i++) {
        // only add this if geometry or geometries are set and not null
        feature = features[i];

        if (feature.geometries || feature.geometry || feature.features || feature.coordinates) {
          this.addData(feature);
        }
      }

      return this;
    }

    var options = this.options;

    if (options.filter && !options.filter(geojson)) {
      return this;
    }

    var layer = this.geometryToLayer(geojson, options);

    if (!layer) {
      return this;
    }

    layer.options = layer.properties || _BaseUtils["default"].extend({}, this.options);
    this._featureLayerMap[_BaseUtils["default"].stamp(geojson)] = layer;
    return this.addLayer(layer);
  },
  getLayerByFeature: function (geoJson) {
    return this._featureLayerMap[_BaseUtils["default"].stamp(geoJson)];
  },
  geometryToLayer: function (geojson, options) {
    var geometry = geojson.type === 'Feature' ? geojson.geometry : geojson,
        coords = geometry ? geometry.coordinates : null,
        layers = [],
        coordsToLatLng = options && options.coordsToLatLng || this.coordsToLatLng,
        latlng,
        latlngs,
        i,
        len;

    if (!coords && !geometry) {
      return null;
    }

    switch (geometry.type) {
      case 'Polygon':
      case 'MultiPolygon':
        latlngs = this.coordsToLatLngs(coords, geometry.type === 'Polygon' ? 1 : 2, coordsToLatLng);
        return new Polygon(latlngs, options);

      case 'LineString':
      case 'MultiLineString':
        latlngs = this.coordsToLatLngs(coords, geometry.type === 'LineString' ? 0 : 1, coordsToLatLng);
        var line = new Polyline(latlngs, options);
        line.properties = _BaseUtils["default"].extend({}, options, geojson.properties);
        return line;

      case 'GeometryCollection':
        for (i = 0, len = geometry.geometries.length; i < len; i++) {
          var layer = this.geometryToLayer({
            geometry: geometry.geometries[i],
            type: 'Feature',
            properties: geojson.properties
          }, options);

          if (layer) {
            layers.push(layer);
          }
        }

        return new _FeatureGroup["default"](layers);
    }
  },
  // @function coordsToLatLng(coords: Array): LatLng
  // Creates a `LatLng` object from an array of 2 numbers (longitude, latitude)
  // or 3 numbers (longitude, latitude, altitude) used in GeoJSON for points.
  coordsToLatLng: function (coords) {
    return new _LatLng["default"](coords[1], coords[0], coords[2]);
  },
  // @function coordsToLatLngs(coords: Array, levelsDeep?: Number, coordsToLatLng?: Function): Array
  // Creates a multidimensional array of `LatLng`s from a GeoJSON coordinates array.
  // `levelsDeep` specifies the nesting level (0 is for an array of points, 1 for an array of arrays of points, etc., 0 by default).
  // Can use a custom [`coordsToLatLng`](#geojson-coordstolatlng) function.
  coordsToLatLngs: function (coords, levelsDeep, coordsToLatLng) {
    var latlngs = [];

    for (var i = 0, len = coords.length, latlng; i < len; i++) {
      latlng = levelsDeep ? this.coordsToLatLngs(coords[i], levelsDeep - 1, coordsToLatLng) : (coordsToLatLng || this.coordsToLatLng)(coords[i]);
      latlngs.push(latlng);
    }

    return latlngs;
  },
  // @function latLngToCoords(latlng: LatLng): Array
  // Reverse of [`coordsToLatLng`](#geojson-coordstolatlng)
  latLngToCoords: function (latlng) {
    return latlng.alt !== undefined ? [latlng.lng, latlng.lat, latlng.alt] : [latlng.lng, latlng.lat];
  },
  // @function latLngsToCoords(latlngs: Array, levelsDeep?: Number, closed?: Boolean): Array
  // Reverse of [`coordsToLatLngs`](#geojson-coordstolatlngs)
  // `closed` determines whether the first point should be appended to the end of the array to close the feature, only used when `levelsDeep` is 0. False by default.
  latLngsToCoords: function (latlngs, levelsDeep, closed) {
    var coords = [];

    for (var i = 0, len = latlngs.length; i < len; i++) {
      coords.push(levelsDeep ? GeoJSON.latLngsToCoords(latlngs[i], levelsDeep - 1, closed) : GeoJSON.latLngToCoords(latlngs[i]));
    }

    if (!levelsDeep && closed) {
      coords.push(coords[0]);
    }

    return coords;
  },
  // @function asFeature(geojson: Object): Object
  // Normalize GeoJSON geometries/features into GeoJSON features.
  asFeature: function (geojson) {
    if (geojson.type === 'Feature' || geojson.type === 'FeatureCollection') {
      return geojson;
    }

    return {
      type: 'Feature',
      properties: {},
      geometry: geojson
    };
  }
});

var Polyline = _Path["default"].extend({
  initialize: function (latlngs, options) {
    _BaseUtils["default"].setOptions(this, options);

    this._setLatLngs(latlngs);
  },
  // @method getLatLngs(): LatLng[]
  // Returns an array of the points in the path, or nested arrays of points in case of multi-polyline.
  getLatLngs: function () {
    return this._latlngs;
  },
  // @method setLatLngs(latlngs: LatLng[]): this
  // Replaces all the points in the polyline with the given array of geographical points.
  setLatLngs: function (latlngs) {
    this._setLatLngs(latlngs);

    return this.redraw();
  },
  // @method isEmpty(): Boolean
  // Returns `true` if the Polyline has no LatLngs.
  isEmpty: function () {
    return !this._latlngs.length;
  },
  closestLayerPoint: function (p) {
    var minDistance = Infinity,
        minPoint = null,
        closest = _LineUtils["default"]._sqClosestPointOnSegment,
        p1,
        p2;

    for (var j = 0, jLen = this._parts.length; j < jLen; j++) {
      var points = this._parts[j];

      for (var i = 1, len = points.length; i < len; i++) {
        p1 = points[i - 1];
        p2 = points[i];
        var sqDist = closest(p, p1, p2, true);

        if (sqDist < minDistance) {
          minDistance = sqDist;
          minPoint = closest(p, p1, p2);
        }
      }
    }

    if (minPoint) {
      minPoint.distance = Math.sqrt(minDistance);
    }

    return minPoint;
  },
  // @method getCenter(): LatLng
  // Returns the center ([centroid](http://en.wikipedia.org/wiki/Centroid)) of the polyline.
  getCenter: function () {
    // throws error when not yet added to map as this center calculation requires projected coordinates
    if (!this._map) {
      throw new Error('Must add layer to map before using getCenter()');
    }

    var i,
        halfDist,
        segDist,
        dist,
        p1,
        p2,
        ratio,
        points = this._rings[0],
        len = points.length;

    if (!len) {
      return null;
    } // polyline centroid algorithm; only uses the first ring if there are multiple


    for (i = 0, halfDist = 0; i < len - 1; i++) {
      halfDist += points[i].distanceTo(points[i + 1]) / 2;
    } // The line is so small in the current view that all points are on the same pixel.


    if (halfDist === 0) {
      return this._map.layerPointToLatLng(points[0]);
    }

    for (i = 0, dist = 0; i < len - 1; i++) {
      p1 = points[i];
      p2 = points[i + 1];
      segDist = p1.distanceTo(p2);
      dist += segDist;

      if (dist > halfDist) {
        ratio = (dist - halfDist) / segDist;
        return this._map.layerPointToLatLng([p2.x - ratio * (p2.x - p1.x), p2.y - ratio * (p2.y - p1.y)]);
      }
    }
  },
  // @method getBounds(): LatLngBounds
  // Returns the `LatLngBounds` of the path.
  getBounds: function () {
    return this._bounds;
  },
  // @method addLatLng(latlng: LatLng, latlngs? LatLng[]): this
  // Adds a given point to the polyline. By default, adds to the first ring of
  // the polyline in case of a multi-polyline, but can be overridden by passing
  // a specific ring as a LatLng array (that you can earlier access with [`getLatLngs`](#polyline-getlatlngs)).
  addLatLng: function (latlng, latlngs) {
    latlngs = latlngs || this._defaultShape();
    latlng = _LatLng["default"].create(latlng);
    latlngs.push(latlng);

    this._bounds.extend(latlng);

    return this.redraw();
  },
  _setLatLngs: function (latlngs) {
    this._bounds = new _LatLngBounds["default"]();
    this._latlngs = this._convertLatLngs(latlngs);
  },
  _defaultShape: function () {
    return Polyline._flat(this._latlngs) ? this._latlngs : this._latlngs[0];
  },
  // recursively convert latlngs input into actual LatLng instances; calculate bounds along the way
  _convertLatLngs: function (latlngs) {
    var result = [],
        flat = Polyline._flat(latlngs);

    for (var i = 0, len = latlngs.length; i < len; i++) {
      if (flat) {
        result[i] = _LatLng["default"].create(latlngs[i]);

        this._bounds.extend(result[i]);
      } else {
        result[i] = this._convertLatLngs(latlngs[i]);
      }
    }

    return result;
  },
  _project: function () {
    var pxBounds = new _Bounds["default"]();
    this._rings = [];

    this._projectLatlngs(this._latlngs, this._rings, pxBounds);

    var w = this._clickTolerance(),
        p = new _Point2D["default"](w, w);

    if (this._bounds.isValid() && pxBounds.isValid()) {
      pxBounds.min._subtract(p);

      pxBounds.max._add(p);

      this._pxBounds = pxBounds;
    }
  },
  // recursively turns latlngs into a set of rings with projected coordinates
  _projectLatlngs: function (latlngs, result, projectedBounds) {
    var flat = latlngs[0] instanceof _LatLng["default"],
        len = latlngs.length,
        i,
        ring;

    if (flat) {
      ring = [];

      for (i = 0; i < len; i++) {
        ring[i] = this._map.latLngToLayerPoint(latlngs[i]);
        projectedBounds.extend(ring[i]);
      }

      result.push(ring);
    } else {
      for (i = 0; i < len; i++) {
        this._projectLatlngs(latlngs[i], result, projectedBounds);
      }
    }
  },
  // clip polyline by renderer bounds so that we have less to render for performance
  _clipPoints: function () {
    var bounds = this._renderer._bounds;
    this._parts = [];

    if (!this._pxBounds || !this._pxBounds.intersects(bounds)) {
      return;
    }

    if (this.options.noClip) {
      this._parts = this._rings;
      return;
    }

    var parts = this._parts,
        i,
        j,
        k,
        len,
        len2,
        segment,
        points;

    for (i = 0, k = 0, len = this._rings.length; i < len; i++) {
      points = this._rings[i];

      for (j = 0, len2 = points.length; j < len2 - 1; j++) {
        segment = _LineUtils["default"].clipSegment(points[j], points[j + 1], bounds, j, true);

        if (!segment) {
          continue;
        }

        parts[k] = parts[k] || [];
        parts[k].push(segment[0]); // if segment goes out of screen, or it's the last one, it's the end of the line part

        if (segment[1] !== points[j + 1] || j === len2 - 2) {
          parts[k].push(segment[1]);
          k++;
        }
      }
    }
  },
  // simplify each clipped part of the polyline for performance
  _simplifyPoints: function () {
    var parts = this._parts,
        tolerance = this.options.smoothFactor;

    for (var i = 0, len = parts.length; i < len; i++) {
      parts[i] = _LineUtils["default"].simplify(parts[i], tolerance);
    }
  },
  _update: function () {
    if (!this._map) {
      return;
    }

    this._clipPoints();

    this._simplifyPoints();

    this._updatePath();
  },
  _updatePath: function () {
    this._updatePoly();
  },
  _updatePoly: function (closed) {
    this._path.attr('d', this.pointsToPath(this._parts, closed));
  },
  pointsToPath: function (rings, closed) {
    var str = '',
        i,
        j,
        len,
        len2,
        points,
        p;

    for (i = 0, len = rings.length; i < len; i++) {
      points = rings[i];

      for (j = 0, len2 = points.length; j < len2; j++) {
        p = points[j];
        str += (j ? 'L' : 'M') + p.x + ' ' + p.y;
      } // closes the ring for polygons; "x" is VML syntax


      str += closed ? 'z' : '';
    } // SVG complains about empty path strings


    return str || 'M0 0';
  },
  _containsPoint: function (p, closed) {
    var i,
        j,
        k,
        len,
        len2,
        part,
        w = this._clickTolerance();

    if (!this._pxBounds.contains(p)) {
      return false;
    } // hit detection for polylines


    for (i = 0, len = this._parts.length; i < len; i++) {
      part = this._parts[i];

      for (j = 0, len2 = part.length, k = len2 - 1; j < len2; k = j++) {
        if (!closed && j === 0) {
          continue;
        }

        if (_LineUtils["default"].pointToSegmentDistance(p, part[k], part[j]) <= w) {
          return true;
        }
      }
    }

    return false;
  }
});

Polyline._flat = function (latlngs) {
  // true if it's a flat array of latlngs; false if nested
  return !_BaseUtils["default"].isArray(latlngs[0]) || typeof latlngs[0][0] !== 'object' && typeof latlngs[0][0] !== 'undefined';
};

var Polygon = Polyline.extend({
  isEmpty: function () {
    return !this._latlngs.length || !this._latlngs[0].length;
  },
  getCenter: function () {
    // throws error when not yet added to map as this center calculation requires projected coordinates
    if (!this._map) {
      throw new Error('Must add layer to map before using getCenter()');
    }

    var i,
        j,
        p1,
        p2,
        f,
        area,
        x,
        y,
        center,
        points = this._rings[0],
        len = points.length;

    if (!len) {
      return null;
    } // polygon centroid algorithm; only uses the first ring if there are multiple


    area = x = y = 0;

    for (i = 0, j = len - 1; i < len; j = i++) {
      p1 = points[i];
      p2 = points[j];
      f = p1.y * p2.x - p2.y * p1.x;
      x += (p1.x + p2.x) * f;
      y += (p1.y + p2.y) * f;
      area += f * 3;
    }

    if (area === 0) {
      // Polygon is so small that all points are on same pixel.
      center = points[0];
    } else {
      center = [x / area, y / area];
    }

    return this._map.layerPointToLatLng(center);
  },
  _convertLatLngs: function (latlngs) {
    var result = Polyline.prototype._convertLatLngs.call(this, latlngs),
        len = result.length; // remove last point if it equals first one


    if (len >= 2 && result[0] instanceof _LatLng["default"] && result[0].equals(result[len - 1])) {
      result.pop();
    }

    return result;
  },
  _setLatLngs: function (latlngs) {
    Polyline.prototype._setLatLngs.call(this, latlngs);

    if (Polyline._flat(this._latlngs)) {
      this._latlngs = [this._latlngs];
    }
  },
  _defaultShape: function () {
    return Polyline._flat(this._latlngs[0]) ? this._latlngs[0] : this._latlngs[0][0];
  },
  _clipPoints: function () {
    // polygons need a different clipping algorithm so we redefine that
    var bounds = this._renderer._bounds,
        w = this.options['stroke-width'],
        p = new _Point2D["default"](w, w); // increase clip padding by stroke width to avoid stroke on clip edges

    bounds = new _Bounds["default"](bounds.min.subtract(p), bounds.max.add(p));
    this._parts = [];

    if (!this._pxBounds || !this._pxBounds.intersects(bounds)) {
      return;
    }

    if (this.options.noClip) {
      this._parts = this._rings;
      return;
    }

    for (var i = 0, len = this._rings.length, clipped; i < len; i++) {
      clipped = _LineUtils["default"].clipPolygon(this._rings[i], bounds, true);

      if (clipped.length) {
        this._parts.push(clipped);
      }
    }
  },
  _updatePath: function () {
    this._updatePoly(true);
  },
  _containsPoint: function (p) {
    var inside = false,
        part,
        p1,
        p2,
        i,
        j,
        k,
        len,
        len2;

    if (!this._pxBounds.contains(p)) {
      return false;
    } // ray casting algorithm for detecting if point is in polygon


    for (i = 0, len = this._parts.length; i < len; i++) {
      part = this._parts[i];

      for (j = 0, len2 = part.length, k = len2 - 1; j < len2; k = j++) {
        p1 = part[j];
        p2 = part[k];

        if (p1.y > p.y !== p2.y > p.y && p.x < (p2.x - p1.x) * (p.y - p1.y) / (p2.y - p1.y) + p1.x) {
          inside = !inside;
        }
      }
    } // also check if it's on polygon stroke


    return inside || Polyline.prototype._containsPoint.call(this, p, true);
  }
});
var _default = GeoJSON;
exports["default"] = _default;

/***/ }),
/* 173 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _LayerGroup = _interopRequireDefault(__webpack_require__(49));

var _LatLngBounds = _interopRequireDefault(__webpack_require__(34));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/20.
 */
var FeatureGroup = _LayerGroup["default"].extend({
  addLayer: function (layer) {
    if (this.hasLayer(layer)) {
      return this;
    }

    layer.addEventParent(this);

    _LayerGroup["default"].prototype.addLayer.call(this, layer);

    return this;
  },
  removeLayer: function (layer) {
    if (!this.hasLayer(layer)) {
      return this;
    }

    if (layer in this._layers) {
      layer = this._layers[layer];
    }

    layer.removeEventParent(this);

    _LayerGroup["default"].prototype.removeLayer.call(this, layer);

    return this;
  },
  // @method setStyle(style: Path options): this
  // Sets the given path options to each layer of the group that has a `setStyle` method.
  setStyle: function (style) {
    return this.invoke('setStyle', style);
  },
  // @method bringToFront(): this
  // Brings the layer group to the top of all other layers
  bringToFront: function () {
    return this.invoke('bringToFront');
  },
  // @method bringToBack(): this
  // Brings the layer group to the top of all other layers
  bringToBack: function () {
    return this.invoke('bringToBack');
  },
  getBounds: function () {
    var bounds = new _LatLngBounds["default"]();

    for (var id in this._layers) {
      var layer = this._layers[id];
      bounds.extend(layer.getBounds ? layer.getBounds() : layer.getLatLng());
    }

    return bounds;
  }
});

var _default = FeatureGroup;
exports["default"] = _default;

/***/ }),
/* 174 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Point2D = _interopRequireDefault(__webpack_require__(15));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/8.
 */
var _default = {
  // Simplify polyline with vertex reduction and Douglas-Peucker simplification.
  // Improves rendering performance dramatically by lessening the number of points to draw.
  // @function simplify(points: Point[], tolerance: Number): Point[]
  // Dramatically reduces the number of points in a polyline while retaining
  // its shape and returns a new array of simplified points, using the
  // [Douglas-Peucker algorithm](http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm).
  // Used for a huge performance boost when processing/displaying Leaflet polylines for
  // each zoom level and also reducing visual noise. tolerance affects the amount of
  // simplification (lesser value means higher quality but slower and with more points).
  // Also released as a separated micro-library [Simplify.js](http://mourner.github.com/simplify-js/).
  simplify: function (points, tolerance) {
    if (!tolerance || !points.length) {
      return points.slice();
    }

    var sqTolerance = tolerance * tolerance; // stage 1: vertex reduction

    points = this._reducePoints(points, sqTolerance); // stage 2: Douglas-Peucker simplification

    points = this._simplifyDP(points, sqTolerance);
    return points;
  },
  // @function pointToSegmentDistance(p: Point, p1: Point, p2: Point): Number
  // Returns the distance between point `p` and segment `p1` to `p2`.
  pointToSegmentDistance: function (p, p1, p2) {
    return Math.sqrt(this._sqClosestPointOnSegment(p, p1, p2, true));
  },
  // @function closestPointOnSegment(p: Point, p1: Point, p2: Point): Number
  // Returns the closest point from a point `p` on a segment `p1` to `p2`.
  closestPointOnSegment: function (p, p1, p2) {
    return this._sqClosestPointOnSegment(p, p1, p2);
  },
  // Douglas-Peucker simplification, see http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm
  _simplifyDP: function (points, sqTolerance) {
    var len = points.length,
        ArrayConstructor = typeof Uint8Array !== undefined + '' ? Uint8Array : Array,
        markers = new ArrayConstructor(len);
    markers[0] = markers[len - 1] = 1;

    this._simplifyDPStep(points, markers, sqTolerance, 0, len - 1);

    var i,
        newPoints = [];

    for (i = 0; i < len; i++) {
      if (markers[i]) {
        newPoints.push(points[i]);
      }
    }

    return newPoints;
  },
  _simplifyDPStep: function (points, markers, sqTolerance, first, last) {
    var maxSqDist = 0,
        index,
        i,
        sqDist;

    for (i = first + 1; i <= last - 1; i++) {
      sqDist = this._sqClosestPointOnSegment(points[i], points[first], points[last], true);

      if (sqDist > maxSqDist) {
        index = i;
        maxSqDist = sqDist;
      }
    }

    if (maxSqDist > sqTolerance) {
      markers[index] = 1;

      this._simplifyDPStep(points, markers, sqTolerance, first, index);

      this._simplifyDPStep(points, markers, sqTolerance, index, last);
    }
  },
  // reduce points that are too close to each other to a single point
  _reducePoints: function (points, sqTolerance) {
    var reducedPoints = [points[0]];

    for (var i = 1, prev = 0, len = points.length; i < len; i++) {
      if (this._sqDist(points[i], points[prev]) > sqTolerance) {
        reducedPoints.push(points[i]);
        prev = i;
      }
    }

    if (prev < len - 1) {
      reducedPoints.push(points[len - 1]);
    }

    return reducedPoints;
  },
  // @function clipSegment(a: Point, b: Point, bounds: Bounds, useLastCode?: Boolean, round?: Boolean): Point[]|Boolean
  // Clips the segment a to b by rectangular bounds with the
  // [Cohen-Sutherland algorithm](https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm)
  // (modifying the segment points directly!). Used by Leaflet to only show polyline
  // points that are on the screen or near, increasing performance.
  clipSegment: function (a, b, bounds, useLastCode, round) {
    var codeA = useLastCode ? this._lastCode : this._getBitCode(a, bounds),
        codeB = this._getBitCode(b, bounds),
        codeOut,
        p,
        newCode; // save 2nd code to avoid calculating it on the next segment


    this._lastCode = codeB;

    while (true) {
      // if a,b is inside the clip window (trivial accept)
      if (!(codeA | codeB)) {
        return [a, b];
      } // if a,b is outside the clip window (trivial reject)


      if (codeA & codeB) {
        return false;
      } // other cases


      codeOut = codeA || codeB;
      p = this._getEdgeIntersection(a, b, codeOut, bounds, round);
      newCode = this._getBitCode(p, bounds);

      if (codeOut === codeA) {
        a = p;
        codeA = newCode;
      } else {
        b = p;
        codeB = newCode;
      }
    }
  },
  _getEdgeIntersection: function (a, b, code, bounds, round) {
    var dx = b.x - a.x,
        dy = b.y - a.y,
        min = bounds.min,
        max = bounds.max,
        x,
        y;

    if (code & 8) {
      // top
      x = a.x + dx * (max.y - a.y) / dy;
      y = max.y;
    } else if (code & 4) {
      // bottom
      x = a.x + dx * (min.y - a.y) / dy;
      y = min.y;
    } else if (code & 2) {
      // right
      x = max.x;
      y = a.y + dy * (max.x - a.x) / dx;
    } else if (code & 1) {
      // left
      x = min.x;
      y = a.y + dy * (min.x - a.x) / dx;
    }

    return new _Point2D["default"](x, y, round);
  },
  _getBitCode: function (p, bounds) {
    var code = 0;

    if (p.x < bounds.min.x) {
      // left
      code |= 1;
    } else if (p.x > bounds.max.x) {
      // right
      code |= 2;
    }

    if (p.y < bounds.min.y) {
      // bottom
      code |= 4;
    } else if (p.y > bounds.max.y) {
      // top
      code |= 8;
    }

    return code;
  },
  // square distance (to avoid unnecessary Math.sqrt calls)
  _sqDist: function (p1, p2) {
    var dx = p2.x - p1.x,
        dy = p2.y - p1.y;
    return dx * dx + dy * dy;
  },
  // return closest point on segment or distance to that point
  _sqClosestPointOnSegment: function (p, p1, p2, sqDist) {
    var x = p1.x,
        y = p1.y,
        dx = p2.x - x,
        dy = p2.y - y,
        dot = dx * dx + dy * dy,
        t;

    if (dot > 0) {
      t = ((p.x - x) * dx + (p.y - y) * dy) / dot;

      if (t > 1) {
        x = p2.x;
        y = p2.y;
      } else if (t > 0) {
        x += dx * t;
        y += dy * t;
      }
    }

    dx = p.x - x;
    dy = p.y - y;
    return sqDist ? dx * dx + dy * dy : new _Point2D["default"](x, y);
  },
  clipPolygon: function (points, bounds, round) {
    var clippedPoints,
        edges = [1, 4, 2, 8],
        i,
        j,
        k,
        a,
        b,
        len,
        edge,
        p;

    for (i = 0, len = points.length; i < len; i++) {
      points[i]._code = this._getBitCode(points[i], bounds);
    } // for each edge (left, bottom, right, top)


    for (k = 0; k < 4; k++) {
      edge = edges[k];
      clippedPoints = [];

      for (i = 0, len = points.length, j = len - 1; i < len; j = i++) {
        a = points[i];
        b = points[j]; // if a is inside the clip window

        if (!(a._code & edge)) {
          // if b is outside the clip window (a->b goes out of screen)
          if (b._code & edge) {
            p = this._getEdgeIntersection(b, a, edge, bounds, round);
            p._code = this._getBitCode(p, bounds);
            clippedPoints.push(p);
          }

          clippedPoints.push(a); // else if b is inside the clip window (a->b enters the screen)
        } else if (!(b._code & edge)) {
          p = this._getEdgeIntersection(b, a, edge, bounds, round);
          p._code = this._getBitCode(p, bounds);
          clippedPoints.push(p);
        }
      }

      points = clippedPoints;
    }

    return points;
  }
};
exports["default"] = _default;

/***/ }),
/* 175 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _LatLngBounds = _interopRequireDefault(__webpack_require__(34));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Bounds = _interopRequireDefault(__webpack_require__(21));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/6.
 */
var ImageOverlay = _Layer["default"].extend({
  // @section
  // @aka ImageOverlay options
  options: {
    // @option opacity: Number = 1.0
    // The opacity of the image overlay.
    opacity: 1,
    // @option alt: String = ''
    // Text for the `alt` attribute of the image (useful for accessibility).
    alt: '',
    // @option interactive: Boolean = false
    // If `true`, the image overlay will emit [mouse events](#interactive-layer) when clicked or hovered.
    interactive: false,
    // @option crossOrigin: Boolean = false
    // If true, the image will have its crossOrigin attribute set to ''. This is needed if you want to access image pixel data.
    crossOrigin: false
  },
  initialize: function (url, bounds, options) {
    // (String, LatLngBounds, Object)
    this._url = url;
    this._bounds = _LatLngBounds["default"].create(bounds);

    _BaseUtils["default"].setOptions(this, options);
  },
  onAdd: function () {
    if (!this._image) {
      this._initImage();

      if (this.options.opacity < 1) {
        this._updateOpacity();
      }
    }

    this.getPane().appendChild(this._image);

    this._reset();
  },
  onRemove: function () {
    _DomUtils["default"].remove(this._image);

    if (this.options.interactive) {
      this.removeInteractiveTarget(this._image);
    }
  },
  // @method setOpacity(opacity: Number): this
  // Sets the opacity of the overlay.
  setOpacity: function (opacity) {
    this.options.opacity = opacity;

    if (this._image) {
      this._updateOpacity();
    }

    return this;
  },
  setStyle: function (styleOpts) {
    if (styleOpts.opacity) {
      this.setOpacity(styleOpts.opacity);
    }

    return this;
  },
  // @method bringToFront(): this
  // Brings the layer to the top of all overlays.
  bringToFront: function () {
    if (this._map) {
      _DomUtils["default"].toFront(this._image);
    }

    return this;
  },
  // @method bringToBack(): this
  // Brings the layer to the bottom of all overlays.
  bringToBack: function () {
    if (this._map) {
      _DomUtils["default"].toBack(this._image);
    }

    return this;
  },
  // @method setUrl(url: String): this
  // Changes the URL of the image.
  setUrl: function (url) {
    this._url = url;

    if (this._image) {
      this._image.src = url;
    }

    return this;
  },
  setBounds: function (bounds) {
    this._bounds = bounds;

    if (this._map) {
      this._reset();
    }

    return this;
  },
  getEvents: function () {
    var events = {
      zoom: this._reset,
      viewreset: this._reset
    };

    if (this._zoomAnimated) {
      events.zoomanim = this._animateZoom;
    }

    return events;
  },
  getBounds: function () {
    return this._bounds;
  },
  _initImage: function () {
    var img = this._image = _DomUtils["default"].create('img', 'leaflet-image-layer ' + (this._zoomAnimated ? 'leaflet-zoom-animated' : ''));

    img.onselectstart = _BaseUtils["default"].falseFn;
    img.onmousemove = _BaseUtils["default"].falseFn;
    img.onload = _BaseUtils["default"].bind(this.fire, this, 'load');

    if (this.options.crossOrigin) {
      img.crossOrigin = '';
    }

    img.src = this._url;
    img.alt = this.options.alt;
  },
  _animateZoom: function (e) {
    var scale = this._map.getZoomScale(e.zoom),
        offset = this._map._latLngBoundsToNewLayerBounds(this._bounds, e.zoom, e.center).min;

    _DomUtils["default"].setTransform(this._image, offset, scale);
  },
  _reset: function () {
    var image = this._image,
        bounds = new _Bounds["default"](this._map.latLngToLayerPoint(this._bounds.getNorthWest()), this._map.latLngToLayerPoint(this._bounds.getSouthEast())),
        size = bounds.getSize();

    _DomUtils["default"].setPosition(image, bounds.min);

    image.style.width = size.x + 'px';
    image.style.height = size.y + 'px';
  },
  _updateOpacity: function () {
    _DomUtils["default"].setOpacity(this._image, this.options.opacity);
  }
});

var _default = ImageOverlay;
exports["default"] = _default;

/***/ }),
/* 176 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _GridLayer = _interopRequireDefault(__webpack_require__(177));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _CRS = _interopRequireDefault(__webpack_require__(65));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _VanHammer = _interopRequireDefault(__webpack_require__(43));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/20.
 */
var emptyImageUrl = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=';

var TileLayer = _GridLayer["default"].extend({
  // @section
  // @aka TileLayer options
  options: {
    // @option minZoom: Number = 0
    // Minimum zoom number.
    minZoom: 0,
    // @option maxZoom: Number = 18
    // Maximum zoom number.
    maxZoom: 18,
    // @option maxNativeZoom: Number = null
    // Maximum zoom number the tile source has available. If it is specified,
    // the tiles on all zoom levels higher than `maxNativeZoom` will be loaded
    // from `maxNativeZoom` level and auto-scaled.
    maxNativeZoom: null,
    // @option minNativeZoom: Number = null
    // Minimum zoom number the tile source has available. If it is specified,
    // the tiles on all zoom levels lower than `minNativeZoom` will be loaded
    // from `minNativeZoom` level and auto-scaled.
    minNativeZoom: null,
    // @option subdomains: String|String[] = 'abc'
    // Subdomains of the tile service. Can be passed in the form of one string (where each letter is a subdomain name) or an array of strings.
    subdomains: 'abc',
    // @option errorTileUrl: String = ''
    // URL to the tile image to show in place of the tile that failed to load.
    errorTileUrl: '',
    // @option zoomOffset: Number = 0
    // The zoom number used in tile URLs will be offset with this value.
    zoomOffset: 0,
    // @option tms: Boolean = false
    // If `true`, inverses Y axis numbering for tiles (turn this on for [TMS](https://en.wikipedia.org/wiki/Tile_Map_Service) services).
    tms: false,
    // @option zoomReverse: Boolean = false
    // If set to true, the zoom number used in tile URLs will be reversed (`maxZoom - zoom` instead of `zoom`)
    zoomReverse: false,
    // @option detectRetina: Boolean = false
    // If `true` and user is on a retina display, it will request four tiles of half the specified size and a bigger zoom level in place of one to utilize the high resolution.
    detectRetina: false,
    // @option crossOrigin: Boolean = false
    // If true, all tiles will have their crossOrigin attribute set to ''. This is needed if you want to access tile pixel data.
    crossOrigin: false
  },
  initialize: function (url, options) {
    this._url = url;
    options = _BaseUtils["default"].setOptions(this, options); // detecting retina displays, adjusting tileSize and zoom levels

    if (options.detectRetina && _Browser["default"].retina && options.maxZoom > 0) {
      options.tileSize = Math.floor(options.tileSize / 2);

      if (!options.zoomReverse) {
        options.zoomOffset++;
        options.maxZoom--;
      } else {
        options.zoomOffset--;
        options.minZoom++;
      }

      options.minZoom = Math.max(0, options.minZoom);
    }

    if (typeof options.subdomains === 'string') {
      options.subdomains = options.subdomains.split('');
    } // for https://github.com/Leaflet/Leaflet/issues/137
    // if (!Browser.android) {
    //     this.on('tileunload', this._onTileRemove);
    // }

  },
  // @method setUrl(url: String, noRedraw?: Boolean): this
  // Updates the layer's URL template and redraws it (unless `noRedraw` is set to `true`).
  setUrl: function (url, noRedraw) {
    this._url = url;

    if (!noRedraw) {
      this.redraw();
    }

    return this;
  },
  // @method createTile(coords: Object, done?: Function): HTMLElement
  // Called only internally, overrides GridLayer's [`createTile()`](#gridlayer-createtile)
  // to return an `<img>` HTML element with the appropiate image URL given `coords`. The `done`
  // callback is called when the tile has been loaded.
  createTile: function (coords, done) {
    var tile = document.createElement('img');

    _VanHammer["default"].on(tile, 'load', _BaseUtils["default"].bind(this._tileOnLoad, this, done, tile));

    _VanHammer["default"].on(tile, 'error', _BaseUtils["default"].bind(this._tileOnError, this, done, tile));

    if (this.options.crossOrigin) {
      tile.crossOrigin = '';
    }
    /*
     Alt tag is set to empty string to keep screen readers from reading URL and for compliance reasons
     http://www.w3.org/TR/WCAG20-TECHS/H67
     */


    tile.alt = '';
    /*
     Set role="presentation" to force screen readers to ignore this
     https://www.w3.org/TR/wai-aria/roles#textalternativecomputation
     */

    tile.setAttribute('role', 'presentation');
    tile.src = this.getTileUrl(coords);
    return tile;
  },
  // @section Extension methods
  // @uninheritable
  // Layers extending `TileLayer` might reimplement the following method.
  // @method getTileUrl(coords: Object): String
  // Called only internally, returns the URL for a tile given its coordinates.
  // Classes extending `TileLayer` can override this function to provide custom tile URL naming schemes.
  getTileUrl: function (coords) {
    var data = {
      r: _Browser["default"].retina ? '@2x' : '',
      s: this._getSubdomain(coords),
      x: coords.x,
      y: coords.y,
      z: this._getZoomForUrl()
    };

    if (this._map && !this._map.options.crs.infinite) {
      var invertedY = this._globalTileRange.max.y - coords.y;

      if (this.options.tms) {
        data['y'] = invertedY;
      }

      data['-y'] = invertedY;
    }

    return _BaseUtils["default"].template(this._url, _BaseUtils["default"].extend(data, this.options));
  },
  _tileOnLoad: function (done, tile) {
    // For https://github.com/Leaflet/Leaflet/issues/3332
    if (_Browser["default"].ielt9) {
      setTimeout(_BaseUtils["default"].bind(done, this, null, tile), 0);
    } else {
      done(null, tile);
    }
  },
  _tileOnError: function (done, tile, e) {
    var errorUrl = this.options.errorTileUrl;

    if (errorUrl) {
      tile.src = errorUrl;
    }

    done(e, tile);
  },
  getTileSize: function () {
    var map = this._map,
        tileSize = _GridLayer["default"].prototype.getTileSize.call(this),
        zoom = this._tileZoom + this.options.zoomOffset,
        minNativeZoom = this.options.minNativeZoom,
        maxNativeZoom = this.options.maxNativeZoom; // decrease tile size when scaling below minNativeZoom


    if (minNativeZoom !== null && zoom < minNativeZoom) {
      return tileSize.divideBy(map.getZoomScale(minNativeZoom, zoom)).round();
    } // increase tile size when scaling above maxNativeZoom


    if (maxNativeZoom !== null && zoom > maxNativeZoom) {
      return tileSize.divideBy(map.getZoomScale(maxNativeZoom, zoom)).round();
    }

    return tileSize;
  },
  _onTileRemove: function (e) {
    e.tile.onload = null;
  },
  _getZoomForUrl: function () {
    var zoom = this._tileZoom,
        maxZoom = this.options.maxZoom,
        zoomReverse = this.options.zoomReverse,
        zoomOffset = this.options.zoomOffset,
        minNativeZoom = this.options.minNativeZoom,
        maxNativeZoom = this.options.maxNativeZoom;

    if (zoomReverse) {
      zoom = maxZoom - zoom;
    }

    zoom += zoomOffset;

    if (minNativeZoom !== null && zoom < minNativeZoom) {
      return minNativeZoom;
    }

    if (maxNativeZoom !== null && zoom > maxNativeZoom) {
      return maxNativeZoom;
    }

    return zoom;
  },
  _getSubdomain: function (tilePoint) {
    var index = Math.abs(tilePoint.x + tilePoint.y) % this.options.subdomains.length;
    return this.options.subdomains[index];
  },
  // stops loading all tiles in the background layer
  _abortLoading: function () {
    var i, tile;

    for (i in this._tiles) {
      if (this._tiles[i].coords.z !== this._tileZoom) {
        tile = this._tiles[i].el;
        tile.onload = _BaseUtils["default"].falseFn;
        tile.onerror = _BaseUtils["default"].falseFn;

        if (!tile.complete) {
          tile.src = emptyImageUrl;

          _DomUtils["default"].remove(tile);
        }
      }
    }
  }
});

TileLayer.WMS = TileLayer.extend({
  // @section
  // @aka TileLayer.WMS options
  // If any custom options not documented here are used, they will be sent to the
  // WMS server as extra parameters in each request URL. This can be useful for
  // [non-standard vendor WMS parameters](http://docs.geoserver.org/stable/en/user/services/wms/vendor.html).
  defaultWmsParams: {
    service: 'WMS',
    request: 'GetMap',
    // @option layers: String = ''
    // **(required)** Comma-separated list of WMS layers to show.
    layers: '',
    // @option styles: String = ''
    // Comma-separated list of WMS styles.
    styles: '',
    // @option format: String = 'image/jpeg'
    // WMS image format (use `'image/png'` for layers with transparency).
    format: 'image/jpeg',
    // @option transparent: Boolean = false
    // If `true`, the WMS service will return images with transparency.
    transparent: false,
    // @option version: String = '1.1.1'
    // Version of the WMS service to use
    version: '1.1.1'
  },
  options: {
    // @option crs: CRS = null
    // Coordinate Reference System to use for the WMS requests, defaults to
    // map CRS. Don't change this if you're not sure what it means.
    crs: null,
    // @option uppercase: Boolean = false
    // If `true`, WMS request parameter keys will be uppercase.
    uppercase: false
  },
  initialize: function (url, options) {
    this._url = url;

    var wmsParams = _BaseUtils["default"].extend({}, this.defaultWmsParams); // all keys that are not TileLayer options go to WMS params


    for (var i in options) {
      if (!(i in this.options)) {
        wmsParams[i] = options[i];
      }
    }

    options = _BaseUtils["default"].setOptions(this, options);
    wmsParams.width = wmsParams.height = options.tileSize * (options.detectRetina && _Browser["default"].retina ? 2 : 1);
    this.wmsParams = wmsParams;
  },
  onAdd: function (map) {
    this._crs = this.options.crs || map.options.crs;
    this._wmsVersion = parseFloat(this.wmsParams.version);
    var projectionKey = this._wmsVersion >= 1.3 ? 'crs' : 'srs';
    this.wmsParams[projectionKey] = this._crs.code;
    TileLayer.prototype.onAdd.call(this, map);
  },
  getTileUrl: function (coords) {
    var tileBounds = this._tileCoordsToBounds(coords),
        nw = this._crs.project(tileBounds.getNorthWest()),
        se = this._crs.project(tileBounds.getSouthEast()),
        bbox = (this._wmsVersion >= 1.3 && this._crs === _CRS["default"].EPSG4326 ? [se.y, nw.x, nw.y, se.x] : [nw.x, se.y, se.x, nw.y]).join(','),
        url = TileLayer.prototype.getTileUrl.call(this, coords);

    return url + _BaseUtils["default"].getParamString(this.wmsParams, url, this.options.uppercase) + (this.options.uppercase ? '&BBOX=' : '&bbox=') + bbox;
  },
  // @method setParams(params: Object, noRedraw?: Boolean): this
  // Merges an object with the new parameters and re-requests tiles on the current screen (unless `noRedraw` was set to true).
  setParams: function (params, noRedraw) {
    _BaseUtils["default"].extend(this.wmsParams, params);

    if (!noRedraw) {
      this.redraw();
    }

    return this;
  }
});
var _default = TileLayer;
exports["default"] = _default;

/***/ }),
/* 177 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _Bounds = _interopRequireDefault(__webpack_require__(21));

var _LatLngBounds = _interopRequireDefault(__webpack_require__(34));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/1/20.
 */
var GridLayer = _Layer["default"].extend({
  // @section
  // @aka GridLayer options
  options: {
    // @option tileSize: Number|Point = 256
    // Width and height of tiles in the grid. Use a number if width and height are equal, or `L.point(width, height)` otherwise.
    tileSize: 256,
    // @option opacity: Number = 1.0
    // Opacity of the tiles. Can be used in the `createTile()` function.
    opacity: 1,
    // @option updateWhenIdle: Boolean = depends
    // If `false`, new tiles are loaded during panning, otherwise only after it (for better performance). `true` by default on mobile browsers, otherwise `false`.
    updateWhenIdle: _Browser["default"].mobile,
    // @option updateWhenZooming: Boolean = true
    // By default, a smooth zoom animation (during a [touch zoom](#map-touchzoom) or a [`flyTo()`](#map-flyto)) will update grid layers every integer zoom level. Setting this option to `false` will update the grid layer only when the smooth animation ends.
    updateWhenZooming: true,
    // @option updateInterval: Number = 200
    // Tiles will not update more than once every `updateInterval` milliseconds when panning.
    updateInterval: 200,
    // @option zIndex: Number = 1
    // The explicit zIndex of the tile layer.
    zIndex: 1,
    // @option bounds: LatLngBounds = undefined
    // If set, tiles will only be loaded inside the set `LatLngBounds`.
    bounds: null,
    // @option minZoom: Number = 0
    // The minimum zoom level that tiles will be loaded at. By default the entire map.
    minZoom: 0,
    // @option maxZoom: Number = undefined
    // The maximum zoom level that tiles will be loaded at.
    maxZoom: undefined,
    // @option noWrap: Boolean = false
    // Whether the layer is wrapped around the antimeridian. If `true`, the
    // GridLayer will only be displayed once at low zoom levels. Has no
    // effect when the [map CRS](#map-crs) doesn't wrap around.
    noWrap: false,
    // @option pane: String = 'tilePane'
    // `Map pane` where the grid layer will be added.
    pane: 'tilePane',
    // @option className: String = ''
    // A custom class name to assign to the tile layer. Empty by default.
    className: '',
    // @option keepBuffer: Number = 2
    // When panning the map, keep this many rows and columns of tiles before unloading them.
    keepBuffer: 2
  },
  initialize: function (options) {
    _BaseUtils["default"].setOptions(this, options);
  },
  onAdd: function () {
    this._initContainer();

    this._levels = {};
    this._tiles = {};

    this._resetView();

    this._update();
  },
  beforeAdd: function (map) {
    map._addZoomLimit(this);
  },
  onRemove: function (map) {
    this._removeAllTiles();

    _DomUtils["default"].remove(this._container);

    map._removeZoomLimit(this);

    this._container = null;
    this._tileZoom = null;
  },
  // @method bringToFront: this
  // Brings the tile layer to the top of all tile layers.
  bringToFront: function () {
    if (this._map) {
      _DomUtils["default"].toFront(this._container);

      this._setAutoZIndex(Math.max);
    }

    return this;
  },
  // @method bringToBack: this
  // Brings the tile layer to the bottom of all tile layers.
  bringToBack: function () {
    if (this._map) {
      _DomUtils["default"].toBack(this._container);

      this._setAutoZIndex(Math.min);
    }

    return this;
  },
  // @method getContainer: HTMLElement
  // Returns the HTML element that contains the tiles for this layer.
  getContainer: function () {
    return this._container;
  },
  // @method setOpacity(opacity: Number): this
  // Changes the [opacity](#gridlayer-opacity) of the grid layer.
  setOpacity: function (opacity) {
    this.options.opacity = opacity;

    this._updateOpacity();

    return this;
  },
  // @method setZIndex(zIndex: Number): this
  // Changes the [zIndex](#gridlayer-zindex) of the grid layer.
  setZIndex: function (zIndex) {
    this.options.zIndex = zIndex;

    this._updateZIndex();

    return this;
  },
  // @method isLoading: Boolean
  // Returns `true` if any tile in the grid layer has not finished loading.
  isLoading: function () {
    return this._loading;
  },
  // @method redraw: this
  // Causes the layer to clear all the tiles and request them again.
  redraw: function () {
    if (this._map) {
      this._removeAllTiles();

      this._update();
    }

    return this;
  },
  getEvents: function () {
    var events = {
      viewprereset: this._invalidateAll,
      viewreset: this._resetView,
      zoom: this._resetView,
      panend: this._onPanEnd,
      moveend: this._update // update tile layer when resize map chart

    };

    if (!this.options.updateWhenIdle) {
      // update tiles on move, but not more often than once per given interval
      if (!this._onPanMove) {
        this._onPanMove = _BaseUtils["default"].throttle(this._onPanEnd, this.options.updateInterval, this);
      }

      events.panmove = this._onPanMove;
    }

    if (this._zoomAnimated) {
      events.zoomanim = this._animateZoom;
    }

    return events;
  },
  // @section Extension methods
  // Layers extending `GridLayer` shall reimplement the following method.
  // @method createTile(coords: Object, done?: Function): HTMLElement
  // Called only internally, must be overriden by classes extending `GridLayer`.
  // Returns the `HTMLElement` corresponding to the given `coords`. If the `done` callback
  // is specified, it must be called when the tile has finished loading and drawing.
  createTile: function () {
    return document.createElement('div');
  },
  // @section
  // @method getTileSize: Point
  // Normalizes the [tileSize option](#gridlayer-tilesize) into a point. Used by the `createTile()` method.
  getTileSize: function () {
    var s = this.options.tileSize;
    return s instanceof _Point2D["default"] ? s : new _Point2D["default"](s, s);
  },
  _updateZIndex: function () {
    if (this._container && this.options.zIndex !== undefined && this.options.zIndex !== null) {
      this._container.style.zIndex = this.options.zIndex;
    }
  },
  _setAutoZIndex: function (compare) {
    // go through all other layers of the same pane, set zIndex to max + 1 (front) or min - 1 (back)
    var layers = this.getPane().children,
        edgeZIndex = -compare(-Infinity, Infinity); // -Infinity for max, Infinity for min

    for (var i = 0, len = layers.length, zIndex; i < len; i++) {
      zIndex = layers[i].style.zIndex;

      if (layers[i] !== this._container && zIndex) {
        edgeZIndex = compare(edgeZIndex, +zIndex);
      }
    }

    if (isFinite(edgeZIndex)) {
      this.options.zIndex = edgeZIndex + compare(-1, 1);

      this._updateZIndex();
    }
  },
  _updateOpacity: function () {
    if (!this._map) {
      return;
    } // IE doesn't inherit filter opacity properly, so we're forced to set it on tiles


    if (_Browser["default"].ielt9) {
      return;
    }

    _DomUtils["default"].setOpacity(this._container, this.options.opacity);

    var now = +new Date(),
        nextFrame = false,
        willPrune = false;

    for (var key in this._tiles) {
      var tile = this._tiles[key];

      if (!tile.current || !tile.loaded) {
        continue;
      }

      var fade = Math.min(1, (now - tile.loaded) / 200);

      _DomUtils["default"].setOpacity(tile.el, fade);

      if (fade < 1) {
        nextFrame = true;
      } else {
        if (tile.active) {
          willPrune = true;
        }

        tile.active = true;
      }
    }

    if (willPrune && !this._noPrune) {
      this._pruneTiles();
    }

    if (nextFrame) {
      _BaseUtils["default"].cancelAnimFrame(this._fadeFrame);

      this._fadeFrame = _BaseUtils["default"].requestAnimFrame(this._updateOpacity, this);
    }
  },
  _initContainer: function () {
    if (this._container) {
      return;
    }

    this._container = _DomUtils["default"].create('div', 'leaflet-layer ' + (this.options.className || ''));

    this._updateZIndex();

    if (this.options.opacity < 1) {
      this._updateOpacity();
    }

    this.getPane().appendChild(this._container);
  },
  _updateLevels: function () {
    var zoom = this._tileZoom,
        maxZoom = this.options.maxZoom;

    if (zoom === undefined) {
      return undefined;
    }

    for (var z in this._levels) {
      if (this._levels[z].el.children.length || z === zoom) {
        this._levels[z].el.style.zIndex = maxZoom - Math.abs(zoom - z);
      } else {
        _DomUtils["default"].remove(this._levels[z].el);

        this._removeTilesAtZoom(z);

        delete this._levels[z];
      }
    }

    var level = this._levels[zoom],
        map = this._map;

    if (!level) {
      level = this._levels[zoom] = {};
      level.el = _DomUtils["default"].create('div', 'leaflet-tile-container leaflet-zoom-animated', this._container);
      level.el.style.zIndex = maxZoom;
      level.origin = map.project(map.unproject(map.getPixelOrigin()), zoom).round();
      level.zoom = zoom;

      this._setZoomTransform(level, map.getCenter(), map.getZoom()); // force the browser to consider the newly added element for transition


      _BaseUtils["default"].falseFn(level.el.offsetWidth);
    }

    this._level = level;
    return level;
  },
  _pruneTiles: function () {
    if (!this._map) {
      return;
    }

    var key, tile;

    var zoom = this._map.getZoom();

    if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {
      this._removeAllTiles();

      return;
    }

    for (key in this._tiles) {
      tile = this._tiles[key];
      tile.retain = tile.current;
    }

    for (key in this._tiles) {
      tile = this._tiles[key];

      if (tile.current && !tile.active) {
        var coords = tile.coords;

        if (!this._retainParent(coords.x, coords.y, coords.z, coords.z - 5)) {
          this._retainChildren(coords.x, coords.y, coords.z, coords.z + 2);
        }
      }
    }

    for (key in this._tiles) {
      if (!this._tiles[key].retain) {
        this._removeTile(key);
      }
    }
  },
  _removeTilesAtZoom: function (zoom) {
    for (var key in this._tiles) {
      if (this._tiles[key].coords.z !== zoom) {
        continue;
      }

      this._removeTile(key);
    }
  },
  _removeAllTiles: function () {
    for (var key in this._tiles) {
      this._removeTile(key);
    }
  },
  _invalidateAll: function () {
    for (var z in this._levels) {
      _DomUtils["default"].remove(this._levels[z].el);

      delete this._levels[z];
    }

    this._removeAllTiles();

    this._tileZoom = null;
  },
  _retainParent: function (x, y, z, minZoom) {
    var x2 = Math.floor(x / 2),
        y2 = Math.floor(y / 2),
        z2 = z - 1,
        coords2 = new _Point2D["default"](+x2, +y2);
    coords2.z = +z2;

    var key = this._tileCoordsToKey(coords2),
        tile = this._tiles[key];

    if (tile && tile.active) {
      tile.retain = true;
      return true;
    } else if (tile && tile.loaded) {
      tile.retain = true;
    }

    if (z2 > minZoom) {
      return this._retainParent(x2, y2, z2, minZoom);
    }

    return false;
  },
  _retainChildren: function (x, y, z, maxZoom) {
    for (var i = 2 * x; i < 2 * x + 2; i++) {
      for (var j = 2 * y; j < 2 * y + 2; j++) {
        var coords = new _Point2D["default"](i, j);
        coords.z = z + 1;

        var key = this._tileCoordsToKey(coords),
            tile = this._tiles[key];

        if (tile && tile.active) {
          tile.retain = true;
          continue;
        } else if (tile && tile.loaded) {
          tile.retain = true;
        }

        if (z + 1 < maxZoom) {
          this._retainChildren(i, j, z + 1, maxZoom);
        }
      }
    }
  },
  _resetView: function (e) {
    var animating = e && (e.pinch || e.flyTo);

    this._setView(this._map.getCenter(), this._map.getZoom(), animating, animating);
  },
  _animateZoom: function (e) {
    this._setView(e.center, e.zoom, true, e.noUpdate);
  },
  _setView: function (center, zoom, noPrune, noUpdate) {
    var tileZoom = Math.round(zoom);

    if (this.options.maxZoom !== undefined && tileZoom > this.options.maxZoom || this.options.minZoom !== undefined && tileZoom < this.options.minZoom) {
      tileZoom = undefined;
    }

    var tileZoomChanged = this.options.updateWhenZooming && tileZoom !== this._tileZoom;

    if (!noUpdate || tileZoomChanged) {
      this._tileZoom = tileZoom;

      if (this._abortLoading) {
        this._abortLoading();
      }

      this._updateLevels();

      this._resetGrid();

      if (tileZoom !== undefined) {
        this._update(center);
      }

      if (!noPrune) {
        this._pruneTiles();
      } // Flag to prevent _updateOpacity from pruning tiles during
      // a zoom anim or a pinch gesture


      this._noPrune = !!noPrune;
    }

    this._setZoomTransforms(center, zoom);
  },
  _setZoomTransforms: function (center, zoom) {
    for (var i in this._levels) {
      this._setZoomTransform(this._levels[i], center, zoom);
    }
  },
  _setZoomTransform: function (level, center, zoom) {
    var scale = this._map.getZoomScale(zoom, level.zoom),
        translate = level.origin.multiplyBy(scale).subtract(this._map._getNewPixelOrigin(center, zoom)).round();

    if (_Browser["default"].any3d) {
      _DomUtils["default"].setTransform(level.el, translate, scale);
    } else {
      _DomUtils["default"].setPosition(level.el, translate);
    }
  },
  _resetGrid: function () {
    var map = this._map,
        crs = map.options.crs,
        tileSize = this._tileSize = this.getTileSize(),
        tileZoom = this._tileZoom;

    var bounds = this._map.getPixelWorldBounds(this._tileZoom);

    if (bounds) {
      this._globalTileRange = this._pxBoundsToTileRange(bounds);
    }

    this._wrapX = crs.wrapLng && !this.options.noWrap && [Math.floor(map.project([0, crs.wrapLng[0]], tileZoom).x / tileSize.x), Math.ceil(map.project([0, crs.wrapLng[1]], tileZoom).x / tileSize.y)];
    this._wrapY = crs.wrapLat && !this.options.noWrap && [Math.floor(map.project([crs.wrapLat[0], 0], tileZoom).y / tileSize.x), Math.ceil(map.project([crs.wrapLat[1], 0], tileZoom).y / tileSize.y)];
  },
  _onPanEnd: function () {
    if (!this._map || this._map._animatingZoom) {
      return;
    }

    this._update();
  },
  _getTiledPixelBounds: function (center) {
    var map = this._map,
        mapZoom = map._animatingZoom ? Math.max(map._animateToZoom, map.getZoom()) : map.getZoom(),
        scale = map.getZoomScale(mapZoom, this._tileZoom),
        pixelCenter = map.project(center, this._tileZoom).floor(),
        halfSize = map.getSize().divideBy(scale * 2);
    return new _Bounds["default"](pixelCenter.subtract(halfSize), pixelCenter.add(halfSize));
  },
  // Private method to load tiles in the grid's active zoom level according to map bounds
  _update: function (center) {
    var map = this._map;

    if (!map) {
      return;
    }

    var zoom = map.getZoom();

    if (center === undefined) {
      center = map.getCenter();
    }

    if (this._tileZoom === undefined) {
      return;
    } // if out of minzoom/maxzoom


    var pixelBounds = this._getTiledPixelBounds(center),
        tileRange = this._pxBoundsToTileRange(pixelBounds),
        tileCenter = tileRange.getCenter(),
        queue = [],
        margin = this.options.keepBuffer,
        noPruneRange = new _Bounds["default"](tileRange.getBottomLeft().subtract([margin, -margin]), tileRange.getTopRight().add([margin, -margin]));

    for (var key in this._tiles) {
      var c = this._tiles[key].coords;

      if (c.z !== this._tileZoom || !noPruneRange.contains(new _Point2D["default"](c.x, c.y))) {
        this._tiles[key].current = false;
      }
    } // _update just loads more tiles. If the tile zoom level differs too much
    // from the map's, let _setView reset levels and prune old tiles.


    if (Math.abs(zoom - this._tileZoom) > 1) {
      this._setView(center, zoom);

      return;
    } // create a queue of coordinates to load tiles from


    for (var j = tileRange.min.y; j <= tileRange.max.y; j++) {
      for (var i = tileRange.min.x; i <= tileRange.max.x; i++) {
        var coords = new _Point2D["default"](i, j);
        coords.z = this._tileZoom;

        if (!this._isValidTile(coords)) {
          continue;
        }

        var tile = this._tiles[this._tileCoordsToKey(coords)];

        if (tile) {
          tile.current = true;
        } else {
          queue.push(coords);
        }
      }
    } // sort tile queue to load tiles in order of their distance to center


    queue.sort(function (a, b) {
      return a.distanceTo(tileCenter) - b.distanceTo(tileCenter);
    });

    if (queue.length !== 0) {
      // if it's the first batch of tiles to load
      if (!this._loading) {
        this._loading = true; // @event loading: Event
        // Fired when the grid layer starts loading tiles.

        this.fire('loading');
      } // create DOM fragment to append tiles in one batch


      var fragment = document.createDocumentFragment();

      for (i = 0; i < queue.length; i++) {
        this._addTile(queue[i], fragment);
      }

      this._level.el.appendChild(fragment);
    }
  },
  _isValidTile: function (coords) {
    var crs = this._map.options.crs;

    if (!crs.infinite) {
      // don't load tile if it's out of bounds and not wrapped
      var bounds = this._globalTileRange;

      if (!crs.wrapLng && (coords.x < bounds.min.x || coords.x > bounds.max.x) || !crs.wrapLat && (coords.y < bounds.min.y || coords.y > bounds.max.y)) {
        return false;
      }
    }

    if (!this.options.bounds) {
      return true;
    } // don't load tile if it doesn't intersect the bounds in options


    var tileBounds = this._tileCoordsToBounds(coords);

    return _LatLngBounds["default"].create(this.options.bounds).overlaps(tileBounds);
  },
  _keyToBounds: function (key) {
    return this._tileCoordsToBounds(this._keyToTileCoords(key));
  },
  // converts tile coordinates to its geographical bounds
  _tileCoordsToBounds: function (coords) {
    var map = this._map,
        tileSize = this.getTileSize(),
        nwPoint = coords.scaleBy(tileSize),
        sePoint = nwPoint.add(tileSize),
        nw = map.unproject(nwPoint, coords.z),
        se = map.unproject(sePoint, coords.z);

    if (!this.options.noWrap) {
      nw = map.wrapLatLng(nw);
      se = map.wrapLatLng(se);
    }

    return new _LatLngBounds["default"](nw, se);
  },
  // converts tile coordinates to key for the tile cache
  _tileCoordsToKey: function (coords) {
    return coords.x + ':' + coords.y + ':' + coords.z;
  },
  // converts tile cache key to coordinates
  _keyToTileCoords: function (key) {
    var k = key.split(':'),
        coords = new _Point2D["default"](+k[0], +k[1]);
    coords.z = +k[2];
    return coords;
  },
  _removeTile: function (key) {
    var tile = this._tiles[key];

    if (!tile) {
      return;
    }

    _DomUtils["default"].remove(tile.el);

    delete this._tiles[key]; // @event tileunload: TileEvent
    // Fired when a tile is removed (e.g. when a tile goes off the screen).

    this.fire('tileunload', {
      tile: tile.el,
      coords: this._keyToTileCoords(key)
    });
  },
  _initTile: function (tile) {
    _DomUtils["default"].addClass(tile, 'leaflet-tile');

    var tileSize = this.getTileSize(); //瓦片缩放等级4，地图缩放等级3.5。tilepane缩放，图片之间有间隙。
    //如果初始化时mapZoom和tileZoom相等，缩放时，还是会出现间隙，所以修改为都默认加1。

    tile.style.width = tileSize.x + 1 + 'px';
    tile.style.height = tileSize.y + 1 + 'px';
    tile.onselectstart = _BaseUtils["default"].falseFn;
    tile.onmousemove = _BaseUtils["default"].falseFn; // update opacity on tiles in IE7-8 because of filter inheritance problems

    if (_Browser["default"].ielt9 && this.options.opacity < 1) {
      _DomUtils["default"].setOpacity(tile, this.options.opacity);
    } // without this hack, tiles disappear after zoom on Chrome for Android
    // https://github.com/Leaflet/Leaflet/issues/2078


    if (_Browser["default"].android && !_Browser["default"].android23) {
      tile.style.WebkitBackfaceVisibility = 'hidden';
    }
  },
  _addTile: function (coords, container) {
    var tilePos = this._getTilePos(coords),
        key = this._tileCoordsToKey(coords);

    var tile = this.createTile(this._wrapCoords(coords), _BaseUtils["default"].bind(this._tileReady, this, coords));

    this._initTile(tile); // if createTile is defined with a second argument ("done" callback),
    // we know that tile is async and will be ready later; otherwise


    if (this.createTile.length < 2) {
      // mark tile as ready, but delay one frame for opacity animation to happen
      _BaseUtils["default"].requestAnimFrame(_BaseUtils["default"].bind(this._tileReady, this, coords, null, tile));
    }

    _DomUtils["default"].setPosition(tile, tilePos); // save tile in cache


    this._tiles[key] = {
      el: tile,
      coords: coords,
      current: true
    };
    container.appendChild(tile); // @event tileloadstart: TileEvent
    // Fired when a tile is requested and starts loading.

    this.fire('tileloadstart', {
      tile: tile,
      coords: coords
    });
  },
  _tileReady: function (coords, err, tile) {
    if (!this._map) {
      return;
    }

    if (err) {
      // @event tileerror: TileErrorEvent
      // Fired when there is an error loading a tile.
      this.fire('tileerror', {
        error: err,
        tile: tile,
        coords: coords
      });
    }

    var key = this._tileCoordsToKey(coords);

    tile = this._tiles[key];

    if (!tile) {
      return;
    }

    tile.loaded = +new Date();

    if (this._map._fadeAnimated) {
      _DomUtils["default"].setOpacity(tile.el, 0);

      _BaseUtils["default"].cancelAnimFrame(this._fadeFrame);

      this._fadeFrame = _BaseUtils["default"].requestAnimFrame(this._updateOpacity, this);
    } else {
      tile.active = true;

      this._pruneTiles();
    }

    if (!err) {
      _DomUtils["default"].addClass(tile.el, 'leaflet-tile-loaded'); // @event tileload: TileEvent
      // Fired when a tile loads.


      this.fire('tileload', {
        tile: tile.el,
        coords: coords
      });
    }

    if (this._noTilesToLoad()) {
      this._loading = false; // @event load: Event
      // Fired when the grid layer loaded all visible tiles.

      this.fire('load');

      if (_Browser["default"].ielt9 || !this._map._fadeAnimated) {
        _BaseUtils["default"].requestAnimFrame(this._pruneTiles, this);
      } else {
        // Wait a bit more than 0.2 secs (the duration of the tile fade-in)
        // to trigger a pruning.
        setTimeout(_BaseUtils["default"].bind(this._pruneTiles, this), 250);
      }
    }
  },
  _getTilePos: function (coords) {
    return coords.scaleBy(this.getTileSize()).subtract(this._level.origin);
  },
  _wrapCoords: function (coords) {
    var newCoords = new _Point2D["default"](this._wrapX ? _BaseUtils["default"].wrapNum(coords.x, this._wrapX) : coords.x, this._wrapY ? _BaseUtils["default"].wrapNum(coords.y, this._wrapY) : coords.y);
    newCoords.z = coords.z;
    return newCoords;
  },
  _pxBoundsToTileRange: function (bounds) {
    var tileSize = this.getTileSize();
    return new _Bounds["default"](bounds.min.unscaleBy(tileSize).floor(), bounds.max.unscaleBy(tileSize).ceil().subtract([1, 1]));
  },
  _noTilesToLoad: function () {
    for (var key in this._tiles) {
      if (!this._tiles[key].loaded) {
        return false;
      }
    }

    return true;
  }
});

var _default = GridLayer;
exports["default"] = _default;

/***/ }),
/* 178 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _RangeLegend = _interopRequireDefault(__webpack_require__(179));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _component = __webpack_require__(4);

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Mitisky on 16/8/10.
 */
var MAX_PROPORTION = '30%';
var MIN_SIZE = 50;
var MAX_SIZE = 150;
var TEXT_SCALE = 0.75;
var SLIDER_THICK = 6;
var THUMB_RADIUS = 7;
var THUMB_HOVER_RADIUS = 8;
var THUMB_FILL = '#fff';
var BACKGROUND_STYLE = {
  'fill': '#eaeaea',
  'stroke-width': 0
};
var THUMB_FILTER = {
  dx: 0,
  dy: 0,
  opacity: 0.4,
  deviation: 4,
  r: 31 / 255,
  g: 74 / 255,
  b: 138 / 255
};
var BUTTON_TEXT_GAP = 2;
var HOVER_LABEL_MOVE = 1;
var GAP = 5;
var RESPONSE_SEGMENT_NUM = 5;
var MAX_INTERVAL_IN_LARGE = 10;

var LARGE_RANGE = _BaseUtils["default"].getTargetFillArray(MAX_INTERVAL_IN_LARGE, function (d, i) {
  return i / MAX_INTERVAL_IN_LARGE;
});

var PADDING = 5;

var PADDING_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING);
};

var GradientRangeLegend = _RangeLegend["default"].extend({
  type: _component.ComponentCst.GradientRangeLegend,
  initAttributesWithSeries: function () {
    var options = this.options,
        range = options.range || {};
    this.valueAndColors = range.color || this._getDefaultValueAndColors();
    var minValue = range.min,
        maxValue = range.max;

    if ((0, _CoreUtils.hasNotDefined)(minValue) || (0, _CoreUtils.hasNotDefined)(maxValue)) {
      var minMax = this.vanchart.getChartMinMaxValue();

      var para = _BaseUtils["default"].calculateAutoMinMaxAndGap(minMax[0], minMax[1], Math.max(2, this.valueAndColors.length - 1));

      minValue = para[0];
      maxValue = para[1];
    }

    this.min = _BaseUtils["default"].pick(range.min, minValue);
    this.max = _BaseUtils["default"].pick(range.max, maxValue);
    this.valueAndColors.sort(function (d1, d2) {
      return d1[0] - d2[0];
    });
    var valueArray = [];
    var colorArray = [];

    for (var i = 0, len = this.valueAndColors.length; i < len; i++) {
      valueArray[i] = this.valueAndColors[i][0];
      colorArray[i] = this.valueAndColors[i][1];
    }

    var largeValueScale = _Scale["default"].quantize().domain([this.min, this.max]).range(LARGE_RANGE);

    var self = this;

    this.largeValueScale = function (datum) {
      return self.min === self.max ? 0 : largeValueScale(datum); // 最大最小一样的时候，直接返回0，不计算了，没有意义
    };

    this.valueScale = _Scale["default"].linear().domain([this.min, this.max]).range([0, 1]);
    this.colorScale = _Scale["default"].linear().domain(valueArray).range(colorArray).interpolate(_interpolator["default"].interpolate).interpolate(_interpolator["default"].interpolate);
  },
  _getMin: function () {
    return this.min;
  },
  _getMax: function () {
    return this.max;
  },
  _getGradient: function () {
    var config = {};
    this.valueAndColors.forEach(function (v_c) {
      config[v_c[0]] = v_c[1];
    });
    return config;
  },
  _getDefaultValueAndColors: function () {
    var colors = _ColorUtils["default"].createColorsWithHsb(this.vanchart.options.colors[0], 3);

    return [[0, colors[2]], [0.5, colors[1]], [1, colors[0]]];
  },
  calculateHorizontalDim: function () {
    var _this$_getLabelDim = this._getLabelDim(),
        minLabelDim = _this$_getLabelDim.minLabelDim,
        maxLabelDim = _this$_getLabelDim.maxLabelDim;

    var maxProportion = this.options.maxHeight || MAX_PROPORTION;
    var width = 0;
    var height = THUMB_RADIUS * 2 + BUTTON_TEXT_GAP + Math.max(minLabelDim.height, maxLabelDim.height);
    height = Math.min(height, this._getPercentValue(maxProportion, this.vanchart.height));

    if (this.vanchart.isMobileFlow()) {
      width = this.vanchart.width - PADDING_FUN() * 2;
      this._trackLength = width - GAP * 2 - PADDING_FUN() * 2;
    } else {
      width = this._getSliderSize();
      this._trackLength = width - THUMB_RADIUS * 2;
    }

    return {
      width: width,
      height: height
    };
  },
  calculateVerticalDim: function () {
    var _this$_getLabelDim2 = this._getLabelDim(),
        minLabelDim = _this$_getLabelDim2.minLabelDim,
        maxLabelDim = _this$_getLabelDim2.maxLabelDim;

    var maxProportion = this.options.maxWidth || MAX_PROPORTION;
    var width = THUMB_RADIUS * 2 + BUTTON_TEXT_GAP + Math.max(minLabelDim.width, maxLabelDim.width);
    var height = 0;
    width = Math.min(width, this._getPercentValue(maxProportion, this.vanchart.width));

    if (this.vanchart.isMobileFlow()) {
      height = this.vanchart.height - PADDING_FUN() * 2;
      this._trackLength = height - GAP * 2 - PADDING_FUN() * 2;
    } else {
      height = this._getSliderSize();
      this._trackLength = height - THUMB_RADIUS * 2;
    }

    return {
      width: width,
      height: height
    };
  },
  _getSliderSize: function () {
    var bounds = this.vanchart.bounds;
    var vanchartSize = this.isHorizontal() ? bounds.width : bounds.height;
    var usableSize = Math.min(MAX_SIZE, Math.max(MIN_SIZE, vanchartSize));
    return usableSize - PADDING_FUN() * 2;
  },
  _getLabelDim: function () {
    var minLabelContent = this._getLabelFormatContent(this.min);

    var maxLabelContent = this._getLabelFormatContent(this.max);

    return {
      minLabelDim: _BaseUtils["default"].getTextDimension(minLabelContent, this.options.style, this.options.useHtml),
      maxLabelDim: _BaseUtils["default"].getTextDimension(maxLabelContent, this.options.style, this.options.useHtml)
    };
  },
  getColorWithSize: function (size, isLargeModel) {
    var valueScale = isLargeModel ? this.largeValueScale : this.valueScale;

    if (size >= this.min && size <= this.max) {
      return this.colorScale(valueScale(size));
    }

    return null;
  },
  _getLabelFormatContent: function (value) {
    var formatter = this.options.formatter;

    if (!formatter) {
      return value;
    }

    return _BaseUtils["default"].format(value, formatter);
  },
  _gradientScale: function (pos) {
    var trackLength = this._trackLength;

    if (!this.isHorizontal()) {
      // vertical
      pos = trackLength - pos;
    }

    var pct = pos / trackLength * 100 | 0;

    var unit = _BaseUtils["default"].accDiv(_BaseUtils["default"].accAdd(this.max, -this.min), 100);

    return _BaseUtils["default"].accAdd(_BaseUtils["default"].accMul(unit, pct), this.min);
  },
  _getGradientFillColor: function (renderer) {
    var isHorizontal = this.isHorizontal();
    var attrs = {
      'x1': '0%',
      'y1': isHorizontal ? '0%' : '100%',
      'x2': isHorizontal ? '100%' : '0%',
      'y2': '0%'
    };
    var stop = this.valueAndColors.map(function (valueAndColor) {
      return {
        'offset': valueAndColor[0],
        'stop-color': valueAndColor[1]
      };
    });

    if (this._bar.colorGradient) {
      renderer.updateColorGradient(this._bar.colorGradient, attrs, stop);
    } else {
      this._bar.colorGradient = renderer.colorGradient(attrs, stop);
    }

    return renderer.toPatternProperty(this._bar.colorGradient);
  },
  _updateClipRect: function () {
    var legend = this,
        vanchart = legend.vanchart,
        renderer = vanchart.renderer;
    var rect;

    if (this.isHorizontal()) {
      rect = {
        'x': this.minPos,
        'y': 0,
        'width': this.maxPos - this.minPos,
        'height': SLIDER_THICK
      };
    } else {
      rect = {
        'x': 0,
        'y': this.minPos,
        'width': SLIDER_THICK,
        'height': this.maxPos - this.minPos
      };
    }

    if (!this._bar.clipG) {
      this._bar.clipG = renderer.createClip(rect);
      renderer.clip(this._bar, this._bar.clipG);
    } else {
      renderer.updateClip(this._bar.clipG, rect);
    }
  },
  renderBody: function (barGroup, bounds) {
    this._initLegendState();

    this._initLegendElement(barGroup, bounds);

    this._initLegendStyle();

    this._updateLegendBar(true);

    this._updateLegendBar(false);
  },
  _initLegendState: function () {
    this.minPos = 0;
    this.maxPos = this._trackLength;
    this.isMinButtonOnHover = false;
    this.isMaxButtonOnHover = false;
  },
  _initLegendElement: function (barGroup, bounds) {
    var renderer = this.vanchart.renderer;
    var isHorizontal = this.isHorizontal();
    var trackLength = this._trackLength;
    var transX = isHorizontal ? (bounds.width - trackLength) / 2 : PADDING_FUN() + THUMB_RADIUS - SLIDER_THICK / 2;
    var transY = isHorizontal ? bounds.height - PADDING_FUN() - THUMB_RADIUS - SLIDER_THICK / 2 : (bounds.height - trackLength) / 2;
    barGroup.attr('transform', _BaseUtils["default"].makeTranslate([transX, transY]));
    this._absX = bounds.x + transX;
    this._absY = bounds.y + transY;
    this._barBackground = this._barBackground || barGroup.append(renderer.rect());
    this._bar = this._bar || barGroup.append(renderer.rect());
    this._minButton = this._minButton || barGroup.append(renderer.circle().style({
      'cursor': 'pointer'
    }));
    this._maxButton = this._maxButton || barGroup.append(renderer.circle().style({
      'cursor': 'pointer'
    }));
    this._minLabel = this._minLabel || barGroup.append(renderer.vtext(this.useHtmlLabel()));
    this._maxLabel = this._maxLabel || barGroup.append(renderer.vtext(this.useHtmlLabel()));
  },
  _initLegendStyle: function () {
    var renderer = this.vanchart.renderer;
    var isHorizontal = this.isHorizontal();
    var trackLength = this._trackLength;
    var slider = {
      'rx': SLIDER_THICK / 2,
      'ry': SLIDER_THICK / 2,
      'x': 0,
      'y': 0,
      'width': isHorizontal ? trackLength : SLIDER_THICK,
      'height': isHorizontal ? SLIDER_THICK : trackLength
    };

    this._barBackground.style(BACKGROUND_STYLE).attr(slider);

    this._bar.attr(slider).style({
      'fill': this._getGradientFillColor(renderer),
      'stroke-width': 0
    }); // todo ie下特殊处理下filter


    if (!(0, _EnvUtils.isSupportSVG)()) {
      renderer._updateGradientFill(this._bar, this._bar.colorGradient);
    }

    var thumbStyle = {
      fill: THUMB_FILL,
      filter: this._getShadowFilter()
    };

    this._minButton.attr('r', THUMB_RADIUS).style(thumbStyle);

    this._maxButton.attr('r', THUMB_RADIUS).style(thumbStyle);

    this._minLabel.attr('dy', '.85em').style(this.options.style);

    this._maxLabel.attr('dy', '.85em').style(this.options.style);
  },
  _getShadowFilter: function () {
    var legend = this,
        vanchart = legend.vanchart,
        renderer = vanchart.renderer;
    var dx = THUMB_FILTER.dx,
        dy = THUMB_FILTER.dy,
        opacity = THUMB_FILTER.opacity,
        deviation = THUMB_FILTER.deviation,
        r = THUMB_FILTER.r,
        g = THUMB_FILTER.g,
        b = THUMB_FILTER.b;
    vanchart.gradientLegendShadowFilter = vanchart.gradientLegendShadowFilter || renderer.createDropShadowFilter(dx, dy, opacity, deviation, r, g, b);
    return renderer.toPatternProperty(vanchart.gradientLegendShadowFilter);
  },
  _updateLegendBar: function (isMinThumb) {
    var _this$_getUpdateProp = this._getUpdateProp(isMinThumb),
        buttonElement = _this$_getUpdateProp.buttonElement,
        labelElement = _this$_getUpdateProp.labelElement,
        pos = _this$_getUpdateProp.pos,
        onHover = _this$_getUpdateProp.onHover;

    buttonElement.attr('r', onHover ? THUMB_HOVER_RADIUS : THUMB_RADIUS).attr('transform', _BaseUtils["default"].makeTranslate(this._getButtonRelativePos(pos)));

    var label = this._getLabelFormatContent(this._gradientScale(pos));

    var labelDim = _BaseUtils["default"].getTextDimension(label, this.options.style, true);

    var labelPos = this._getLabelPos(isMinThumb, labelDim, pos, onHover);

    labelElement.textContent(label).attr('transform', _BaseUtils["default"].makeTranslate(labelPos));

    this._updateClipRect();
  },
  _getUpdateProp: function (isMinThumb) {
    var horizontal = this.isHorizontal();

    if (isMinThumb) {
      return {
        buttonElement: this._minButton,
        labelElement: this._minLabel,
        pos: horizontal ? this.minPos : this.maxPos,
        onHover: this.isMinButtonOnHover
      };
    }

    return {
      buttonElement: this._maxButton,
      labelElement: this._maxLabel,
      pos: horizontal ? this.maxPos : this.minPos,
      onHover: this.isMaxButtonOnHover
    };
  },
  _getButtonRelativePos: function (pos) {
    if (this.isHorizontal()) {
      return [pos, SLIDER_THICK / 2];
    }

    return [SLIDER_THICK / 2, pos];
  },
  _getButtonAbsolutePos: function () {
    var minButtonPos, maxButtonPos;

    if (this.isHorizontal()) {
      minButtonPos = {
        x: this._absX + this.minPos,
        y: this._absY + SLIDER_THICK / 2
      };
      maxButtonPos = {
        x: this._absX + this.maxPos,
        y: this._absY + SLIDER_THICK / 2
      };
    } else {
      minButtonPos = {
        x: this._absX + SLIDER_THICK / 2,
        y: this._absY + this.maxPos
      };
      maxButtonPos = {
        x: this._absX + SLIDER_THICK / 2,
        y: this._absY + this.minPos
      };
    }

    return {
      minButtonPos: minButtonPos,
      maxButtonPos: maxButtonPos
    };
  },
  _getLabelPos: function (isMinThumb, labelDim, pos, onHover) {
    var hoverMove = onHover ? HOVER_LABEL_MOVE : 0;

    if (this.isHorizontal()) {
      var x = isMinThumb ? Math.max(Math.round(this.minPos - labelDim.width), -THUMB_RADIUS) : Math.min(Math.round(this.maxPos), this._trackLength + THUMB_RADIUS - labelDim.width);
      var y = Math.round(SLIDER_THICK / 2 - THUMB_RADIUS - BUTTON_TEXT_GAP - labelDim.height * TEXT_SCALE - hoverMove);
      return [x, y];
    } else {
      var _x = Math.round(SLIDER_THICK / 2 + THUMB_RADIUS + BUTTON_TEXT_GAP + hoverMove);

      var _y = Math.round(pos - labelDim.height * TEXT_SCALE / 2);

      return [_x, _y];
    }
  },
  getEvents: function () {
    return {
      "mouseover": this._onMouseOver,
      "mouseout": this._onMouseOut,
      "panstart": this._panStart,
      "panmove": this._panMove,
      "panend": this._panEnd
    };
  },
  _onMouseOver: function (ev) {
    this._updateHoverState(this._findMouseTarget(ev), true);
  },
  _onMouseOut: function () {
    if (this.eventTarget == null) {
      this.isMinButtonOnHover = false;
      this.isMaxButtonOnHover = false;

      this._updateLegendBar(true);

      this._updateLegendBar(false);
    }
  },
  _panStart: function (ev) {
    if (this.options.panStart) {
      _BaseUtils["default"].getFormatterFunction(this.options.panStart)();

      return;
    }

    this.eventTarget = this._findDraggableTarget(ev);

    this._updateHoverState(this.eventTarget, true);
  },
  // 寻找可拖拽的事件对象
  _findDraggableTarget: function (ev) {
    this.currentX = ev.containerPoint.x;
    this.currentY = ev.containerPoint.y;

    var _this$_getButtonAbsol = this._getButtonAbsolutePos(),
        minButtonPos = _this$_getButtonAbsol.minButtonPos,
        maxButtonPos = _this$_getButtonAbsol.maxButtonPos;

    if (this.isHorizontal()) {
      var segment = (maxButtonPos.x - minButtonPos.x) / RESPONSE_SEGMENT_NUM;

      if (this.currentX < minButtonPos.x + segment) {
        return this._minButton;
      }

      if (this.currentX > maxButtonPos.x - segment) {
        return this._maxButton;
      }
    } else {
      var _segment = (minButtonPos.y - maxButtonPos.y) / RESPONSE_SEGMENT_NUM;

      if (this.currentY > minButtonPos.y - _segment) {
        return this._minButton;
      }

      if (this.currentY < maxButtonPos.y + _segment) {
        return this._maxButton;
      }
    }
  },
  // 寻找位于小球内的鼠标事件对象
  _findMouseTarget: function (ev) {
    this.currentX = ev.containerPoint.x;
    this.currentY = ev.containerPoint.y;

    var _this$_getButtonAbsol2 = this._getButtonAbsolutePos(),
        minButtonPos = _this$_getButtonAbsol2.minButtonPos,
        maxButtonPos = _this$_getButtonAbsol2.maxButtonPos;

    if (this._isButtonInside(minButtonPos.x, minButtonPos.y, THUMB_RADIUS, this.currentX, this.currentY)) {
      return this._minButton;
    }

    if (this._isButtonInside(maxButtonPos.x, maxButtonPos.y, THUMB_RADIUS, this.currentX, this.currentY)) {
      return this._maxButton;
    }
  },
  _isButtonInside: function (centerX, centerY, radius, currentX, currentY) {
    var distance = Math.pow(Math.pow(currentX - centerX, 2) + Math.pow(currentY - centerY, 2), 0.5);
    return distance < radius;
  },
  _updateHoverState: function (target, isOnHover) {
    if (target === this._minButton) {
      this.isMinButtonOnHover = isOnHover;

      this._updateLegendBar(true);
    }

    if (target === this._maxButton) {
      this.isMaxButtonOnHover = isOnHover;

      this._updateLegendBar(false);
    }
  },
  _panMove: function (ev) {
    if (this.eventTarget === this._minButton) {
      this._dealButtonMove(true, ev.containerPoint.x, ev.containerPoint.y);
    }

    if (this.eventTarget === this._maxButton) {
      this._dealButtonMove(false, ev.containerPoint.x, ev.containerPoint.y);
    }
  },
  _dealButtonMove: function (isMinThumb, currentX, currentY) {
    var _ref = [this.currentX, this.currentY],
        lastX = _ref[0],
        lastY = _ref[1];
    var horizontal = this.isHorizontal();
    var change = horizontal ? Math.round(currentX - lastX) : Math.round(currentY - lastY);

    if (isMinThumb && horizontal || !isMinThumb && !horizontal) {
      var pos = this.minPos;
      this.minPos += change;
      this.minPos = Math.max(this.minPos, 0);
      this.minPos = Math.min(this.minPos, this.maxPos);
      change = this.minPos - pos;
    }

    if (isMinThumb && !horizontal || !isMinThumb && horizontal) {
      var _pos = this.maxPos;
      this.maxPos += change;
      this.maxPos = Math.min(this.maxPos, this._trackLength);
      this.maxPos = Math.max(this.maxPos, this.minPos);
      change = this.maxPos - _pos;
    }

    this._checkButtonMove(isMinThumb, change, currentX, currentY);
  },
  _checkButtonMove: function (isMinThumb, change, currentX, currentY) {
    if (Math.abs(change) >= 1) {
      this.currentX = currentX;
      this.currentY = currentY;

      this._updateLegendBar(isMinThumb);

      this.refreshPoints();
    }
  },
  _panEnd: function (ev) {
    if (this._findMouseTarget(ev) == null) {
      this.isMinButtonOnHover = false;
      this.isMaxButtonOnHover = false;

      this._updateLegendBar(true);

      this._updateLegendBar(false);
    }

    this.eventTarget = null;
  },
  refreshPoints: function () {
    var minSize = this._gradientScale(this.minPos);

    var maxSize = this._gradientScale(this.maxPos);

    var vanChart = this.vanchart,
        series = vanChart.series;
    var change = false;

    for (var i = 0, len = series.length; i < len; i++) {
      var sery = series[i];
      sery.points.forEach(function (point) {
        var temp = point.visible;
        var size = point.getTargetValue();
        point.visible = size >= minSize && size <= maxSize || size >= maxSize && size <= minSize;
        change = change || temp != point.visible;
      });
    }

    if (change) {
      vanChart.filterRender();
    }
  },
  isPanMovingAtTheBoundary: function (ev) {
    var direction = ev.direction;
    var leftward = direction === _Constants["default"].DIRECTION_LEFT,
        rightward = direction === _Constants["default"].DIRECTION_RIGHT,
        upward = direction === _Constants["default"].DIRECTION_UP,
        downward = direction === _Constants["default"].DIRECTION_DOWN;
    var target = this.eventTarget,
        maxButton = this._maxButton,
        minButton = this._minButton;
    var maxPos = this.maxPos,
        minPos = this.minPos;
    var isMinMeetMax = minPos === maxPos;

    if (this.isHorizontal()) {
      switch (target) {
        case maxButton:
          return leftward && isMinMeetMax || rightward && maxPos === this._trackLength;

        case minButton:
          return leftward && minPos === 0 || rightward && isMinMeetMax;
      }
    } else {
      switch (target) {
        case minButton:
          return upward && isMinMeetMax || downward && maxPos === this._trackLength;

        case maxButton:
          return upward && minPos === 0 || downward && isMinMeetMax;
      }
    }

    return false;
  }
});

var _default = GradientRangeLegend;
exports["default"] = _default;

/***/ }),
/* 179 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _helper = __webpack_require__(91);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Mitisky on 16/3/21.
 */
var PADDING = 5;

var PADDING_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING);
};

var RangeLegend = _Base["default"].extend({
  doLayout: function () {
    if (this.invisible()) {
      this.remove();
      return;
    }

    var cfg = this.options;
    var position = cfg.position || _Constants["default"].RIGHT;
    var gap = PADDING_FUN() * (this.isFloat ? 2 : 4); //*4: 两边*内外边距

    if (position == _Constants["default"].TOP || position == _Constants["default"].BOTTOM) {
      this._layoutHorizontal(position, gap);
    } else {
      this._layoutVertical(position, gap);
    } // flow 没有 zoom 缩放条


    if (!this.isFloat && !this.vanchart.isMobileFlow()) {
      var outGap = this.options.borderWidth + PADDING_FUN() * 2;
      this.bounds.x += outGap / 2;
      this.bounds.y += outGap / 2;
      this.bounds.width -= outGap;
      this.bounds.height -= outGap;

      if (position == _Constants["default"].BOTTOM) {
        var zoomComponent = this.vanchart.getComponent(_component.ComponentCst.ZOOM_COMPONENT);

        if (zoomComponent && zoomComponent.zoomToolEnabled() && zoomComponent.bounds) {
          this.bounds.y += zoomComponent.bounds.height || 0;
        }
      }

      if (position == _Constants["default"].RIGHT_TOP) {
        var tools = this.vanchart.getComponent(_component.ComponentCst.TOOLBAR_COMPONENT);

        if (tools) {
          this.bounds.y = Math.max(37, this.bounds.y);
        }
      }
    }
  },
  _layoutHorizontal: function (position, gap) {
    var dim = this.calculateHorizontalDim();
    var usedSize = dim.height + gap;
    usedSize = this.options.maxHeight ? Math.min(usedSize, this._maxHeight()) : Math.min(usedSize, this._maxLegendHeight());

    this._setComponentBounds(position, usedSize);

    var width = 0;

    if (this.vanchart.isMobileFlow()) {
      width = dim.width;
      this.bounds.x = (this.vanchart.width - width) / 2;
    } else {
      width = dim.width + gap;

      if (!this.isFloat) {
        this.bounds.x += Math.max((this.bounds.width - width) / 2, 0);
      }
    }

    this.bounds.width = width;
  },
  _layoutVertical: function (position, gap) {
    var dim = this.calculateVerticalDim();
    var usedSize = dim.width + gap;
    usedSize = this.options.maxWidth ? Math.min(usedSize, this._maxWidth()) : Math.min(usedSize, this._maxLegendWidth());

    this._setComponentBounds(position, usedSize);

    var height = 0;

    if (this.vanchart.isMobileFlow()) {
      height = dim.height;
      this.bounds.y = (this.vanchart.height - height) / 2;
    } else {
      height = dim.height + gap;

      if (!this.isFloat && (position == _Constants["default"].RIGHT || position == _Constants["default"].LEFT)) {
        this.bounds.y += Math.max((this.bounds.height - height) / 2, 0);
      } else if (!this.isFloat && position == _Constants["default"].RIGHT_BOTTOM) {
        this.bounds.y = Math.round(this.bounds.y + this.bounds.height - height);
      }
    }

    this.bounds.height = height;
  },
  render: function () {
    if (this.invisible()) {
      return;
    }

    var bounds = this.bounds,
        legend = this,
        vanchart = legend.vanchart,
        renderer = vanchart.renderer;

    if (bounds.width <= 0 || bounds.height <= 0) {
      //最大占比0
      return;
    }

    if (!this.group) {
      this.backgroundGroup = renderer.group().addTo(this.getComponentParentGroup());
      this.group = renderer.vgroup().add(this.getComponentParentGroup());
      this.legendGroup = this.group.append(renderer.vgroup());
    }

    var targetG;

    if (this.useHtmlLabel()) {
      targetG = this.legendGroup.divG.attr({
        'pointer-events': 'auto'
      });
    } else {
      targetG = this.legendGroup.renderG;
    }

    vanchart.registerInteractiveTarget(this, targetG);

    this._innerClip(this.group);

    this.group.attr('transform', _BaseUtils["default"].makeTranslate(bounds));
    var backgroundOptions = (0, _helper.fixBackgroundOptions)(vanchart, this.options);

    vanchart._renderRectangleBackground(this.backgroundGroup, backgroundOptions, bounds);

    this.renderBody(this.legendGroup, bounds);
  },
  getEvents: function () {
    return {
      'mouseout': this.mouseOut
    };
  },
  mouseOut: function () {
    if (this.highlighted) {
      this.vanchart.cancelLegendHighlight();
    }
  },
  remove: function () {
    this.group && this.group.remove();
    this.backgroundGroup && this.backgroundGroup.remove();
    this.group = this.items = this._barBackground = this._bar = this._minButton = this._maxButton = this._minLabel = this._maxLabel = this.backgroundGroup = null;
  },
  contains: function (containerPoint) {
    return this.bounds && _BaseUtils["default"].containsPoint(this.bounds, containerPoint);
  }
});

var _default = RangeLegend;
exports["default"] = _default;

/***/ }),
/* 180 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _component = __webpack_require__(4);

var _Legend = _interopRequireDefault(__webpack_require__(92));

var _LegendItem = _interopRequireDefault(__webpack_require__(93));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Mitisky on 16/8/10.
 */
var HEAT_MAP_RANGE_COLOR = {
  0: 'rgb(255,255,255)',
  0.25: 'rgb(0,0,255)',
  0.55: 'rgb(0,255,0)',
  0.85: 'rgb(255,255,0)',
  1: 'rgb(255,0,0)'
};

var IntervalRangeLegend = _Legend["default"].extend({
  type: _component.ComponentCst.INTERVAL_RANGE_LEGEND,
  initAttributesWithSeries: function () {
    var options = this.options,
        range = options.range || {};

    if (this._isAutoRange()) {
      //自动计算
      var splitNumber = range.splitNumber || 5;
      var color = range.color || this.vanchart.options.colors[0];
      var colors = this.vanchart.isHeatMap() ? ['rgb(0,0,255)', 'rgb(0,255,0)', 'rgb(255,255,0)', 'rgb(255,0,0)'] : _ColorUtils["default"].createColorsWithHsb(color, splitNumber);
      var minMax = this.vanchart.getChartMinMaxValue();

      var para = _BaseUtils["default"].calculateAutoMinMaxAndGap(minMax[0], minMax[1], splitNumber);

      var minValue = para[0];
      var gap = para[2];
      range = [];

      if (this.vanchart.isHeatMap()) {
        var sepPara = [0, 0.25, 0.55, 0.85, 1],
            valueRange = _BaseUtils["default"].accMul(gap, splitNumber);

        for (var i = 1; i < 5; i++) {
          range.push({
            from: _BaseUtils["default"].accAdd(minValue, _BaseUtils["default"].accMul(valueRange, sepPara[i - 1])),
            to: _BaseUtils["default"].accAdd(minValue, _BaseUtils["default"].accMul(valueRange, sepPara[i])),
            color: colors[i - 1]
          });
        }
      } else {
        for (var i = 0; i < splitNumber; i++) {
          range.push({
            from: _BaseUtils["default"].accAdd(minValue, _BaseUtils["default"].accMul(gap, splitNumber - i - 1)),
            to: _BaseUtils["default"].accAdd(minValue, _BaseUtils["default"].accMul(gap, splitNumber - i)),
            color: colors[i]
          });
        }
      }
    }

    this.items = this.items || [];
    var realLen = range.length;

    this._removeOldItems(this.items);

    this._initRangeLegendItem(realLen, range);

    this.items.length = realLen;
    var self = this,
        series = this.vanchart.series;
    this.items.sort(function (itemA, itemB) {
      var itemAMin = Math.min(itemA.from, itemA.to);
      var itemBMin = Math.min(itemB.from, itemB.to);
      return self.isHorizontal() ? itemAMin - itemBMin : itemBMin - itemAMin;
    });

    for (var i = 0, len = series.length; i < len; i++) {
      var sery = series[i],
          valueKey = sery.getTargetKey();
      var pointS = sery.points;
      pointS.forEach(function (point) {
        var size = point[valueKey];

        var item = self._getPointItem(size);

        if (item) {
          item.points.push(point);
          item.options.series = sery; //缓存一下数据点属于的那个item

          point._rangeItem = item;
        }
      });
    }
  },
  _removeOldItems: function (items) {
    if (!items.length) {
      return;
    }

    for (var i = 0; i < items.length; i++) {
      items[i].graphic && items[i].graphic.remove();
      items[i] = null;
    }
  },
  _initRangeLegendItem: function (realLen, range) {
    var options = this.options;
    var formatter = options.formatter;

    for (var index = 0; index < realLen; index++) {
      var band = range[index];

      var label = this._getIntervalLabelContent(band.from, band.to, formatter);

      var legendItemOptions = {
        color: band.color,
        bindName: label,
        itemName: label,
        visible: true,
        hiddenColor: options.hiddenColor,
        hoverColor: options.hoverColor,
        legendIconType: _Constants["default"].NORMAL_ICON,
        lineIndex: 0 //记录下如果换行的行号

      };
      var item = this.items[index] || new _LegendItem["default"](this, legendItemOptions);
      this.items[index] = item;
      item.legendType = this.type;
      item.from = band.from;
      item.to = band.to;
      item.color = band.color;
      item.label = label;
      item.visible = true;
      item.hiddenColor = options.hiddenColor;
      item.hoverColor = options.hoverColor;
      item.points = [];
      item.lineIndex = 0; //记录下如果换行的行号
    }
  },
  _updateLegendItems: function () {},
  _isAutoRange: function () {
    return !_BaseUtils["default"].isArray(this.options.range);
  },
  _getMin: function () {
    if (!this.items) {
      return;
    }

    var index = this.isHorizontal() ? 0 : this.items.length - 1;
    return this.items[index].from;
  },
  _getMax: function () {
    if (!this.items) {
      return;
    }

    var index = this.isHorizontal() ? this.items.length - 1 : 0;
    return this.items[index].to;
  },
  _getGradient: function () {
    if (!this.items) {
      return;
    }

    if (this._isAutoRange()) {
      return HEAT_MAP_RANGE_COLOR;
    }

    var config = {
      '0': 'white'
    };

    var min = this._getMin(),
        max = this._getMax(),
        det = (0, _CoreUtils.fixDivisor)(max - min);

    for (var i = this.items.length - 1; i >= 0; i--) {
      var item = this.items[i];
      config[(item.to - min) / det] = item.color;
    }

    return config;
  },
  _getIntervalLabelContent: function (from, to, formatter) {
    if (!formatter) {
      return from + '-' + to;
    }

    return _BaseUtils["default"].format({
      'from': from,
      'to': to
    }, formatter);
  },
  _getPointItem: function (size) {
    for (var i = 0, len = this.items.length; i < len; i++) {
      var item = this.items[i];
      var min = Math.min(item.from, item.to);
      var max = Math.max(item.from, item.to);

      if (size >= min && size <= max) {
        return item;
      }
    }
  },
  getColorWithSize: function (size) {
    var item = this._getPointItem(size);

    return item && item.color;
  }
});

var _default = IntervalRangeLegend;
exports["default"] = _default;

/***/ }),
/* 181 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _renderer = _interopRequireDefault(__webpack_require__(22));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

var _GradualColorUtils = __webpack_require__(42);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Cmen on 2017/6/20.
 */
var DEFAULT_PADDING = 6,
    DEFAULT_GAP = 5; // 边框和内容的显示和隐藏的deley

var MORELABEL_BORDER_INIT_TIME = 250,
    MORELABEL_CONTENT_INIT_TIME = 350,
    MORELABEL_CONTENT_REMOVE_TIME = 350,
    MORELABEL_BORDER_REMOVE_TIME = 250;
var MORELABEL_BORDER_INIT_EASE = _BezierEasing["default"].css["ease"],
    // 边框init
MORELABEL_BORDER_EXIT_EASE = _BezierEasing["default"].css["ease"],
    // 边框exit
MORELABEL_CONTENT_INIT_EASE = _BezierEasing["default"].css["ease"],
    // 内容Init
MORELABEL_CONTENT_EXIT_EASE = _BezierEasing["default"].css["ease"]; // 内容exit

var DIRECTION_TOP = "top",
    DIRECTION_LEFT = "left",
    DIRECTION_BOTTOM = "bottom",
    DIRECTION_RIGHT = "right",
    DIRECTION_LEFT_TOP = "left_top",
    DIRECTION_RIGHT_TOP = "right_top",
    DIRECTION_LEFT_BOTTOM = "left_bottom",
    DIRECTION_RIGHT_BOTTOM = "right_bottom";
var MORELABEL_TOTAL_TIME = MORELABEL_BORDER_INIT_TIME + MORELABEL_CONTENT_INIT_TIME + MORELABEL_CONTENT_REMOVE_TIME + MORELABEL_BORDER_REMOVE_TIME; // 默认的提示边框的相关信息

var DEFAULT_TRIANGLE_SIZE = 5,
    DEFAULT_BORDER_RADIUS = 8; // 系列，值，变化值，变化百分比，分类，百分比，x, y, 层级，指标，转换率，变化转换率

var identifiers = ['changedValue', // 变化值
'changedPercent', // 变化百分比
'changedArrivalRate', // 变化转换率
'changedWordRate', // 变化词频
'value', // 值
'percent', // 百分比
'name', // 词名
'wordRate', // 词频
'arrivalRate', // 转换率
'x', // x
'y', // y
'series', // 系列
'category', // 分类
'size'];
var contentType = {
  'changedValue': 'changedValue',
  'changedPercent': 'changedValue',
  'changedArrivalRate': 'changedValue',
  'changedWordRate': 'changedValue',
  'value': 'value',
  'size': 'value',
  'percentage': 'value',
  'x': 'value',
  'y': 'value',
  'arrivalRate': 'value',
  'wordRate': 'value',
  'seriesName': 'series',
  'category': 'series',
  'name': 'series'
};
var identifierMap = {};
identifiers.forEach(function (identifier) {
  var key = "{" + identifier.toUpperCase() + "}";
  identifierMap[key] = [identifier, identifier + "Format"];
});
identifierMap['{SERIES}'] = ['seriesName', 'seriesFormat'];
identifierMap['{PERCENT}'] = ['percentage', 'percentFormat'];
identifierMap['{X}'] = ['x', 'XFormat'];
identifierMap['{Y}'] = ['y', 'YFormat'];

var MoreLabel = _Base["default"].extend({
  /**
   * 初始化执行方法，@override Base.initialize
   * @param options  moreLabel相关的配置项
   * @param componentType  组件类型
   * @param vanchart    vanchart图表对象
   */
  initialize: function (options, componentType, vanchart) {
    this.componentType = componentType;
    this.vanchart = vanchart;
    this.refresh(options);
    this.hasAniamtion = vanchart.renderer.isAnimation; // 用于保存点和点相关的内容

    this.pointsContentArray = [];
    this.contentArray = []; // 用于保存moreLabelG和divLabelG，图表刷新的时候会同意删除并重置数组

    this.svgMoreLabels = [];
    this.divMoreLabels = [];
  },

  /**
   * 合并给出的配置和默认的配置
   * @param options
   * @private
   */
  _refresh: function (options) {
    _QueryUtils["default"].merge(options, this.getDefaultMoreLabelOptions()); // 持续时间为0则moreLabel不可用


    if (options.duration == 0) {
      options.enabled = false;
    }
  },

  /**
   * Dom相关初始化，构建svg容器和div容器，用于后期存放提示框和内容
   * @param dom
   */
  doLayout: function (dom) {
    if (!this._dom) {
      dom = dom || this.vanchart.getDivParentDom();
      this._dom = _DomUtils["default"].create("div", "moreLabelWrapper", dom);
      this._dom.style.cssText = "width:100%;height:100%;top:0;left:0;position:absolute;z-index:2000;pointer-events:none;";
      this.renderer = (0, _renderer["default"])(this._dom, this.vanchart);
      this.renderer.onAdd(); // MOBILE-18618
      // RN 框架web同构使用了

      /*
      .pointer-event-box-none * {
          pointer-events: all;
      }
      */
      // 所以这个要强制加上none

      if ((0, _EnvUtils.isSupportSVG)()) {
        this.renderer._container.style('pointer-events', 'none');
      }
    }
  },
  resize: function () {
    this.renderer.resize();
    this.clearMoreLabelTimers();
  },
  clearMoreLabelTimers: function () {
    var moreLabelTimers = this.vanchart.moreLabelTimers;
    moreLabelTimers && moreLabelTimers.forEach(function (moreLabelTimer) {
      _BaseUtils["default"].clearTimeout(moreLabelTimer);
    });
  },

  /**
   * 移除所有的MoreLabel：
   */
  removeAllMoreLabels: function () {
    if (this.svgMoreLabels.length === 0 && this.divMoreLabels.length === 0) {
      return;
    }

    this.clearMoreLabelTimers();
    this.svgMoreLabels.forEach(function (moreLabel) {
      moreLabel.remove();
    });
    this.divMoreLabels.forEach(function (moreLabel) {
      moreLabel.remove();
    });
    this.svgMoreLabels = [];
    this.divMoreLabels = [];
  },

  /**
   * 所谓的移除组件，一般指的是把组件所在的group移除
   * 但是MoreLabel还有tooltip比较特殊，是独立于绘图区的，因此这里只是清除现有的moreLabel提示框
   * 而不是把MoreLabel组件实例移除
   * @return {[type]} [description]
   */
  remove: function () {
    this.removeAllMoreLabels();

    _DomUtils["default"].remove(this._dom);

    this._dom = null;
    this.renderer && this.renderer.remove();
    this.renderer = null;
  },

  /**
   * 根据给出的point，显示moreLabel, like Tooltip.showWithPoint.
   * @param point  发生值变化的point
   * @param startX moreLabel的缩放起始位置X(非必填，如果没传的话，则会调用seires.calcMoreLabelPosition计算)
   * @param startY moreLabel的缩放起始位置X(同startX)
   */
  showWithPoint: function (point, startX, startY) {
    if (this.pointsContentArray.length === 0) {
      return;
    }

    var series = point.series; // 先布局

    this.layoutContent();
    var moreLabelDim = {
      width: this.moreLabelWidth,
      height: this.moreLabelHeight
    };
    var position;

    if ((0, _CoreUtils.hasDefined)(startX) && (0, _CoreUtils.hasDefined)(startY)) {
      position = {
        startX: startX,
        startY: startY,
        direction: "top"
      };
    } else {
      position = series.calcMoreLabelPosition(point, moreLabelDim);
    }

    position = this._calculateBeyondBounds(position);

    this._show(position);
  },

  /**
   * 计算当前的摆放位置和朝向，会不会导致moreLabel超出绘图区:
   * 这边的处理逻辑是，当前方向上如果溢出，那么就使用当前方向的反方向
   * 同时判断其余方向存不存在溢出的可能，如果其余方向也存在溢出，则其余方向上也进行调整，保证上下左右都不会溢出
   * @param position
   */
  _calculateBeyondBounds: function (position) {
    position.direction = position.direction || "top";

    var domWidth = _BaseUtils["default"].getDomWidth(this._dom),
        domHeight = _BaseUtils["default"].getDomHeight(this._dom);

    var dir = position.direction,
        startX = position.startX,
        startY = position.startY,
        moreLabelHeight = this.moreLabelHeight,
        moreLabelWidth = this.moreLabelWidth;
    var vertical = "",
        horizontal = ""; // 判断水平放下存不存在溢出

    var checkHorizontalOverflow = function () {
      if (startX - moreLabelWidth / 2 - DEFAULT_TRIANGLE_SIZE < 0) {
        horizontal = DIRECTION_RIGHT;
        return true;
      } else if (startX + moreLabelWidth / 2 + DEFAULT_TRIANGLE_SIZE > domWidth) {
        horizontal = DIRECTION_LEFT;
        return true;
      }

      return false;
    }; // 判断竖直方向存不存在溢出


    var checkVerticalOverflow = function () {
      if (startY - moreLabelHeight / 2 - DEFAULT_TRIANGLE_SIZE < 0) {
        horizontal = DIRECTION_BOTTOM;
        return true;
      } else if (startY + moreLabelHeight / 2 + DEFAULT_TRIANGLE_SIZE > domHeight) {
        horizontal = DIRECTION_TOP;
        return true;
      }

      return false;
    };

    switch (dir) {
      case DIRECTION_TOP:
        if (startY - moreLabelHeight - DEFAULT_TRIANGLE_SIZE < 0) {
          dir = DIRECTION_BOTTOM;
        } // 如果此时水平方向也溢出了，那么水平方向上的位置调整也会影响到最终的dir，后面同理


        dir = checkHorizontalOverflow() ? horizontal + "_" + dir : dir;
        break;

      case DIRECTION_BOTTOM:
        if (startY + moreLabelHeight + DEFAULT_TRIANGLE_SIZE > domHeight) {
          dir = DIRECTION_TOP;
        }

        dir = checkHorizontalOverflow() ? horizontal + "_" + dir : dir;
        break;

      case DIRECTION_LEFT:
        if (startX - moreLabelWidth - DEFAULT_TRIANGLE_SIZE < 0) {
          dir = DIRECTION_RIGHT;
        }

        dir = checkVerticalOverflow() ? dir + "_" + vertical : dir;
        break;

      case DIRECTION_RIGHT:
        if (startX + moreLabelWidth + DEFAULT_TRIANGLE_SIZE > domWidth) {
          dir = DIRECTION_LEFT;
        }

        dir = checkVerticalOverflow() ? dir + "_" + vertical : dir;
        break;
    }

    position.direction = dir;
    return position;
  },

  /**
   * 渲染MoreLabel
   * @param position moreLabel的位置和朝向
   */
  _show: function (position) {
    var moreLabel = this,
        option = this.options,
        renderer = this.renderer;
    var svgContainer = renderer._container,
        divContainer = renderer._divContainer;
    var useHtml = (0, _EnvUtils.isSupportSVG)() ? option.useHtml : true;
    var direction = position.direction || "top";
    var moreLabelG, moreLabelDivG;

    if (this.vanchart.isMap()) {
      position = this._considerMapPane(position);
    }

    var translateInfo = this.calculateTranslate(position);
    moreLabelG = renderer.group().addTo(svgContainer);
    this.svgMoreLabels.push(moreLabelG);
    moreLabelG.attr({
      "transform": "translate(" + translateInfo[0] + "," + translateInfo[1] + ")"
    });
    this.renderSvgBorder(moreLabelG, renderer, direction);

    if (useHtml) {
      moreLabelDivG = renderer.div().addTo(divContainer);
      moreLabelDivG.style({
        "left": translateInfo[0] + "px",
        "top": translateInfo[1] + "px"
      });
      this.divMoreLabels.push(moreLabelDivG);
      this.renderHtmlContent(moreLabelDivG, renderer);
    } else {
      this.renderSvgContent(moreLabelG, renderer);
    }

    var removeMoreLabelDelay = MORELABEL_TOTAL_TIME + this.getMoreLabelDuration(); // 定时清除moreLabel

    this.vanchart.setTimeout('moreLabel_remove_timer', function () {
      moreLabel.removeAllMoreLabels();
    }, removeMoreLabelDelay);
    this.resetContentArray();
  },

  /**
   * 边框Path生成器
   * @param width 边框宽度
   * @param height 边框高度
   * @param direction 提示框所在方向
   * @param borderSize 边框宽度
   * @param borderRadius 圆角大小
   * @param triangleSize 三角大小
   * @returns {string} 计算得到的path
   */
  borderPathGenerator: function (width, height, direction, borderSize, borderRadius, triangleSize) {
    width += borderSize;
    height += borderSize;
    var r = borderRadius;
    var triangleDirectionMap = {
      "top": "bottom",
      "left": "right",
      "bottom": "top",
      "right": "left"
    };
    var hasTriangle = !!triangleDirectionMap[direction];
    var triangleDirection = hasTriangle && triangleDirectionMap[direction];
    var maxBorderRadius;

    if (hasTriangle) {
      // 圆角，不能大于最小宽高的一半（去掉凸出三角后的宽高）
      var isVertical = direction === "top" || direction === "bottom";
      maxBorderRadius = Math.min(width - (isVertical ? triangleSize * 2 : 0), height - (isVertical ? 0 : triangleSize * 2)) / 2;
    } else {
      maxBorderRadius = Math.min(width, height) / 2;
    }

    if (r > maxBorderRadius) {
      r = maxBorderRadius;
    }

    var endPoints = [[0, 0], [width, 0], [width, height], [0, height]],
        curvePoints = [[0, r], [r, 0], [width - r, 0], [width, r], [width, height - r], [width - r, height], [r, height], [0, height - r], [0, r]]; // 依次连接4个点和四条边

    var path = 'M' + points(curvePoints[0]) + angle(0) + line(0) + angle(1) + line(1) + angle(2) + line(2) + angle(3) + line(3);
    return path;

    function points(arr) {
      return arr.join(',');
    } // 画圆角


    function angle(index) {
      var trianglePosMap = [DIRECTION_RIGHT_BOTTOM, DIRECTION_LEFT_BOTTOM, DIRECTION_LEFT_TOP, DIRECTION_RIGHT_TOP];
      var p1 = endPoints[index],
          p2 = curvePoints[index * 2 + 1]; // 画直角

      if (trianglePosMap[index] === direction) {
        return "L" + points(p1) + "L" + points(p2);
      }

      return 'Q' + points(p1) + ',' + points(p2);
    } // 画边框，对于有三角的那个边，要特殊对待


    function line(index) {
      var trianglePosMap = [DIRECTION_TOP, DIRECTION_RIGHT, DIRECTION_BOTTOM, DIRECTION_LEFT];
      var p1 = curvePoints[index * 2 + 1],
          p2 = curvePoints[index * 2 + 2]; // 存在triangle

      if (trianglePosMap[index] === triangleDirection) {
        // 存在三角的那条边框
        var centerPoints = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
        var centerX = centerPoints[0],
            centerY = centerPoints[1];
        var x1, x2, y1, y2;

        switch (index) {
          case 0:
            x1 = -1;
            y1 = 0;
            x2 = 0;
            y2 = -1;
            break;

          case 1:
            x1 = 0;
            y1 = -1;
            x2 = 1;
            y2 = 0;
            break;

          case 2:
            x1 = 1;
            y1 = 0;
            x2 = 0;
            y2 = 1;
            break;

          case 3:
            x1 = 0;
            y1 = 1;
            x2 = -1;
            y2 = 0;
            break;
        }

        var m1 = [centerX + x1 * triangleSize, centerY + y1 * triangleSize];
        var m2 = [centerX + x2 * triangleSize, centerY + y2 * triangleSize];
        var m3 = [centerX - x1 * triangleSize, centerY - y1 * triangleSize];
        return 'L' + points(m1) + 'L' + points(m2) + 'L' + points(m3) + 'L' + points(p2);
      }

      return 'L' + points(p2);
    }
  },

  /**
   * 渲染moreLabel边框
   * @param moreLabelG 边框所属group
   * @param renderer
   * @param direction moreLabel朝向
   */
  renderSvgBorder: function (moreLabelG, renderer, direction) {
    var option = this.options,
        borderWidth = option.borderWidth,
        width = this.moreLabelWidth,
        height = this.moreLabelHeight,
        borderRadius = option.borderRadius || DEFAULT_BORDER_RADIUS;
    var path = this.borderPathGenerator(width, height, direction, borderWidth, borderRadius, DEFAULT_TRIANGLE_SIZE);
    var duration = this.getMoreLabelDuration();
    var moreLabelBorder = renderer.path().addTo(moreLabelG);

    var borderShadow = this._createMoreLabelShadow(renderer);

    var transformOrigin = this.getSvgTransformOrigin(width, height, direction); // 由于IE和fireFox下不支持SVG-transform-origin属性，因此这里采用translate(a,b) scale(c) translate(-a, -b)的方式实现单方向缩放

    var setScaleWithOrigin = function (scale, origin) {
      var leftTranslate = "translate(" + origin[0] + "," + origin[1] + ")",
          rightTranslate = "translate(" + -origin[0] + "," + -origin[1] + ")";
      var translateScale = leftTranslate + " scale(" + scale + ") " + rightTranslate; // IE8及以下就不要用这种位移加缩放来模拟SVG-transform-origin了:
      // 第一，IE8下面没有动画
      // 第二，VMLRender还会直接把translate转成top和left。。。

      return (0, _EnvUtils.isSupportSVG)() ? translateScale : 'scale(' + scale + ')';
    };

    var fillColor = typeof option.backgroundColor === 'string' ? option.backgroundColor || "rgba(0,0,0,0)" : this._createGradientBackground(renderer, option.backgroundColor);
    moreLabelBorder.attr({
      "d": path,
      "transform": setScaleWithOrigin(1, transformOrigin),
      "filter": option.shadow ? borderShadow : "none"
    }).style({
      'fill': fillColor,
      'stroke': option.borderColor,
      'stroke-width': option.borderWidth
    }); // 😔还要考虑没开启动画的情况，如果用户强制关闭动画的话
    // transition就会把两个动画合在一起，这样一开一合就不显示了😔😔😔😔😔😔
    // 那么这边就先分开吧，没动画的时候，直接更新属性和样式，有动画再使用transition去执行动画

    this.hasAniamtion && moreLabelBorder.attr("transform", setScaleWithOrigin(0, transformOrigin)).transition().ease(MORELABEL_BORDER_INIT_EASE).duration(MORELABEL_BORDER_INIT_TIME).attr('transform', setScaleWithOrigin(1, transformOrigin)).transition().ease(MORELABEL_BORDER_EXIT_EASE).delay(MORELABEL_BORDER_INIT_TIME + MORELABEL_CONTENT_INIT_TIME + duration + MORELABEL_CONTENT_REMOVE_TIME).duration(MORELABEL_BORDER_REMOVE_TIME).attr('transform', setScaleWithOrigin(0, transformOrigin));
  },

  /**
   * 边框阴影
   * @param renderer
   * @returns {string}
   * @private
   */
  _createMoreLabelShadow: function (renderer) {
    this.borderShadow = this.borderShadow || renderer.createDropShadowFilter(0, 0, 4, 2);
    return renderer.toPatternProperty(this.borderShadow);
  },

  /**
   * 创建渐变色背景
   * @private
   */
  _createGradientBackground: function (renderer, color) {
    return (0, _GradualColorUtils.createGradientBackground)(this, 'backgroundColorGradient', renderer, color);
  },

  /**
   * 计算SVG下进行Scale缩放时的原点：主要针对IE，fireFox和其他不支持transform-origin使用的黑科技
   * @param width
   * @param height
   * @param direction
   */
  getSvgTransformOrigin: function (width, height, direction) {
    var centerX = width / 2,
        centerY = height / 2;
    var originPosition = [centerX, height];

    switch (direction) {
      case DIRECTION_TOP:
        originPosition = [centerX, height];
        break;

      case DIRECTION_BOTTOM:
        originPosition = [centerX, 0];
        break;

      case DIRECTION_RIGHT:
        originPosition = [0, centerY];
        break;

      case DIRECTION_LEFT:
        originPosition = [width, centerY];
        break;

      case DIRECTION_LEFT_TOP:
        originPosition = [width, height];
        break;

      case DIRECTION_LEFT_BOTTOM:
        originPosition = [width, 0];
        break;

      case DIRECTION_RIGHT_TOP:
        originPosition = [0, height];
        break;

      case DIRECTION_RIGHT_BOTTOM:
        originPosition = [0, 0];
        break;
    }

    return originPosition;
  },

  /**
   * 使用SVG渲染内容
   * @param moreLabelG 所属group
   * @param renderer
   */
  renderSvgContent: function (moreLabelG, renderer) {
    var contentArray = this.contentArray;
    var svgOffset = !(0, _EnvUtils.isSupportSVG)() ? {} : {
      'dy': '0.32em'
    };
    var option = this.options;
    var duration = this.getMoreLabelDuration();
    var textGroup = renderer.group().addTo(moreLabelG);
    contentArray.forEach(function (content) {
      var textG = renderer.group().attr({
        'transform': _BaseUtils["default"].makeTranslate([content.x + option.borderWidth, option.borderWidth + content.y + content.height * 0.65])
      }).addTo(textGroup);
      var text = renderer.text().attr(svgOffset).addTo(textG);
      content.data.forEach(function (c) {
        renderer.tspan().style(c.style).textContent(c.content).addTo(text);
      });
    });
    this.hasAniamtion && textGroup.attr('fill-opacity', 0).transition().ease(MORELABEL_CONTENT_INIT_EASE).delay(MORELABEL_BORDER_INIT_TIME).duration(MORELABEL_CONTENT_INIT_TIME).attr('fill-opacity', 1).transition().ease(MORELABEL_CONTENT_EXIT_EASE).delay(MORELABEL_BORDER_INIT_TIME + MORELABEL_CONTENT_INIT_TIME + duration).duration(MORELABEL_CONTENT_REMOVE_TIME).attr('fill-opacity', 0);
  },

  /**
   * 使用HTML渲染内容
   * @param divG 所属div
   * @param renderer
   */
  renderHtmlContent: function (divG, renderer) {
    var contentArray = this.contentArray;
    var duration = this.getMoreLabelDuration();
    contentArray.forEach(function (content) {
      var lineHeight = content.height;
      var lineDiv = renderer.div().style({
        "top": content.y + 'px',
        "left": content.x + 'px'
      }).addTo(divG);
      var translateX = 0;
      content.data.forEach(function (d) {
        var dim = d.dim;

        var style = _BaseUtils["default"].clone(d.style);

        style.display = 'inline-block'; //lineHeight = fontSize 就没有行间距了。所以去掉。

        style['top'] = lineHeight - dim.height + 'px';
        style['left'] = translateX + 'px';
        renderer.div().style(style).textContent(d.content).addTo(lineDiv);
        translateX += dim.width;
      });
    });
    this.hasAniamtion && divG.style("opacity", 0).transition().style({
      "opacity": 1
    }).delay(MORELABEL_BORDER_INIT_TIME).duration(MORELABEL_CONTENT_INIT_TIME).ease(MORELABEL_CONTENT_INIT_EASE).transition().style({
      "opacity": 0
    }).delay(MORELABEL_BORDER_INIT_TIME + MORELABEL_CONTENT_INIT_TIME + duration).duration(MORELABEL_CONTENT_REMOVE_TIME).ease(MORELABEL_CONTENT_EXIT_EASE);
  },

  /**
   * 收集值变化的点，并存入moreLabel.pointsContentArray
   * @param point
   * @returns {*}
   */
  collectPoint: function (point) {
    var option = this.options,
        formatter = option.formatter; // 现在的MoreLabel的画布大小等于vanchart.dom的大小，理论上只要不超出这块区域都是可以显示MoreLabel的
    // 但是正是由于MoreLabel脱离图表区，这就导致了超出图表区的点发生值变化时，可以显示MoreLabel，理论上不应该显示，
    // 因此这里加一个判断，如果点已经超出绘图区，则默认该点不可用

    var series = point.series,
        vanchart = series.vanchart,
        plotBounds = vanchart.bounds;

    var isOutChartBounds = function (x, y) {
      return x < plotBounds.x || x > plotBounds.x + plotBounds.width || y < plotBounds.y || y > plotBounds.y + plotBounds.height;
    }; // 对于直接传位置的点，应该不存在点移除的问题，比如地图


    if (series.calcMoreLabelPosition) {
      var pointPos = series.calcMoreLabelPosition(point, {
        width: 0,
        height: 0
      });

      if (isOutChartBounds(pointPos.startX, pointPos.startY)) {
        return;
      }
    } // 自定义值变化提示内容,直接当作系列处理，不走calculateContent的逻辑了


    if (typeof formatter !== 'object') {
      try {
        var content = _BaseUtils["default"].getFormatterFunction(formatter).call(point);

        if (content) {
          this.pointsContentArray.push({
            point: point,
            seriesMap: [{
              type: "series",
              content: content
            }],
            changedValueMap: [],
            valueMap: [],
            categoryMap: []
          });
        }

        return;
      } catch (e) {
        return;
      }
    } // 这种啥都没有的不计算


    if (formatter.identifier === "") {
      return;
    }

    this.calculateContent(formatter, point);
  },

  /**
   * 获取MoreLabel持续时间
   * @return {[type]} [description]
   */
  getMoreLabelDuration: function () {
    var duration = this.options.duration;
    return (0, _CoreUtils.hasDefined)(duration) ? duration * 1000 : 3000;
  },

  /**
   * 根据内容进行排版
   */
  layoutContent: function () {
    var self = this; // 布局根据展示的点的数目(一个点和多个点)分开考虑

    if (this.pointsContentArray.length === 1) {
      this.onePointMoreLabelLayout(this.pointsContentArray[0]);
    } else {
      this.pointsContentArray.forEach(function (pointContentObj, index, arr) {
        // 这边很多个点的时候，诸如分类一些共有的信息还得单独另开一行，因此在最后一行布局的时候，加一个lastPoint的判断
        if (index === arr.length - 1) {
          self.morePointsMoreLabelLayout(pointContentObj, true);
        } else {
          self.morePointsMoreLabelLayout(pointContentObj);
        }
      });
    } // 内容排版完成后，计算每一行的尺寸和偏移


    this.calculateContentDim();
  },

  /**
   * 计算MoreLabel的偏移，用于后期摆放MoreLabel
   * @param position
   * @returns {[*,*]}
   */
  calculateTranslate: function (position) {
    var translateX = 0,
        translateY = 0,
        moreLabelPosX = position.startX,
        moreLabelPosY = position.startY;
    var moreLabelWidth = this.moreLabelWidth,
        moreLabelHeight = this.moreLabelHeight;

    switch (position.direction) {
      case DIRECTION_TOP:
        translateX = moreLabelPosX - moreLabelWidth / 2;
        translateY = moreLabelPosY - moreLabelHeight - DEFAULT_TRIANGLE_SIZE;
        break;

      case DIRECTION_BOTTOM:
        translateX = moreLabelPosX - moreLabelWidth / 2;
        translateY = moreLabelPosY + DEFAULT_TRIANGLE_SIZE;
        break;

      case DIRECTION_RIGHT:
        translateX = moreLabelPosX + DEFAULT_TRIANGLE_SIZE;
        translateY = moreLabelPosY - moreLabelHeight / 2;
        break;

      case DIRECTION_LEFT:
        translateX = moreLabelPosX - moreLabelWidth - DEFAULT_TRIANGLE_SIZE;
        translateY = moreLabelPosY - moreLabelHeight / 2;
        break;

      case DIRECTION_LEFT_TOP:
        translateX = moreLabelPosX - moreLabelWidth;
        translateY = moreLabelPosY - moreLabelHeight;
        break;

      case DIRECTION_LEFT_BOTTOM:
        translateX = moreLabelPosX - moreLabelWidth;
        translateY = moreLabelPosY;
        break;

      case DIRECTION_RIGHT_TOP:
        translateX = moreLabelPosX;
        translateY = moreLabelPosY - moreLabelHeight;
        break;

      case DIRECTION_RIGHT_BOTTOM:
        translateX = moreLabelPosX;
        translateY = moreLabelPosY;
        break;
    }

    return [translateX, translateY];
  },

  /**
   * 一个框一个点的布局方式
   * @param pointContentObj
   */
  onePointMoreLabelLayout: function (pointContentObj) {
    var self = this;
    var point = pointContentObj.point,
        series = point.series,
        chartType = series.type;
    var vanchart = series.vanchart;

    var Style = this._getContentStyle(),
        plusStyle = Style.plus,
        minusStyle = Style.minus,
        numericalStyle = Style.numerical,
        textStyle = Style.text,
        delimiterStyle = Style.delimiter;

    var changedStyle = point.changedValue > 0 ? plusStyle : minusStyle;
    var changedValueMap = pointContentObj.changedValueMap,
        valueMap = pointContentObj.valueMap,
        seriesMap = pointContentObj.seriesMap,
        categoryMap = pointContentObj.categoryMap; // 单点布局的时候，系列和分类放在一行，因此这里把系列和分类合并，分类在前

    seriesMap = categoryMap.concat(seriesMap);
    var changedCount = changedValueMap.length,
        valueCount = valueMap.length,
        seriesCount = seriesMap.length; // 普通的气泡图和散点图需要特殊排版，气泡地图和散点地图则按找默认排版

    if (!vanchart.isMap() && (chartType === _Constants["default"].BUBBLE_CHART || chartType === _Constants["default"].SCATTER_CHART)) {
      bubbleContentLayoutFuc();
    } else {
      defaultContentLayoutFuc();
    } // 气泡图提示内容布局


    function bubbleContentLayoutFuc() {
      var xContent, yContent, valueContent;
      valueMap.forEach(function (value) {
        var type = value.type,
            content = value.content;

        if (type === 'x') {
          xContent = content + ''; // 防止为0的时候判断为false
        } else if (type === 'y') {
          yContent = content + '';
        } else if (type === 'size' || type === 'value') {
          valueContent = content;
        }
      });
      var lineOne = [],
          lineTwo = []; // 加入变化值

      changedCount && pushContent(lineOne, changedValueMap[0].content, changedStyle); // 加入分隔符

      (changedCount === 1 && valueCount || changedCount === 2) && pushContent(lineOne, "/", delimiterStyle); // 加入变化百分比

      changedCount === 2 && pushContent(lineOne, changedValueMap[1].content, changedStyle); // 重新组合值内容

      var newValueContent = valueCount && valueContent != null ? '' + valueContent : ''; // 加入坐标内容

      if (xContent && yContent) {
        newValueContent += '  (' + xContent + ',' + yContent + ')';
      } else if (xContent || yContent) {
        newValueContent += '  (' + (xContent || yContent) + ')';
      } // 加入值内容


      newValueContent && pushContent(lineOne, newValueContent, textStyle);
      pushLine(lineOne);
      seriesCount && lineTwo.push(lineContentFuc(seriesMap, " ", textStyle));
      pushLine(lineTwo);
    }
    /**
     * 默认的布局方式：最多三行：第一行变化值和变化百分比，第二行值和百分比，第三行系列名和分类名
     * 当变化类和值类的内容数目小于等于2个的时候，就需要把变化类和值类放在一行，中间加一个黑色的/
     */


    function defaultContentLayoutFuc() {
      var lineOne = [],
          lineTwo = [],
          lineThree = []; // 变化类内容和值内容分两行显示

      if (changedCount + valueCount > 2) {
        lineOne.push(lineContentFuc(changedValueMap, '/', changedStyle));
        lineTwo.push(lineContentFuc(valueMap, '/', numericalStyle));
      } // 变化类内容和值内容一行显示，中间加一个分隔符
      else {
          changedCount && lineOne.push(lineContentFuc(changedValueMap, '/', changedStyle));

          if (changedCount === 1 && valueCount === 1) {
            lineOne.push({
              content: '/',
              style: delimiterStyle
            });
          }

          valueCount && lineOne.push(lineContentFuc(valueMap, '/', numericalStyle));
        }

      seriesCount && lineThree.push(lineContentFuc(seriesMap, ' ', textStyle));
      lineOne.length && self.contentArray.push({
        data: lineOne
      });
      lineTwo.length && self.contentArray.push({
        data: lineTwo
      });
      lineThree.length && self.contentArray.push({
        data: lineThree
      });
    }
    /**
     * 把每一行的内容数组存入contentArray.
     * @param line
     */


    function pushLine(line) {
      line.length && self.contentArray.push({
        data: line
      });
    }

    function pushContent(line, content, style) {
      line.push({
        content: content,
        style: style
      });
    }
    /**
     * 单行内容生成
     */


    function lineContentFuc(contentMap, separator, style) {
      var content,
          len = contentMap.length;

      if (len === 1) {
        content = contentMap[0].content;
      } else if (len === 2) {
        content = contentMap[0].content + separator + contentMap[1].content;
      }

      if (content) {
        return {
          content: content,
          style: style
        };
      }
    }
  },

  /**
   * 一个框多个点的布局方式
   * @param pointContentObj 点内容对象
   * @param lastPoint 是否为最后一个点(最后一个点的时候，需要再加一行用于存放共有的分类名)
   */
  morePointsMoreLabelLayout: function (pointContentObj, lastPoint) {
    var self = this;
    var point = pointContentObj.point,
        series = point.series,
        vanchart = series.vanchart;

    var Style = this._getContentStyle();

    var plusStyle = Style.plus,
        minusStyle = Style.minus,
        numericalStyle = Style.numerical,
        textStyle = Style.text,
        delimiterStyle = Style.delimiter;
    var changedStyle = point.changedValue > 0 ? plusStyle : minusStyle;
    var changedValueMap = pointContentObj.changedValueMap,
        valueMap = pointContentObj.valueMap,
        seriesMap = pointContentObj.seriesMap,
        categoryMap = pointContentObj.categoryMap;
    var cateContent = vanchart.isPointOrAreaOrHeatMap() ? point.name : point.category;
    var changedCount = changedValueMap.length,
        valueCount = valueMap.length,
        seriesCount = seriesMap.length,
        categoryCount = categoryMap.length;
    var lineData = [];
    var changedContent = createContent(changedValueMap);
    var valueContent = createContent(valueMap, true);
    var seriesContent = createContent(seriesMap, true); // 加入变化值

    changedCount && pushContent(lineData, changedContent, changedStyle); // 加入分隔符

    if (changedCount === 1 && (valueCount || seriesCount)) {
      pushContent(lineData, "/", delimiterStyle);
    } // 加入值


    valueCount && pushContent(lineData, valueContent, numericalStyle); // 加入系列

    seriesCount && pushContent(lineData, seriesContent, textStyle); // 把整行加入到contentArray

    lineData.length && self.contentArray.push({
      data: lineData
    }); // 最后一个点且选中了分类的时候还需要另开一行用来放分类

    if (lastPoint && categoryCount && cateContent) {
      self.contentArray.push({
        data: [{
          content: cateContent,
          style: textStyle
        }]
      });
    }

    function createContent(contentMap, space) {
      var content = space ? "  " : "";

      switch (contentMap.length) {
        case 2:
          content += contentMap[0].content + '/' + contentMap[1].content;
          break;

        case 1:
          content += contentMap[0].content;
          break;
      }

      return content;
    }

    function pushContent(line, content, style) {
      line.push({
        content: content,
        style: style
      });
    }
  },

  /**
   * 统一获取内容的样式，分为值变化样式, 文字样式，数字样式，分隔符样式
   * 当存在自定义样式的时候，则统一使用自定义样式。
   */
  _getContentStyle: function () {
    // TODO 本来每次获取样式都要计算，于是重写了一下，直接把样式绑定在this上，这样只有第一次的时候会计算一下样式
    // 这样做，后期如果有样式修改的话，就比较麻烦了，想了想，好像也没有可能会在自动刷新的过程中改变样式
    // 性能问题虽然现在不重要，但是也需要考虑，不然后期整理起来就繁琐了，因此能不重复计算的就不重复计算
    if (this.moreLabelStyle) {
      return this.moreLabelStyle;
    }

    var style = this.options.style,
        customStyle = _BaseUtils["default"].clone(style.custom); // 自定义的样式或者默认的样式，都需要考虑Scale缩放的问题


    if (customStyle) {
      customStyle = _BaseUtils["default"].calculateFontSizeWithScale(customStyle);
    }

    ['plus', 'minus', 'numerical', 'text'].forEach(function (name) {
      style[name] = _BaseUtils["default"].calculateFontSizeWithScale(style[name]);
    });
    var plusStyle = customStyle ? customStyle : style.plus,
        minusStyle = customStyle ? customStyle : style.minus,
        numericalStyle = customStyle ? customStyle : style.numerical,
        textStyle = customStyle ? customStyle : style.text,
        delimiterStyle = customStyle ? customStyle : {
      "fontSize": style.plus.fontSize,
      "fontFamily": style.plus.fontFamily,
      "color": "#1515151"
    };
    this.moreLabelStyle = {
      plus: plusStyle,
      minus: minusStyle,
      numerical: numericalStyle,
      text: textStyle,
      delimiter: delimiterStyle
    };
    return this.moreLabelStyle;
  },

  /**
   * 计算需要显示的内容和样式
   * @param formatter
   * @param point
   */
  calculateContent: function (formatter, point) {
    var series = point.series,
        vanchart = series.vanchart,
        chartType = series.type;
    var changedValueMap = [],
        valueMap = [],
        seriesMap = [],
        categoryMap = [];

    var sortContent = function (type, content) {
      if (!content) {
        return;
      } // 内容为空不显示


      var contentObj = {
        type: type,
        content: content
      };

      switch (contentType[type]) {
        case 'changedValue':
          changedValueMap.push(contentObj);
          break;

        case 'value':
          valueMap.push(contentObj);
          break;

        case 'series':
          if (vanchart.isPointOrAreaOrHeatMap() && type === 'name' || type === 'category') {
            categoryMap.push(contentObj);
          } else {
            seriesMap.push(contentObj);
          }

          break;
      }
    };

    formatter.identifier.substring(1).split("$").forEach(function (id) {
      var type = identifierMap[id][0],
          formatKey = identifierMap[id][1];
      var content; // 矩形树图的层级名需要特殊计算

      if (chartType === _Constants["default"].TREEMAP_CHART && type === 'name') {
        content = treeMapNameContentFuc(point);
      } else {
        content = _BaseUtils["default"].format(point[type == 'size' ? 'value' : type], formatter[formatKey]);
      } // FR.format会移除字符串中的+,因此这里格式化之后再判断加上+


      if (type === 'changedValue' && content > 0) {
        content = '+' + content;
      }

      sortContent(type, content);
    });
    this.pointsContentArray.push({
      point: point,
      changedValueMap: changedValueMap,
      valueMap: valueMap,
      seriesMap: seriesMap,
      categoryMap: categoryMap
    }); // 矩形树图层级名生成

    function treeMapNameContentFuc(point) {
      var p,
          d = point,
          points = [point.name];

      while ((p = d.parent) && p.depth) {
        d = p;
        points.unshift(p.name);
      }

      return points.join(' / ');
    }
  },

  /**
   * 重置内容数组，showWithPoint中调用，表示一个moreLabel制作已经完成。
   */
  resetContentArray: function () {
    this.pointsContentArray = [];
    this.contentArray = [];
  },

  /**
   * 根据内容数组计算数据提示框的尺寸
   * @param contentArray
   */
  calculateContentDim: function () {
    var gap = DEFAULT_GAP,
        padding = DEFAULT_PADDING;
    var maxWidth = 0,
        maxHeight = padding;
    var borderWidth = this.options.borderWidth;
    var useHtml = this.options.useHtml;
    this.contentArray.forEach(function (line) {
      var lineWidth = 0,
          lineHeight = 0;
      line.data.forEach(function (content) {
        var dim = _BaseUtils["default"].getTextDimension(content.content, content.style, true);

        dim.height = useHtml ? dim.height : parseFloat(content.style.fontSize);
        content.dim = dim;
        lineWidth += dim.width;
        lineHeight = Math.max(dim.height || 0, lineHeight);
      });
      line.x = padding;
      line.y = maxHeight;
      line.width = lineWidth;
      line.height = lineHeight;
      maxWidth = Math.max(lineWidth, maxWidth);
      maxHeight += lineHeight + gap;
    });
    this.moreLabelWidth = maxWidth + 2 * padding;
    this.moreLabelHeight = maxHeight - gap + padding + 2 * borderWidth;
  },

  /**
   * do nothing
   */
  render: function () {},

  /**
   * 默认的moreLabel.options
   */
  getDefaultMoreLabelOptions: function () {
    return {
      "style": {
        "plus": {
          "color": "#FF4848",
          "fontSize": "22px",
          "fontFamily": "Akrobat,Helvetica"
        },
        "minus": {
          "color": "#1CBE91",
          "fontSize": "22px",
          "fontFamily": "Akrobat,Helvetica"
        },
        "numerical": {
          "color": "#151515",
          "fontSize": "12px",
          "fontFamily": "Helvetica,Akrobat"
        },
        "text": {
          "color": "#151515",
          "fontSize": "12px",
          "fontFamily": "Microsoft YaHei, PingFang SC"
        }
      },
      "duration": 3000,
      "borderWidth": 1,
      "borderColor": "#000",
      "shadow": false,
      "useHtml": false
    };
  },

  /**
   * 地图这边的paneMove后，点的pixel位置并没有变
   * 但由于leaflet自身发生了translate，所以点的位置更新了。
   * 因此这边再绘制地图的自动提示时，需要考虑地图自身的translate
   * @param position 之前的数据变化提示的起始位置
   * @returns {*}  兼容地图位置偏移后的数据变化提示起始位置
   * @private
   */
  _considerMapPane: function (position) {
    var mapTranslateInfo = this.vanchart._getMapPanePos();

    position.startX += mapTranslateInfo.x;
    position.startY += mapTranslateInfo.y;
    return position;
  }
});

var _default = MoreLabel;
exports["default"] = _default;

/***/ }),
/* 182 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Axis = _interopRequireDefault(__webpack_require__(62));

var _Polar = _interopRequireDefault(__webpack_require__(183));

var _AngleAxis = _interopRequireDefault(__webpack_require__(184));

var _RadiusAxis = _interopRequireDefault(__webpack_require__(185));

var _component = __webpack_require__(4);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 16/8/17.
 */
var PolarAxis = _Axis["default"].extend({
  _refresh: function () {
    this._axisList = this._axisList || [];
    var options = this.options;
    options = _BaseUtils["default"].isArray(options) ? options : [options]; //最终生成的坐标轴数应该和新的option一样

    var len = options.length;

    for (var axisIndex = len; axisIndex < this._axisList.length; axisIndex++) {
      this._axisList[axisIndex].remove();

      this._axisList[axisIndex] = null;
    }

    this._axisList.length = len;

    for (var axisIndex = len - 1; axisIndex >= 0; axisIndex--) {
      //增加一个坐标轴序号的标记
      options[axisIndex].axisIndex = axisIndex;

      if (this._axisList[axisIndex] && this._axisList[axisIndex].type != options[axisIndex].type) {
        this._axisList[axisIndex].remove();

        this._axisList[axisIndex] = null;
      }

      if (this._axisList[axisIndex]) {
        this._axisList[axisIndex].refresh(options[axisIndex]);
      } else {
        var AxisClass;

        if (this.componentType === _component.ComponentCst.POLAR_COMPONENT) {
          AxisClass = _Polar["default"];
        } else {
          var axisType = options[axisIndex].type || _component.ComponentCst.VALUE_AXIS_COMPONENT;

          if (axisType == _component.ComponentCst.VALUE_AXIS_COMPONENT) {
            AxisClass = _RadiusAxis["default"];
          } else if (axisType == _component.ComponentCst.CATEGORY_AXIS_COMPONENT) {
            AxisClass = _AngleAxis["default"];
          }
        }

        this._axisList[axisIndex] = new AxisClass(options[axisIndex], this.componentType, this.vanchart);
      }
    }
  },
  doLayout: function () {
    var axisCount = this._axisList.length;

    for (var i = axisCount - 1; i >= 0; i--) {
      this._axisList[i].doLayout();
    }
  },
  render: function () {
    this._axisList.map(function (axis) {
      if (axis.componentType === _component.ComponentCst.POLAR_COMPONENT) {
        axis.render();
      }
    });
  }
});

var _default = PolarAxis;
exports["default"] = _default;

/***/ }),
/* 183 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var Polar = _Base["default"].extend({
  _refresh: function () {
    this.series = [];
  },
  _isBaseAxis: function () {
    return true;
  },
  doLayout: function () {
    var option = this.options;
    var radius = option.radius;
    var center = option.center; // keep origin radius (include null)
    // adjust radius by angleAxis later

    if (!center || center.length === 0) {
      var plotBounds = this.vanchart.bounds;
      center = [plotBounds.width / 2 + plotBounds.x, plotBounds.height / 2 + plotBounds.y];
    }

    this.setCenter(center);

    if ((0, _CoreUtils.hasDefined)(radius)) {
      this.setRadius(radius);
    } else {
      this.radius = null;
    }

    var plotOptions = this.vanchart.options.plotOptions; //组合图中 雷达图和柱形雷达图 shape不同。不能放到共用的plotOptions.radar里面，只能放到组件polar的options里面

    var shape = this.options.shape || plotOptions.radar && plotOptions.radar.shape || plotOptions.shape;
    this.shape = shape || this.shape;
  },

  /**
   * set polar radius and update radiusAxis scale
   * @param {number|string} radius
   */
  setRadius: function (radius) {
    if (!radius) {
      return;
    }

    this.radius = this._getPercentValue(radius, Math.min(this.vanchart.width, this.vanchart.height) / 2);
  },

  /**
   * set polar center
   * @param {number[]|string[]} center
   */
  setCenter: function (center) {
    if (!center) {
      return;
    }

    this.center = [];
    this.center[0] = this._getPercentValue(center[0], this.vanchart.width);
    this.center[1] = this._getPercentValue(center[1], this.vanchart.height);
  },
  render: function () {
    var R = this.vanchart.renderer,
        radiusAxis = this.radiusAxis;
    var clipPath = {
      'd': radiusAxis._getRadiusGridPath(radiusAxis.scale.domain()[1])
    };

    if (!this.clip) {
      this.clip = R.createClip(clipPath, 'path');
    } else {
      R.updateClip(this.clip, clipPath);
    }

    this.radiusAxis.render();
    this.angleAxis.render();
  }
});

var _default = Polar;
exports["default"] = _default;

/***/ }),
/* 184 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _CategoryAxis = _interopRequireDefault(__webpack_require__(51));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _BoundsManager = _interopRequireDefault(__webpack_require__(25));

var _StyleUtils = __webpack_require__(29);

var _component = __webpack_require__(4);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 16/8/17.
 */
var PADDING_GAP = 8;

var PADDING_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING_GAP);
};

var TOP = 'radar-top';
var BOTTOM = 'radar-bottom';
var LEFT = 'radar-left';
var RIGHT = 'radar-right';

var AngleAxis = _CategoryAxis["default"].extend({
  _refresh: function (options) {
    this.series = [];
    this.piece = null;
    this.initScale();
    this.refreshPolar(options);
  },
  refreshPolar: function (axisOption) {
    this.polar = this.vanchart.polar(axisOption.axisIndex);
    this.polar.angleAxis = this;
  },
  doLayout: function () {
    this.calculateDomainFromData();
    this.scale.domain(this._dataDomain).rangePoints([0, this._dataDomain.length - 1]);
    this.piece = Math.PI * 2 / Math.max(this._dataDomain.length, 1);

    this._updateOriginTickData();

    this._updatePolarBounds();

    this._calculateTickData();
  },
  fixScaleAndTickData: function () {
    this.scale.domain(this._dataDomain).rangePoints([0, this._dataDomain.length - 1]);

    this._updateOriginTickData();

    this._calculateTickData();
  },
  _calculateTickData: function () {
    var radius = this.polar.radius,
        bounds,
        axisOptions = this.options;

    if (this.isBreakLabels) {
      bounds = this._getTestBoundsAndRadius().testBounds;
    } // AngleAxis 也可以设置固定标签间隔


    if (axisOptions.step) {
      this.tickData.forEach(function (t, index) {
        if (index % axisOptions.step) {
          t.tickContent = '';
        }
      });
    }

    this.tickData.map(function (t) {
      this._getCateLabelBounds(radius, t, bounds);
    }, this);
  },
  _getTestBoundsAndRadius: function () {
    var plotBounds = this.vanchart.bounds;
    var center = this.polar.center;
    var tmpBounds = [// 0 top
    center[1] - plotBounds.y, // 1 right
    plotBounds.x + plotBounds.width - center[0], // 2 bottom
    plotBounds.y + plotBounds.height - center[1], // 3 left
    center[0] - plotBounds.x];
    var radius = Math.min.apply(null, tmpBounds);
    radius -= PADDING_GAP_FUN();
    var testBounds = {
      x: -tmpBounds[3],
      y: -tmpBounds[0],
      width: plotBounds.width,
      height: plotBounds.height
    };
    return {
      testBounds: testBounds,
      radius: radius
    };
  },
  _updatePolarBounds: function () {
    if (this.polar.radius) {
      return;
    } // no radius setting, auto adjust


    var tmp = this._getTestBoundsAndRadius();

    var radius = tmp.radius;
    var testBounds = tmp.testBounds;

    if (this.options.showLabel) {
      if (!this._testRadius(radius, testBounds)) {
        radius = this._findNiceRadius(testBounds);

        this._testRadius(radius, testBounds);
      }
    }

    this.polar.setRadius(radius);
  },
  getIndexByPosition: function (pos) {
    return this._getIndexByPolarCoordinate(pos);
  },
  _getIndexByPolarCoordinate: function (pos) {
    var center = this.polar.center;
    var r = this.polar.radius;
    var isReversed = this.isAxisReversed();
    var x = pos[0] - center[0];
    var y = center[1] - pos[1];

    if (x * x + y * y > r * r) {
      return -1;
    }

    var arc = _BaseUtils["default"].getArcByPoint(x, y);

    var index;
    var categories = this.getCategories();

    if (categories.length > 1) {
      var unitLength = 2 * Math.PI / categories.length;
      index = isReversed ? categories.length - 1 - arc / unitLength : arc / unitLength;
    } else {
      index = 0;
    }

    index = Math.round(index);
    index = index % categories.length;
    return index;
  },
  getAngleGridLineData: function () {
    var points = [];
    var angleAxis = this.polar.angleAxis;
    var categories = angleAxis.scale.domain();
    var self = this;
    categories.forEach(function (category) {
      var radian = angleAxis.scale(category) * angleAxis.piece;
      var r = self.polar.radius;
      points.push(_BaseUtils["default"].getArcPoint(r, radian));
    });
    points = points.length ? points : [_BaseUtils["default"].getArcPoint(this.polar.radius, 0)];
    return points;
  },
  // clac the endPos of every gridLine.
  getCateAngleGridLineData: function () {
    var points = this.getAngleGridLineData();
    var category = this.polar.angleAxis.scale.domain();
    return points.map(function (p, index) {
      return {
        name: category[index],
        pos: p
      };
    });
  },
  _testRadius: function (radius, testBounds) {
    for (var i = 0, count = this.tickData.length; i < count; i++) {
      var tick = this.tickData[i];

      var labelBounds = this._getCateLabelBounds(radius, tick);

      if (!_BaseUtils["default"].containsRect(testBounds, labelBounds)) {
        return false;
      }
    }

    return true;
  },
  _getCateLabelBounds: function (radius, cateTick, testBounds) {
    var category = cateTick.tickValue;
    var dim = cateTick.tickRectDim;
    var domain = this.scale.domain();
    var index = domain.indexOf(category);

    var arcPoint = _BaseUtils["default"].getArcPoint(radius + PADDING_GAP_FUN(), index * this.piece);

    var pos;
    var cfg = this.options;

    var position = this._getPolarPosition(category);

    var originStyle = _BaseUtils["default"].extend({
      width: '',
      'white-space': '',
      'text-align': ''
    }, cfg.labelStyle);

    switch (position) {
      case TOP:
        pos = {
          style: originStyle,
          x: -dim.width / 2,
          y: -radius - dim.height * 0.65 - PADDING_GAP_FUN()
        };
        break;

      case RIGHT:
        pos = {
          style: originStyle,
          x: arcPoint[0],
          y: arcPoint[1] - dim.height / 2
        };

        if (testBounds && this.isBreakLabels && pos.x + dim.width > testBounds.x + testBounds.width) {
          var width = testBounds.x + testBounds.width - arcPoint[0];

          var style = _BaseUtils["default"].extend({
            width: width + 'px',
            'white-space': 'normal',
            'text-align': 'left'
          }, cfg.labelStyle);

          dim = _BaseUtils["default"].getTextWrapDimension(cateTick.tickContent, style);
          pos = {
            style: style,
            x: arcPoint[0],
            y: arcPoint[1] - dim.height / 2
          };
        }

        break;

      case BOTTOM:
        pos = {
          style: originStyle,
          x: -dim.width / 2,
          y: radius + PADDING_GAP_FUN()
        };
        break;

      case LEFT:
        pos = {
          style: originStyle,
          x: arcPoint[0] - dim.width,
          y: arcPoint[1] - dim.height / 2
        };

        if (testBounds && this.isBreakLabels && pos.x < testBounds.x) {
          var width = arcPoint[0] - testBounds.x;

          var style = _BaseUtils["default"].extend({
            width: width + 'px',
            'white-space': 'normal',
            'text-align': 'right'
          }, cfg.labelStyle);

          dim = _BaseUtils["default"].getTextWrapDimension(cateTick.tickContent, style);
          pos = {
            style: style,
            x: arcPoint[0] - dim.width,
            y: arcPoint[1] - dim.height / 2
          };
        }

        break;
    }

    cateTick.tickPos = pos;
    return _BaseUtils["default"].makeBounds(pos, dim);
  },
  _getPolarPosition: function (category) {
    var domain = this.scale.domain();
    var index = domain.indexOf(category);
    var midIndex = domain.length / 2;

    if (index === 0) {
      return TOP;
    } else if (index > 0 && index < midIndex) {
      return RIGHT;
    } else if (index == midIndex) {
      return BOTTOM;
    } else if (index > midIndex) {
      return LEFT;
    }
  },
  _findNiceRadius: function (testBounds) {
    var tmpBounds = [-testBounds.y, testBounds.width + testBounds.x, testBounds.height + testBounds.y, -testBounds.x];
    var minBounds = Math.min.apply(null, tmpBounds);
    var minRadius = minBounds;
    var domain = this.scale.domain();
    var self = this;
    this.tickData.forEach(function (cateTick) {
      if (cateTick.tickContent) {
        var category = cateTick.tickValue;
        var tickDim = cateTick.tickDim;
        var index = domain.indexOf(category);

        var position = self._getPolarPosition(category);

        var radius;

        switch (position) {
          case TOP:
            radius = tmpBounds[0] - tickDim.height;
            break;

          case RIGHT:
            radius = (tmpBounds[1] - tickDim.width) / Math.abs(Math.sin(index * self.piece));
            break;

          case BOTTOM:
            radius = tmpBounds[2] - tickDim.height;
            break;

          case LEFT:
            radius = (tmpBounds[3] - tickDim.width) / Math.abs(Math.sin(index * self.piece));
            break;

          default:
        }

        minRadius = Math.min(minRadius, radius);
      }
    });

    if (minRadius < minBounds * 2 / 3) {
      minRadius = minBounds * 2 / 3; // this.breakLabels(this.tickData);

      if (!this.options.labelRotation && !this.options.useHtml && !false) {
        this.isBreakLabels = true; // break labels in render
      }
    }

    return minRadius - PADDING_GAP_FUN();
  },
  getCategoryByPos: function (containerPoint) {
    var center = this.polar.center;
    var r = this.polar.radius;
    var x = containerPoint.x - center[0];
    var y = center[1] - containerPoint.y;

    if (x * x + y * y > r * r) {
      return null;
    }

    var arc = _BaseUtils["default"].getArcByPoint(x, y);

    var domain = this.scale.domain(),
        range = this.scale.rangeExtent();

    var tmpScale = _Scale["default"].quantize().domain(range).range(domain);

    var l = domain.length,
        index = Math.round(arc / (2 * Math.PI) * l) % l;
    var category = tmpScale(index);
    return category;
  },
  getPointsInCategory: function (containerPoint) {
    var category = this.getCategoryByPos(containerPoint);
    return this.vanchart.getValidPointsPara(category);
  },
  render: function () {
    var vanchart = this.vanchart,
        renderer = vanchart.renderer;

    if (!this.axisGroup) {
      this.axisGroup = renderer.vgroup().add(vanchart.seriesGroup);
    } // 没有数据时，不绘制任何轴线


    if (this.series.length === 0) {
      this.remove();
      return;
    }

    this.axisGroup.attr('transform', _BaseUtils["default"].makeTranslate(this.polar.center));

    this._drawAxisLine(this.axisGroup);

    this._drawGridLine(this.axisGroup);

    this._drawTickLabel(this.axisGroup);
  },
  _drawAxisLine: function (axisGroup) {
    var R = this.vanchart.renderer;
    var radiusAxis = this.polar.radiusAxis;
    var angleAxis = this;
    var lineWidth = angleAxis.options.lineWidth;
    var lineColor = angleAxis.options.lineColor;
    var maxValue = radiusAxis.scale.domain()[1];

    if (!this.axisLine) {
      this.axisLine = axisGroup.append(R.path());
    }

    this.axisLine.attr({
      d: radiusAxis._getRadiusGridPath(maxValue)
    }).style({
      fill: 'none',
      'stroke': lineColor,
      'stroke-width': lineColor ? lineWidth : 0
    });
  },
  _drawGridLine: function (axisGroup) {
    var R = this.vanchart.renderer; // 'angle grid line' is like xAxis grid line
    // but now we name it radiusAxis axisLine in options
    // so

    var cfg = this.polar.radiusAxis.options;
    var lineConfig = {
      color: cfg.lineColor,
      lineWidth: cfg.lineColor ? cfg.lineWidth : 0,
      lineType: cfg.lineType
    };

    if (!this.gridLinesGroup) {
      this.gridLinesGroup = axisGroup.append(R.group());
      this.gridLines = [];
    }

    var gridLinesGroup = this.gridLinesGroup;
    var axisLineData = this.getAngleGridLineData();

    var selection = this._bindData(this.gridLines, axisLineData);

    selection.exit.map(function (d) {
      d.remove();
    });
    var enter = selection.enter.map(function (d) {
      return gridLinesGroup.append(R.line()).datum(d);
    });
    this.gridLines = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();
      return ele.style((0, _StyleUtils.getLineStyle)(lineConfig)).attr({
        x1: 0,
        y1: 0,
        x2: d[0],
        y2: d[1]
      });
    });
  },
  _drawTickLabel: function (axisGroup) {
    this._drawSvgTickLabel(axisGroup);
  },
  _drawSvgTickLabel: function (axisGroup) {
    var R = this.vanchart.renderer;
    var angleAxis = this;
    var cfg = angleAxis.options;
    var isBreakLabels = this.isBreakLabels;
    var useHtml = cfg.useHtml || isBreakLabels;
    var ticks = [],
        tickData = angleAxis.tickData,
        boundsManager = new _BoundsManager["default"](); // 考虑标签重叠

    for (var i = 0; i < tickData.length; i++) {
      var tick = tickData[i],
          pos = tick.tickPos,
          dim = tick.tickDim;
      var tickBounds = {
        x: pos.x,
        y: pos.y,
        width: dim.width,
        height: dim.height
      };

      if (!boundsManager.isOverlapped(tickBounds)) {
        boundsManager.addBounds(tickBounds);
        ticks.push(tick);
      }
    }

    if (!this.tickLabelsGroup) {
      this.tickLabelsGroup = axisGroup.append(R.vgroup());
      this.tickLabels = [];
    }

    if (useHtml && this.tickLabels.length && this.tickLabels[0].type !== 'div') {
      this.tickLabels.map(function (d) {
        d.remove();
      });
      this.tickLabels = [];
    }

    var tickLabelsGroup = this.tickLabelsGroup;

    var selection = this._bindData(this.tickLabels, ticks, function (d) {
      return d.tickValue;
    });

    selection.exit.map(function (d) {
      d.remove();
    });

    if (cfg.showLabel) {
      var enter = selection.enter.map(function (d) {
        return tickLabelsGroup.append(R.vtext(useHtml).datum(d));
      });
      this.tickLabels = enter.concat(selection.update).filter(function (ele) {
        return ele.datum().tickPos;
      }).map(function (ele) {
        var d = ele.datum();
        var tx = d.tickPos.x,
            ty = d.tickPos.y;
        var px = ele.type === 'div' ? 'px' : '';
        var attr = {
          transform: 'translate(' + tx + px + ' ' + ty + px + ')',
          dy: '0.85em'
        };
        var labelStyle = d.tickPos.style;

        if (d.labelRotation === 360) {
          labelStyle['writingMode'] = 'tb-rl';
          labelStyle['writing-mode'] = 'tb-rl';
        }

        ele.style(d.tickPos.style).attr(attr).textContent(d.tickContent);
        ele.vRotate(d.labelRotation);
        return ele;
      });
    }
  },
  drawHighlightBackground: function (sharedPoints) {
    var category = sharedPoints[0].category;
    var scale = this.scale,
        columnType = this.series[0] && this.series[0].options.columnType || false;
    var R = this.vanchart.renderer;
    var domain = scale.domain();
    var r = this.polar.radius;
    var radian = scale(category) / domain.length * 2 * Math.PI;

    if (columnType) {
      var halfSize = 1 / domain.length * 2 * Math.PI * 0.5;
      var startRadian = radian - halfSize;
      var endRadian = radian + halfSize;

      var arc = _PathGenerator["default"].arc().innerRadius(0).outerRadius(r).startAngle(startRadian).endAngle(endRadian);

      if (!this.highlightBand) {
        this.highlightBand = this.axisGroup.append(R.path().style({
          'fill': 'rgba(98,179,240,0.2)'
        }));
      }

      this.highlightBand.attr('d', arc());
    } else {
      var point = _BaseUtils["default"].getArcPoint(r, radian);

      if (!this.highlightLine) {
        this.highlightLine = this.axisGroup.append(R.line({
          'stroke': 'rgb(140,140,140)',
          'stroke-width': '1'
        }));
      }

      this.highlightLine.attr('x2', point[0]).attr('y2', point[1]);
    }
  },
  remove: function () {
    this.axisGroup && this.axisGroup.remove();
    this.axisGroup = null;
    this.gridLinesGroup = null;
    this.tickLabelsGroup = null;
  }
});

var _default = AngleAxis;
exports["default"] = _default;

/***/ }),
/* 185 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _ValueAxis = _interopRequireDefault(__webpack_require__(64));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _component = __webpack_require__(4);

var _CoreUtils = __webpack_require__(3);

var _StyleUtils = __webpack_require__(29);

var _AxisUtils = __webpack_require__(40);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 16/8/17.
 */
var VALUE_TICK_GAP = 2;

var VALUE_TICK_GAP_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(VALUE_TICK_GAP);
};

var RadiusAxis = _ValueAxis["default"].extend({
  _refresh: function (options) {
    this.series = [];
    this.initScale();
    this.refreshPolar(options);
  },
  refreshPolar: function (axisOption) {
    this.polar = this.vanchart.polar(axisOption.axisIndex);
    this.polar.radiusAxis = this;
  },
  doLayout: function () {
    var series = this.series;
    this.indicator = series.length && series[0].options.indicator && series[0].options.indicator.enabled; // bind indicator property

    this.calculateDomainFromData();
    this.scale.domain(this._domain).range([0, this.polar.radius]); // init categoryScale, used for calc scale value for points radius of every category

    this._initCateScale(this._domain, [0, this.polar.radius]);

    this._updateOriginTickData();
    /**
     * CHART-1285
     * 由于RadiusAxis计算tickData的时候使用的是BaseAxis下的_updateOriginTickData方法，
     * 所以如果给RadiusAxis设置了step的属性，也不能在那里进行修改，现在在这里修改吧。
     * 另外如果设置了RadiusAxis也设置了“值定义-->分别计算”，
     * 那么也将每一分类对应的RadiusAxis的标签间隔显示。
     */


    var axisOptions = this.options;

    if (axisOptions.step) {
      this.tickData.forEach(function (t, index) {
        if (index % axisOptions.step) {
          t.tickContent = '';
        }
      });
      this.indicator && this.cateTickData.forEach(function (c) {
        c.tickData.forEach(function (t, index) {
          if (index % axisOptions.step) {
            t.tickContent = '';
          }
        });
      });
    }
  },
  // bind radiusAxis.cateScale
  _initCateScale: function (d, r) {
    var scale = _Scale["default"].linear().domain(d).range(r);

    this._cateScale = scale;
  },
  // calc domain form data for every categroy
  // if the category is accumulated, calc sum use value of points on this category.
  _calculateCateDomainData: function () {
    var radiusAxis = this,
        series = radiusAxis.series,
        vanchart = series.vanchart;
    var options = series.length && series[0].options,
        indicator = options.indicator;
    var fromZero = this.type == _component.ComponentCst.VALUE_AXIS_COMPONENT && !this._isBaseAxis();
    var minValue = Number.MAX_VALUE,
        maxValue = -minValue;
    var dataMap = {},
        indicatorDataDomain;
    this._cateDataDomain = []; // 先格式化出option中给出的数据值域

    if (indicator.data && indicator.data.length) {
      indicatorDataDomain = indicator.data.map(function (data) {
        return {
          name: data.name,
          domain: [data.min, data.max]
        };
      });
    }

    var visible = false;

    for (var i = 0, len = series.length; i < len && !visible; i++) {
      visible = series[i].visible;
    }

    series.forEach(function (ser) {
      if (ser.visible || !visible) {
        var isAccumulate = !((0, _CoreUtils.hasNotDefined)(ser.stack) || radiusAxis._isBaseAxis());
        ser.points.forEach(function (point) {
          var key = point.category,
              value = point.value;

          if (!point.isNull && point.visible) {
            if (isAccumulate) {
              dataMap[key] = dataMap[key] || [0, 0];

              if (value >= 0) {
                dataMap[key][1] += value;
              } else {
                dataMap[key][0] += value;
              }
            } else {
              dataMap[key] = dataMap[key] || [minValue, maxValue];
              dataMap[key][0] = Math.min(dataMap[key][0], value);
              dataMap[key][1] = Math.max(dataMap[key][1], value);
            }
          }
        });
      }
    });

    for (var key in dataMap) {
      this._cateDataDomain.push({
        useIndicator: false,
        name: key,
        domain: dataMap[key]
      });
    } // 从0开始的值轴，最小值不应该大于0


    var checkMaxAndMin = function (arr) {
      if (fromZero) {
        if (arr[0] > 0) {
          arr[0] = 0;
        } else if (arr[1] < 0) {
          arr[1] = 0;
        }
      }
    }; // 对于有自定义数据时，需要对数据进行校验
    // 只有对于那些指定分类且值域范围符合标准的才使用自定义的数据


    if (indicatorDataDomain) {
      indicatorDataDomain.forEach(function (cate) {
        var name = cate.name,
            min = cate.domain[0],
            max = cate.domain[1]; // 最小值大于等于最大值的直接过滤

        radiusAxis._cateDataDomain.forEach(function (_cate) {
          // 未指定和多余的分类数据也同样过滤
          if (name === _cate.name) {
            // 都不存在时直接返回
            if (min == null && max == null) {
              return;
            } // 都存在且相等或最大值小于最小值是也返回


            if (min != null && max != null && min >= max) {
              return;
            }

            var d_0 = _cate.domain[0],
                d_1 = _cate.domain[1]; // 这里做一下归0判断，不然后面会很难做

            var _min = min || (fromZero ? d_0 > 0 ? 0 : d_0 : d_0),
                _max = max || (fromZero ? d_1 < 0 ? 0 : d_1 : d_1);

            var hasMin = false,
                hasMax = false;

            if (min) {
              hasMin = true;
            }

            if (max) {
              hasMax = true;
            } // 有最小值没有最大值判断最大值是否小于最小值


            if (hasMin && !hasMax) {
              _max = _max <= _min ? _min + 100 : _max; // 有最大值没有最小值判断最小值是否大于最大值
            } else if (hasMax && !hasMin) {
              _min = _min > _max ? _max - 100 : _min;
            }

            _cate.useIndicator = true;
            _cate.domain = [_min, _max];
          }
        });
      });
    } // 对于那些未能使用自定义数据的分类，需要判断将最小值置为0


    this._cateDataDomain.forEach(function (d) {
      if (!d.useIndicator) {
        checkMaxAndMin(d.domain);
      }
    }); // As we get Max and Min of each category, next setp is to calc cateNiceDomain, cateStartTick, cateStep and cateTickData.


    this._calculateCateNiceDomain();

    this._updateCategoryTickData();
  },
  // clac nice domain for every category
  // and get each's tickStartValue,tickStep by the way.
  _calculateCateNiceDomain: function () {
    var radiusAxis = this,
        series = radiusAxis.series,
        vanchart = series.vanchart;
    this._cateTickStart = [];
    this._cateStep = [];
    this._cateDomain = [];

    var hasIndicator = false,
        defaultTickCount = this._getDefaultTickCount(); // 第一步，依次计算每条值轴的最优值域和间隔
    // 对于自定义值域的分类轴，使用默认的tickCount进行计算


    this._cateDataDomain.forEach(function (data) {
      var name = data.name,
          _domain = data.domain,
          useIndicator = data.useIndicator;
      var step, domain, start;

      if (data.useIndicator) {
        hasIndicator = true;
        start = _domain[0], domain = [_domain[0], _domain[1]];
        step = parseFloat((_domain[1] - _domain[0]) / defaultTickCount);
      } else {
        step = (0, _AxisUtils.getLinearNiceInterval)(_domain[0], _domain[1], radiusAxis._getDefaultTickCount(), radiusAxis.type), domain = (0, _AxisUtils.getIntegerNiceDomain)(_domain[0], _domain[1], step);
        start = domain[0];
      }

      radiusAxis._cateTickStart.push(start);

      radiusAxis._cateDomain.push({
        useIndicator: useIndicator,
        name: name,
        domain: domain
      });

      radiusAxis._cateStep.push(step);
    }); // 第二步，对数据再处理
    // 当有使用到自定义的最大最小值时，就全部使用默认的4行grinLine进行排版


    if (!hasIndicator) {
      var labelsLengthArr = this._getCateTickValues().map(function (d) {
        return d.labels.length;
      });

      defaultTickCount = Math.max.apply(Math, labelsLengthArr);
    }

    this._cateDomain.forEach(function (d, i) {
      var min = d.domain[0],
          max = d.domain[1],
          useIndicator = d.useIndicator; // 自适应大小的轴重新计算step和max，确保上面的tickLabels不会出现小数

      if (!useIndicator) {
        var _step = Math.ceil((max - min) / defaultTickCount);

        d.domain[1] = min + _step * defaultTickCount;
        radiusAxis._cateStep[i] = _step;
      }
    });
  },
  // Update TickData for every radiusAxis
  _updateCategoryTickData: function () {
    var radiusAxis = this;

    var cateLabels = this._getCateTickValues();

    this.cateTickData = [];

    for (var i = 0, len = cateLabels.length; i < len; i++) {
      var cateName = cateLabels[i].name,
          cateLabel = cateLabels[i].labels;
      var cateTickData = [];

      for (var j = 0, labelLen = cateLabel.length; j < labelLen; j++) {
        cateTickData.push(radiusAxis._labelInfoFormatter(cateLabel[j]));
      }

      radiusAxis.cateTickData.push({
        name: cateName,
        tickData: cateTickData
      });
    }
  },
  // tickLabel info formatter, copy from BaseAxis._updateOriginTickData
  _labelInfoFormatter: function (tickValue) {
    var radiusAxis = this,
        axisOption = this.options;
    var formatter = axisOption.formatter,
        useHtml = axisOption.useHtml;
    var style = axisOption.labelStyle || {};

    var tbStyle = _BaseUtils["default"].extend({
      'writingMode': 'tb-rl',
      'writing-mode': 'tb-rl',
      '-webkit-writing-mode': 'vertical-rl'
    }, style);

    var tickContent = radiusAxis._getTickContent(tickValue, formatter);

    if (radiusAxis.type === _component.ComponentCst.CATEGORY_AXIS_COMPONENT) {
      tickContent = tickContent.trim();
    }

    var rectDim,
        labelDim,
        tmpStyle = style;
    var labelRotation = radiusAxis.options.labelRotation;

    if (Math.abs(labelRotation) === 90 && _BaseUtils["default"].hasChn(tickContent)) {
      labelRotation = 360; // as a log

      tmpStyle = tbStyle;
    }

    rectDim = _BaseUtils["default"].getTextDimension(tickContent, tmpStyle, useHtml);
    labelDim = _BaseUtils["default"].getTextDimRotated(rectDim, labelRotation);

    if (useHtml) {
      labelDim.width = isNaN(parseFloat(axisOption.labelWidth)) ? labelDim.width : parseFloat(axisOption.labelWidth);
      labelDim.height = isNaN(parseFloat(axisOption.labelHeight)) ? labelDim.height : parseFloat(axisOption.labelHeight);
    }

    return {
      tickValue: tickValue,
      tickContent: tickContent,
      tickDim: labelDim,
      tickRectDim: rectDim,
      labelRotation: labelRotation
    };
  },
  // calc tickLabels info for ervery radiusAxis
  _getCateTickValues: function () {
    if (!this._cateDataDomain) {
      return [];
    }

    var cateValueList = [];
    var radiusAxis = this;

    this._cateDomain.forEach(function (d, i) {
      var cateLabel = [];
      var start = radiusAxis._cateTickStart[i],
          step = radiusAxis._cateStep[i];
      var max = d.domain[1];

      if (start === max || step === 0) {
        cateLabel.push(start);
      } else {
        for (; start <= max; start = _BaseUtils["default"].accAdd(start, step)) {
          cateLabel.push(start);
        }
      }

      cateValueList.push({
        name: d.name,
        labels: cateLabel
      });
    });

    return cateValueList;
  },
  fixScaleAndTickData: function () {
    this.scale.domain(this._domain).range([0, this.polar.radius]);

    this._updateOriginTickData();
  },
  getRadiusPlotBands: function () {
    var plotBands = this._getPlotBands();

    var result = [];
    var self = this;
    plotBands.forEach(function (d) {
      result.push({
        path: self._getRadiusPlotBandsPath(d.from, d.to),
        color: d.color
      });
    });
    return result;
  },
  _getRadiusPlotBandsPath: function (from, to) {
    var shape = this.polar.shape;

    if (shape === _Constants["default"].POLYGON_RADAR) {
      return this._getRadiusGridPath(Math.min(from, to)) + this._getRadiusGridPath(Math.max(from, to), true);
    } else {
      var arc = _PathGenerator["default"].arc().startAngle(0).endAngle(2 * Math.PI);

      return arc.innerRadius(this.scale(Math.min(from, to))).outerRadius(this.scale(Math.max(from, to)))();
    }
  },
  getPlotLines: function () {
    var plotLines = this.options.plotLines || [];
    var self = this;
    var result = [];
    plotLines.forEach(function (d) {
      var text, style, align;
      var lineWidth = _Constants["default"].DASH_ARRAY[d.lineType] == null ? 0 : d.lineWidth;

      if (d.label && d.label.text && d.label.style) {
        text = d.label.text;
        style = d.label.style;
        align = d.label.align;
      }

      result.push({
        color: d.color,
        value: d.value,
        width: lineWidth,
        dataArray: _Constants["default"].DASH_ARRAY[d.lineType],
        text: text,
        baseY: -self.scale(d.value),
        textAnchor: align == _Constants["default"].LEFT ? 'end' : 'start',
        style: style
      });
    });
    return result;
  },
  // radius grids are circles
  _getRadiusGridPath: function (value, reversed) {
    var data = this._getRadiusGridData(value, reversed);

    return this._getRadiusGridPathByData(data);
  },
  _getRadiusGridData: function (value, reversed, scale) {
    var radiusScale = scale || this.scale;
    var angleAxis = this.polar.angleAxis;
    var shape = this.polar.shape;

    if (shape === _Constants["default"].POLYGON_RADAR) {
      var points = [];
      var cateScale = angleAxis.scale;
      var categories = cateScale.domain();
      categories.forEach(function (category) {
        var radian = cateScale(category) * angleAxis.piece;
        var r = radiusScale(value);
        points.push(_BaseUtils["default"].getArcPoint(r, radian));
      });

      if (reversed) {
        points.reverse();
      }

      return points;
    } else {
      return radiusScale(value);
    }
  },
  _getRadiusGridPathByData: function (data) {
    if (_BaseUtils["default"].isArray(data)) {
      var path = "";

      if (data.length) {
        for (var i = 0, count = data.length; i < count; i++) {
          var mOrl = i ? 'L' : 'M';
          path += mOrl + _BaseUtils["default"].dealFloatPrecision(data[i][0]) + "," + _BaseUtils["default"].dealFloatPrecision(data[i][1]);
        }

        path += 'Z';
      }

      return path;
    } else {
      var arc = _PathGenerator["default"].arc().startAngle(0).endAngle(2 * Math.PI).innerRadius(0);

      return arc.outerRadius(data)();
    }
  },
  render: function () {
    var vanchart = this.vanchart,
        renderer = vanchart.renderer;

    if (!this.axisGroup) {
      this.axisGroup = renderer.vgroup().add(vanchart.seriesGroup);
      this.ticksLabelGroup = renderer.vgroup().add(vanchart.seriesGroup);
      renderer.clip(this.axisGroup.renderG, this.polar.clip);
    } // 没有数据时，不绘制任何轴线


    if (this.series.length === 0) {
      this.remove();
      return;
    }

    this.axisGroup.attr('transform', _BaseUtils["default"].makeTranslate(this.polar.center));
    this.ticksLabelGroup.attr('transform', _BaseUtils["default"].makeTranslate(this.polar.center));

    this._drawPlotBands(this.axisGroup);

    this.indicator ? this._drawCateGridLine(this.axisGroup) : this._drawGridLine(this.axisGroup);

    this._drawPlotLines();

    this._drawTickLabel(this.ticksLabelGroup);
  },
  _drawGridLine: function (axisGroup) {
    var R = this.vanchart.renderer;
    var radiusAxis = this;
    var lastScale = radiusAxis.lastScale || radiusAxis.scale;
    var cfg = radiusAxis.options;
    var ticks = radiusAxis.getTickData();
    var lineConfig = {
      color: cfg.gridLineColor,
      lineWidth: cfg.gridLineWidth,
      lineType: cfg.gridLineType
    };

    if (!this.gridLinesGroup) {
      this.gridLinesGroup = axisGroup.append(R.group());
      this.gridLines = [];
    }

    var gridLinesGroup = this.gridLinesGroup;

    var selection = this._bindData(this.gridLines, ticks);

    selection.exit.map(function (ele) {
      var d = ele.datum();

      var prePos = radiusAxis._getRadiusGridData(d.tickValue, false, lastScale);

      var curPos = radiusAxis._getRadiusGridData(d.tickValue);

      ele.animate({
        'attrTween': {
          'd': function () {
            var interpolate = (0, _interpolator["default"])(prePos, curPos);
            return function (t) {
              return radiusAxis._getRadiusGridPathByData(interpolate(t));
            };
          }
        }
      }).remove();
    });
    var enter = selection.enter.map(function (d) {
      return gridLinesGroup.append(R.path()).datum(d);
    });
    this.gridLines = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();

      var curPos = radiusAxis._getRadiusGridData(d.tickValue);

      ele.style((0, _StyleUtils.getLineStyle)(lineConfig));

      var prePos = radiusAxis._getRadiusGridData(d.tickValue, false, lastScale);

      ele.animate({
        'attrTween': {
          'd': function () {
            var interpolate = (0, _interpolator["default"])(prePos, curPos);
            return function (t) {
              return radiusAxis._getRadiusGridPathByData(interpolate(t));
            };
          }
        }
      });
      return ele;
    });
  },
  _drawCateGridLine: function (axisGroup) {
    var R = this.vanchart.renderer;
    var radiusAxis = this;
    var lastScale = radiusAxis.lastScale || radiusAxis._cateScale;
    var cfg = radiusAxis.options;
    var ticks = radiusAxis.cateTickData[0].tickData;
    var gridLineColor = cfg.gridLineColor;
    var gridLineWidth = cfg.gridLineWidth;
    var domain = radiusAxis._cateDomain[0].domain;

    if (!this.gridLinesGroup) {
      this.gridLinesGroup = axisGroup.append(R.group());
      this.gridLines = [];
    }

    var gridLinesGroup = this.gridLinesGroup;

    var selection = this._bindData(this.gridLines, ticks);

    selection.exit.map(function (ele) {
      var d = ele.datum();

      var prePos = radiusAxis._getRadiusGridData(d.tickValue, false, lastScale);

      var curPos = radiusAxis._getRadiusGridData(d.tickValue, false, lastScale);

      ele.animate({
        'attrTween': {
          'd': function () {
            var interpolate = (0, _interpolator["default"])(prePos, curPos);
            return function (t) {
              return radiusAxis._getRadiusGridPathByData(interpolate(t));
            };
          }
        }
      }).remove();
    });
    var enter = selection.enter.map(function (d) {
      return gridLinesGroup.append(R.path()).datum(d);
    });
    this.gridLines = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();
      lastScale.domain(domain);

      var curPos = radiusAxis._getRadiusGridData(d.tickValue, false, lastScale);

      ele.style({
        fill: 'none',
        'stroke': gridLineColor,
        'stroke-width': gridLineWidth,
        'opacity': 1
      });

      var prePos = radiusAxis._getRadiusGridData(d.tickValue, false, lastScale);

      ele.animate({
        'attrTween': {
          'd': function () {
            var interpolate = (0, _interpolator["default"])(prePos, curPos);
            return function (t) {
              return radiusAxis._getRadiusGridPathByData(interpolate(t));
            };
          }
        }
      });
      return ele;
    });
  },
  _drawPlotLines: function () {
    var R = this.vanchart.renderer;
    var plotLines = this.getPlotLines();

    if (!this.plotLinesGroup) {
      this.plotLinesGroup = R.vgroup().add(this.vanchart.frontGroup);
      this.plotLines = [];
    }

    this.plotLinesGroup.attr('transform', _BaseUtils["default"].makeTranslate(this.polar.center));
    var plotLinesGroup = this.plotLinesGroup;

    var selection = this._bindData(this.plotLines, plotLines);

    selection.exit.map(function (layer) {
      layer.text && layer.text.remove();
      layer.remove();
    });
    var enter = selection.enter.map(function (d) {
      var path = plotLinesGroup.append(R.path().datum(d));

      if (d.text) {
        path.text = plotLinesGroup.append(R.vtext());
      }

      return path;
    });
    this.plotLines = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();

      var path = this._getRadiusGridPath(d.value);

      ele.style({
        'fill': 'none',
        'stroke': d.color,
        'stroke-width': d.width,
        'stroke-dasharray': d.dataArray
      }).animate({
        'attr': {
          'd': path
        }
      });
      ele.text && ele.text.style(d.style).style({
        'text-anchor': d.textAnchor
      }).attr({
        y: d.baseY
      }).textContent(d.text);
      return ele;
    }, this);
  },
  _drawPlotBands: function (axisGroup) {
    var R = this.vanchart.renderer;
    var plotBands = this.getRadiusPlotBands();

    if (!this.plotBandsGroup) {
      this.plotBandsGroup = axisGroup.append(R.group());
      this.plotBands = [];
    }

    var plotBandsGroup = this.plotBandsGroup;

    var selection = this._bindData(this.plotBands, plotBands);

    selection.exit.map(function (d) {
      d.remove();
    });
    var enter = selection.enter.map(function (d) {
      return plotBandsGroup.append(R.path()).datum(d);
    });
    this.plotBands = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();
      ele.style('fill', d.color).animate({
        'attr': {
          'd': d.path
        }
      });
      return ele;
    }, this);
  },
  _drawTickLabel: function (axisGroup) {
    this.indicator ? this._drawCateSvgTickLabel(axisGroup) : this._drawSvgTickLabel(axisGroup);
  },
  _drawSvgTickLabel: function (axisGroup) {
    var R = this.vanchart.renderer;
    var radiusAxis = this;
    var scale = radiusAxis.scale;
    var lastScale = radiusAxis.lastScale || radiusAxis.scale;
    var cfg = radiusAxis.options; //最大值标签不显示

    var ticks = cfg.showLabel ? radiusAxis.getTickData().slice(0, -1) : [];
    var labelStyle = cfg.labelStyle;
    var useHtml = cfg.useHtml;

    var selection = this._bindData(this.tickLabels || [], ticks, function (d) {
      return d.tickValue;
    });

    this.tickLabels = [];

    if (!this.tickLabelsGroup) {
      this.tickLabelsGroup = axisGroup.append(R.vgroup());
    }

    var tickLabelsGroup = this.tickLabelsGroup;
    selection.exit.map(function (d) {
      d.remove();
    });

    if (cfg.showLabel) {
      var enter = selection.enter.map(function (d) {
        return tickLabelsGroup.append(R.vtext(useHtml).datum(d));
      });
      this.tickLabels = enter.concat(selection.update).map(function (ele) {
        var d = ele.datum();
        ele.textContent(d.tickContent).style(_BaseUtils["default"].clone(labelStyle));
        var tx = -(d.tickRectDim.width + d.tickDim.width) / 2 - VALUE_TICK_GAP_FUN(),
            ty = -scale(d.tickValue) - (d.tickRectDim.height + d.tickDim.height) / 2;
        var attr = {
          transform: 'translate(' + tx + ' ' + ty + ')',
          dy: '0.85em'
        };

        if (!useHtml) {
          var rotateStr = d.labelRotation % 360 ? ele.vRotate(d.labelRotation).rotateStr : '';
          attr.transform += rotateStr;

          var _tx = -(d.tickRectDim.width + d.tickDim.width) / 2 - VALUE_TICK_GAP_FUN(),
              _ty = -lastScale(d.tickValue) - (d.tickRectDim.height + d.tickDim.height) / 2;

          var lastAttr = {
            transform: 'translate(' + _tx + ' ' + _ty + ')',
            dy: '0.85em'
          };
          lastAttr.transform += rotateStr;
          ele.attr(lastAttr).animate({
            'attr': attr
          });
        } else {
          ele.attr(attr);
          ele.vRotate(d.labelRotation);
        }

        return ele;
      });
    }
  },
  _drawCateSvgTickLabel: function (axisGroup) {
    var R = this.vanchart.renderer;
    var radiusAxis = this;
    var lastScale = radiusAxis.lastScale || radiusAxis._cateScale;
    var cfg = radiusAxis.options; //最大值标签不显示

    var ticks = radiusAxis.getTickData().slice(0, -1);
    var labelStyle = cfg.labelStyle;
    var useHtml = cfg.useHtml;

    if (!this.cateTickLabelsGroup) {
      this.cateTickLabelsGroup = axisGroup.append(R.vgroup());
      this.cateTickLabels = [];

      this._cateDataDomain.forEach(function () {
        radiusAxis.cateTickLabels.push([]);
      });
    }

    var tickLabelsGroup = this.cateTickLabelsGroup;
    var cateSelection = [];

    var getDir = function (x, y) {
      var horizontal = x >= 0 ? 'RIGHT' : 'LEFT',
          vertical = y >= 0 ? 'BOTTOM' : 'TOP';
      return horizontal + '_' + vertical;
    }; // label位置统一计算


    var calcPosition = function (dir, x, y, rect_w, rect_h, dim_w, dim_h) {
      var gap = VALUE_TICK_GAP_FUN();

      var _w = (rect_w + dim_w) / 2,
          _h = (rect_h + dim_h) / 2,
          _x = x,
          _y = y;

      switch (dir) {
        case 'LEFT_TOP':
          _x = x + gap;
          _y = y + gap;
          break;

        case 'RIGHT_TOP':
          _x = x - _w - gap;
          _y = y + gap;
          break;

        case 'RIGHT_BOTTOM':
          _x = x + -_w - gap;
          _y = y - _h - gap;
          break;

        case 'LEFT_BOTTOM':
          _x = x + gap;
          _y = y - _h - gap;
          break;
      }

      return {
        x: _x,
        y: _y
      };
    }; // 获取网格线的终点位置信息


    var gridLineEndPosData = this.series[0].angleAxis.getCateAngleGridLineData();
    var labelLenArr = this.cateTickData.map(function (tick) {
      return tick.tickData.length;
    });
    var lastDomain = lastScale.domain(),
        lastRange = lastScale.range();
    this.cateTickData.forEach(function (tick, i) {
      var cateName = tick.name,
          pos;

      var selection = radiusAxis._bindData(radiusAxis.cateTickLabels[i], tick.tickData, function (d) {
        return d.tickValue;
      });

      gridLineEndPosData.forEach(function (d) {
        if (d.name == cateName) {
          pos = d.pos;
        }
      });
      selection.exit.map(function (d) {
        d.remove();
      });
      var x0 = pos[0],
          y0 = pos[1],
          dir = getDir(x0, y0);

      if (cfg.showLabel) {
        var _enter = selection.enter.map(function (d) {
          return tickLabelsGroup.append(R.vtext(useHtml).datum(d));
        });

        radiusAxis.cateTickLabels[i] = _enter.concat(selection.update).map(function (ele, j, labels) {
          var d = ele.datum();
          ele.style(labelStyle).textContent(d.tickContent); // 这里用scale感觉有点蠢

          lastScale.domain(radiusAxis._cateDomain[i].domain);
          lastScale.range([0, x0]);

          var _x0 = lastScale(d.tickValue);

          lastScale.range([0, y0]);

          var _y0 = lastScale(d.tickValue);

          var _pos = calcPosition(dir, _x0, _y0, d.tickRectDim.width, d.tickRectDim.height, d.tickDim.width, d.tickDim.height);

          var tx = _pos.x,
              ty = _pos.y;
          var attr = {
            transform: 'translate(' + tx + ' ' + ty + ')',
            dy: '0.85em'
          };

          if (!useHtml) {
            var rotateStr = d.labelRotation % 360 ? ele.vRotate(d.labelRotation).rotateStr : '';
            attr.transform += rotateStr;
            var _tx = tx,
                _ty = ty;
            var lastAttr = {
              transform: 'translate(' + _tx + ' ' + _ty + ')',
              dy: '0.85em'
            };
            lastAttr.transform += rotateStr;
            ele.attr(lastAttr).animate({
              'attr': attr
            });
          } else {
            ele.attr(attr);
            ele.vRotate(d.labelRotation);
          }

          return ele;
        });
      }
    });
    lastScale.range(lastRange).domain(lastDomain);
  }
});

var _default = RadiusAxis;
exports["default"] = _default;

/***/ }),
/* 186 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _EnvUtils = __webpack_require__(2);

var _Browser = _interopRequireDefault(__webpack_require__(8));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/5/4.
 * 标题组建，包括图表标题和坐标轴标题
 */
var PADDING = 8;
var LINE_HEIGHT = 1.2;
var DEFAULT_TITLE_BOTTOM_PADDING = 3;

var PADDING_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING);
};

var Title = _Base["default"].extend({
  _refresh: function () {
    this.remove();
    this.bounds = null;
    this.textBounds = null;
    this.labels = [];
  },
  doLayout: function () {
    var cfg = this.options;

    if (!cfg.text) {
      return;
    }

    var originBounds = this.vanchart.bounds;
    var remainWidth = originBounds.width;
    var remainHeight = originBounds.height; // get maximal area

    if (this.isFloat) {
      remainWidth -= this._floatX - originBounds.x;
      remainHeight -= this._floatY - originBounds.y;
    } else {
      var toolbar = this.vanchart.components[_component.ComponentCst.TOOLBAR_COMPONENT];
      this.initBarWidth = toolbar && toolbar.getToolBarInitWidth() || 0;
      remainWidth -= this.initBarWidth;

      if (cfg.align === 'center') {
        remainWidth -= this.initBarWidth;
      }
    } // cut padding to place text


    remainWidth -= 2 * PADDING_FUN();
    remainHeight -= 2 * PADDING_FUN();
    var textsHeight;
    var textMaxWidth;
    var textDim;
    var texts;

    if (cfg.useHtml) {
      textDim = _BaseUtils["default"].getTextDimension(cfg.text, cfg.style, cfg.useHtml);
      textMaxWidth = textDim.width;
      textsHeight = textDim.height;
      texts = [cfg.text];
    } else {
      texts = _BaseUtils["default"].splitText(cfg.text, cfg.style, remainWidth);
      textDim = _BaseUtils["default"].getTextDimension(texts[0], cfg.style, cfg.useHtml);
      textMaxWidth = textDim.width;
      textsHeight = texts.length * textDim.height * LINE_HEIGHT;
    }

    var doublePadding = 2 * PADDING_FUN(); // 这里的height就是bounds.height，当使用限制的尺寸的时则使用限制的尺寸，否则以文字的尺寸+2*padding

    var height = Math.min(this._maxHeight(), remainHeight + doublePadding, textsHeight + doublePadding);

    if (this.isFloat) {
      this.bounds = {
        x: this._floatX,
        y: this._floatY,
        // contract floating title's background width
        width: textMaxWidth + 2 * PADDING_FUN(),
        height: height
      };
    } else {
      var bottomPadding = this._getTitleBottomPadding();

      this._setComponentBounds(_Constants["default"].TOP, height === 0 ? 0 : height + bottomPadding);

      this.bounds.height = height;
    } // 文字在内部整体居中


    var textTranslateY = (height - textsHeight) / 2;

    if (this.isFloat) {
      this.textBounds = {
        x: PADDING_FUN(),
        y: textTranslateY,
        width: textMaxWidth,
        height: textsHeight
      };
    } else {
      var x;

      switch (cfg.align) {
        case 'right':
          x = remainWidth - textMaxWidth;
          break;

        case 'center':
          x = this.bounds.width / 2 - textMaxWidth / 2;
          break;

        case 'left':
        default:
          x = this.bounds.x + PADDING_FUN();
      }

      this.textBounds = {
        x: x,
        y: textTranslateY,
        width: textMaxWidth,
        height: textsHeight
      };
    }

    if (cfg.useHtml) {
      this.labels = [];
      this.labels.push({
        text: cfg.text,
        dim: textDim,
        style: cfg.style
      });
    } else {
      this.labels = texts.map(function (text) {
        return {
          text: text,
          dim: _BaseUtils["default"].getTextDimension(text, cfg.style, cfg.useHtml),
          style: cfg.style
        };
      });
    }
  },
  // 使用直角坐标系时标题与坐标轴整个组件(包含轴标签)的间距为3px
  _getTitleBottomPadding: function () {
    // 不使用直角坐标系时标题与绘图区的间距为0
    if (!this.vanchart.getComponent("xAxis") && !this.vanchart.getComponent("yAxis")) {
      return 0;
    }

    var yAxes = this.vanchart.getComponent("yAxis").options;

    if (yAxes[0].type === _component.ComponentCst.VALUE_AXIS_COMPONENT && (yAxes[0].position === _Constants["default"].LEFT || yAxes[0].position === _Constants["default"].RIGHT)) {
      var axisFontSizeArr = yAxes.map(function (axis) {
        return (0, _EnvUtils.convertREMtoPX)(axis.labelStyle.fontSize);
      });
      return Math.max.apply(Math, axisFontSizeArr) / 2 + DEFAULT_TITLE_BOTTOM_PADDING;
    }

    return DEFAULT_TITLE_BOTTOM_PADDING;
  },
  render: function () {
    if (!this.textBounds || this.textBounds.width < 0 || this.textBounds.height < 0) {
      this.remove();
      return;
    }

    var vanchart = this.vanchart,
        renderer = vanchart.renderer;

    if (!this.titleGroup) {
      this.titleGroup = renderer.vgroup(); //add进componentGroup中，toolbar不会被遮住

      this.titleGroup.renderG.addTo(this.getComponentParentGroup());
      this.titleGroup.divG.add();
      this.titleGroup.divG.style('pointer-events', 'auto');
    }

    this.titleGroup.attr('transform', _BaseUtils["default"].makeTranslate([this.bounds.x, this.bounds.y]));

    this._innerClip(this.titleGroup); // use renderG to avoid style on div


    this.drawBackground(this.titleGroup.renderG);
    this.drawTitle(this.titleGroup);
  },
  drawBackground: function (titleGroup) {
    var cfg = this.options,
        bounds = this.bounds;

    if (cfg.backgroundColor) {
      this.vanchart._renderRectangleBackground(titleGroup, cfg, {
        x: 0,
        y: 0,
        width: bounds.width,
        height: bounds.height
      });
    }
  },
  drawTitle: function (titleGroup) {
    if (this.text) {
      this.text.remove();
      this.text = null;
    }

    var R = this.vanchart.renderer;
    var cfg = this.options;
    var textBounds = this.textBounds;
    var useHtml = cfg.useHtml;
    var align = this.isFloat ? _Constants["default"].LEFT : cfg.align;
    var text = R.vtext(useHtml).attr({
      'transform': _BaseUtils["default"].makeTranslate([textBounds.x, textBounds.y]),
      'width': textBounds.width + 'px',
      'text-align': align,
      'white-space': 'normal'
    });
    this.text = text;
    var svgOffset = useHtml ? {} : _Browser["default"].ie ? {
      'dy': '1em'
    } : {
      'dominant-baseline': 'central',
      'dy': textBounds.height / this.labels.length / 2
    };
    var y = useHtml ? textBounds.height * (LINE_HEIGHT - 1) / 2 : 0;
    this.labels.map(function (label) {
      var dx,
          labelDim = label.dim;

      switch (align) {
        case _Constants["default"].LEFT:
          dx = 0;
          break;

        case _Constants["default"].RIGHT:
          dx = textBounds.width - labelDim.width;
          break;

        case _Constants["default"].CENTER:
        default:
          dx = (textBounds.width - labelDim.width) / 2;
      }

      text.append(R.vtspan(useHtml).attr({
        'y': y,
        'x': 0,
        'dx': dx
      }).attr(svgOffset).style(label.style).style('text-align', align).textContent(label.text));
      y += labelDim.height * LINE_HEIGHT;
    });
    titleGroup.append(text);
  },
  remove: function () {
    this.titleGroup && this.titleGroup.remove();
    this._clip && this._clip.remove && this._clip.remove(); // VmlRender下_clip没有remove方法，会报错

    this.titleGroup = this._clip = null;
  }
});

var _default = Title;
exports["default"] = _default;

/***/ }),
/* 187 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _ToolbarIcon = _interopRequireDefault(__webpack_require__(188));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/7/27.
 * 工具栏组建
 */
var ICON_SIZE = _Constants["default"].TOOLBAR_ICON_SIZE;
var ICON_GAP = 2;
var DEFAULT_GAP = 5;
var GAP = ICON_SIZE + ICON_GAP;
var NONSUPPORT_SORT = [_Constants["default"].GANTT_CHART, _Constants["default"].TREEMAP_CHART, _Constants["default"].WORD_CLOUD_CHART, _Constants["default"].FUNNEL_CHART, _Constants["default"].STRUCTURE_CHART, _Constants["default"].SCATTER_CHART, _Constants["default"].BUBBLE_CHART, _Constants["default"].FORCE_BUBBLE_CHART, _Constants["default"].AREA_MAP, _Constants["default"].POINT_MAP, _Constants["default"].LINE_MAP, _Constants["default"].HEAT_MAP];

var Toolbar = _Base["default"].extend({
  doLayout: function () {
    var options = this.options,
        hidden = options.hidden; // 在这里合并一下toolbar-tooltip-option

    options.tooltip = options.tooltip || {};

    _QueryUtils["default"].merge(options.tooltip, this.getDefaultToolbarTooltipOption());

    var keys = this.sortEnable() ? ['sort', 'toImage', 'fullScreen'] : ['toImage', 'fullScreen'];
    var icons = [_Constants["default"].REFRESH_ICON];
    keys.forEach(function (key) {
      if (options[key] && options[key].enabled) {
        icons.push(key);
      }
    });
    hidden && icons.push(_Constants["default"].MENU_ICON);
    var GAP = ICON_SIZE + ICON_GAP;
    var size = icons.length * GAP + DEFAULT_GAP; //resize的时候translate下

    this.startX = this.vanchart.width - size;

    if (this.toolbarGroup) {
      return;
    }

    this.toolbarIcons = [];
    this.hidden = hidden;

    for (var iconIndex = 0, len = icons.length; iconIndex < len; iconIndex++) {
      var pos = {
        x: iconIndex * GAP,
        y: DEFAULT_GAP
      };
      var type = icons[iconIndex];
      var visible = !hidden;

      if (type === _Constants["default"].MENU_ICON) {
        this.menuIcon = new _ToolbarIcon["default"](type, this, pos, true);
      } else if (type === _Constants["default"].REFRESH_ICON) {
        this.refreshIcon = new _ToolbarIcon["default"](type, this, pos, false);
      } else {
        this.toolbarIcons.push(new _ToolbarIcon["default"](type, this, pos, visible));
      }
    }

    this.isFloat = true;
  },
  sortEnable: function () {
    var sort = true;
    var options = this.vanchart.options,
        seriesData = options.series;
    var chartType;

    if (options.chartType) {
      chartType = options.chartType;
    }

    seriesData && seriesData.forEach(function (sery) {
      if (sery.type) {
        if (chartType && chartType != sery.type) {
          sort = false; //组合图

          return;
        }

        chartType = sery.type;
      }
    });
    return sort && NONSUPPORT_SORT.indexOf(chartType) == -1;
  },
  render: function () {
    var renderer = this.vanchart.renderer;

    if (this.toolbarGroup) {
      this.toolbarGroup.attr('transform', _BaseUtils["default"].makeTranslate([this.startX, 0]));
      return; //工具栏只刷新一次
    } else {
      this.toolbarGroup = this.createComponentGroup().attr('transform', _BaseUtils["default"].makeTranslate([this.startX, 0]));
    }

    this.toolbarIcons.forEach(function (icon) {
      icon.render();
    });
    this.menuIcon && this.menuIcon.render();
    this.refreshIcon && this.refreshIcon.render();
  },
  showOrHide: function () {
    this.hidden = !this.hidden;
    this.hidden ? this.hide() : this.show();
  },
  hide: function () {
    var toolbarIcons = this.toolbarIcons,
        iconSize = toolbarIcons.length,
        delay = [],
        i;

    for (i = 0; i < iconSize; i++) {
      delay.push(100 + 80 * i);
    }

    for (i = 0; i < iconSize; i++) {
      var moveIndex = iconSize - i;
      toolbarIcons[i].hideIcon(moveIndex, delay[i]);
    }

    var left = 4 * (iconSize + 1);
    var right = 4 * (iconSize + 1) + GAP * iconSize;

    if (this.refreshIcon.visible) {
      this.refreshIcon.refreshMove(left, right);
    }
  },
  show: function () {
    var delay = [0],
        toolbarIcons = this.toolbarIcons,
        iconSize = toolbarIcons.length,
        i;

    for (i = 0; i < iconSize - 1; i++) {
      delay.push(100 + 80 * i);
    }

    for (i = 0; i < iconSize; i++) {
      var moveIndex = iconSize - i;
      toolbarIcons[i].showIcon(moveIndex, delay[i]);
    }

    var left = 4 * (iconSize + 1) + GAP * iconSize;
    var right = 4 * (iconSize + 1);

    if (this.refreshIcon.visible) {
      this.refreshIcon.refreshMove(left, right);
    }
  },
  showRefreshIconWhenZoom: function () {
    if (!this.refreshIcon.visible && this.refreshEnabled()) {
      if (this.menuIcon) {
        if (this.hidden) {
          var iconSize = this.toolbarIcons.length;
          var left = 4 * (iconSize + 1);
          var right = 4 * (iconSize + 1) + GAP * iconSize;
          this.refreshIcon.refreshMoveWithoutAnimation(left, right);
          this.refreshIcon.showIcon();
        } else {
          this.refreshIcon.showIcon();
        }
      } else {
        this.refreshIcon.showIcon();
      }
    }
  },
  refreshEnabled: function () {
    return !(this.options.refresh && this.options.refresh.enabled === false);
  },
  getToolBarInitWidth: function () {
    if (!this.options.enabled) {
      return 0;
    }

    if (this.options.hidden) {
      return ICON_SIZE + DEFAULT_GAP;
    } else {
      return this.toolbarIcons.length * (ICON_SIZE + ICON_GAP) - ICON_GAP + DEFAULT_GAP;
    }
  },
  remove: function () {
    this.toolbarGroup && this.toolbarGroup.remove();
    this.toolbarGroup = null;
  },

  /**
   * 默认的toolbar-tooltip-option，用于和给出的options合并，保证能够正常显示工具栏提示
   * @return {Object} [description]
   */
  getDefaultToolbarTooltipOption: function () {
    // 默认是开启工具栏提示的，但是提示内容为空，由后台传入对应的提示文字
    return {
      "enabled": true,
      "content": {
        "menuOpen": "",
        "menuClose": "",
        "sort": "",
        "toImage": "",
        "refresh": "",
        "fullScreenOpen": "",
        "fullScreenClose": ""
      },
      "style": {
        "fontSize": "12pt",
        "fontFamily": "Microsoft Yahei",
        "color": "rgb(255,255,255)"
      },
      "borderRadius": 2,
      "borderWidth": 0,
      "backgroundColor": "rgba(0,0,0,.3)",
      "padding": 5,
      "animation": true
    };
  },

  /**
   * 获取当前显示的toolbar的尺寸
   * @return {Object}
   */
  getToolbarBounds: function () {
    var boundsWidth = this.menuIcon ? ICON_SIZE : 0,
        totalWidth = boundsWidth,
        otherIcons = [this.refreshIcon].concat(this.toolbarIcons);
    otherIcons.forEach(function (icon) {
      if (icon.visible) {
        boundsWidth += ICON_SIZE + ICON_GAP;
      }

      totalWidth += ICON_SIZE + ICON_GAP;
    });
    var boundsX = this.startX + totalWidth - boundsWidth;
    return {
      x: boundsX,
      y: DEFAULT_GAP,
      width: boundsWidth,
      height: ICON_SIZE
    };
  },

  /**
   * 根据icon和提示框尺寸，计算提示框位置的top和left
   * @param  {Object} icon   工具提示对应的Icon
   * @param  {Object} divDim 工具提示框的尺寸
   * @return {Array}         计算后的提示框的left和top值
   */
  calcToolbarTipPos: function (icon, divDim) {
    var toolbarBounds = this.getToolbarBounds();
    var boundsEndX = toolbarBounds.x + toolbarBounds.width;
    var iconStartX = icon.currentPos.x + this.startX;
    var startY = toolbarBounds.y + toolbarBounds.height + ICON_GAP * 2;
    var startX = iconStartX + divDim.width > boundsEndX ? iconStartX + ICON_SIZE - divDim.width : iconStartX;
    return [startX, startY];
  },
  needTooltip: function () {
    var options = this.options;
    return options && options.tooltip && options.tooltip.enabled;
  },

  /**
   * 获取指定类型的icon对象
   * @param iconType
   * @returns {*}
   */
  getIcon: function (iconType) {
    var target,
        i = -1,
        icons = this.toolbarIcons,
        icon;

    while (++i < icons.length) {
      icon = icons[i];

      if (icon.iconType === iconType) {
        target = icon;
        break;
      }
    }

    return target;
  }
});

var _default = Toolbar;
exports["default"] = _default;

/***/ }),
/* 188 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _localeText = _interopRequireDefault(__webpack_require__(32));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/8/24.
 */
var i18nText = _localeText["default"].i18nText;
var RECT_R = 2;
var ICON_SIZE = _Constants["default"].TOOLBAR_ICON_SIZE;

var ToolbarIcon = _Evented["default"].extend({
  initialize: function (iconType, toolbar, pos, visible) {
    this.iconType = iconType;
    this.toolbar = toolbar;
    this.visible = visible;
    this.pos = pos;
    this.currentPos = {
      x: pos.x,
      y: pos.y
    };
  },
  render: function () {
    var toolbar = this.toolbar,
        vanchart = toolbar.vanchart,
        renderer = vanchart.renderer,
        icon = this;

    if (!this.iconG) {
      this.iconG = renderer.group().style({
        'cursor': 'pointer'
      }).addTo(toolbar.toolbarGroup);
    }

    vanchart.registerInteractiveTarget(this, this.iconG);
    this.iconG.attr('transform', 'translate(' + icon.pos.x + ',' + icon.pos.y + ')').style({
      'display': this.visible ? '' : 'none'
    });
    this.iconG.rect = this.iconG.rect || renderer.rect().attr('width', ICON_SIZE).attr('height', ICON_SIZE).attr('rx', RECT_R).attr('ry', RECT_R).addTo(this.iconG);
    this.iconG.rect.style(toolbar.hidden ? CLOSED_NORMAL() : OPEN_NORMAL());
    this.iconG.path = this.iconG.path || this._getIconPathGraphic(vanchart, renderer, icon);
  },
  _getIconPathGraphic: function (vanchart, renderer, icon) {
    switch (this.iconType) {
      case _Constants["default"].REFRESH_ICON:
        return renderer.path().attr('d', icon.getRefreshIconPath()).style(PATH_NORMAL()).addTo(this.iconG);

      case _Constants["default"].SORT:
        if (vanchart.orderType === _Constants["default"].ASCENDING) {
          return renderer.path().attr('d', icon.getDecreaseIconPath()).style(PATH_NORMAL()).addTo(this.iconG);
        } else {
          return renderer.path().attr('d', icon.getIncreaseIconPath()).style(PATH_NORMAL()).addTo(this.iconG);
        }

      case _Constants["default"].EXPORT_ICON:
        return renderer.path().attr('d', icon.getExportIconPath()).style(PATH_NORMAL()).addTo(this.iconG);

      case _Constants["default"].FULL_SCREEN_ICON:
        if (vanchart.vancharts.fullScreenFather) {
          return renderer.path().attr('d', icon.getMinIconPath()).style(PATH_NORMAL()).addTo(this.iconG);
        } else {
          return renderer.path().attr('d', icon.getMaxIconPath()).style(PATH_NORMAL()).addTo(this.iconG);
        }

      case _Constants["default"].MENU_ICON:
        return renderer.path().attr('d', icon.getMenuIconPath()).style(PATH_NORMAL()).addTo(this.iconG);
    }
  },
  refreshMove: function (left, right) {
    var pos = this.pos,
        currentPos = this.currentPos;
    var leftPos = currentPos.x - left,
        rightPos = leftPos + right;
    this.iconG.animate({
      ease: 'circle-out',
      duration: 220,
      attr: {
        transform: 'translate(' + leftPos + ',' + pos.y + ')'
      }
    }).transition({
      ease: 'circle-in',
      duration: 220,
      attr: {
        transform: 'translate(' + rightPos + ',' + pos.y + ')'
      }
    });
    this.currentPos.x = rightPos;
    this.iconG.rect.style(this.toolbar.hidden ? CLOSED_NORMAL() : OPEN_NORMAL());
  },
  refreshMoveWithoutAnimation: function (left, right) {
    var rightPos = this.currentPos.x - left + right;
    this.iconG.attr('transform', 'translate(' + rightPos + ',' + this.pos.y + ')');
    this.currentPos.x = rightPos;
  },
  showIcon: function () {
    this.visible = true;

    if (arguments.length) {
      this._iconAnimation(arguments[0], arguments[1]);
    } else {
      //refresh icon
      this.iconG.style({
        'display': ''
      });
    }
  },
  hideIcon: function () {
    this.visible = false;

    if (arguments.length) {
      this._iconAnimation(arguments[0], arguments[1]);
    } else {
      //refresh icon
      this.iconG.style({
        'display': 'none'
      }); //每次刷新之后，刷新按钮隐藏并且回到初始位置

      this.iconG.attr('transform', 'translate(' + this.pos.x + ',' + this.pos.y + ')');
      this.currentPos.x = this.pos.x;
    }
  },
  _iconAnimation: function (moveIndex, delay) {
    var iconG = this.iconG,
        pos = this.pos,
        visible = this.visible;

    if ((0, _EnvUtils.isSupportSVG)()) {
      _BaseUtils["default"].setTimeout(function () {
        iconG.style({
          'display': ''
        }); // 先置成""保证动画时显示

        var moveDet = 4 * moveIndex,
            leftX = pos.x - moveDet;
        iconG.animate([{
          ease: 'circle-out',
          duration: 100,
          attr: {
            'transform': 'translate(' + leftX + ',' + pos.y + ')'
          }
        }, {
          ease: 'circle-in',
          duration: 100,
          attr: {
            'transform': 'translate(' + pos.x + ',' + pos.y + ')'
          }
        }]).each("end", function () {
          iconG.style({
            'display': visible ? '' : "none"
          }); //动画结束后判断设置"none"隐藏
        });
        iconG.rect.style(visible ? CLOSED_NORMAL() : OPEN_NORMAL()).animate({
          ease: 'linear',
          duration: 200,
          style: visible ? OPEN_NORMAL() : CLOSED_NORMAL()
        });
      }, delay);
    } else {
      iconG.attr('transform', 'translate(' + pos.x + ',' + pos.y + ')').style({
        'display': visible ? '' : 'none'
      });
      iconG.rect.style(visible ? OPEN_NORMAL() : CLOSED_NORMAL());
    }

    this.currentPos.x = this.pos.x;
  },
  onMouseOver: function () {
    this.iconG.path.style(PATH_HOVER());
    this.iconG.rect.style(this.toolbar.hidden ? CLOSED_HOVER() : OPEN_HOVER());
    var toolbar = this.toolbar,
        vanchart = toolbar.vanchart;
    var tipMsg = '',
        icon = this;

    if (toolbar.needTooltip()) {
      switch (icon.iconType) {
        case _Constants["default"].REFRESH_ICON:
          tipMsg = i18nText("refresh");
          break;

        case _Constants["default"].SORT:
          tipMsg = i18nText("sort");
          break;

        case _Constants["default"].EXPORT_ICON:
          tipMsg = i18nText("toImage");
          break;

        case _Constants["default"].FULL_SCREEN_ICON:
          tipMsg = vanchart.vancharts.fullScreenFather ? i18nText("fullScreenClose") : i18nText("fullScreenOpen");
          break;

        case _Constants["default"].MENU_ICON:
          tipMsg = toolbar.hidden ? i18nText("menuOpen") : i18nText("menuClose");
          break;
      } // 有内容时才呈现


      tipMsg && vanchart.showToolbarTooltip(icon, tipMsg);
    }
  },
  onMouseOut: function () {
    this.iconG.path.style(PATH_NORMAL());
    this.iconG.rect.style(this.toolbar.hidden ? CLOSED_NORMAL() : OPEN_NORMAL());
    this.toolbar.vanchart.hideTooltip(); // 地图上面只能通过toolbar的mouseout移除
  },
  onTap: function () {
    var toolbar = this.toolbar;
    var vanchart = toolbar.vanchart;
    var icon = this;
    var dom = vanchart.getDivParentDom();
    vanchart.hideTooltip();

    switch (icon.iconType) {
      case _Constants["default"].REFRESH_ICON:
        vanchart.clearAllEffects();
        vanchart.refreshRestore();
        icon.hideIcon();
        break;

      case _Constants["default"].SORT:
        vanchart.orderType = vanchart.orderType === _Constants["default"].ASCENDING ? _Constants["default"].DESCENDING : _Constants["default"].ASCENDING;
        icon.updateSortIconPath();
        toolbar.refreshEnabled() && toolbar.refreshIcon.showRefreshIcon();
        vanchart.orderData(); // vanchart.orderType = Constants.DISORDER;  todo 这样就只能点一次排序了

        break;

      case _Constants["default"].EXPORT_ICON:
        var size = vanchart.getSize();
        var exportIcon = this.toolbar.options.toImage;
        exportIcon && exportIcon.imageUrl && _BaseUtils["default"].toPng(exportIcon.imageUrl + '&width=' + size.x + '&height=' + size.y);
        break;

      case _Constants["default"].FULL_SCREEN_ICON:
        icon.iconG.path.style(PATH_NORMAL());

        if (vanchart.vancharts.fullScreenFather) {
          vanchart.vancharts.hideLightBox(dom, vanchart.vancharts.fullScreenFather);
        } else {
          vanchart.vancharts.showLightBox(vanchart);
        }

        break;

      case _Constants["default"].MENU_ICON:
        toolbar.showOrHide();
        break;
    }
  },
  showRefreshIcon: function () {
    this.iconG.rect.style(OPEN_NORMAL());
    this.showIcon();
  },

  /**
   *  更新排序按钮的svgPath
   */
  updateSortIconPath: function () {
    this.iconG.path.attr({
      'd': this[this.toolbar.vanchart.orderType === _Constants["default"].ASCENDING ? "getDecreaseIconPath" : "getIncreaseIconPath"]()
    });
  },
  getEvents: function () {
    return {
      mouseover: this.onMouseOver,
      mouseout: this.onMouseOut,
      tap: this.onTap
    };
  },
  getMaxIconPath: function () {
    return 'M14.1166475,16.7288924 C14.4354429,16.4100971 14.9523122,16.4100971 15.2711076,16.7288924 C15.5899029,17.0476878 15.5899029,17.5645571 15.2711076,17.8833525 L15.2711076,17.8833525 L10.786,22.367 L14.0408163,22.3673469 C14.4569807,22.3673469 14.8004098,22.6787634 14.8507825,23.0812752 L14.8571429,23.1836735 C14.8571429,23.6345182 14.491661,24 14.0408163,24 L14.0408163,24 L8.81632653,24 C8.77576028,24 8.73519403,23.996995 8.69499032,23.9909851 C8.6320221,23.9817028 8.57091757,23.9649744 8.51307994,23.9418193 C8.50561165,23.9388276 8.49818233,23.9357314 8.49079082,23.9325206 C8.46589029,23.9216668 8.44167797,23.9096432 8.41818253,23.8964917 C8.41126327,23.8926924 8.40452797,23.8887964 8.3978376,23.8847963 C8.37564103,23.8714409 8.35403077,23.8570711 8.33317612,23.8417338 C8.30037983,23.8176772 8.26887409,23.7906811 8.23909651,23.7609035 L8.30160859,23.8173115 C8.28568335,23.8043593 8.2702558,23.7908187 8.25535903,23.7767229 L8.23909651,23.7609035 C8.23365522,23.7554622 8.22830681,23.7499632 8.22305127,23.7444085 C8.20918129,23.7297442 8.19564074,23.7143166 8.18268852,23.6983914 C8.17403191,23.6878114 8.16592503,23.6773335 8.15810801,23.6667091 C8.14292887,23.6459692 8.12855907,23.624359 8.11522299,23.6020593 C8.11120355,23.595472 8.1073076,23.5887367 8.10351581,23.5819588 C8.09035677,23.558322 8.07833325,23.5341097 8.06751105,23.5092539 C8.0642686,23.5018177 8.0611724,23.4943883 8.05819078,23.4869239 C8.02064736,23.3931679 8,23.2908319 8,23.1836735 L8,23.1836735 L8,17.9591837 C8,17.508339 8.36548184,17.1428571 8.81632653,17.1428571 C9.26717122,17.1428571 9.63265306,17.508339 9.63265306,17.9591837 L9.63265306,17.9591837 L9.632,21.213 Z M23.1836735,8 C23.2242397,8 23.264806,8.00300495 23.3050097,8.00901486 C23.3679779,8.0182972 23.4290824,8.03502564 23.4869201,8.05818075 C23.4943883,8.0611724 23.5018177,8.0642686 23.5092092,8.06747938 C23.5341097,8.07833325 23.558322,8.09035677 23.5818175,8.10350828 C23.5887367,8.1073076 23.595472,8.11120355 23.6021624,8.11520368 C23.624359,8.12855907 23.6459692,8.14292887 23.6668239,8.15826621 C23.6996202,8.18232275 23.7311259,8.20931892 23.7609035,8.23909651 L23.6983914,8.18268852 C23.7143166,8.19564074 23.7297442,8.20918129 23.744641,8.22327706 L23.7609035,8.23909651 C23.7663448,8.24453779 23.7716932,8.25003678 23.7769487,8.25559151 C23.7908187,8.2702558 23.8043593,8.28568335 23.8173115,8.30160859 C23.8259681,8.3121886 23.834075,8.32266652 23.841892,8.33329089 C23.8570711,8.35403077 23.8714409,8.37564103 23.884777,8.39794071 C23.8887964,8.40452797 23.8926924,8.41126327 23.8964842,8.41804115 C23.9096432,8.44167797 23.9216668,8.46589029 23.932489,8.49074615 C23.9357314,8.49818233 23.9388276,8.50561165 23.9418092,8.5130761 C23.9793526,8.60683214 24,8.70916811 24,8.81632653 L24,8.81632653 L24,14.0408163 C24,14.491661 23.6345182,14.8571429 23.1836735,14.8571429 C22.7328288,14.8571429 22.3673469,14.491661 22.3673469,14.0408163 L22.3673469,14.0408163 L22.367,10.786 L17.8833525,15.2711076 C17.5911234,15.5633366 17.1324571,15.5876891 16.8124885,15.3441648 L16.7288924,15.2711076 C16.4100971,14.9523122 16.4100971,14.4354429 16.7288924,14.1166475 L16.7288924,14.1166475 L21.213,9.632 L17.9591837,9.63265306 C17.5430193,9.63265306 17.1995902,9.32123658 17.1492175,8.9187248 L17.1428571,8.81632653 C17.1428571,8.36548184 17.508339,8 17.9591837,8 L17.9591837,8 Z';
  },
  getMinIconPath: function () {
    return 'M14.7264695,16.4775739 C14.7376285,16.4775739 14.7487338,16.4778036 14.759781,16.4782584 C14.7729987,16.4788207 14.7859915,16.4796826 14.798961,16.4808617 C14.8217163,16.4828774 14.8444526,16.4859279 14.8668644,16.4899163 C14.8795309,16.4922349 14.8924942,16.4948734 14.9053979,16.497837 C14.9274759,16.5028468 14.9488792,16.5087421 14.9699017,16.5154877 C14.9830149,16.5197372 14.9960224,16.5242785 15.0089284,16.5291672 C15.0723946,16.5531829 15.1325196,16.5854821 15.1874659,16.6245852 C15.2232346,16.6499864 15.257289,16.6786974 15.2892958,16.7107042 L15.2240163,16.6522092 C15.2416475,16.6663464 15.2586641,16.6812185 15.2750196,16.6967791 L15.2892958,16.7107042 C15.2940584,16.7154668 15.2987481,16.7202748 15.3033647,16.7251267 C15.3187815,16.7413359 15.3336536,16.7583525 15.3477908,16.7759837 C15.3574854,16.7880003 15.3666536,16.8001261 15.375429,16.8124458 C15.4145179,16.8674804 15.4468171,16.9276054 15.4710834,16.9916798 C15.4757215,17.0039776 15.4802628,17.0169851 15.4844567,17.0300797 C15.4912579,17.0511208 15.4971532,17.0725241 15.5021579,17.0942677 C15.5051266,17.1075058 15.5077651,17.1204691 15.5100785,17.1334788 C15.5181941,17.1787098 15.5224261,17.2256259 15.5224261,17.2735305 L15.5191383,17.201039 C15.5203174,17.2140085 15.5211793,17.2270013 15.5217241,17.240005 L15.5224261,17.2735305 L15.5224261,22.3676523 C15.5224261,22.807247 15.1660642,23.1636089 14.7264695,23.1636089 C14.2868749,23.1636089 13.930513,22.807247 13.930513,22.3676523 L13.930513,22.3676523 L13.93,19.195 L9.35878281,23.7668697 C9.07620066,24.0494519 8.63400575,24.0751412 8.3224031,23.8439376 L8.23313027,23.7668697 C7.92228991,23.4560294 7.92228991,22.9520576 8.23313027,22.6412172 L8.23313027,22.6412172 L12.804,18.069 L9.63234767,18.069487 C9.22656799,18.069487 8.89170854,17.7658414 8.84259276,17.3733736 L8.83639113,17.2735305 C8.83639113,16.8339358 9.19275301,16.4775739 9.63234767,16.4775739 L9.63234767,16.4775739 Z M22.6412172,8.23313027 C22.9520576,7.92228991 23.4560294,7.92228991 23.7668697,8.23313027 C24.0777101,8.54397064 24.0777101,9.04794244 23.7668697,9.35878281 L23.7668697,9.35878281 L19.195,13.93 L22.3676523,13.930513 C22.773432,13.930513 23.1082915,14.2341586 23.1574072,14.6266264 L23.1636089,14.7264695 C23.1636089,15.1660642 22.807247,15.5224261 22.3676523,15.5224261 L22.3676523,15.5224261 L17.2735305,15.5224261 C17.2623715,15.5224261 17.2512662,15.5221964 17.240219,15.5217416 C17.2270013,15.5211793 17.2140085,15.5203174 17.201039,15.5191383 C17.1782837,15.5171226 17.1555474,15.5140721 17.1331356,15.5100837 C17.1204691,15.5077651 17.1075058,15.5051266 17.0946021,15.502163 C17.0725241,15.4971532 17.0511208,15.4912579 17.0300983,15.4845123 C17.0169851,15.4802628 17.0039776,15.4757215 16.9910716,15.4708328 C16.9276054,15.4468171 16.8674804,15.4145179 16.8125341,15.3754148 C16.7767654,15.3500136 16.742711,15.3213026 16.7107042,15.2892958 L16.7759837,15.3477908 C16.7583525,15.3336536 16.7413359,15.3187815 16.7249804,15.3032209 L16.7107042,15.2892958 C16.7059416,15.2845332 16.7012519,15.2797252 16.6966353,15.2748733 C16.6812185,15.2586641 16.6663464,15.2416475 16.6522092,15.2240163 C16.6425146,15.2119997 16.6333464,15.1998739 16.624571,15.1875542 C16.5854821,15.1325196 16.5531829,15.0723946 16.5289166,15.0083202 C16.5242785,14.9960224 16.5197372,14.9830149 16.5155433,14.9699203 C16.5087421,14.9488792 16.5028468,14.9274759 16.4978421,14.9057323 C16.4948734,14.8924942 16.4922349,14.8795309 16.4899215,14.8665212 C16.4818059,14.8212902 16.4775739,14.7743741 16.4775739,14.7264695 L16.4808617,14.798961 C16.4796826,14.7859915 16.4788207,14.7729987 16.4782759,14.759995 L16.4775739,14.7264695 L16.4775739,9.63234767 C16.4775739,9.19275301 16.8339358,8.83639113 17.2735305,8.83639113 C17.7131251,8.83639113 18.069487,9.19275301 18.069487,9.63234767 L18.069487,9.63234767 L18.069,12.804 Z';
  },
  getIncreaseIconPath: function () {
    return 'M23.245283,22.4771574 C23.6621017,22.4771574 24,22.8180573 24,23.2385787 C24,23.6591001 23.6621017,24 23.245283,24 L23.245283,24 L8.75471698,24 C8.3378983,24 8,23.6591001 8,23.2385787 C8,22.8180573 8.3378983,22.4771574 8.75471698,22.4771574 L8.75471698,22.4771574 Z M21.4339623,9 C21.8507809,9 22.1886792,9.34089994 22.1886792,9.76142132 L22.1886792,9.76142132 L22.1886792,20.7258883 C22.1886792,21.1464097 21.8507809,21.4873096 21.4339623,21.4873096 C21.0171436,21.4873096 20.6792453,21.1464097 20.6792453,20.7258883 L20.6792453,20.7258883 L20.6792453,9.76142132 C20.6792453,9.34089994 21.0171436,9 21.4339623,9 Z M17.8113208,11.4365482 C18.2281394,11.4365482 18.5660377,11.7774482 18.5660377,12.1979695 L18.5660377,12.1979695 L18.5660377,20.7258883 C18.5660377,21.1464097 18.2281394,21.4873096 17.8113208,21.4873096 C17.3945021,21.4873096 17.0566038,21.1464097 17.0566038,20.7258883 L17.0566038,20.7258883 L17.0566038,12.1979695 C17.0566038,11.7774482 17.3945021,11.4365482 17.8113208,11.4365482 Z M14.1886792,13.8730964 C14.6054979,13.8730964 14.9433962,14.2139964 14.9433962,14.6345178 L14.9433962,14.6345178 L14.9433962,20.7258883 C14.9433962,21.1464097 14.6054979,21.4873096 14.1886792,21.4873096 C13.7718606,21.4873096 13.4339623,21.1464097 13.4339623,20.7258883 L13.4339623,20.7258883 L13.4339623,14.6345178 C13.4339623,14.2139964 13.7718606,13.8730964 14.1886792,13.8730964 Z M10.5660377,16.3096447 C10.9828564,16.3096447 11.3207547,16.6505446 11.3207547,17.071066 L11.3207547,17.071066 L11.3207547,20.7258883 C11.3207547,21.1464097 10.9828564,21.4873096 10.5660377,21.4873096 C10.1492191,21.4873096 9.81132075,21.1464097 9.81132075,20.7258883 L9.81132075,20.7258883 L9.81132075,17.071066 C9.81132075,16.6505446 10.1492191,16.3096447 10.5660377,16.3096447 Z';
  },
  getDecreaseIconPath: function () {
    return 'M23.245283,22.4771574 C23.6621017,22.4771574 24,22.8180573 24,23.2385787 C24,23.6591001 23.6621017,24 23.245283,24 L23.245283,24 L8.75471698,24 C8.3378983,24 8,23.6591001 8,23.2385787 C8,22.8180573 8.3378983,22.4771574 8.75471698,22.4771574 L8.75471698,22.4771574 Z M10.5660377,9 C10.9828564,9 11.3207547,9.34089994 11.3207547,9.76142132 L11.3207547,9.76142132 L11.3207547,20.7258883 C11.3207547,21.1464097 10.9828564,21.4873096 10.5660377,21.4873096 C10.1492191,21.4873096 9.81132075,21.1464097 9.81132075,20.7258883 L9.81132075,20.7258883 L9.81132075,9.76142132 C9.81132075,9.34089994 10.1492191,9 10.5660377,9 Z M14.1886792,11.4365482 C14.6054979,11.4365482 14.9433962,11.7774482 14.9433962,12.1979695 L14.9433962,12.1979695 L14.9433962,20.7258883 C14.9433962,21.1464097 14.6054979,21.4873096 14.1886792,21.4873096 C13.7718606,21.4873096 13.4339623,21.1464097 13.4339623,20.7258883 L13.4339623,20.7258883 L13.4339623,12.1979695 C13.4339623,11.7774482 13.7718606,11.4365482 14.1886792,11.4365482 Z M17.8113208,13.8730964 C18.2281394,13.8730964 18.5660377,14.2139964 18.5660377,14.6345178 L18.5660377,14.6345178 L18.5660377,20.7258883 C18.5660377,21.1464097 18.2281394,21.4873096 17.8113208,21.4873096 C17.3945021,21.4873096 17.0566038,21.1464097 17.0566038,20.7258883 L17.0566038,20.7258883 L17.0566038,14.6345178 C17.0566038,14.2139964 17.3945021,13.8730964 17.8113208,13.8730964 Z M21.4339623,16.3096447 C21.8507809,16.3096447 22.1886792,16.6505446 22.1886792,17.071066 L22.1886792,17.071066 L22.1886792,20.7258883 C22.1886792,21.1464097 21.8507809,21.4873096 21.4339623,21.4873096 C21.0171436,21.4873096 20.6792453,21.1464097 20.6792453,20.7258883 L20.6792453,20.7258883 L20.6792453,17.071066 C20.6792453,16.6505446 21.0171436,16.3096447 21.4339623,16.3096447 Z';
  },
  getExportIconPath: function () {
    return 'M22.2040816,8 C23.1959876,8 24,8.80401245 24,9.79591837 L24,22.2040816 C24,23.1959876 23.1959876,24 22.2040816,24 L9.79591837,24 C8.80401245,24 8,23.1959876 8,22.2040816 L8,9.79591837 C8,8.80401245 8.80401245,8 9.79591837,8 L22.2040816,8 Z M10.938,9.632 L9.79591837,9.63265306 C9.70570184,9.63265306 9.63265306,9.70570184 9.63265306,9.79591837 L9.63265306,22.2040816 C9.63265306,22.2942982 9.70570184,22.3673469 9.79591837,22.3673469 L22.2040816,22.3673469 C22.2942982,22.3673469 22.3673469,22.2942982 22.3673469,22.2040816 L22.3673469,9.79591837 C22.3673469,9.70570184 22.2942982,9.63265306 22.2040816,9.63265306 L20.408,9.632 L20.4081633,13.0612245 C20.4081633,14.2333753 19.4578651,15.1836735 18.2857143,15.1836735 L13.0612245,15.1836735 C11.8890737,15.1836735 10.9387755,14.2333753 10.9387755,13.0612245 L10.938,9.632 Z M18.7755102,9.63265306 L17.795,9.632 L17.7959184,12.0816327 C17.7959184,13.170068 16.1632653,13.170068 16.1632653,12.0816327 L16.163,9.632 L12.5714286,9.63265306 L12.5714286,13.0612245 C12.5714286,13.3316859 12.7907631,13.5510204 13.0612245,13.5510204 L18.2857143,13.5510204 C18.5561757,13.5510204 18.7755102,13.3316859 18.7755102,13.0612245 L18.7755102,9.63265306 Z';
  },
  getRefreshIconPath: function () {
    return 'M15.6862142,8 C18.5585489,8 21.1138764,9.65340502 22.4321668,12.1605737 L22.4313849,9.14285714 C22.4313849,8.69201245 22.7825313,8.32653061 23.2156924,8.32653061 C23.6488535,8.32653061 24,8.69201245 24,9.14285714 L24,9.14285714 L24,14.3673469 C24,14.8181916 23.6488535,15.1836735 23.2156924,15.1836735 L23.2156924,15.1836735 L18.196124,15.1836735 C17.7629628,15.1836735 17.4118164,14.8181916 17.4118164,14.3673469 C17.4118164,13.9165022 17.7629628,13.5510204 18.196124,13.5510204 L18.196124,13.5510204 L21.3358345,13.551001 C20.4040081,11.2204507 18.1970324,9.63265306 15.6862142,9.63265306 C12.3076405,9.63265306 9.56861515,12.4834978 9.56861515,16 C9.56861515,19.5165022 12.3076405,22.3673469 15.6862142,22.3673469 C17.7918319,22.3673469 19.7129682,21.2525916 20.8328732,19.4435664 C21.0492604,19.0943863 21.2322453,18.7239964 21.3789252,18.3372949 C21.5379879,17.9179477 21.9935479,17.7122097 22.3964469,17.8777661 C22.7993459,18.0433224 22.9970143,18.5174804 22.8379515,18.9368276 C22.6533472,19.4235116 22.4231464,19.889474 22.1512707,20.3281946 C20.745732,22.598615 18.3306267,24 15.6862142,24 C11.4413183,24 8,20.4181916 8,16 C8,11.5818084 11.4413183,8 15.6862142,8 Z';
  },
  getMenuIconPath: function () {
    return 'M10,14 C11.1048,14 12,14.8952 12,16 C12,17.1048 11.1048,18 10,18 C8.8952,18 8,17.1048 8,16 C8,14.8952 8.8952,14 10,14 Z M16,14 C17.1048,14 18,14.8952 18,16 C18,17.1048 17.1048,18 16,18 C14.8952,18 14,17.1048 14,16 C14,14.8952 14.8952,14 16,14 Z M22,14 C23.1048,14 24,14.8952 24,16 C24,17.1048 23.1048,18 22,18 C20.8952,18 20,17.1048 20,16 C20,14.8952 20.8952,14 22,14 Z';
  }
}); // icon的几种背景颜色


function OPEN_NORMAL() {
  return {
    'fill': 'black',
    'fill-opacity': 0.05,
    'cursor': 'pointer'
  };
}

function OPEN_HOVER() {
  return {
    'fill': 'black',
    'fill-opacity': 0.1,
    'cursor': 'pointer'
  };
}

function CLOSED_NORMAL() {
  return {
    'fill': 'black',
    'fill-opacity': 0,
    'cursor': 'pointer'
  };
}

function CLOSED_HOVER() {
  return {
    'fill': 'black',
    'fill-opacity': 0.05,
    'cursor': 'pointer'
  };
} // icon的颜色


function PATH_NORMAL() {
  return {
    fill: '#757575'
  };
}

function PATH_HOVER() {
  return {
    fill: '#00A1E6'
  };
}

var _default = ToolbarIcon;
exports["default"] = _default;

/***/ }),
/* 189 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Base = _interopRequireDefault(__webpack_require__(11));

var _component = __webpack_require__(4);

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 15/10/12.
 */
//缩放控件默认的高度
var HEIGHT = 30;
var WIDTH = 10; // 缩放控件的最小高度和最大高度

var HEIGHT_MIN = 10,
    HEIGHT_MAX = 25;
var DIRECTION_NONE = 'none';
var DIRECTION_LEFT_TO_RIGHT = 'left-to-right';
var DIRECTION_RIGHT_TO_LEFT = 'right-to-left';
var MAGIC_ACCURACY = 0.0000001;
var PADDING = 4;

var PADDING_FUN = function () {
  return _BaseUtils["default"].paddingConvertWithScale(PADDING);
};

var Zoom = _Base["default"].extend({
  _refresh: function () {
    this.rangeLeftTop = this.rangeRightBottom = null;
  },
  doLayout: function () {
    this.byAxisType = this.vanchart.chartType() == _Constants["default"].BAR_CHART ? 'yAxis' : 'xAxis';
    this.byAxis = this.vanchart[this.byAxisType]();
    /**
     * CHART-1192
     * 这里判断有没有dataSheet，如果有的话，会在dataSheet的updateAxisSizeAndBounds函数中对Zoom的bounds进行赋值，
     * 如果没有在这里就计算了Zoom的bounds。
     */

    !this.vanchart.components[_component.ComponentCst.DATA_SHEET_COMPONENT] && this.calcZoomControlsSize();
  },
  fixBoundsByPlot: function () {
    if (!this.zoomToolEnabled()) {
      return;
    }

    var positionAxis,
        axisCompo = this.vanchart.components[this.byAxisType];
    var axisCount = axisCompo.getAxisCount();

    for (var axisIndex = 0; axisIndex < axisCount; axisIndex++) {
      var axis = axisCompo.getAxis(axisIndex),
          position = axis.getPosition();

      if (position == _Constants["default"].BOTTOM || position == _Constants["default"].LEFT) {
        positionAxis = axis;
      }
    }

    positionAxis = positionAxis || this.byAxis;
    var plotBounds = this.vanchart.bounds;

    if (positionAxis.isHorizontal()) {
      this.bounds = _BaseUtils["default"].makeBounds(plotBounds.x, this.bounds.y, plotBounds.width, this.bounds.height);
    } else {
      this.bounds = _BaseUtils["default"].makeBounds(this.bounds.x, plotBounds.y, this.bounds.width, plotBounds.height);
    }
  },
  initToolDomain: function (axis) {
    var tool = this.options.zoomTool;
    tool.from = (0, _CoreUtils.hasDefined)(tool.from) && tool.from !== '' ? tool.from : null;
    tool.to = (0, _CoreUtils.hasDefined)(tool.to) && tool.to !== '' ? tool.to : null;

    if (axis.type === _component.ComponentCst.DATE_AXIS_COMPONENT) {
      tool.from = tool.from == null ? tool.from : _BaseUtils["default"].date2int(_BaseUtils["default"].object2date(tool.from));
      tool.to = tool.to == null ? tool.to : _BaseUtils["default"].date2int(_BaseUtils["default"].object2date(tool.to));
    } // 多分类轴的from和to格式化


    if (axis.type === _component.ComponentCst.CATEGORY_AXIS_COMPONENT && axis.isMultiCateAxis()) {
      tool.from = _BaseUtils["default"].encodeCategoryArray(tool.from);
      tool.to = _BaseUtils["default"].encodeCategoryArray(tool.to);
    }
  },
  getZoomInitDomain: function (zoomAxis) {
    var axis = this.byAxis; // CHART-1002
    // 当图表中有gaugeAxis的时候，在VanChart.js中update函数中，
    // 没有对zoomAxis进行初始化就在这里调用zoomTool的各种方法和属性，
    // 显然会报错，所以这里做一下错误处理

    if (this.zoomToolEnabled() && axis && axis._isBaseAxis() && zoomAxis == axis) {
      var tool = this.options.zoomTool;
      this.initToolDomain(axis);
      return [tool.from, tool.to];
    }
  },
  getZoomDomain: function (zoomAxis) {
    var axis = this.byAxis,
        dataDomain = zoomAxis.isCategory() ? axis._dataDomain : axis._domain;

    if (this.zoomToolEnabled() && axis._isBaseAxis() && zoomAxis == axis) {
      var tool = this.options.zoomTool;
      this.initToolDomain(axis);
      var zoomToolFrom = tool.from;
      var zoomToolTo = tool.to;
      var isCategory = axis.isCategory();

      if (!isCategory) {
        isNaN(parseFloat(zoomToolFrom)) && (zoomToolFrom = null);
        isNaN(parseFloat(zoomToolTo)) && (zoomToolTo = null);
      }

      var from = _BaseUtils["default"].pick(this.rangeLeftTop, zoomToolFrom, dataDomain[0]);

      var to = _BaseUtils["default"].pick(this.rangeRightBottom, zoomToolTo, dataDomain[dataDomain.length - 1]);

      return this._getValidDomain(from, to, dataDomain, isCategory);
    }
  },
  getMinAndMaxPos: function () {
    var domain = this.getZoomDomain(this.byAxis),
        scale = this.axisScale;
    var x1 = scale(domain[0]),
        x2 = scale(domain[domain.length - 1]);
    return [Math.min(x1, x2), Math.max(x1, x2) + (scale.rangeBand ? scale.rangeBand() - MAGIC_ACCURACY : 0)]; // 这边+rangeBand可能会丢失精度从而导致得到的值比scale(next)大一点点点，这边做一下细微的调整
  },
  //只有分类轴排序以后会调用这个方法
  updateRangeLeftAndRight: function (cateAxis, lastDomain, currentDomain) {
    var leftIndex = _BaseUtils["default"].indexOf(lastDomain, this.rangeLeftTop);

    var rightIndex = _BaseUtils["default"].indexOf(lastDomain, this.rangeRightBottom);

    var domain = currentDomain.slice(Math.min(leftIndex, rightIndex), Math.max(leftIndex, rightIndex) + 1);

    if (cateAxis.isAxisReversed() ^ cateAxis.isHorizontal()) {
      this.rangeLeftTop = domain[0];
      this.rangeRightBottom = domain[domain.length - 1];
    } else {
      this.rangeLeftTop = domain[domain.length - 1];
      this.rangeRightBottom = domain[0];
    }
  },
  _getValidDomain: function (from, to, dataDomain, isCategory) {
    var tmp;

    if (isCategory) {
      var maxIndex = dataDomain.length - 1;
      var minIndex = 0;
      from = (0, _CoreUtils.isEmpty)(from) ? minIndex : _BaseUtils["default"].indexOf(dataDomain, from);
      to = (0, _CoreUtils.isEmpty)(to) ? maxIndex : _BaseUtils["default"].indexOf(dataDomain, to);
      from = Math.min(Math.max(from, minIndex), maxIndex);
      to = Math.min(Math.max(to, minIndex), maxIndex);

      if (from > to) {
        tmp = to;
        to = from;
        from = tmp;
      }

      return dataDomain.slice(from, to + 1);
    } else {
      from = parseFloat(from);
      to = parseFloat(to);

      if (from > to) {
        tmp = to;
        to = from;
        from = tmp;
      }

      return [from, to];
    }
  },
  zoomToolEnabled: function () {
    var opt = this.options;
    return this.vanchart.series.length && opt && opt.zoomTool && opt.zoomTool.enabled && (0, _EnvUtils.supportFillFilter)();
  },

  /**
   * 计算缩放控件的高度或者宽度（取决于当前控件的绘制位置）
   */
  calcZoomControlsSize: function () {
    if (!this.zoomToolEnabled()) {
      return false;
    }

    var dataSheet = this.vanchart.getComponent(_component.ComponentCst.DATA_SHEET_COMPONENT),
        plotBounds = this.vanchart.bounds,
        isHorizontal = this.byAxis.isHorizontal(),
        padding = PADDING_FUN();
    var validHeight = isHorizontal ? plotBounds.height : plotBounds.width;
    var calcZoomHeight = (validHeight - 2 * padding) / 22.3;
    HEIGHT = calcZoomHeight < HEIGHT_MIN ? HEIGHT_MIN : calcZoomHeight > HEIGHT_MAX ? HEIGHT_MAX : calcZoomHeight | 0;
    WIDTH = Math.ceil(HEIGHT / 3);

    this._setComponentBounds(isHorizontal ? _Constants["default"].BOTTOM : _Constants["default"].LEFT, HEIGHT + padding * 2); // 在这里更新一下尺寸，方便下面计算位置时直接使用


    if (isHorizontal) {
      this.bounds.y += padding + dataSheet && dataSheet.bounds ? dataSheet.bounds.height : 0;
      this.bounds.height -= 2 * padding;
    } else {
      this.bounds.x += padding;
      this.bounds.width -= 2 * padding;
    }
  },
  _getAxisScale: function () {
    var axis = this.byAxis,
        scale = axis.scale.copy();

    if (axis.type == _component.ComponentCst.CATEGORY_AXIS_COMPONENT) {
      scale.rangeBand ? scale.rangeBands(axis._getPlotRange()) : scale.range(axis._getPlotRange());
    } else {
      var domain = axis._dataDomain,
          zoomDomain = this.getZoomDomain(axis);
      var min = Math.min(domain[0], zoomDomain[0]);
      var max = Math.max(domain[1], zoomDomain[1]); //不用日期类型，全部是毫秒数
      // if(axis.type == ComponentLibrary.DATE_AXIS_COMPONENT){
      //     min = BaseUtils.int2date(min);
      //     max = BaseUtils.int2date(max);
      // }

      scale.domain([min, max]);
    }

    return scale;
  },
  render: function () {
    this.remove();

    if (this.zoomBarGroup || !this.zoomToolEnabled()) {
      return;
    }

    this.axisScale = this._getAxisScale();
    var zoomBar = this,
        bounds = zoomBar.bounds,
        vanchart = zoomBar.vanchart,
        renderer = vanchart.renderer;
    var pos = this.getMinAndMaxPos(),
        isVertical = this.byAxis.isVertical();
    var minPos = pos[0],
        maxPos = pos[1];

    if (!this.zoomBarGroup) {
      this.zoomBarGroup = this.createComponentGroup().attr('transform', _BaseUtils["default"].makeTranslate(bounds)).style('cursor', isVertical ? 'ns-resize ' : 'ew-resize');
      vanchart.registerInteractiveTarget(this, this.zoomBarGroup);
    }

    this._createLines();

    this.leftTopRect = this._createSideRect(isVertical, minPos, true);
    this.rightBottomRect = this._createSideRect(isVertical, maxPos, false);
    this.centerRect = this._createCenterRect(isVertical, minPos, maxPos);
    this.leftTopButton = this._createButton(isVertical, minPos, true);
    this.rightBottomButton = this._createButton(isVertical, maxPos, false);
    var l_transX = this.leftTopButton.pos,
        r_transX = this.rightBottomButton.pos;
    this.rangeLeftTop = this._getValueByPosition(l_transX);
    this.rangeRightBottom = this._getValueByPosition(r_transX + WIDTH);
  },
  //缩放底边上的线
  _createLines: function () {
    var axisScale = this.axisScale,
        byAxisType = this.byAxisType,
        vanchart = this.vanchart,
        renderer = vanchart.renderer,
        series = vanchart.series;
    var det = axisScale.rangeBand ? axisScale.rangeBand() / 2 : 0,
        catePoints = vanchart.cateMap;
    var linePoints = [],
        min = Number.MAX_VALUE,
        max = -Number.MAX_VALUE;
    var isHorizontal = this.byAxis.isHorizontal(),
        isDate = this.byAxis.type === _component.ComponentCst.DATE_AXIS_COMPONENT;

    for (var key in catePoints) {
      var points = catePoints[key];
      var value;

      if (points[0].series[byAxisType]) {
        value = 0; //todo 是否要取绝对值

        points.forEach(function (point) {
          value += +point.getTargetValue() || 0;
        });
      } // @CHART-10498


      if (value != null) {
        linePoints.push({
          'x': axisScale(isDate ? _BaseUtils["default"].date2int(_BaseUtils["default"].object2date(key)) : key) + det,
          'y': value
        });
      }

      min = Math.min(min, value);
      max = Math.max(max, value);
    }

    var yRange = isHorizontal ? [HEIGHT, 0] : [0, HEIGHT];

    var yScale = _Scale["default"].linear().domain([min, max]).range(yRange);

    var lineSvg = _PathGenerator["default"].line().interpolate("linear").x(function (d) {
      return isHorizontal ? d.x : yScale(d.y);
    }).y(function (d) {
      return isHorizontal ? yScale(d.y) : d.x;
    });

    linePoints.sort(function (pA, pB) {
      return pA.x - pB.x;
    });
    this._line = this._line || renderer.path().style({
      fill: 'none',
      stroke: 'black',
      'stroke-width': 1
    });

    this._line.attr('d', lineSvg(linePoints)).addTo(this.zoomBarGroup); //保证折线不超过区域


    this._innerClip(this._line);
  },
  _getStartEndPos: function () {
    return this.byAxis._getPlotRange().sort(function (a, b) {
      return a - b;
    });
  },
  _createSideRect: function (isVertical, pos, isLeftTop) {
    var renderer = this.vanchart.renderer;

    var startEndPos = this._getStartEndPos();

    var x = 'x',
        y = 'y',
        width = 'width',
        height = 'height',
        size = startEndPos[1];

    if (isVertical) {
      x = 'y';
      y = 'x';
      width = 'height';
      height = 'width';
    }

    var xPos, xWidth;

    if (isLeftTop) {
      xPos = startEndPos[0];
      xWidth = Math.abs(pos - xPos);
    } else {
      xPos = pos;
      xWidth = Math.abs(size - xPos);
    }

    return renderer.rect().attr(x, xPos).attr(y, 0).attr(width, xWidth).attr(height, HEIGHT).style({
      'fill': 'rgba(220,221,221,0.4)'
    }).addTo(this.zoomBarGroup);
  },
  _createCenterRect: function (isVertical, startX, endX) {
    var renderer = this.vanchart.renderer;
    var x = 'x',
        y = 'y',
        width = 'width',
        height = 'height';

    if (isVertical) {
      x = 'y';
      y = 'x';
      width = 'height';
      height = 'width';
    }

    return renderer.rect().attr(x, startX + WIDTH).attr(y, 0).attr(width, endX - startX - 2 * WIDTH).attr(height, HEIGHT).style({
      'fill': 'rgba(255,255,255,0)',
      'stroke': '#29ABE2',
      'stroke-width': 1
    }).addTo(this.zoomBarGroup);
  },

  /**
   * 创建缩放控件按钮:
   * 由于现在的控件高度是不固定的，因此要根据控件高度来计算buttonPath。
   * 此外，内部的线的宽度和数量也要考虑到控件的大小而做出变化
   * @param  {Boolean} isVertical 样式水平或者数值
   * @param  {Number}  startPos   按钮起始位置
   * @param  {Boolean} isLeftTop  是否为Left或Top按钮
   * @return {Object}             按钮对象
   */
  _createButton: function (isVertical, startPos, isLeftTop) {
    startPos = isLeftTop ? startPos : startPos - WIDTH;
    var renderer = this.vanchart.renderer;
    var button = renderer.group().attr('transform', this._getButtonTranslate(isVertical, startPos));
    var lineStyle = {
      'fill': '#FFFFFF',
      'stroke': '#7ADAF4',
      'stroke-width': 2,
      'stroke-linecap': 'round',
      'stroke-linejoin': 'round',
      'stroke-miterlimit': 10
    };
    var buttonPath;

    if (isLeftTop) {
      if (isVertical) {
        buttonPath = this.buttonPathGenerator(HEIGHT, WIDTH, WIDTH / 3, [0, 0, 1, 1]);
      } else {
        buttonPath = this.buttonPathGenerator(WIDTH, HEIGHT, WIDTH / 3, [0, 1, 1, 0]);
      }
    } else {
      if (isVertical) {
        buttonPath = this.buttonPathGenerator(HEIGHT, WIDTH, WIDTH / 3, [1, 1, 0, 0]);
      } else {
        buttonPath = this.buttonPathGenerator(WIDTH, HEIGHT, WIDTH / 3, [1, 0, 0, 1]);
      }
    }

    renderer.path().attr('d', buttonPath).style({
      'fill': '#29ABE2'
    }).addTo(button);
    var x1 = 'x1',
        y1 = 'y1',
        x2 = 'x2',
        y2 = 'y2',
        startY = Math.ceil(HEIGHT / 4),
        endY = HEIGHT - startY;

    if (isVertical) {
      x1 = 'y1';
      y1 = 'x1';
      x2 = 'y2';
      y2 = 'x2';
    }

    var lineWidth = lineStyle['stroke-width'] = Math.floor(WIDTH / 5) || 1;
    var needSecondLine = WIDTH >= 5;
    var startX1 = needSecondLine ? (WIDTH - lineWidth * 2) / 3 : (WIDTH - lineWidth) / 2;
    var startX2 = needSecondLine ? (WIDTH - lineWidth * 2) / 3 * 2 + lineWidth : 0;
    renderer.line().attr(x1, startX1).attr(y1, startY).attr(x2, startX1).attr(y2, endY).style(lineStyle).addTo(button);

    if (needSecondLine) {
      renderer.line().attr(x1, startX2).attr(y1, startY).attr(x2, startX2).attr(y2, endY).style(lineStyle).addTo(button);
    }

    button.pos = startPos;
    button.addTo(this.zoomBarGroup);
    return button;
  },

  /**
   * 按钮路径生成器:根据给定的参数，生成带有指定圆角的svg矩形路径。
   * @param  {Number} width  [矩形宽度]
   * @param  {Number} height [矩形高度]
   * @param  {Number} r      [圆角大小]
   * @param  {Array} arr     [角形状,1表示尖角,0表示圆角]
   * @return {String}        [svg path string]
   */
  buttonPathGenerator: function (width, height, r, arr) {
    var endPoints = [[0, 0], [width, 0], [width, height], [0, height]],
        curvePoints = [[0, r], [r, 0], [width - r, 0], [width, r], [width, height - r], [width - r, height], [r, height], [0, height - r], [0, r]];
    var path = 'M' + point(curvePoints[0]) + move(0) + move(1) + move(2) + move(3) + 'z';
    return path;

    function point(arr) {
      return arr.join(',');
    }

    function move(index) {
      var p1 = endPoints[index],
          p2 = curvePoints[index * 2 + 1];
      var str = '';

      if (arr[index]) {
        str = 'L' + point(p1) + 'L' + point(p2);
      } else {
        str = 'Q' + point(p1) + ',' + point(p2);
      }

      return str + 'L' + point(curvePoints[index * 2 + 2]);
    }
  },
  _findDraggingTarget: function (ev) {
    var event = ev.srcEvent,
        src = event.target || event.srcElement;

    var pos = this.byAxis.isHorizontal() ? ev.containerPoint.x - this.bounds.x : ev.containerPoint.y - this.bounds.y,
        resizeable = this._resizeable();

    var target;

    while (src) {
      //by position
      var leftTopDet = this.leftTopButton.pos - pos;
      var rightBottomDet = pos - (this.rightBottomButton.pos + WIDTH);

      if (leftTopDet > 0 && leftTopDet < 10 && resizeable) {
        target = this.leftTopButton;
      }

      if (rightBottomDet > 0 && rightBottomDet < 10 && resizeable) {
        target = this.rightBottomButton;
      }

      if (target) {
        break;
      } //by dom


      if (src == this.leftTopButton.node() && resizeable) {
        target = this.leftTopButton;
      } else if (src == this.rightBottomButton.node() && resizeable) {
        target = this.rightBottomButton;
      } else if (src == this.centerRect.node() || src == this.zoomBarGroup.node()) {
        target = this.centerRect;
      }

      if (target) {
        break;
      }

      src = src.parentNode;
    }

    return target;
  },
  _panStart: function (ev, target) {
    this.target = target || this._findDraggingTarget(ev);

    if (this.target) {
      this.downPos = this.byAxis.isHorizontal() ? ev.containerPoint.x : ev.containerPoint.y;
      this.initPos = this.target.pos;
      this.initTranslate = 0;
      this.vanchart._zooming = true;
    }
  },
  _panContainerMove: function (ev) {
    if (this.target) {
      var pos = this.byAxis.isHorizontal() ? ev.containerPoint.x : ev.containerPoint.y;
      var direction = pos < this.downPos ? DIRECTION_LEFT_TO_RIGHT : DIRECTION_RIGHT_TO_LEFT;

      this._centerRectMove(this.downPos, this.downPos + this.downPos - pos);

      this._zoomRefresh(direction);
    }
  },
  _panMove: function (ev) {
    var direction = DIRECTION_NONE,
        pos = this.byAxis.isHorizontal() ? ev.containerPoint.x : ev.containerPoint.y; //如果是拖拽的话要保持显示的分类个数不变

    if (!this.target || this.downPos == pos) {
      return;
    }

    switch (this.target) {
      case this.leftTopButton:
        this._leftButtonMove(this.downPos, this.initPos, pos);

        break;

      case this.rightBottomButton:
        this._rightButtonMove(this.downPos, this.initPos, pos);

        break;

      case this.centerRect:
        direction = this._centerRectMove(this.downPos, pos);
        break;
    }

    this._zoomRefresh(direction);
  },
  _leftButtonMove: function (downPos, initPos, currentPos) {
    var startEndPos = this._getStartEndPos();

    var minTransPos = startEndPos[0],
        maxTransPos = this.rightBottomButton.pos - WIDTH;
    var trans = initPos + currentPos - downPos;
    var isVertical = this.byAxis.isVertical();
    trans = Math.max(Math.min(trans, maxTransPos), minTransPos);
    this.leftTopButton.pos = trans;
    var width = 'width',
        x = 'x';

    if (isVertical) {
      width = 'height';
      x = 'y';
    }

    this.leftTopButton.attr('transform', this._getButtonTranslate(isVertical, trans));
    this.leftTopRect.attr(width, trans);
    this.centerRect.attr(x, trans + WIDTH).attr(width, maxTransPos - trans);
  },
  _rightButtonMove: function (downPos, initPos, currentPos) {
    var startEndPos = this._getStartEndPos();

    var size = startEndPos[1],
        x = 'x',
        width = 'width';
    var isVertical = this.byAxis.isVertical();

    if (isVertical) {
      x = 'y';
      width = 'height';
    }

    var maxTransPos = size - WIDTH,
        minTransPos = this.leftTopButton.pos + WIDTH;
    var trans = initPos + currentPos - downPos;
    trans = Math.max(Math.min(trans, maxTransPos), minTransPos);
    this.rightBottomButton.pos = trans;
    this.rightBottomButton.attr('transform', this._getButtonTranslate(isVertical, trans));
    this.rightBottomRect.attr(x, trans + WIDTH).attr(width, size - (trans + WIDTH));
    this.centerRect.attr(width, trans - minTransPos);
  },
  _centerRectMove: function (downPos, currentPos) {
    var startEndPos = this._getStartEndPos();

    var endPos = startEndPos[1],
        det = currentPos - downPos - this.initTranslate;
    var x = 'x',
        width = 'width';
    var isVertical = this.byAxis.isVertical();

    if (isVertical) {
      x = 'y';
      width = 'height';
    }

    this.initTranslate = currentPos - downPos;

    if (this.leftTopButton.pos + det >= startEndPos[0] && this.rightBottomButton.pos + WIDTH + det <= endPos) {
      var l_trans = this.leftTopButton.pos + det;
      this.leftTopButton.pos = l_trans;
      this.leftTopButton.attr('transform', this._getButtonTranslate(isVertical, l_trans));
      this.leftTopRect.attr(width, l_trans);
      var r_trans = this.rightBottomButton.pos + det;
      this.rightBottomButton.pos = r_trans;
      this.rightBottomButton.attr('transform', this._getButtonTranslate(isVertical, r_trans));
      this.rightBottomRect.attr(x, r_trans + WIDTH).attr(width, endPos - (r_trans + WIDTH));
      this.centerRect.attr(x, l_trans + WIDTH);
    }

    return this.initTranslate > 0 ? DIRECTION_LEFT_TO_RIGHT : DIRECTION_RIGHT_TO_LEFT;
  },
  _getValueByPosition: function (x) {
    var axis = this.byAxis,
        scale = this.axisScale;

    switch (axis.type) {
      case _component.ComponentCst.CATEGORY_AXIS_COMPONENT:
        var domain = scale.domain(),
            range = scale.range(); // category对应的range，应该为左闭右开或者左开右闭，否则不能划分边界值

        for (var i = 0, len = range.length - 1; i < len; i++) {
          if (x >= range[i] && x < range[i + 1]) {
            return domain[i];
          } else if (x < range[i] && x >= range[i + 1]) {
            return domain[i + 1];
          }
        }

        return range[0] > range[range.length - 1] ? domain[0] : domain[domain.length - 1];

      case _component.ComponentCst.DATE_AXIS_COMPONENT:
        return _BaseUtils["default"].date2int(this.axisScale.invert(x));

      default:
        return this.axisScale.invert(x);
    }
  },
  _getButtonTranslate: function (isVertical, pos) {
    var translate = isVertical ? [0, pos] : [pos, 0];
    return 'translate(' + translate + ')';
  },
  _zoomRefresh: function (direction) {
    var l_trans = this.leftTopButton.pos,
        r_trans = this.rightBottomButton.pos + WIDTH;

    var rangeLeftTop = this._getValueByPosition(l_trans);

    var rangeRightBottom = this._getValueByPosition(r_trans);

    var vanchart = this.vanchart,
        axis = this.byAxis,
        dataDomain = axis._dataDomain,
        indexOfCate = _BaseUtils["default"].indexOf;
    var dataSheet = vanchart.getComponent(_component.ComponentCst.DATA_SHEET_COMPONENT);
    var domain;

    if (axis.isCategory()) {
      if (direction == DIRECTION_NONE) {
        domain = this._getValidDomain(rangeLeftTop, rangeRightBottom, dataDomain, true);
      } else {
        var cateCount = indexOfCate(dataDomain, this.rangeLeftTop) - indexOfCate(dataDomain, this.rangeRightBottom);
        cateCount = Math.abs(cateCount) + 1; //在平移过程中需要显示的分类个数

        if (direction == DIRECTION_LEFT_TO_RIGHT && rangeRightBottom != this.rangeRightBottom) {
          if (axis.isAxisReversed() ^ axis.isHorizontal()) {
            var endIndex = indexOfCate(dataDomain, rangeRightBottom);
            var startIndex = endIndex - cateCount + 1;
            rangeLeftTop = dataDomain[startIndex];
            rangeRightBottom = dataDomain[endIndex];
            domain = dataDomain.slice(startIndex, endIndex + 1);
          } else {
            var startIndex = indexOfCate(dataDomain, rangeRightBottom);
            var endIndex = startIndex + cateCount - 1;
            rangeLeftTop = dataDomain[endIndex];
            rangeRightBottom = dataDomain[startIndex];
            domain = dataDomain.slice(startIndex, endIndex + 1);
          }
        } else if (direction == DIRECTION_RIGHT_TO_LEFT && rangeLeftTop != this.rangeLeftTop) {
          if (axis.isAxisReversed() ^ axis.isHorizontal()) {
            var startIndex = indexOfCate(dataDomain, rangeLeftTop);
            var endIndex = startIndex + cateCount - 1;
            rangeLeftTop = dataDomain[startIndex];
            rangeRightBottom = dataDomain[endIndex];
            domain = dataDomain.slice(startIndex, endIndex + 1);
          } else {
            var endIndex = indexOfCate(dataDomain, rangeLeftTop);
            var startIndex = endIndex - cateCount + 1;
            rangeLeftTop = dataDomain[endIndex];
            rangeRightBottom = dataDomain[startIndex];
            domain = dataDomain.slice(startIndex, endIndex + 1);
          }
        } else {
          //平移的时候考虑移动的方向
          rangeLeftTop = this.rangeLeftTop;
          rangeRightBottom = this.rangeRightBottom;
        }
      } //中间滑块移动的时候，调整以后可能不需要更新


      if (this.rangeLeftTop != rangeLeftTop || this.rangeRightBottom != rangeRightBottom) {
        this.rangeLeftTop = rangeLeftTop;
        this.rangeRightBottom = rangeRightBottom;
        axis.zoomRefresh(domain);
        axis.fixScaleAndTickData();
        axis.render();

        if (dataSheet) {
          dataSheet.zoomRefresh();
        }

        vanchart.reRenderSeries();
      }
    } else {
      domain = this._getValidDomain(rangeLeftTop, rangeRightBottom, dataDomain, false);
      this.rangeLeftTop = rangeLeftTop;
      this.rangeRightBottom = rangeRightBottom;
      axis.zoomRefresh(domain);
      axis.fixScaleAndTickData();
      axis.render();
      vanchart.reRenderSeries();
    }
  },
  _panEnd: function () {
    this.target = null;
    this.vanchart._zooming = false;
  },
  _resizeable: function () {
    return this.options && this.options.zoomTool && this.options.zoomTool.resize;
  },
  getEvents: function () {
    return {
      "panstart": this._panStart,
      "panmove": _BaseUtils["default"].throttle(this._panMove, 16, this),
      //60帧应该很流畅了
      "panend": this._panEnd
    };
  },
  remove: function () {
    this.zoomBarGroup && this.zoomBarGroup.remove();
    this.zoomBarGroup = null;
  },

  /**
   * 判断缩放控件在拖拽方向上是否到达边界
   * 需要考虑缩放控件的位置，拖拽方向，拖拽目标等因素
   * @param ev
   * @returns {boolean}
   */
  isPanMovingAtTheBoundary: function (ev) {
    var direction = ev.direction;
    var leftward = direction === _Constants["default"].DIRECTION_LEFT,
        rightward = direction === _Constants["default"].DIRECTION_RIGHT,
        upward = direction === _Constants["default"].DIRECTION_UP,
        downward = direction === _Constants["default"].DIRECTION_DOWN;
    var isHorizontal = this.byAxis.isHorizontal(),
        leftTopButtonPos = this.leftTopButton.pos,
        rightBottomButtonPos = this.rightBottomButton.pos;
    var size = this.bounds[isHorizontal ? "width" : "height"];

    var equal = function (a, b) {
      return Math.abs(a - b) < 0.0000001; // 差值小于这个即可认为是相等的了，只要兼容浮点数
    };

    var isLeftTopButtonAtMinTrans = equal(leftTopButtonPos, 0),
        isLeftTopButtonAtMaxTrans = equal(leftTopButtonPos, rightBottomButtonPos - WIDTH),
        isRightButtonButtonAtMaxTrans = equal(rightBottomButtonPos, size - WIDTH);

    if (isHorizontal) {
      // 具体目标具体对待
      switch (this.target) {
        case this.leftTopButton:
          return leftward && isLeftTopButtonAtMinTrans || rightward && isLeftTopButtonAtMaxTrans;

        case this.rightBottomButton:
          return leftward && isLeftTopButtonAtMaxTrans || rightward && isRightButtonButtonAtMaxTrans;

        case this.centerRect:
          return leftward && isLeftTopButtonAtMinTrans || rightward && isRightButtonButtonAtMaxTrans;
      }
    } else {
      switch (this.target) {
        case this.leftTopButton:
          return upward && isLeftTopButtonAtMinTrans || downward && isLeftTopButtonAtMaxTrans;

        case this.rightBottomButton:
          return upward && isLeftTopButtonAtMaxTrans || downward && isRightButtonButtonAtMaxTrans;

        case this.centerRect:
          return upward && isLeftTopButtonAtMinTrans || downward && isRightButtonButtonAtMaxTrans;
      }
    }

    return false;
  }
});

var _default = Zoom;
exports["default"] = _default;

/***/ }),
/* 190 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 *
 * Created by Jeffrey on 2018/7/3.
 */
var CROSS_COLOR = '#98B4CD';
var LINE_STYLE = {
  'fill': 'none',
  'stroke': CROSS_COLOR,
  'stroke-width': 1
};

var CrossLine = _Base["default"].extend({
  doLayout: function () {},
  render: function () {
    if (!this.group) {
      this.group = this.vanchart.crossLineGroup;
      var R = this.vanchart.renderer;
      this.group.style('display', 'none');
      this._vLine = R.line({
        x1: 0,
        y1: 0,
        x2: 0,
        y2: 2000 // no need to update

      }).style(LINE_STYLE);
      this._hLine = R.line({
        x1: 0,
        y1: 0,
        x2: 2000,
        y2: 0
      }).style(LINE_STYLE);
      this._vLine.name = 'v';
      this._hLine.name = 'h';
      this.group.append(this._vLine);
      this.group.append(this._hLine);
    }
  },
  show: function () {
    this.group && this.group.style('display', '');
  },
  hide: function () {
    this.group && this.group.style('display', 'none');
  },
  setPos: function (x, y, ani) {
    if (!this.group) {
      return;
    }

    this.centerPos = [x, y];

    this._translateLine(this._vLine, [x, 0], ani);

    this._translateLine(this._hLine, [0, y], ani);

    this.show();
  },
  _translateLine: function (line, pos, ani) {
    if (ani) {
      line.interrupt(line.name).transition(line.name).ease('ease').duration(250).attr('transform', _BaseUtils["default"].makeTranslate(pos));
    } else {
      line.interrupt(line.name).attr('transform', _BaseUtils["default"].makeTranslate(pos));
    }
  }
});

var _default = CrossLine;
exports["default"] = _default;

/***/ }),
/* 191 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ManagerPie = _interopRequireDefault(__webpack_require__(192));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/8/2.
 */
var H = 16,
    W = 20,
    POINTER_COLOR = 'rgba(255, 255, 255, 0.6)',
    BORDER_WIDTH = 5,
    BORDER_COLOR = 'rgba(255, 255, 255, 0.3)';
var ANIMATION = 'pieIndicatorAnimation';

function pointerSideY(r) {
  return -Math.sqrt(r * r - W / 2 * (W / 2));
}

function getPointerPath(r) {
  var dy = pointerSideY(r);
  var points = [[0, dy + H], // bottom
  [-W / 2, dy], // left
  [-W / 2, dy - 10], [W / 2, dy - 10], [W / 2, dy] // right
  ];
  var d = points.join(' L');
  return 'M' + d + 'Z';
}

var PieIndicator = _Base["default"].extend({
  doLayout: function () {
    if (this.group) {
      this.group.remove();
      this.group = null;
    }
  },
  show: function () {
    this.group && this.group.interrupt(ANIMATION).transition(ANIMATION).duration(0).style('opacity', 1);
  },
  hide: function () {
    this.group && this.group.interrupt(ANIMATION).transition(ANIMATION).delay(500).ease('ease').duration(200).style('opacity', 0);
  },
  render: function () {
    var series = this.vanchart.series;

    if (series.length !== 1) {
      return;
    }

    if (!this.__manager) {
      this.__manager = new _ManagerPie["default"](this.vanchart.handler);
      this.vanchart.handler.registerManager(this.__manager);
    }

    if (!this.group) {
      var R = this.vanchart.renderer;
      this.group = R.group({
        'class': 'pie-indicator'
      }).add();
      var chartInfo = series[0].chartInfo;
      var r = chartInfo.radius;
      this.group.style({
        opacity: 0,
        transform: _BaseUtils["default"].makeTranslateWithPX([chartInfo.centerX, chartInfo.centerY])
      });
      this.clip = R.createClip({
        r: r
      }, 'circle');
      R.clip(this.group, this.clip);
      var pointerPath = getPointerPath(r);
      this.ringMask = R.mask();

      var maskId = _BaseUtils["default"].stamp(this.ringMask);

      this.ringMask.attr('id', maskId);
      this.ringMask.append(R.circle({
        r: r + BORDER_WIDTH,
        fill: 'white'
      }));
      this.ringMask.append(R.path({
        d: pointerPath,
        fill: 'black'
      }));
      this.pointer = R.path({
        d: pointerPath
      }).style({
        fill: POINTER_COLOR
      });
      this.group.append(this.ringMask);
      this.group.append(this.pointer);
    }
  }
});

var _default = PieIndicator;
exports["default"] = _default;

/***/ }),
/* 192 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _AbstractManager = _interopRequireDefault(__webpack_require__(26));

var _component = __webpack_require__(4);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/8/6.
 */
var PI_2 = Math.PI * 2;
var PIE_ROTATE_ANI = 'PIE_ROTATE_ANI'; // var POINTER_RADIAN = 270 * Math.PI / 180;
// here's rotation 0 means top-middle, clockwise 270 degree

function calcFineRotation(sector) {
  var centerAngle = (sector.startAngle + sector.endAngle) / 2;
  return -centerAngle;
}

function findSectorByRadian(points, rotation, targetRadian) {
  if (points.length <= 1) {
    return;
  }

  if (targetRadian == null) {
    targetRadian = PI_2;
  }

  var targetRadian2 = targetRadian + PI_2;
  var sector;
  points.some(function (p) {
    var s = p.startAngle + rotation,
        e = p.endAngle + rotation;
    var angle = e - s; // limit s within [0, 2pi)

    s = (s % PI_2 + PI_2) % PI_2; // so e [2pi, )

    e = s + angle;

    if (s <= targetRadian && targetRadian <= e || s <= targetRadian2 && targetRadian2 <= e) {
      sector = p;
      return true;
    }
  });
  return sector;
}

var _default = _AbstractManager["default"].extend({
  initialize: function () {
    _AbstractManager["default"].prototype.initialize.apply(this, arguments);

    var self = this; // 奇技淫巧……

    this.vanchart.setTimeout('firstPieRotation', function () {
      self._rotateToFirstSector();

      self.vanchart.resize();
    }, 1);
    this._lastSector = null;
  },
  z: 20,
  name: 'pie',
  getBoundingRect: function () {
    return this.vanchart.bounds;
  },
  // _shouldPan: function (pos) {
  //     var chartInfo = this._getPieSeries().chartInfo;
  //     if (chartInfo && chartInfo.radius) {
  //         var d = BaseUtils.distance(pos, { x: chartInfo.centerX, y: chartInfo.centerY });
  //         return d <= chartInfo.radius
  //     }
  // },
  _getPieSeries: function () {
    return this.vanchart.series[0];
  },
  _moveStart: function () {
    var pie = this._getPieSeries();

    pie._removeDataLabels();

    this.vanchart.getComponent(_component.ComponentCst.PIE_INDICATOR).show();
  },
  _moveEnd: function () {
    this._reshowLabel();

    this.vanchart.getComponent(_component.ComponentCst.PIE_INDICATOR).hide();
  },
  _reshowLabel: function () {
    var pie = this._getPieSeries();

    pie._calculateLabelPosWhenRadiusFixed();

    pie._rotateLabels();
  },
  _rotatePie: function (angle) {
    var pie = this._getPieSeries();

    pie._getPointGraphicGroup().interrupt(PIE_ROTATE_ANI);

    pie._getPointGraphicGroup().attr("transform", "rotate(" + angle + ")");

    pie.chartInfo.rotate = _BaseUtils["default"].toRadian(angle);
  },
  _rotatePieTransition: function (angle, cb) {
    var pie = this._getPieSeries();

    pie._getPointGraphicGroup().interrupt(PIE_ROTATE_ANI).transition(PIE_ROTATE_ANI).ease('ease').duration(100).attr("transform", "rotate(" + angle + ")").each('end', function () {
      // console.log('end');
      pie.chartInfo.rotate = _BaseUtils["default"].toRadian(angle);
      cb && cb();
    });
  },
  _findSectorByTapPos: function (ev) {
    var pie = this._getPieSeries(); // the angle is from normal start point: right-middle


    var angle = pie._getAngle(pie._getPositionInPie(ev.containerPoint));

    var radian = _BaseUtils["default"].toRadian(angle); // normalize radian to [0, 2pi)


    radian = (radian + Math.PI / 2 + PI_2) % PI_2;
    return findSectorByRadian(pie.points, pie.chartInfo.rotate, radian);
  },
  _attachVanXYToEvent: function (e) {
    var pie = this._getPieSeries();

    var chartInfo = pie.chartInfo;
    var p = {
      x: chartInfo.centerX,
      y: chartInfo.centerY - chartInfo.radius
    };
    var srcEvent = e.srcEvent;
    srcEvent.vanX = p.x;
    srcEvent.vanY = p.y + this.vanchart.vancharts.getCarouselChartOffset();
  },
  ontap: function (e) {
    e.stop();

    var sector = e.target || this._findSectorByTapPos(e);

    if (sector) {
      this._attachVanXYToEvent(e);

      sector.fire('tap', e);
      var self = this;
      var radian = calcFineRotation(sector);

      self._moveStart();

      this._rotatePieTransition(_BaseUtils["default"].toDegree(radian), function () {
        self._moveEnd();
      });
    }
  },
  onpanstart: function (ev) {
    if (!ev.target) {
      return;
    }

    ev.stop();
    this._lastSector = null;

    var pie = this._getPieSeries();

    this._moveStart();

    pie.initPos = ev.containerPoint;
    pie.initRotate = _BaseUtils["default"].toDegree(pie.chartInfo.rotate);
  },
  onpanmove: function (ev) {
    var pie = this._getPieSeries();

    if (!pie.initPos) {
      return;
    }

    this._attachVanXYToEvent(ev);

    ev.stop();

    var startAngle = pie._getAngle(pie._getPositionInPie(pie.initPos));

    var newAngle = pie._getAngle(pie._getPositionInPie(ev.containerPoint));

    var rotate = newAngle - startAngle + pie.initRotate;

    this._rotatePie(rotate);

    var sector = findSectorByRadian(pie.points, pie.chartInfo.rotate, PI_2);

    if (this._lastSector !== sector) {
      this._lastSector = sector;
      sector && sector.fire('tap', ev);
    }
  },
  onpanend: function (ev) {
    var pie = this._getPieSeries();

    if (!pie.initPos) {
      return;
    }

    this._attachVanXYToEvent(ev);

    ev.stop();
    var sector = findSectorByRadian(pie.points, pie.chartInfo.rotate, PI_2);

    if (sector) {
      var self = this;
      var radian = calcFineRotation(sector);

      this._rotatePieTransition(_BaseUtils["default"].toDegree(radian), function () {
        self._moveEnd();
      });
    } else {
      this._moveEnd();
    }

    pie.initPos = pie.initRotate = this.vanchart.handler.panTarget = null;
  },
  _rotateToFirstSector: function () {
    var pie = this._getPieSeries();

    var sector = pie.points[0];

    if (sector) {
      var radian = calcFineRotation(sector);

      this._rotatePie(_BaseUtils["default"].toDegree(radian));

      pie._removeDataLabels();

      this._reshowLabel();
    }
  }
});

exports["default"] = _default;

/***/ }),
/* 193 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _Base = _interopRequireDefault(__webpack_require__(11));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _ScrollbarItem = _interopRequireDefault(__webpack_require__(61));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/7/5.
 */
var MIN_BAR_LENGTH = 20;
var BAR_SIZE = 4; // the same as BI

var THUMB_COLOR = 'rgba(61,77,102,0.3)';

function toFixed(value) {
  return +value.toFixed(3);
}
/**
 * 再看一年前写的scrollbar代码
 * 感觉味道都不对……
 */


var Scroll = _Evented["default"].extend({
  initialize: function (options) {
    this.vanchart = options.vanchart;
    this.renderer = this.vanchart.renderer;
    this.group = options.group;
    this.options = options;
    this.x = this.y = 0; // inner bounds translation

    this.barX = this._barBottom();
    this.barY = this._barRight();
  },
  show: function (d) {
    this.barX && this.barX.show(d);
    this.barY && this.barY.show(d);
  },
  setPos: function (pos) {
    if (this.barX && pos.x != null) {
      var pctX = pos.x / (this.options.width - this.options.innerWidth) || 0;
      this.barX.setPct(pctX);
    }

    if (this.barY && pos.y != null) {
      var pctY = pos.y / (this.options.height - this.options.innerHeight) || 0;
      this.barY.setPct(pctY);
    }
  },
  // resize, bar group pos and bar size
  setSize: function (options) {
    var lengths = this._getLengths(options, 'width');

    this.barX.setPos(0, this._getBarY());
    this.barX.setSize(lengths.length, lengths.barLength);

    var lengths = this._getLengths(options, 'height');

    this.barY.setPos(this._getBarX(), 0);
    this.barY.setSize(lengths.length, lengths.barLength);

    _BaseUtils["default"].extend(this.options, options);
  },
  _barBottom: function () {
    var lengths = this._getLengths(this.options, 'width');

    return this._bar('x', 0, this._getBarY(), lengths.length, lengths.barLength);
  },
  _barRight: function () {
    var lengths = this._getLengths(this.options, 'height');

    return this._bar('y', this._getBarX(), 0, lengths.length, lengths.barLength);
  },
  _getBarX: function () {
    return this.options.width - BAR_SIZE - 1;
  },
  _getBarY: function () {
    return this.options.height - BAR_SIZE - 1;
  },
  _getLengths: function (options, prop) {
    var outer = options[prop];
    var inner = prop === 'width' ? options.innerWidth : options.innerHeight;
    var length = outer;
    return {
      length: length,
      barLength: Math.max(outer / inner * length, MIN_BAR_LENGTH)
    };
  },

  /**
   *
   * @param dir 'x'/'y'
   * @param x translate x
   * @param y translate y
   * @param length background length
   * @param barLength
   * @private
   */
  _bar: function (dir, x, y, length, barLength) {
    var bar = new _ScrollbarItem["default"]({
      manager: this,
      group: this.group,
      x: x,
      y: y,
      length: length,
      barLength: barLength,
      dir: dir,
      backgroundSize: BAR_SIZE,
      backgroundColor: 'none',
      backgroundStroke: 'none',
      barColor: THUMB_COLOR,
      barHoverColor: THUMB_COLOR,
      barSize: BAR_SIZE
    });

    if (length === barLength) {
      bar.show(false);
    }

    return bar;
  },
  onx: function (pct) {
    this.fire('scrollX', {
      initiator: this,
      x: pct * (this.options.width - this.options.innerWidth)
    });
  },
  ony: function (pct) {
    this.fire('scrollY', {
      initiator: this,
      y: pct * (this.options.height - this.options.innerHeight)
    });
  },
  _isScrollX: function (options) {
    return options.scrollX && toFixed(options.width) < toFixed(options.innerWidth);
  },
  _isScrollY: function (options) {
    return options.scrollY && toFixed(options.height) < toFixed(options.innerHeight);
  },
  _isScrollBoth: function (options) {
    return this._isScrollX(options) && this._isScrollY(options);
  },
  remove: function () {
    this.barX && this.barX.remove();
    this.barY && this.barY.remove();
    this.barX = this.barY = null;
  }
});

var PlotScroll = _Base["default"].extend({
  doLayout: function () {},
  isExist: function () {
    return this.__inited;
  },
  show: function () {
    this.scroll && this.scroll.show(true);
  },
  hide: function () {
    this.scroll && this.scroll.show(false);
  },
  _getMaxZoom: function (axis) {
    var bounds = this.vanchart.bounds;

    if (axis.isCategory()) {
      var zoom = this.vanchart.getPlotZoom();

      if (axis.componentType[0] === 'x') {
        return Math.max(1, bounds.width / axis.scale.rangeBand(), zoom.x);
      } else {
        return Math.max(1, bounds.height / axis.scale.rangeBand(), zoom.y);
      }
    } else {
      // value max scale 10
      return 10;
    }
  },
  _getAxisInfo: function (axis) {
    var len = axis.getAxisCount();
    var domains = [],
        maxZoom = 0;

    for (var i = 0; i < len; ++i) {
      var a = axis.getAxis(i);
      domains.push(a._domain);
      maxZoom = Math.max(maxZoom, this._getMaxZoom(a));
    }

    return {
      domains: domains,
      maxZoom: maxZoom
    };
  },
  updateInitState: function () {
    this.__inited = true; // store some axis values for zoom

    var xAxisInfo = this._getAxisInfo(this.vanchart.components.xAxis);

    var yAxisInfo = this._getAxisInfo(this.vanchart.components.yAxis);

    this.xDomains = xAxisInfo.domains;
    this.yDomains = yAxisInfo.domains;
    this.xMaxZoom = xAxisInfo.maxZoom;
    this.yMaxZoom = yAxisInfo.maxZoom;
  },
  render: function () {
    if (!this.vanchart.hasScroll()) {
      return;
    }

    if (!this.__inited) {
      this.updateInitState();
    }

    var vanchart = this.vanchart,
        bounds = vanchart.bounds,
        plotScrollBounds = vanchart.getPlotContentBounds(),
        axisSize = vanchart.axisSize;

    if (!this.scroll) {
      var R = vanchart.renderer;
      this.group = R.group({
        'class': 'van-plot-scroll'
      }).add(); // todo, update

      this.group.attr('transform', _BaseUtils["default"].makeTranslate([bounds.x, bounds.y]));
      this.scroll = new Scroll({
        vanchart: vanchart,
        group: this.group,
        width: bounds.width,
        height: bounds.height,
        innerWidth: bounds.width,
        innerHeight: bounds.height
      });
      this.hide();
    }

    this.scroll.setSize({
      width: bounds.width,
      height: bounds.height,
      innerWidth: plotScrollBounds.width,
      innerHeight: plotScrollBounds.height
    }); // console.log(plotScrollBounds);

    this.scroll.setPos(plotScrollBounds);
  }
});

var _default = PlotScroll;
exports["default"] = _default;

/***/ }),
/* 194 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _Gauge = _interopRequireDefault(__webpack_require__(50));

var _interpolator = _interopRequireDefault(__webpack_require__(16));

var _slotAndRing = __webpack_require__(82);

var _ThemeConfig = __webpack_require__(17);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/8/9.
 * 刻度槽仪表盘
 */
var SLOT_PADDING_PERCENT = 0.08; //槽型仪表盘内边距占比

var SLOT_NEEDLE_PERCENT = 0.3; //指针半径占滑槽宽度的比例

var SLOT_PANE_BACKGROUND_OPACITY = 1; //槽型仪表盘底盘颜色不透明度

var SLOT_PANE_RADIAN = {
  startRadian: _BaseUtils["default"].toRadian(-135),
  endRadian: _BaseUtils["default"].toRadian(135)
}; // 刻度槽的起始弧度和终止弧度

var SlotGauge = _Gauge["default"].extend({
  gaugeType: _Constants["default"].SLOT_GAUGE,
  _doLayout: function () {
    (0, _slotAndRing.dealSlotAndRingPercentLabel)(this, SLOT_PADDING_PERCENT);
    (0, _slotAndRing.dealSlotAndRingValueLabel)(this, SLOT_PADDING_PERCENT);

    this._fixCenterAndRadius(SLOT_PADDING_PERCENT);
  },
  _getFixedPos: function (datum, divDim) {
    var gauge = datum.series;
    var x = gauge.centerX + gauge.radius * 1.08 + 10; //这里的10是啥？

    var y = gauge.centerY - divDim.height / 2;
    return [x, y];
  },
  drawSeries: function () {
    var series = this,
        options = series.options,
        point = series.points[0],
        vanchart = series.vanchart,
        renderer = vanchart.renderer,
        group = series.group;
    var slotPercent = options.circleWidth;
    var slotRadius = series.radius * (1 - slotPercent / 2);

    if (!this.backgruondPath) {
      this.backgruondPath = renderer.path().addTo(group);
    }

    if (!this.slotBackground) {
      this.slotBackground = renderer.path().addTo(group);
      this.needlePath = renderer.circle().addTo(group);
    }

    this.labelGroup = this._getPointTextLabelGroup();

    var arc = _PathGenerator["default"].arc().startAngle(SLOT_PANE_RADIAN.startRadian).endAngle(SLOT_PANE_RADIAN.endRadian).innerRadius(0).outerRadius(slotRadius).toCenter(false).closePath(false);

    var circle = _PathGenerator["default"].arc().startAngle(SLOT_PANE_RADIAN.startRadian).endAngle(SLOT_PANE_RADIAN.endRadian).innerRadius(0).outerRadius(slotRadius).toCenter(false).closePath(false);

    var arcPercentage = _BaseUtils["default"].getValueInDomain(point.percentage, [0, 1]);

    var slotBackgroundColor = (0, _ThemeConfig.getThemeAutoValue)(options.slotBackgroundColor, 'paneBackgroundColor', vanchart.isDarkTheme());
    series.backgruondPath.attr('d', circle()).style({
      'fill': 'none',
      'stroke': slotBackgroundColor,
      'stroke-linecap': 'round',
      "stroke-opacity": SLOT_PANE_BACKGROUND_OPACITY,
      'stroke-width': Math.max(series.radius * slotPercent - 1, 0) // CHART-12839

    });

    if (!point || point.isNull) {
      if (series.slotBackground) {
        series.slotBackground.remove();
        series.needlePath.remove();
        series.slotBackground = series.needlePath = null;
      }

      series._removeNormalLabels(this.labelGroup);
    } else {
      var initRadian = SLOT_PANE_RADIAN.startRadian,
          endRadian = (SLOT_PANE_RADIAN.endRadian - SLOT_PANE_RADIAN.startRadian) * arcPercentage + initRadian;

      var endDegree = _BaseUtils["default"].toDegree(endRadian - initRadian);

      var endStroke = point.color;
      series.slotBackground.style({
        'fill': 'none',
        'stroke': _ColorUtils["default"].colorToHex(endStroke),
        'stroke-linecap': 'round',
        'stroke-width': series.radius * slotPercent
      }); //白色指针

      var slotNeedleRadius = SLOT_NEEDLE_PERCENT * slotPercent * series.radius;

      var cP = this._getArcPoint(slotRadius, initRadian);

      series.needlePath.attr('cx', cP[0]).attr('cy', cP[1]).attr('r', slotNeedleRadius).style({
        'fill': options.needle,
        'fill-opacity': _ColorUtils["default"].getColorOpacity(options.needle)
      });

      if (series.vanchart.renderer.isAnimation) {
        series.slotBackground.animate({
          duration: series.ANIMATION_TIME,
          ease: series.EASE_TYPE,
          attrTween: {
            'd': function () {
              this._lastRadian_ = this._lastRadian_ || initRadian;
              var interpolate = (0, _interpolator["default"])(this._lastRadian_, endRadian);
              this._lastRadian_ = endRadian;
              return function (t) {
                return arc.endAngle(interpolate(t))();
              };
            }
          }
        });
        series.needlePath.animate({
          duration: series.ANIMATION_TIME,
          ease: series.EASE_TYPE,
          attrTween: {
            'transform': function () {
              this._lastRotate_ = this._lastRotate_ || 0;
              var interpolate = (0, _interpolator["default"])(this._lastRotate_, endDegree);
              this._lastRotate_ = endDegree;
              return function (t) {
                return "rotate(" + interpolate(t) + ")";
              };
            }
          }
        });
      } else {
        //todo ie bug
        var pathStr = arc.endAngle(endRadian)();

        var pos = series._getArcPoint(slotRadius, endRadian);

        var x = pos[0],
            y = pos[1],
            r = series.radius * slotPercent / 8;

        if (Math.abs(endRadian - initRadian) < 1e-6) {
          var arc = 'a' + r + ',' + r + ' 0 1,0 ';
          pathStr = 'M' + (x - r) + ',' + y + arc + r * 2 + ',0 ' + arc + -r * 2 + ',0 ';
        }

        series.slotBackground.attr('d', pathStr).style({
          'stroke-linecap': 'round'
        });
        series.needlePath.attr({
          'cx': pos[0],
          'cy': pos[1]
        });
      }
    }

    this._drawGaugeLabels(this.labelGroup);
  },
  _onSeriesMouseOver: function (ev) {
    _Gauge["default"].prototype._onSeriesMouseOver.call(this, ev);

    var point = this.points[0];

    if (point) {
      var backgroundColor = _ColorUtils["default"].getHighLightColor(point.color);

      var needleColor = _ColorUtils["default"].getHighLightColor(this.options.needle);

      this._onState(this.slotBackground, true, {
        'stroke': _ColorUtils["default"].colorToHex(backgroundColor)
      });

      this._onState(this.needlePath, true, {
        'fill': needleColor
      });
    }
  },
  _onSeriesMouseOut: function (ev) {
    _Gauge["default"].prototype._onSeriesMouseOut.call(this, ev);

    var point = this.points[0];

    if (point) {
      this._onState(this.slotBackground, false, {
        'stroke': point.color
      });

      this._onState(this.needlePath, false, {
        'fill': point.options.needle
      });
    }
  },
  onSeriesPress: function () {
    var point = this.points[0];

    if (point) {
      var backgroundColor = _ColorUtils["default"].getColorWithDivider(point.color, 1 / 0.95);

      var needleColor = _ColorUtils["default"].getColorWithDivider(this.options.needle, 1 / 0.95);

      this.slotBackground.style({
        'stroke': _ColorUtils["default"].colorToHex(backgroundColor)
      });
      this.needlePath.style({
        'fill': needleColor
      });
    }
  },
  onSeriesPressUp: function () {
    this._onSeriesMouseOver();
  },
  getDefaultTooltipFormatter: function () {
    return {
      categoryFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{CATEGORY}{VALUE}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = SlotGauge;
exports["default"] = _default;

/***/ }),
/* 195 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Series = _interopRequireDefault(__webpack_require__(13));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _EffectHelper = _interopRequireDefault(__webpack_require__(18));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _CoreUtils = __webpack_require__(3);

var _StyleUtils = __webpack_require__(29);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Mitisky on 16/3/24.
 */
var SCATTER_INIT_TIME = 300;
var SCATTER_UPDATE_TIME = 500;
var LABEL_GAP = 2;
var MAP_SCATTER_STATE_EASE = _BezierEasing["default"].custom["ease-out-back"];
var MAP_SCATTER_STATE_DURATION = 300;

var Scatter = _Series["default"].extend({
  doLayout: function () {
    var isInverted = this.vanchart.isInverted();
    var xAxis = this.xAxis,
        yAxis = this.yAxis;
    this.points.forEach(function (point) {
      var det = xAxis.scale.rangeBand ? xAxis.scale.rangeBand() / 2 : 0;
      var t1 = xAxis.scale(xAxis.getAxisValue(point.options.x)) + det;
      var t2 = yAxis.scale(yAxis.getAxisValue(point.options.y));
      point.posX = isInverted ? t2 : t1;
      point.posY = isInverted ? t1 : t2;

      if (point.labelDim) {
        var marker = point.options.marker,
            markerRadius = _BaseUtils["default"].isImageMarker(marker.symbol) ? marker.height / 2 : marker.radius;
        point.labelPos = {
          x: point.posX - point.labelDim.width / 2,
          y: point.posY - markerRadius - LABEL_GAP - point.labelDim.height
        };
      }
    });
    var series = this;

    var lineSvg = _PathGenerator["default"].line().interpolate(series.interpolate).x(function (d) {
      return d.posX;
    }).y(function (d) {
      return d.posY;
    }).defined(function (d) {
      return !d.isNull;
    });

    this.points.sort(function (pointA, pointB) {
      return pointA.posX - pointB.posX;
    });
    this.linePath = lineSvg(this.points);
  },
  useCanvas: function () {
    return this.options.large;
  },
  //用来计算百分比的指标的名字,相当于value的含义
  getTargetKey: function () {
    return 'size';
  },
  isNullValue: function (point) {
    var options = point.options;

    if (this.vanchart.isMap()) {
      return options.size == '-' || (0, _CoreUtils.hasNotDefined)(options.size);
    } else {
      return options.x == '-' || options.y == '-' || (0, _CoreUtils.hasNotDefined)(options.y) || !point.isLogAxisValidValue();
    }
  },
  _calculateLabelPos: function (point) {},
  getTrendLineXYValues: function (sery) {
    return this._getNormalTrendLineXYValues(sery);
  },
  _getFixedPos: function (point) {
    var vanchart = this.vanchart,
        plotBounds = vanchart.bounds,
        radius = point.options.marker && point.options.marker.radius || 0;
    var pos;

    if (vanchart.vanChartType == 'vanChartMap') {
      var latlng = point.getLatLng();

      if (!latlng) {
        return;
      }

      pos = vanchart.latLngToContainerPoint(latlng);
    } else {
      pos = {
        x: plotBounds.x + point.posX,
        y: plotBounds.y + point.posY
      };
    }

    radius = (radius + 1) / 1.414;
    return [pos.x + radius, pos.y + radius];
  },
  _animateEnd: function () {
    this._showLabels();

    this._drawEffectPoints();

    var series = this,
        vanchart = series.vanchart,
        renderer = vanchart.renderer;
    var _series$options = series.options,
        lineWidth = _series$options.lineWidth,
        lineType = _series$options.lineType;

    if (!series.group) {
      series.group = series._createGroup(renderer, vanchart).attr('transform', _BaseUtils["default"].makeTranslate(series._getTranslate())).attr('class', series.className + ' ' + series.type);
    } // 当系列visible为true且linePath存在的时候，再去绘制lineGraphic


    if (series.visible && series.linePath) {
      series.lineGraphic = series.lineGraphic || renderer.path({
        'd': series.linePath
      }).addTo(series.group);
      series.lineGraphic.style((0, _StyleUtils.getLineStyle)({
        color: series.color,
        lineWidth: lineWidth,
        lineType: lineType
      }));
      series.lineGraphic.style({
        'pointer-events': 'none'
      });
    }
  },
  calcMoreLabelPosition: function (point, moreLabelDim) {
    var chartBounds = this.vanchart.bounds;
    var startX = point.posX + chartBounds.x,
        startY = point.posY + chartBounds.y;
    return {
      startX: startX,
      startY: startY,
      direction: "top"
    };
  },
  effectAnimation: function (d) {
    _EffectHelper["default"].markerEffectAnimation(d, this.vanchart.isMap());
  },
  getDefaultEffectTime: function () {
    return _EffectHelper["default"].MARKER_EFFECT_TIME;
  },
  _getPointKey: function (point) {
    var option = point.options || point;
    return this.vanchart.isMap() ? point.name : '' + option.x + option.y;
  },
  getAttrs: function (p) {
    return {
      'transform': _BaseUtils["default"].makeTranslate({
        x: p.posX,
        y: p.posY
      })
    };
  },
  _updatePointGraphicStyle: function (point) {
    this._updateMarkerPointGraphic(point);

    this._updateMarker(point);
  },
  updatePointGraphic: function (point) {
    this._updateMarkerPointGraphic(point);
  },
  _createPointGraphic: function (point) {
    return point.graphic = this._createMarker(point.options.marker);
  },
  getPointInitAttr: function (point) {
    return {
      'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(0.01)'
    };
  },
  getPointInitAnimationAttr: function (point) {
    return {
      delay: point.delayTime,
      ease: 'back-out',
      duration: SCATTER_INIT_TIME,
      attr: {
        'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(1)'
      }
    };
  },
  getPointReShowAnimationAttr: function (point) {
    return {
      ease: 'back-out',
      duration: SCATTER_INIT_TIME,
      attr: {
        'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(1)'
      }
    };
  },
  getPointUpdateAnimationAttr: function (point) {
    return {
      ease: 'back-out',
      duration: SCATTER_UPDATE_TIME,
      attr: {
        'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(1)'
      }
    };
  },
  getPointDropAnimationAttr: function (point) {
    return {
      ease: 'back-in',
      duration: SCATTER_INIT_TIME,
      attr: {
        'transform': 'translate(' + point.posX + ',' + point.posY + ') scale(0)'
      }
    };
  },
  drawSeries: function () {
    var series = this;
    series.visible && series.lineGraphic && series.lineGraphic.animate({
      duration: SCATTER_UPDATE_TIME,
      ease: 'back-out',
      attr: {
        'd': series.linePath
      }
    });

    if (!series.visible) {
      series.lineGraphic && series.lineGraphic.remove();
      series.lineGraphic = null;
    }
  },
  getStyle: function (point) {
    var marker = point.options.marker;

    if (_BaseUtils["default"].isImageMarker(marker.symbol)) {
      return {
        symbol: marker.symbol
      };
    }

    var isHollow = this._isHollowMarker(marker.symbol);

    return isHollow ? {
      'fill-opacity': 0,
      fill: 'white',
      stroke: marker.fillColor,
      'stroke-opacity': marker.fillColorOpacity,
      'stroke-width': 2
    } : {
      fill: marker.fillColor,
      'fill-opacity': marker.fillColorOpacity,
      stroke: 'none'
    };
  },
  _onPointMouseOver: function (point) {
    var series = point.series;

    if (series.vanchart.isLargeMode()) {
      return;
    }

    if (series.vanchart.isMap()) {
      series._onMapPointState(point, true);
    } else {
      series._onMarkerMouseOver(point);
    }
  },
  _onPointMouseOut: function (point) {
    var series = point.series;

    if (series.vanchart.isLargeMode()) {
      return;
    }

    if (series.vanchart.isMap()) {
      series._onMapPointState(point, false);
    } else {
      series._onMarkerMouseOut(point);
    }
  },
  getHighLightStyle: function (point) {
    var series = this,
        marker = point.options.marker,
        mouseOverColor = point.mouseOverColor || marker.fillColor,
        style = series.getStyle(point);

    if (_BaseUtils["default"].isImageMarker(marker.symbol)) {
      return {
        symbol: marker.symbol
      };
    }

    var isHollow = this._isHollowMarker(marker.symbol);

    if (isHollow) {
      style.stroke = mouseOverColor;
    } else {
      style.fill = mouseOverColor;
    }

    return style;
  },
  _onMapPointState: function (point, isChosen) {
    var series = this,
        style = isChosen ? series.getHighLightStyle(point) : series.getStyle(point);

    point._mapPointOnMouseState(isChosen, MAP_SCATTER_STATE_DURATION, MAP_SCATTER_STATE_EASE, style);

    point.textLayers && point.textLayers.forEach(function (layer) {
      layer._transformState(isChosen);
    });
  },
  getDefaultTooltipFormatter: function () {
    return this.vanchart.isMap() ? {
      areaNameFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{NAME}{SERIES}{VALUE}{SIZE}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    } : {
      XFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      YFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{SERIES}{X}{Y}{SIZE}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      sizeFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = Scatter;
exports["default"] = _default;

/***/ }),
/* 196 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Series = _interopRequireDefault(__webpack_require__(13));

var _Point = _interopRequireDefault(__webpack_require__(46));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by shine on 2017/1/10.
 */
var CHOSEN_TIME = 300;
var CHOSEN_EASE = _BezierEasing["default"].custom["ease-out-back"];

var Structure = _Series["default"].extend({
  //用来计算百分比的指标的名字,相当于value的含义
  getTargetKey: function () {
    return 'value';
  },
  _getPointKey: function (point, parent, level) {
    parent = point.parent || parent;
    level = point.level || level || 0;
    return (parent ? parent.name : "") + point.name + level;
  },
  isNullValue: function (point) {
    return false;
  },
  _dealData: function (data) {
    var series = this,
        vanchart = series.vanchart,
        ancestorData = data[0],
        ancestor = vanchart.ancestor;
    vanchart.nodes && vanchart.nodes.forEach(function (node) {
      node._events = null;
      node.graphic && node.graphic.remove();
      node.textGraphic && node.textGraphic.remove();
      node.textGraphic = node.graphic = null;
    });
    vanchart.edges && vanchart.edges.forEach(function (edge) {
      edge.linkGraphic && edge.linkGraphic.remove();
      edge.linkGraphic = null;
    });

    if (ancestorData) {
      var dealNodesAndEdges = function (parent, data, level, pointsMap) {
        var key = series._getPointKey(data, parent, level);

        var oldPoint = pointsMap[key];
        var point;

        if (oldPoint) {
          oldPoint._lastValue = oldPoint[series.getTargetKey()];
          oldPoint.moreLabelG && oldPoint.moreLabelG.remove();
          oldPoint.moreLabelG = null;
          oldPoint.children = null; //children置空，否则刷新一次多一倍

          oldPoint.refresh(data);
          point = oldPoint;
          pointsMap[key] = null;
        } else {
          point = new _Point["default"](data, series);
        }

        point.level = level;
        maxLevel = Math.max(level, maxLevel);

        if (parent) {
          point.parent = parent;
          parent.children = parent.children || [];

          if (_BaseUtils["default"].indexOf(parent.children, point) == -1) {
            parent.children.push(point);
          }
        }

        nodes.push(point);

        if (parent) {
          edges.push({
            source: parent,
            target: point
          });
        }

        if (data.children) {
          var pointsMap = {};

          if (point.children) {
            point.children.forEach(function (child) {
              pointsMap[series._getPointKey(child)] = child;
            });
          }

          data.children.forEach(function (d) {
            dealNodesAndEdges(point, d, level + 1, pointsMap);
          });

          for (var key in pointsMap) {
            pointsMap[key] && pointsMap[key].clearChild();
          }
        }

        return point;
      };

      var nodes = [],
          edges = [],
          maxLevel = 0;
      var map = {};

      if (ancestor) {
        map[series._getPointKey(ancestor)] = ancestor;
      }

      ancestor = dealNodesAndEdges(null, ancestorData, 0, map);

      for (var key in map) {
        map[key] && map[key].remove();
      }

      vanchart.ancestor = ancestor;
      vanchart.maxLevel = maxLevel;
      vanchart.nodes = nodes;
      vanchart.edges = edges;
      series.points = nodes;
    }
  },
  doLayout: function () {},
  _calculateLabelPos: function () {},
  _getFixedPos: function (point, divDim) {
    var vanchart = this.vanchart,
        plotBounds = vanchart.bounds;
    var radius = (point.radius + 1) / 1.414;
    return [plotBounds.x + point.posX + radius, plotBounds.y + point.posY + radius];
  },

  /**
   * @override Series.calcMoreLabelPosition
   * @param  {[type]} point [description]
   * @return {[type]}       [description]
   */
  calcMoreLabelPosition: function (point) {
    var chartBounds = this.vanchart.bounds;
    var startX = point.posX + chartBounds.x,
        startY = point.posY + chartBounds.y;
    return {
      startX: startX,
      startY: startY,
      direction: "top"
    };
  },
  getStyle: function (node) {
    var options = node.options;
    return {
      'fill': node.color,
      'fill-opacity': options.fillColorOpacity,
      'stroke': node.borderColor || node.color,
      'stroke-opacity': node.borderOpacity,
      'stroke-width': options.borderWidth
    };
  },
  getHighLightStyle: function (node) {
    var options = node.options;
    return {
      'fill': node.mouseOverColor || node.color,
      'fill-opacity': options.fillColorOpacity,
      'stroke-width': options.borderWidth,
      'stroke-opacity': node.borderOpacity,
      'stroke': node.borderColor || node.color
    };
  },
  getPressedStyle: function (node) {
    var options = node.options;
    return {
      'fill': node.clickColor || node.color,
      'fill-opacity': options.fillColorOpacity,
      'stroke-width': options.borderWidth,
      'stroke-opacity': node.borderOpacity,
      'stroke': node.borderColor || node.color
    };
  },
  _onPointMouseOver: function (point) {
    _Series["default"].prototype._onPointMouseOver.call(this, point); // 超链鼠标悬浮变手


    var series = point.series,
        style = series.getHighLightStyle(point);

    series._onState(point, true, style);
  },
  _onPointMouseOut: function (point) {
    var series = point.series,
        style = series.getStyle(point);

    series._onState(point, false, style);
  },
  _onState: function (point, isChosen, style) {
    var diff = isChosen ? 2 : 0,
        radius = point.radius,
        attr = {
      r: radius + diff
    };

    if (point.options.image) {
      attr = {
        x: -radius - diff,
        y: -radius - diff,
        width: (radius + diff) * 2,
        height: (radius + diff) * 2
      };
    }

    point.graphic.nodeGraphic.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      duration: CHOSEN_TIME,
      ease: CHOSEN_EASE,
      attr: attr,
      style: style
    });
    var options = point.options,
        dataLabels = options.dataLabels,
        align = dataLabels.align;

    if (align == _Constants["default"].INSIDE) {
      point.series._labelFontSizeState(point, isChosen, CHOSEN_TIME, CHOSEN_EASE);
    } else {
      point.series._labelTransformState(point, 0, -2, isChosen, CHOSEN_TIME, CHOSEN_EASE);
    }
  },
  getDefaultTooltipFormatter: function () {
    return {
      changedPercentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      changedValueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      identifier: "{NAME}{SERIES}{VALUE}",
      nameFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      percentFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      valueFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}"
    };
  }
});

var _default = Structure;
exports["default"] = _default;

/***/ }),
/* 197 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Gesture = _interopRequireDefault(__webpack_require__(198));

var _ManagerContainer = _interopRequireDefault(__webpack_require__(199));

var _ManagerDom = _interopRequireDefault(__webpack_require__(200));

var _ManagerLegend = _interopRequireDefault(__webpack_require__(201));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _ManagerHover = _interopRequireDefault(__webpack_require__(202));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _ManagerRangeLegend = _interopRequireDefault(__webpack_require__(204));

var _HammerHandler = _interopRequireDefault(__webpack_require__(94));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/7/2.
 */
function stop() {
  if (this.srcEvent.cancelable) {
    this.srcEvent.preventDefault();
  }

  this.cancelBubble = true;
}
/**
 * Handler 分发事件到各个 manager
 * 使用类冒泡模型，按注册顺序倒序遍历 manager，可以用e.cancelBubble取消冒泡（遍历）
 * 各个 manager 提供：
 * 1. contain 是否在区域内
 * 2. onevent 遍历时触发交互事件
 * 3. getActions 提供可全局共用的action；使其他manager可以触发逻辑
 */


var MobileHandler = _Evented["default"].extend({
  initialize: function (vanchart, dom) {
    this.vanchart = vanchart;
    this.dom = dom; // carousel event switch

    this.hammer = {
      set: _BaseUtils["default"].emptyFn
    };
    this.proxy = new _Gesture["default"](this);
    this.managers = [];
    this.stage = _Constants["default"].STAGES.NORMAL; // default manager

    this.registerManager(new _ManagerContainer["default"](this));
    this.registerManager(new _ManagerDom["default"](this));
    this.registerManager(new _ManagerHover["default"](this));
    this.registerManager(new _ManagerLegend["default"](this));
    this.registerManager(new _ManagerRangeLegend["default"](this));
  },
  cursor: _BaseUtils["default"].emptyFn,
  enable: function () {
    this.proxy.addDomEventListener();
  },
  disable: function () {
    this.proxy.removeDomEventListener();
  },
  registerManager: function (manager) {
    if (this.managers.indexOf(manager) === -1) {
      this.managers.push(manager);
      this.managers.sort(function (a, b) {
        return a.z - b.z;
      });
      this.on(manager.getActions(), manager);
    }
  },
  makeEventPacket: function (e, type, target) {
    var p;

    if (e.vanSynth) {
      p = _Point2D["default"].create(e.vanX, e.vanY);
    } else {
      p = _DomUtils["default"].getMousePos(e, this.dom);
    }

    return {
      type: type,
      srcEvent: e,
      target: this.findInteractiveTarget(target),
      startPosition: e.startPosition,
      containerPoint: p,
      stop: stop,
      cancelBubble: false
    };
  },
  getTouchPos: function (touch) {
    return _DomUtils["default"].getMousePos(touch, this.dom);
  },
  findInteractiveTarget: function (el) {
    return el && this.vanchart.findInteractiveTarget(el);
  },
  dispatchToElement: function (target, type, event) {
    /**
     * 缺乏冒泡模型
     * 搞个manager遍历
     * 分发：按区域（`manager.contain`）分发事件，就像平铺的rect
     * 捕获：某区域捕获事件后，捕获的内部继续决定逻辑
     *
     * 理论上按冒泡，一个parent中重叠的rect会挡住事件，但是我们现在没有层次结构，或很乱
     * 所以现在都按z算层次遍历，manager不多，遍历也可以接受
     *
     */
    var e = this.makeEventPacket(event, type, target);

    for (var i = this.managers.length - 1; i >= 0; --i) {
      var manager = this.managers[i];

      if (manager.contain(e.startPosition)) {
        var eventHandler = 'on' + type; //sequence

        manager[eventHandler] && manager[eventHandler](e);

        if (e.cancelBubble) {
          break;
        }
      }
    }
  },
  end: function (event) {
    this.vanchart.vancharts.handleTouchEnd(event);
  },
  removeAllChosen: _HammerHandler["default"].prototype.removeAllChosen,
  _removeHighlight: _HammerHandler["default"].prototype._removeHighlight,
  getCanvasClosestPoint: _HammerHandler["default"].prototype._getCanvasClosestPoint,
  destroy: function () {
    this.proxy.dispose();
  }
});

var _default = MobileHandler;
exports["default"] = _default;

/***/ }),
/* 198 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var TOUCHSTART = 'touchstart',
    TOUCHMOVE = 'touchmove',
    TOUCHEND = 'touchend',
    TOUCHCANCEL = 'touchcancel';
var TOUCH_HANDLER_NAMES = [TOUCHSTART, TOUCHMOVE, TOUCHEND, TOUCHCANCEL];
var EVENTS = ['rotate', 'touchStart', 'multipointStart', 'multipointEnd', 'pinch', 'swipe', 'tap', 'doubleTap', 'longTap', 'singleTap', // 'pressMove',
'panStart', 'panMove', 'panEnd', // 'twoFingerPressMove',
'touchMove', 'touchEnd']; // todo, check by direction instead of len

var MIN_PINCH_LEN = 50;

function getValidPinchStartLen(v) {
  v = Math.abs(v);
  return v < MIN_PINCH_LEN ? 0 : v;
}

function getLen(v) {
  return Math.sqrt(v.x * v.x + v.y * v.y);
}

function dot(v1, v2) {
  return v1.x * v2.x + v1.y * v2.y;
}

function getAngle(v1, v2) {
  var mr = getLen(v1) * getLen(v2);

  if (mr === 0) {
    return 0;
  }

  var r = dot(v1, v2) / mr;

  if (r > 1) {
    r = 1;
  }

  return Math.acos(r);
}

function cross(v1, v2) {
  return v1.x * v2.y - v2.x * v1.y;
}

function getRotateAngle(v1, v2) {
  var angle = getAngle(v1, v2);

  if (cross(v1, v2) > 0) {
    angle *= -1;
  }

  return angle * 180 / Math.PI;
}
/**
 * 监听在container上，target在handler中处理
 * 这里获取的target只是dom node，还可能是空，但我们需要的target比较复杂：
 * 可能是dom node，可能是canvas内对象，可能需要通过区域判断
 * @param handler
 * @constructor
 */


var Gesture = function GestureProxy(handler) {
  this.handler = handler;
  this.dom = handler.dom;
  this.preV = {
    x: null,
    y: null
  };
  this.pinchStartLen = null;
  this.zoom = 1;
  this.isDoubleTap = false;
  this.delta = null;
  this.last = null;
  this.now = null;
  this.tapTimeout = null;
  this.singleTapTimeout = null;
  this.longTapTimeout = null;
  this.swipeTimeout = null;
  this.x1 = this.x2 = this.sx2 = this.y1 = this.y2 = this.sy2 = null;
  this.preTapPosition = {
    x: null,
    y: null
  };
  this.element = null;
  this.startPosition = {
    x: 0,
    y: 0
  };
  this._domHandler = this.domHandler.bind(this); // MOBILE-17989 激活再监听
  // this.initDomHandler();

  this.normalizeLeafletTouchAction();
};

Gesture.prototype.normalizeLeafletTouchAction = function () {
  _DomUtils["default"].addClass(this.dom, 'touch-enable');
};

Gesture.prototype.recoverLeafletTouchAction = function () {
  _DomUtils["default"].removeClass(this.dom, 'touch-enable');
};

Gesture.prototype.initDomHandler = function initDomHandler() {
  this.addDomEventListener();
};

Gesture.prototype.addDomEventListener = function () {
  var self = this;
  this.recoverLeafletTouchAction();
  TOUCH_HANDLER_NAMES.forEach(function (name) {
    return self.dom.addEventListener(name, self._domHandler);
  });
};

Gesture.prototype.removeDomEventListener = function () {
  var self = this;
  this.normalizeLeafletTouchAction();
  TOUCH_HANDLER_NAMES.forEach(function (name) {
    self.dom.removeEventListener(name, self._domHandler);
  });
};

Gesture.prototype.domHandler = function domHandler(event) {
  // event = normalizeEvent(this.dom, event);
  this.recognize(event);
};

Gesture.prototype.dispatch = function dispatch(obj) {
  if (!obj || !obj.type || !obj.touches) {
    // console.warn('touchEvent obj.type & obj.touches are required!');
    return;
  }

  obj.touches.forEach(function (touch) {
    // pageX Y 只用来计算相对移动，偏移没有关系
    touch.pageX = touch.x | 0;
    touch.pageY = touch.y | 0;
  });
  var event = obj; // event.touches = obj.touches;

  event.changedTouches = []; // end check

  event.targetTouches = obj.touches;
  event.vanSynth = true;
  var p = obj.touches[0];
  event.vanX = p.x;
  event.vanY = p.y;
  var el = this.element;

  if (obj.type === TOUCHSTART) {
    var chartPoint = obj.touches[0];
    var bbox = this.dom.getBoundingClientRect();
    var viewPortPoint = {
      x: chartPoint.x + bbox.left,
      y: chartPoint.y + bbox.top
    };
    el = document.elementFromPoint(viewPortPoint.x, viewPortPoint.y); // console.log('chartPoint', chartPoint);
    // console.log('bbox', bbox);
    // console.log('viewPortPoint', viewPortPoint);
    // console.log('target', el);
  }

  if (el) {
    event.target = el;
    this.recognize(event);
  }
};

Gesture.prototype.recognize = function recognize(event) {
  var target = event.target;
  var type = event.type;
  this.element = target;

  if (type === TOUCHSTART) {
    // log startPosition to determine which area to dispatch;
    if (event.vanSynth) {
      this.startPosition = _Point2D["default"].create(event.vanX, event.vanY);
    } else {
      this.startPosition = _DomUtils["default"].getMousePos(event, this.dom);
    }

    event.startPosition = this.startPosition;
    this.start(event);
  } else if (type === TOUCHMOVE) {
    event.startPosition = this.startPosition;
    this.move(event);
  } else if (type === TOUCHEND || type === TOUCHCANCEL) {
    event.startPosition = this.startPosition;
    this.end(event);
  } else {
    throw 'unrecognized type:' + type;
  }
};

Gesture.prototype.start = function start(evt) {
  if (!evt.touches) {
    return;
  }

  this.now = Date.now();
  this.x1 = evt.touches[0].pageX;
  this.y1 = evt.touches[0].pageY; // 不知道为什么Alloy要从第二次move开始算delta...
  // 感觉完全没必要……

  this.x2 = this.x1;
  this.y2 = this.y1;
  this.delta = this.now - (this.last || this.now); // #event

  this.touchStart(evt, this.element);

  if (this.preTapPosition.x !== null) {
    this.isDoubleTap = this.delta > 0 && this.delta <= 250 && Math.abs(this.preTapPosition.x - this.x1) < 30 && Math.abs(this.preTapPosition.y - this.y1) < 30;

    if (this.isDoubleTap) {
      clearTimeout(this.singleTapTimeout);
    }
  }

  this.preTapPosition.x = this.x1;
  this.preTapPosition.y = this.y1;
  this.last = this.now;
  var preV = this.preV,
      len = evt.touches.length;

  if (len > 1) {
    // set zrX/zrY
    this._clientToLocal(evt);

    this._cancelLongTap();

    this._cancelSingleTap();

    var v = {
      x: evt.touches[1].pageX - this.x1,
      y: evt.touches[1].pageY - this.y1
    };
    preV.x = v.x;
    preV.y = v.y;
    this.pinchStartLen = getLen(preV);
    this.pinchStartLenX = getValidPinchStartLen(v.x);
    this.pinchStartLenY = getValidPinchStartLen(v.y); // FIXME #panend ########

    if (this.element && this.element.panning === true) {
      this.panEnd(evt, this.element);
    }

    this.element.panning = 'avoid'; // #########
    // #event

    this.multipointStart(evt, this.element);
  }

  this._preventTap = false;
  this.longTapTimeout = setTimeout(function () {
    // #event
    this.longTap(evt, this.element);
    this._preventTap = true;
  }.bind(this), 750);
};

Gesture.prototype.move = function move(evt) {
  if (!evt.touches) {
    return;
  }

  var preV = this.preV,
      len = evt.touches.length,
      currentX = evt.touches[0].pageX,
      currentY = evt.touches[0].pageY;
  this.isDoubleTap = false;

  if (len > 1) {
    this._preventTap = true; // set zrX/zrY

    this._clientToLocal(evt);

    var sCurrentX = evt.touches[1].pageX,
        sCurrentY = evt.touches[1].pageY;
    var v = {
      x: evt.touches[1].pageX - currentX,
      y: evt.touches[1].pageY - currentY
    };

    if (preV.x !== null) {
      if (this.pinchStartLen > 0) {
        evt.zoom = getLen(v) / this.pinchStartLen;
        evt.zoomX = this.pinchStartLenX ? Math.abs(v.x) / this.pinchStartLenX : 1;
        evt.zoomY = this.pinchStartLenY ? Math.abs(v.y) / this.pinchStartLenY : 1; // #event

        this.pinch(evt, this.element);
      }

      evt.angle = getRotateAngle(v, preV); // #event

      this.rotate(evt, this.element);
    }

    preV.x = v.x;
    preV.y = v.y;

    if (this.x2 !== null && this.sx2 !== null) {
      evt.deltaX = (currentX - this.x2 + sCurrentX - this.sx2) / 2;
      evt.deltaY = (currentY - this.y2 + sCurrentY - this.sy2) / 2;
    } else {
      evt.deltaX = 0;
      evt.deltaY = 0;
    } // #event
    // this.twoFingerPressMove(evt, this.element);


    this.sx2 = sCurrentX;
    this.sy2 = sCurrentY;
  } else {
    if (this.x2 !== null) {
      evt.deltaX = currentX - this.x2;
      evt.deltaY = currentY - this.y2; //move事件中添加对当前触摸点到初始触摸点的判断，
      //如果曾经大于过某个距离(比如10),就认为是移动到某个地方又移回来，应该不再触发tap事件才对。

      var movedX = Math.abs(this.x1 - this.x2),
          movedY = Math.abs(this.y1 - this.y2);

      if (movedX > 8 || movedY > 8) {
        this._preventTap = true;
      }
    } else {
      evt.deltaX = 0;
      evt.deltaY = 0;
    } // #event
    // this.pressMove(evt, this.element);
    // Maybe pan outside to inside.
    // Should we strict the event to which is started from inside only?
    // #panend


    if (this.element) {
      if (this.element.panning === true) {
        evt.preventDefault();
        this.panMove(evt, this.element);
      } else if (this.handler.vanchart._eventsConfig.pan && this.element.panning !== 'avoid') {
        this.element.panning = true;
        evt.preventDefault();
        this.panStart(evt, this.element);
      }
    }
  }

  this.touchMove(evt, this.element);

  this._cancelLongTap();

  this.x2 = currentX;
  this.y2 = currentY;

  if (len > 1) {// evt.preventDefault();
  }
};

Gesture.prototype.end = function end(evt) {
  if (!evt.changedTouches) {
    return;
  }

  this._cancelLongTap();

  var self = this;

  if (evt.touches.length < 2) {
    // #event
    this.multipointEnd(evt, this.element);
    this.sx2 = this.sy2 = null;
  } else {
    // set zrX/zrY
    this._clientToLocal(evt);
  } //swipe


  if (this.x2 && Math.abs(this.x1 - this.x2) > 30 || this.y2 && Math.abs(this.y1 - this.y2) > 30) {
    evt.direction = this._swipeDirection(this.x1, this.x2, this.y1, this.y2);
    this.swipeTimeout = setTimeout(function () {
      // #event
      self.swipe(evt, self.element);
    }, 0);
  } else {
    this.tapTimeout = setTimeout(function () {
      if (!self._preventTap) {
        // #event
        self.tap(evt, self.element);
      } // trigger double tap immediately


      if (self.isDoubleTap) {
        // #event
        self.doubleTap(evt, self.element);
        self.isDoubleTap = false;
      }
    }, 0);

    if (!self.isDoubleTap) {
      self.singleTapTimeout = setTimeout(function () {
        // #event
        self.singleTap(evt, self.element);
      }, 250);
    }
  } // #event
  // #panend


  if (this.element && this.element.panning) {
    if (this.element.panning === true) {
      this.panEnd(evt, this.element);
      this.element.panning = false;
    } else if (this.element.panning === 'avoid') {
      if (evt.touches.length === 0) {
        this.element.panning = false;
      }
    }
  }

  this.touchEnd(evt, this.element);
  this.preV.x = 0;
  this.preV.y = 0;
  this.zoom = 1;
  this.pinchStartLen = this.pinchStartLenX = this.pinchStartLenY = null;
  this.x1 = this.x2 = this.y1 = this.y2 = null;
}; // 看上去暂时不用知道多点具体坐标……


Gesture.prototype._clientToLocal = function _clientToLocal(evt) {
  // convert coordinate, only two point
  // set zrX/zrY directly to `touch`
  var touch1 = evt.touches[0],
      touch2 = evt.touches[1]; // clientToLocal(this.handler.painterRoot, touch1, touch1);
  // clientToLocal(this.handler.painterRoot, touch2, touch2);
};

Gesture.prototype._cancelLongTap = function _cancelLongTap() {
  clearTimeout(this.longTapTimeout);
};

Gesture.prototype._cancelSingleTap = function _cancelSingleTap() {
  clearTimeout(this.singleTapTimeout);
};

Gesture.prototype._swipeDirection = function _swipeDirection(x1, x2, y1, y2) {
  return Math.abs(x1 - x2) >= Math.abs(y1 - y2) ? x1 - x2 > 0 ? 'Left' : 'Right' : y1 - y2 > 0 ? 'Up' : 'Down';
};

Gesture.prototype.dispose = function dispose() {
  var self = this;

  if (this.singleTapTimeout) {
    clearTimeout(this.singleTapTimeout);
  }

  if (this.tapTimeout) {
    clearTimeout(this.tapTimeout);
  }

  if (this.longTapTimeout) {
    clearTimeout(this.longTapTimeout);
  }

  if (this.swipeTimeout) {
    clearTimeout(this.swipeTimeout);
  }

  this.preV = this.pinchStartLen = this.zoom = this.isDoubleTap = this.delta = this.last = this.now = this.tapTimeout = this.singleTapTimeout = this.longTapTimeout = this.swipeTimeout = this.x1 = this.x2 = this.y1 = this.y2 = this.preTapPosition = this.rotate = this.touchStart = this.multipointStart = this.multipointEnd = this.pinch = this.swipe = this.tap = this.doubleTap = this.longTap = this.singleTap = this.pressMove = this.touchMove = this.touchEnd = this.touchCancel = this.twoFingerPressMove = null;
  this.element = null;
  this.removeDomEventListener();
  return null;
};

EVENTS.forEach(function (name) {
  var type = name.toLowerCase();

  Gesture.prototype[name] = function (event, target) {
    // target && console.log(type);
    this.handler.dispatchToElement(target, type, event);

    if (type === 'panend') {
      this.handler.end(event);
    }
  };
});
var _default = Gesture;
exports["default"] = _default;

/***/ }),
/* 199 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractManager = _interopRequireDefault(__webpack_require__(26));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/7/5.
 */
// a default container manager
// to handle tap in blank
var _default = _AbstractManager["default"].extend({
  z: -10,
  name: 'container',
  contain: function () {
    return true;
  },
  ontap: function (e) {
    // 保证点击axis/legend等取消提示高亮
    this.handler.fire('forceHide', 'containerTap');
  },
  onpanstart: function (e) {
    e.chart = this.vanchart;
    this.vanchart.vancharts.trigger('carouselpanstart', e);
  },
  onpanmove: function (e) {
    this.vanchart.vancharts.trigger('carouselpanmove', e);
  },
  onpanend: function (e) {
    this.vanchart.vancharts.trigger('carouselpanend', e);
  }
});

exports["default"] = _default;

/***/ }),
/* 200 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractManager = _interopRequireDefault(__webpack_require__(26));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/7/4.
 */
function fireTargetByEvent(e) {
  var src = e.srcEvent.target;
  var type = e.type;
  var target;
  var vanchart = this.vanchart;

  if (vanchart.force) {
    target = vanchart.force.dragFire(e, this.handler.dom);
  }

  if (!target) {
    // 这里应该搞冒泡，但是考虑有可能反而搞乱，先不搞冒泡了
    while (src) {
      if (src === this.handler.dom) {
        break;
      }

      target = this.handler.findInteractiveTarget(src);

      if (target && target.listens(type, false)) {
        break;
      }

      src = src.parentNode;
    }
  }

  if (target) {
    target.fire(type, e);
    e.stop();
  }
}
/**
 * default dom handler manager
 * fire the event on the target directly
 * @param handler
 * @constructor
 */


var _default = _AbstractManager["default"].extend({
  z: 0,
  name: 'dom',
  contain: function () {
    return true;
  },
  fireTargetByEvent: fireTargetByEvent,
  ontap: fireTargetByEvent,
  // will it cause problem?
  onpanstart: fireTargetByEvent,
  onpanmove: fireTargetByEvent,
  onpanend: fireTargetByEvent
});

exports["default"] = _default;

/***/ }),
/* 201 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractManager = _interopRequireDefault(__webpack_require__(26));

var _component = __webpack_require__(4);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/8/8.
 */
var _default = _AbstractManager["default"].extend({
  z: 100,
  name: 'legend',
  _getLegend: function () {
    return this.vanchart.getComponent(_component.ComponentCst.LEGEND_COMPONENT);
  },
  contain: function (p) {
    var legend = this._getLegend();

    if (legend) {
      return _BaseUtils["default"].containsPoint(legend.bounds, p);
    }
  },
  onpanstart: function (e) {
    e.stop();

    this._getLegend().fire('panstart', e);
  },
  onpanmove: function (e) {
    e.stop();

    this._getLegend().fire('panmove', e);
  },
  onpanend: function (e) {
    e.stop();

    this._getLegend().fire('panend', e);
  }
});

exports["default"] = _default;

/***/ }),
/* 202 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _AbstractManager = _interopRequireDefault(__webpack_require__(26));

var _component = __webpack_require__(4);

var _findClosestPoint = _interopRequireDefault(__webpack_require__(203));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/7/3.
 */
var CROSS_TIMEOUT_KEY = 'CROSS_TIMEOUT_KEY';
var CROSS_TIMEOUT = 1000;
var CROSS_CENTER_RADIUS = 20;
var EDGE_MOVE_KEY = 'EDGE_MOVE_KEY';
var EDGE_MOVE_RATE = 10;
var EDGE_MOVE_DELTA = 1;
var STAGES = _Constants["default"].STAGES;

function sideOfBounds(bounds, pos) {
  if (pos.y < bounds.y) {
    return 'top';
  }

  if (pos.y > bounds.y + bounds.height) {
    return 'bottom';
  }

  if (pos.x < bounds.x) {
    return 'left';
  }

  if (pos.x > bounds.x + bounds.width) {
    return 'right';
  }
}

var _default = _AbstractManager["default"].extend({
  z: 10,
  name: 'hover',
  initialize: function (handler) {
    this.init(handler); // debug

    handler.__hover = this;
    this.movingEdge = null;
    this._hoveredTarget = null;
    this._pinchStartPlotZoom = 1;
    this._pinchStartCenter = {};
    this._tapPoint = _BaseUtils["default"].throttle(this._tapPoint, 250, this);
  },
  // delay or wait
  delayHide: function (name) {
    // console.log('delayHide', name);
    this.vanchart.vancharts.trigger('hideMobileTooltip', {
      delay: true
    });
    var self = this;
    this.vanchart.setTimeout(CROSS_TIMEOUT_KEY, function () {
      self.hideCross();
    }, CROSS_TIMEOUT);
  },
  forceHide: function (name) {
    // console.log('forceHide', name);
    this.vanchart.setTimeout(EDGE_MOVE_KEY);
    this.hide();
    this.vanchart.vancharts.trigger('hideMobileTooltip', {
      delay: false
    });
  },
  getBoundingRect: function () {
    return this.vanchart.bounds;
  },
  getPointAbsCenter: function (point) {
    if (!point) {
      return;
    }

    var p = _findClosestPoint["default"].getCenter(point);

    if (p) {
      if (this._hoveredTarget && this._hoveredTarget.series.type === _Constants["default"].RADAR_CHART) {
        var center = this._hoveredTarget.series.getCenter();

        p.x += center[0];
        p.y += center[1];
      } else if (!this.vanchart.isMap()) {
        p.x += this.vanchart.bounds.x;
        p.y += this.vanchart.bounds.y;
      }

      return p;
    }
  },
  _disableAnimation: function () {
    this.__isAnimation = this.vanchart.renderer.isAnimation;
    this.vanchart.renderer.isAnimation = false;
  },
  _enableAnimation: function () {
    this.vanchart.renderer.isAnimation = this.__isAnimation;
  },
  _mutateValueAxis: function (valueAxis, initDomain) {
    var range = valueAxis.getWholeRange();

    var visibleRange = valueAxis._getRange();

    var scale = _Scale["default"].linear().domain(initDomain).range(range);

    var nextDomain = [scale.invert(visibleRange[0]), scale.invert(visibleRange[1])];

    if (initDomain[0] !== nextDomain[0] || initDomain[1] !== nextDomain[1]) {
      valueAxis._calculateNiceDomain(null, null, nextDomain[0], nextDomain[1]);
    } // from zoom.js
    // valueAxis.zoomRefresh(nextDomain);


    valueAxis.fixScaleAndTickData();
    valueAxis.render();
  },
  _mutateCategoryAxis: function (axis) {
    axis.fixScaleAndTickData();
    axis.render();
  },
  _mutateSingleAxis: function (axis, domain) {
    if (axis.isValue() || axis.isDate()) {
      this._mutateValueAxis(axis, domain);
    } else if (axis.isCategory()) {
      this._mutateCategoryAxis(axis);
    }
  },
  _mutateAxisList: function (axis, domains) {
    var len = axis.getAxisCount();

    for (var i = 0; i < len; ++i) {
      var a = axis.getAxis(i);

      this._mutateSingleAxis(a, domains[i]);
    }
  },
  _mutateAllAxes: function (initDomains) {
    var xs = initDomains.xDomains,
        ys = initDomains.yDomains;

    this._mutateAxisList(this.vanchart.components.xAxis, xs);

    this._mutateAxisList(this.vanchart.components.yAxis, ys);
  },
  _showScroll: function () {
    var plotScroll = this.vanchart.getComponent(_component.ComponentCst.PLOT_SCROLL);
    plotScroll && plotScroll.show();
  },
  _hideScroll: function () {
    var plotScroll = this.vanchart.getComponent(_component.ComponentCst.PLOT_SCROLL);
    plotScroll && plotScroll.hide();
  },
  mutatePlotByZoomAndOffset: function () {
    var plotScroll = this.vanchart.getComponent(_component.ComponentCst.PLOT_SCROLL);

    if (!plotScroll.isExist()) {
      return;
    }

    this._mutateAllAxes(plotScroll);

    this.vanchart.reRenderSeries();
    plotScroll.render();
  },
  onmultipointstart: function (e) {
    var touches = e.srcEvent.touches;

    if (touches.length !== 2) {
      return;
    }

    if (this.vanchart.shouldPinch()) {
      if (this.handler.stage !== STAGES.NORMAL) {
        this.forceHide('pinch');
      }

      e.stop();
      this.handler.stage = STAGES.ZOOM;

      this._disableAnimation();

      var p1 = this.handler.getTouchPos(touches[0]),
          p2 = this.handler.getTouchPos(touches[1]); // pos to plotBounds

      this._pinchStartCenter = p1.add(p2).divideBy(2).subtract(this.vanchart.bounds).round();
      this._pinchStartPlotOffset = this.vanchart.getPlotOffset();
      this._pinchStartPlotZoom = this.vanchart.getPlotZoom(); // todo, remove label
    }

    this._showScroll();
  },
  onpinch: function (e) {
    if (this.handler.stage !== STAGES.ZOOM) {
      return;
    }

    e.stop();
    var vanchart = this.vanchart;
    var plotScroll = this.vanchart.getComponent(_component.ComponentCst.PLOT_SCROLL);
    var zoomX = e.srcEvent.zoomX,
        zoomY = e.srcEvent.zoomY;

    var zoom = _Point2D["default"].create(zoomX, zoomY); // limited


    var plotZoom = zoom.scaleBy(this._pinchStartPlotZoom); // `zoom = 1` is chart's original size;

    plotZoom.x = Math.max(1, Math.min(plotZoom.x, plotScroll.xMaxZoom));
    plotZoom.y = Math.max(1, Math.min(plotZoom.y, plotScroll.yMaxZoom)); // limited

    var limitedZoom = plotZoom.unscaleBy(this._pinchStartPlotZoom); // pos to content bounds

    var focusedPos = this._pinchStartCenter.subtract(this._pinchStartPlotOffset).scaleBy(limitedZoom);

    var plotOffset = focusedPos.subtract(this._pinchStartCenter).multiplyBy(-1); // zoom the plot, then offset to keep the focused position

    vanchart.setPlotZoom(plotZoom);
    vanchart.setPlotOffset(plotOffset); // initDomains are saved in the plotScroll

    this.mutatePlotByZoomAndOffset();
  },
  onmultipointend: function () {
    if (this.handler.stage === STAGES.ZOOM) {
      this._enableAnimation();

      this.handler.stage = STAGES.NORMAL; // todo, label
    }

    this._hideScroll();
  },
  ontap: function (e) {
    if (this.handler.stage === STAGES.SELECT) {
      // 在selecting中，最终通过触发target tap来实现高亮、onclick回调
      // 所以不要让tap继续流转到target上
      e.stop();
    } else {
      // 1. 大多数点通过`highlightByTarget`找到，并手动触发tap
      //    同时stop，防止流转到dom再次触发
      //
      // 2. 但是部分如gauge，不是普通point触发逻辑，没有通过`highlightByTarget`找到
      //    需要流转到dom manager按原来逻辑触发
      //    在point.onClick中stop，防止流转到container进行hide
      this.highlightByTarget(e);
      this.moveCrossToHovered(e);
      this.delayHide('tap');
    }
  },
  ontouchstart: function (e) {
    if (this.handler.stage === STAGES.SELECT) {
      var isTouchEnable = !_DomUtils["default"].hasClass(this.handler.dom, 'touch-enable');

      if (this.isInCrossCenter(e) && isTouchEnable) {
        e.__forceSelect = true;
        this.highlightByTarget(e);
        this.vanchart.setTimeout(CROSS_TIMEOUT_KEY);
      } else {
        this.forceHide('touchstart');
      }
    }
  },
  ontouchend: function (e) {
    if (this.handler.stage === STAGES.SELECT) {
      this.moveCrossToHovered(e);
      this.delayHide('touchend');
    }
  },
  onpanstart: function (e) {
    this._disableAnimation();

    if (this.handler.stage === STAGES.NORMAL) {
      this.scroll(e);
    } else if (this.handler.stage === STAGES.SELECT) {
      if (this.isInCrossCenter(e)) {
        e.stop();
      } else {
        this.forceHide('panstart');
        this.scroll(e);
      }
    }
  },
  onpanmove: function (e) {
    if (this.handler.stage === STAGES.NORMAL) {
      this.scroll(e);
    } else if (this.handler.stage === STAGES.SELECT) {
      e.stop();
      this.edgeMove(e);
      this.highlightByPos(e);
    }
  },
  onpanend: function (e) {
    this._enableAnimation();

    this._hideScroll(); // cancel


    this.vanchart.setTimeout(EDGE_MOVE_KEY);
  },
  getActions: function () {
    return {
      pointSelect: this.pointSelect,
      pointCancel: this.pointCancel,
      forceHide: this.forceHide,
      delayHide: this.delayHide,
      edgeMove: this.edgeMove,
      mutatePlot: this.mutatePlotByZoomAndOffset
    };
  },
  pointCancel: function () {
    this.hide();
  },
  scroll: function (e) {
    var d = e.srcEvent || e;
    var b = this.vanchart.getScrollBounds();

    if (b.shouldParentHandle && b.horizontalEdge !== 'middle') {// carousel handle it
    } else {
      e.stop && e.stop();
    }

    if (this.vanchart.addPlotOffset(d)) {
      this._showScroll();

      this.mutatePlotByZoomAndOffset();
    }
  },
  hide: function () {
    // cancel
    this.vanchart.setTimeout(EDGE_MOVE_KEY);
    this.vanchart.setTimeout(CROSS_TIMEOUT_KEY);

    this._tapPoint.cancel();

    this.handler.stage = STAGES.NORMAL;
    this.handler.removeAllChosen();
    this._hoveredTarget = null;
    this.hideCross();
    this.vanchart.vancharts.trigger('pointCanceled');
  },
  hideCross: function () {
    var crossLine = this.vanchart.getComponent(_component.ComponentCst.CROSS_LINE);
    crossLine && crossLine.hide();
  },
  _attachVanXYToEvent: function (e, p) {
    if (!p) {
      return;
    }

    var srcEvent = e.srcEvent;
    srcEvent.vanX = p.x;
    srcEvent.vanY = p.y + this.vanchart.vancharts.getCarouselChartOffset();
  },
  isShowCrossLine: function () {
    var crossLine = this.vanchart.getComponent(_component.ComponentCst.CROSS_LINE);
    return crossLine && crossLine.group && crossLine.group.isVisible();
  },
  isInCrossCenter: function (e) {
    if (!this.isShowCrossLine()) {
      return false;
    }

    var crossLine = this.vanchart.getComponent(_component.ComponentCst.CROSS_LINE);
    return _BaseUtils["default"].distance(crossLine.centerPos, e.startPosition) < CROSS_CENTER_RADIUS;
  },
  showCross: function (point, e) {
    if (!this.vanchart.hasCrossLine()) {
      return;
    }

    var crossLine = this.vanchart.getComponent(_component.ComponentCst.CROSS_LINE);
    var p = this.getPointAbsCenter(point);

    this._attachVanXYToEvent(e, p);

    if (p && point.isPointSupportTooltipShared()) {
      // 共享时若干个数据点高亮，不知道选中了哪个，让十字线移动到点上指示选中
      crossLine.setPos(p.x, p.y);
    } else {
      var pos = e.containerPoint;
      crossLine.setPos(pos.x, pos.y);
    }
  },
  moveCrossToHovered: function (e) {
    if (!this.vanchart.hasCrossLine()) {
      return;
    }

    var crossLine = this.vanchart.getComponent(_component.ComponentCst.CROSS_LINE);
    var p = this.getPointAbsCenter(this._hoveredTarget);

    this._attachVanXYToEvent(e, p);

    if (p) {
      crossLine.setPos(p.x, p.y, true);
    }
  },
  // start/tap时e.target直接是目标
  findPointByTarget: function (e) {
    var target = e.target;

    if (target && target.vanChartType === 'point') {
      return target;
    }

    return this.findClosestPoint(e);
  },
  // touch事件特点，move时e.target是start时的target
  // 通过位置找当下target
  findPointByPos: function (e) {
    var target;

    if (e.srcEvent.touches[0]) {
      var t = e.srcEvent.touches[0];
      var targetElement = document.elementFromPoint(t.clientX, t.clientY);
      target = this.handler.findInteractiveTarget(targetElement);
    }

    if (target && target.vanChartType === 'point') {
      return target;
    }

    return this.findClosestPoint(e);
  },
  findClosestPoint: _findClosestPoint["default"],
  highlightByTarget: function (e) {
    var point = this.findPointByTarget(e);
    this.highlight(point, e);
  },
  highlightByPos: function (e) {
    var point = this.findPointByPos(e);
    this.highlight(point, e);
  },
  // point & crossLine if needed
  highlight: function (point, e) {
    this.showCross(point, e);
    this.highlightPoint(point, e);
  },
  _attachPieVanXYToEvent: function (target, e) {
    var series = target.series;

    if (!(series.type === 'pie' || series.type === 'multiPie')) {
      return;
    }

    var chartInfo = series.chartInfo;
    var cx, cy;

    if (series.type === 'pie') {
      cx = chartInfo.centerX;
      cy = chartInfo.centerY;
    } else {
      cx = chartInfo.center[0];
      cy = chartInfo.center[1];
    }

    var radius = series._getOuterRadius(target) * 1.1; // hover

    var centerArc = series.getCenterAngle(target);
    var p = {
      x: cx + radius * Math.sin(centerArc),
      y: cy + radius * Math.cos(centerArc + Math.PI)
    };
    var srcEvent = e.srcEvent;
    srcEvent.vanX = p.x;
    srcEvent.vanY = p.y + this.vanchart.vancharts.getCarouselChartOffset();
  },
  highlightPoint: function (target, e) {
    if (target) {
      e.stop();

      if (e.__forceSelect || target !== this._hoveredTarget) {
        this.handler.stage = STAGES.SELECT;

        this._attachPieVanXYToEvent(target, e);

        this._hoveredTarget = target; // 都fire series似乎也没什么错……

        target.series.fire('tap', e);

        if (target.series.type === _Constants["default"].HEAT_MAP) {
          this.vanchart.showTooltip(target);
        } // then point
        // target.fire('tap', e);


        this._tapPoint(target, e);
      }
    } else {
      // 地图的脏规则
      // try to force lineMap highlight
      if (this.vanchart.chartType() === _Constants["default"].LINE_MAP) {
        // 到这里的事件源是tap或者select后的panmove
        // 不管有没有都先进入select状态
        this.handler.stage = STAGES.SELECT; // 停止流转到其他manager

        e.stop(); // 尝试高亮linemap

        this.vanchart.fire('mousemove', e); // 高亮后在vanchart上拿到target

        if (this.vanchart.hoverPoint !== this._hoveredTarget) {
          this._hoveredTarget = this.vanchart.hoverPoint; // 触发移动端tooltip

          this._tapPoint(this._hoveredTarget, e);
        }
      }
    }
  },
  _tapPoint: function (target, e) {
    target && target._onPointTap(e);
  },
  edgeMove: function (e) {
    var self = this;
    var vanchart = this.vanchart;
    var bounds = vanchart.bounds;
    var edge = sideOfBounds(bounds, e.containerPoint);
    var keepMove = null;

    if (edge) {
      // has edge, need moving
      // but only start a new turn for a new edge
      if (edge !== this.movingEdge) {
        this.movingEdge = edge;
        var d = {
          deltaX: 0,
          deltaY: 0
        };

        switch (edge) {
          case 'top':
            d.deltaY = EDGE_MOVE_DELTA;
            break;

          case 'bottom':
            d.deltaY = -EDGE_MOVE_DELTA;
            break;

          case 'left':
            d.deltaX = EDGE_MOVE_DELTA;
            break;

          case 'right':
            d.deltaX = -EDGE_MOVE_DELTA;
            break;
        }

        keepMove = function () {
          // scroll 后会刷新series
          // highlight 就没了 →_→ 这个bug没法改
          // 因为强制highlight会让移动端一直收到一个点
          // 而强制其实也没用，还有其他bug →_→
          self.highlightByPos(e);
          self.scroll(d);
          vanchart.setTimeout(EDGE_MOVE_KEY, keepMove, EDGE_MOVE_RATE);
        };

        keepMove();
      }

      return true;
    } else {
      this.movingEdge = null; // cancel

      vanchart.setTimeout(EDGE_MOVE_KEY);
      return false;
    }
  }
});

exports["default"] = _default;

/***/ }),
/* 203 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/7/23.
 */
// put all find-by-pos logic here
var NO_CENTER = {};
NO_CENTER[_Constants["default"].PIE_CHART] = true;

function getCenter(point) {
  // 雷达图的偏移……event的偏移……plot的偏移………………
  // ~！@#￥……&*（）
  // if (point.series === Constants.RADAR_CHART) {
  //     var center = point.series.getCenter();
  //     return {
  //         x: point.posX + center[0],
  //         y: point.posY + center[1]
  //     }
  // }
  var latlng = point.series.vanchart.isMap() && point.getLatLng();

  if (latlng) {
    return point.series.vanchart.latLngToContainerPoint(latlng);
  } else // bar, column
    if (point.rect) {
      var rect = point.rect;
      return {
        x: rect.x + rect.width / 2,
        y: rect.y + rect.height / 2
      };
    } else // line, area, bubble, scatter
      if (point.posX != null) {
        return {
          x: point.posX,
          y: point.posY
        };
      } else if (point.px != null) {
        return {
          x: point.px,
          y: point.py
        };
      } else if (point.word) {
        var word = point.word,
            dim = point.labelDim;
        var plotBounds = point.series.vanchart.bounds;
        var translate = [plotBounds.width / 2, plotBounds.height / 2];

        var rotate = _BaseUtils["default"].toRadian(word.rotate);

        var dy = dim.height * .35 * Math.cos(rotate);
        var dx = dim.height * .35 * Math.sin(rotate);
        return {
          x: translate[0] + word.x + dx,
          y: translate[1] + word.y - dy
        };
      } else {
        if (NO_CENTER[point.series.type]) {
          return;
        } // for debug
        // console.error('resolve me', point);

      }
}

function getDistanceSquare(point, pos) {
  var center = getCenter(point);

  if (!center) {
    return Number.MAX_VALUE;
  }

  return (pos.x - center.x) * (pos.x - center.x) + (pos.y - center.y) * (pos.y - center.y);
}

function findClosestPoint(event) {
  var sharedCoordAxis = this.vanchart.getSharedAxis();
  var chartType = this.vanchart.chartType();
  var pos;

  if (chartType === _Constants["default"].GANTT_CHART) {
    var t = this.vanchart.getTimeAxis();
    pos = event.containerPoint.subtract({
      x: t.bounds.x,
      y: t.bounds.y + t.tableDims.headerHeight
    }).subtract({
      x: t.view.innerPosX,
      y: t.view.innerPosY
    });
  } else if (chartType === _Constants["default"].RADAR_CHART) {
    pos = this.vanchart.series[0] && event.containerPoint.subtract(this.vanchart.series[0].getCenter());
  } else if (this.vanchart.isMap()) {
    pos = event.containerPoint;
  } else {
    pos = event.containerPoint.subtract(this.vanchart.bounds);
  }

  var minDistance = Number.MAX_VALUE,
      target = null;
  var targetPoints = [];

  if (sharedCoordAxis) {
    var category;

    if (sharedCoordAxis.getCategoryByPos) {
      category = sharedCoordAxis.getCategoryByPos(event.containerPoint);
    } else {
      var domain = sharedCoordAxis.scale.domain(),
          range = sharedCoordAxis._getRange();

      var tmpScale = _Scale["default"].quantize().domain(range).range(domain);

      category = tmpScale(sharedCoordAxis.isHorizontal() ? pos.x : pos.y);
    }

    targetPoints = this.vanchart.cateMap[category];
  } else {
    var series = this.vanchart.series;

    for (var i = series.length - 1; i > -1; --i) {
      var s = series[i];

      if (!s.visible) {
        continue;
      }

      targetPoints = targetPoints.concat(series[i].points);
    }
  } // 组合图真tm难搞，怎么搞


  if (targetPoints && targetPoints.length) {
    for (var i = targetPoints.length - 1; i > -1; --i) {
      var point = targetPoints[i];

      if (!point.isVisible()) {
        continue;
      }

      var distance = getDistanceSquare(point, pos);

      if (distance < minDistance) {
        minDistance = distance;
        target = point;
      }
    }
  } // fallback to canvas


  if (!target) {
    return this.handler.getCanvasClosestPoint(event.containerPoint);
  }

  return target;
}

findClosestPoint.getCenter = getCenter;
var _default = findClosestPoint;
exports["default"] = _default;

/***/ }),
/* 204 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractManager = _interopRequireDefault(__webpack_require__(26));

var _component = __webpack_require__(4);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/8/8.
 */
var _default = _AbstractManager["default"].extend({
  z: 100,
  name: 'rangeLegend',
  _getLegend: function () {
    return this.vanchart.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT);
  },
  contain: function (p) {
    var legend = this._getLegend();

    if (legend) {
      return _BaseUtils["default"].containsPoint(legend.bounds, p);
    }
  },
  onpanstart: function (e) {
    e.stop();

    this._getLegend().fire('panstart', e);
  },
  onpanmove: function (e) {
    e.stop();

    this._getLegend().fire('panmove', e);
  },
  onpanend: function (e) {
    e.stop();

    this._getLegend().fire('panend', e);
  }
});

exports["default"] = _default;

/***/ }),
/* 205 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.DEFAULT_COLORS = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _QueryUtils = _interopRequireDefault(__webpack_require__(14));

var _CRS = _interopRequireDefault(__webpack_require__(65));

var _Browser = _interopRequireDefault(__webpack_require__(8));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 16/5/19.
 */
var DEFAULT_COLORS = function () {
  return ['#63b2ee', '#76da91', '#f8cb7f', '#f89588', '#7cd6cf', '#9192ab', '#7898e1', '#efa666', '#eddd86', '#9987ce'];
};

exports.DEFAULT_COLORS = DEFAULT_COLORS;
var colors = [];
var defaultColors = ['#231815', '#727171', '#898989', '#B5B5B6', '#C9CACA'];
var defaultFontFamily = 'PingFang SC Light, Lantinghei SC-Extralight, Hiragino Sans GB W3, Microsoft Yahei Font, Helvetica, Arial, sans-serif';
var MAP_CONFIG = {
  // @section Map State Options
  // @option crs: CRS = L.CRS.EPSG3857
  // The [Coordinate Reference System](#crs) to use. Don't change this if you're not
  // sure what it means.
  crs: _CRS["default"].EPSG3857,
  // @option center: LatLng = undefined
  // Initial geographic center of the map
  center: undefined,
  // @option zoom: Number = undefined
  // Initial map zoom level
  zoom: undefined,
  // @option minZoom: Number = undefined
  // Minimum zoom level of the map. Overrides any `minZoom` option set on map layers.
  minZoom: undefined,
  // @option maxZoom: Number = undefined
  // Maximum zoom level of the map. Overrides any `maxZoom` option set on map layers.
  maxZoom: undefined,
  // @option layers: Layer[] = []
  // Array of layers that will be added to the map initially
  layers: [],
  // @option maxBounds: LatLngBounds = null
  // When this option is set, the map restricts the view to the given
  // geographical bounds, bouncing the user back when he tries to pan
  // outside the view. To set the restriction dynamically, use
  // [`setMaxBounds`](#map-setmaxbounds) method.
  maxBounds: undefined,
  // @option renderer: Renderer = *
  // The default method for drawing vector layers on the map. `L.SVG`
  // or `L.Canvas` by default depending on browser support.
  renderer: undefined,
  // @section Animation Options
  // @option zoomAnimation: Boolean = true
  // Whether the map zoom animation is enabled. By default it's enabled
  // in all browsers that support CSS3 Transitions except Android.
  zoomAnimation: true,
  // @option zoomAnimationThreshold: Number = 4
  // Won't animate zoom if the zoom difference exceeds this value.
  zoomAnimationThreshold: 4,
  // @option fadeAnimation: Boolean = true
  // Whether the tile fade animation is enabled. By default it's enabled
  // in all browsers that support CSS3 Transitions except Android.
  fadeAnimation: true,
  // @option markerZoomAnimation: Boolean = true
  // Whether markers animate their zoom with the zoom animation, if disabled
  // they will disappear for the length of the animation. By default it's
  // enabled in all browsers that support CSS3 Transitions except Android.
  markerZoomAnimation: true,
  // @option transform3DLimit: Number = 2^23
  // Defines the maximum size of a CSS translation transform. The default
  // value should not be changed unless a web browser positions layers in
  // the wrong place after doing a large `panBy`.
  transform3DLimit: 8388608,
  // Precision limit of a 32-bit float
  // @section Interaction Options
  // @option zoomSnap: Number = 1
  // Forces the map's zoom level to always be a multiple of this, particularly
  // right after a [`fitBounds()`](#map-fitbounds) or a pinch-zoom.
  // By default, the zoom level snaps to the nearest integer; lower values
  // (e.g. `0.5` or `0.1`) allow for greater granularity. A value of `0`
  // means the zoom level will not be snapped after `fitBounds` or a pinch-zoom.
  zoomSnap: 0.1,
  // @option zoomDelta: Number = 1
  // Controls how much the map's zoom level will change after a
  // [`zoomIn()`](#map-zoomin), [`zoomOut()`](#map-zoomout), pressing `+`
  // or `-` on the keyboard, or using the [zoom controls](#control-zoom).
  // Values smaller than `1` (e.g. `0.5`) allow for greater granularity.
  zoomDelta: 0.2,
  // @option trackResize: Boolean = true
  // Whether the map automatically handles browser window resize to update itself.
  trackResize: true,
  // @option dragging: Boolean = true
  // Whether the map be draggable with mouse/touch or not.
  dragging: true,
  // @section Panning Inertia Options
  // @option inertia: Boolean = *
  // If enabled, panning of the map will have an inertia effect where
  // the map builds momentum while dragging and continues moving in
  // the same direction for some time. Feels especially nice on touch
  // devices. Enabled by default unless running on old Android devices.
  inertia: !_Browser["default"].android23,
  // @option inertiaDeceleration: Number = 3000
  // The rate with which the inertial movement slows down, in pixels/second².
  inertiaDeceleration: 3400,
  // px/s^2
  // @option inertiaMaxSpeed: Number = Infinity
  // Max speed of the inertial movement, in pixels/second.
  inertiaMaxSpeed: Infinity,
  // px/s
  // @option easeLinearity: Number = 0.2
  easeLinearity: 0.2,
  // TODO refactor, move to CRS
  // @option worldCopyJump: Boolean = false
  // With this option enabled, the map tracks when you pan to another "copy"
  // of the world and seamlessly jumps to the original one so that all overlays
  // like markers and vector layers are still visible.
  worldCopyJump: false,
  // @option maxBoundsViscosity: Number = 0.0
  // If `maxBounds` is set, this option will control how solid the bounds
  // are when dragging the map around. The default value of `0.0` allows the
  // user to drag outside the bounds at normal speed, higher values will
  // slow down map dragging outside bounds, and `1.0` makes the bounds fully
  // solid, preventing the user from dragging outside the bounds.
  maxBoundsViscosity: 0.0,
  // @section Mousewheel options
  // @option scrollWheelZoom: Boolean|String = true
  // Whether the map can be zoomed by using the mouse wheel. If passed `'center'`,
  // it will zoom to the center of the view regardless of where the mouse was.
  scrollWheelZoom: true,
  // @option wheelDebounceTime: Number = 40
  // Limits the rate at which a wheel can fire (in milliseconds). By default
  // user can't zoom via wheel more often than once per 40 ms.
  wheelDebounceTime: 40,
  // @option wheelPxPerZoomLevel: Number = 60
  // How many scroll pixels (as reported by [L.DomEvent.getWheelDelta](#domevent-getwheeldelta))
  // mean a change of one full zoom level. Smaller values will make wheel-zooming
  // faster (and vice versa).
  wheelPxPerZoomLevel: 60
};

function optionsFun() {
  var options = {
    pie: {
      plotOptions: {
        gradualStyle: gradualStyle,
        rotatable: true,
        startAngle: 0,
        endAngle: 360,
        borderWidth: 1,
        borderColor: 'white',
        dataLabels: {
          "formatter": {
            "identifier": "{Y}"
          },
          "enabled": false,
          "align": "inside"
        },
        tooltip: seriesValueTooltipFun()
      },
      options: {
        colors: colors,
        legend: disabledLegendFun()
      }
    },
    multiPie: {
      plotOptions: {
        borderWidth: 1,
        borderColor: 'rgb(255,255,255)',
        rotatable: true,
        gradual: 'lighter',
        innerRadius: 0,
        startAngle: 0,
        endAngle: 360,
        drilldown: true,
        tooltip: nameSeriesValueTooltipFun(),
        dataLabels: {
          "formatter": {
            "identifier": "{NAME}"
          },
          "enabled": false,
          "align": "inside"
        }
      },
      options: {
        colors: colors,
        legend: disabledLegendFun()
      }
    },
    treeMap: {
      plotOptions: {
        borderWidth: 1,
        borderColor: 'rgb(255,255,255)',
        zoom: true,
        tooltip: nameSeriesValueTooltipFun(),
        dataLabels: {
          "formatter": {
            "identifier": "{NAME}"
          },
          "enabled": false,
          align: 'top'
        }
      },
      options: {
        colors: colors,
        legend: disabledLegendFun()
      }
    },
    bar: {
      plotOptions: {
        categoryGap: '20%',
        gap: '20%',
        borderRadius: 0,
        borderWidth: 1,
        borderColor: 'white',
        dataLabels: {
          "formatter": {
            "identifier": "{Y}"
          },
          "enabled": false,
          "align": "inside"
        },
        tooltip: normalTooltipFun(),
        gradualStyle: gradualStyle
      },
      options: {
        colors: colors,
        zoom: xyZoomFun(),
        legend: disabledLegendFun(),
        xAxis: [xValueAxisFun()],
        yAxis: [yCategoryAxisFun()]
      }
    },
    column: {
      plotOptions: {
        categoryGap: '20%',
        gap: '20%',
        borderRadius: 0,
        borderWidth: 1,
        borderColor: 'white',
        dataLabels: {
          "formatter": {
            "identifier": "{Y}"
          },
          "enabled": false,
          "align": "inside"
        },
        tooltip: normalTooltipFun(),
        gradualStyle: gradualStyle
      },
      options: {
        colors: colors,
        zoom: xyZoomFun(),
        legend: disabledLegendFun(),
        xAxis: [xCategoryAxisFun()],
        yAxis: [yValueAxisFun()]
      }
    },
    box: {
      plotOptions: {
        isDetailed: true,
        borderRadius: 0,
        borderWidth: 1,
        tooltip: boxTooltipFun()
      },
      options: {
        colors: colors,
        zoom: xyZoomFun(),
        legend: disabledLegendFun(),
        xAxis: [xCategoryAxisFun()],
        yAxis: [yValueAxisFun()]
      }
    },
    line: {
      plotOptions: {
        large: false,
        connectNulls: false,
        lineWidth: 2,
        step: false,
        curve: false,
        marker: {
          radius: _Constants["default"].MARKER_RADIUS
        },
        dataLabels: {
          "formatter": {
            "identifier": "{Y}"
          },
          "enabled": false,
          "align": "outside"
        },
        tooltip: normalTooltipFun()
      },
      options: {
        colors: colors,
        zoom: xyZoomFun(),
        legend: disabledLegendFun(),
        xAxis: [xCategoryAxisFun()],
        yAxis: [yValueAxisFun()]
      }
    },
    area: {
      plotOptions: {
        large: false,
        connectNulls: false,
        lineWidth: 2,
        step: false,
        curve: false,
        marker: {
          radius: _Constants["default"].MARKER_RADIUS
        },
        dataLabels: {
          "formatter": {
            "identifier": "{Y}"
          },
          "enabled": false,
          "align": "outside"
        },
        tooltip: normalTooltipFun(),
        fillColor: true,
        fillColorOpacity: 0.15,
        gradualStyle: gradualStyle
      },
      options: {
        colors: colors,
        zoom: xyZoomFun(),
        legend: disabledLegendFun(),
        xAxis: [xCategoryAxisFun()],
        yAxis: [yValueAxisFun()]
      }
    },
    gauge: {
      thermometer: {
        layout: 'horizontal',
        thermometerWidth: 10,
        tooltip: disabledTooltipFun(),
        percentageLabel: {
          enabled: false,
          labelPosition: 'auto',
          style: {
            color: defaultColors[1],
            fontSize: 12,
            fontFamily: defaultFontFamily,
            fontWeight: 'bold'
          },
          useHtml: false,
          align: 'left',
          formatter: {
            identifier: "{PERCENT}"
          }
        },
        valueLabel: {
          enabled: false,
          labelPosition: 'auto',
          style: {
            color: defaultColors[1],
            fontSize: 12,
            fontFamily: defaultFontFamily
          },
          useHtml: false,
          align: 'left',
          formatter: {
            identifier: "{CATEGORY}{VALUE}"
          },
          needle: '#ffffff',
          slotBackgroundColor: '#eeeeee',
          thermometerWidth: 10,
          thermometerLayout: 'vertical'
        }
      },
      ring: {
        layout: 'horizontal',
        circleWidth: 0.15,
        tooltip: disabledTooltipFun(),
        percentageLabel: {
          enabled: false,
          useHtml: false,
          style: {
            fontSize: 24,
            fontFamily: defaultFontFamily,
            fontWeight: 'bold'
          },
          formatter: {
            identifier: "{PERCENT}"
          }
        },
        valueLabel: {
          enabled: false,
          useHtml: false,
          style: {
            color: defaultColors[1],
            fontSize: 12,
            fontFamily: defaultFontFamily
          },
          formatter: {
            identifier: "{CATEGORY}{VALUE}"
          }
        },
        clockwise: false,
        paneBackgroundColor: '#eeeeee',
        innerPaneBackgroundColor: '#f4f4f4'
      },
      pointer: {
        layout: 'horizontal',
        tooltip: disabledTooltipFun(),
        seriesLabel: {
          enabled: false,
          align: _Constants["default"].BOTTOM,
          useHtml: false,
          style: {
            color: defaultColors[1],
            fontSize: 12,
            fontFamily: defaultFontFamily
          },
          formatter: {
            identifier: "{CATEGORY}"
          }
        },
        valueLabel: {
          enabled: false,
          useHtml: false,
          backgroundColor: '#F5F5F7',
          style: {
            color: defaultColors[1],
            fontSize: 10,
            fontFamily: defaultFontFamily
          },
          formatter: {
            identifier: "{SERIES}{VALUE}"
          }
        },
        needle: '#E5715A',
        hinge: '#656B6D',
        hingeBackgroundColor: '#DCF2F9',
        paneBackgroundColor: '#FCFCFC'
      },
      slot: {
        layout: 'horizontal',
        circleWidth: 0.15,
        tooltip: disabledTooltipFun(),
        percentageLabel: {
          enabled: false,
          useHtml: false,
          style: {
            fontSize: 36,
            fontFamily: defaultFontFamily,
            fontWeight: 'bold'
          },
          formatter: {
            identifier: "{PERCENT}"
          }
        },
        valueLabel: {
          enabled: false,
          useHtml: false,
          style: {
            color: defaultColors[1],
            fontSize: 12,
            fontFamily: defaultFontFamily
          },
          formatter: {
            identifier: "{CATEGORY}{VALUE}"
          }
        },
        needle: '#ffffff',
        slotBackgroundColor: '#eeeeee'
      },
      options: {
        colors: colors,
        legend: disabledLegendFun(),
        gaugeAxis: [{
          type: 'value',
          showLabel: true,
          step: 1,
          enableTick: true,
          tickColor: '#BBBBBB',
          tickWidth: 1,
          enableMinorTick: true,
          minorTickColor: '#e2e2e2',
          minorTickWidth: 1,
          labelStyle: {
            color: defaultColors[1],
            fontFamily: defaultFontFamily,
            fontSize: 10
          }
        }]
      }
    },
    radar: {
      plotOptions: {
        fillColorOpacity: 0.15,
        columnType: false,
        marker: {
          radius: _Constants["default"].MARKER_RADIUS
        },
        lineWidth: 2,
        lineType: 'solid',
        shape: 'circle',
        dataLabels: {
          "formatter": {
            "identifier": "{Y}"
          },
          "enabled": false,
          "align": "outside"
        },
        tooltip: normalTooltipFun()
      },
      options: {
        colors: colors,
        polar: {},
        legend: disabledLegendFun(),
        angleAxis: [angleAxisFun()],
        radiusAxis: [radiusAxisFun()]
      }
    },
    scatter: {
      plotOptions: {
        large: false,
        lineWidth: 0,
        curve: false,
        marker: {
          symbol: _Constants["default"].SYMBOL_AUTO,
          radius: _Constants["default"].MARKER_RADIUS
        },
        opacity: 1,
        tooltip: seriesXYSizeTooltipFun(),
        dataLabels: {
          "formatter": {
            "identifier": "{X}{Y}{SIZE}"
          },
          "enabled": false,
          "align": "outside"
        }
      },
      options: {
        colors: colors,
        zoom: xyZoomFun(),
        legend: disabledLegendFun(),
        rangeLegend: disabledRangeLegendFun(),
        xAxis: [xValueAxisFun()],
        yAxis: [yValueAxisFun()]
      }
    },
    bubble: {
      plotOptions: {
        large: false,
        displayNegative: true,
        shadow: true,
        minSize: 12,
        maxSize: 60,
        sizeBy: 'area',
        opacity: 0.7,
        tooltip: seriesXYSizeTooltipFun(),
        dataLabels: {
          "formatter": {
            "identifier": "{X}{Y}{SIZE}"
          },
          "enabled": false,
          "align": "inside"
        }
      },
      options: {
        colors: colors,
        zoom: xyZoomFun(),
        rangeLegend: disabledRangeLegendFun(),
        legend: disabledLegendFun(),
        xAxis: [xValueAxisFun()],
        yAxis: [yValueAxisFun()]
      }
    },
    funnel: {
      plotOptions: {
        gradualStyle: gradualStyle,
        borderColor: "rgb(255,255,255)",
        borderWidth: 1,
        sort: true,
        useSameSlantAngle: true,
        dataLabels: {
          "formatter": {
            "identifier": "{VALUE}"
          },
          "enabled": false,
          "connectorWidth": 1,
          "align": "outside"
        }
      },
      options: {
        colors: colors,
        legend: disabledLegendFun()
      }
    },
    wordCloud: {
      plotOptions: {
        "fontFamily": "Microsoft YaHei",
        "maxRotation": 0,
        "minRotation": 0,
        tooltip: nameSeriesValueTooltipFun(),
        dataLabels: {
          "enabled": false
        },
        gradualStyle: gradualStyle
      },
      options: {
        colors: colors,
        legend: disabledLegendFun(),
        rangeLegend: disabledRangeLegendFun()
      }
    },
    structure: {
      plotOptions: {
        layout: 'vertical',
        force: true,
        lineColor: 'rgb(156,156,156)',
        lineOpacity: 1,
        borderWidth: 1,
        borderOpacity: 1,
        fillColorOpacity: 1,
        tooltip: nameSeriesValueTooltipFun(),
        dataLabels: {
          "enabled": false
        },
        gradualStyle: gradualStyle
      },
      options: {
        colors: colors,
        legend: disabledLegendFun(),
        rangeLegend: disabledRangeLegendFun()
      }
    },
    forceBubble: {
      plotOptions: {
        large: false,
        displayNegative: true,
        shadow: true,
        minSize: 12,
        maxSize: 60,
        sizeBy: 'area',
        opacity: 1.0,
        tooltip: normalTooltipFun(),
        dataLabels: {
          "formatter": {
            "identifier": "{SERIES}"
          },
          "enabled": false,
          "align": "inside"
        }
      },
      options: {
        colors: colors,
        legend: disabledLegendFun(),
        zoom: xyZoomFun(),
        rangeLegend: disabledRangeLegendFun()
      }
    },
    areaMap: {
      plotOptions: {
        nullColor: '#cccccc',
        opacity: 0.75,
        borderColor: '#ffffff',
        borderWidth: 1,
        borderOpacity: 1,
        tooltip: nameSeriesValueSizeTooltipFun(),
        dataLabels: {
          "formatter": {
            "identifier": "{NAME}"
          },
          "enabled": false,
          "align": "inside",
          useHtml: false
        }
      },
      options: {
        geo: {
          'zoom': true
        },
        colors: colors,
        title: nullTitleFun(),
        rangeLegend: rangeLegendFun(),
        legend: disabledLegendFun(),
        dTools: {
          style: {
            "fontFamily": defaultFontFamily,
            "color": defaultColors[1],
            "fontSize": 12,
            "fontWeight": ""
          },
          currentColor: '#62b2ef',
          backgroundColor: 'white',
          enabled: false
        }
      }
    },
    pointMap: {
      plotOptions: {
        opacity: 1,
        icon: {
          iconUrl: '../../doc/example/marker-icon.png',
          iconSize: [25, 41]
        },
        dataLabels: {
          "formatter": {
            "identifier": "{NAME}{SERIES}{VALUE}"
          },
          "enabled": false,
          "align": "outside",
          useHtml: false
        },
        tooltip: nameSeriesValueSizeTooltipFun()
      },
      options: {
        geo: {
          'zoom': true
        },
        colors: colors,
        title: nullTitleFun(),
        rangeLegend: rangeLegendFun(),
        legend: disabledLegendFun(),
        dTools: {
          style: {
            "fontFamily": defaultFontFamily,
            "color": defaultColors[1],
            "fontSize": 12,
            "fontWeight": ""
          },
          currentColor: '#62b2ef',
          backgroundColor: 'white',
          enabled: false
        }
      }
    },
    heatMap: {
      plotOptions: {
        'maxOpacity': 1,
        'minOpacity': 0,
        'radius': 15,
        'blur': 0.15,
        dataLabels: {
          useHtml: false
        }
      },
      options: {
        geo: {
          'zoom': true
        },
        colors: colors,
        title: nullTitleFun(),
        rangeLegend: rangeLegendFun(),
        legend: disabledLegendFun()
      }
    },
    lineMap: {
      plotOptions: {
        "lineWidth": 0.5,
        "curveness": 0.3,
        "mouseOverColor": "rgb(253,221,49)",
        "opacity": 1,
        dataLabels: {
          useHtml: false
        }
      },
      options: {
        geo: {
          'zoom': true
        },
        colors: colors,
        title: nullTitleFun(),
        rangeLegend: rangeLegendFun(),
        legend: disabledLegendFun()
      }
    },
    gantt: {
      plotOptions: {
        newLine: true,
        borderWidth: 1,
        borderColor: 'white',
        dataLabels: {
          "formatter": {
            "identifier": "{DURATION}{PROGRESS}"
          },
          "enabled": false
        },
        tooltip: normalTooltipFun()
      },
      options: {
        processes: {
          resize: true
        },
        levelBar: {
          enabled: true
        },
        timeAxis: {
          zoom: true,
          showWeekends: true
        },
        colors: colors,
        legend: disabledLegendFun()
      }
    }
  };
  options.MAP_CONFIG = MAP_CONFIG;
  return options;
}

function normalTooltipFun() {
  return {
    formatter: {
      identifier: "{CATEGORY}{SERIES}{VALUE}"
    },
    enabled: true,
    animation: true,
    follow: false,
    backgroundColor: 'rgba(0,0,0,0.5)',
    borderColor: null,
    borderWidth: 0,
    borderRadius: 2,
    shadow: true,
    hideDelay: 500,
    shared: false,
    padding: 5
  };
}

function boxTooltipFun() {
  return {
    formatter: {
      identifier: "{CATEGORY}{SERIES}{DATA_NUMBER}{DATA_MAX}{DATA_Q3}{DATA_MEDIAN}{DATA_Q1}{DATA_MIN}{DATA_OUTLIER}"
    },
    enabled: true,
    animation: true,
    follow: false,
    backgroundColor: 'rgba(0,0,0,0.5)',
    borderColor: null,
    borderWidth: 0,
    borderRadius: 2,
    shadow: true,
    hideDelay: 500,
    shared: false,
    padding: 5
  };
}

function disabledTooltipFun() {
  return _QueryUtils["default"].merge(normalTooltipFun(), {
    formatter: {
      enabled: false
    }
  }, true);
}

function seriesXYSizeTooltipFun() {
  return _QueryUtils["default"].merge(normalTooltipFun(), {
    formatter: {
      identifier: "{SERIES}{X}{Y}{SIZE}"
    }
  }, true);
}

function seriesValueTooltipFun() {
  return _QueryUtils["default"].merge(normalTooltipFun(), {
    formatter: {
      identifier: "{SERIES}{VALUE}"
    }
  }, true);
}

function nameSeriesValueTooltipFun() {
  return _QueryUtils["default"].merge(normalTooltipFun(), {
    formatter: {
      identifier: "{NAME}{SERIES}{VALUE}",
      shared: true
    }
  }, true);
}

function nameSeriesValueSizeTooltipFun() {
  return _QueryUtils["default"].merge(normalTooltipFun(), {
    formatter: {
      identifier: "{NAME}{SERIES}{VALUE}{SIZE}",
      shared: true
    }
  }, true);
}

function nullTitleFun() {
  return {
    align: 'center',
    backgroundColor: null,
    borderRadius: 0,
    floating: false,
    x: 0,
    y: 0,
    text: null,
    style: {
      color: defaultColors[1],
      fontSize: 18,
      fontFamily: defaultFontFamily
    },
    useHtml: false
  };
}

var gradualStyle = 'gradual';

function xyZoomFun() {
  return {
    zoomType: 'xy',
    zoomTool: {
      enabled: false,
      resize: true
    }
  };
}

function rangeLegendFun() {
  return {
    visible: true,
    enabled: true,
    borderColor: defaultColors[4],
    borderWidth: 0,
    hiddenColor: defaultColors[4],
    hoverColor: '#293C55',
    style: {
      color: defaultColors[1],
      fontFamily: defaultFontFamily,
      fontSize: 12
    },
    position: 'right',
    floating: false,
    x: 0,
    y: 0,
    layout: 'vertical',
    continuous: true,
    margin: 10
  };
}

function disabledRangeLegendFun() {
  return _QueryUtils["default"].merge(rangeLegendFun(), {
    enabled: false
  }, true);
}

function disabledLegendFun() {
  return {
    visible: true,
    enabled: false,
    hiddenColor: defaultColors[4],
    hoverColor: '#293C55',
    borderRadius: 0,
    borderColor: defaultColors[4],
    borderWidth: 0,
    backgroundColor: null,
    style: {
      color: defaultColors[1],
      fontFamily: defaultFontFamily,
      fontSize: 12
    },
    position: 'right',
    floating: false,
    layout: 'vertical',
    x: 0,
    y: 0,
    shadow: false,
    margin: 10
  };
}

function xCategoryAxisFun() {
  return {
    type: 'category',
    position: 'bottom',
    onZero: false,
    reversed: false,
    title: {
      text: null,
      align: 'center',
      rotation: 0,
      useHtml: false,
      style: {
        color: defaultColors[1],
        fontFamily: defaultFontFamily,
        fontSize: 12
      }
    },
    lineWidth: 0.5,
    lineColor: defaultColors[2],
    showArrow: false,
    enableTick: true,
    enableMinorTick: false,
    minorTickColor: defaultColors[2],
    minorTickWidth: 0.5,
    minorTickLength: 2,
    tickColor: defaultColors[2],
    tickWidth: 0.5,
    tickLength: 4,
    tickPadding: 4,
    gridLineWidth: 0,
    gridLineColor: defaultColors[3],
    gridLineType: _Constants["default"].SOLID,
    showLabel: true,
    labelStyle: {
      color: defaultColors[1],
      fontFamily: defaultFontFamily,
      fontSize: 12
    },
    labelRotation: 0,
    useHtml: false
  };
}

function yValueAxisFun() {
  return {
    type: 'value',
    position: 'left',
    onZero: false,
    reversed: false,
    title: {
      text: null,
      align: 'center',
      rotation: 0,
      useHtml: false,
      style: {
        color: defaultColors[1],
        fontFamily: defaultFontFamily,
        fontSize: 12
      }
    },
    lineWidth: 0,
    lineColor: defaultColors[2],
    showArrow: false,
    enableTick: false,
    enableMinorTick: false,
    minorTickColor: defaultColors[2],
    minorTickWidth: 0.5,
    minorTickLength: 2,
    tickColor: defaultColors[2],
    tickWidth: 0.5,
    tickLength: 4,
    tickPadding: 4,
    gridLineWidth: 1,
    gridLineColor: defaultColors[3],
    gridLineType: _Constants["default"].SOLID,
    showLabel: true,
    labelStyle: {
      color: defaultColors[1],
      fontFamily: defaultFontFamily,
      fontSize: 12
    },
    labelRotation: 0,
    useHtml: false
  };
}

function xValueAxisFun() {
  return _QueryUtils["default"].merge(xCategoryAxisFun(), {
    type: 'value'
  }, true);
}

function yCategoryAxisFun() {
  return _QueryUtils["default"].merge(yValueAxisFun(), {
    type: 'category'
  }, true);
}

function angleAxisFun() {
  return {
    type: 'category',
    lineWidth: 0.5,
    lineColor: defaultColors[2],
    gridLineWidth: 1,
    gridLineColor: defaultColors[3],
    gridLineType: _Constants["default"].SOLID,
    showLabel: true,
    labelStyle: {
      color: defaultColors[1],
      fontFamily: defaultFontFamily,
      fontSize: 12
    },
    labelRotation: 0,
    useHtml: false
  };
}

function radiusAxisFun() {
  return _QueryUtils["default"].merge(angleAxisFun(), {
    type: 'value'
  }, true);
}

function drillTools() {
  return {
    style: {
      "fontFamily": defaultFontFamily,
      "color": defaultColors[1],
      "fontSize": 12,
      "fontWeight": ""
    },
    currentColor: '#62b2ef',
    backgroundColor: 'white',
    enabled: false
  };
}

var _default = optionsFun;
exports["default"] = _default;

/***/ }),
/* 206 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = compareOptions;
exports._compareSeries = _compareSeries;
exports._getPointKey = _getPointKey;

var _CoreUtils = __webpack_require__(3);

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function compareOptions(lastOptions, options) {
  // 进行一遍克隆，否则后面更新的时候会有对象引用的影响
  lastOptions = _BaseUtils["default"].clone(lastOptions);
  var addData = [],
      updateData = [],
      removeData = [],
      sameKey = [],
      currentKeyOrder = [],
      currentSeriesKeyOrder = [],
      currentCategoryKeyOrder = [],
      series = options.series,
      chartType = options.chartType,
      seriesData,
      key,
      changePoints,
      serCateArray; // hasCategoryChange = false;

  var _getSeriesMap2 = _getSeriesMap(lastOptions),
      lastSeriesMap = _getSeriesMap2.seriesMap,
      lastSeriesKeyOrder = _getSeriesMap2.seriesKeyOrder;

  for (var i = 0, len = series.length; i < len; i++) {
    seriesData = series[i];
    key = _getSeriesKey(seriesData, options.plotOptions);
    /*
    * 一样的系列就一定要跳过吗？？？不会有重复系列吗？？
    * */
    // CHART-15969 ie8-11下，图表不能刷新并报错
    // IE不支持includes（ES7的方法）

    if (sameKey.indexOf(key) > -1) {
      continue;
    }

    sameKey.push(key);
    currentKeyOrder[i] = key;
    currentSeriesKeyOrder.push(key);

    if (lastSeriesMap[key]) {
      changePoints = _compareSeries(lastSeriesMap[key], seriesData, chartType);
      serCateArray = changePoints.result; // if (serCateArray != null) {
      //     hasCategoryChange = true;
      // }

      currentCategoryKeyOrder.push(serCateArray == null ? [] : serCateArray);
      changePoints.addData.length > 0 && addData.push(_calcChangeSeries(changePoints.addData, seriesData));
      changePoints.updateData.length > 0 && updateData.push(_calcChangeSeries(changePoints.updateData, seriesData));
      changePoints.removeData.length > 0 && removeData.push(_calcChangeSeries(changePoints.removeData, seriesData));
      delete lastSeriesMap[key];
    } else {
      if (seriesData.hasOwnProperty('data')) {
        addData.push(seriesData);
      }
    }
  }

  _getRemoveData(lastSeriesMap).forEach(function (removeSeries) {
    removeData.push(removeSeries);
  });

  return {
    add: addData,
    update: updateData,
    remove: removeData,
    option: _calcAdditionalOption(lastOptions, options),
    changeSeriesKeyOrder: _changeOrder(lastSeriesKeyOrder, currentKeyOrder) ? currentSeriesKeyOrder : [],
    changeCategoryKeyOrder: currentCategoryKeyOrder
  };
} // 比较过程暂没想到什么好的重构方法能进行对比抽离出来test


function _compareSeries(lastSeriesData, seriesData, chartType) {
  var addData = [],
      updateData = [],
      currentKeyOrder = [],
      currentCategoryKeyOrder = [],
      sameKey = [],
      pointData,
      key;
  chartType = _calcChartType(chartType, seriesData.type);

  var _getPointMap2 = _getPointMap(lastSeriesData, chartType),
      lastPointMap = _getPointMap2.pointMap,
      lastPointKeyOrder = _getPointMap2.pointKeyOrder;

  var data = _getSeriesData(seriesData);

  for (var i = 0, len = data.length; i < len; i++) {
    pointData = data[i];
    key = _getPointKey(pointData, chartType);

    if (sameKey.indexOf(key) > -1) {
      continue;
    }

    sameKey.push(key);
    currentKeyOrder[i] = key;
    currentCategoryKeyOrder.push(key);

    if (lastPointMap[key]) {
      if (_getPointValue(lastPointMap[key]) != _getPointValue(pointData)) {
        updateData.push(pointData);
      }

      delete lastPointMap[key];
    } else {
      addData.push(pointData);
    }
  }

  var removeData = _getRemoveData(lastPointMap);

  return {
    addData: addData,
    updateData: updateData,
    removeData: removeData,
    result: _changeOrder(lastPointKeyOrder, currentKeyOrder) ? currentCategoryKeyOrder : null
  };
}

function _getSeriesMap(options) {
  var series = options.series,
      seriesMap = {},
      seriesKeyOrder = [],
      seriesData,
      key;

  for (var i = 0, len = series.length; i < len; i++) {
    seriesData = series[i];
    key = _getSeriesKey(seriesData, options.plotOptions);
    seriesMap[key] = seriesData;
    seriesKeyOrder.push(key);
  }

  return {
    seriesMap: seriesMap,
    seriesKeyOrder: seriesKeyOrder
  };
}

function _getPointMap(seriesData, type) {
  var pointMap = {},
      pointKeyOrder = [],
      pointData,
      key,
      data = _getSeriesData(seriesData);

  for (var i = 0, len = data.length; i < len; i++) {
    pointData = data[i];
    key = _getPointKey(pointData, type);
    pointMap[key] = pointData;
    pointKeyOrder.push(key);
  }

  return {
    pointMap: pointMap,
    pointKeyOrder: pointKeyOrder
  };
}

function _getSeriesData(series) {
  return series.hasOwnProperty('data') ? series.data : [];
}

function _getSeriesKey(seriesData, plotOptions) {
  if ((0, _CoreUtils.hasDefined)(seriesData) // eslint-disable-next-line no-prototype-builtins
  && seriesData.hasOwnProperty('type') // eslint-disable-next-line no-prototype-builtins
  && seriesData.hasOwnProperty('name')) {
    var key = "" + seriesData.name + seriesData.type;

    if (seriesData.type === _Constants["default"].PIE_CHART) {
      key += seriesData.roseType ? seriesData.roseType : '';
    }

    if (seriesData.type === _Constants["default"].GAUGE_CHART) {
      key += plotOptions.style == _Constants["default"].THERMOMETER_GAUGE ? "" + plotOptions.style + plotOptions.thermometerLayout : plotOptions.style;
    }

    if (seriesData.type === _Constants["default"].RADAR_CHART) {
      key += seriesData.columnType ? _Constants["default"].COLUMN_RADAR : _Constants["default"].LINE_RADAR;
    }

    return key;
  }

  return '';
}

function _getPointKey(pointData, type) {
  if ((0, _CoreUtils.hasNotDefined)(pointData)) {
    return '';
  }
  /*
  * 饼图、柱形图、折线图、面积图、仪表盘、雷达图、箱型图、力学气泡图
  * */


  if (type == _Constants["default"].PIE_CHART || type == _Constants["default"].COLUMN_CHART || type == _Constants["default"].LINE_CHART || type == _Constants["default"].AREA_CHART || type == _Constants["default"].RADAR_CHART || type == _Constants["default"].GAUGE_CHART || type == _Constants["default"].BOX_CHART || type == _Constants["default"].FORCE_BUBBLE_CHART) {
    return pointData.categoryArray ? pointData.x + "-" + JSON.stringify(pointData.categoryArray) : pointData.x;
  }
  /*
  * 条形图
  * */


  if (type == _Constants["default"].BAR_CHART) {
    return pointData.categoryArray ? pointData.y + "-" + JSON.stringify(pointData.categoryArray) : pointData.y;
  }
  /*
  * 气泡图、散点图
  * */


  if (type == _Constants["default"].BUBBLE_CHART || type == _Constants["default"].SCATTER_CHART) {
    return pointData.x + "-" + pointData.y;
  }
  /*
  * 多层饼图、矩形树图、漏斗图、词云、框架图、区域地图、点地图、热力地图
  * */


  if (type == _Constants["default"].MULTIPIE_CHART || type == _Constants["default"].TREEMAP_CHART || type == _Constants["default"].FUNNEL_CHART || type == _Constants["default"].WORD_CLOUD_CHART || type == _Constants["default"].STRUCTURE_CHART || type == _Constants["default"].AREA_MAP) {
    return pointData.name;
  }

  if (type == _Constants["default"].POINT_MAP || type == _Constants["default"].HEAT_MAP) {
    return pointData.name + "-" + JSON.stringify(pointData.lnglat);
  }
  /*
  * 流向地图
  * */


  if (type == _Constants["default"].LINE_MAP) {
    return JSON.stringify(pointData.from) + "-" + JSON.stringify(pointData.to);
  }
  /*
  * 甘特图
  * */


  if (type == _Constants["default"].GANTT_CHART) {
    return pointData.processesId;
  }

  return '';
}

function _getPointValue(pointData) {
  return JSON.stringify(pointData);
}

function _getRemoveData(lastMap) {
  var removeData = [];

  if (Object.keys(lastMap).length > 0) {
    Object.keys(lastMap).forEach(function (key) {
      removeData.push(lastMap[key]);
    });
  }

  return removeData;
}

function _calcChangeSeries(changePoints, seriesData) {
  seriesData = _BaseUtils["default"].clone(seriesData);
  seriesData.data = changePoints;
  return seriesData;
}

function _changeOrder(lastKeyOrder, currentKeyOrder) {
  var hasNotFoundKey = false,
      tmpIndex_1,
      tmpIndex_2;

  for (var i = 0, len = currentKeyOrder.length - 1; i < len; i++) {
    tmpIndex_1 = lastKeyOrder.indexOf(currentKeyOrder[i]);
    tmpIndex_2 = lastKeyOrder.indexOf(currentKeyOrder[i + 1]);

    if (hasNotFoundKey) {
      if (tmpIndex_1 != -1 || tmpIndex_2 != -1) {
        return true;
      }
    }

    if (tmpIndex_1 != -1 && tmpIndex_2 != -1) {
      if (tmpIndex_2 <= tmpIndex_1) {
        return true;
      }
    } else if (tmpIndex_1 == -1 && tmpIndex_2 != -1) {
      return true;
    } else {
      hasNotFoundKey = true;
    }
  }

  return false;
} // CHART-16089 解决组合图和组合地图的图表类型问题


function _calcChartType(chartType, type) {
  if (chartType == _Constants["default"].MULTI_CHARTS) {
    return type;
  }

  if (chartType.indexOf('Map') > -1) {
    if (type.indexOf('Map') > -1) {
      return type;
    }
  }

  return chartType;
}

function _calcAdditionalOption(lastOptions, options) {
  var option = {};
  Object.keys(options).forEach(function (key) {
    if (key != 'series' && lastOptions[key]) {
      if (_getOptionValue(lastOptions[key]) != _getOptionValue(options[key])) {
        option[key] = options[key];
      }
    }
  });
  return option;
}

function _getOptionValue(option) {
  return JSON.stringify(option);
}

/***/ }),
/* 207 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _chart = _interopRequireDefault(__webpack_require__(74));

var _LineMapLayer = _interopRequireDefault(__webpack_require__(208));

var _CanvasMapLayer = _interopRequireDefault(__webpack_require__(209));

var _HeatMapOverlay = _interopRequireDefault(__webpack_require__(211));

var _Icon = _interopRequireDefault(__webpack_require__(95));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BoundsManager = _interopRequireDefault(__webpack_require__(25));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

var _LayerGroup = _interopRequireDefault(__webpack_require__(49));

var _CircleMarker = _interopRequireDefault(__webpack_require__(213));

var _Marker = _interopRequireDefault(__webpack_require__(214));

var _ScatterMarker = _interopRequireDefault(__webpack_require__(215));

var _VanChartBaseMap = _interopRequireDefault(__webpack_require__(96));

var _ManagerMap = _interopRequireDefault(__webpack_require__(217));

var _component = __webpack_require__(4);

var _renderer = _interopRequireWildcard(__webpack_require__(22));

var _setMapOptions = _interopRequireDefault(__webpack_require__(218));

var _calculateMapSeries = _interopRequireDefault(__webpack_require__(219));

var _validMapPoints = __webpack_require__(28);

var _renderAreaPointMap = _interopRequireDefault(__webpack_require__(220));

var _mapNormalLabel = _interopRequireDefault(__webpack_require__(221));

var _ThemeConfig = __webpack_require__(17);

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/4/10.
 */
var PINCH_SCALE = 1,
    // 默认的pinch是的缩放比例,pinchstart的时候会自动重置为1，主要用来和pinch.scale比较
PINCH_SCALE_INTERVAL = 0.1; // pinch时与上一次缩放的scale的差值,大于该值的时候才会触发地图缩放

var VanChartMap = _VanChartBaseMap["default"].extend({
  vanChartType: 'vanChartMap',
  _initDomLayout: function (dom) {
    var options = this.options;

    this._initContainer(dom);

    this._initLayout();

    this.on(this.getEvents(), this);
    this.dom = this._controlCorners['topleft'];

    if (options.maxBounds) {
      this.setMaxBounds(options.maxBounds);
    }

    if (options.zoom !== undefined) {
      this._zoom = this._limitZoom(options.zoom);
    }

    if (options.center && options.zoom !== undefined) {
      this.setView(_LatLng["default"].create(options.center), options.zoom, {
        reset: true
      });
    }

    this._layers = {};
    this._zoomBoundLayers = {};
    this._sizeChanged = true; // don't animate on browsers without hardware-accelerated transitions or old Android/Opera

    this._zoomAnimated = _DomUtils["default"].TRANSITION && _Browser["default"].any3d && !_Browser["default"].mobileOpera && this.options.zoomAnimation; // zoom transitions run with the same duration for all layers, so if one of transitionend events
    // happens after starting zoom animation (propagating to the map pane), we know that it ended globally

    if (this._zoomAnimated) {// this._createAnimProxy();
      // L.DomEvent.on(this._proxy, DomUtils.TRANSITION_END, this._catchTransitionEnd, this);
    }

    _VanChartBaseMap["default"].prototype._initDomLayout.call(this, this._controlCorners['topleft']);

    if (this.isMobileFlow()) {
      this.__flowManager = new _ManagerMap["default"](this.handler);
      this.handler.registerManager(this.__flowManager);
    }
  },
  setOptions: function (options) {
    (0, _setMapOptions["default"])(this, options);
  },
  getMapRenderer: function () {
    var dom = this._panes['overlayPane'];

    if (!this.mapRenderer) {
      this.mapRenderer = (0, _renderer["default"])(dom, this);
      this.addLayer(this.mapRenderer);
    }

    return this.mapRenderer;
  },
  getTileLayerUrl: function (options) {
    var tileLayer = options.tileLayer || this.options.geo.tileLayer;
    return (0, _ThemeConfig.getThemeAutoValue)(tileLayer, 'mapTileLayer', this.isDarkTheme());
  },
  getEvents: function () {
    return {
      'mousemove': this._onMouseMove,
      'scroll': this._onScroll,
      'panstart': this._onPanStart,
      'panmove': this._onPanMove,
      'panend': this._onPanEnd,
      'wheel': this._onWheelScroll,
      'pinchstart': this._pinchStart,
      'pinchmove': this._onPinch,
      'zoom': this._onZoom
    };
  },
  registerInteractiveTarget: function (data, elementWrapper) {
    _VanChartBaseMap["default"].prototype.registerInteractiveTarget.call(this, data, elementWrapper);

    data.addEventParent(this);
  },
  _zoomEnabled: function () {
    return this.options.geo.zoom && this._eventsConfig.pinch;
  },
  _onMouseMove: function (ev) {
    this.cancelLegendHighlight(ev.containerPoint);
  },
  _onScroll: function () {
    this._container.scrollTop = 0;
    this._container.scrollLeft = 0;
  },
  //mark the start of drag
  _onPanStart: function (event) {
    if (this._zoomEnabled()) {
      this._initPos = _DomUtils["default"].getPosition(this._mapPane);
      this._startPoint = event.containerPoint; // 抓取开始，使用抓取中手型dragging,绑定在this._container即可

      this._mapDragged = true;
      this.bindIEDragCursor();

      this._stop();
    }
  },
  _onPanMove: function (event) {
    if (this._zoomEnabled()) {
      _BaseUtils["default"].cancelAnimFrame(this._animRequest);

      var offset = event.containerPoint.subtract(this._startPoint);
      this._newPos = this._initPos.add(offset);
      this._animRequest = _BaseUtils["default"].requestAnimFrame(function () {
        this.setMapPanePosition(this._newPos); // 拖拽地图的时候移除MoreLabel

        this.removeMoreLabel();
      }, this, true);

      _DomUtils["default"].addClass(document.body, 'leaflet-dragging');
    }
  },
  _onPanEnd: function () {
    if (this._zoomEnabled()) {
      this.fire('moveend'); // 抓取结束，恢复正常手型drag

      this._mapDragged = false;
      this.bindIEDragCursor();

      _DomUtils["default"].removeClass(document.body, 'leaflet-dragging');

      var pos = this._getMapPanePos();

      if (Math.max(Math.abs(pos.x), Math.abs(pos.y)) >= this.options.transform3DLimit) {
        // https://bugzilla.mozilla.org/show_bug.cgi?id=1203873 but Webkit also have
        // a pixel offset on very high values, see: http://jsfiddle.net/dg6r5hhb/
        this._resetView(this.getCenter(), this.getZoom());
      }
    }
  },
  _pinchStart: function () {
    PINCH_SCALE = 1;
  },
  _onPinch: function (e) {
    var eventScale = e.scale,
        map = this,
        pointCenterArray = [];

    if (!this._zoomEnabled()) {
      return;
    } // 手势缩放比例过小时地图不进行缩放


    if (Math.abs(PINCH_SCALE - eventScale) < PINCH_SCALE_INTERVAL) {
      return;
    }

    var zoomType = PINCH_SCALE > eventScale ? -1 : 1; // 判断是放大还是缩小
    // @Cmen=CHART-839:钻取地图-->移动端手势缩放自动钻取
    // 注：只有点地图和区域地图支持钻取，且chartType不能用做判断的标准，比如组合地图的时候chartType为areaMap，里面可能就包含lineMap

    map.series.forEach(function (ser) {
      var isPointMap = ser.type === _Constants["default"].POINT_MAP,
          isAreaMap = ser.type === _Constants["default"].AREA_MAP;

      if (isPointMap || isAreaMap) {
        var points = ser.points;
        points.forEach(function (point) {
          var layers = point.layers || [];
          layers.forEach(function (layer) {
            var center = isPointMap ? point.getLatLng() : layer.getCenter ? layer.getCenter() : null; // 区域地图如果其坐标未定义，layer.getCenter不可用

            center && pointCenterArray.push({
              point: point,
              distance: map.latLngToContainerPoint(center).distanceTo(e.containerPoint)
            });
          });
        });
      }
    });
    pointCenterArray.sort(function (p1, p2) {
      return p1.distance - p2.distance;
    });
    this.hoverPoint = pointCenterArray.length && pointCenterArray[0].point;
    this._pinchZoom = map._limitZoom(map.getZoom() + zoomType * Math.abs(eventScale - 1)); //移动端还是用center，触摸屏center不准确，用containerPoint。
    //诡异的是，mac投屏不支持缩放。

    this._pinchCenter = this.isMobile() ? e.center : e.containerPoint;

    if (!this._pinchStartTime) {
      this._pinchStartTime = +new Date();
    }

    var debounce = this.options.wheelDebounceTime;
    var left = Math.max(debounce - (+new Date() - this._pinchStartTime), 0); // 现在这样感觉定时器就没有必要了，但是也不影响，就留着吧

    clearTimeout(this._pinchTimer);
    this._pinchTimer = setTimeout(function () {
      map._stop(); // stop panning and fly animations if any


      map._pinchStartTime = null;
      map.setZoomAround(_Point2D["default"].create(map._pinchCenter), map._pinchZoom);
    }, left);
    PINCH_SCALE = eventScale;
  },
  _onWheelScroll: function (e) {
    if (!this._zoomEnabled()) {
      return;
    }

    e = e.srcEvent;

    var delta = _DomUtils["default"].getWheelDelta(e);

    var debounce = this.options.wheelDebounceTime;
    this._delta = _BaseUtils["default"].pick(this._delta, 0);
    this._delta += delta;
    this._lastMousePos = this.mouseEventToContainerPoint(e);

    if (!this._startTime) {
      this._startTime = +new Date();
    }

    var left = Math.max(debounce - (+new Date() - this._startTime), 0);
    clearTimeout(this._timer);
    this._timer = setTimeout(_BaseUtils["default"].bind(this._performZoom, this), left);

    _DomUtils["default"].stop(e);
  },
  // 地图暂时好像不需要做什么
  _animationEnd: function () {
    this._animationStarted = false;
    this.drawAllEffects();
  },
  drawAllEffects: function () {
    // 地图闪烁动画只画validPoints,validPoints的意义详见areaPointMapValidPoints方法
    var validMapPoints = (0, _validMapPoints.areaPointMapValidPoints)(this);
    validMapPoints.forEach(function (point) {
      var series = point.series;
      series.drawPointEffect(point);
    });
  },
  _animationStart: function () {
    //锁住fire的'animationEnd'
    this._animationStarted = true; // this.animationCount = 0;   地图这边动画在renderSeries里面就已经开始了

    var vanchart = this; // 这里考虑渐变色图例加闪烁动画，如果图表在renderSeries时，没有动画，是否理解执行animationEnd,
    // 实验结果证明，这样高频率的绑定effect动画，会造成视觉上的抖动。因此这里在animationStart和animationEnd之间
    // 给予250毫秒的间隔，当诸如拖动渐变色图例这样的高频渲染情况下，节约性能

    if (!this.animationCount) {
      this.setTimeout("chart_animation_end", function () {
        vanchart.fire('animationEnd');
      }, 250);
    }

    if (false) {}
  },
  _initLayout: function () {
    var container = this._container;
    this._fadeAnimated = !this.options.toPhantom && this.options.fadeAnimation && _Browser["default"].any3d;

    _DomUtils["default"].addClass(container, 'leaflet-container' + (_Browser["default"].touch ? ' leaflet-touch' : '') + (_Browser["default"].retina ? ' leaflet-retina' : '') + (_Browser["default"].ielt9 ? ' leaflet-oldie' : '') + (_Browser["default"].safari ? ' leaflet-safari' : '') + (this._fadeAnimated ? ' leaflet-fade-anim' : ''));

    var position = _DomUtils["default"].getStyle(container, 'position');

    if (position !== 'absolute' && position !== 'relative' && position !== 'fixed') {
      container.style.position = 'relative';
    } //@CHART-1451(https://github.com/Leaflet/Leaflet/issues/1549:Map tiles are not clipped by border-radius in Webkit )


    container.style.zIndex = container.style.zIndex || "0";

    this._initPanes();

    this._initControlPos();
  },
  _initPanes: function () {
    var panes = this._panes = {};
    this._mapPane = this.createPane('rootPane', this._container);

    _DomUtils["default"].setPosition(this._mapPane, new _Point2D["default"](0, 0)); // @pane tilePane: HTMLElement = 200
    // Pane for `GridLayer`s and `TileLayer`s


    this.createPane('tilePane'); // @pane overlayPane: HTMLElement = 400
    // Pane for vector overlays (`Path`s), like `Polyline`s and `Polygon`s

    this.createPane('overlayPane'); // @pane markerPane: HTMLElement = 600
    // Pane for `Icon`s of `Marker`s

    this.createPane('markerPane');

    if (!this.options.markerZoomAnimation) {
      _DomUtils["default"].addClass(panes.markerPane, 'leaflet-zoom-hide');
    }
  },
  layoutComponentsAndCharts: function () {
    this.initLayerInfo();
    var vanchart = this;
    vanchart.bounds = vanchart._getDefaultBounds();

    _component.ComponentsOrder.map(function (c) {
      if (c in vanchart.components) {
        vanchart.components[c].doLayout();
      }
    }, this);

    this.reRenderSeries();
  },
  filterRender: function () {
    /**
     * 这里之前的考虑是，渐变色图例拖拽，exit的动画会覆盖update的样式设置，倒是render的结果出错，
     * 然后和郑大姐讨论得出的结论是尝试在这里把renderer.isAnimation设为false，即下面renderSeries里面的动画都不执行
     * 按理说应该可以保证不覆盖，看了一下点地图好像的确没问题，今天检查了区域地图，拖得快的情况下，还是会覆盖，导致区域地图的颜色刷不出来
     * 可见即使设置noAnimation, ele.animate的结束也要比JS慢一大拍
     * 如此一来，那么只能用这种及其丑陋的写法+判断了：
     * 这里设置useFilterRender为true，所有关于layer的动画，在useFilterRender时，都直接更新属性或样式，否则则正常执行动画
     * @type {boolean}
     */
    this.useFilterRender = true;
    this.renderSeries();
    this.useFilterRender = false;
  },
  // 点地图、区域地图
  _updateSeriesStyle: function () {
    var validMapPoints = (0, _validMapPoints.areaPointMapValidPoints)(this);
    validMapPoints.forEach(function (point) {
      if (!point.layers || !point.visible) {
        return; //removed
      }

      var style = point.series._getDynamicStyle(point);

      point.layers.forEach(function (layer) {
        layer.setStyle(style);
      });
    });
  },
  reRenderWholePlot: function () {
    var legend = this.components[_component.ComponentCst.LEGEND_COMPONENT];
    legend && legend.render();
    this.reRenderSeries();
  },
  //地图需要在当前层级上刷新
  refreshRestore: function () {
    this._initIntermediateState();

    for (var component in this.components) {
      this.components[component].refresh();
    }

    this.series.forEach(function (ser, index) {
      ser.refresh(ser.options, index);
    });
    this.updateRangeLegend();
    this.series.forEach(function (ser) {
      // try in large mode
      if (ser.type === _Constants["default"].LINE_MAP && ser.options.large) {
        return;
      }

      for (var i = 0, len = ser.points.length; i < len; i++) {
        ser.points[i].refreshPointColor();
      }
    });
    this.layoutComponentsAndCharts();
  },
  reRenderSeries: function () {
    this.hoverPoint = this.hoverSeries = null;
    this.calculateMapSeries();
    this.render();
  },
  calculateMapSeries: function () {
    var vanchart = this;
    (0, _calculateMapSeries["default"])(vanchart);
  },
  defaultDrillUpDataPoint: function () {
    for (var i = 0; i < this.series.length; i++) {
      var ser = this.series[i];

      if (ser && ser.points) {
        var points = ser.points;

        for (var j = 0; j < points.length; j++) {
          if (points[j]) {
            return points[j];
          }
        }
      }
    }
  },
  initLayerInfo: function () {
    if (this.layerMap) {
      //新的options进来的时候调用
      return;
    } //@mango CHART-1830
    //监控刷新，this._effectLayer._layers中layer会不停的增加，是导致浏览器内存不断增大的原因之一；
    //当刷新时，手动清理_effectLayer，并将_effectLayer置为null；


    if (this._effectLayer && this._effectLayer._layers) {
      for (var key in this._effectLayer._layers) {
        this.removeLayer(this._effectLayer._layers[key]);
      }

      this._effectLayer._layers = null;
      this._effectLayer = null;
    }

    this.layerMap = [];
    this.layerIndex = 0;
    var geo = this.getComponent(_component.ComponentCst.GEO_COMPONENT);
    var series = this.series;
    this.layerMap = [{
      series: series,
      geo: geo,
      layerIndex: this.layerIndex,
      drillUpDataPoint: this.defaultDrillUpDataPoint()
    }];
  },
  _createChildSeriesWhenLoaded: function (point) {
    if (point.childSeries) {
      return;
    }

    var childSeries = [],
        vanchart = this;
    vanchart.parentPoint = point;
    point.options.drilldown.series.forEach(function (sery, index) {
      var classType = sery.type || vanchart.options.chartType;
      var Class = (0, _chart["default"])(classType);
      childSeries.push(new Class(sery, vanchart, index));
    });
    point.childSeries = childSeries;
  },
  allowDrillDown: function (dataPoint) {
    var lastLayer = this.layerMap[this.layerIndex - 1];
    return dataPoint.options.drilldown && dataPoint.options.drilldown.series && (!lastLayer || lastLayer.drillUpDataPoint != dataPoint);
  },
  drillDown: function (dataPoint) {
    if (this.allowDrillDown(dataPoint)) {
      this._createChildSeriesWhenLoaded(dataPoint);

      this.layerMap[this.layerIndex].drillUpDataPoint = dataPoint;

      this._setNewGeoAndSeries(dataPoint.geo, dataPoint.childSeries, this.layerIndex + 1);
    }
  },
  drillUp: function (iconData) {
    var vanchart = this;

    if (iconData.series == vanchart.series) {
      return;
    }

    this._setNewGeoAndSeries(iconData.geo, iconData.series, iconData.layerIndex);
  },
  removeAllLayers: function () {
    var vanchart = this;

    for (var i = 0, len = vanchart.series.length; i < len; i++) {
      var ser = vanchart.series[i],
          type = ser.type,
          points = ser.points;
      points.forEach(function (point) {
        vanchart.removePointGraphics(point, type);
      });
    }
  },
  _setNewGeoAndSeries: function (geo, series, newLayerIndex) {
    var vanchart = this; //先要删除上一层的所有的layer

    vanchart.removeAllLayers();
    this._canvasMapLayer && this._canvasMapLayer.setData([]);
    vanchart.series = series;
    var lastGeo = this.layerMap[this.layerIndex] ? this.layerMap[this.layerIndex].geo : undefined;
    this.layerMap[newLayerIndex] = {
      geo: geo,
      series: series,
      layerIndex: newLayerIndex,
      drillUpDataPoint: this.defaultDrillUpDataPoint()
    };
    this.layerIndex = newLayerIndex;
    this.layerMap = this.layerMap.slice(0, newLayerIndex + 1);
    lastGeo && lastGeo.remove();
    this.updateRangeLegend();
    series.forEach(function (ser) {
      for (var i = 0, len = ser.points.length; i < len; i++) {
        ser.points[i].refreshPointColor();
      }
    });
    this.setComponent(geo, _component.ComponentCst.GEO_COMPONENT);
    this.layoutComponentsAndCharts();
  },
  updateRangeLegend: function () {
    var rangeLegend = this.components[_component.ComponentCst.RANGE_LEGEND_COMPONENT];

    if (rangeLegend) {
      rangeLegend.initAttributesWithSeries();
    }
  },
  cancelLegendHighlight: function (containerPoint) {
    var highlightTarget = this.highlightTarget;

    _VanChartBaseMap["default"].prototype.cancelLegendHighlight.call(this, containerPoint);

    if (this._lineMapLayer && highlightTarget) {
      this._lineMapLayer.redraw();
    }
  },
  makeLegendHighlight: function (target) {
    _VanChartBaseMap["default"].prototype.makeLegendHighlight.call(this, target);

    if (this._lineMapLayer) {
      this._lineMapLayer.redraw();
    }
  },
  getEffectLayer: function () {
    var vanchart = this;

    if (!vanchart._effectLayer) {
      vanchart._effectLayer = new _LayerGroup["default"]().addTo(vanchart);
    }

    return vanchart._effectLayer;
  },
  renderSeries: function () {
    this.removeMoreLabel();
    this.animationCount = 0; // renderSeries即动画开始

    var tooltip = this.getComponent(_component.ComponentCst.TOOLTIP_COMPONENT);
    tooltip && tooltip.immediateHide(); // 换一个简单的逻辑实现，先把区块都画一遍，用空值的颜色，再把数据点的样子画出来

    var vanchart = this;
    this._pointLayer = this._pointLayer || new _LayerGroup["default"]().addTo(this);
    vanchart.seriesOfType(_Constants["default"].SCATTER_CHART).concat(vanchart.seriesOfType(_Constants["default"].BUBBLE_CHART)).forEach(function (ser) {
      vanchart.activeDataEvents(ser);
    });
    var largeTypes = [_Constants["default"].SCATTER_CHART, _Constants["default"].BUBBLE_CHART];
    this.largeSeries = largeTypes.reduce(function (obj, type) {
      obj[type] && obj[type].points && obj[type].points.forEach(function (point) {
        // 可能是为了性能将完全重叠的点就去掉了，所以这个时候的point.graphic为undefined，
        // 调用remove函数就会报错，在这里添加一层判断避免报错。
        point && point.graphic && point.graphic.remove();
        point.graphic = null;
      });
      obj[type] = obj[type] || {
        visible: true,
        type: type
      };
      obj[type].points = [];
      return obj;
    }, this.largeSeries || {});

    this._renderAreaPointMap();

    this._renderHeatMap(); // CHART-2368
    // VanChartBaseMap._animateZoom
    // ……重构就是重写


    this.setTimeout('renderLineMap', function () {
      vanchart._renderLineMap();
    }, 300);

    this._renderMapOnCanvas(); // 地图初始动画结束后画标签


    vanchart.setTimeout('render map label', function () {
      vanchart.updateLabel();
    }, 800);
    this.fire('animationStart');
  },
  _onZoom: function () {
    var vanchart = this,
        hoverPoint = vanchart.hoverPoint,
        zoomLevel = vanchart.getZoom(); //检查是否要做自动下钻,如果下钻成功,则直接返回

    if (hoverPoint && hoverPoint.geo) {
      var zoomListener = hoverPoint.geo.getZoomListener();

      if (zoomListener && zoomListener <= zoomLevel) {
        vanchart.drillDown(hoverPoint);
        return;
      }
    }

    var lastLayer = vanchart.layerMap[vanchart.layerIndex - 1]; // @CHART-2346: 默认的只有鼠标触发的zoom且currentZoomLevel < lastZoomLevel才会自动上钻

    if (lastLayer && this._scrollZoom && lastLayer.geo.getZoomListener() > zoomLevel) {
      vanchart.drillUp(lastLayer);
    }

    this._scrollZoom = false;
  },
  updateLabel: function () {
    var needShowMoreLabel = this._needShowMoreLabel();

    if (!needShowMoreLabel || this.layerIndex > 0) {
      this._updateNormalLabel();

      return;
    }

    var vanchart = this;

    vanchart._updateNormalLabel(); // renderSeries的时候，地图这时如果正好在animateZoom
    // 那么就导致showMoreLabel计算的位置，和animateZoom结束后不对应，，从而发生数据点与提示位置偏移
    // 这里hack一下，350毫秒后才_updateMoreLabels（250ms内animateZoom就结束了），保证此时点的位置已经是最终的位置


    needShowMoreLabel && this.setTimeout("map_label_timer", function () {
      vanchart._updateMoreLabels();
    }, 350);
    vanchart._changeDataState = false;
  },
  _updateMoreLabels: function () {
    var vanchart = this;
    var validMapPoints = (0, _validMapPoints.areaPointMapValidPoints)(vanchart).concat(this._getHeatMapPoints());
    validMapPoints.forEach(function (point) {
      var latlng = point.getLatLng();

      if (latlng) {
        var pixels = vanchart.latLngToLayerPoint(latlng); // 区域地图和点地图这边绘制的时候，只取points[0]存在validPoints里面，因此要遍历所有point.points

        var points = point.points;
        points.length && points.forEach(function (p) {
          p.series._showMoreLabel(p, pixels.x, pixels.y);
        });
      }
    });
  },
  _updateNormalLabel: function () {
    this._fixConflictLabel();

    var vanchart = this;
    (0, _mapNormalLabel["default"])(vanchart);
    var manager = new _BoundsManager["default"]();

    if (vanchart.isMobileFlow()) {
      var layers = vanchart._textGroup && vanchart._textGroup._layers;
      layers && Object.keys(layers).forEach(function (key) {
        var layer = layers[key]; // FIXPM 因为不知道会搞出什么东西来，所以加各种空检查

        if (!layer) {
          return;
        }

        var text = layer._text;

        if (!text) {
          return;
        }

        var x = text.offsetLeft,
            y = text.offsetTop;
        var ch = text.children;

        for (var i = 0; i < ch.length; i++) {
          var c = ch[i];

          if (!c) {
            continue;
          }

          var b = {
            x: x + c.offsetLeft,
            y: y + c.offsetTop,
            width: c.offsetWidth,
            height: c.offsetHeight
          };

          if (manager.isOverlapped(b)) {
            c.style.visibility = 'hidden';
          } else {
            manager.addBounds(b);
          }
        }
      });
    }
  },
  _fixConflictLabel: function () {
    var vanchart = this,
        manager = new _BoundsManager["default"]();
    var geo = vanchart.getCurrentGeo(),
        labelPoints = (0, _validMapPoints.areaPointMapValidPoints)(vanchart).concat(this._getHeatMapPoints());
    labelPoints.forEach(function (point) {
      var type = point.series.type;
      point.labelPos = null;

      if (type == _Constants["default"].AREA_MAP && point.labelContent) {
        var features = geo.getFeaturesByName(point.name, type);
        features.forEach(function (feature, index) {
          point.labelPos = point.labelPos || [];

          if (feature.properties.center) {
            var labelBounds = vanchart._getTextBounds(point, feature);

            point.labelPos[index] = labelBounds;
            manager.isValidBounds(labelBounds) && manager.addBounds(labelBounds); // @CHART-1542: 对于区域地图和气泡地图的组合,某一个dataLabel的enable为false时，计算出的bounds的height和width为0，这样的无效点，就没有必要存到BoundsManager里面作为是否重叠的判断依据了
          } else {
            point.labelPos[index] = null;
          }
        });

        if (point.labelPos && !point.labelPos.filter(function (p) {
          return !!p;
        }).length) {
          point.labelPos = null;
        }
      }
    });
    labelPoints.forEach(function (point) {
      if (point.labelContent) {
        var type = point.series.type;
        var features = geo.getFeaturesByName(point.name, type);
        features = point.options.lnglat ? ['null'] : features;

        if (features) {
          features.forEach(function (feature, index) {
            if (!point.labelPos || !point.labelPos[index]) {
              var labelBounds = vanchart._getTextBounds(point, feature);

              if (manager.isOverlapped(labelBounds)) {
                point.labelPos = point.labelPos || [];
                point.labelPos[index] = null;
              } else {
                point.labelPos = point.labelPos || [];
                point.labelPos[index] = labelBounds;
                manager.isValidBounds(labelBounds) && manager.addBounds(labelBounds);
              }
            }

            if (point.labelPos && !point.labelPos.filter(function (p) {
              return !!p;
            }).length) {
              point.labelPos = null;
            }
          });
        }
      }
    });
  },
  _getTextBounds: function (point, feature) {
    var vanchart = this;
    var latlng = point.getLatLng(feature);
    var pixels = vanchart.latLngToContainerPoint(latlng);
    var leftTop = this.getLabelLeftTop(point);
    return _BaseUtils["default"].makeBounds([pixels.x + leftTop.left, pixels.y + leftTop.top], point.labelDim);
  },
  //计算重叠 应该和实际画 走一套代码
  getLabelLeftTop: function (point) {
    var marker = point.options.marker,
        icon = point.options.icon,
        seriesType = point.series.type;
    var startY = -point.labelDim.height / 2;

    if (seriesType === _Constants["default"].SCATTER_CHART || seriesType === _Constants["default"].POINT_MAP) {
      if (marker && !_BaseUtils["default"].isImageMarker(marker.symbol)) {
        var radius = marker.radius || _Constants["default"].MARKER_RADIUS;
        startY = -radius - point.labelDim.height;
      } else {
        //icon是都会传的，不能作为判别使用默认点地图图标的标准 seriesType可以
        var iconHeight = seriesType === _Constants["default"].POINT_MAP ? icon.iconSize[1] : marker.height;
        startY = -iconHeight / 2 - point.labelDim.height;
      }
    }

    if (marker) {
      startY -= 4;
    } //标签和图片的间隔


    return {
      left: -point.labelDim.width / 2,
      top: startY
    };
  },
  updatePointLayer: function (point, layer) {
    var type = point.series.type;

    switch (type) {
      case _Constants["default"].BUBBLE_CHART:
        layer.setAttr(point.radius);
        break;

      case _Constants["default"].SCATTER_CHART:
        layer.setAttr(point.options.marker);
        break;
    }
  },
  createPointLayer: function (feature, point, options) {
    var type = point.series.type;
    var latlng = point.getLatLng(feature);
    var layer;

    switch (type) {
      case _Constants["default"].BUBBLE_CHART:
        layer = new _CircleMarker["default"](latlng, options, point.radius).addTo(this._pointLayer);
        break;

      case _Constants["default"].POINT_MAP:
        layer = new _Marker["default"](latlng, {
          icon: new _Icon["default"](point.options.icon)
        }).addTo(this._pointLayer);
        break;

      case _Constants["default"].SCATTER_CHART:
        var marker = point.options.marker;

        var isImageMarker = _BaseUtils["default"].isImageMarker(marker.symbol);

        if (isImageMarker) {
          options = {
            icon: new _Icon["default"]({
              iconSize: [marker.width, marker.height],
              iconUrl: marker.symbol
            })
          };
        }

        layer = isImageMarker ? new _Marker["default"](latlng, options) : new _ScatterMarker["default"](latlng, options, point.options.marker);
        layer.addTo(this._pointLayer);
    }

    layer.setStyle && layer.setStyle(options) && layer.setStyle({
      'pointer-events': "auto"
    });
    return layer;
  },
  getCurrentGeo: function () {
    return this.layerMap ? this.layerMap[this.layerMap.length - 1].geo : this.components.geo;
  },
  _getHeatMapPoints: function () {
    return (0, _validMapPoints.getHeatMapPoints)(this).filter(function (point) {
      return point.visible;
    });
  },
  _getHeatMapDataAndConfig: function (validPoints) {
    var heatMapSeries = this.seriesOfType(_Constants["default"].HEAT_MAP);
    var rangeLegend = this.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT);

    if (!heatMapSeries || !heatMapSeries.length || !rangeLegend) {
      return {};
    }

    var data = {
      'min': rangeLegend._getMin(),
      'max': rangeLegend._getMax(),
      'data': validPoints
    };
    var options = heatMapSeries[0].options;
    var config = {
      'maxOpacity': options.maxOpacity,
      'minOpacity': options.minOpacity,
      'radius': options.radius,
      'blur': options.blur,
      'gradient': rangeLegend._getGradient(),
      'valueField': 'value'
    };
    return {
      data: data,
      config: config
    };
  },
  _removeHeatMapTextGraphics: function () {
    var _this = this;

    (0, _validMapPoints.getHeatMapPoints)(this).forEach(function (point) {
      if (!point.visible) {
        _this.removePointGraphics(point, _Constants["default"].HEAT_MAP);
      }
    });
  },
  _removeHeatMapOverlay: function () {
    this._heatMapOverlay && this.removeLayer(this._heatMapOverlay);
    this._heatMapOverlay = null;
  },
  _renderHeatMap: function () {
    var validPoints = this._getHeatMapPoints();

    this._removeHeatMapTextGraphics();

    if (validPoints.length === 0) {
      return this._removeHeatMapOverlay();
    }

    var _this$_getHeatMapData = this._getHeatMapDataAndConfig(validPoints),
        data = _this$_getHeatMapData.data,
        config = _this$_getHeatMapData.config;

    if (!this._heatMapOverlay) {
      this._heatMapOverlay = new _HeatMapOverlay["default"](config).addTo(this);
    }

    this._heatMapOverlay.setData(data);
  },
  removePointGraphics: function (point, type, animate) {
    if (point) {
      type = type || point.series.type;
      var vanchart = this;

      if (type === _Constants["default"].LINE_MAP) {
        this._lineMapLayer.removeEffect(point);

        point.remove();
      }

      if (point.layers) {
        point.layers.forEach(function (layer) {
          vanchart.removeInteractiveTarget(point, layer); // removeLayer等写在exitAnimate.end中了

          var useFilterRender = vanchart.useFilterRender;
          layer.exitAnimate && layer.exitAnimate(vanchart, useFilterRender ? false : !!animate);
        });

        if (type != _Constants["default"].AREA_MAP) {
          point.layers = null;
        }
      }

      var textG = this._textGroup;

      if (point.textLayers && textG) {
        point.textLayers.forEach(function (layer) {
          textG.removeLayer(layer);
        });
        point.textLayers = null;
        point.labelPos = null;
      }

      point.series.clearPointEffect(point);
    }
  },
  // 绘制区域地图和点地图
  _renderAreaPointMap: function () {
    var vanchart = this;
    (0, _renderAreaPointMap["default"])(vanchart);
  },
  _renderLineMap: function () {
    var lineMapSeries = this.seriesOfType(_Constants["default"].LINE_MAP);
    var data = lineMapSeries.reduce(function (accum, seriesItems) {
      return accum.concat(seriesItems.points);
    }, []);

    if (!lineMapSeries.length || !data.length) {
      this._lineMapLayer && this._lineMapLayer.setData([]);
      return;
    }

    if (!this._lineMapLayer) {
      var vanchart = this;
      var size = this.getSize();
      var options = {
        width: size.x,
        height: size.y,
        x: 0,
        y: 0,
        dpr: window.devicePixelRatio || 1
      };
      var mainRenderer = this.mainRenderer = (0, _renderer.createCanvasRenderer)(this._panes.overlayPane, this, options);
      var animationRenderer = this.animationRenderer = (0, _renderer.createCanvasRenderer)(this._panes.overlayPane, this, options);
      mainRenderer.onAdd();
      animationRenderer.onAdd();
      this.addCanvasRendererForResize(mainRenderer);
      this.addCanvasRendererForResize(animationRenderer);
      this._lineMapLayer = (0, _LineMapLayer["default"])({
        mainRenderer: mainRenderer,
        animationRenderer: animationRenderer,
        vanchart: vanchart
      }).addTo(this);
    }

    this._lineMapLayer.setData(data);
  },
  _renderMapOnCanvas: function () {
    var largeSeries = (0, _validMapPoints.pointMapLargeModePoints)(this);

    var data = largeSeries[_Constants["default"].SCATTER_CHART].points.concat(largeSeries[_Constants["default"].BUBBLE_CHART].points); // 数据为空，就不用创建canvasMapOverLayer了
    // @CHART-2263 空数据时，clear已有的canvas


    if (!data.length) {
      this._canvasMapLayer && this._canvasMapLayer.options.renderer && this._canvasMapLayer.options.renderer.clearAll();
      return;
    } // 开启大数据的情况下，每一个气泡的颜色都强制转换成第一个系列的气泡颜色


    var color,
        len = data.length,
        i = 0,
        p;

    for (; i < len; i++) {
      p = data[i]; // 将最初的气泡颜色保存起来，下次用户刷新图表的时候再将这个颜色值赋值给color属性

      p.originalColor ? p.color = p.originalColor : p.originalColor = p.color;
      !color && (color = p.color);
      p.color = color;
    }

    if (!this._canvasMapLayer) {
      var vanchart = this;
      var size = this.getSize();
      var options = {
        width: size.x,
        height: size.y,
        x: 0,
        y: 0,
        dpr: window.devicePixelRatio || 1
      };
      var mainRenderer = this.mapCanvasRenderer = (0, _renderer.createCanvasRenderer)(this._panes.overlayPane, this, options);
      mainRenderer.onAdd();
      this.addCanvasRendererForResize(this.mapCanvasRenderer);
      this._canvasMapLayer = new _CanvasMapLayer["default"]({
        renderer: mainRenderer,
        vanchart: vanchart
      }).addTo(this);
    }

    this._canvasMapLayer.setData(data);
  },

  /**
   * 获取mapPane在Y轴上位移的限制
   * @returns {*[]}
   * @private
   */
  _getMaxMinMapPaneTranslateY: function () {
    var top = [90, 0],
        bottom = [-90, 0],
        center = [0, 0];
    var maxY = this.latLngToLayerPoint(top).y * -1,
        minY = this.height - this.latLngToLayerPoint(bottom).y,
        centerY = this.height / 2 - this.latLngToLayerPoint(center).y;
    return this._getMapPaneHeight() > this.height ? [minY, maxY] : [centerY]; // 底图高度大于图表时，限制为纬度90度到纬度-90度，反之则底图居中
  },

  /**
   * 根据纬度限制条件，设置mapPane的位置
   * @param pos
   * @param rangeTransY 之前计算获得的偏移范围限制，节约利用
   */
  setMapPanePosition: function (pos, rangeTransY) {
    this.mapTrans = pos; //ImageMap 不需要限制经纬度，直接更新pos

    if (this.getCurrentGeo()._isImageMap()) {
      _DomUtils["default"].setPosition(this._mapPane, pos);

      return;
    }

    var mapPaneMaxMinTransY = rangeTransY || this._getMaxMinMapPaneTranslateY();

    if (mapPaneMaxMinTransY.length === 2) {
      var minY = mapPaneMaxMinTransY[0],
          maxY = mapPaneMaxMinTransY[1];
      pos.y = Math.min(maxY, Math.max(minY, pos.y));
    } else {
      pos.y = mapPaneMaxMinTransY[0];
    }

    _DomUtils["default"].setPosition(this._mapPane, pos);
  },

  /**
   * 获取当前缩放层级下底图的高度
   * @returns {number}
   * @private
   */
  _getMapPaneHeight: function () {
    return Math.pow(2, this._zoom) * 256;
  },

  /**
   * 缩放的过程中，调整mapPaneTranslate
   * 主要为了保证底图大于图表高度时底图与边界之间不出现空白
   * Only adjust when it needs to -- Cmen
   * @private
   */
  _adjustMapPaneTranslateAfterZoom: function () {
    var mapTrans = this.mapTrans || new _Point2D["default"](0, 0);

    var rangeTransY = this._getMaxMinMapPaneTranslateY();
    /**
     * 当底图高度大于当前图表高度this.height时，底图能完全在图表区内显示（能够不出现空白），rangeTransY有minY&maxY，作为底图上下偏移的范围
     maxY是图层能往下拖拽的最大限度（想看北极，就往下拖拽）。minY是图层能往上拖拽的最大限度。
     一般地，maxY为正 minY为负。当底图的y偏移量mapTrans.y在偏移范围之内，则不需adjust直接返回
     但若minY与maxY同号时(由于初始中心点的设定)，此时必然有空白，需要adjust
     */


    if (rangeTransY.length === 2) {
      var minY = rangeTransY[0],
          maxY = rangeTransY[1];

      if (maxY >= mapTrans.y && mapTrans.y >= minY) {
        //按位异或，两数异号时结果为负
        if (maxY ^ minY < 0) {
          return;
        }
      }
    }

    this.setMapPanePosition(mapTrans, rangeTransY);
    this.fire("zoom");
  },

  /**
   * 底图在拖拽方向上是否到达边界
   * 由于左右默认是可以无限拖动的，故这里只需要考虑上下的边界
   * @param ev
   * @returns {boolean}
   */
  isPanMovingAtTheBoundary: function (ev) {
    if (!this._zoomEnabled()) {
      return true;
    }

    var direction = ev.direction,
        upward = direction === _Constants["default"].DIRECTION_UP,
        downward = direction === _Constants["default"].DIRECTION_DOWN;
    var mapPaneTransY = this.mapTrans ? this.mapTrans.y : 0;

    var minMaxMapPaneTranslateY = this._getMaxMinMapPaneTranslateY();

    var limitPolarRegion = this._getMapPaneHeight() > this.height; // 是否以两极作为上下滑动限制
    // 底图高度大于图表高度时，(向下且底图滑动到纬度90度)||(向上且底图滑动到纬度-90)，则此时底图在拖拽方向上到达边界
    // 当底图小于图表高度时，底图位置整体居中，这时拖拽方向为upward或者downward都是认为到达边界

    return limitPolarRegion && upward && mapPaneTransY === minMaxMapPaneTranslateY[0] || downward && mapPaneTransY === minMaxMapPaneTranslateY[1] || !limitPolarRegion && (upward || downward);
  }
});

var _default = VanChartMap;
exports["default"] = _default;

/***/ }),
/* 208 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.lineMap = lineMap;
exports["default"] = _default;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var LINE_MAP = _Constants["default"].LINE_MAP;
var LARGE_MODE_COLOR = 'rgba(255, 255, 0, 1)';
var SQRT2 = Math.SQRT2;
var INIT_TIME = 800;
var INIT_EASE = 'ease-in-out-quad';

function lineMap(mainRenderer, animationRenderer, leafletMap) {
  var _data = [];

  function data(data) {
    _data = data;
    return this;
  }

  function clear() {
    _data = [];
    return this;
  }

  function redraw(highlightTarget) {
    draw(true, highlightTarget);
  }

  function lineMapLargeModeColor(data) {
    var validPoints = data.filter(function (point) {
      var series = point.series;
      return series.options.large && !point.isNull && point.visible && series.visible;
    });

    if (!validPoints.length) {
      return LARGE_MODE_COLOR;
    }

    validPoints[0].refreshPointColor();
    return _ColorUtils["default"].mixColorWithAlpha(validPoints[0].color, validPoints[0].opacity);
  }

  function draw(redraw, highlightTarget) {
    var len = _data.length;
    var largeModeColor = lineMapLargeModeColor(_data);

    _data.map(function (p) {
      var series = p.series;
      var large = series.options.large;
      var visible = !p.isNull && p.visible && series.visible;
      var staged = p.graphic;
      var options = p.options;
      var fLng = options.from.lnglat[0],
          fLat = options.from.lnglat[1];
      var tLng = options.to.lnglat[0],
          tLat = options.to.lnglat[1];

      if (fLng === tLng && fLat === tLat) {
        return;
      }

      var from = leafletMap.latLngToContainerPoint([fLat, fLng]);
      var to = leafletMap.latLngToContainerPoint([tLat, tLng]);
      p.ax = from.x;
      p.ay = from.y;
      p.bx = to.x;
      p.by = to.y;
      p.curveness = options.curveness;
      p.curveness === 0 && (p.curveness = 0.01);

      if (visible) {
        if (large) {
          mainRenderer.ctx.globalCompositeOperation = 'lighter';
          p._color = largeModeColor;
        } else {
          var opacity = p.opacity;

          if (highlightTarget) {
            opacity *= p.series.name == highlightTarget || p._rangeItem == highlightTarget ? 1 : _Constants["default"].HOVER_OPACITY;
          }

          p._color = _ColorUtils["default"].mixColorWithAlpha(p.color, opacity);
        }
      } // enter/update/exit process


      if (visible && !staged) {
        var arc, ani; // enter

        p.graphic = mainRenderer.arc();
        p.graphic.point = p;
        arc = mapShapeStyle(p.graphic, p);

        if ((0, _EnvUtils.isSupportSVG)() && !redraw && !large && series.options.animation && p.options.lineWidth) {
          p.graphic.style['endAngle'] = arc[3];
          ani = p.graphic.animate().duration(INIT_TIME).ease(INIT_EASE).tween('endAngle', arc[4]);
        }

        if ((0, _EnvUtils.isSupportSVG)() && !large && visible && p.options.effect && p.options.effect.enabled) {
          var indexInSeries = series.points.indexOf(p);

          if (ani) {
            ani.end(singleEffect.bind(this, p, len, indexInSeries));
          } else {
            singleEffect(p, len, indexInSeries);
          }
        }
      } else if (visible && staged) {
        //update
        mapShapeStyle(p.graphic, p); // CHART-15775,原本在有effect时候又enabled才去removeEffect，，但实际如果没有流向后台传来json没有effect属性

        if ((0, _CoreUtils.hasNotDefined)(p.options.effect) || !p.options.effect.enabled) {
          removeEffect(p);
        }

        if ((0, _EnvUtils.isSupportSVG)() && !large && visible && p.options.effect) {
          if (!p._effect && p.options.effect.enabled) {
            var _indexInSeries = series.points.indexOf(p);

            singleEffect(p, len, _indexInSeries);
          }
        } // effect depends on graphic
        // so update graphic = update effect

      } else if (!visible && staged) {
        // exit
        p.graphic.needToRemove = true;
        p.graphic = null;
        removeEffect(p);
      }
    });
  }

  function removeEffect(p) {
    // stop effect animation
    if (p._effect) {
      p._effect.stop();

      p._effect = null;
    }

    if (p._symbol) {
      p._symbol.needToRemove = true;
      p._symbol = null;
    }
  } // animation handle plain value now
  // so make an ugly helper...


  function mapShapeStyle(graphic, p) {
    var arc = _BaseUtils["default"].computeArc(p.ax, p.ay, p.bx, p.by, p.curveness);

    graphic.setStyle({
      x: arc[0],
      y: arc[1],
      r: arc[2],
      startAngle: arc[3],
      endAngle: arc[4],
      lineWidth: p.options.lineWidth,
      strokeStyle: p._color
    });
    return arc;
  }

  function stop() {
    animationRenderer.clearAll();
  }

  function singleEffect(p, len, i) {
    if (!p.graphic) {
      return;
    }

    var period = p.options.effect.period || 2000;
    p._effect = animationRenderer.animation.animate(p.graphic.style).delay(period / 5 * i / len).duration(period).tween('track', function (target) {
      return drawEffect(target, p);
    }).end(singleEffect.bind(this, p, len, i));
  }

  function drawEffect(g, p) {
    var begin = g.startAngle;
    var end = g.endAngle;
    var length = (end - begin) / 3;
    var distance = end - begin + length;
    var options = p.options.effect;
    p._symbol && p._symbol.remove();

    if (options.symbol) {
      var url = options.symbol;
      var width = options.width;
      var height = options.height;
      var dpr = window.devicePixelRatio || 1;
      p._symbol = animationRenderer.image({
        url: url,
        width: width,
        height: height
      });
      return function (t) {
        var style = drawSymbol(distance * t, g.x, g.y, g.r, g.startAngle, g.endAngle, length, url, width, height, dpr);

        p._symbol.setStyle(style || {
          x: null
        });
      };
    }

    var maxR = 1.5; // px

    p._symbol = animationRenderer.lineEffect({
      ox: g.x,
      oy: g.y,
      r: g.r,
      d: maxR,
      fillStyle: p.color
    });
    return function (t) {
      // var style = drawTailShape(distance * t, g.x, g.y, g.r, g.startAngle, g.endAngle, length);
      // p._symbol.setStyle(style);
      drawTailShape(p._symbol, distance * t, g.x, g.y, g.r, g.startAngle, g.endAngle, length);
    };
  }

  function drawSymbol(progress, ox, oy, r, begin, end, length, url, width, height, dpr) {
    var base = progress - length + begin;

    if (progress + begin > end) {
      return;
    }

    var th = length + base;
    var x = r * Math.cos(th) + ox;
    var y = r * Math.sin(th) + oy;
    return {
      x: x,
      y: y,
      radian: Math.PI + th
    };
  } // new


  function drawTailShape(symbol, progress, ox, oy, r, begin, end, length) {
    var from = progress > length ? 0 : length - progress;
    var to = progress + begin < end ? length : length - (progress + begin - end);
    var base = progress - length + begin; // return {
    //     ox: ox,
    //     oy: oy,
    //     startAngle: from + base,
    //     endAngle: to + base
    // }

    var s = symbol.style;
    s.ox = ox;
    s.oy = oy;
    s.r = r;
    s.startAngle = from + base;
    s.endAngle = to + base;
  }

  return {
    data: data,
    lineMapLargeModeColor: lineMapLargeModeColor,
    clear: clear,
    draw: draw,
    redraw: redraw,
    stop: stop,
    removeEffect: removeEffect
  };
}

var LineMapLayer = _Layer["default"].extend({
  options: {
    mainRenderer: null,
    animationRenderer: null,
    vanchart: null
  },
  initialize: function (options) {
    _BaseUtils["default"].setOptions(this, options);
  },
  setData: function (pairs) {
    this._pairs = pairs;
    return this._draw(); //todo, ->redraw
  },
  addData: function (pair) {
    this._pairs.push(pair);

    return this._draw();
  },
  setOptions: function (options) {
    _BaseUtils["default"].setOptions(this, options);

    if (this._lineMap) {
      this._updateOptions();
    }

    return this._draw();
  },
  redraw: function () {
    this._lineMap.redraw(this.options.vanchart.highlightTarget);

    this.options.mainRenderer.flush();
    return this;
  },
  removeEffect: function (p) {
    if (this._lineMap) {
      this._lineMap.removeEffect(p);
    }
  },
  onAdd: function (map) {
    this._map = map;

    if (!this._lineMap) {
      this._initRenderer();
    }

    map.on('moveend', this._reset, this);

    if (map.options.zoomAnimation && _Browser["default"].any3d) {
      map.on('zoomanim', this._animateZoom, this);
    }

    map.on(this._events, this);

    this._reset();
  },
  onRemove: function (map) {
    if (this.options.pane) {
      this.getPane().removeChild(this._canvas);
      this.getPane().removeChild(this._animCanvas);
    } else {
      map.getPanes().overlayPane.removeChild(this._canvas);
      map.getPanes().overlayPane.removeChild(this._animCanvas);
    }

    map.off('moveend', this._reset, this);

    if (map.options.zoomAnimation) {
      map.off('zoomanim', this._animateZoom, this);
    }

    map.off(this._events, this);
  },
  addTo: function (map) {
    map.addLayer(this);
    return this;
  },
  _initRenderer: function () {
    var canvas = this._canvas = this.options.mainRenderer._container.node();

    var animCanvas = this._animCanvas = this.options.animationRenderer._container.node();

    var originProp = _DomUtils["default"].TRANSFORM_ORIGIN;
    canvas.style[originProp] = animCanvas.style[originProp] = '50% 50%';
    var animated = this._map.options.zoomAnimation && _Browser["default"].any3d;
    var zoomStyle = 'leaflet-zoom-' + (animated ? 'animated' : 'hide');
    var layerStyle = 'leaflet-linemap-layer leaflet-layer ';

    _DomUtils["default"].addClass(canvas, layerStyle + zoomStyle);

    _DomUtils["default"].addClass(animCanvas, layerStyle + zoomStyle);

    this._lineMap = lineMap(this.options.mainRenderer, this.options.animationRenderer, this._map);
  },
  _updateOptions: function () {},
  _reset: function () {
    this._lineMap.stop();

    var topLeft = this._map.containerPointToLayerPoint([0, 0]);

    _DomUtils["default"].setPosition(this._canvas, topLeft);

    _DomUtils["default"].setPosition(this._animCanvas, topLeft);

    this._draw(); // todo,
    // flash sometimes, don't know why
    //
    // var topLeft = this._map.containerPointToLayerPoint([0, 0]);
    // var size = this._map.getSize();
    //
    // var mainRenderer = this.options.mainRenderer;
    // var animationRenderer = this.options.animationRenderer;
    //
    // if (mainRenderer.left !== topLeft.x ||
    //     mainRenderer.top !== topLeft.y ||
    //     mainRenderer.width !== size.x ||
    //     mainRenderer.height !== size.y) {
    //
    //     this._lineMap.stop();
    //
    //     mainRenderer.setPosition(topLeft.x, topLeft.y);
    //     mainRenderer.setSize(size.x, size.y);
    //
    //     animationRenderer.setPosition(topLeft.x, topLeft.y);
    //     animationRenderer.setSize(size.x, size.y);
    //
    //     this._draw();
    // }

  },
  _draw: function () {
    if (!(this._map && this._pairs && this._pairs.length)) {
      this.options.mainRenderer.flush();
      return;
    }

    this._lineMap.data(this._pairs).draw();

    this.options.mainRenderer.flush();
  },
  _animateZoom: function (e) {
    this._lineMap.stop();

    var scale = this._map.getZoomScale(e.zoom),
        offset = this._map._getCenterOffset(e.center)._multiplyBy(-scale).subtract(this._map._getMapPanePos());

    if (_DomUtils["default"].setTransform) {
      // todo, use our own functions
      // this.options.animationRenderer.left =
      //     this.options.mainRenderer.left = offset.x;
      // this.options.animationRenderer.top =
      //     this.options.mainRenderer.top = offset.y;
      _DomUtils["default"].setTransform(this._canvas, offset, scale);

      _DomUtils["default"].setTransform(this._animCanvas, offset, scale);
    } else {
      var trans = _BaseUtils["default"].makeTranslate(offset) + ' scale(' + scale + ')';
      this._canvas.style[_DomUtils["default"].TRANSFORM] = trans;
      this._animCanvas.style[_DomUtils["default"].TRANSFORM] = trans;
    }
  },
  _events: {
    tap: function (ev) {
      var vanchart = this.options.vanchart;

      if (vanchart && vanchart.isMobile()) {
        this._map.fire('mousemove', ev);
      }

      var point = this.hoverPoint;

      if (point) {
        point._onPointTap(ev); // fire('tap') no effect?

      }
    },
    unchosen: function () {
      var vanchart = this.options.vanchart;
      var mainRenderer = this.options.mainRenderer;
      vanchart.hideTooltip();

      if (this.hoverPoint) {
        // recover
        this.recoverStrokeColor(this.hoverPoint);
        this.hoverPoint = null;
      }

      mainRenderer.flush();
    },
    mousemove: function (ev) {
      var mainRenderer = this.options.mainRenderer;
      var vanchart = this.options.vanchart,
          handler = vanchart.handler;
      var self = this;
      var target = mainRenderer.findTargetByMousePosition(ev.containerPoint);
      var targetPoint = target && target.point;
      var large = targetPoint && targetPoint.series.options.large;

      if (targetPoint) {
        // found target
        if (isTooltipEnabled(targetPoint)) {
          handler.removeAllChosen(ev);
          handler.lineMapTargetFind = true;
          vanchart.showTooltip(targetPoint, ev);
        }

        handler.cursor(targetPoint.series._pointerStyle()); // has hover color and needs to change

        if (targetPoint.mouseOverColor && !large && targetPoint !== self.hoverPoint) {
          // change target element color
          target.style.strokeStyle = target.point.mouseOverColor;
        } // 当前选中的point的tooltip不可见且上一次鼠标选中的point的tooltip可见时，应隐藏提示框


        if (!isTooltipEnabled(targetPoint) && isTooltipEnabled(self.hoverPoint)) {
          vanchart.hideTooltip();
        }
      } else {
        handler.lineMapTargetFind = false; // 当前鼠标悬浮没有选中任何point时，如果vanchart的hoverPoint为空，
        // 或者上一次鼠标悬浮的point的tooltip可见时，应隐藏提示框

        if (!vanchart.hoverPoint || isTooltipEnabled(self.hoverPoint)) {
          vanchart.hideTooltip();
        }

        vanchart.handler.cursor('');
      } // different from last


      if (!large && self.hoverPoint !== targetPoint) {
        // recover
        self.hoverPoint && self.recoverStrokeColor(self.hoverPoint);
        self.hoverPoint = targetPoint; // 当鼠标选中point的tooltip可见且和上一次选中的point不同时，更新vanchart的hoverPoint

        if (isTooltipEnabled(targetPoint)) {
          vanchart.hoverPoint = targetPoint;
        }

        mainRenderer.flush();
      }
    }
  },
  recoverStrokeColor: function (point) {
    point.graphic.style.strokeStyle = point._color;
  }
});

function isTooltipEnabled(point) {
  return point && point.options && point.options.tooltip && point.options.tooltip.enabled;
}

function _default(options) {
  return new LineMapLayer(options);
}

/***/ }),
/* 209 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _CanvasLayer = _interopRequireDefault(__webpack_require__(210));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/7/11.
 */
var DET = 30;

var _default = _CanvasLayer["default"].extend({
  _drawPoints: function (points) {
    var vanchart = this.options.vanchart,
        renderer = this.options.renderer;
    var hasRangelegend = vanchart.hasRangeLegend();
    var width = renderer.width;
    var height = renderer.height;
    var len = points.length,
        i = len; // todo

    renderer.elements = []; // 倒过来筛，因为后面的覆盖前面

    while (i--) {
      var p = points[i];
      var latlng = p.getLatLng();

      if (!latlng) {
        continue;
      }

      var pos = vanchart.latLngToContainerPoint(latlng);
      var x = pos.x,
          y = pos.y;

      if (x < -DET || width + DET < x || y < -DET || height + DET < y || !hasRangelegend && renderer.shouldFilter(x, y)) {
        if (p.graphic) {
          p.graphic.needToRemove = true; // todo, remove from canvas but save in point

          p.graphic = null;
        }

        continue;
      }

      p.x = pos.x;
      p.y = pos.y;

      if (p.graphic) {
        renderer.elements.push(p.graphic);
        var x = p.x,
            y = p.y;
        var marker = p.options.marker;

        if (marker) {
          var symbol = marker.symbol,
              radius = marker.radius; // todo, remove this condition

          if (symbol === _Constants["default"].LOCATION) {
            y -= radius;
          } else if (symbol === _Constants["default"].SQUARE_HOLLOW || symbol === _Constants["default"].SQUARE) {
            x -= radius;
            y -= radius;
          }
        }

        p.graphic.setStyle({
          x: x,
          y: y
        });
      } else {
        p.graphic = this._getGraphic(p, renderer);
        p.graphic.point = p;
      }
    }

    var left = null;
    var right = null;
    var array = renderer.elements;

    for (left = 0, right = length - 1; left < right; left += 1, right -= 1) {
      var temporary = array[left];
      array[left] = array[right];
      array[right] = temporary;
    }

    renderer.resetFilter();
  },
  _getGraphic: function (p, renderer) {
    if (p.series.type === _Constants["default"].SCATTER_CHART) {
      var marker = p.options.marker,
          symbol = marker.symbol,
          radius = marker.radius,
          color = marker.fillColor || p.color;

      if (symbol === _Constants["default"].LOCATION) {
        return renderer.image({
          url: _Constants["default"].LOCATION,
          x: p.x,
          y: p.y - radius,
          width: radius * 2,
          height: radius * 2,
          color: p.color
        });
      }

      return renderer.marker(symbol, {
        x: p.x,
        y: p.y,
        radius: radius,
        color: _ColorUtils["default"].mixColorWithAlpha(p.color, p.opacity)
      });
    } else {
      // bubble
      return renderer.circle({
        x: p.x,
        y: p.y,
        r: p.radius,
        fillStyle: _ColorUtils["default"].mixColorWithAlpha(p.color, p.opacity)
      });
    }
  }
});

exports["default"] = _default;

/***/ }),
/* 210 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _Browser = _interopRequireDefault(__webpack_require__(8));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/7/7.
 */
var _default = _Layer["default"].extend({
  options: {
    renderer: null,
    vanchart: null
  },
  initialize: function (options) {
    _BaseUtils["default"].setOptions(this, options);
  },
  setOptions: function (options) {
    _BaseUtils["default"].setOptions(this, options);

    this._draw();
  },
  onAdd: function (map) {
    this._map = map;

    this._initRenderer();

    map.on('moveend', this._reset, this);

    if (map.options.zoomAnimation && _Browser["default"].any3d) {
      map.on('zoomanim', this._animateZoom, this);
    }

    map.on(this._events, this);

    this._reset();
  },
  onRemove: function (map) {
    if (this.options.pane) {
      this.getPane().removeChild(this._canvas);
    } else {
      map.getPanes().overlayPane.removeChild(this._canvas);
    }

    map.off('moveend', this._reset, this);

    if (map.options.zoomAnimation) {
      map.off('zoomanim', this._animateZoom, this);
    }

    map.off(this._events, this);
  },
  setData: function (points) {
    this._points = points;

    this._draw();
  },
  addTo: function (map) {
    map.addLayer(this);
    return this;
  },
  _initRenderer: function () {
    var canvas = this._canvas = this.options.renderer._container.node();

    var originProp = _DomUtils["default"].TRANSFORM_ORIGIN;
    canvas.style[originProp] = '50% 50%';
    var animated = this._map.options.zoomAnimation && _Browser["default"].any3d;
    var zoomStyle = 'leaflet-zoom-' + (animated ? 'animated' : 'hide');
    var layerStyle = 'leaflet-linemap-layer leaflet-layer ';

    _DomUtils["default"].addClass(canvas, layerStyle + zoomStyle);
  },
  _reset: function () {
    var topLeft = this._map.containerPointToLayerPoint([0, 0]);

    _DomUtils["default"].setPosition(this._canvas, topLeft);

    this._draw();
  },
  _draw: function () {
    if (this._map && this._points && this._points.length) {
      this._drawPoints(this._points);
    }

    this.options.renderer.flush();
  },
  _animateZoom: function (e) {
    var scale = this._map.getZoomScale(e.zoom),
        offset = this._map._getCenterOffset(e.center)._multiplyBy(-scale).subtract(this._map._getMapPanePos());

    _DomUtils["default"].setTransform(this._canvas, offset, scale);
  },
  _events: {
    tap: function (ev) {
      var vanchart = this.options.vanchart;

      if (vanchart.isMobile()) {
        this._events.mousemove.call(this, ev);

        vanchart.setTimeout('mobileTooltip', function () {
          vanchart.hideTooltip();
        }, 4000);
      }

      var point = this.hoverPoint;
      point && point._onPointTap(ev);
    },
    mousemove: function (ev) {
      var renderer = this.options.renderer;
      var vanchart = this.options.vanchart;
      var self = this;
      var target = renderer.findTargetByMousePosition(ev.containerPoint);
      var targetPoint = target && target.point;
      var large = targetPoint && targetPoint.series.options.large;

      if (targetPoint) {
        // found target
        vanchart.handler.removeAllChosen(ev);
        vanchart.handler.canvasMapTargetFind = true;
        vanchart.showTooltip(targetPoint, ev);
        vanchart.handler.cursor('pointer'); // // has hover color and needs to change
        // if (targetPoint.mouseOverColor && !large &&
        //     targetPoint !== self.hoverPoint) {
        //
        //     // change target element color
        //     target.style.color = target.point.mouseOverColor;
        // }
      } else {
        vanchart.handler.canvasMapTargetFind = false;

        if (!vanchart.hoverPoint) {
          vanchart.hideTooltip();
        }

        vanchart.handler.cursor('');
      } // different from last


      if (self.hoverPoint != targetPoint) {
        // if (self.hoverPoint) {
        //     // recover
        //     self.hoverPoint.graphic.style.color = self.hoverPoint._color;
        // }
        self.hoverPoint = targetPoint; // renderer.flush();
      }
    }
  }
});

exports["default"] = _default;

/***/ }),
/* 211 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Point2D = _interopRequireDefault(__webpack_require__(15));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

var _heatmap = _interopRequireDefault(__webpack_require__(212));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/3/13.
 */
var HeatMapOverlay = _Layer["default"].extend({
  initialize: function (config) {
    this.cfg = config;
    this._el = _DomUtils["default"].create('div', 'leaflet-zoom-hide');
    this._el.style.zIndex = 201;
    this._data = [];
    this._max = 1;
    this._min = 0;
    this.cfg.container = this._el;
  },
  onAdd: function (map) {
    var size = map.getSize();
    this._map = map;
    this._width = size.x;
    this._height = size.y;
    this._el.style.width = size.x + 'px';
    this._el.style.height = size.y + 'px';
    this._el.style.position = 'absolute';
    this._origin = this._map.layerPointToLatLng(new _Point2D["default"](0, 0));
    map.getPanes().overlayPane.appendChild(this._el);

    if (!this._heatmap) {
      this._heatmap = _heatmap["default"].create(this.cfg);
    } // this resets the origin and redraws whenever
    // the zoom changed or the map has been moved


    map.on('moveend', this._reset, this);
    map.on(this._events, this);

    this._draw();
  },
  addTo: function (map) {
    map.addLayer(this);
    return this;
  },
  onRemove: function (map) {
    // remove layer's DOM elements and listeners
    map.getPanes().overlayPane.removeChild(this._el);
    map.off('moveend', this._reset, this);
    map.off(this._events, this);
  },
  _draw: function () {
    if (!this._map) {
      return;
    }

    var mapPane = this._map.getPane('rootPane');

    var point = mapPane._leaflet_pos; // reposition the layer

    if ((0, _EnvUtils.isSupportSVG)()) {
      this._el.style[HeatMapOverlay.CSS_TRANSFORM()] = 'translate(' + -Math.round(point.x) + 'px,' + -Math.round(point.y) + 'px)';
    } else {
      this._el.style.left = -Math.round(point.x) + 'px';
      this._el.style.bottom = Math.round(point.y) + 'px';
    }

    this._update();
  },
  _update: function () {
    var bounds, zoom, scale;
    var generatedData = {
      max: this._max,
      min: this._min,
      data: []
    };
    bounds = this._map.getBounds();
    zoom = this._map.getZoom();
    scale = Math.pow(2, zoom);

    if (this._data.length === 0) {
      if (this._heatmap) {
        this._heatmap.setData(generatedData);
      }

      return;
    }

    var latLngPoints = [];
    var radiusMultiplier = this.cfg.scaleRadius ? scale : 1;
    var localMax = 0;
    var localMin = 0;
    var valueField = this.cfg.valueField;
    var len = this._data.length;

    while (len--) {
      var entry = this._data[len];
      var value = entry[valueField];
      var latlng = entry.latlng; // we don't wanna render points that are not even on the map ;-)

      if (!bounds.contains(latlng)) {
        continue;
      } // local max is the maximum within current bounds


      localMax = Math.max(value, localMax);
      localMin = Math.min(value, localMin);

      var point = this._map.latLngToContainerPoint(latlng);

      var latlngPoint = {
        x: Math.round(point.x),
        y: Math.round(point.y)
      };
      latlngPoint[valueField] = value;
      var radius;

      if (entry.radius) {
        radius = entry.radius * radiusMultiplier;
      } else {
        radius = (this.cfg.radius || 2) * radiusMultiplier;
      }

      latlngPoint.radius = radius;
      latLngPoints.push(latlngPoint);
    }

    if (this.cfg.useLocalExtrema) {
      generatedData.max = localMax;
      generatedData.min = localMin;
    }

    generatedData.data = latLngPoints;

    this._heatmap.setData(generatedData);
  },
  setData: function (data) {
    this._max = (0, _CoreUtils.hasDefined)(data.max) ? data.max : this._max;
    this._min = (0, _CoreUtils.hasDefined)(data.min) ? data.min : this._min;
    var lnglatField = this.cfg.lnglatField || 'lnglat';
    var valueField = this.cfg.valueField || 'value'; // transform data to latlngs

    var data = data.data;
    var len = data.length;
    var d = [];

    while (len--) {
      var entry = data[len].options;
      var latlng = new _LatLng["default"](entry[lnglatField][1], entry[lnglatField][0]);
      var dataObj = {
        latlng: latlng
      };
      dataObj[valueField] = entry[valueField];

      if (entry.radius) {
        dataObj.radius = entry.radius;
      }

      d.push(dataObj);
    }

    this._data = d;

    this._draw();
  },
  // experimential... not ready.
  addData: function (pointOrArray) {
    if (pointOrArray.length > 0) {
      var len = pointOrArray.length;

      while (len--) {
        this.addData(pointOrArray[len]);
      }
    } else {
      var lnglatField = this.cfg.lnglatField || 'lnglat';
      var valueField = this.cfg.valueField || 'value';
      var entry = pointOrArray;
      var latlng = new _LatLng["default"](entry[lnglatField][1], entry[lnglatField][0]);
      var dataObj = {
        latlng: latlng
      };
      dataObj[valueField] = entry[valueField];
      this._max = Math.max(this._max, dataObj[valueField]);
      this._min = Math.min(this._min, dataObj[valueField]);

      if (entry.radius) {
        dataObj.radius = entry.radius;
      }

      this._data.push(dataObj);

      this._draw();
    }
  },
  _reset: function () {
    this._origin = this._map.layerPointToLatLng(new _Point2D["default"](0, 0));

    var size = this._map.getSize();

    if (this._width !== size.x || this._height !== size.y) {
      this._width = size.x;
      this._height = size.y;
      this._el.style.width = this._width + 'px';
      this._el.style.height = this._height + 'px';

      this._heatmap._renderer.setDimensions(this._width, this._height);
    }

    this._draw();
  },
  _setCursor: function (cursor) {
    var canvas = this._heatmap._renderer && this._heatmap._renderer.canvas;
    canvas && (canvas.style.cursor = cursor);
  },
  _events: {
    tap: function (ev) {
      // todo, 移动端点击触发Tap特别费劲
      var vanchart = this._map; // 移动端需要考虑showToolTip

      if (vanchart.isMobile()) {
        vanchart.fire('mousemove', ev);
      }

      vanchart.hoverPoint && vanchart.hoverPoint._onPointTap(ev);
    },
    mousemove: function (ev) {
      var vanchart = this._map;

      var closestPoint = vanchart.handler._getCanvasClosestPoint(ev.containerPoint);

      if (closestPoint) {
        vanchart.handler.removeAllChosen(ev);
        vanchart.handler.heatMapTargetFind = true;

        if (!closestPoint._events) {
          closestPoint.getEvents && closestPoint.on(closestPoint.getEvents(), closestPoint);
        }

        vanchart.showTooltip(closestPoint, ev);
        vanchart.hoverPoint = closestPoint;

        this._setCursor(closestPoint.series._pointerStyle());
      } else {
        this._setCursor('inherit');

        vanchart.handler.heatMapTargetFind = false;
        vanchart.hideTooltip();
      }
    }
  }
});

HeatMapOverlay.CSS_TRANSFORM = function () {
  var div = document.createElement('div');
  var props = ['transform', 'WebkitTransform', 'MozTransform', 'OTransform', 'msTransform'];

  for (var i = 0; i < props.length; i++) {
    var prop = props[i];

    if (div.style[prop] !== undefined) {
      return prop;
    }
  }

  return props[0];
};

var _default = HeatMapOverlay;
exports["default"] = _default;

/***/ }),
/* 212 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _EnvUtils = __webpack_require__(2);

var _Browser = _interopRequireDefault(__webpack_require__(8));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/*
 * heatmap.js v2.0.5 | JavaScript Heatmap Library
 *
 * Copyright 2008-2016 Patrick Wied <heatmapjs@patrick-wied.at> - All rights reserved.
 * Dual licensed under MIT and Beerware license
 *
 * :: 2016-09-05 01:16
 */
// Heatmap Config stores default values and will be merged with instance config
var HeatmapConfig = {
  defaultRadius: 40,
  defaultRenderer: 'canvas2d',
  defaultGradient: {
    0.25: "rgb(0,0,255)",
    0.55: "rgb(0,255,0)",
    0.85: "yellow",
    1.0: "rgb(255,0,0)"
  },
  defaultMaxOpacity: 1,
  defaultMinOpacity: 0,
  defaultBlur: .85,
  defaultXField: 'x',
  defaultYField: 'y',
  defaultValueField: 'value',
  plugins: {}
};

var Store = function StoreClosure() {
  var Store = function Store(config) {
    this._coordinator = {};
    this._data = [];
    this._radi = [];
    this._min = 10;
    this._max = 1;
    this._xField = config['xField'] || config.defaultXField;
    this._yField = config['yField'] || config.defaultYField;
    this._valueField = config['valueField'] || config.defaultValueField;

    if (config["radius"]) {
      this._cfgRadius = config["radius"];
    }
  };

  var defaultRadius = HeatmapConfig.defaultRadius;
  Store.prototype = {
    // when forceRender = false -> called from setData, omits renderall event
    _organiseData: function (dataPoint, forceRender) {
      var x = dataPoint[this._xField];
      var y = dataPoint[this._yField];
      var radi = this._radi;
      var store = this._data;
      var max = this._max;
      var min = this._min; // @CHART-9046

      var value = +(dataPoint[this._valueField] || 1);
      var radius = dataPoint.radius || this._cfgRadius || defaultRadius;

      if (!store[x]) {
        store[x] = [];
        radi[x] = [];
      }

      if (!store[x][y]) {
        store[x][y] = value;
        radi[x][y] = radius;
      } else {
        store[x][y] += value;
      }

      var storedVal = store[x][y];

      if (storedVal > max) {
        if (!forceRender) {
          this._max = storedVal;
        } else {
          this.setDataMax(storedVal);
        }

        return false;
      } else if (storedVal < min) {
        if (!forceRender) {
          this._min = storedVal;
        } else {
          this.setDataMin(storedVal);
        }

        return false;
      } else {
        return {
          x: x,
          y: y,
          value: value,
          radius: radius,
          min: min,
          max: max
        };
      }
    },
    _unOrganizeData: function () {
      var unorganizedData = [];
      var data = this._data;
      var radi = this._radi;

      for (var x in data) {
        for (var y in data[x]) {
          unorganizedData.push({
            x: x,
            y: y,
            radius: radi[x][y],
            value: data[x][y]
          });
        }
      }

      return {
        min: this._min,
        max: this._max,
        data: unorganizedData
      };
    },
    _onExtremaChange: function () {
      this._coordinator.emit('extremachange', {
        min: this._min,
        max: this._max
      });
    },
    addData: function () {
      if (arguments[0].length > 0) {
        var dataArr = arguments[0];
        var dataLen = dataArr.length;

        while (dataLen--) {
          this.addData.call(this, dataArr[dataLen]);
        }
      } else {
        // add to store
        var organisedEntry = this._organiseData(arguments[0], true);

        if (organisedEntry) {
          // if it's the first datapoint initialize the extremas with it
          if (this._data.length === 0) {
            this._min = this._max = organisedEntry.value;
          }

          this._coordinator.emit('renderpartial', {
            min: this._min,
            max: this._max,
            data: [organisedEntry]
          });
        }
      }

      return this;
    },
    setData: function (data) {
      var dataPoints = data.data;
      var pointsLen = dataPoints.length; // reset data arrays

      this._data = [];
      this._radi = [];

      for (var i = 0; i < pointsLen; i++) {
        this._organiseData(dataPoints[i], false);
      }

      this._max = data.max;
      this._min = data.min || 0;

      this._onExtremaChange();

      this._coordinator.emit('renderall', this._getInternalData());

      return this;
    },
    removeData: function () {// TODO: implement
    },
    setDataMax: function (max) {
      this._max = max;

      this._onExtremaChange();

      this._coordinator.emit('renderall', this._getInternalData());

      return this;
    },
    setDataMin: function (min) {
      this._min = min;

      this._onExtremaChange();

      this._coordinator.emit('renderall', this._getInternalData());

      return this;
    },
    setCoordinator: function (coordinator) {
      this._coordinator = coordinator;
    },
    _getInternalData: function () {
      return {
        max: this._max,
        min: this._min,
        data: this._data,
        radi: this._radi
      };
    },
    getData: function () {
      return this._unOrganizeData();
    }
    /*,
       TODO: rethink.
       getValueAt: function(point) {
      var value;
      var radius = 100;
      var x = point.x;
      var y = point.y;
      var data = this._data;
       if (data[x] && data[x][y]) {
      return data[x][y];
      } else {
      var values = [];
      // radial search for datapoints based on default radius
      for(var distance = 1; distance < radius; distance++) {
      var neighbors = distance * 2 +1;
      var startX = x - distance;
      var startY = y - distance;
       for(var i = 0; i < neighbors; i++) {
      for (var o = 0; o < neighbors; o++) {
      if ((i == 0 || i == neighbors-1) || (o == 0 || o == neighbors-1)) {
      if (data[startY+i] && data[startY+i][startX+o]) {
      values.push(data[startY+i][startX+o]);
      }
      } else {
      continue;
      }
      }
      }
      }
      if (values.length > 0) {
      return Math.max.apply(Math, values);
      }
      }
      return false;
      }*/

  };
  return Store;
}();

var Canvas2dRenderer = function Canvas2dRendererClosure() {
  var _getColorPalette = function (config) {
    var gradientConfig = config.gradient || config.defaultGradient;
    var paletteCanvas = (0, _EnvUtils.createCanvas)(); // ie8及以下不支持getContext、getImageData,但是现在的createCanvas初始化生成了getContext方法导致进入if语句中报错

    if (paletteCanvas.getContext && !_Browser["default"].ielt9) {
      var paletteCtx = paletteCanvas.getContext('2d');
      paletteCanvas.width = 256;
      paletteCanvas.height = 1;
      var gradient = paletteCtx.createLinearGradient(0, 0, 256, 1);

      for (var key in gradientConfig) {
        gradient.addColorStop(key, gradientConfig[key]);
      }

      paletteCtx.fillStyle = gradient;
      paletteCtx.fillRect(0, 0, 256, 1);
      return paletteCtx.getImageData(0, 0, 256, 1).data;
    }

    return {};
  };

  var _getPointTemplate = function (radius, blurFactor) {
    var tplCanvas = (0, _EnvUtils.createCanvas)();
    var tplCtx = tplCanvas.getContext('2d');
    var x = radius;
    var y = radius;
    tplCanvas.width = tplCanvas.height = radius * 2;

    if (blurFactor === 1) {
      tplCtx.beginPath();
      tplCtx.arc(x, y, radius, 0, 2 * Math.PI, false);
      tplCtx.fillStyle = 'rgba(0,0,0,1)';
      tplCtx.fill();
    } else {
      var gradient = tplCtx.createRadialGradient(x, y, radius * blurFactor, x, y, radius);
      gradient.addColorStop(0, 'rgba(0,0,0,1)');
      gradient.addColorStop(1, 'rgba(0,0,0,0)');
      tplCtx.fillStyle = gradient;
      tplCtx.fillRect(0, 0, 2 * radius, 2 * radius);
    }

    return tplCanvas;
  };

  var _prepareData = function (data) {
    var renderData = [];
    var min = data.min;
    var max = data.max;
    var radi = data.radi;
    var data = data.data;
    var xValues = Object.keys(data);
    var xValuesLen = xValues.length;

    while (xValuesLen--) {
      var xValue = xValues[xValuesLen];
      var yValues = Object.keys(data[xValue]);
      var yValuesLen = yValues.length;

      while (yValuesLen--) {
        var yValue = yValues[yValuesLen];
        var value = data[xValue][yValue];
        var radius = radi[xValue][yValue];
        renderData.push({
          x: xValue,
          y: yValue,
          value: value,
          radius: radius
        });
      }
    }

    return {
      min: min,
      max: max,
      data: renderData
    };
  };

  function Canvas2dRenderer(config) {
    var container = config.container;
    var shadowCanvas = this.shadowCanvas = (0, _EnvUtils.createCanvas)();
    var canvas = this.canvas = config.canvas || (0, _EnvUtils.createCanvas)(); //excanvas

    window.VanCanvasManager && VanCanvasManager.initElement(canvas);
    window.VanCanvasManager && VanCanvasManager.initElement(shadowCanvas);
    var renderBoundaries = this._renderBoundaries = [10000, 10000, 0, 0];
    var computed = {};

    if (config.container) {
      computed = config.container.currentStyle || getComputedStyle(config.container) || {};
      canvas.className = 'heatmap-canvas';
    }

    this._width = canvas.width = shadowCanvas.width = config.width || +computed.width.replace(/px/, '');
    this._height = canvas.height = shadowCanvas.height = config.height || +computed.height.replace(/px/, '');
    this.shadowCtx = shadowCanvas.getContext('2d');
    this.ctx = canvas.getContext('2d'); // @TODO:
    // conditional wrapper

    if (config.container) {
      canvas.style.cssText = shadowCanvas.style.cssText = 'position:absolute;left:0;top:0;';
      container.style.position = 'relative';
      container.appendChild(canvas);
    }

    this._palette = _getColorPalette(config);
    this._templates = {};

    this._setStyles(config);
  }

  ;
  Canvas2dRenderer.prototype = {
    renderPartial: function (data) {
      if (data.data.length > 0) {
        if (this.ctx.getImageData) {
          this._drawAlpha(data);

          this._colorize();
        } else {
          this._drawPoints(data);
        }
      }
    },
    renderAll: function (data) {
      // reset render boundaries
      this._clear();

      if (data.data.length > 0) {
        var data = _prepareData(data);

        if (this.ctx.getImageData) {
          this._drawAlpha(data);

          this._colorize();
        } else {
          this._drawPoints(data);
        }
      }
    },
    _drawPoints: function (data) {
      var min = this._min = data.min,
          max = this._max = data.max;
      var data = data.data || [],
          dataLen = data.length;
      var blur = 1 - this._blur,
          ctx = this.ctx;

      while (dataLen--) {
        var point = data[dataLen],
            radius = +point.radius;
        var value = Math.min(point.value, max);
        var x = +point.x,
            y = +point.y;
        var templateAlpha = (value - min) / (max - min);
        templateAlpha = isNaN(templateAlpha) ? 1 : templateAlpha;
        ctx.globalAlpha = templateAlpha < .01 ? .01 : templateAlpha;
        var gradient = ctx.createRadialGradient(x, y, radius * blur, x, y, radius);
        var gradientConfig = this._gradientConfig;

        for (var key in gradientConfig) {
          gradient.addColorStop(+key, gradientConfig[key]);
        }

        ctx.fillStyle = gradient;
        ctx.beginPath();
        ctx.moveTo(x, y);
        ctx.arc(x, y, radius, 0, Math.PI * 2, false);
        ctx.fill();
      }
    },
    _updateGradient: function (config) {
      this._palette = _getColorPalette(config);
    },
    updateConfig: function (config) {
      if (config['gradient']) {
        this._updateGradient(config);
      }

      this._setStyles(config);
    },
    setDimensions: function (width, height) {
      this._width = width;
      this._height = height;
      this.canvas.width = this.shadowCanvas.width = width;
      this.canvas.height = this.shadowCanvas.height = height;
    },
    _clear: function () {
      this.shadowCtx.clearRect(0, 0, this._width, this._height);
      this.ctx.clearRect(0, 0, this._width, this._height);
    },
    _setStyles: function (config) {
      this._blur = config.blur === 0 ? 0 : config.blur || config.defaultBlur;
      this._gradientConfig = config.gradient || config.defaultGradient;

      if (config.backgroundColor) {
        this.canvas.style.backgroundColor = config.backgroundColor;
      }

      this._width = this.canvas.width = this.shadowCanvas.width = config.width || this._width;
      this._height = this.canvas.height = this.shadowCanvas.height = config.height || this._height;
      this._opacity = (config.opacity || 0) * 255;
      this._maxOpacity = (config.maxOpacity || config.defaultMaxOpacity) * 255;
      this._minOpacity = (config.minOpacity || config.defaultMinOpacity) * 255;
      this._useGradientOpacity = !!config.useGradientOpacity;
    },
    _drawAlpha: function (data) {
      var min = this._min = data.min;
      var max = this._max = data.max;
      var data = data.data || [];
      var dataLen = data.length; // on a point basis?

      var blur = 1 - this._blur;

      while (dataLen--) {
        var point = data[dataLen];
        var x = point.x;
        var y = point.y;
        var radius = point.radius; // if value is bigger than max
        // use max as value

        var value = Math.min(point.value, max);
        var rectX = x - radius;
        var rectY = y - radius;
        var shadowCtx = this.shadowCtx;
        var tpl;

        if (!this._templates[radius]) {
          this._templates[radius] = tpl = _getPointTemplate(radius, blur);
        } else {
          tpl = this._templates[radius];
        } // value from minimum / value range
        // => [0, 1]


        var templateAlpha = (value - min) / (max - min);
        templateAlpha = isNaN(templateAlpha) ? 1 : templateAlpha; // this fixes #176: small values are not visible because globalAlpha < .01 cannot be read from imageData

        shadowCtx.globalAlpha = templateAlpha < .01 ? .01 : templateAlpha;
        shadowCtx.drawImage(tpl, rectX, rectY); // update renderBoundaries

        if (rectX < this._renderBoundaries[0]) {
          this._renderBoundaries[0] = rectX;
        }

        if (rectY < this._renderBoundaries[1]) {
          this._renderBoundaries[1] = rectY;
        }

        if (rectX + 2 * radius > this._renderBoundaries[2]) {
          this._renderBoundaries[2] = rectX + 2 * radius;
        }

        if (rectY + 2 * radius > this._renderBoundaries[3]) {
          this._renderBoundaries[3] = rectY + 2 * radius;
        }
      }
    },
    _colorize: function () {
      var x = this._renderBoundaries[0];
      var y = this._renderBoundaries[1];
      var width = this._renderBoundaries[2] - x;
      var height = this._renderBoundaries[3] - y;
      var maxWidth = this._width;
      var maxHeight = this._height;
      var opacity = this._opacity;
      var maxOpacity = this._maxOpacity;
      var minOpacity = this._minOpacity;
      var useGradientOpacity = this._useGradientOpacity;

      if (x < 0) {
        x = 0;
      }

      if (y < 0) {
        y = 0;
      }

      if (x + width > maxWidth) {
        width = maxWidth - x;
      }

      if (y + height > maxHeight) {
        height = maxHeight - y;
      }

      var img = this.shadowCtx.getImageData(x, y, width, height);
      var imgData = img.data;
      var len = imgData.length;
      var palette = this._palette;

      for (var i = 3; i < len; i += 4) {
        var alpha = imgData[i];
        var offset = alpha * 4;

        if (!offset) {
          continue;
        }

        var finalAlpha;

        if (opacity > 0) {
          finalAlpha = opacity;
        } else {
          if (alpha < maxOpacity) {
            if (alpha < minOpacity) {
              finalAlpha = minOpacity;
            } else {
              finalAlpha = alpha;
            }
          } else {
            finalAlpha = maxOpacity;
          }
        }

        imgData[i - 3] = palette[offset];
        imgData[i - 2] = palette[offset + 1];
        imgData[i - 1] = palette[offset + 2];
        imgData[i] = useGradientOpacity ? palette[offset + 3] : finalAlpha;
      } //https://stackoverflow.com/questions/11098419/imagedata-data-assignment-in-strict-mode


      this.ctx.putImageData(img, x, y);
      this._renderBoundaries = [1000, 1000, 0, 0];
    },
    getValueAt: function (point) {
      var value;
      var shadowCtx = this.shadowCtx;
      var img = shadowCtx.getImageData(point.x, point.y, 1, 1);
      var data = img.data[3];
      var max = this._max;
      var min = this._min;
      value = Math.abs(max - min) * (data / 255) >> 0;
      return value;
    },
    getDataURL: function () {
      return this.canvas.toDataURL();
    }
  };
  return Canvas2dRenderer;
}();

var Renderer = function RendererClosure() {
  var rendererFn = false;

  if (HeatmapConfig['defaultRenderer'] === 'canvas2d') {
    rendererFn = Canvas2dRenderer;
  }

  return rendererFn;
}();

var Util = {
  merge: function () {
    var merged = {};
    var argsLen = arguments.length;

    for (var i = 0; i < argsLen; i++) {
      var obj = arguments[i];

      for (var key in obj) {
        merged[key] = obj[key];
      }
    }

    return merged;
  }
}; // Heatmap Constructor

var Heatmap = function HeatmapClosure() {
  var Coordinator = function CoordinatorClosure() {
    function Coordinator() {
      this.cStore = {};
    }

    ;
    Coordinator.prototype = {
      on: function (evtName, callback, scope) {
        var cStore = this.cStore;

        if (!cStore[evtName]) {
          cStore[evtName] = [];
        }

        cStore[evtName].push(function (data) {
          return callback.call(scope, data);
        });
      },
      emit: function (evtName, data) {
        var cStore = this.cStore;

        if (cStore[evtName]) {
          var len = cStore[evtName].length;

          for (var i = 0; i < len; i++) {
            var callback = cStore[evtName][i];
            callback(data);
          }
        }
      }
    };
    return Coordinator;
  }();

  var _connect = function (scope) {
    var renderer = scope._renderer;
    var coordinator = scope._coordinator;
    var store = scope._store;
    coordinator.on('renderpartial', renderer.renderPartial, renderer);
    coordinator.on('renderall', renderer.renderAll, renderer);
    coordinator.on('extremachange', function (data) {
      scope._config.onExtremaChange && scope._config.onExtremaChange({
        min: data.min,
        max: data.max,
        gradient: scope._config['gradient'] || scope._config['defaultGradient']
      });
    });
    store.setCoordinator(coordinator);
  };

  function Heatmap() {
    var config = this._config = Util.merge(HeatmapConfig, arguments[0] || {});
    this._coordinator = new Coordinator();

    if (config['plugin']) {
      var pluginToLoad = config['plugin'];

      if (!HeatmapConfig.plugins[pluginToLoad]) {
        throw new Error('Plugin \'' + pluginToLoad + '\' not found. Maybe it was not registered.');
      } else {
        var plugin = HeatmapConfig.plugins[pluginToLoad]; // set plugin renderer and store

        this._renderer = new plugin.renderer(config);
        this._store = new plugin.store(config);
      }
    } else {
      this._renderer = new Renderer(config);
      this._store = new Store(config);
    }

    _connect(this);
  }

  ; // @TODO:
  // add API documentation

  Heatmap.prototype = {
    addData: function () {
      this._store.addData.apply(this._store, arguments);

      return this;
    },
    removeData: function () {
      this._store.removeData && this._store.removeData.apply(this._store, arguments);
      return this;
    },
    setData: function () {
      this._store.setData.apply(this._store, arguments);

      return this;
    },
    setDataMax: function () {
      this._store.setDataMax.apply(this._store, arguments);

      return this;
    },
    setDataMin: function () {
      this._store.setDataMin.apply(this._store, arguments);

      return this;
    },
    configure: function (config) {
      this._config = Util.merge(this._config, config);

      this._renderer.updateConfig(this._config);

      this._coordinator.emit('renderall', this._store._getInternalData());

      return this;
    },
    repaint: function () {
      this._coordinator.emit('renderall', this._store._getInternalData());

      return this;
    },
    getData: function () {
      return this._store.getData();
    },
    getDataURL: function () {
      return this._renderer.getDataURL();
    },
    getValueAt: function (point) {
      if (this._store.getValueAt) {
        return this._store.getValueAt(point);
      } else if (this._renderer.getValueAt) {
        return this._renderer.getValueAt(point);
      } else {
        return null;
      }
    }
  };
  return Heatmap;
}();

var _default = {
  create: function (config) {
    return new Heatmap(config);
  },
  register: function (pluginKey, plugin) {
    HeatmapConfig.plugins[pluginKey] = plugin;
  }
};
exports["default"] = _default;

/***/ }),
/* 213 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Path = _interopRequireDefault(__webpack_require__(48));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

var _Bounds = _interopRequireDefault(__webpack_require__(21));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/4/10.
 */
var CircleMarker = _Path["default"].extend({
  initialize: function (latlng, options, radius) {
    _BaseUtils["default"].setOptions(this, options);

    this._latlng = _LatLng["default"].create(latlng);
    this._radius = radius;
    this._circle = _PathGenerator["default"].arc().startAngle(0).endAngle(2 * Math.PI).innerRadius(0);
  },
  // @method setLatLng(latLng: LatLng): this
  // Sets the position of a circle marker to a new location.
  setLatLng: function (latlng) {
    this._latlng = _LatLng["default"].create(latlng);
    this.redraw();
    return this.fire('move', {
      latlng: this._latlng
    });
  },
  // @method getLatLng(): LatLng
  // Returns the current geographical position of the circle marker
  getLatLng: function () {
    return this._latlng;
  },
  // @method setRadius(radius: Number): this
  // Sets the radius of a circle marker. Units are in pixels.
  setRadius: function (radius) {
    this._radius = radius;
    return this.redraw();
  },
  // @method getRadius(): Number
  // Returns the current radius of the circle
  getRadius: function () {
    return this._radius;
  },
  initAnimate: function (point) {
    this._animate(500, point.delayTime);
  },
  reShowAnimate: function () {
    this._animate(300);
  },
  _animate: function (duration, delayTime) {
    this._path.attr({
      'd': this._circle.outerRadius(0)()
    }).animate({
      delay: delayTime || 0,
      ease: 'bounce',
      duration: duration,
      attr: {
        'd': this._circle.outerRadius(this._radius)()
      }
    });
  },
  exitAnimate: function (vanchart, animate) {
    var layer = this,
        group = vanchart._pointLayer;
    animate == false ? group.removeLayer(layer) : this._path.animate({
      ease: 'back-in',
      duration: 300,
      attr: {
        'd': this._circle.outerRadius(0)()
      }
    }).remove().each('end', function () {
      group.removeLayer(layer);
    });
  },
  _onMouseState: function (isChosen, duration, ease, style) {
    var radius = this._radius + (isChosen ? 1 : 0);

    this._path.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      ease: ease,
      duration: duration,
      style: style,
      attr: {
        'd': this._circle.outerRadius(radius)()
      }
    });
  },
  _project: function () {
    this._point = this._map.latLngToLayerPoint(this._latlng);

    this._updateBounds();
  },
  _updateBounds: function () {
    var r = this._radius,
        r2 = this._radiusY || r,
        w = this._clickTolerance(),
        p = [r + w, r2 + w];

    this._pxBounds = new _Bounds["default"](this._point.subtract(p), this._point.add(p));
  },
  _update: function () {
    if (this._map) {
      this._updatePath();
    }
  },
  _updatePath: function () {
    this._path.attr({
      'd': this._circle.outerRadius(this._radius)(),
      'transform': _BaseUtils["default"].makeTranslate(this._point)
    });

    this.setStyle();
  },
  _empty: function () {
    return !this._renderer._bounds.intersects(this._pxBounds);
  },
  setAttr: function (radius) {
    if (radius !== this._radius) {
      this._radius = radius;

      this._update();
    }
  }
});

var _default = CircleMarker;
exports["default"] = _default;

/***/ }),
/* 214 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _Icon = _interopRequireDefault(__webpack_require__(95));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Transition = _interopRequireDefault(__webpack_require__(44));

var _Browser = _interopRequireDefault(__webpack_require__(8));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/7.
 */
var Marker = _Layer["default"].extend({
  // @section
  // @aka Marker options
  options: {
    // @option icon: Icon = *
    // Icon class to use for rendering the marker. See [Icon documentation](#L.Icon) for details on how to customize the marker icon. If not specified, a new `L.Icon.Default` is used.
    icon: new _Icon["default"].Default(),
    // Option inherited from "Interactive layer" abstract class
    interactive: true,
    // @option draggable: Boolean = false
    // Whether the marker is draggable with mouse/touch or not.
    draggable: false,
    // @option keyboard: Boolean = true
    // Whether the marker can be tabbed to with a keyboard and clicked by pressing enter.
    keyboard: true,
    // @option title: String = ''
    // Text for the browser tooltip that appear on marker hover (no tooltip by default).
    title: '',
    // @option alt: String = ''
    // Text for the `alt` attribute of the icon image (useful for accessibility).
    alt: '',
    // @option zIndexOffset: Number = 0
    // By default, marker images zIndex is set automatically based on its latitude. Use this option if you want to put the marker on top of all others (or below), specifying a high value like `1000` (or high negative value, respectively).
    zIndexOffset: 0,
    // @option opacity: Number = 1.0
    // The opacity of the marker.
    opacity: 1,
    // @option riseOnHover: Boolean = false
    // If `true`, the marker will get on top of others when you hover the mouse over it.
    riseOnHover: false,
    // @option riseOffset: Number = 250
    // The z-index offset used for the `riseOnHover` feature.
    riseOffset: 250,
    // @option pane: String = 'markerPane'
    // `Map pane` where the markers icon will be added.
    pane: 'markerPane',
    // FIXME: shadowPane is no longer a valid option
    nonBubblingEvents: ['click', 'dblclick', 'mouseover', 'mouseout', 'contextmenu']
  },

  /* @section
   *
   * In addition to [shared layer methods](#Layer) like `addTo()` and `remove()` and [popup methods](#Popup) like bindPopup() you can also use the following methods:
   */
  initialize: function (latlng, options) {
    _BaseUtils["default"].setOptions(this, options);

    this._latlng = _LatLng["default"].create(latlng);
  },
  onAdd: function (map) {
    this._zoomAnimated = this._zoomAnimated && map.options.markerZoomAnimation;

    if (this._zoomAnimated) {
      map.on('zoomanim', this._animateZoom, this);
    }

    this._initIcon();

    this.update();
  },
  onRemove: function (map) {
    if (this._zoomAnimated) {
      map.off('zoomanim', this._animateZoom, this);
    }

    this._removeIcon();
  },
  getEvents: function () {
    return {
      zoom: this.update,
      viewreset: this.update
    };
  },
  // @method getLatLng: LatLng
  // Returns the current geographical position of the marker.
  getLatLng: function () {
    return this._latlng;
  },
  // @method setLatLng(latlng: LatLng): this
  // Changes the marker position to the given point.
  setLatLng: function (latlng) {
    var oldLatLng = this._latlng;
    this._latlng = _LatLng["default"].create(latlng);
    this.update(); // @event move: Event
    // Fired when the marker is moved via [`setLatLng`](#marker-setlatlng) or by [dragging](#marker-dragging). Old and new coordinates are included in event arguments as `oldLatLng`, `latlng`.

    return this.fire('move', {
      oldLatLng: oldLatLng,
      latlng: this._latlng
    });
  },
  update: function () {
    if (this._icon) {
      var pos = this._map.latLngToLayerPoint(this._latlng).round();

      this._setPos(pos);
    }

    return this;
  },
  initAnimate: function (point) {
    var marker = this,
        icon = marker._icon,
        lastTranslate;

    function getTranslate() {
      var trans,
          leaflet_pos = icon._leaflet_pos;
      trans = marker._icon ? _BaseUtils["default"][_Browser["default"].ie3d ? "makeTranslate" : "makeTranslate3d"](leaflet_pos) : lastTranslate;
      lastTranslate = trans;
      return trans;
    }

    function tween() {
      return function (t) {
        return getTranslate() + 'scale(' + t + ')';
      };
    }

    var useFilterRender = point.series.vanchart.useFilterRender;

    if (_Browser["default"].any3d) {
      // 这边exit的已经移除了，所以useFilterRender的时候，也会initAnimate
      if (useFilterRender) {
        this._icon.style.transform = getTranslate() + 'scale(1)';
      } else {
        this._icon.style.transform = getTranslate() + 'scale(0.01)';
        this._icon.style["transform-origin"] = "bottom";
        new _Transition["default"](this._icon).delay(point.delayTime || 0).ease('back-out').duration(600).styleTween('transform', tween);
      }
    } else {
      _DomUtils["default"].setPosition(this._icon, icon._leaflet_pos);
    }
  },
  exitAnimate: function (vanchart) {
    var group = vanchart._pointLayer;
    group.removeLayer(this);
  },
  _onMouseState: function (isChosen) {
    var options = this.options.icon.options,
        height = options.iconSize[1],
        leaflet_pos = this._icon._leaflet_pos;
    var diffScale = 4 / height;

    var trans = _BaseUtils["default"][_Browser["default"].ie3d ? "makeTranslateWithPX" : "makeTranslate3d"](leaflet_pos);

    function tween() {
      return function (t) {
        var scale = isChosen ? 1 : 1 + diffScale;
        scale = isChosen ? scale + diffScale * t : scale - diffScale * t;
        return trans + 'scale(' + scale + ')';
      };
    }

    _Browser["default"].any3d ? new _Transition["default"](this._icon).ease(_BezierEasing["default"].custom["ease-out-back"]).duration(300).styleTween('transform', tween) : // 低版本IE修改position-left&top
    _DomUtils["default"].setPosition(this._icon, leaflet_pos);
  },
  _initIcon: function () {
    var options = this.options,
        classToAdd = 'leaflet-zoom-' + (this._zoomAnimated ? 'animated' : 'hide');
    var icon = options.icon.createIcon(this._icon),
        addIcon = false; // if we're not reusing the icon, remove the old one and init new one

    if (icon !== this._icon) {
      if (this._icon) {
        this._removeIcon();
      }

      addIcon = true;

      if (options.title) {
        icon.title = options.title;
      }

      if (options.alt) {
        icon.alt = options.alt;
      }
    }

    _DomUtils["default"].addClass(icon, classToAdd);

    if (options.keyboard) {
      icon.tabIndex = '0';
    }

    this._icon = icon;

    if (addIcon) {
      this.getPane().appendChild(this._icon);
    }
  },
  _removeIcon: function () {
    _DomUtils["default"].remove(this._icon);

    this._icon = null;
  },
  _setPos: function (pos) {
    _DomUtils["default"].setPosition(this._icon, pos);

    if (this._shadow) {
      _DomUtils["default"].setPosition(this._shadow, pos);
    }

    this._zIndex = pos.y + this.options.zIndexOffset;

    this._resetZIndex();
  },
  _updateZIndex: function (offset) {
    this._icon.style.zIndex = this._zIndex + offset;
  },
  _animateZoom: function (opt) {
    var pos = this._map._latLngToNewLayerPoint(this._latlng, opt.zoom, opt.center).round();

    this._setPos(pos);
  },
  _resetZIndex: function () {
    this._updateZIndex(0);
  },
  node: function () {
    return this._icon;
  },
  setStyle: function (options) {
    if (!this._icon || !options) {
      return;
    }

    options.symbol && (this._icon.src = options.symbol);
    this._icon.style.cursor = options.cursor || "";
  }
});

var _default = Marker;
exports["default"] = _default;

/***/ }),
/* 215 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Path = _interopRequireDefault(__webpack_require__(48));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/4/10.
 */
var ScatterMarker = _Path["default"].extend({
  initialize: function (latlng, options, marker) {
    _BaseUtils["default"].setOptions(this, options);

    this._latlng = _LatLng["default"].create(latlng);
    this._marker = marker;
  },
  setLatLng: function (latlng) {
    this._latlng = _LatLng["default"].create(latlng);
    this.redraw();
    return this.fire('move', {
      latlng: this._latlng
    });
  },
  // @method getLatLng(): LatLng
  // Returns the current geographical position of the circle marker
  getLatLng: function () {
    return this._latlng;
  },
  initAnimate: function (point) {
    this._animate(point.delayTime);
  },
  reShowAnimate: function () {
    this._animate();
  },
  _animate: function (delayTime) {
    var self = this,
        lastTranslate;

    function getTranslate() {
      var translate = self._point ? _BaseUtils["default"].makeTranslate(self._point) : lastTranslate;
      lastTranslate = translate;
      return translate;
    }

    function translateTween() {
      return function (t) {
        return getTranslate() + 'scale(' + t + ')';
      };
    }

    this._path.attr({
      'transform': _BaseUtils["default"].makeTranslate(this._point) + 'scale(0.01)'
    }).animate({
      delay: delayTime || 0,
      ease: 'back-out',
      duration: 300,
      attrTween: {
        "transform": translateTween
      }
    });
  },
  exitAnimate: function (vanchart, animate) {
    var layer = this,
        group = vanchart._pointLayer;
    animate == false ? group.removeLayer(layer) : this._path.animate({
      ease: 'back-in',
      duration: 300,
      attr: {
        'transform': _BaseUtils["default"].makeTranslate(this._point) + 'scale(0)'
      }
    }).remove().each('end', function () {
      group.removeLayer(layer);
    });
  },
  _onMouseState: function (isChosen, duration, ease, style) {
    var markerType = this._marker.symbol || "circle";
    var radius = this._marker.radius || _Constants["default"].MARKER_RADIUS;
    radius = radius + (isChosen ? 2 : 0);

    this._path.interrupt(_Constants["default"].SELECT_ANIMATION).transition(_Constants["default"].SELECT_ANIMATION).animate({
      duration: duration,
      ease: ease,
      style: style,
      attr: {
        'd': _PathGenerator["default"].getMarkerPath(markerType, radius)
      }
    });
  },
  _getMarkerPath: function () {
    var markerType = this._marker.symbol || "circle";
    var r = this._marker.radius || _Constants["default"].MARKER_RADIUS;
    return _PathGenerator["default"].getMarkerPath(markerType, r);
  },
  _project: function () {
    this._point = this._map.latLngToLayerPoint(this._latlng);
  },
  _update: function () {
    if (this._map) {
      this._updatePath();
    }
  },
  _updatePath: function () {
    this._path.attr({
      'd': this._getMarkerPath(),
      'transform': _BaseUtils["default"].makeTranslate(this._point)
    });
  },
  _empty: function () {
    return !this._renderer._bounds.intersects(this._pxBounds);
  },
  setAttr: function (marker) {
    if (!marker || !this._marker) {
      return;
    }

    if (marker.symbol !== this._marker.symbol || marker.radius !== this._marker.radius) {
      this._marker.symbol = marker.symbol;
      this._marker.radius = marker.radius;

      this._update();
    }
  }
});

var _default = ScatterMarker;
exports["default"] = _default;

/***/ }),
/* 216 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Evented = _interopRequireDefault(__webpack_require__(12));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/7.
 */
var PosAnimation = _Evented["default"].extend({
  // @method run(el: HTMLElement, newPos: Point, duration?: Number, easeLinearity?: Number)
  // Run an animation of a given element to a new position, optionally setting
  // duration in seconds (`0.25` by default) and easing linearity factor (3rd
  // argument of the [cubic bezier curve](http://cubic-bezier.com/#0,0,.5,1),
  // `0.5` by default).
  run: function (el, newPos, duration, easeLinearity) {
    this.stop();
    this._el = el;
    this._inProgress = true;
    this._duration = duration || 0.25;
    this._easeOutPower = 1 / Math.max(easeLinearity || 0.5, 0.2);
    this._startPos = _DomUtils["default"].getPosition(el);
    this._offset = newPos.subtract(this._startPos);
    this._startTime = +new Date(); // @event start: Event
    // Fired when the animation starts

    this.fire('start');

    this._animate();
  },
  // @method stop()
  // Stops the animation (if currently running).
  stop: function () {
    if (!this._inProgress) {
      return;
    }

    this._step(true);

    this._complete();
  },
  _animate: function () {
    // animation loop
    this._animId = _BaseUtils["default"].requestAnimFrame(this._animate, this);

    this._step();
  },
  _step: function (round) {
    var elapsed = +new Date() - this._startTime,
        duration = this._duration * 1000;

    if (elapsed < duration) {
      this._runFrame(this._easeOut(elapsed / duration), round);
    } else {
      this._runFrame(1);

      this._complete();
    }
  },
  _runFrame: function (progress, round) {
    var pos = this._startPos.add(this._offset.multiplyBy(progress));

    if (round) {
      pos._round();
    }

    _DomUtils["default"].setPosition(this._el, pos); // @event step: Event
    // Fired continuously during the animation.


    this.fire('step');
  },
  _complete: function () {
    _BaseUtils["default"].cancelAnimFrame(this._animId);

    this._inProgress = false; // @event end: Event
    // Fired when the animation ends.

    this.fire('end');
  },
  _easeOut: function (t) {
    return 1 - Math.pow(1 - t, this._easeOutPower);
  }
});

var _default = PosAnimation;
exports["default"] = _default;

/***/ }),
/* 217 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractManager = _interopRequireDefault(__webpack_require__(26));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/8/13.
 */
var STAGES = _Constants["default"].STAGES;

var _default = _AbstractManager["default"].extend({
  z: 12,
  name: 'map',
  contain: function () {
    return true;
  },
  onmultipointstart: function (e) {
    var touches = e.srcEvent.touches;

    if (touches.length !== 2) {
      return;
    }

    if (this.handler.stage === STAGES.NORMAL) {
      e.stop();
      this.handler.stage = STAGES.ZOOM;
      var p1 = this.handler.getTouchPos(touches[0]),
          p2 = this.handler.getTouchPos(touches[1]); // pos to plotBounds

      this._pinchStartCenter = p1.add(p2).divideBy(2).subtract(this.vanchart.bounds).round();
      this.vanchart.fire('pinchstart', e);
    }
  },
  onpinch: function (e) {
    if (this.handler.stage !== STAGES.ZOOM) {
      return;
    }

    e.scale = e.srcEvent.zoom;
    e.center = this._pinchStartCenter;
    this.vanchart.fire('pinchmove', e);
    e.stop();
  },
  onmultipointend: function () {
    if (this.handler.stage === STAGES.ZOOM) {
      this.handler.stage = STAGES.NORMAL;
    }
  },
  onpanstart: function (e) {
    if (this.handler.stage !== _Constants["default"].STAGES.NORMAL) {
      return;
    }

    this.vanchart.fire('panstart', e);
  },
  onpanmove: function (e) {
    if (this.handler.stage !== _Constants["default"].STAGES.NORMAL) {
      return;
    }

    this.deltaX += e.srcEvent.deltaX;
    this.deltaY += e.srcEvent.deltaY;
    this.vanchart.fire('panmove', e);
  },
  onpanend: function (e) {
    if (this.handler.stage !== _Constants["default"].STAGES.NORMAL) {
      return;
    }

    this.vanchart.fire('panend', e);
  }
});

exports["default"] = _default;

/***/ }),
/* 218 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = setMapOptions;

var _VanChartBaseMap = _interopRequireDefault(__webpack_require__(96));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _refreshGeoData(mapChart) {
  var options = mapChart.options;
  var geo = options.geo;

  if (!geo) {
    return;
  }

  var lastGeoData = mapChart.lastGeoData;

  if (geo.data !== lastGeoData) {
    // 刷新前后的json文件不一样，则把地图上已经画的全部清空。
    // 原因是，新的区域节点不能放在老的散点的上面
    mapChart.removeAllLayers();
  }

  mapChart.lastGeoData = geo.data;
}

function _refreshDrillDownSeries(mapChart) {
  if (mapChart.layerIndex === 0) {
    return;
  } // 钻取以后的刷新用最原始的数据


  if (mapChart.layerMap && mapChart.layerMap.length) {
    mapChart.series.forEach(function (ser) {
      ser.remove();
    });
    mapChart.components.geo.remove();
    mapChart.series = mapChart.layerMap[0].series;
    mapChart.components.geo = mapChart.layerMap[0].geo;
  }
}

function setMapOptions(mapChart, options) {
  _VanChartBaseMap["default"].prototype.setOptions.call(mapChart, options);

  if (false) {}

  _BaseUtils["default"].setDomBackground(mapChart.wrapDom, mapChart.options);

  _refreshGeoData(mapChart);

  _refreshDrillDownSeries(mapChart);
}

/***/ }),
/* 219 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = calculateMapSeries;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _VanChartLayout = _interopRequireDefault(__webpack_require__(52));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _calculatePointPercentage(vanchart) {
  var series = vanchart.series;
  series.forEach(function (ser) {
    var total = 0;
    var points = ser.points;
    points.forEach(function (point) {
      total = _BaseUtils["default"].accAdd(total, Math.abs(point.getTargetValue()));
    });
    points.forEach(function (point) {
      point.percentage = Math.abs(point.getTargetValue() / total);
    });
  });
}

function _createNameMap(vanchart) {
  var nameMap = {};
  var series = vanchart.series;
  series.forEach(function (ser) {
    var points = ser.points,
        type = ser.type;
    points.forEach(function (point) {
      var key = point.options.lnglat ? point.options.lnglat.join('-') : point.name;
      key = key + type;
      nameMap[key] = nameMap[key] || [];
      nameMap[key].push(point);
    });
  });
  return nameMap;
}

function _dealNameMapPoints(nameMap) {
  var _loop = function (name) {
    var allPoints = nameMap[name];
    var j = allPoints.length,
        drillDown = void 0,
        geo = void 0;

    while (--j > -1) {
      if (allPoints[j].options.drilldown) {
        drillDown = allPoints[j].options.drilldown;
        geo = allPoints[j].geo;
      }
    }

    allPoints.forEach(function (point) {
      if (point.series.type === _Constants["default"].LINE_MAP) {
        return;
      }

      point.points = allPoints; // points参数

      if (!point.options.drilldown) {
        // 设置drilldown
        point.options.drillDown = drillDown;
        point.geo = geo;
      }

      point.series.calculateLabelInfo(point);
    });
  };

  for (var name in nameMap) {
    _loop(name);
  }
}

function calculateMapSeries(vanchart) {
  vanchart.hoverPoint = null;
  vanchart.hoverSeries = null;

  _VanChartLayout["default"].calculateBubbleRadius(vanchart.seriesOfType(_Constants["default"].BUBBLE_CHART));

  _VanChartLayout["default"].calculateDelayTime(vanchart, vanchart.seriesOfType(_Constants["default"].BUBBLE_CHART), _Constants["default"].BUBBLE_CHART);

  _VanChartLayout["default"].calculateDelayTime(vanchart, vanchart.seriesOfType(_Constants["default"].SCATTER_CHART), _Constants["default"].SCATTER_CHART);

  _VanChartLayout["default"].calculateDelayTime(vanchart, vanchart.seriesOfType(_Constants["default"].POINT_MAP), _Constants["default"].BUBBLE_CHART);

  _calculatePointPercentage(vanchart);

  var nameMap = _createNameMap(vanchart);

  _dealNameMapPoints(nameMap);
}

/***/ }),
/* 220 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = renderAreaPointMap;

var _validMapPoints = __webpack_require__(28);

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _component = __webpack_require__(4);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function showPointGraphics(vanchart, point) {
  var series = point.series,
      name = point.name;
  var type = series.type;
  var options = point.series.getStyle(point);
  options.cursor = point.series._pointerStyle();
  var geo = vanchart.getCurrentGeo();
  var features = geo.getFeaturesByName(name, type);
  features = point.options.lnglat ? ['null'] : features;
  var animate = vanchart.renderer.isAnimation;

  if (point.layers && point.layers[0]._map) {
    var reshow = point.series.reShowPoint(point);
    point.layers.forEach(function (layer, index) {
      layer.setLatLng && layer.setLatLng(point.getLatLng(features[index]));
      layer.setStyle(options);
      vanchart.updatePointLayer(point, layer);
      reshow && animate && layer.initAnimate && layer.initAnimate(point);
      vanchart.registerInteractiveTarget(point, layer);
    });
  } else {
    point.layers = [];
    features.forEach(function (feature) {
      var layer;

      if (type == _Constants["default"].AREA_MAP) {
        layer = geo.getLayerByFeature(feature);
        layer.setStyle(options);
      } else {
        layer = vanchart.createPointLayer(feature, point, options);
      }

      point.layers.push(layer);
      animate && layer.initAnimate && layer.initAnimate(point);
      vanchart.registerInteractiveTarget(point, layer);
    });
  }
}

function renderAreaPointMapWithRangeLegend(vanchart) {
  var largeSeries = vanchart.largeSeries;
  var points = (0, _validMapPoints.areaPointMapPointsWithRangeLegend)(vanchart);

  for (var i = 0; i < points.length; i++) {
    var point = points[i];
    var series = point.series;
    var options = series.options,
        type = series.type; // large mode

    if (options.large && largeSeries[type]) {
      continue;
    } // normal mode


    if (point.visible) {
      showPointGraphics(vanchart, point);
    } else {
      vanchart.removePointGraphics(point, type);
    }
  }
}

function renderAreaPointMapWithNormalLegend(vanchart) {
  var largeSeries = vanchart.largeSeries;
  var showPoints = (0, _validMapPoints.areaPointMapPointsWithNormalLegend)(vanchart);
  var unShowPoints = [];
  vanchart.series.filter(function (ser) {
    return ser.type !== _Constants["default"].LINE_MAP;
  }).forEach(function (ser) {
    ser.points.forEach(function (point) {
      if (!_BaseUtils["default"].includes(showPoints, point)) {
        unShowPoints.push(point);
      }
    });
  });
  unShowPoints.forEach(function (point) {
    vanchart.removePointGraphics(point, point.series.type);
  });

  for (var i = 0; i < showPoints.length; i++) {
    var point = showPoints[i];
    var series = point.series;
    var options = series.options,
        type = series.type; // large mode

    if (options.large && largeSeries[type]) {
      continue;
    }

    showPointGraphics(vanchart, point);
  }
}

function renderAreaPointMap(vanchart) {
  var isRangeLegend = vanchart.getComponent(_component.ComponentCst.RANGE_LEGEND_COMPONENT);
  isRangeLegend ? renderAreaPointMapWithRangeLegend(vanchart) : renderAreaPointMapWithNormalLegend(vanchart);
}

/***/ }),
/* 221 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = updateMapNormaLabelLayers;

var _TextLayer = _interopRequireDefault(__webpack_require__(222));

var _LayerGroup = _interopRequireDefault(__webpack_require__(49));

var _component = __webpack_require__(4);

var _validMapPoints = __webpack_require__(28);

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function isValidDataLabels(point) {
  return point.options.dataLabels && point.options.dataLabels.enabled && point.labelPos;
}

function createNormalLabel(vanchart, point) {
  var type = point.series.type;
  var geo = vanchart.getCurrentGeo();
  var features = geo.getFeaturesByName(point.name, type);
  features = point.options.lnglat ? ['null'] : features;
  vanchart._textGroup = vanchart._textGroup || new _LayerGroup["default"]().addTo(vanchart);

  if (isValidDataLabels(point) && point.labelContent && features) {
    features.forEach(function (feature, index) {
      if (point.labelPos[index]) {
        point.textLayers = point.textLayers || [];

        if (point.textLayers[index]) {
          point.textLayers[index].setStyle(point.getLatLng(feature));
        } else {
          point.textLayers[index] = new _TextLayer["default"](point.getLatLng(feature), point).addTo(vanchart._textGroup);
        }
      }
    });
  }
}

function removeNormalLabels(vanchart, point) {
  var textG = vanchart._textGroup;

  if (point.textLayers) {
    point.textLayers.forEach(function (layer) {
      textG.removeLayer(layer);
    });
    point.textLayers = null;
  }
}

function updateNormalLabelWithRangeLegend(vanchart) {
  var points = (0, _validMapPoints.areaPointMapPointsWithRangeLegend)(vanchart).concat(vanchart._getHeatMapPoints());
  points.forEach(function (point) {
    if (point.visible && isValidDataLabels(point)) {
      createNormalLabel(vanchart, point);
    } else {
      removeNormalLabels(vanchart, point);
    }
  });
}

function updateNormalLabelWithNormalLegend(vanchart) {
  var showHeatMapPoints = vanchart._getHeatMapPoints().filter(function (point) {
    return point.series.visible;
  });

  var showPoints = (0, _validMapPoints.areaPointMapPointsWithNormalLegend)(vanchart).concat(showHeatMapPoints);
  var unShowPoints = [];
  vanchart.series.filter(function (ser) {
    return ser.type !== _Constants["default"].LINE_MAP;
  }).forEach(function (ser) {
    ser.points.forEach(function (point) {
      if (!_BaseUtils["default"].includes(showPoints, point) || !isValidDataLabels(point)) {
        unShowPoints.push(point);
      }
    });
  });
  unShowPoints.forEach(function (point) {
    removeNormalLabels(vanchart, point);
  });
  showPoints.forEach(function (point) {
    createNormalLabel(vanchart, point);
  });
}

function updateMapNormaLabelLayers(vanchart) {
  var isNormalLegend = vanchart.getComponent(_component.ComponentCst.LEGEND_COMPONENT);
  return isNormalLegend ? updateNormalLabelWithNormalLegend(vanchart) : updateNormalLabelWithRangeLegend(vanchart);
}

/***/ }),
/* 222 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Layer = _interopRequireDefault(__webpack_require__(20));

var _LatLng = _interopRequireDefault(__webpack_require__(19));

var _ColorUtils = _interopRequireDefault(__webpack_require__(5));

var _DomUtils = _interopRequireDefault(__webpack_require__(6));

var _Transition = _interopRequireDefault(__webpack_require__(44));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _richTextMount = __webpack_require__(54);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/4/10.
 */
var FONTSIZE_EXPAND = 1.1;
var ITALIC_DIM_EXPAND = 1.1;

var TextLayer = _Layer["default"].extend({
  initialize: function (latlng, dataPoint) {
    this._latlng = _LatLng["default"].create(latlng);
    this._dataPoint = dataPoint;
  },
  setStyle: function (latlng) {
    this._latlng = latlng;
    this.onRemove();
    this.onAdd();
  },
  beforeAdd: function (map) {
    this._renderer = map.getMapRenderer(this);
  },
  _fontSizeState: function (isChosen, duration, ease) {
    if (this._text && this._text.texts) {
      var scale = 0;

      this._text.texts.forEach(function (text) {
        var size = parseFloat(text.labelStyle['fontSize']);
        scale = size * 0.1;
        size = isChosen ? size * FONTSIZE_EXPAND : size;
        new _Transition["default"](text).ease(ease).duration(duration).style({
          'font-size': size + 'px'
        });
      });

      if (scale) {
        var top = this._point.y - (isChosen ? scale : 0);
        var left = this._point.x - (isChosen ? scale : 0);
        new _Transition["default"](this._text).ease(ease).duration(duration).style({
          top: top + 'px',
          left: left + 'px'
        });
      }
    }
  },
  _transformState: function (isChosen) {
    var top = this._point.y - (isChosen ? 2 : 0);
    new _Transition["default"](this._text).ease(_BezierEasing["default"].custom["ease-out-back"]).duration(300).style({
      top: top + 'px'
    });
  },
  _isLimitLabelWidthHeight: function (point) {
    var options = point.options;
    var dataLabels = options.dataLabels;
    return dataLabels && dataLabels.useHtml && (dataLabels.labelWidth || dataLabels.labelHeight);
  },
  onAdd: function () {
    //地图上的标签都用html显示
    this._text = document.createElement('div');
    this._text.style.position = 'absolute';
    this._text.style.zIndex = 1001;
    this._text.style['pointer-events'] = 'none';
    this.getPane().appendChild(this._text);
    var dataPoint = this._dataPoint,
        labelContent = dataPoint.labelContent,
        marker = dataPoint.options.marker,
        chartType = dataPoint.series.type;
    var vanchart = dataPoint.series.vanchart;
    var leftTop = vanchart.getLabelLeftTop(dataPoint);
    var startY = leftTop.top;

    if (dataPoint.options && dataPoint.options.dataLabels && dataPoint.options.dataLabels.useRichText) {
      var verticalPadding = (startY + dataPoint.labelDim.height / 2) * 2;
      var textWrapper = (0, _richTextMount.createDivRichTextWrapper)(dataPoint, labelContent, 0, [0, verticalPadding]);
      this._text.innerHTML = textWrapper.node().innerHTML;

      this._reset();

      return;
    }

    this._text.texts = [];

    for (var i = 0, count = labelContent.length; i < count; i++) {
      var label = labelContent[i];
      var labelDim = label.dim;
      var labelText = label.text;
      var labelStyle = label.style;
      var labelLeft = -labelDim.width / 2; // var expand = labelStyle["fontStyle"] === "italic" ? ITALIC_DIM_EXPAND * FONTSIZE_EXPAND : FONTSIZE_EXPAND;

      var div = document.createElement('div');
      div.innerHTML = labelText;
      div.style.zIndex = 1001;
      div.style.position = 'absolute';
      div.style.left = labelLeft + 'px';
      div.style.top = startY + 'px';
      div.style.textAlign = 'center'; // @CHART-4093 & CHART-9139
      // 最开始只有一个overflow: hidden, 没有设置width
      // 后来因为斜体的默认浏览器宽度计算问题导致显示不全, 加的 width + italicExpand
      // 但是chrome下面又会存在最小字体限制, 当浏览器缩放时, 小于最小字体的仍旧会按照最小字体显示, 这就导致了溢出被裁剪
      // 对于最小字体限制我们似乎一直都没有处理, 依稀记得以前是让客户改浏览器字体设置去规避这个问题
      // 尝试一下改了最小字体, 测试了一下, 居然有bug, 调整了最小字体在浏览器缩放下依然显示的是固定的尺寸
      // 这里把overflow: hidden 和width都去掉了, 最开始写的时候, 也没加width, 默认应该就是全部显示的
      // div.style.overflow = 'hidden';

      div.style.whiteSpace = 'nowrap'; // div.style.width = labelDim.width * expand + 'px';

      if (this._isLimitLabelWidthHeight(dataPoint)) {
        div.style.overflow = 'hidden';
        div.style.width = labelDim.width + 'px';
        div.style.height = labelDim.height + 'px';
        div.style.lineHeight = labelDim.height + 'px';
      }

      for (var fontStyle in labelStyle) {
        //ie789的color属性只能是16进制的值
        if (fontStyle == 'color' && labelStyle.color != 'inherit') {
          div.style.color = _ColorUtils["default"].colorToHex(labelStyle.color);
        } else {
          div.style[fontStyle] = labelStyle[fontStyle];
        }
      }

      div.labelStyle = labelStyle;

      this._text.appendChild(div);

      this._text.texts.push(div);

      startY += labelDim.height + 2;
    }

    this._reset();
  },
  onRemove: function () {
    _DomUtils["default"].remove(this._text);
  },
  getEvents: function () {
    return {
      zoomend: this._project,
      moveend: this._update,
      viewreset: this._reset
    };
  },
  _reset: function () {
    // defined in children classes
    this._project();

    this._update();
  },
  _project: function () {
    this._point = this._map.latLngToLayerPoint(this._latlng);
  },
  _update: function () {
    if (this._map) {
      this._text.style.left = this._point.x + 'px';
      this._text.style.top = this._point.y + 'px';
    }
  }
});

var _default = TextLayer;
exports["default"] = _default;

/***/ }),
/* 223 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _VanChart = _interopRequireDefault(__webpack_require__(33));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _ForceLayout = _interopRequireDefault(__webpack_require__(97));

var _quadtree = _interopRequireDefault(__webpack_require__(98));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 16/8/29.
 */
var padding = 2,
    clusterPadding = 4;
var BUBBLE_UPDATE_TIME = 500;

var VanChartForceBubble = _VanChart["default"].extend({
  vanChartType: 'vanChartForceBubble',
  renderSeries: function () {
    _VanChart["default"].prototype.renderSeries.call(this);

    var vanchart = this,
        plotBounds = vanchart.bounds;
    var nodes = this.nodes = [];
    this.maxRadius = 0;
    var isAnimation = vanchart.renderer.isAnimation;
    vanchart.force && vanchart.force.stop();
    vanchart.force = vanchart.force || (0, _ForceLayout["default"])();
    this.series.forEach(function (ser) {
      var cluster;
      ser.points.forEach(function (point) {
        if (point.isVisible()) {
          point.x = point._posX;
          point.y = point._posY;

          if (isAnimation) {
            vanchart.force.registerDragTarget(point, point.graphic);
          }

          nodes.push(point);
          vanchart.maxRadius = Math.max(vanchart.maxRadius, point.radius);
          cluster = cluster || point;
          cluster = point.radius > cluster.radius ? point : cluster;
        }
      });
      ser.cluster = cluster;
    });
    vanchart.force.nodes(nodes).size([plotBounds.width, plotBounds.height]).gravity(0.05).charge(0).eachTick(eachTick);
    (0, _EnvUtils.isSupportSVG)() ? isAnimation ? vanchart.force.start() : vanchart.force.simulateForce() : vanchart.force.endTick(_simpleSimulateEnd).simpleSimulateForce();

    function eachTick(e) {
      if (vanchart._animationStarted && e.alpha < 0.05) {
        _VanChart["default"].prototype._animationEnd.bind(vanchart)();
      }

      var clusterFuc = cluster(10 * e.alpha * e.alpha);
      var collideFuc = collide(0.5, nodes, vanchart.maxRadius);
      nodes.forEach(function (point) {
        clusterFuc(point);
      });
      nodes.forEach(function (point) {
        collideFuc(point);
      });

      vanchart._updateGraphics();
    }

    function _simpleSimulateEnd() {
      vanchart._updateGraphics();

      _VanChart["default"].prototype._animationEnd.bind(vanchart)();
    }
  },
  _updateGraphics: function () {
    var vanchart = this;
    vanchart.nodes && vanchart.nodes.forEach(function (point) {
      var pointAnimationAttr = point.series.getPointUpdateAnimationAttr(point);
      point._posX = point.x;
      point._posY = point.y;

      vanchart._calculateLabelPos(point); // CHART-15784 之前没有检测是否是正常的点
      //这边不能create。因为自动刷新init渲染过程中不能有标签


      if (point.textGraphic && point.hasValidDataLabel()) {
        var isChosen = point._isChosen,
            trans = point.series._labelTrans(point);

        point.textGraphic && point.textGraphic.interrupt(_Constants["default"].SELECT_ANIMATION).attr('transform', 'translate(' + trans.x + ',' + trans.y + ') scale(' + (isChosen ? 1.1 : 1) + ')');
      }

      point.graphic && point.graphic.attr(pointAnimationAttr);
      point.effectGraphic && point.effectGraphic.attr(pointAnimationAttr);
    });
  },
  _animationEnd: function () {},
  validPosXY: function (data, min, max) {
    data = +data;
    return data > min && data < max ? data : undefined;
  },
  dealAxisZoom: function (downPos, upPos) {
    var vanchart = this,
        plotBounds = vanchart.bounds;
    vanchart.force && vanchart.force.stop();

    var zoomParas = vanchart._calculateZoomParas(downPos, upPos),
        shiftX = zoomParas.shiftX,
        shiftY = zoomParas.shiftY,
        scale = zoomParas.scale;

    var _animationEnd = false;
    vanchart.nodes.forEach(function (node) {
      node.radius *= scale;
      var x = node.x + shiftX;
      var y = node.y + shiftY;
      x -= plotBounds.width / 2;
      y -= plotBounds.height / 2;
      node.x = x * scale + plotBounds.width / 2 - shiftX;
      node.y = y * scale + plotBounds.height / 2 - shiftY;

      vanchart._calculateLabelPos(node);

      vanchart._updatePointTextGraphic(node);

      var series = node.series,
          attrs = series.getPointUpdateAnimationAttr(node);
      node.graphic.animate({
        duration: BUBBLE_UPDATE_TIME,
        ease: 'back-out',
        attr: attrs
      }).each("end", function () {
        if (!_animationEnd) {
          _VanChart["default"].prototype._animationEnd.bind(vanchart)();
        }

        _animationEnd = true;
      });
    });
    this.scale = scale * _BaseUtils["default"].pick(this.scale, 1);
  },
  refreshRestore: function () {
    this.scale = 1;
    this.update();
  },
  _calculateLabelPos: function (node) {
    if (node.labelContent && node.labelDim) {
      var radius = node.radius;

      if (node.labelDim.width > 2 * radius || node.labelDim.height > 2 * radius) {
        node.labelPos = null;
      } else {
        node.labelPos = {
          x: -node.labelDim.width / 2 + node.x,
          y: -node.labelDim.height / 2 + node.y
        };
      }
    }
  },
  orderData: function () {},
  _updatePointTextGraphic: function (point) {
    if (point.textGraphic) {
      if (point.labelPos) {
        point.textGraphic.interrupt(_Constants["default"].SELECT_ANIMATION).attr('transform', _BaseUtils["default"].makeTranslate(point.series._labelTrans(point)));
      } else {
        point.textGraphic.remove();
        point.textGraphic = null;
      }
    } else {
      point.series._createTextGraphic(point);
    }
  }
}); // Move d to be adjacent to the cluster node.


function cluster(alpha) {
  return function (d) {
    var cluster = d.series.cluster;

    if (!cluster || cluster === d) {
      return;
    }

    var x = d.x - cluster.x,
        y = d.y - cluster.y,
        l = Math.sqrt(x * x + y * y),
        r = d.radius + cluster.radius;

    if (l != r) {
      l = (l - r) / l * alpha;
      d.x -= x *= l;
      d.y -= y *= l;
      cluster.x += x;
      cluster.y += y;
    }
  };
} // Resolves collisions between d and all other circles.


function collide(alpha, nodes, maxRadius) {
  var tree = (0, _quadtree["default"])(nodes);
  return function (d) {
    var r = d.radius + maxRadius + Math.max(padding, clusterPadding),
        nx1 = d.x - r,
        nx2 = d.x + r,
        ny1 = d.y - r,
        ny2 = d.y + r;
    tree.visit(function (quad, x1, y1, x2, y2) {
      if (quad.point && quad.point !== d) {
        var x = d.x - quad.point.x,
            y = d.y - quad.point.y,
            l = Math.sqrt(x * x + y * y),
            r = d.radius + quad.point.radius + (d.series.cluster === quad.point.series.cluster ? padding : clusterPadding);

        if (l < r) {
          l = (l - r) / l * alpha;
          d.x -= x *= l;
          d.y -= y *= l;
          quad.point.x += x;
          quad.point.y += y;
        }
      }

      return x1 > nx2 || x2 < nx1 || y1 > ny2 || y2 < ny1;
    });
  };
}

var _default = VanChartForceBubble;
exports["default"] = _default;

/***/ }),
/* 224 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _VanChart = _interopRequireDefault(__webpack_require__(33));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _CloudLayout = _interopRequireDefault(__webpack_require__(225));

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Mitisky on 16/11/30.
 */
var SHOW_TIME = 800; //所有词依次出现总时间

var VanChartWordCloud = _VanChart["default"].extend({
  vanChartType: 'vanChartWordCloud',
  dealAxisZoom: function (downPos, upPos) {
    var vanchart = this,
        series = vanchart.series;

    var zoomParas = vanchart._calculateZoomParas(downPos, upPos),
        shiftX = zoomParas.shiftX,
        shiftY = zoomParas.shiftY,
        scale = zoomParas.scale;

    series.forEach(function (ser) {
      ser.points.forEach(function (point) {
        if (point.word) {
          var x = point.word.x,
              y = point.word.y;
          point.word.x = (x + shiftX) * scale - shiftX;
          point.word.y = (y + shiftY) * scale - shiftY;
          point.word.size *= scale;

          ser._drawUpdatePoints(point);
        }
      });
    });
    this.scale = scale * _BaseUtils["default"].pick(this.scale, 1);
  },
  _getTranslate: function () {
    var plotBounds = this.bounds;
    return [plotBounds.x + plotBounds.width / 2, plotBounds.y + plotBounds.height / 2];
  },
  _animationStart: function () {
    this._animationStarted = true;
    this.animationCount = 0;
    this.removeMoreLabel();

    if (false) {}
  },
  renderSeries: function () {
    this.fire('animationStart');
    var vanchart = this,
        renderer = vanchart.renderer,
        plotOptions = vanchart.options.plotOptions;
    var bounds = vanchart.bounds,
        width = bounds.width,
        height = bounds.height;
    var minR = plotOptions.minRotation,
        maxR = plotOptions.maxRotation;
    var fontFamily = plotOptions.fontFamily,
        minFontSize = plotOptions.minFontSize,
        maxFontSize = plotOptions.maxFontSize;
    var allPoints = vanchart.pointsOfType(_Constants["default"].WORD_CLOUD_CHART).filter(function (p) {
      return !p.isNull;
    }).sort(function (pointA, pointB) {
      return Math.abs(pointB.value) - Math.abs(pointA.value);
    });

    if (allPoints.length === 0) {
      return;
    }

    minFontSize = (0, _CoreUtils.hasDefined)(minFontSize) ? minFontSize : 10;
    maxFontSize = (0, _CoreUtils.hasDefined)(maxFontSize) ? maxFontSize : vanchart._calculateNiceMaxFontSize(width, height, allPoints[0].name, fontFamily);
    vanchart.minFontSize = Math.min(parseFloat(minFontSize), parseFloat(maxFontSize));
    vanchart.maxFontSize = Math.max(parseFloat(minFontSize), parseFloat(maxFontSize));

    var sizeScale = _Scale["default"].linear().domain([Math.abs(allPoints[allPoints.length - 1].value), Math.abs(allPoints[0].value)]).range([vanchart.minFontSize, vanchart.maxFontSize]);

    var layout = (0, _CloudLayout["default"])().size([width, height]).words(allPoints.filter(function (p) {
      return p.visible;
    }).map(function (p) {
      var word = {
        text: p.name,
        size: sizeScale(Math.abs(p.value)) * vanchart.scale,
        point: p,
        fontFamily: fontFamily
      };
      p.word = word;
      return word;
    })).path(plotOptions.path).padding(5).rotate(function () {
      return minR + Math.random() * (maxR - minR);
    }).font(fontFamily).fontSize(function (p) {
      return p.size;
    }).renderFun(draw);
    layout.start();

    function draw(words) {
      if (!vanchart.group) {
        vanchart.group = renderer.group().addTo(vanchart.clipSeriesGroup);
      }

      vanchart.group.attr('transform', _BaseUtils["default"].makeTranslate(vanchart._getTranslate()));
      var series = vanchart.seriesOfType(_Constants["default"].WORD_CLOUD_CHART);

      if (series && series.length) {
        var ser = series[0];
        vanchart.registerInteractiveTarget(ser, vanchart.group);

        ser._removeDataLabels();

        var each = SHOW_TIME / parseFloat(words.length),
            delayTime = 0;
        allPoints.forEach(function (point) {
          var word = point.word;

          if (words.indexOf(word) != -1) {
            point.delayTime = delayTime;
            delayTime += each; //visible==false的时候没有word

            point.labelDim = _BaseUtils["default"].getTextDimension(word.text, {
              'fontSize': word.size + 'px',
              'fontFamily': word.fontFamily
            }, false);
          }

          ser.drawPoint(point);
        });
        vanchart.setTimeout('effect', function () {
          allPoints.forEach(function (point) {
            ser.drawPointEffect(point);
          });
        }, 800);
      }
    }
  },
  _calculateNiceMaxFontSize: function (width, height, text, fontFamily) {
    var range = {
      'min': 0,
      'max': 100
    },
        validInterval = function () {
      return range.max - range.min > 2;
    };

    var style = {
      'fontSize': range.max + 'px',
      'fontFamily': fontFamily
    };

    var maxDim = _BaseUtils["default"].getTextDimension(text, style, false);

    while (validInterval() && (maxDim.width > width || maxDim.height > height)) {
      var middle = Math.ceil(range.min + (range.max - range.min) / 2); //二分法

      style.fontSize = middle + 'px';

      var middleDim = _BaseUtils["default"].getTextDimension(text, style, false);

      if (middleDim.width > width || middleDim.height > height) {
        range.max = middle;
        maxDim = middleDim;
      } else {
        range.min = middle;
      }
    }

    return validInterval() ? range.max : range.min;
  }
});

var _default = VanChartWordCloud;
exports["default"] = _default;

/***/ }),
/* 225 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = _default;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by eason on 2017/2/20.
 */
var cloudRadians = Math.PI / 180,
    cw = 1 << 11 >> 5,
    ch = 1 << 11;

function _default() {
  var size = [256, 256],
      text = cloudText,
      font = cloudFont,
      fontSize = cloudFontSize,
      fontStyle = cloudFontNormal,
      fontWeight = cloudFontNormal,
      rotate = cloudRotate,
      padding = cloudPadding,
      spiral = archimedeanSpiral,
      path = null,
      simpleLayout = !(0, _EnvUtils.isSupportSVG)() && !false,
      renderFun = null,
      words = [],
      timeInterval = Infinity,
      timer = null,
      random = Math.random,
      cloud = {},
      canvas = _EnvUtils.createCanvas;

  cloud.canvas = function (_) {
    return arguments.length ? (canvas = functor(_), cloud) : canvas;
  };

  cloud.start = function () {
    var contextAndRatio = getContext(canvas()),
        board = imageShape() ? imageDataArray(contextAndRatio, stepInterval) : simpleLayout ? [] : zeroArray((size[0] >> 5) * size[1]),
        bounds = null,
        n = words.length,
        i = -1,
        tags = [],
        data = words.map(function (d, i) {
      d.text = text.call(this, d, i);
      d.font = font.call(this, d, i);
      d.style = fontStyle.call(this, d, i);
      d.weight = fontWeight.call(this, d, i);
      d.rotate = rotate.call(this, d, i);
      d.size = ~~fontSize.call(this, d, i);
      d.padding = padding.call(this, d, i);
      return d;
    }).sort(function (a, b) {
      return b.size - a.size;
    });

    if (!imageShape()) {
      stepInterval();
    }

    function stepInterval(temp) {
      if (simpleLayout) {
        simpleStep(temp);
      } else {
        if (timer) {
          _BaseUtils["default"].clearInterval(timer);
        }

        timer = _BaseUtils["default"].setInterval(step, 0);
        step(temp);
      }
    }

    return cloud;

    function step(temp) {
      board = temp ? temp : board;
      var start = Date.now();

      while (Date.now() - start < timeInterval && ++i < n && timer) {
        var oncePlace = function () {
          if (d.hasText && place(board, d, bounds)) {
            tags.push(d);

            if (bounds) {
              cloudBounds(bounds, d);
            } else {
              bounds = [{
                x: d.x + d.x0,
                y: d.y + d.y0
              }, {
                x: d.x + d.x1,
                y: d.y + d.y1
              }];
            } // Temporary hack


            d.x -= size[0] >> 1;
            d.y -= size[1] >> 1;
            return true;
          }

          return false;
        };

        var d = data[i];
        d.x = size[0] * (random() + .5) >> 1;
        d.y = size[1] * (random() + .5) >> 1;
        cloudSprite(contextAndRatio, d, data, i, simpleLayout);

        if (!oncePlace() && n < 100) {
          //数据量不大的时候，没找到放得下的地方再找一次
          oncePlace();
        }
      }

      if (i >= n) {
        cloud.stop();
        renderFun(tags);
      }
    } //ie8 simpleLayout


    function simpleStep(temp) {
      while (++i < n) {
        var d = data[i];
        d.x = size[0] * (random() + .5) >> 1;
        d.y = size[1] * (random() + .5) >> 1;

        var dim = _BaseUtils["default"].getTextDimension(d.text, {
          'fontSize': d.size + 'px',
          'fontFamily': d.fontFamily
        }, false);

        d.height = dim.height;
        d.y0 = -d.height >> 1;
        d.y1 = -d.y0;
        d.width = dim.width;
        d.x0 = -d.width >> 1;
        d.x1 = -d.x0;

        if (place(board, d, bounds)) {
          tags.push(d);

          if (bounds) {
            bounds.push({
              x: d.x,
              y: d.y,
              x0: d.x0,
              y0: d.y0,
              x1: d.x1,
              y1: d.y1
            });
          } else {
            bounds = [{
              x: d.x,
              y: d.y,
              x0: d.x0,
              y0: d.y0,
              x1: d.x1,
              y1: d.y1
            }];
          }

          d.x -= size[0] >> 1;
          d.y -= size[1] >> 1;
          d.x -= d.width >> 1;
          d.y -= d.height >> 1;
        }
      }

      if (i >= n) {
        cloud.stop();
        renderFun(tags);
      }
    }
  };

  cloud.stop = function () {
    if (timer) {
      _BaseUtils["default"].clearInterval(timer);

      timer = null;
    }

    return cloud;
  };

  function imageShape() {
    return path && !simpleLayout && !false;
  }

  function imageDataArray(contextAndRatio, complete) {
    var c = contextAndRatio.context,
        ratio = contextAndRatio.ratio;
    var width = (size[0] >> 5) / ratio,
        height = size[1] / ratio;
    c.clearRect(0, 0, width, height);
    var img = new Image();

    img.onload = function () {
      c.drawImage(img, 0, 0, width, height);
      var data = c.getImageData(0, 0, width, height).data;
      c.clearRect(0, 0, width, height);
      var len = data.length,
          board = [];

      for (var i = 0; i < len; i += 4) {
        board[i / 4] = data[i + 3] ? 0 : 1;
      }

      complete(board);
    }; //先给src会导致onload不会执行，比如图片缓存，或者是js由于某些原因被阻塞


    img.src = path;
  }

  function getContext(canvas) {
    canvas.width = canvas.height = 1;
    var context = canvas.getContext("2d");
    var ratio = simpleLayout ? 1 : Math.sqrt(context.getImageData(0, 0, 1, 1).data.length >> 2);
    canvas.width = (cw << 5) / ratio;
    canvas.height = ch / ratio;
    context.fillStyle = context.strokeStyle = "red";
    context.textAlign = "center";
    return {
      context: context,
      ratio: ratio
    };
  }

  function collideRectsArray(a, array) {
    var minx_a = a.x + a.x0,
        maxx_a = a.x + a.x1,
        miny_a = a.y + a.y0,
        maxy_a = a.y + a.y1;

    for (var i = 0, len = array.length; i < len; i++) {
      var b = array[i];
      var minx_b = b.x + b.x0,
          maxx_b = b.x + b.x1,
          miny_b = b.y + b.y0,
          maxy_b = b.y + b.y1;
      var minx = Math.max(minx_a, minx_b),
          maxx = Math.min(maxx_a, maxx_b),
          miny = Math.max(miny_a, miny_b),
          maxy = Math.min(maxy_a, maxy_b);

      if (minx < maxx && miny < maxy) {
        return true;
      }
    }

    return false;
  }

  function place(board, tag, bounds) {
    //绘图区没有空间，直接返回
    if (size[0] <= 0 || size[1] <= 0) {
      return true;
    }

    var startX = tag.x,
        startY = tag.y,
        maxDelta = Math.sqrt(size[0] * size[0] + size[1] * size[1]),
        s = spiral(size),
        dt = random() < .5 ? 1 : -1,
        t = -dt,
        dxdy,
        dx,
        dy;

    while (dxdy = s(t += dt)) {
      dx = ~~dxdy[0];
      dy = ~~dxdy[1];

      if (dx === 0 && dy === 0) {
        continue;
      }

      if (Math.min(Math.abs(dx), Math.abs(dy)) >= maxDelta) {
        break;
      }

      tag.x = startX + dx;
      tag.y = startY + dy;

      if (tag.x + tag.x0 < 0 || tag.y + tag.y0 < 0 || tag.x + tag.x1 > size[0] || tag.y + tag.y1 > size[1]) {
        continue;
      }

      if (simpleLayout) {
        if (!bounds || !collideRectsArray(tag, bounds)) {
          return true;
        }
      } // TODO only check for collisions within current bounds.
      //有图形的时候第一个词也要判断是否在里面cloudCollide
      else if (!bounds && !path || !cloudCollide(tag, board, size[0])) {
          if (!bounds || collideRects(tag, bounds)) {
            var sprite = tag.sprite,
                w = tag.width >> 5,
                sw = size[0] >> 5,
                lx = tag.x - (w << 4),
                sx = lx & 0x7f,
                msx = 32 - sx,
                h = tag.y1 - tag.y0,
                x = (tag.y + tag.y0) * sw + (lx >> 5),
                last;

            for (var j = 0; j < h; j++) {
              last = 0;

              for (var i = 0; i <= w; i++) {
                board[x + i] |= last << msx | (i < w ? (last = sprite[j * w + i]) >>> sx : 0);
              }

              x += sw;
            }

            delete tag.sprite;
            return true;
          }
        }
    }

    return false;
  }

  cloud.timeInterval = function (_) {
    return arguments.length ? (timeInterval = _ == null ? Infinity : _, cloud) : timeInterval;
  };

  cloud.words = function (_) {
    return arguments.length ? (words = _, cloud) : words;
  };

  cloud.path = function (_) {
    return arguments.length ? (path = _, cloud) : path;
  };

  cloud.renderFun = function (_) {
    return arguments.length ? (renderFun = _, cloud) : renderFun;
  };

  cloud.size = function (_) {
    return arguments.length ? (size = [+_[0], +_[1]], cloud) : size;
  };

  cloud.font = function (_) {
    return arguments.length ? (font = functor(_), cloud) : font;
  };

  cloud.fontStyle = function (_) {
    return arguments.length ? (fontStyle = functor(_), cloud) : fontStyle;
  };

  cloud.fontWeight = function (_) {
    return arguments.length ? (fontWeight = functor(_), cloud) : fontWeight;
  };

  cloud.rotate = function (_) {
    return arguments.length ? (rotate = functor(_), cloud) : rotate;
  };

  cloud.text = function (_) {
    return arguments.length ? (text = functor(_), cloud) : text;
  };

  cloud.spiral = function (_) {
    return arguments.length ? (spiral = spirals[_] || _, cloud) : spiral;
  };

  cloud.fontSize = function (_) {
    return arguments.length ? (fontSize = functor(_), cloud) : fontSize;
  };

  cloud.padding = function (_) {
    return arguments.length ? (padding = functor(_), cloud) : padding;
  };

  cloud.random = function (_) {
    return arguments.length ? (random = _, cloud) : random;
  };

  return cloud;
}

;

function cloudText(d) {
  return d.text;
}

function cloudFont() {
  return "serif";
}

function cloudFontNormal() {
  return "normal";
}

function cloudFontSize(d) {
  return Math.sqrt(d.value);
}

function cloudRotate() {
  return (~~(Math.random() * 6) - 3) * 30;
}

function cloudPadding() {
  return 1;
} // Fetches a monochrome sprite bitmap for the specified text.
// Load in batches for speed.


function cloudSprite(contextAndRatio, d, data, di, simpleLayout) {
  if (d.sprite) {
    return;
  }

  var c = contextAndRatio.context,
      ratio = contextAndRatio.ratio;
  c.clearRect(0, 0, (cw << 5) / ratio, ch / ratio);
  var x = 0,
      y = 0,
      maxh = 0,
      n = data.length;
  --di;

  while (++di < n) {
    d = data[di];
    c.save();
    c.font = d.style + " " + d.weight + " " + ~~((d.size + 1) / ratio) + "px \"" + d.font + "\"";
    var w = c.measureText(d.text + "m").width * ratio,
        h = d.size << 1;

    if (d.rotate) {
      var sr = Math.sin(d.rotate * cloudRadians),
          cr = Math.cos(d.rotate * cloudRadians),
          wcr = w * cr,
          wsr = w * sr,
          hcr = h * cr,
          hsr = h * sr;
      w = Math.max(Math.abs(wcr + hsr), Math.abs(wcr - hsr)) + 0x1f >> 5 << 5;
      h = ~~Math.max(Math.abs(wsr + hcr), Math.abs(wsr - hcr));
    } else {
      w = w + 0x1f >> 5 << 5;
    }

    if (h > maxh) {
      maxh = h;
    }

    if (x + w >= cw << 5) {
      x = 0;
      y += maxh;
      maxh = 0;
    }

    if (y + h >= ch && !simpleLayout) {
      break;
    }

    c.translate((x + (w >> 1)) / ratio, (y + (h >> 1)) / ratio);

    if (d.rotate) {
      c.rotate(d.rotate * cloudRadians);
    }

    c.fillText(d.text, 0, 0);

    if (d.padding && !simpleLayout) {
      c.lineWidth = 2 * d.padding, c.strokeText(d.text, 0, 0);
    }

    c.restore();
    d.width = w;
    d.height = h;
    d.xoff = x;
    d.yoff = y;
    d.x1 = w >> 1;
    d.y1 = h >> 1;
    d.x0 = -d.x1;
    d.y0 = -d.y1;
    d.hasText = true;
    x += w;
  }

  if (simpleLayout) {
    return;
  }

  var pixels = c.getImageData(0, 0, (cw << 5) / ratio, ch / ratio).data,
      sprite = [];

  while (--di >= 0) {
    d = data[di];

    if (!d.hasText) {
      continue;
    }

    var w = d.width,
        w32 = w >> 5,
        h = d.y1 - d.y0; // Zero the buffer

    for (var i = 0; i < h * w32; i++) {
      sprite[i] = 0;
    }

    x = d.xoff;

    if (x == null) {
      return;
    }

    y = d.yoff;
    var seen = 0,
        seenRow = -1;

    for (var j = 0; j < h; j++) {
      for (var i = 0; i < w; i++) {
        var k = w32 * j + (i >> 5),
            m = pixels[(y + j) * (cw << 5) + (x + i) << 2] ? 1 << 31 - i % 32 : 0;
        sprite[k] |= m;
        seen |= m;
      }

      if (seen) {
        seenRow = j;
      } else {
        d.y0++;
        h--;
        j--;
        y++;
      }
    }

    d.y1 = d.y0 + seenRow;
    d.sprite = sprite.slice(0, (d.y1 - d.y0) * w32);
  }
} // Use mask-based collision detection.


function cloudCollide(tag, board, sw) {
  sw >>= 5;
  var sprite = tag.sprite,
      w = tag.width >> 5,
      lx = tag.x - (w << 4),
      sx = lx & 0x7f,
      msx = 32 - sx,
      h = tag.y1 - tag.y0,
      x = (tag.y + tag.y0) * sw + (lx >> 5),
      last;

  for (var j = 0; j < h; j++) {
    last = 0;

    for (var i = 0; i <= w; i++) {
      if ((last << msx | (i < w ? (last = sprite[j * w + i]) >>> sx : 0)) & board[x + i]) {
        return true;
      }
    }

    x += sw;
  }

  return false;
}

function cloudBounds(bounds, d) {
  var b0 = bounds[0],
      b1 = bounds[1];

  if (d.x + d.x0 < b0.x) {
    b0.x = d.x + d.x0;
  }

  if (d.y + d.y0 < b0.y) {
    b0.y = d.y + d.y0;
  }

  if (d.x + d.x1 > b1.x) {
    b1.x = d.x + d.x1;
  }

  if (d.y + d.y1 > b1.y) {
    b1.y = d.y + d.y1;
  }
}

function collideRects(a, b) {
  return a.x + a.x1 > b[0].x && a.x + a.x0 < b[1].x && a.y + a.y1 > b[0].y && a.y + a.y0 < b[1].y;
}

function archimedeanSpiral(size) {
  var e = size[0] / size[1];
  return function (t) {
    return [e * (t *= .1) * Math.cos(t), t * Math.sin(t)];
  };
}

function rectangularSpiral(size) {
  var dy = 4,
      dx = dy * size[0] / size[1],
      x = 0,
      y = 0;
  return function (t) {
    var sign = t < 0 ? -1 : 1; // See triangular numbers: T_n = n * (n + 1) / 2.

    switch (Math.sqrt(1 + 4 * sign * t) - sign & 3) {
      case 0:
        x += dx;
        break;

      case 1:
        y += dy;
        break;

      case 2:
        x -= dx;
        break;

      default:
        y -= dy;
        break;
    }

    return [x, y];
  };
} // TODO reuse arrays?


function zeroArray(n) {
  var a = [],
      i = -1;

  while (++i < n) {
    a[i] = 0;
  }

  return a;
}

function functor(d) {
  return typeof d === "function" ? d : function () {
    return d;
  };
}

var spirals = {
  archimedean: archimedeanSpiral,
  rectangular: rectangularSpiral
};

/***/ }),
/* 226 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _VanChart = _interopRequireDefault(__webpack_require__(33));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _BezierEasing = _interopRequireDefault(__webpack_require__(7));

var _BoundsManager = _interopRequireDefault(__webpack_require__(25));

var _TreeMapLayout = __webpack_require__(81);

var _ForceLayout = _interopRequireDefault(__webpack_require__(97));

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _EventObject = _interopRequireDefault(__webpack_require__(83));

var _EnvUtils = __webpack_require__(2);

var _CoreUtils = __webpack_require__(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by shine on 2017/1/10.
 */
var LINK_TIME = 1200;
var NODE_TIME = 300;
var UPDATE_TIME = 500;
var LINK_EASE = _BezierEasing["default"].css['ease-in-quad'];
var NODE_EASE = _BezierEasing["default"].css['swing'];
var LABEL_GAP = 2;

function nodeRadius(node, maxLevel) {
  return node.radius = (0, _CoreUtils.hasDefined)(node.options.radius) ? node.options.radius : (9 + (maxLevel - node.level) * 3) / 2;
}

function forceDelayTimeArray(maxLevel) {
  if (maxLevel === 0) {
    return [0];
  }

  var array = [],
      level = 0,
      temp = 0,
      length = 2 - Math.pow(2, -(maxLevel - 1));

  while (level <= maxLevel) {
    array[level] = LINK_TIME * _BezierEasing["default"].calculateQuadInT(temp / length);
    temp += Math.pow(2, -level);
    level++;
  }

  return array;
}

function treeDelayTimeArray(maxLevel) {
  if (maxLevel === 0) {
    return [0];
  }

  var array = [],
      level = 0;

  while (level <= maxLevel) {
    array[level] = LINK_TIME * _BezierEasing["default"].calculateQuadInT(level / maxLevel);
    level++;
  }

  return array;
}

function strokeWidth(edge, maxLevel) {
  return maxLevel - edge.source.level;
}

var VanChartStructure = _VanChart["default"].extend({
  vanChartType: 'vanChartStructure',
  dealAxisZoom: function (downPos, upPos) {
    var vanchart = this,
        plotBounds = vanchart.bounds,
        isHorizontal = vanchart._horizontalLayout(),
        isRadial = vanchart._radialLayout();

    var zoomParas = vanchart._calculateZoomParas(downPos, upPos),
        shiftX = zoomParas.shiftX,
        shiftY = zoomParas.shiftY,
        scale = zoomParas.scale;

    if (vanchart.linkGroup && vanchart.linkGroup.clipG) {
      vanchart.linkGroup.clipG.remove();
      vanchart.linkGroup.clipG = null;
    }

    vanchart.nodes.forEach(function (node) {
      var x = node.posX + shiftX;
      var y = node.posY + shiftY;
      x -= plotBounds.width / 2;
      y -= plotBounds.height / 2;
      node.posX = x * scale + plotBounds.width / 2 - shiftX;
      node.posY = y * scale + plotBounds.height / 2 - shiftY;
      node.x = isHorizontal ? node.posY : node.posX;
      node.y = isHorizontal ? node.posX : node.posY;
      node.radius *= scale;
      node.labelPos = vanchart._labelPos(node);

      var nodeAttrs = vanchart._nodeAttrs(node),
          textAttrs = {
        transform: _BaseUtils["default"].makeTranslate(node.labelPos)
      },
          styleAttrs = {
        transform: _BaseUtils["default"].makeTranslateWithPX(node.labelPos)
      };

      var trans = 'translate(' + node.posX + ',' + node.posY + ')';
      node.graphic.animate({
        duration: UPDATE_TIME,
        attr: {
          'transform': trans
        }
      });
      node.graphic.nodeGraphic.animate({
        duration: UPDATE_TIME,
        attr: nodeAttrs
      });
      node.textGraphic && node.textGraphic.animate({
        duration: UPDATE_TIME,
        attr: textAttrs,
        style: styleAttrs
      });
    });
    vanchart.edges.forEach(function (edge) {
      var edgeAttrs = isRadial ? vanchart._forceLinkAttrs(edge) : {
        d: vanchart._treeLinkPath(edge)
      };
      edge.linkGraphic.animate({
        duration: UPDATE_TIME,
        attr: edgeAttrs
      });
    });

    if (vanchart._forceDragEnabled()) {
      vanchart.force.scale(scale);
    }

    this.scale = scale * _BaseUtils["default"].pick(this.scale, 1);
  },
  renderSeries: function () {
    this.fire('animationStart');
    var vanchart = this,
        renderer = vanchart.renderer,
        plotBounds = vanchart.bounds;
    var series = vanchart.seriesOfType(_Constants["default"].STRUCTURE_CHART);

    if (!(vanchart.nodes && series && series.length)) {
      return;
    }

    vanchart.layout = vanchart.options.plotOptions.layout;
    vanchart.animation = vanchart.options.plotOptions.animation;
    vanchart.lineWidth = vanchart.options.plotOptions.lineWidth;

    if ((0, _CoreUtils.hasNotDefined)(vanchart.lineWidth)) {
      vanchart.lineWidth = null;
    }

    if (!vanchart.linkGroup) {
      vanchart.linkGroup = renderer.group().addTo(vanchart.clipSeriesGroup);
      vanchart.nodeGroup = renderer.group().addTo(vanchart.clipSeriesGroup);
    }

    vanchart.linkGroup.attr('transform', _BaseUtils["default"].makeTranslate(plotBounds));
    vanchart.nodeGroup.attr('transform', _BaseUtils["default"].makeTranslate(plotBounds));
    vanchart.groupTrans = null;
    vanchart.registerInteractiveTarget(series[0], vanchart.linkGroup);

    if (vanchart._radialLayout()) {
      vanchart._forceRenderer();
    } else {
      vanchart._treeRenderer();
    }

    if (!this.animationCount) {
      this.fire('animationEnd');
    }
  },
  _animationStart: function () {
    //锁住fire的'animationEnd'
    this._animationStarted = true;
    this.animationCount = 0;
    this.removeMoreLabel();
    this.series.forEach(function (ser) {
      ser._removeDataLabels();
    });

    if (false) {}
  },
  _forceDragEnabled: function () {
    return this.animation && this._radialLayout() && this.options.plotOptions.force;
  },
  _treeDragEnabled: function () {
    return this.animation && !this._radialLayout() && this.options.plotOptions.force;
  },
  _verticalLayout: function () {
    return this.layout === 'vertical';
  },
  _horizontalLayout: function () {
    return this.layout === 'horizontal';
  },
  _radialLayout: function () {
    return this.layout === 'radial';
  },
  _validPosition: function (pos, minGap, maxGap, max) {
    return Math.min(max - maxGap, Math.max(pos, minGap));
  },
  _forceRenderer: function () {
    var vanchart = this,
        plotBounds = vanchart.bounds;
    var nodes = vanchart.nodes,
        edges = vanchart.edges,
        maxLevel = vanchart.maxLevel;
    var maxLength = Math.min(plotBounds.width, plotBounds.height) / 4;

    function linkDistance(edge) {
      return maxLength * Math.pow(2, -edge.source.level);
    }

    var centerX = plotBounds.width / 2,
        centerY = plotBounds.height / 2;

    function initTick() {
      tick(true);
    }

    function tick(init) {
      //forcelayout中每个tick调整点顺序：先考虑两点连线长度distance，然后是重力，之后是引力（斥力）。
      //这样就存在一个问题：如果斥力这个值较大，那么他对整个位置在力学上的影响就比较大，点多的时候必然导致distance和设置的不一样（因为根据斥力调整点位置是在距离之后）。
      //斥力不能设置太小原因：希望是发散型的，尽量少交叉重叠。
      //调整两处解决上述问题：1、根据引力调整点之后再根据distance调整一下。2、斥力由定值-150改成根据level确定，domain(0,maxlevel)range(0,-100)
      init && vanchart.force._distanceTick(); //init决定根是否在中心位置

      var diffX = init ? vanchart.ancestor.x - centerX : 0,
          diffY = init ? vanchart.ancestor.y - centerY : 0;
      nodes.forEach(function (node) {
        node.x -= diffX;
        node.y -= diffY;
        node.labelPos = vanchart._labelPos(node);
        nodeRadius(node, vanchart.maxLevel);
        var left = node.radius,
            right = node.radius,
            top = node.radius,
            bottom = node.radius;

        if (node.hasValidDataLabel()) {
          left = Math.max(left, node.x - node.labelPos.x);
          right = Math.max(right, node.labelPos.x + node.labelDim.width - node.x);
          top = Math.max(top, node.y - node.labelPos.y);
          bottom = Math.max(bottom, node.labelPos.y + node.labelDim.height - node.y);
        }

        node.x = vanchart._validPosition(node.x, left, right, plotBounds.width);
        node.y = vanchart._validPosition(node.y, top, bottom, plotBounds.height);
        node.labelPos = vanchart._labelPos(node);
        node.posX = node.x;
        node.posY = node.y;
        node.graphic && node.graphic.attr('transform', _BaseUtils["default"].makeTranslate(node));

        var labelTrans = node.series._labelTrans(node);

        node.textGraphic && node.textGraphic.attr('transform', _BaseUtils["default"].makeTranslate(labelTrans)).style('transform', _BaseUtils["default"].makeTranslateWithPX(labelTrans)); // CHART-1717:html标签兼容
      });
      edges.forEach(function (edge) {
        edge.linkGraphic && edge.linkGraphic.attr("x1", edge.source.x).attr("y1", edge.source.y).attr("x2", edge.target.x).attr("y2", edge.target.y);
      });
    }

    vanchart.force && vanchart.force.stop();
    vanchart.force = (0, _ForceLayout["default"])().nodes(nodes).links(edges).size([plotBounds.width, plotBounds.height]).linkDistance(linkDistance).gravity(0).charge(function charge(node) {
      return -100 * node.level / maxLevel;
    }).eachTick(initTick);
    vanchart.force.simulateForce();
    var delayTimeArray = forceDelayTimeArray(maxLevel);

    vanchart._rendererNodes(delayTimeArray);

    vanchart._renderLabels(delayTimeArray);

    vanchart._renderForceLink(delayTimeArray);

    vanchart.force.eachTick(dragTick);

    function dragTick() {
      tick(false);
    }
  },
  _renderForceLink: function (delayTimeArray) {
    var vanchart = this,
        renderer = vanchart.renderer;
    vanchart.edges.forEach(function (edge) {
      edge.linkGraphic && edge.linkGraphic.remove();
      edge.linkGraphic = null;

      var attrs = vanchart._forceLinkAttrs(edge);

      var plotOptions = vanchart.options.plotOptions,
          styles = {
        'fill': 'none',
        'stroke': plotOptions.lineColor,
        'stroke-opacity': plotOptions.lineOpacity,
        'stroke-width': vanchart.lineWidth == null ? strokeWidth(edge, vanchart.maxLevel) : vanchart.lineWidth
      };
      edge.linkGraphic = renderer.line(attrs).style(styles).addTo(vanchart.linkGroup);
      edge.linkGraphic.datum(edge);

      if (vanchart.animation) {
        var sourceDelay = delayTimeArray[edge.source.level],
            targetDelay = delayTimeArray[edge.target.level];
        var st = sourceDelay / LINK_TIME,
            tt = targetDelay / LINK_TIME,
            sx = LINK_EASE(st),
            tx = LINK_EASE(tt);

        var tScale = _Scale["default"].linear().domain([0, 1]).range([st, tt]),
            xScale = _Scale["default"].linear().domain([sx, tx]).range([0, 1]);

        edge.linkGraphic.attr('x2', attrs.x1).attr('y2', attrs.y1).animate({
          delay: sourceDelay,
          ease: 'linear',
          duration: targetDelay - sourceDelay,
          attrTween: {
            'x2': function () {
              return function (t) {
                return attrs.x1 + (attrs.x2 - attrs.x1) * xScale(LINK_EASE(tScale(t)));
              };
            },
            'y2': function () {
              return function (t) {
                return attrs.y1 + (attrs.y2 - attrs.y1) * xScale(LINK_EASE(tScale(t)));
              };
            }
          }
        });
      }
    });
  },
  _forceLinkAttrs: function (edge) {
    return {
      x1: edge.source.x,
      x2: edge.target.x,
      y1: edge.source.y,
      y2: edge.target.y
    };
  },
  _treeRenderer: function () {
    var vanchart = this,
        plotBounds = vanchart.bounds;
    var maxLevel = vanchart.maxLevel;
    var size = vanchart._verticalLayout() ? [plotBounds.width, plotBounds.height] : [plotBounds.height, plotBounds.width];
    var tree = (0, _TreeMapLayout.treeLayout)().size(size);
    var nodes = tree.nodes(vanchart.ancestor).reverse();

    vanchart._adjustTreeSize(tree, size, nodes, maxLevel);

    var delayTimeArray = treeDelayTimeArray(maxLevel);

    vanchart._rendererNodes(delayTimeArray);

    vanchart._renderLabels(delayTimeArray);

    vanchart._renderTreeLink();
  },
  //调整一下,不切断节点&显示全标签
  _adjustTreeSize: function (tree, size, nodes, maxLevel) {
    var vanchart = this,
        isVertical = vanchart._verticalLayout();

    var left = 0,
        right = size[0],
        top = 0,
        bottom = size[1];
    nodes.forEach(function (node) {
      var radius = nodeRadius(node, maxLevel);
      radius += node.options.borderWidth || 0;
      var dataLabels = node.options.dataLabels,
          labelDim = node.labelDim;

      if (dataLabels && dataLabels.enabled) {
        var width = labelDim.width,
            height = labelDim.height,
            out = dataLabels.align == _Constants["default"].OUTSIDE;

        if (isVertical) {
          left = Math.min(left, node.x - width / 2);
          right = Math.max(right, node.x + width / 2);
          top = Math.min(top, node.y - (out ? height + LABEL_GAP + radius : height / 2));
          bottom = Math.max(bottom, node.y + (out ? 0 : height / 2));
        } else {
          left = Math.min(left, node.x - (out ? 0 : height / 2));
          right = Math.max(right, node.x + (out ? radius + LABEL_GAP + height : height / 2));
          top = Math.min(top, node.y - width / 2);
          bottom = Math.max(bottom, node.y + width / 2);
        }
      }

      left = Math.min(left, node.x - radius);
      right = Math.max(right, node.x + radius);
      top = Math.min(top, node.y - radius);
      bottom = Math.max(bottom, node.y + radius);
    });
    left = -left;
    right = right - size[0];
    top = -top;
    bottom = bottom - size[1];
    size = [size[0] - left - right, size[1] - top - bottom];
    tree.size(size);
    tree.nodes(vanchart.ancestor).reverse();
    nodes.forEach(function (node) {
      node.x = node.x + left;
      node.y = node.y + top;
    });
  },
  _treeLinkPath: function (link) {
    var vanchart = this,
        maxLevel = vanchart.maxLevel;
    var diagonalFun = vanchart._verticalLayout() ? function (d) {
      return [d.x, d.y];
    } : function (d) {
      return [d.y, d.x];
    };

    if (vanchart.lineWidth) {
      var diagonal = _PathGenerator["default"].diagonal().projection(diagonalFun);

      return diagonal(link);
    }

    var source = link.source,
        target = link.target,
        width = strokeWidth(link, maxLevel),
        gap = width / 2;
    var sx = source.x,
        sy = source.y,
        tx = target.x,
        ty = target.y,
        m = (sy + ty) / 2;
    var sx1 = sx - gap,
        tx1 = Math.min(tx - 0.25, tx - gap + 0.5),
        sx2 = sx + gap,
        tx2 = Math.max(tx + 0.25, tx + gap - 0.5);
    var p = [{
      x: sx1,
      y: sy
    }, {
      x: sx1,
      y: m
    }, {
      x: tx1,
      y: m
    }, {
      x: tx1,
      y: ty
    }, {
      x: tx2,
      y: ty
    }, {
      x: tx2,
      y: m
    }, {
      x: sx2,
      y: m
    }, {
      x: sx2,
      y: sy
    }];
    p = p.map(diagonalFun);
    return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3] + "L" + p[4] + "C" + p[5] + " " + p[6] + " " + p[7];
  },
  _renderTreeLink: function () {
    var vanchart = this,
        renderer = vanchart.renderer,
        plotBounds = vanchart.bounds;
    var plotOptions = vanchart.options.plotOptions,
        styles;

    if (vanchart.lineWidth == null) {
      styles = {
        'fill': plotOptions.lineColor,
        'fill-opacity': plotOptions.lineOpacity
      };
    } else {
      styles = {
        'fill': 'none',
        'stroke': plotOptions.lineColor,
        'stroke-opacity': plotOptions.lineOpacity,
        'stroke-width': vanchart.lineWidth
      };
    }

    var minx = plotBounds.width,
        miny = plotBounds.height,
        maxx = 0,
        maxy = 0;
    vanchart.edges.forEach(function (link) {
      link.linkGraphic && link.linkGraphic.remove();
      link.linkGraphic = null;
      link.linkGraphic = renderer.path().addTo(vanchart.linkGroup);
      link.linkGraphic.attr('d', vanchart._treeLinkPath(link)).style(styles);
      link.linkGraphic.datum(link);
      var source = link.source,
          target = link.target;
      minx = Math.min(minx, source.posX);
      miny = Math.min(miny, source.posY);
      maxx = Math.max(maxx, source.posX);
      maxy = Math.max(maxy, source.posY);
      minx = Math.min(minx, target.posX);
      miny = Math.min(miny, target.posY);
      maxx = Math.max(maxx, target.posX);
      maxy = Math.max(maxy, target.posY);
    });
    var lineWidth = vanchart.lineWidth || 1,
        isHorizontal = vanchart.layout === _Constants["default"].HORIZONTAL_LAYOUT;

    if (vanchart.animation && (0, _EnvUtils.isSupportSVG)()) {
      if (maxx < minx || maxy < miny) {
        //只有根节点，没有edges
        minx = 0;
        maxx = plotBounds.width;
        miny = 0;
        maxy = plotBounds.height;
      } // @CHART-1379
      //+1防止最外面一根线被截断


      var attrs = {
        'x': minx - (isHorizontal ? 0 : lineWidth / 2),
        'y': miny - (isHorizontal ? lineWidth / 2 : 0),
        'width': maxx - minx + (isHorizontal ? 0 : lineWidth) + 1,
        'height': maxy - miny + (isHorizontal ? lineWidth : 0) + 1
      };

      if (!vanchart.linkGroup.clipG) {
        vanchart.linkGroup.clipG = renderer.createClip(attrs);
        renderer.clip(vanchart.linkGroup, vanchart.linkGroup.clipG);
      } else {
        renderer.updateClip(vanchart.linkGroup.clipG, attrs);
      }

      var clipKey = vanchart._verticalLayout() ? 'height' : 'width';
      var endAttr = {};
      endAttr[clipKey] = attrs[clipKey];
      vanchart.linkGroup.clipG.rect.attr(clipKey, 0).animate({
        ease: LINK_EASE,
        duration: LINK_TIME,
        attr: endAttr
      });
    }
  },
  //with node.x node.y delayTime
  _rendererNodes: function (delayArray) {
    var vanchart = this,
        renderer = vanchart.renderer,
        maxLevel = vanchart.maxLevel;
    vanchart.nodes.forEach(function (node) {
      node._events = null;
      node.graphic && node.graphic.remove();
      node.graphic = null;
      var radius = nodeRadius(node, maxLevel),
          delay = delayArray[node.level];
      node.posX = parseInt(vanchart._horizontalLayout() ? node.y : node.x);
      node.posY = parseInt(vanchart._horizontalLayout() ? node.x : node.y);

      var attrs = vanchart._nodeAttrs(node),
          style = node.series.getStyle(node);

      node.graphic = renderer.group().attr('transform', 'translate(' + node.posX + ',' + node.posY + ')').addTo(vanchart.nodeGroup);

      if (node.options.image) {
        node.graphic.nodeGraphic = renderer.image(attrs).imageContent(node.options.image).addTo(node.graphic);
      } else {
        node.graphic.nodeGraphic = renderer.circle(attrs).style(style).addTo(node.graphic);
      }

      function createNodeEventObject() {
        var nodeEventObject = new _EventObject["default"](vanchart.getEvents());
        nodeEventObject.vanchart = vanchart;
        return nodeEventObject;
      }

      function registerTarget(object, graphic) {
        graphic && vanchart.registerInteractiveTarget(object, graphic);
      }

      registerTarget(node, node.graphic);
      registerTarget(createNodeEventObject(), node.graphic.nodeGraphic);
      node.graphic.attr('transform', 'translate(' + node.posX + ',' + node.posY + ') scale(0.01)').animate([{
        delay: delay,
        ease: NODE_EASE,
        duration: NODE_TIME / 2,
        attr: {
          'transform': 'translate(' + node.posX + ',' + node.posY + ') scale(1.5)'
        }
      }, {
        ease: NODE_EASE,
        duration: NODE_TIME / 2,
        attr: {
          'transform': 'translate(' + node.posX + ',' + node.posY + ') scale(1)'
        }
      }]);

      if (vanchart._forceDragEnabled()) {
        vanchart.force.registerDragTarget(node, node.graphic);
      }
    });
  },
  _nodeAttrs: function (node) {
    var radius = node.radius;
    return node.options.image ? {
      'preserveAspectRatio': 'none',
      'x': -radius,
      'y': -radius,
      'width': radius * 2,
      'height': radius * 2
    } : {
      'cx': 0,
      'cy': 0,
      'r': radius
    };
  },
  _labelPos: function (node) {
    if (!node.labelDim) {
      return;
    }

    var dataLabels = node.options.dataLabels;
    var dim = node.labelDim,
        alignInside = dataLabels.align == _Constants["default"].INSIDE;
    return alignInside ? {
      x: node.posX - dim.width / 2,
      y: node.posY - dim.height / 2
    } : {
      x: node.posX - dim.width / 2,
      y: node.posY - node.radius - LABEL_GAP - dim.height
    };
  },
  _animationEnd: function () {
    this._animationStarted = false;
  },
  _renderLabels: function (delayArray) {
    var manager = new _BoundsManager["default"](),
        vanchart = this;

    var needShowMoreLabel = this._needShowMoreLabel();

    var isFlow = this.isMobileFlow();
    vanchart.nodes && vanchart.nodes.forEach(function (node) {
      node.textGraphic && node.textGraphic.remove();
      node.textGraphic = null;
      var dataLabels = node.options.dataLabels,
          series = node.series;

      if (dataLabels && dataLabels.enabled) {
        var pos = vanchart._labelPos(node);

        if (dataLabels.autoAdjust) {
          pos = series._calculateAutoLabelPos(node, pos, vanchart._horizontalLayout(), manager);
        }

        if (pos) {
          var b = _BaseUtils["default"].makeBounds(pos, node.labelDim);

          if (isFlow && manager.isOverlapped(b)) {
            // no overlap in flow
            // don't set labelPos
            node.labelPos = null;
          } else {
            node.labelPos = pos;
            manager.addBounds(b);
          }
        }

        if (node.labelPos) {
          series._createTextGraphic(node);

          node.textGraphic.style('opacity', 0).animate({
            delay: delayArray[node.level],
            duration: 0,
            style: {
              opacity: 1
            }
          });
        }
      } // 定时在节点绘制之后渲染moreLabel


      if (needShowMoreLabel) {
        var moreLabelTimer = _BaseUtils["default"].setTimeout(function () {
          series._showMoreLabel(node);
        }, delayArray[node.level]);

        vanchart.moreLabelTimers = vanchart.moreLabelTimers || [];
        vanchart.moreLabelTimers.push(moreLabelTimer);
      }
    });
  },
  _onPanStart: function (ev) {
    var eventObject = this,
        vanchart = eventObject.vanchart;
    vanchart.groupTrans = vanchart.groupTrans || vanchart.bounds;
    vanchart.currentPoint = ev.containerPoint;
  },
  _onPanMove: function (ev) {
    var eventObject = this,
        vanchart = eventObject.vanchart;
    var transX = ev.containerPoint.x - vanchart.currentPoint.x,
        transY = ev.containerPoint.y - vanchart.currentPoint.y;
    vanchart.groupTrans.x += transX;
    vanchart.groupTrans.y += transY;
    vanchart.currentPoint = ev.containerPoint;
    vanchart.removeMoreLabel(); // 拖拽时移除moreLabel

    var trans = _BaseUtils["default"].makeTranslate(vanchart.groupTrans);

    vanchart.linkGroup.attr('transform', trans);
    vanchart.nodeGroup.attr('transform', trans);

    if (vanchart.ancestor.series.textGraphicGroup) {
      vanchart.ancestor.series.textGraphicGroup.attr('transform', trans);
    }
  },
  _onPanEnd: function (ev) {
    var eventObject = this,
        vanchart = eventObject.vanchart;
    vanchart.handler.panTarget = null;
  },
  getEvents: function () {
    var vanchart = this;
    return vanchart._treeDragEnabled() ? {
      'panstart': vanchart._onPanStart,
      'panmove': vanchart._onPanMove,
      'panend': vanchart._onPanEnd
    } : {};
  }
});

var _default = VanChartStructure;
exports["default"] = _default;

/***/ }),
/* 227 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _locale = _interopRequireDefault(__webpack_require__(228));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _VanChart = _interopRequireDefault(__webpack_require__(33));

var _VanChartLayout = _interopRequireDefault(__webpack_require__(52));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _localeText = _interopRequireDefault(__webpack_require__(32));

var _dateUnits = _interopRequireDefault(__webpack_require__(87));

var _ManagerGantt = _interopRequireDefault(__webpack_require__(233));

var _component = __webpack_require__(4);

var _Link = _interopRequireDefault(__webpack_require__(234));

var _Mark = _interopRequireDefault(__webpack_require__(235));

var _EnvUtils = __webpack_require__(2);

var _helper = _interopRequireDefault(__webpack_require__(30));

var _renderer = __webpack_require__(22);

var _Browser = _interopRequireDefault(__webpack_require__(8));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/1/11.
 */
var PROCESSES = _component.ComponentCst.PROCESSES;
var TIMEAXIS = _component.ComponentCst.TIMEAXIS;
var LEVELBAR = _component.ComponentCst.LEVELBAR;
var Max = Math.max;
var sum = _helper["default"].sum;
var RESZIE_TOLERANCE = 10;

var Gantt = _VanChart["default"].extend({
  vanChartType: _Constants["default"].GANTT_CHART,
  initialize: function (option) {
    // 看来还是少了个中介→_→
    // CHART-1424: Have to fire these events in init. So listen before init...
    this.on('moveSeries', (0, _EnvUtils.isSupportSVG)() ? this.moveSeries : _BaseUtils["default"].throttle(this.moveSeries, 50, this));
    this.on('updateSeries', this.updateSeriesTextDivGroup);

    _VanChart["default"].prototype.initialize.apply(this, arguments);

    this.handler && this.handler.on('resizeEnd', this.onResizeEnd, this);

    if (this.isMobileFlow()) {
      this.handler && this.handler.registerManager(new _ManagerGantt["default"](this.handler));
    }
  },
  moveSeries: function (pos) {
    this.clipSeriesGroup.attr('transform', 'translate(' + pos.x + ',' + 0 + ')');
    this.moveSeriesTextGroup(pos);
    this.moveCanvasSeries(pos);
  },
  moveCanvasSeries: function (pos) {
    if (!this.realGantt) {
      return;
    }

    this.putGanttImageData(pos.x, pos.y);
  },
  useCanvas: function () {
    return !_Browser["default"].ielt9 && this.options.plotOptions.large;
  },
  refresh: function (options) {
    // @Cmen：CHART-1130:同initialize
    if (!this.width || !this.height) {
      return;
    }

    if (this.getTimeAxis()) {
      this.remove();
      this.removeLinks();
      this.removeMarks();
      this.removeCanvasSeries();
      this.off('moveY');
      var vanchart = this;
      vanchart.panBounds = vanchart.backGroup = vanchart.processesGroup = vanchart.timeaxisGroup = vanchart.frontGroup = vanchart.seriesTextDivGroupWrapper = null;

      _component.ComponentsOrder.map(function (c) {
        if (c in vanchart.components) {
          vanchart.components[c].remove();
          vanchart.components[c] = null;
        }
      });

      vanchart.components = {};
      var oldFullScreenChart = this.fullScreenChart;
      this.initialize(options, this.wrapDom, this.vancharts); // 这一步把fullScreenChart置为null，这里在之前保存一下

      if (oldFullScreenChart) {
        this.fullScreenChart = oldFullScreenChart;
        this.fullScreenChart.setData(this.options);
      }
    } else {
      _VanChart["default"].prototype.refresh.call(this, options);
    }
  },
  removeCanvasSeries: function () {
    this.ganttCanvasArr && this.ganttCanvasArr.forEach(function (ganttCanvas) {
      return ganttCanvas.remove();
    });
    this.realGantt && this.realGantt.remove();
    this.ganttScrollBar && this.ganttScrollBar.remove();
    this.ganttCanvasArr = this.realGantt = this.ganttScrollBar = null;
  },
  setOptions: function (options) {
    var lan = _localeText["default"].normalizeLocale(options.language);

    _dateUnits["default"].setLocale((0, _locale["default"])(lan));

    _VanChart["default"].prototype.setOptions.call(this, options);
  },
  resize: function () {
    this._sizeChanged = true;
    this.refresh(this.options);
  },
  _calcCanvasBounds: function () {
    if (!this.useCanvas()) {
      return;
    }

    var plotBounds = this.bounds;
    var timeAxis = this.getTimeAxis();
    var processes = this.getProcesses();
    var scale = timeAxis.scale;
    var cateMap = processes.cateMap;
    var pTableDims = processes.tableDims;
    var rowHeight = pTableDims.rowHeight;
    var x = sum(pTableDims.widths);
    var y = timeAxis.tableDims.headerHeight;
    var width = 0,
        height = 0;
    this.series.forEach(function (ser) {
      ser.getDataToDraw().forEach(function (point) {
        var pId = point.options.processesId;
        width = Max(width, scale(+point.finishTime));
        height = Max(height, cateMap[pId] * rowHeight);
      });
    });
    var moveX = timeAxis.getMovePos().pos.x;
    this.canvasBounds = {
      x: x + plotBounds.x + moveX,
      y: y + plotBounds.y,
      width: width + rowHeight,
      height: height + rowHeight
    };
    this.realCanvasBounds = {
      x: x + plotBounds.x,
      y: y + plotBounds.y,
      width: plotBounds.width - x,
      height: plotBounds.height - y
    };
  },
  updateGanttCanvas: function () {
    if (!this.useCanvas()) {
      return;
    }

    this._calcCanvasBounds();

    var vanchart = this;
    var canvasBounds = this.canvasBounds,
        ganttCanvasArr = this.ganttCanvasArr;
    var currentLength = ganttCanvasArr.length;
    var newLength = Math.ceil(canvasBounds.width / _Constants["default"].GANTT_CANVAS_WIDTH);
    newLength = Math.min(newLength, _Constants["default"].GANTT_MAX_CANVAS_NUM);

    var ganttCanvasArrPop = function (currentLength, newLength) {
      for (var i = currentLength - 1; i >= 0; i--) {
        if (i < newLength) {
          ganttCanvasArr[i].clearAll();
        } else {
          ganttCanvasArr[i].remove();
          ganttCanvasArr.pop();
        }
      }
    };

    var ganttCanvasArrPush = function (currentLength, newLength) {
      for (var i = 0; i < newLength; i++) {
        if (i < currentLength) {
          ganttCanvasArr[i].clearAll();
        } else {
          var bounds = {
            x: canvasBounds.x,
            y: canvasBounds.y,
            width: _Constants["default"].GANTT_CANVAS_WIDTH,
            height: canvasBounds.height
          };
          ganttCanvasArr[i] = (0, _renderer.createCanvasRenderer)(vanchart.dom, vanchart, bounds);
          ganttCanvasArr[i].onAdd();
          ganttCanvasArr[i].ctx.canvas.style.display = 'none';
        }
      }
    };

    if (currentLength > newLength) {
      ganttCanvasArrPop(currentLength, newLength);
    } else {
      ganttCanvasArrPush(currentLength, newLength);
    }
  },
  renderCanvasSeries: function () {
    if (!this.useCanvas()) {
      return;
    }

    var realCanvasBounds = this.realCanvasBounds;

    if (!this.realGantt) {
      this.realGantt = (0, _renderer.createCanvasRenderer)(this.dom, this, realCanvasBounds);
      this.realGantt.onAdd();
    }

    var timeAxis = this.getTimeAxis();
    var moveX = timeAxis.getMovePos().pos.x;
    this.putGanttImageData(moveX, 0);
  },
  putGanttImageData: function (moveX, moveY) {
    var realCanvasBounds = this.realCanvasBounds,
        canvasBounds = this.canvasBounds;
    var width = realCanvasBounds.width,
        height = realCanvasBounds.height;
    var clipStartX = canvasBounds.x - moveX;
    var clipEndX = clipStartX + width;
    this.realGantt.clearAll();
    var ganttImageDataArr = [];
    this.ganttCanvasArr.forEach(function (ganttCanvas, index) {
      var startX = canvasBounds.x + _Constants["default"].GANTT_CANVAS_WIDTH * index;
      var endX = startX + _Constants["default"].GANTT_CANVAS_WIDTH;

      if (startX < clipEndX && endX > clipStartX) {
        var x = startX > clipStartX ? 0 : clipStartX - startX;
        var imageDataEndX = Math.min(endX, clipEndX) - clipStartX;
        var imageWidth = Math.min(imageDataEndX, _Constants["default"].GANTT_CANVAS_WIDTH);
        var imageData = ganttCanvas.ctx.getImageData(x, -moveY, imageWidth, height);
        ganttImageDataArr.push({
          imageData: imageData,
          imageDataEndX: imageDataEndX
        });
      }
    });
    var realGantt = this.realGantt;
    ganttImageDataArr.forEach(function (ganttImageData, index) {
      var x = index ? ganttImageDataArr[index - 1].imageDataEndX : 0;
      var imageData = ganttImageData.imageData;
      realGantt.ctx.putImageData(imageData, x, 0);
    });
  },
  layoutComponentsAndCharts: function () {
    var vanchart = this;
    vanchart.bounds = vanchart._getDefaultBounds();

    _component.ComponentsOrder.map(function (c) {
      if (c in vanchart.components) {
        vanchart.components[c].doLayout();
      }
    });

    var P = this.getProcesses();
    var T = this.getTimeAxis();

    if (!this.panBounds) {
      var panelDims = this._calcDims(P, T);

      this.panBounds = this._calcPanBounds(panelDims); // re-calc after resize

      this.resizeBounds = this._calcResizeBounds(panelDims);
      P.setPanelDims(panelDims);
      T.setPanelDims(panelDims);
    } // todo calcSeries -> vcLayout.calcS...


    T.calcSeries(this.series, P.procMap, P.cateMap);
    T.calcScale();

    _VanChartLayout["default"].calculateSeries(this); // calculateLabelInfo


    _VanChartLayout["default"].calculateSeriesShapes(this);

    this._calcCanvasBounds();

    this.render();
  },
  render: function () {
    this.vancharts.endLoading();
    var vanchart = this,
        renderer = this.renderer; // 数据为空时显示提示

    if (this._isEmptyDataChart()) {
      this._showEmptyDataTip();

      return;
    } else {
      this.emptyDataGroup && this.emptyDataGroup.remove();
    } // var clipBounds = this.getPlotClipBounds();
    // if(!this.plotClip){
    //     this.plotClip = renderer.createClip(clipBounds);
    // }else{
    //     renderer.updateClip(this.plotClip, clipBounds);
    // }
    // gantt
    // series' inside timeAxis [inner-body] group
    // so...


    ['backGroup', 'processesGroup', 'timeaxisGroup', 'frontGroup'].forEach(function (groupName) {
      if (!vanchart[groupName]) {
        var g = vanchart[groupName] = renderer.group().addClass(groupName).add(); // so ugly

        if (groupName === 'processesGroup' || groupName === 'timeaxisGroup') {
          var name = groupName + '-body';
          g = vanchart[name] = g.append(renderer.group().addClass(name));
          name = groupName + '-inner-body';
          vanchart[name] = g.append(renderer.group().addClass(name));
        }
      }
    });
    var mainGroup = vanchart['timeaxisGroup-inner-body'];
    ['clipSeriesGroup', 'seriesGroup', 'seriesTextRenderGroup'].forEach(function (groupName) {
      if (!vanchart[groupName]) {
        vanchart[groupName] = mainGroup.append(renderer.group().addClass(groupName));
      }
    });

    this._addSeriesTextDivGroup();

    this._renderBackground();

    this.renderSeries(); // series related

    this.renderLinks();
    this.renderMarks();
    this.renderCanvasSeries();
    this.renderComponents(); // layout levelbar before P&T,
    // but render it last

    var levelBar = this.getComponent(LEVELBAR);

    if (levelBar && levelBar.isVisible()) {
      levelBar.setLevel(this.getTimeAxis().getLevel());
    }
  },
  // no clip, but overflow: hidden
  _addSeriesTextDivGroup: function () {
    var vanchart = this;

    if (!vanchart.seriesTextDivGroupWrapper) {
      vanchart.seriesTextDivGroupWrapper = this.renderer.div().add();
      vanchart.seriesTextDivGroup = this.renderer.div();
      vanchart.seriesTextDivGroupWrapper.append(vanchart.seriesTextDivGroup);
    }

    this.updateSeriesTextDivGroup();
  },
  updateSeriesTextDivGroup: function () {
    // contract div to TimeAxis's inner
    var T = this.getTimeAxis();
    var clipBounds = {
      x: T.bounds.x,
      y: T.bounds.y + T.tableDims.headerHeight,
      width: T.bounds.width,
      height: T.bounds.height - T.tableDims.headerHeight
    }; // CHART-1353
    // 透明div会影响IE8 event

    this.seriesTextDivGroupWrapper.style({
      left: clipBounds.x + 'px',
      top: clipBounds.y + 'px',
      // clip: rect(<top>, <right>, <bottom>, <left>);
      clip: 'rect(' + [0, clipBounds.width, clipBounds.height, 0].join('px ') + 'px)'
    });
  },
  moveSeriesTextGroup: function (pos) {
    this.seriesTextRenderGroup.attr('transform', 'translate(' + pos.x + ',' + 0 + ')');
    this.seriesTextDivGroup.style('transform', 'translate(' + pos.x + ',' + pos.y + 'px)');
  },

  /**
   * 甘特图内部拖拽时是否到达边界
   * timeAxis&&processes都到了边界位置
   */
  _isPanMovingAtTheBoundary: function (ev) {
    var containerPoint = ev.containerPoint;
    var levelBar = this.getComponent(_component.ComponentCst.LEVELBAR);

    var inViewBounds = _BaseUtils["default"].containsPoint(this.panBounds, containerPoint);

    var inLevelBarBounds = levelBar && _BaseUtils["default"].containsPoint(levelBar.thumbBounds, containerPoint);

    if (!inViewBounds && !inLevelBarBounds) {
      return true;
    }

    var timeAxis = this.getComponent(_component.ComponentCst.TIMEAXIS),
        processes = this.getComponent(_component.ComponentCst.PROCESSES);
    var l1 = timeAxis.view.isViewScrollAtTheBoundary(ev),
        l2 = processes.view.isViewScrollAtTheBoundary(ev);
    return l1 && l2;
  },
  changeToLevel: function (level) {
    var timeAxis = this.getTimeAxis();
    var levelNow = timeAxis.getLevel();

    if (level === levelNow) {
      return;
    }

    timeAxis.setLevel(level);
    timeAxis.calcScale();
    timeAxis.renderContent();
    this.reRenderWholePlot();
  },
  reRenderWholePlot: function () {
    _VanChartLayout["default"].calculateSeriesShapes(this);

    this.updateGanttCanvas();
    this.renderSeries();
    this.renderLinks();
    this.renderMarks();
    this.renderCanvasSeries();
    this.getComponent(_component.ComponentCst.LEGEND_COMPONENT).render();
  },
  _calcDims: function (P, T) {
    var bounds = this.bounds;
    var wholeWidth = bounds.width;
    var pDim = P.getInitPanelDims();
    var pWidth = pDim.width;
    var headerHeight = pDim.headerHeight;
    var tDim = T.getInitPanelDims();
    var tWidth = wholeWidth - pWidth;
    headerHeight = Max(headerHeight, tDim.headerHeight);
    var calcHeight = pDim.rowHeight * pDim.rowNum;
    var bodyViewHeight = bounds.height - headerHeight;
    var rowNum = pDim.rowNum;

    if (calcHeight < bodyViewHeight && pDim.rowHeight > 0) {
      rowNum = Math.floor(bodyViewHeight / pDim.rowHeight);
    }

    return {
      x: bounds.x,
      y: bounds.y,
      pWidth: pWidth,
      // visible width
      tWidth: tWidth,
      height: bounds.height,
      headerHeight: headerHeight,
      rowHeight: pDim.rowHeight,
      rowNum: rowNum
    };
  },
  getProcesses: function () {
    return this.getComponent(PROCESSES);
  },
  getTimeAxis: function () {
    return this.getComponent(TIMEAXIS);
  },
  isResizeEnabled: function () {
    return this.getComponent(PROCESSES).options.resize;
  },
  // bounds to determine wheel/scroll
  _calcPanBounds: function (dims) {
    return {
      x: dims.x,
      y: dims.y,
      width: dims.pWidth + dims.tWidth,
      height: dims.height
    };
  },
  _calcResizeBounds: function (dims) {
    return {
      x: dims.x + dims.pWidth - RESZIE_TOLERANCE / 2,
      y: dims.y,
      width: RESZIE_TOLERANCE,
      height: dims.height
    };
  },
  onResizeEnd: function () {
    this.resizeBounds.x = this.getTimeAxis().bounds.x - RESZIE_TOLERANCE / 2;
  },
  onScrollY: function (data) {
    this.fire('moveY', data);
  },
  addPlotOffset: _BaseUtils["default"].falseFn,
  getPlotContentBounds: function () {
    var t = this.getTimeAxis();
    return {
      x: t.view.innerPosX,
      y: t.view.innerPosY,
      width: t.innerWidth,
      height: t.view.innerBodyHeight
    };
  },
  getScrollVisibleBounds: function () {
    var t = this.getTimeAxis();
    return {
      x: t.bounds.x,
      y: t.bounds.y + t.tableDims.headerHeight,
      width: t.bounds.width,
      height: t.view.visibleBodyHeight
    };
  },
  getDefaultTooltipFormatter: function () {
    return {
      durationFormat: "function(d) {return d.as('day')}",
      finishTimeFormat: "",
      identifier: "{PROCESSES}{SERIES}{STARTTIME}{FINISHTIME}{DURATION}{PROGRESS}",
      progressFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '#.##%') : arguments[0]}",
      seriesFormat: "function(){return window.FR ? FR.contentFormat(arguments[0], '') : arguments[0]}",
      startTimeFormat: ""
    };
  }
});

Gantt.include(_Link["default"]);
Gantt.include(_Mark["default"]);
var _default = Gantt;
exports["default"] = _default;

/***/ }),
/* 228 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _jaJp = _interopRequireDefault(__webpack_require__(229));

var _zhCn = _interopRequireDefault(__webpack_require__(230));

var _zhTw = _interopRequireDefault(__webpack_require__(231));

var _enUs = _interopRequireDefault(__webpack_require__(232));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var _languages = {
  'ja-jp': _jaJp["default"],
  'zh-cn': _zhCn["default"],
  'zh-tw': _zhTw["default"],
  'en-us': _enUs["default"]
};

var _default = function _default(name) {
  return _languages[name] ? _languages[name] : _enUs["default"];
};

exports["default"] = _default;

/***/ }),
/* 229 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by Yuqian on 2017/6/7.
 */
var _default = {
  _locale: 'ja-jp',
  // duration[units] can be a function
  // duration.year = function(duration) { return 'string' }
  duration: {
    year: '年',
    month: 'か月',
    day: '日',
    hour: '時間',
    minute: '分',
    second: '秒'
  },
  halfYears: ['前', '後'],
  quarters: '第1四半期_第2四半期_第3四半期_第4四半期'.split('_'),
  months: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
  monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
  weekdays: '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
  weekdaysShort: '日_月_火_水_木_金_土'.split('_'),
  weekdaysMin: '日_月_火_水_木_金_土'.split('_'),
  meridiem: ['午前', '午後'],
  qDay: '0~6時_6~12時_12~18時_18~24時'.split('_'),
  base: function (add, names) {
    // format according to
    // http://www.unicode.org/reports/tr35/tr35-dates.html#Parsing_Dates_Times
    //
    // custom:
    // half year = N
    // 1/4 day = I
    // week of year
    add('www', 0, 0, function () {
      return '第' + this.week() + '週';
    });
  }
};
exports["default"] = _default;

/***/ }),
/* 230 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * Created by Yuqian on 2017/3/1.
 */
var _default = {
  _locale: 'zh-cn',
  // duration[units] can be a function
  // duration.year = function(duration) { return 'string' }
  duration: {
    year: '年',
    month: '月',
    day: '天',
    hour: '小时',
    minute: '分钟',
    second: '秒'
  },
  halfYears: ['上', '下'],
  quarters: '一季度_二季度_三季度_四季度'.split('_'),
  months: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
  monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
  weekdays: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
  weekdaysShort: '周日_周一_周二_周三_周四_周五_周六'.split('_'),
  weekdaysMin: '日_一_二_三_四_五_六'.split('_'),
  meridiem: ['上午', '下午'],
  qDay: '0~6点_6~12点_12~18点_18~24点'.split('_'),
  base: function (add, names) {
    // format according to
    // http://www.unicode.org/reports/tr35/tr35-dates.html#Parsing_Dates_Times
    //
    // custom:
    // half year = N
    // 1/4 day = I
    // week of year
    add('www', 0, 0, function () {
      return this.week() + '周';
    });
  }
};
exports["default"] = _default;

/***/ }),
/* 231 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _default = {
  _locale: 'zh-tw',
  // duration[units] can be a function
  // duration.year = function(duration) { return 'string' }
  duration: {
    year: '年',
    month: '月',
    day: '天',
    hour: '小時',
    minute: '分鐘',
    second: '秒'
  },
  halfYears: ['上', '下'],
  quarters: '一季度_二季度_三季度_四季度'.split('_'),
  months: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
  monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
  weekdays: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
  weekdaysShort: '週日_週一_週二_週三_週四_週五_週六'.split('_'),
  weekdaysMin: '日_一_二_三_四_五_六'.split('_'),
  meridiem: ['上午', '下午'],
  qDay: '0~6點_6~12點_12~18點_18~24點'.split('_'),
  base: function (add, names) {
    // format according to
    // http://www.unicode.org/reports/tr35/tr35-dates.html#Parsing_Dates_Times
    //
    // custom:
    // half year = N
    // 1/4 day = I
    // week of year
    add('www', 0, 0, function () {
      return this.week() + '週';
    });
  }
};
exports["default"] = _default;

/***/ }),
/* 232 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _default = {
  _locale: "en_US",
  duration: {
    year: 'years',
    month: 'months',
    day: 'days',
    hour: 'hours',
    minute: 'minutes',
    second: 'seconds'
  },
  halfYears: ['H1', 'H2'],
  quarters: 'Q1_Q2_Q3_Q4'.split('_'),
  months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
  monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
  weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
  weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
  weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
  meridiem: ['am', 'pm'],
  qDay: '0h~6h_6h~12h_12h~18h_18h~24h'.split('_'),
  base: function (add, names) {
    // format according to
    // http://www.unicode.org/reports/tr35/tr35-dates.html#Parsing_Dates_Times
    //
    // custom:
    // half year = N
    // 1/4 day = I
    // week of year
    add('www', 0, 0, function () {
      return 'Week' + this.week();
    });
  }
};
exports["default"] = _default;

/***/ }),
/* 233 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _AbstractManager = _interopRequireDefault(__webpack_require__(26));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/8/13.
 */
var _default = _AbstractManager["default"].extend({
  z: 11,
  name: 'gantt',
  getBoundingRect: function () {
    return this.vanchart.panBounds;
  },
  onpanstart: function (e) {
    if (this.handler.stage !== _Constants["default"].STAGES.NORMAL) {
      return;
    }

    this._scroll(e);

    this.deltaX = e.srcEvent.deltaX;
    this.deltaY = e.srcEvent.deltaY;
    e.deltaX = this.deltaX;
    e.deltaY = this.deltaY;
    this.handler.fire('pan', e);
  },
  onpanmove: function (e) {
    if (this.handler.stage !== _Constants["default"].STAGES.NORMAL) {
      return;
    }

    this._scroll(e);

    this.deltaX += e.srcEvent.deltaX;
    this.deltaY += e.srcEvent.deltaY;
    e.deltaX = this.deltaX;
    e.deltaY = this.deltaY;
    this.handler.fire('pan', e);
  },
  onpanend: function (e) {
    if (this.handler.stage !== _Constants["default"].STAGES.NORMAL) {
      return;
    }

    e.deltaX = this.deltaX;
    e.deltaY = this.deltaY;
    this.handler.fire('pan', e);
  },
  _scroll: function (e) {
    var d = e.srcEvent || e;
    var b = this.vanchart.getScrollBounds();

    if (b.shouldParentHandle && b.handleH !== 'middle' || b.handleV !== 'middle') {// todo, 2 directions ?
      // carousel handle it
    } else {
      e.stop && e.stop();
    }
  }
});

exports["default"] = _default;

/***/ }),
/* 234 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/3/8.
 */
var bindData = _BaseUtils["default"].bindData;

var PathBefore = _PathGenerator["default"].line().interpolate('step-before');

var PathAfter = _PathGenerator["default"].line().interpolate('step-after');

var SAME_LINE_GAP = 2;
var ARROW_WIDTH = 3;
var TYPES = {};
TYPES.fs = TYPES.ff = TYPES.sf = TYPES.ss = true;

function calcLinks(cfg) {
  var options = cfg.links,
      idMap = cfg.idMap;
  var links = [];
  options.filter(function (link) {
    return link.type && TYPES[link.type.toLowerCase()] && link.lineWidth && idMap[link.from] && idMap[link.from].isVisible() && idMap[link.to] && idMap[link.to].isVisible();
  }).forEach(function (link) {
    var l = buildLink(link, cfg);

    if (l) {
      links.push(l[0], l[1]);
    }
  }, this);
  return links;
}

function buildLink(link, cfg) {
  var paths = getLinkPath(link, cfg);

  if (!paths) {
    return;
  }

  var lineAttr = {
    'd': paths.line
  };
  var lineStyle = {
    'fill': 'none',
    'stroke': link.lineColor,
    'stroke-width': link.lineWidth,
    'stroke-dasharray': _Constants["default"].DASH_ARRAY[link.lineType || _Constants["default"].SOLID]
  };
  var arrowAttr = {
    'd': paths.arrow
  };
  var arrowStyle = {
    'fill': link.lineColor,
    'stroke': 'none'
  };
  return [{
    attr: lineAttr,
    style: lineStyle
  }, {
    attr: arrowAttr,
    style: arrowStyle
  }];
}

function getLinkPath(link, cfg) {
  var idMap = cfg.idMap;
  var type = link.type.toLowerCase();
  var from = getEdgePoints(type, 0, idMap[link.from], cfg);
  var to = getEdgePoints(type, 1, idMap[link.to], cfg);
  var begin = from[1]; // turn point of from

  var end = to[0]; // turn point of to

  var beginx = begin[0];
  var endx = end[0];
  var gen = PathBefore;
  var mp = [null, (begin[1] + end[1]) / 2]; // middle point to adjust line

  if (begin[1] === end[1]) {
    var noBetween = function () {
      var left = Math.min(fromRight, toRight);
      var right = Math.max(fromLeft, toLeft);
      return cfg.rowMap[rowNum].every(function (bar) {
        if (bar === barFrom || bar === barTo) {
          return true;
        }

        var minx = Math.max(left, bar.rect.x);
        var maxx = Math.min(right, bar.rect.x + bar.rect.width);
        return minx > maxx;
      });
    };

    // same line
    var rowNum = idMap[link.from].rowNum;
    var barFrom = idMap[link.from];
    var barTo = idMap[link.to];
    var fromLeft = barFrom.rect.x;
    var fromRight = barFrom.rect.x + barFrom.rect.width;
    var toLeft = barTo.rect.x;
    var toRight = barTo.rect.x + barTo.rect.width; // same line no turn:
    //    1. fs/sf, f < s
    // && 2. no bar is between from,to

    var condition1 = type === 'fs' && fromRight < toLeft || type === 'sf' && toRight < fromLeft;

    if (condition1 && noBetween()) {
      to = [from[0], to[1]];
      from = [];
    } else {
      mp = [begin[0], begin[1] - idMap[link.from].rect.height / 2 - SAME_LINE_GAP];
    }

    gen = PathAfter;
  } else {
    switch (type) {
      case 'fs':
        if (beginx > endx) {
          mp[0] = endx;
        }

        break;

      case 'ff':
        if (beginx < endx) {
          gen = PathAfter;
        }

        break;

      case 'ss':
        if (beginx > endx) {
          gen = PathAfter;
        }

        break;

      case 'sf':
      default:
        if (beginx < endx) {
          mp[0] = endx;
        }

    }
  }

  var points = from;

  if (mp[0] != null) {
    points.push(mp);
  }

  points = points.concat(to);
  return {
    line: gen(points),
    arrow: genArrowPath(to[1], type.charAt(1))
  };
} // i = 0/1
// get head or tail line key points


function getEdgePoints(type, i, p, cfg) {
  var cmd = type.charAt(i);
  var rect = p.rect;
  var y = rect.y + rect.height / 2;
  var a = Math.max(rect.height / 2, ARROW_WIDTH * 2); // point on the rect

  var onPoint = [cmd === 's' ? rect.x : rect.x + rect.width, y]; // point off the rect

  var offPoint = [onPoint[0] + (cmd === 's' ? -a : a), y];
  var points; // if 0 (from), on -> off
  // if 1 (to), off -> on

  if (i) {
    // 1
    points = [offPoint, onPoint];
  } else {
    points = [onPoint, offPoint];
  }

  return points;
} // pos: vertex
// cms: f ←, s →
// Mx,yl3,3v-6z
// Mx,yl-3,3v-6z


function genArrowPath(pos, cmd) {
  var d = 'M' + pos[0] + ',' + pos[1] + 'l';
  var w = ARROW_WIDTH;

  if (cmd === 's') {
    // to right
    d += '-';
  }

  d += w + ',' + w + 'v-' + w * 2 + 'z';
  return d;
}

var _default = {
  removeLinks: function () {
    this._linksGroup = null;
  },
  renderLinks: function () {
    var links = this.options.plotOptions.links || [];

    if (!this._linksGroup) {
      this._linksGroup = this.renderer.group().addTo(this.clipSeriesGroup);
      this._linkEls = [];
    }

    var T = this.getTimeAxis();
    var m = T.getMovePos(); // a link' gap to a rect is less than the rect height
    // so we extend the bounds by adding rowHeight

    var ext = this.getProcesses().tableDims.rowHeight;

    var _links = calcLinks({
      links: links,
      idMap: T.idMap,
      rowMap: T.rowMap,
      // for windowing
      pos: m.pos,
      bounds: {
        x: -ext,
        y: 0,
        width: m.bounds.width + 2 * ext,
        height: m.bounds.height
      }
    });

    var g = this._linksGroup,
        R = this.renderer;
    var selection = bindData(this._linkEls, _links);
    selection.exit.map(function (d) {
      d.remove();
    });
    var enter = selection.enter.map(function (d) {
      return g.append(R.path().datum(d));
    });
    this._linkEls = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();
      return ele.attr(d.attr).style(d.style);
    });
  }
};
exports["default"] = _default;

/***/ }),
/* 235 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Yuqian on 2017/3/9.
 */
var getMarkerPath = _PathGenerator["default"].getMarkerPath;
var makeTranslate = _BaseUtils["default"].makeTranslate;
var bindData = _BaseUtils["default"].bindData;
var DEFAULT_MARKER_HEIGHT = 0.8; // 里程碑标记默认为系列高度的0.8

var DEFAULT_MARKER_COLOR = 'rgb(248,182,44)';

var drawMarkerShape = function (ctx, markerType, R) {
  if (markerType.indexOf(_Constants["default"].DIAMOND) != -1) {
    ctx.beginPath();
    ctx.moveTo(-R, 0);
    ctx.lineTo(0, -R);
    ctx.lineTo(R, 0);
    ctx.lineTo(0, R);
    ctx.closePath();
  } else if (markerType.indexOf(_Constants["default"].TRIANGLE) != -1) {
    ctx.beginPath();
    ctx.moveTo(-2 * R / Math.sqrt(3), R);
    ctx.lineTo(0, -R);
    ctx.lineTo(2 * R / Math.sqrt(3), R);
    ctx.closePath();
  } else {
    var r1 = R * 1.105,
        // magic num
    r2 = r1 / 3;
    ctx.beginPath();

    for (var i = 0; i < 5; i++) {
      var x1 = r1 * Math.cos((54 + i * 72) / 180 * Math.PI);
      var y1 = r1 * Math.sin((54 + i * 72) / 180 * Math.PI);
      var x2 = r2 * Math.cos((18 + i * 72) / 180 * Math.PI);
      var y2 = r2 * Math.sin((18 + i * 72) / 180 * Math.PI);
      ctx.lineTo(x2, y2);
      ctx.lineTo(x1, y1);
    }

    ctx.closePath();
  }

  ctx.fill();
};

function drawCanvasMarks(vanchart, marks) {
  var ganttCanvasArr = vanchart.ganttCanvasArr;

  var drawMark = function (canvas, mark, canvasX) {
    var ctx = canvas.ctx;
    var pos = mark.pos,
        size = mark.size,
        color = mark.color,
        type = mark.type;
    var relativeX = pos[0] - canvasX;
    ctx.save();
    ctx.translate(relativeX, pos[1]);
    ctx.fillStyle = color;
    drawMarkerShape(ctx, type, size / 2);
    ctx.translate(-relativeX, -pos[1]);
    ctx.restore();
  };

  ganttCanvasArr.forEach(function (ganttCanvas, index) {
    var _ganttCanvas$config = ganttCanvas.config,
        width = _ganttCanvas$config.width,
        height = _ganttCanvas$config.height;
    var canvasX = _Constants["default"].GANTT_CANVAS_WIDTH * index;
    var canvasBounds = {
      x: canvasX,
      y: 0,
      width: width,
      height: height
    };
    marks.forEach(function (mark) {
      var pos = mark.pos,
          size = mark.size;
      var radius = size / 2;
      var markBounds = {
        x: pos[0] - radius,
        y: pos[1] - radius,
        width: size,
        height: size
      };

      if (!_BaseUtils["default"].outsideRect(canvasBounds, markBounds)) {
        drawMark(ganttCanvas, mark, canvasX);
      }
    });
  });
}

var _default = {
  removeMarks: function () {
    this._marksGroup = null;
  },
  renderMarks: function () {
    if (!this._marksGroup) {
      this._marksGroup = this.renderer.group().addTo(this.clipSeriesGroup);
      this._imageMarkEls = [];
      this._markEls = [];
    }

    var T = this.getTimeAxis();
    var markArray = T.markArray;
    var scale = T.scale;
    var g = this._marksGroup,
        R = this.renderer;
    var _marks = []; // path marks

    var _imageMarks = [];
    markArray.forEach(function (p) {
      if (!(p.visible && p.series.visible)) {
        return;
      }

      var height = p.rect.height;
      var x = scale(p.markTime);
      var y = p.rect.y + 0.5 * height;
      var type = p.options.markType;
      var d = {
        type: type,
        pos: [x, y],
        size: height * DEFAULT_MARKER_HEIGHT,
        color: p.options.markColor || DEFAULT_MARKER_COLOR
      };

      if (_BaseUtils["default"].isImageMarker(type)) {
        _imageMarks.push(d);
      } else {
        _marks.push(d);
      }
    });

    if (this.useCanvas()) {
      return drawCanvasMarks(this, [].concat(_marks, _imageMarks));
    } // image marker


    var selection = bindData(this._imageMarkEls, _imageMarks);
    selection.exit.map(function (d) {
      d.remove();
    });
    var enter = selection.enter.map(function (d) {
      var _g = R.group().datum(d);

      _g.marker = R.image();

      _g.append(_g.marker);

      return g.append(_g);
    });
    this._imageMarkEls = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();
      ele.attr('transform', makeTranslate(d.pos));
      var image = ele.marker;
      var w = d.size,
          h = d.size;
      image.attr({
        'preserveAspectRatio': 'none',
        'x': -w / 2,
        'y': -h / 2,
        'width': w,
        'height': h
      });
      image.imageContent(d.type);
      return ele;
    }); // path marker

    var selection = bindData(this._markEls, _marks);
    selection.exit.map(function (d) {
      d.remove();
    });
    var enter = selection.enter.map(function (d) {
      var _g = R.group().datum(d);

      _g.marker = R.path();

      _g.append(_g.marker);

      return g.append(_g);
    });
    this._markEls = enter.concat(selection.update).map(function (ele) {
      var d = ele.datum();
      ele.attr('transform', makeTranslate(d.pos));
      var path = ele.marker;
      path.attr('d', getMarkerPath(d.type, d.size / 2)).style({
        stroke: 'none',
        fill: d.color
      });
      return ele;
    });
  }
};
exports["default"] = _default;

/***/ }),
/* 236 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _component = __webpack_require__(4);

var _Scale = _interopRequireDefault(__webpack_require__(10));

var _LegendIconFactory = _interopRequireDefault(__webpack_require__(53));

var _EnvUtils = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Jeffrey on 2018/8/8.
 */
var HAS_CROSSLINE = {};
[_Constants["default"].BAR_CHART, _Constants["default"].COLUMN_CHART, _Constants["default"].LINE_CHART, _Constants["default"].AREA_CHART, _Constants["default"].TREEMAP_CHART, _Constants["default"].SCATTER_CHART, _Constants["default"].BUBBLE_CHART, _Constants["default"].FORCE_BUBBLE_CHART, _Constants["default"].RADAR_CHART, _Constants["default"].POINT_MAP, _Constants["default"].AREA_MAP, _Constants["default"].HEAT_MAP, _Constants["default"].LINE_MAP, _Constants["default"].WORD_CLOUD_CHART, _Constants["default"].STRUCTURE_CHART, _Constants["default"].MULTI_CHARTS].forEach(function (k) {
  HAS_CROSSLINE[k] = true;
});
var _default = {
  isFlowTouchPie: function (option) {
    option = option || this.options;
    return this.isMobileFlow() && option.chartType === _Constants["default"].PIE_CHART && option.series.length === 1 && !option.plotOptions.roseType && !option.series[0].roseType;
  },
  _mutateOptions: function (option) {
    // add component crossLine
    if (option.chartType !== _Constants["default"].GANTT_CHART) {
      option.crossLine = {};
      option.plotScroll = {};
    }

    if (option.zoom && option.zoom.zoomTool) {
      // save zoomTool info for init zoom
      option.zoom._zoomTool = option.zoom.zoomTool;
      option.zoom.zoomTool = {};
    }

    if (option.dTools) {
      option.dTools.currentColor = '#999';
      option.dTools.style = option.dTools.style || {};
      option.dTools.style.color = '#1fade5';
    }

    if (option.tools) {
      option.tools = {
        enabled: false
      };
    }

    if (option.dataSheet) {
      option.dataSheet = {
        enabled: false
      };
      option.xAxis && option.xAxis.forEach(function (axis) {
        return axis.showLabel = true;
      });
    }

    if (option.moreLabel) {
      option.moreLabel = {};
    }

    if (this.isFlowTouchPie(option)) {
      option.pieIndicator = {};
    }

    var legend = option.legend && option.legend.enabled && option.legend.visible ? option.legend : null;
    var legendFontSize;

    if (legend) {
      // todo, one line = ?
      // MOBILE-11060 record origin, prevent refresh bug
      legend.style._fontSize = legend.style._fontSize || legend.style.fontSize;
      legendFontSize = 1.5 * (0, _EnvUtils.convertREMtoPX)(legend.style._fontSize);
    }

    var rangeLegend = option.rangeLegend && option.rangeLegend.enabled && option.rangeLegend.visible ? option.rangeLegend : null;

    if (this.vancharts.getOrientation() === 'portrait') {
      if (legend) {
        legend.floating = false; // @MOBILE-21269  这边考虑Icon, 不去遍历series判断maxIconSize了

        legend.maxHeight = Math.max(legendFontSize, _LegendIconFactory["default"].maxIconSize);
        legend.position = 'bottom';
      }

      if (rangeLegend) {
        rangeLegend.floating = false;
        rangeLegend.position = 'bottom';
      }
    } else {
      if (legend) {
        legend.floating = false;
        legend.position = 'right';
      }

      if (rangeLegend) {
        rangeLegend.floating = false;
        rangeLegend.position = 'right';
      }
    }

    if (this.options !== option) {
      var plotScroll = this.getComponent(_component.ComponentCst.PLOT_SCROLL);

      if (plotScroll) {
        plotScroll.__inited = false;
      }
    }

    return option;
  },
  hasScroll: function () {
    return this.yAxis() && this.xAxis();
  },
  shouldPinch: function () {
    return this.yAxis() && this.xAxis() && this._eventsConfig.pinch;
  },
  flowResize: function () {
    this.setPlotOffset({
      x: null,
      y: null
    });
    this.handler.fire('mutatePlot');
  },
  isMobileFlow: function () {
    return this.vancharts.isMobileFlow();
  },
  setPlotZoom: function (z) {
    if (z && z.x >= 1 && z.y >= 1) {
      z.x = z.x || this._plotZoom.x;
      z.y = z.y || this._plotZoom.y;
      this._plotZoom = z;
    } else {
      throw z;
    }

    return this._plotZoom;
  },
  getPlotZoom: function () {
    return {
      x: this._plotZoom.x,
      y: this._plotZoom.y
    };
  },
  setPlotOffset: function (offset) {
    if (offset) {
      if (offset.x == null) {
        offset.x = this._plotOffset.x;
      }

      if (offset.y == null) {
        offset.y = this._plotOffset.y;
      }

      var contentBounds = this.getPlotContentBounds();
      var bounds = this.bounds;
      var xMin = bounds.width - contentBounds.width,
          yMin = bounds.height - contentBounds.height;
      offset.x = Math.max(xMin, Math.min(offset.x, 0));
      offset.y = Math.max(yMin, Math.min(offset.y, 0));
      this._plotOffset = offset;
    } else {
      throw offset;
    }

    return this._plotOffset;
  },
  getPlotOffset: function () {
    return {
      x: this._plotOffset.x,
      y: this._plotOffset.y
    };
  },
  addPlotOffset: function (d) {
    var lastContentBounds = this.getPlotContentBounds();
    var offset = this.setPlotOffset({
      x: this._plotOffset.x + d.deltaX,
      y: this._plotOffset.y + d.deltaY
    });
    return offset.x !== lastContentBounds.x || offset.y !== lastContentBounds.y;
  },
  getPlotContentBounds: function () {
    if (!this.__contentBoundsInited) {
      this.__contentBoundsInited = true; // FIXPM

      var axis = this.baseAxis();

      if (axis) {
        var zoomTool = this.options.zoom && this.options.zoom._zoomTool;
        var dd = axis._dataDomain;
        var domainLen = dd.length;

        if (zoomTool && (zoomTool.from || zoomTool.to)) {
          // 难得见到一个纯函数，好感动!!!
          var getValidDomain = this.getComponent(_component.ComponentCst.ZOOM_COMPONENT)._getValidDomain;

          var domain = getValidDomain(zoomTool.from, zoomTool.to, dd, axis.isCategory());
          var offset, z;

          if (axis.isCategory()) {
            var nextRange = axis._getRangeFromDomain(domain);

            offset = Math.min(nextRange[0], nextRange[1]);
            z = domainLen ? domainLen / domain.length : 1;
          } else {
            var range = axis._getRange();

            var scale = _Scale["default"].linear().domain(domain).range(range); // 用放大后的scale计算原始domain的可视range，因为是init，值就是偏移


            offset = Math.min(scale(dd[0]), scale(dd[1]));
            z = domainLen && domainLen > 1 && domain && domain.length > 1 ? Math.abs(dd[1] - dd[0]) / Math.abs(domain[1] - domain[0]) : 1;
          }

          if (axis.isHorizontal()) {
            this._plotOffset.x = offset;
            this._plotZoom.x = z;
          } else {
            this._plotOffset.y = offset;
            this._plotZoom.y = z;
          }
        } else if (domainLen > 30) {
          var z = domainLen / 30.5;

          if (axis.isHorizontal()) {
            this._plotZoom.x = z;
          } else {
            this._plotZoom.y = z;
          }
        }
      }
    }

    var bounds = this.bounds;
    var contentBounds = {
      x: this._plotOffset.x,
      // scroll offset
      y: this._plotOffset.y,
      width: bounds.width * this._plotZoom.x,
      height: bounds.height * this._plotZoom.y
    };
    return contentBounds;
  },
  changeOrientation: function () {},
  getScrollVisibleBounds: function () {
    return this.bounds;
  },
  _checkHandle: function () {
    if (this.handler.stage !== _Constants["default"].STAGES.NORMAL || this.isMap()) {
      return false;
    } // #MOBILE-18781
    // 除了选择状态和地图，都进入边界判断逻辑
    // 因为有轮播切换


    return true; // return this.shouldPinch();
  },
  getScrollBounds: function () {
    var shouldParentHandle = null,
        // should parent check the bounds...
    horizontalEdge = null,
        verticalEdge = null;

    if (this._checkHandle()) {
      var plotContentBounds = this.getPlotContentBounds();
      var visibleBounds = this.getScrollVisibleBounds();

      if (visibleBounds.width < plotContentBounds.width) {
        if (plotContentBounds.x >= 0) {
          horizontalEdge = 'left';
        } else if (plotContentBounds.width + plotContentBounds.x <= visibleBounds.width) {
          horizontalEdge = 'right';
        } else {
          horizontalEdge = 'middle';
        }
      }

      if (visibleBounds.height < plotContentBounds.height) {
        if (plotContentBounds.y >= 0) {
          verticalEdge = 'top';
        } else if (plotContentBounds.height + plotContentBounds.y <= visibleBounds.height) {
          verticalEdge = 'bottom';
        } else {
          verticalEdge = 'middle';
        }
      }

      shouldParentHandle = !(verticalEdge === 'middle');
    } else {
      // select, zoom or other state, parent shouldn't handle
      shouldParentHandle = false;
    }

    return {
      shouldParentHandle: shouldParentHandle,
      horizontalEdge: horizontalEdge,
      verticalEdge: verticalEdge
    };
  },
  checkCrossLineFlag: function () {
    if (!HAS_CROSSLINE[this.chartType()]) {
      this._hasCrossLine = false;
    } else if (this.series.length === 0 || this.series.length === 1 && (this.series[0].points.length <= 1 || this.vanChartType === 'vanChart')) {
      // <=1个数据，不出十字线
      // 1个系列普通图，不出十字线
      this._hasCrossLine = false;
    } else {
      this._hasCrossLine = true;
    }
  },
  hasCrossLine: function () {
    return this._hasCrossLine;
  }
};
exports["default"] = _default;

/***/ }),
/* 237 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseUtils = _interopRequireDefault(__webpack_require__(0));

var _Constants = _interopRequireDefault(__webpack_require__(1));

var _PathGenerator = _interopRequireDefault(__webpack_require__(9));

var _StyleUtils = __webpack_require__(29);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

function isInvert(location) {
  return location === _Constants["default"].LEFT || location === _Constants["default"].RIGHT;
}

function leastSquares(asXsues, asYsues) {
  var reduceSumFunc = function (prev, cur) {
    return prev + cur;
  };

  var xBar = asXsues.reduce(reduceSumFunc) * 1.0 / asXsues.length;
  var yBar = asYsues.reduce(reduceSumFunc) * 1.0 / asYsues.length;
  var ssXX = asXsues.map(function (d) {
    return Math.pow(d - xBar, 2);
  }).reduce(reduceSumFunc);
  var ssYY = asYsues.map(function (d) {
    return Math.pow(d - yBar, 2);
  }).reduce(reduceSumFunc);
  var ssXY = asXsues.map(function (d, i) {
    return (d - xBar) * (asYsues[i] - yBar);
  }).reduce(reduceSumFunc);
  var slope = ssXY / ssXX;
  var intercept = yBar - xBar * slope;
  return [slope, intercept];
}

var _default = {
  trendLines: [],
  calcTrendLines: function () {
    var trendLines = [],
        vanchart = this,
        series = vanchart.series;

    for (var i = 0, len = series.length; i < len; i++) {
      var sery = series[i],
          trendLine = sery.options.trendLine; //堆积的系列用趋势线没意义吧

      if (!trendLine || !sery.visible) {
        continue;
      }

      var func;

      switch (trendLine.type) {
        case _Constants["default"].LINEAR:
          func = vanchart.linear;
          break;

        case _Constants["default"].LOGARITHMIC:
          func = vanchart.logarithmic;
          break;

        case _Constants["default"].POLYNOMIAL:
          func = vanchart.polynomial;
          break;

        default:
        case _Constants["default"].EXPONENTIAL:
          func = vanchart.exponential;
      }

      var XY = sery.getTrendLineXYValues(sery);
      var baseAxis = sery[sery.getBaseAxisType()];
      var gap = baseAxis.getPeriodSize();

      if (XY[0].length <= 1) {
        continue;
      }

      var isInverted = isInvert(XY[2]);
      var asXs, asYs;

      if (isInverted) {
        asYs = XY[0];
        asXs = XY[1];
      } else {
        asXs = XY[0];
        asYs = XY[1];
      }

      var data = func(asXs, asYs, this.extendXs(asXs, trendLine.period, gap, isInverted, XY[3]));

      var lineGen = _PathGenerator["default"].line().interpolate('cardinal');

      if (isInverted) {
        // normal: [x, y]; inverted: [y, x]
        lineGen.x(function (d) {
          return d[1];
        }).y(function (d) {
          return d[0];
        });
      }

      var line = {
        d: lineGen(data),
        trendLine: _extends({}, trendLine, {
          opacity: sery.opacity
        }),
        bindName: sery.name
      };
      trendLines.push(line);
    }

    this.trendLines = trendLines;
  },
  extendXs: function (asXs, period, gap, isInverted, isReversed) {
    var newArray = _BaseUtils["default"].getTargetFillArray;

    if (period && period.length === 2 && asXs.length > 1) {
      // var gap = asXs[1] - asXs[0];
      var _this$getForecastPeri = this.getForecastPeriod(period, isInverted, isReversed),
          forward = _this$getForecastPeri[0],
          backward = _this$getForecastPeri[1];

      return newArray(forward, function (t, i) {
        return asXs[0] - (i + 1) * gap;
      }).reverse().concat(asXs).concat(newArray(backward, function (t, i) {
        return asXs[asXs.length - 1] + (i + 1) * gap;
      }));
    }

    return asXs;
  },
  getForecastPeriod: function (originalPeriod, isInverted, isReversed) {
    var forward = 0,
        backward = 0;

    if (originalPeriod && originalPeriod.length === 2) {
      var _ref = [-originalPeriod[0], originalPeriod[1]];
      forward = _ref[0];
      backward = _ref[1];

      if (isInverted && !isReversed || !isInverted && isReversed) {
        var _ref2 = [backward, forward];
        forward = _ref2[0];
        backward = _ref2[1];
      }
    }

    return [forward, backward];
  },
  linear: function (asXs, asYs, extXs) {
    var x1, x2, y1, y2;
    var coeff = leastSquares(asXs, asYs);
    x1 = extXs[0];
    y1 = coeff[0] * x1 + coeff[1];
    x2 = extXs[extXs.length - 1];
    y2 = coeff[0] * x2 + coeff[1];
    return [[x1, y1], [x2, y2]];
  },
  logarithmic: function (asXs, asYs, extXs) {
    var newXs = [],
        newYs = []; // get min X in extendXs

    var minX = Math.min.apply(null, extXs);
    asXs.map(function (val, i) {
      if (minX <= 0) {
        // offset to positive
        val += -minX + 1;
      }

      newXs.push(Math.log(val));
      newYs.push(asYs[i]);
    });
    var coeff = leastSquares(newXs, newYs);
    return extXs.map(function (val) {
      var x = val; // x is the true position

      if (minX <= 0) {
        val += -minX + 1; // value offset is equation's value
      }

      return [x, coeff[0] * Math.log(val) + coeff[1]];
    });
  },
  exponential: function (asXs, asYs, extXs) {
    var newXs = [],
        newYs = [];
    var minY = Math.min.apply(null, asYs);
    asXs.map(function (val, i) {
      if (minY <= 0) {
        // offset to positive
        asYs[i] += -minY + 1;
      }

      newXs.push(val);
      newYs.push(Math.log(asYs[i]));
    });
    var coeff = leastSquares(newXs, newYs);
    var tmp = coeff[0];
    coeff[0] = Math.exp(coeff[1]);
    coeff[1] = tmp;
    return extXs.map(function (val) {
      var y = coeff[0] * Math.exp(val * coeff[1]);

      if (minY <= 0) {
        y -= -minY + 1;
      }

      return [val, y];
    });
  },
  polynomial: function (asXs, asYs, extXs) {
    var M = Math.min(asXs.length - 1, 6);
    M++;
    var t;
    var b = [];
    var A = [];

    for (var i = 0; i < M; i++) {
      b[i] = [];
      A[i] = [];
    }

    var B = [];
    var y = [];
    var coeff = [];
    var i, j, k, l;

    for (i = 0; i < M; i++) {
      for (j = 0; j < asXs.length; j++) {
        t = 1;

        for (l = 0; l < i; l++) {
          t = t * asXs[j];
        }

        b[i][j] = t;
      }
    }

    for (i = 0; i < M; i++) {
      for (k = 0; k < M; k++) {
        t = 0;

        for (j = 0; j < asXs.length; j++) {
          t += b[i][j] * b[k][j];
        }

        A[i][k] = t;
      }
    }

    for (i = 0; i < M; i++) {
      t = 0;

      for (j = 0; j < asXs.length; j++) {
        t += asYs[j] * b[i][j];
      }

      B[i] = t;
    }

    for (i = 1; i < M; i++) {
      A[i][0] = A[i][0] / A[0][0];
    }

    for (i = 1; i < M; i++) {
      for (j = i; j < M; j++) {
        var tmp1 = 0;

        for (k = 0; k < i; k++) {
          tmp1 += A[k][j] * A[i][k];
        }

        A[i][j] = A[i][j] - tmp1;

        if (j + 1 != M) {
          var tmp2 = 0;

          for (k = 0; k < i; k++) {
            tmp2 += A[k][i] * A[j + 1][k];
          }

          A[j + 1][i] = (A[j + 1][i] - tmp2) / A[i][i];
        }
      }
    }

    y[0] = B[0];

    for (i = 1; i < M; i++) {
      t = 0;

      for (j = 0; j < i; j++) {
        t += A[i][j] * y[j];
      }

      y[i] = B[i] - t;
    }

    coeff[M - 1] = y[M - 1] / A[M - 1][M - 1];

    for (i = M - 2; i >= 0; i--) {
      t = 0;

      for (j = i + 1; j < M; j++) {
        t += A[i][j] * coeff[j];
      }

      coeff[i] = (y[i] - t) / A[i][i];
    }

    return extXs.map(function (val) {
      return [val, coeff.reduce(function (prev, curr, i) {
        return prev + curr * Math.pow(val, i);
      }, 0)];
    });
  },
  _renderTrendLine: function () {
    this.calcTrendLines();
    var trendLineOptions = this.trendLines,
        plotBounds = this.bounds,
        renderer = this.renderer;

    if (!this.trendLineGroup) {
      // don't render it if empty
      if (!(this.trendLines && this.trendLines.length)) {
        return;
      }

      this.trendLineGroup = this.seriesGroup.append(renderer.group());
      renderer.clip(this.trendLineGroup, this.plotClip);
    }

    this.trendLineGroup.trendLines = this.trendLineGroup.trendLines || [];
    var trendLines = this.trendLineGroup.trendLines;

    for (var i = 0, len = trendLineOptions.length; i < len; i++) {
      var options = trendLineOptions[i];
      var attrs = {
        'd': options.d
      };
      var style = (0, _StyleUtils.getLineStyle)(options.trendLine);

      if (trendLines[i]) {
        trendLines[i].attr(attrs).style(style);
      } else {
        trendLines[i] = renderer.path(attrs).style(style).addTo(this.trendLineGroup);
      }

      trendLines[i].attr('transform', _BaseUtils["default"].makeTranslate(plotBounds));
    }

    for (var _i = trendLineOptions.length; _i < trendLines.length; _i++) {
      trendLines[_i].remove();

      trendLines[_i] = null;
    }

    trendLines.length = trendLineOptions.length;
    return this.trendLineGroup;
  }
};
exports["default"] = _default;

/***/ }),
/* 238 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/**
 * echarts设备环境识别
 *
 * @desc echarts基于Canvas，纯Javascript图表库，提供直观，生动，可交互，可个性化定制的数据统计图表。
 * @author firede[firede@firede.us]
 * @desc thanks zepto.
 */

/* global wx */
var env = {};

if (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') {
  // In Weixin Application
  env = {
    browser: {},
    os: {},
    node: false,
    wxa: true,
    // Weixin Application
    canvasSupported: true,
    svgSupported: false,
    touchEventsSupported: true,
    domSupported: false
  };
} else if (typeof document === 'undefined' && typeof self !== 'undefined') {
  // In worker
  env = {
    browser: {},
    os: {},
    node: false,
    worker: true,
    canvasSupported: true,
    domSupported: false
  };
} else if (typeof navigator === 'undefined') {
  // In node
  env = {
    browser: {},
    os: {},
    node: true,
    worker: false,
    // Assume canvas is supported
    canvasSupported: true,
    svgSupported: true,
    domSupported: false
  };
} else {
  env = detect(navigator.userAgent);
}

var _default = env; // Zepto.js
// (c) 2010-2013 Thomas Fuchs
// Zepto.js may be freely distributed under the MIT license.

exports["default"] = _default;

function detect(ua) {
  var os = {};
  var browser = {}; // var webkit = ua.match(/Web[kK]it[\/]{0,1}([\d.]+)/);
  // var android = ua.match(/(Android);?[\s\/]+([\d.]+)?/);
  // var ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
  // var ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
  // var iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/);
  // var webos = ua.match(/(webOS|hpwOS)[\s\/]([\d.]+)/);
  // var touchpad = webos && ua.match(/TouchPad/);
  // var kindle = ua.match(/Kindle\/([\d.]+)/);
  // var silk = ua.match(/Silk\/([\d._]+)/);
  // var blackberry = ua.match(/(BlackBerry).*Version\/([\d.]+)/);
  // var bb10 = ua.match(/(BB10).*Version\/([\d.]+)/);
  // var rimtabletos = ua.match(/(RIM\sTablet\sOS)\s([\d.]+)/);
  // var playbook = ua.match(/PlayBook/);
  // var chrome = ua.match(/Chrome\/([\d.]+)/) || ua.match(/CriOS\/([\d.]+)/);

  var firefox = ua.match(/Firefox\/([\d.]+)/); // var safari = webkit && ua.match(/Mobile\//) && !chrome;
  // var webview = ua.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/) && !chrome;

  var ie = ua.match(/MSIE\s([\d.]+)/) // IE 11 Trident/7.0; rv:11.0
  || ua.match(/Trident\/.+?rv:(([\d.]+))/);
  var edge = ua.match(/Edge\/([\d.]+)/); // IE 12 and 12+

  var weChat = /micromessenger/i.test(ua); // Todo: clean this up with a better OS/browser seperation:
  // - discern (more) between multiple browsers on android
  // - decide if kindle fire in silk mode is android or not
  // - Firefox on Android doesn't specify the Android version
  // - possibly devide in os, device and browser hashes
  // if (browser.webkit = !!webkit) browser.version = webkit[1];
  // if (android) os.android = true, os.version = android[2];
  // if (iphone && !ipod) os.ios = os.iphone = true, os.version = iphone[2].replace(/_/g, '.');
  // if (ipad) os.ios = os.ipad = true, os.version = ipad[2].replace(/_/g, '.');
  // if (ipod) os.ios = os.ipod = true, os.version = ipod[3] ? ipod[3].replace(/_/g, '.') : null;
  // if (webos) os.webos = true, os.version = webos[2];
  // if (touchpad) os.touchpad = true;
  // if (blackberry) os.blackberry = true, os.version = blackberry[2];
  // if (bb10) os.bb10 = true, os.version = bb10[2];
  // if (rimtabletos) os.rimtabletos = true, os.version = rimtabletos[2];
  // if (playbook) browser.playbook = true;
  // if (kindle) os.kindle = true, os.version = kindle[1];
  // if (silk) browser.silk = true, browser.version = silk[1];
  // if (!silk && os.android && ua.match(/Kindle Fire/)) browser.silk = true;
  // if (chrome) browser.chrome = true, browser.version = chrome[1];

  if (firefox) {
    browser.firefox = true;
    browser.version = firefox[1];
  } // if (safari && (ua.match(/Safari/) || !!os.ios)) browser.safari = true;
  // if (webview) browser.webview = true;


  if (ie) {
    browser.ie = true;
    browser.version = ie[1];
  }

  if (edge) {
    browser.edge = true;
    browser.version = edge[1];
  } // It is difficult to detect WeChat in Win Phone precisely, because ua can
  // not be set on win phone. So we do not consider Win Phone.


  if (weChat) {
    browser.weChat = true;
  } // os.tablet = !!(ipad || playbook || (android && !ua.match(/Mobile/)) ||
  //     (firefox && ua.match(/Tablet/)) || (ie && !ua.match(/Phone/) && ua.match(/Touch/)));
  // os.phone  = !!(!os.tablet && !os.ipod && (android || iphone || webos ||
  //     (chrome && ua.match(/Android/)) || (chrome && ua.match(/CriOS\/([\d.]+)/)) ||
  //     (firefox && ua.match(/Mobile/)) || (ie && ua.match(/Touch/))));


  return {
    browser: browser,
    os: os,
    node: false,
    // 原生canvas支持，改极端点了
    // canvasSupported : !(browser.ie && parseFloat(browser.version) < 9)
    canvasSupported: !!document.createElement('canvas').getContext,
    svgSupported: typeof SVGRect !== 'undefined',
    // works on most browsers
    // IE10/11 does not support touch event, and MS Edge supports them but not by
    // default, so we dont check navigator.maxTouchPoints for them here.
    touchEventsSupported: 'ontouchstart' in window && !browser.ie && !browser.edge,
    // <http://caniuse.com/#search=pointer%20event>.
    pointerEventsSupported: // (1) Firefox supports pointer but not by default, only MS browsers are reliable on pointer
    // events currently. So we dont use that on other browsers unless tested sufficiently.
    // For example, in iOS 13 Mobile Chromium 78, if the touching behavior starts page
    // scroll, the `pointermove` event can not be fired any more. That will break some
    // features like "pan horizontally to move something and pan vertically to page scroll".
    // The horizontal pan probably be interrupted by the casually triggered page scroll.
    // (2) Although IE 10 supports pointer event, it use old style and is different from the
    // standard. So we exclude that. (IE 10 is hardly used on touch device)
    'onpointerdown' in window && (browser.edge || browser.ie && browser.version >= 11),
    // passiveSupported: detectPassiveSupport()
    domSupported: typeof document !== 'undefined'
  };
} // See https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection
// function detectPassiveSupport() {
//     // Test via a getter in the options object to see if the passive property is accessed
//     var supportsPassive = false;
//     try {
//         var opts = Object.defineProperty({}, 'passive', {
//             get: function() {
//                 supportsPassive = true;
//             }
//         });
//         window.addEventListener('testPassive', function() {}, opts);
//     } catch (e) {
//     }
//     return supportsPassive;
// }

/***/ }),
/* 239 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.$override = $override;
exports.clone = clone;
exports.merge = merge;
exports.mergeAll = mergeAll;
exports.extend = extend;
exports.defaults = defaults;
exports.getContext = getContext;
exports.indexOf = indexOf;
exports.inherits = inherits;
exports.mixin = mixin;
exports.isArrayLike = isArrayLike;
exports.each = each;
exports.map = map;
exports.reduce = reduce;
exports.filter = filter;
exports.find = find;
exports.bind = bind;
exports.curry = curry;
exports.isArray = isArray;
exports.isFunction = isFunction;
exports.isString = isString;
exports.isObject = isObject;
exports.isBuiltInObject = isBuiltInObject;
exports.isTypedArray = isTypedArray;
exports.isDom = isDom;
exports.eqNaN = eqNaN;
exports.retrieve = retrieve;
exports.retrieve2 = retrieve2;
exports.retrieve3 = retrieve3;
exports.slice = slice;
exports.normalizeCssArray = normalizeCssArray;
exports.assert = assert;
exports.trim = trim;
exports.setAsPrimitive = setAsPrimitive;
exports.isPrimitive = isPrimitive;
exports.createHashMap = createHashMap;
exports.concatArray = concatArray;
exports.noop = noop;
exports.createCanvas = void 0;

/**
 * @module zrender/core/util
 */
// 用于处理merge时无法遍历Date等对象的问题
var BUILTIN_OBJECT = {
  '[object Function]': 1,
  '[object RegExp]': 1,
  '[object Date]': 1,
  '[object Error]': 1,
  '[object CanvasGradient]': 1,
  '[object CanvasPattern]': 1,
  // For node-canvas
  '[object Image]': 1,
  '[object Canvas]': 1
};
var TYPED_ARRAY = {
  '[object Int8Array]': 1,
  '[object Uint8Array]': 1,
  '[object Uint8ClampedArray]': 1,
  '[object Int16Array]': 1,
  '[object Uint16Array]': 1,
  '[object Int32Array]': 1,
  '[object Uint32Array]': 1,
  '[object Float32Array]': 1,
  '[object Float64Array]': 1
};
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 nativeReduce = arrayProto.reduce; // Avoid assign to an exported variable, for transforming to cjs.

var methods = {};

function $override(name, fn) {
  // Clear ctx instance for different environment
  if (name === 'createCanvas') {
    _ctx = null;
  }

  methods[name] = fn;
}
/**
 * Those data types can be cloned:
 *     Plain object, Array, TypedArray, number, string, null, undefined.
 * Those data types will be assgined using the orginal data:
 *     BUILTIN_OBJECT
 * Instance of user defined class will be cloned to a plain object, without
 * properties in prototype.
 * Other data types is not supported (not sure what will happen).
 *
 * Caution: do not support clone Date, for performance consideration.
 * (There might be a large number of date in `series.data`).
 * So date should not be modified in and out of echarts.
 *
 * @param {*} source
 * @return {*} new
 */


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 (source.constructor.from) {
        result = Ctor.from(source);
      } else {
        result = new Ctor(source.length);

        for (var i = 0, len = source.length; i < len; i++) {
          result[i] = clone(source[i]);
        }
      }
    }
  } else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {
    result = {};

    for (var key in source) {
      if (source.hasOwnProperty(key)) {
        result[key] = clone(source[key]);
      }
    }
  }

  return result;
}
/**
 * @memberOf module:zrender/core/util
 * @param {*} target
 * @param {*} source
 * @param {boolean} [overwrite=false]
 */


function merge(target, source, overwrite) {
  // We should escapse that source is string
  // and enter for ... in ...
  if (!isObject(source) || !isObject(target)) {
    return overwrite ? clone(source) : target;
  }

  for (var key in source) {
    if (source.hasOwnProperty(key)) {
      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
        merge(targetProp, sourceProp, overwrite);
      } else if (overwrite || !(key in target)) {
        // 否则只处理overwrite为true，或者在目标对象中没有此属性的情况
        // NOTE，在 target[key] 不存在的时候也是直接覆盖
        target[key] = clone(source[key], true);
      }
    }
  }

  return target;
}
/**
 * @param {Array} targetAndSources The first item is target, and the rests are source.
 * @param {boolean} [overwrite=false]
 * @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;
}
/**
 * @param {*} target
 * @param {*} source
 * @memberOf module:zrender/core/util
 */


function extend(target, source) {
  for (var key in source) {
    if (source.hasOwnProperty(key)) {
      target[key] = source[key];
    }
  }

  return target;
}
/**
 * @param {*} target
 * @param {*} source
 * @param {boolean} [overlay=false]
 * @memberOf module:zrender/core/util
 */


function defaults(target, source, overlay) {
  for (var key in source) {
    if (source.hasOwnProperty(key) && (overlay ? source[key] != null : target[key] == null)) {
      target[key] = source[key];
    }
  }

  return target;
}

var createCanvas = function () {
  return methods.createCanvas();
};

exports.createCanvas = createCanvas;

methods.createCanvas = function () {
  return document.createElement('canvas');
}; // FIXME


var _ctx;

function getContext() {
  if (!_ctx) {
    // Use util.createCanvas instead of createCanvas
    // because createCanvas may be overwritten in different environment
    _ctx = createCanvas().getContext('2d');
  }

  return _ctx;
}
/**
 * 查询数组中元素的index
 * @memberOf module:zrender/core/util
 */


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;
}
/**
 * 构造类继承关系
 *
 * @memberOf module:zrender/core/util
 * @param {Function} clazz 源类
 * @param {Function} baseClazz 基类
 */


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;
}
/**
 * @memberOf module:zrender/core/util
 * @param {Object|Function} target
 * @param {Object|Function} sorce
 * @param {boolean} overlay
 */


function mixin(target, source, overlay) {
  target = 'prototype' in target ? target.prototype : target;
  source = 'prototype' in source ? source.prototype : source;
  defaults(target, source, overlay);
}
/**
 * Consider typed array.
 * @param {Array|TypedArray} data
 */


function isArrayLike(data) {
  if (!data) {
    return;
  }

  if (typeof data === 'string') {
    return false;
  }

  return typeof data.length === 'number';
}
/**
 * 数组或对象遍历
 * @memberOf module:zrender/core/util
 * @param {Object|Array} obj
 * @param {Function} cb
 * @param {*} [context]
 */


function each(obj, cb, context) {
  if (!(obj && cb)) {
    return;
  }

  if (obj.forEach && obj.forEach === nativeForEach) {
    obj.forEach(cb, context);
  } else if (obj.length === +obj.length) {
    for (var i = 0, len = obj.length; i < len; i++) {
      cb.call(context, obj[i], i, obj);
    }
  } else {
    for (var key in obj) {
      if (obj.hasOwnProperty(key)) {
        cb.call(context, obj[key], key, obj);
      }
    }
  }
}
/**
 * 数组映射
 * @memberOf module:zrender/core/util
 * @param {Array} obj
 * @param {Function} cb
 * @param {*} [context]
 * @return {Array}
 */


function map(obj, cb, context) {
  if (!(obj && cb)) {
    return;
  }

  if (obj.map && obj.map === nativeMap) {
    return obj.map(cb, context);
  } else {
    var result = [];

    for (var i = 0, len = obj.length; i < len; i++) {
      result.push(cb.call(context, obj[i], i, obj));
    }

    return result;
  }
}
/**
 * @memberOf module:zrender/core/util
 * @param {Array} obj
 * @param {Function} cb
 * @param {Object} [memo]
 * @param {*} [context]
 * @return {Array}
 */


function reduce(obj, cb, memo, context) {
  if (!(obj && cb)) {
    return;
  }

  if (obj.reduce && obj.reduce === nativeReduce) {
    return obj.reduce(cb, memo, context);
  } else {
    for (var i = 0, len = obj.length; i < len; i++) {
      memo = cb.call(context, memo, obj[i], i, obj);
    }

    return memo;
  }
}
/**
 * 数组过滤
 * @memberOf module:zrender/core/util
 * @param {Array} obj
 * @param {Function} cb
 * @param {*} [context]
 * @return {Array}
 */


function filter(obj, cb, context) {
  if (!(obj && cb)) {
    return;
  }

  if (obj.filter && obj.filter === nativeFilter) {
    return obj.filter(cb, context);
  } else {
    var result = [];

    for (var i = 0, len = obj.length; i < len; i++) {
      if (cb.call(context, obj[i], i, obj)) {
        result.push(obj[i]);
      }
    }

    return result;
  }
}
/**
 * 数组项查找
 * @memberOf module:zrender/core/util
 * @param {Array} obj
 * @param {Function} cb
 * @param {*} [context]
 * @return {*}
 */


function find(obj, cb, context) {
  if (!(obj && cb)) {
    return;
  }

  for (var i = 0, len = obj.length; i < len; i++) {
    if (cb.call(context, obj[i], i, obj)) {
      return obj[i];
    }
  }
}
/**
 * @memberOf module:zrender/core/util
 * @param {Function} func
 * @param {*} context
 * @return {Function}
 */


function bind(func, context) {
  var args = nativeSlice.call(arguments, 2);
  return function () {
    return func.apply(context, args.concat(nativeSlice.call(arguments)));
  };
}
/**
 * @memberOf module:zrender/core/util
 * @param {Function} func
 * @return {Function}
 */


function curry(func) {
  var args = nativeSlice.call(arguments, 1);
  return function () {
    return func.apply(this, args.concat(nativeSlice.call(arguments)));
  };
}
/**
 * @memberOf module:zrender/core/util
 * @param {*} value
 * @return {boolean}
 */


function isArray(value) {
  return objToString.call(value) === '[object Array]';
}
/**
 * @memberOf module:zrender/core/util
 * @param {*} value
 * @return {boolean}
 */


function isFunction(value) {
  return typeof value === 'function';
}
/**
 * @memberOf module:zrender/core/util
 * @param {*} value
 * @return {boolean}
 */


function isString(value) {
  return objToString.call(value) === '[object String]';
}
/**
 * @memberOf module:zrender/core/util
 * @param {*} value
 * @return {boolean}
 */


function isObject(value) {
  // Avoid a V8 JIT bug in Chrome 19-20.
  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
  var type = typeof value;
  return type === 'function' || !!value && type === 'object';
}
/**
 * @memberOf module:zrender/core/util
 * @param {*} value
 * @return {boolean}
 */


function isBuiltInObject(value) {
  return !!BUILTIN_OBJECT[objToString.call(value)];
}
/**
 * @memberOf module:zrender/core/util
 * @param {*} value
 * @return {boolean}
 */


function isTypedArray(value) {
  return !!TYPED_ARRAY[objToString.call(value)];
}
/**
 * @memberOf module:zrender/core/util
 * @param {*} value
 * @return {boolean}
 */


function isDom(value) {
  return typeof value === 'object' && typeof value.nodeType === 'number' && typeof value.ownerDocument === 'object';
}
/**
 * Whether is exactly NaN. Notice isNaN('a') returns true.
 * @param {*} value
 * @return {boolean}
 */


function eqNaN(value) {
  /* eslint-disable-next-line no-self-compare */
  return value !== value;
}
/**
 * If value1 is not null, then return value1, otherwise judget rest of values.
 * Low performance.
 * @memberOf module:zrender/core/util
 * @return {*} Final value
 */


function retrieve(values) {
  for (var i = 0, len = arguments.length; i < len; i++) {
    if (arguments[i] != null) {
      return arguments[i];
    }
  }
}

function retrieve2(value0, value1) {
  return value0 != null ? value0 : value1;
}

function retrieve3(value0, value1, value2) {
  return value0 != null ? value0 : value1 != null ? value1 : value2;
}
/**
 * @memberOf module:zrender/core/util
 * @param {Array} arr
 * @param {number} startIndex
 * @param {number} endIndex
 * @return {Array}
 */


function slice() {
  return Function.call.apply(nativeSlice, arguments);
}
/**
 * Normalize css liked array configuration
 * e.g.
 *  3 => [3, 3, 3, 3]
 *  [4, 2] => [4, 2, 4, 2]
 *  [4, 3, 2] => [4, 3, 2, 3]
 * @param {number|Array.<number>} val
 * @return {Array.<number>}
 */


function normalizeCssArray(val) {
  if (typeof val === 'number') {
    return [val, val, val, val];
  }

  var len = val.length;

  if (len === 2) {
    // vertical | horizontal
    return [val[0], val[1], val[0], val[1]];
  } else if (len === 3) {
    // top | horizontal | bottom
    return [val[0], val[1], val[2], val[1]];
  }

  return val;
}
/**
 * @memberOf module:zrender/core/util
 * @param {boolean} condition
 * @param {string} message
 */


function assert(condition, message) {
  if (!condition) {
    throw new Error(message);
  }
}
/**
 * @memberOf module:zrender/core/util
 * @param {string} str string to be trimed
 * @return {string} trimed string
 */


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__';
/**
 * Set an object as primitive to be ignored traversing children in clone or merge
 */

function setAsPrimitive(obj) {
  obj[primitiveKey] = true;
}

function isPrimitive(obj) {
  return obj[primitiveKey];
}
/**
 * @constructor
 * @param {Object} obj Only apply `ownProperty`.
 */


function HashMap(obj) {
  var isArr = isArray(obj); // Key should not be set on this, otherwise
  // methods get/set/... may be overrided.

  this.data = {};
  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 = {
  constructor: HashMap,
  // Do not provide `has` method to avoid defining what is `has`.
  // (We usually treat `null` and `undefined` as the same, different
  // from ES6 Map).
  get: function (key) {
    return this.data.hasOwnProperty(key) ? this.data[key] : null;
  },
  set: function (key, value) {
    // Comparing with invocation chaining, `return value` is more commonly
    // used in this case: `var someVal = map.set('a', genVal());`
    return this.data[key] = value;
  },
  // Although util.each can be performed on this hashMap directly, user
  // should not use the exposed keys, who are prefixed.
  each: function (cb, context) {
    context !== void 0 && (cb = bind(cb, context));
    /* eslint-disable guard-for-in */

    for (var key in this.data) {
      this.data.hasOwnProperty(key) && cb(this.data[key], key);
    }
    /* eslint-enable guard-for-in */

  },
  // Do not use this method if performance sensitive.
  removeKey: function (key) {
    delete this.data[key];
  }
};

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 (i = 0; i < b.length; i++) {
    newArray[i + offset] = b[i];
  }

  return newArray;
}

function noop() {}

/***/ })
/******/ ])["default"];
});
//# sourceMappingURL=vancharts-all.js.map

})();