text: (function webpackUniversalModuleDefinition(root, factory) {
      if (typeof exports === 'object' && typeof module === 'object')
          module.exports = factory(require("echarts"));
      else if (typeof define === 'function' && define.amd)
          define(["echarts"], factory);
      else if (typeof exports === 'object')
          exports["dataTool"] = factory(require("echarts"));
      else
          root["echarts"] = root["echarts"] || {}, root["echarts"]["dataTool"] = factory(root["echarts"]);
  })(this, function (__WEBPACK_EXTERNAL_MODULE_1__) {
      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] = {
                  /******/            exports: {},
                  /******/            id: moduleId,
                  /******/            loaded: false
                  /******/
              };
  
              /******/ 		// Execute the module function
              /******/
              modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
              /******/ 		// Flag the module as loaded
              /******/
              module.loaded = 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;
  
          /******/ 	// __webpack_public_path__
          /******/
          __webpack_require__.p = "";
  
          /******/ 	// Load entry module and return exports
          /******/
          return __webpack_require__(0);
          /******/
      })
      /************************************************************************/
      /******/([
          /* 0 */
          /***/ function (module, exports, __webpack_require__) {
  
              var __WEBPACK_AMD_DEFINE_RESULT__;
              !(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
                  var echarts = __webpack_require__(1);
                  echarts.dataTool = {
                      version: '1.0.0',
                      gexf: __webpack_require__(5),
                      prepareBoxplotData: __webpack_require__(6)
                  };
                  return echarts.dataTool;
              }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  
              /***/
          },
          /* 1 */
          /***/ function (module, exports) {
  
              module.exports = __WEBPACK_EXTERNAL_MODULE_1__;
  
              /***/
          },
          /* 2 */,
          /* 3 */,
          /* 4 */,
          /* 5 */
          /***/ function (module, exports, __webpack_require__) {
  
              var __WEBPACK_AMD_DEFINE_RESULT__;// GEXF File Parser
              // http://gexf.net/1.2draft/gexf-12draft-primer.pdf
              !(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
  
                  'use strict';
                  var zrUtil = __webpack_require__(1).util;
  
                  function parse(xml) {
                      var doc;
                      if (typeof xml === 'string') {
                          var parser = new DOMParser();
                          doc = parser.parseFromString(xml, 'text/xml');
                      } else {
                          doc = xml;
                      }
                      if (!doc || doc.getElementsByTagName('parsererror').length) {
                          return null;
                      }
  
                      var gexfRoot = getChildByTagName(doc, 'gexf');
  
                      if (!gexfRoot) {
                          return null;
                      }
  
                      var graphRoot = getChildByTagName(gexfRoot, 'graph');
  
                      var attributes = parseAttributes(getChildByTagName(graphRoot, 'attributes'));
                      var attributesMap = {};
                      for (var i = 0; i < attributes.length; i++) {
                          attributesMap[attributes[i].id] = attributes[i];
                      }
  
                      return {
                          nodes: parseNodes(getChildByTagName(graphRoot, 'nodes'), attributesMap),
                          links: parseEdges(getChildByTagName(graphRoot, 'edges'))
                      };
                  }
  
                  function parseAttributes(parent) {
                      return parent ? zrUtil.map(getChildrenByTagName(parent, 'attribute'), function (attribDom) {
                          return {
                              id: getAttr(attribDom, 'id'),
                              title: getAttr(attribDom, 'title'),
                              type: getAttr(attribDom, 'type')
                          };
                      }) : [];
                  }
  
                  function parseNodes(parent, attributesMap) {
                      return parent ? zrUtil.map(getChildrenByTagName(parent, 'node'), function (nodeDom) {
  
                          var id = getAttr(nodeDom, 'id');
                          var label = getAttr(nodeDom, 'label');
  
                          var node = {
                              id: id,
                              name: label,
                              itemStyle: {
                                  normal: {}
                              }
                          };
  
                          var vizSizeDom = getChildByTagName(nodeDom, 'viz:size');
                          var vizPosDom = getChildByTagName(nodeDom, 'viz:position');
                          var vizColorDom = getChildByTagName(nodeDom, 'viz:color');
                          // var vizShapeDom = getChildByTagName(nodeDom, 'viz:shape');
  
                          var attvaluesDom = getChildByTagName(nodeDom, 'attvalues');
  
                          if (vizSizeDom) {
                              node.symbolSize = parseFloat(getAttr(vizSizeDom, 'value'));
                          }
                          if (vizPosDom) {
                              node.x = parseFloat(getAttr(vizPosDom, 'x'));
                              node.y = parseFloat(getAttr(vizPosDom, 'y'));
                              // z
                          }
                          if (vizColorDom) {
                              node.itemStyle.normal.color = 'rgb(' + [
                                  getAttr(vizColorDom, 'r') | 0,
                                  getAttr(vizColorDom, 'g') | 0,
                                  getAttr(vizColorDom, 'b') | 0
                              ].join(',') + ')';
                          }
                          // if (vizShapeDom) {
                          // node.shape = getAttr(vizShapeDom, 'shape');
                          // }
                          if (attvaluesDom) {
                              var attvalueDomList = getChildrenByTagName(attvaluesDom, 'attvalue');
  
                              node.attributes = {};
  
                              for (var j = 0; j < attvalueDomList.length; j++) {
                                  var attvalueDom = attvalueDomList[j];
                                  var attId = getAttr(attvalueDom, 'for');
                                  var attValue = getAttr(attvalueDom, 'value');
                                  var attribute = attributesMap[attId];
  
                                  if (attribute) {
                                      switch (attribute.type) {
                                          case 'integer':
                                          case 'long':
                                              attValue = parseInt(attValue, 10);
                                              break;
                                          case 'float':
                                          case 'double':
                                              attValue = parseFloat(attValue);
                                              break;
                                          case 'boolean':
                                              attValue = attValue.toLowerCase() == 'true';
                                              break;
                                          default:
                                      }
                                      node.attributes[attId] = attValue;
                                  }
                              }
                          }
  
                          return node;
                      }) : [];
                  }
  
                  function parseEdges(parent) {
                      return parent ? zrUtil.map(getChildrenByTagName(parent, 'edge'), function (edgeDom) {
                          var id = getAttr(edgeDom, 'id');
                          var label = getAttr(edgeDom, 'label');
  
                          var sourceId = getAttr(edgeDom, 'source');
                          var targetId = getAttr(edgeDom, 'target');
  
                          var edge = {
                              id: id,
                              name: label,
                              source: sourceId,
                              target: targetId,
                              lineStyle: {
                                  normal: {}
                              }
                          };
  
                          var lineStyle = edge.lineStyle.normal;
  
                          var vizThicknessDom = getChildByTagName(edgeDom, 'viz:thickness');
                          var vizColorDom = getChildByTagName(edgeDom, 'viz:color');
                          // var vizShapeDom = getChildByTagName(edgeDom, 'viz:shape');
  
                          if (vizThicknessDom) {
                              lineStyle.width = parseFloat(vizThicknessDom.getAttribute('value'));
                          }
                          if (vizColorDom) {
                              lineStyle.color = 'rgb(' + [
                                  getAttr(vizColorDom, 'r') | 0,
                                  getAttr(vizColorDom, 'g') | 0,
                                  getAttr(vizColorDom, 'b') | 0
                              ].join(',') + ')';
                          }
                          // if (vizShapeDom) {
                          //     edge.shape = vizShapeDom.getAttribute('shape');
                          // }
  
                          return edge;
                      }) : [];
                  }
  
                  function getAttr(el, attrName) {
                      return el.getAttribute(attrName);
                  }
  
                  function getChildByTagName(parent, tagName) {
                      var node = parent.firstChild;
  
                      while (node) {
                          if (
                              node.nodeType != 1 ||
                              node.nodeName.toLowerCase() != tagName.toLowerCase()
                          ) {
                              node = node.nextSibling;
                          } else {
                              return node;
                          }
                      }
  
                      return null;
                  }
  
                  function getChildrenByTagName(parent, tagName) {
                      var node = parent.firstChild;
                      var children = [];
                      while (node) {
                          if (node.nodeName.toLowerCase() == tagName.toLowerCase()) {
                              children.push(node);
                          }
                          node = node.nextSibling;
                      }
  
                      return children;
                  }
  
                  return {
                      parse: parse
                  };
              }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  
              /***/
          },
          /* 6 */
          /***/ function (module, exports, __webpack_require__) {
  
              var __WEBPACK_AMD_DEFINE_RESULT__;
              !(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
  
                  var quantile = __webpack_require__(7);
                  var numberUtil = __webpack_require__(1).number;
  
                  /**
                   * Helper method for preparing data.
                   * @param {Array.<number>} rawData like
                   *        [
                   *            [12,232,443], (raw data set for the first box)
                   *            [3843,5545,1232], (raw datat set for the second box)
                   *            ...
                   *        ]
                   * @param {Object} [opt]
                   *
                   * @param {(number|string)} [opt.boundIQR=1.5] Data less than min bound is outlier.
                   *                          default 1.5, means Q1 - 1.5 * (Q3 - Q1).
                   *                          If pass 'none', min bound will not be used.
                   * @param {(number|string)} [opt.layout='horizontal']
                   *                          Box plot layout, can be 'horizontal' or 'vertical'
                   */
                  return function (rawData, opt) {
                      opt = opt || [];
                      var boxData = [];
                      var outliers = [];
                      var axisData = [];
                      var boundIQR = opt.boundIQR;
  
                      for (var i = 0; i < rawData.length; i++) {
                          axisData.push(i + '');
                          var ascList = numberUtil.asc(rawData[i].slice());
  
                          var Q1 = quantile(ascList, 0.25);
                          var Q2 = quantile(ascList, 0.5);
                          var Q3 = quantile(ascList, 0.75);
                          var IQR = Q3 - Q1;
  
                          var low = boundIQR === 'none'
                              ? ascList[0]
                              : Q1 - (boundIQR == null ? 1.5 : boundIQR) * IQR;
                          var high = boundIQR === 'none'
                              ? ascList[ascList.length - 1]
                              : Q3 + (boundIQR == null ? 1.5 : boundIQR) * IQR;
  
                          boxData.push([low, Q1, Q2, Q3, high]);
  
                          for (var j = 0; j < ascList.length; j++) {
                              var dataItem = ascList[j];
                              if (dataItem < low || dataItem > high) {
                                  var outlier = [i, dataItem];
                                  opt.layout === 'vertical' && outlier.reverse();
                                  outliers.push(outlier);
                              }
                          }
                      }
                      return {
                          boxData: boxData,
                          outliers: outliers,
                          axisData: axisData
                      };
                  };
  
              }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  
              /***/
          },
          /* 7 */
          /***/ function (module, exports, __webpack_require__) {
  
              var __WEBPACK_AMD_DEFINE_RESULT__;
              /**
               * Copyright (c) 2010-2015, Michael Bostock
               * All rights reserved.
               *
               * Redistribution and use 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.
               *
               * * The name Michael Bostock may not be used to endorse or promote products
               *   derived from this software without specific prior written permission.
               *
               * 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 MICHAEL BOSTOCK 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.
               */
              !(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
  
                  /**
                   * @see <https://github.com/mbostock/d3/blob/master/src/arrays/quantile.js>
                   * @see <http://en.wikipedia.org/wiki/Quantile>
                   * @param {Array.<number>} ascArr
                   */
                  return function (ascArr, p) {
                      var H = (ascArr.length - 1) * p + 1,
                          h = Math.floor(H),
                          v = +ascArr[h - 1],
                          e = H - h;
                      return e ? v + e * (ascArr[h] - v) : v;
                  };
  
              }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  
              /***/
          }
          /******/])
  });
  ;