(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__));

/***/ }
/******/ ])
});
;