code

+console.error('code.highcharts.local has moved to the /code folder'); // eslint-disable-line no-console

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * 3D features for Highcharts JS
+ *
+ * @license: www.highcharts.com/license
+ */
+'use strict';
+import '../parts-3d/Math.js';
+import '../parts-3d/SVGRenderer.js';
+import '../parts-3d/Chart.js';
+import '../parts-3d/Axis.js';
+import '../parts-3d/Series.js';
+import '../parts-3d/Column.js';
+import '../parts-3d/Pie.js';
+import '../parts-3d/Scatter.js';
+import '../parts-3d/VMLRenderer.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2016 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../parts-more/Pane.js';
+import '../parts-more/RadialAxis.js';
+import '../parts-more/AreaRangeSeries.js';
+import '../parts-more/AreaSplineRangeSeries.js';
+import '../parts-more/ColumnRangeSeries.js';
+import '../parts-more/GaugeSeries.js';
+import '../parts-more/BoxPlotSeries.js';
+import '../parts-more/ErrorBarSeries.js';
+import '../parts-more/WaterfallSeries.js';
+import '../parts-more/PolygonSeries.js';
+import '../parts-more/BubbleSeries.js';
+import '../parts-more/Polar.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2016 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import Highcharts from '../parts/Globals.js';
+import '../parts/SvgRenderer.js';
+import '../parts/Html.js';
+import '../parts/Axis.js';
+import '../parts/DateTimeAxis.js';
+import '../parts/LogarithmicAxis.js';
+import '../parts/PlotLineOrBand.js';
+import '../parts/Tooltip.js';
+import '../parts/Pointer.js';
+import '../parts/TouchPointer.js';
+import '../parts/MSPointer.js';
+import '../parts/Legend.js';
+import '../parts/Chart.js';
+import '../parts/ScrollablePlotArea.js';
+import '../parts/Stacking.js';
+import '../parts/Dynamics.js';
+import '../parts/AreaSeries.js';
+import '../parts/SplineSeries.js';
+import '../parts/AreaSplineSeries.js';
+import '../parts/ColumnSeries.js';
+import '../parts/BarSeries.js';
+import '../parts/ScatterSeries.js';
+import '../parts/PieSeries.js';
+import '../parts/DataLabels.js';
+import '../modules/overlapping-datalabels.src.js';
+import '../parts/Interaction.js';
+import '../parts/Responsive.js';
+export default Highcharts;

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Accessibility module
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Oystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/a11y-i18n.src.js';
+import '../../modules/screen-reader.src.js';
+import '../../modules/keyboard-navigation.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Annotations module
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/annotations.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Arrow Symbols
+ *
+ * (c) 2017 Lars A. V. Cabrera
+ *
+ * --- WORK IN PROGRESS ---
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../parts-gantt/ArrowSymbols.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Boost module
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/boost-canvas.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Boost module
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/boost.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/broken-axis.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * Bullet graph series type for Highcharts
+ *
+ * (c) 2010-2017 Kacper Madej
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/bullet.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * CurrentDateIndicator
+ *
+ * (c) 2010-2016 Lars A. V. Cabrera
+ *
+ * --- WORK IN PROGRESS ---
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../parts-gantt/CurrentDateIndicator.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Data module
+ *
+ * (c) 2012-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/data.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Drag-panes module
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Kacper Madej
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/drag-panes.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/draggable-points.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Highcharts Drilldown module
+ *
+ * Author: Torstein Honsi
+ * License: www.highcharts.com/license
+ *
+ */
+'use strict';
+import '../../modules/drilldown.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Exporting module
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/export-data.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Exporting module
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/exporting.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Highcharts funnel module
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/funnel.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Gantt series
+ *
+ * (c) 2016 Lars A. V. Cabrera
+ *
+ * --- WORK IN PROGRESS ---
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../parts-gantt/GanttSeries.js';
+import '../../parts-gantt/GanttChart.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * GridAxis
+ *
+ * (c) 2016 Lars A. V. Cabrera
+ *
+ * --- WORK IN PROGRESS ---
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../parts-gantt/GridAxis.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../parts-map/ColorAxis.js';
+import '../../parts-map/ColorSeriesMixin.js';
+import '../../parts-map/HeatmapSeries.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Sebastian Domas
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/histogram.src.js';
+import '../../modules/bellcurve.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * Item series type for Highcharts
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/item-series.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Plugin for displaying a message when there is no data visible in chart.
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Oystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/no-data-to-display.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Client side exporting module
+ *
+ * (c) 2015 Torstein Honsi / Oystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/offline-exporting.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Old IE (v6, v7, v8) module for Highcharts v6+.
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/oldie.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/overlapping-datalabels.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * Support for parallel coordinates in Highcharts
+ *
+ * (c) 2010-2017 Pawel Fus
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/parallel-coordinates.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * Pareto series type for Highcharts
+ *
+ * (c) 2010-2017 Sebastian Bochan
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/pareto.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Pathfinder
+ *
+ * (c) 2016 Øystein Moseng
+ *
+ * --- WORK IN PROGRESS ---
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../parts-gantt/Pathfinder.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Module for adding patterns and images as point fills.
+ *
+ * (c) 2010-2018 Highsoft AS
+ * Author: Torstein Hønsi, Øystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/pattern-fill.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ * Sankey diagram module
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/sankey.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/series-label.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ * Solid angular gauge module
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/solid-gauge.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * StaticScale
+ *
+ * (c) 2016 Torstein Honsi, Lars A. V. Cabrera
+ *
+ * --- WORK IN PROGRESS ---
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/static-scale.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Highstock as a plugin for Highcharts
+ *
+ * (c) 2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../parts/OrdinalAxis.js';
+import './broken-axis.src.js';
+import '../../parts/DataGrouping.js';
+import '../../parts/OHLCSeries.js';
+import '../../parts/CandlestickSeries.js';
+import '../../parts/FlagsSeries.js';
+import '../../parts/Scrollbar.js';
+import '../../parts/Navigator.js';
+import '../../parts/RangeSelector.js';
+import '../../parts/StockChart.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ * Streamgraph module
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/streamgraph.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2016 Highsoft AS
+ * Authors: Jon Arild Nygard
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/sunburst.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ * Tilemap module
+ *
+ * (c) 2010-2017 Highsoft AS
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/tilemap.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * Tree Grid
+ *
+ * (c) 2016 Jon Arild Nygard
+ *
+ * --- WORK IN PROGRESS ---
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../parts-gantt/TreeGrid.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2014 Highsoft AS
+ * Authors: Jon Arild Nygard / Oystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/treemap.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * Variable Pie module for Highcharts
+ *
+ * (c) 2010-2017 Grzegorz Blachliński
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/variable-pie.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ * Highcharts variwide module
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/variwide.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ * Vector plot series module
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/vector.src.js';

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ * Wind barb series module
+ *
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/windbarb.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2016 Highsoft AS
+ * Authors: Jon Arild Nygard
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/wordcloud.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ * X-range series
+ *
+ * (c) 2010-2018 Torstein Honsi, Lars A. V. Cabrera
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../modules/xrange.src.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2017 Highsoft AS
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/avocado.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2017 Highsoft AS
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/avocado.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/dark-blue.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/dark-green.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/dark-unica.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/gray.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/grid-light.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/grid.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/sand-signika.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/skies.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2017 Highsoft AS
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/sunset.js';

+/**
+ * @license @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2009-2017 Highsoft AS
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import '../../themes/sunset.js';

+/**
+ * (c) 2010-2017 Christer Vasseng, Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import H from '../parts/Globals.js';
+/**
+ * @typedef {Object} AjaxSettings
+ * @property {String} url - The URL to call
+ * @property {('get'|'post'|'update'|'delete')} type - The verb to use
+ * @property {('json'|'xml'|'text'|'octet')} dataType - The data type expected
+ * @property {Function} success - Function to call on success
+ * @property {Function} error - Function to call on error
+ * @property {Object} data - The payload to send
+ * @property {Object} headers - The headers; keyed on header name
+ */
+
+/**
+ * Perform an Ajax call.
+ *
+ * @memberof Highcharts
+ * @param {AjaxSettings} - The Ajax settings to use
+ *
+ */
+H.ajax = function (attr) {
+    var options = H.merge(true, {
+            url: false,
+            type: 'GET',
+            dataType: 'json',
+            success: false,
+            error: false,
+            data: false,
+            headers: {}
+        }, attr),
+        headers = {
+            json: 'application/json',
+            xml: 'application/xml',
+            text: 'text/plain',
+            octet: 'application/octet-stream'
+        },
+        r = new XMLHttpRequest();
+
+    function handleError(xhr, err) {
+        if (options.error) {
+            options.error(xhr, err);
+        } else {
+            // Maybe emit a highcharts error event here
+        }
+    }
+
+    if (!options.url) {
+        return false;
+    }
+
+    r.open(options.type.toUpperCase(), options.url, true);
+    r.setRequestHeader(
+        'Content-Type',
+        headers[options.dataType] || headers.text
+    );
+
+    H.objectEach(options.headers, function (val, key) {
+        r.setRequestHeader(key, val);
+    });
+
+    r.onreadystatechange = function () {
+        var res;
+
+        if (r.readyState === 4) {
+            if (r.status === 200) {
+                res = r.responseText;
+                if (options.dataType === 'json') {
+                    try {
+                        res = JSON.parse(res);
+                    } catch (e) {
+                        return handleError(r, e);
+                    }
+                }
+                return options.success && options.success(res);
+            }
+
+            handleError(r, r.responseText);
+        }
+    };
+
+    try {
+        options.data = JSON.stringify(options.data);
+    } catch (e) {}
+
+    r.send(options.data || true);
+};

+/**
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+/**
+ * @private
+ * @typedef Highcharts.RadianAngles
+ *
+ * @property {number} start
+ *
+ * @property {number} end
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+
+var deg2rad = H.deg2rad,
+    isNumber = H.isNumber,
+    pick = H.pick,
+    relativeLength = H.relativeLength;
+
+/**
+ * @private
+ * @mixin Highcharts.CenteredSeriesMixin
+ */
+H.CenteredSeriesMixin = {
+
+    /**
+     * Get the center of the pie based on the size and center options relative
+     * to the plot area. Borrowed by the polar and gauge series types.
+     *
+     * @private
+     * @function Highcharts.CenteredSeriesMixin.getCenter
+     *
+     * @return {Array<number>}
+     */
+    getCenter: function () {
+
+        var options = this.options,
+            chart = this.chart,
+            slicingRoom = 2 * (options.slicedOffset || 0),
+            handleSlicingRoom,
+            plotWidth = chart.plotWidth - 2 * slicingRoom,
+            plotHeight = chart.plotHeight - 2 * slicingRoom,
+            centerOption = options.center,
+            positions = [
+                pick(centerOption[0], '50%'),
+                pick(centerOption[1], '50%'),
+                options.size || '100%',
+                options.innerSize || 0
+            ],
+            smallestSize = Math.min(plotWidth, plotHeight),
+            i,
+            value;
+
+        for (i = 0; i < 4; ++i) {
+            value = positions[i];
+            handleSlicingRoom = i < 2 || (i === 2 && /%$/.test(value));
+
+            // i == 0: centerX, relative to width
+            // i == 1: centerY, relative to height
+            // i == 2: size, relative to smallestSize
+            // i == 3: innerSize, relative to size
+            positions[i] = relativeLength(
+                value,
+                [plotWidth, plotHeight, smallestSize, positions[2]][i]
+            ) + (handleSlicingRoom ? slicingRoom : 0);
+
+        }
+        // innerSize cannot be larger than size (#3632)
+        if (positions[3] > positions[2]) {
+            positions[3] = positions[2];
+        }
+        return positions;
+    },
+
+    /**
+     * getStartAndEndRadians - Calculates start and end angles in radians.
+     * Used in series types such as pie and sunburst.
+     *
+     * @private
+     * @function Highcharts.CenteredSeriesMixin.getStartAndEndRadians
+     *
+     * @param {number} start
+     *        Start angle in degrees.
+     *
+     * @param {number} end
+     *        Start angle in degrees.
+     *
+     * @return {Highcharts.RadianAngles}
+     *         Returns an object containing start and end angles as radians.
+     */
+    getStartAndEndRadians: function getStartAndEndRadians(start, end) {
+        var startAngle = isNumber(start) ? start : 0, // must be a number
+            endAngle = (
+                (
+                    isNumber(end) && // must be a number
+                    end > startAngle && // must be larger than the start angle
+                    // difference must be less than 360 degrees
+                    (end - startAngle) < 360
+                ) ?
+                end :
+                startAngle + 360
+            ),
+            correction = -90;
+        return {
+            start: deg2rad * (startAngle + correction),
+            end: deg2rad * (endAngle + correction)
+        };
+    }
+};

+'use strict';
+import H from '../parts/Globals.js';
+import '../parts/Series.js';
+
+var each = H.each,
+    Series = H.Series,
+    addEvent = H.addEvent,
+    noop = H.noop;
+
+
+/* ***************************************************************************
+*
+* DERIVED SERIES MIXIN
+*
+**************************************************************************** */
+
+/**
+ * Provides methods for auto setting/updating series data based on the based
+ * series data.
+ *
+ * @mixin
+ **/
+var derivedSeriesMixin = {
+  /**
+   * Initialise series
+   *
+   * returns {undefined}
+   **/
+    init: function () {
+        Series.prototype.init.apply(this, arguments);
+
+        this.initialised = false;
+        this.baseSeries = null;
+        this.eventRemovers = [];
+
+        this.addEvents();
+    },
+
+  /**
+   * Method to be implemented - inside the method the series has already access
+   * to the base series via m `this.baseSeries` and the bases data is
+   * initialised. It should return data in the format accepted by
+   * `Series.setData()` method
+   *
+   * @returns {Array} - an array of data
+   **/
+    setDerivedData: noop,
+
+  /**
+   * Sets base series for the series
+   *
+   * returns {undefined}
+   **/
+    setBaseSeries: function () {
+        var chart = this.chart,
+            baseSeriesOptions = this.options.baseSeries,
+            baseSeries =
+        baseSeriesOptions &&
+        (chart.series[baseSeriesOptions] || chart.get(baseSeriesOptions));
+
+        this.baseSeries = baseSeries || null;
+    },
+
+  /**
+   * Adds events for the series
+   *
+   * @returns {undefined}
+   **/
+    addEvents: function () {
+        var derivedSeries = this,
+            chartSeriesLinked;
+
+        chartSeriesLinked = addEvent(
+            this.chart,
+            'afterLinkSeries',
+            function () {
+                derivedSeries.setBaseSeries();
+
+                if (derivedSeries.baseSeries && !derivedSeries.initialised) {
+                    derivedSeries.setDerivedData();
+                    derivedSeries.addBaseSeriesEvents();
+                    derivedSeries.initialised = true;
+                }
+            }
+        );
+
+        this.eventRemovers.push(
+            chartSeriesLinked
+        );
+    },
+
+  /**
+   * Adds events to the base series - it required for recalculating the data in
+   * the series if the base series is updated / removed / etc.
+   *
+   * @returns {undefined}
+   **/
+    addBaseSeriesEvents: function () {
+        var derivedSeries = this,
+            updatedDataRemover,
+            destroyRemover;
+
+        updatedDataRemover = addEvent(
+            derivedSeries.baseSeries,
+            'updatedData',
+            function () {
+                derivedSeries.setDerivedData();
+            }
+        );
+
+        destroyRemover = addEvent(
+            derivedSeries.baseSeries,
+            'destroy',
+            function () {
+                derivedSeries.baseSeries = null;
+                derivedSeries.initialised = false;
+            }
+        );
+
+        derivedSeries.eventRemovers.push(
+        updatedDataRemover,
+        destroyRemover
+      );
+    },
+
+  /**
+   * Destroys the series
+   *
+   * @returns {undefined}
+   **/
+    destroy: function () {
+        each(this.eventRemovers, function (remover) {
+            remover();
+        });
+
+        Series.prototype.destroy.apply(this, arguments);
+    }
+};
+
+export default derivedSeriesMixin;

+var isFn = function (x) {
+    return typeof x === 'function';
+};
+
+/**
+ * draw - Handles the drawing of a point.
+ * TODO: add type checking.
+ *
+ * @param  {object} params Parameters.
+ * @return {undefined} Returns undefined.
+ */
+var draw = function draw(params) {
+    var point = this,
+        graphic = point.graphic,
+        animate = params.animate,
+        attr = params.attr,
+        onComplete = params.onComplete,
+        css = params.css,
+        group = params.group,
+        renderer = params.renderer,
+        shape = params.shapeArgs,
+        type = params.shapeType;
+
+    if (point.shouldDraw()) {
+        if (!graphic) {
+            point.graphic = graphic = renderer[type](shape).add(group);
+        }
+        graphic.css(css).attr(attr).animate(animate, undefined, onComplete);
+    } else if (graphic) {
+        graphic.animate(animate, undefined, function () {
+            point.graphic = graphic = graphic.destroy();
+            if (isFn(onComplete)) {
+                onComplete();
+            }
+        });
+    }
+    if (graphic) {
+        graphic.addClass(point.getClassName(), true);
+    }
+};
+
+export default draw;

+/**
+ * (c) 2010-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import H from '../parts/Globals.js';
+
+var each = H.each,
+    defined = H.defined,
+    seriesTypes = H.seriesTypes,
+    stableSort = H.stableSort;
+
+var onSeriesMixin = {
+
+    /**
+     * Override getPlotBox. If the onSeries option is valid, return the plot box
+     * of the onSeries, otherwise proceed as usual.
+     */
+    getPlotBox: function () {
+        return H.Series.prototype.getPlotBox.call(
+            (
+                this.options.onSeries &&
+                this.chart.get(this.options.onSeries)
+            ) || this
+        );
+    },
+
+    /**
+     * Extend the translate method by placing the point on the related series
+     */
+    translate: function () {
+
+        seriesTypes.column.prototype.translate.apply(this);
+
+        var series = this,
+            options = series.options,
+            chart = series.chart,
+            points = series.points,
+            cursor = points.length - 1,
+            point,
+            lastPoint,
+            optionsOnSeries = options.onSeries,
+            onSeries = optionsOnSeries && chart.get(optionsOnSeries),
+            onKey = options.onKey || 'y',
+            step = onSeries && onSeries.options.step,
+            onData = onSeries && onSeries.points,
+            i = onData && onData.length,
+            inverted = chart.inverted,
+            xAxis = series.xAxis,
+            yAxis = series.yAxis,
+            xOffset = 0,
+            leftPoint,
+            lastX,
+            rightPoint,
+            currentDataGrouping,
+            distanceRatio;
+
+        // relate to a master series
+        if (onSeries && onSeries.visible && i) {
+            xOffset = (onSeries.pointXOffset || 0) + (onSeries.barW || 0) / 2;
+            currentDataGrouping = onSeries.currentDataGrouping;
+            lastX = (
+                onData[i - 1].x +
+                (currentDataGrouping ? currentDataGrouping.totalRange : 0)
+            ); // #2374
+
+            // sort the data points
+            stableSort(points, function (a, b) {
+                return (a.x - b.x);
+            });
+
+            onKey = 'plot' + onKey[0].toUpperCase() + onKey.substr(1);
+            while (i-- && points[cursor]) {
+                leftPoint = onData[i];
+                point = points[cursor];
+                point.y = leftPoint.y;
+
+                if (leftPoint.x <= point.x && leftPoint[onKey] !== undefined) {
+                    if (point.x <= lastX) { // #803
+
+                        point.plotY = leftPoint[onKey];
+
+                        // interpolate between points, #666
+                        if (leftPoint.x < point.x && !step) {
+                            rightPoint = onData[i + 1];
+                            if (rightPoint && rightPoint[onKey] !== undefined) {
+                                // the distance ratio, between 0 and 1
+                                distanceRatio = (point.x - leftPoint.x) /
+                                    (rightPoint.x - leftPoint.x);
+                                point.plotY +=
+                                    distanceRatio *
+                                    // the plotY distance
+                                    (rightPoint[onKey] - leftPoint[onKey]);
+                                point.y +=
+                                    distanceRatio *
+                                    (rightPoint.y - leftPoint.y);
+                            }
+                        }
+                    }
+                    cursor--;
+                    i++; // check again for points in the same x position
+                    if (cursor < 0) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Add plotY position and handle stacking
+        each(points, function (point, i) {
+
+            var stackIndex;
+
+            point.plotX += xOffset; // #2049
+
+            // Undefined plotY means the point is either on axis, outside series
+            // range or hidden series. If the series is outside the range of the
+            // x axis it should fall through with an undefined plotY, but then
+            // we must remove the shapeArgs (#847). For inverted charts, we need
+            // to calculate position anyway, because series.invertGroups is not
+            // defined
+            if (point.plotY === undefined || inverted) {
+                if (point.plotX >= 0 && point.plotX <= xAxis.len) {
+                    // We're inside xAxis range
+                    if (inverted) {
+                        point.plotY = xAxis.translate(point.x, 0, 1, 0, 1);
+                        point.plotX = defined(point.y) ?
+                            yAxis.translate(point.y, 0, 0, 0, 1) : 0;
+                    } else {
+                        point.plotY = chart.chartHeight - xAxis.bottom -
+                            (xAxis.opposite ? xAxis.height : 0) +
+                            xAxis.offset - yAxis.top; // #3517
+                    }
+                } else {
+                    point.shapeArgs = {}; // 847
+                }
+            }
+
+            // if multiple flags appear at the same x, order them into a stack
+            lastPoint = points[i - 1];
+            if (lastPoint && lastPoint.plotX === point.plotX) {
+                if (lastPoint.stackIndex === undefined) {
+                    lastPoint.stackIndex = 0;
+                }
+                stackIndex = lastPoint.stackIndex + 1;
+            }
+            point.stackIndex = stackIndex; // #3639
+        });
+
+        this.onSeries = onSeries;
+    }
+};
+export default onSeriesMixin;

+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+var deg2rad = H.deg2rad,
+    find = H.find,
+    isArray = H.isArray,
+    isNumber = H.isNumber,
+    map = H.map,
+    reduce = H.reduce;
+
+/**
+ * Alternative solution to correctFloat.
+ * E.g H.correctFloat(123, 2) returns 120, when it should be 123.
+ */
+var correctFloat = function (number, precision) {
+    var p = isNumber(precision) ? precision : 14,
+        magnitude = Math.pow(10, p);
+    return Math.round(number * magnitude) / magnitude;
+};
+
+/**
+ * Calculates the normals to a line between two points.
+ * @param {Array} p1 Start point for the line. Array of x and y value.
+ * @param {Array} p2 End point for the line. Array of x and y value.
+ * @returns {Array} Returns the two normals in an array.
+ */
+var getNormals = function getNormal(p1, p2) {
+    var dx = p2[0] - p1[0], // x2 - x1
+        dy = p2[1] - p1[1]; // y2 - y1
+    return [
+        [-dy, dx],
+        [dy, -dx]
+    ];
+};
+
+/**
+ * Calculates the dot product of two coordinates. The result is a scalar value.
+ * @param {Array} a The x and y coordinates of the first point.
+ * @param {Array} b The x and y coordinates of the second point.
+ * @returns {Number} Returns the dot product of a and b.
+ */
+var dotProduct = function dotProduct(a, b) {
+    var ax = a[0],
+        ay = a[1],
+        bx = b[0],
+        by = b[1];
+    return ax * bx + ay * by;
+};
+
+/**
+ * Projects a polygon onto a coordinate.
+ * @param {Array} polygon Array of points in a polygon.
+ * @param {Array} target The coordinate of pr
+ */
+var project = function project(polygon, target) {
+    var products = map(polygon, function (point) {
+        return dotProduct(point, target);
+    });
+    return {
+        min: Math.min.apply(this, products),
+        max: Math.max.apply(this, products)
+    };
+};
+
+/**
+ * Rotates a point clockwise around the origin.
+ * @param {Array} point The x and y coordinates for the point.
+ * @param {Number} angle The angle of rotation.
+ * @returns {Array} The x and y coordinate for the rotated point.
+ */
+var rotate2DToOrigin = function (point, angle) {
+    var x = point[0],
+        y = point[1],
+        rad = deg2rad * -angle,
+        cosAngle = Math.cos(rad),
+        sinAngle = Math.sin(rad);
+    return [
+        correctFloat(x * cosAngle - y * sinAngle),
+        correctFloat(x * sinAngle + y * cosAngle)
+    ];
+};
+
+/**
+ * Rotate a point clockwise around another point.
+ * @param {Array} point The x and y coordinates for the point.
+ * @param {Array} origin The point to rotate around.
+ * @param {Number} angle The angle of rotation.
+ * @returns {Array} The x and y coordinate for the rotated point.
+ */
+var rotate2DToPoint = function (point, origin, angle) {
+    var x = point[0] - origin[0],
+        y = point[1] - origin[1],
+        rotated = rotate2DToOrigin([x, y], angle);
+    return [
+        rotated[0] + origin[0],
+        rotated[1] + origin[1]
+    ];
+};
+
+var isAxesEqual = function (axis1, axis2) {
+    return (
+        axis1[0] === axis2[0] &&
+        axis1[1] === axis2[1]
+    );
+};
+
+var getAxesFromPolygon = function (polygon) {
+    var points,
+        axes = polygon.axes;
+    if (!isArray(axes)) {
+        axes = [];
+        points = points = polygon.concat([polygon[0]]);
+        reduce(
+            points,
+            function findAxis(p1, p2) {
+                var normals = getNormals(p1, p2),
+                    axis = normals[0]; // Use the left normal as axis.
+
+                // Check that the axis is unique.
+                if (!find(axes, function (existing) {
+                    return isAxesEqual(existing, axis);
+                })) {
+                    axes.push(axis);
+                }
+
+                // Return p2 to be used as p1 in next iteration.
+                return p2;
+            }
+        );
+        polygon.axes = axes;
+    }
+    return axes;
+};
+
+var getAxes = function (polygon1, polygon2) {
+    // Get the axis from both polygons.
+    var axes1 = getAxesFromPolygon(polygon1),
+        axes2 = getAxesFromPolygon(polygon2);
+    return axes1.concat(axes2);
+};
+
+var getPolygon = function (x, y, width, height, rotation) {
+    var origin = [x, y],
+        left = x - (width / 2),
+        right = x + (width / 2),
+        top = y - (height / 2),
+        bottom = y + (height / 2),
+        polygon = [
+            [left, top],
+            [right, top],
+            [right, bottom],
+            [left, bottom]
+        ];
+    return map(polygon, function (point) {
+        return rotate2DToPoint(point, origin, -rotation);
+    });
+};
+
+var getBoundingBoxFromPolygon = function (points) {
+    return reduce(points, function (obj, point) {
+        var x = point[0],
+            y = point[1];
+        obj.left = Math.min(x, obj.left);
+        obj.right = Math.max(x, obj.right);
+        obj.bottom = Math.max(y, obj.bottom);
+        obj.top = Math.min(y, obj.top);
+        return obj;
+    }, {
+        left: Number.MAX_VALUE,
+        right: -Number.MAX_VALUE,
+        bottom: -Number.MAX_VALUE,
+        top: Number.MAX_VALUE
+    });
+};
+
+var isPolygonsOverlappingOnAxis = function (axis, polygon1, polygon2) {
+    var projection1 = project(polygon1, axis),
+        projection2 = project(polygon2, axis),
+        isOverlapping = !(
+            projection2.min > projection1.max ||
+            projection2.max < projection1.min
+        );
+    return !isOverlapping;
+};
+
+/**
+ * Checks wether two convex polygons are colliding by using the Separating Axis
+ * Theorem.
+ * @param {Array} polygon1 First polygon.
+ * @param {Array} polygon2 Second polygon.
+ * @returns {boolean} Returns true if they are colliding, otherwise false.
+ */
+var isPolygonsColliding = function isPolygonsColliding(polygon1, polygon2) {
+    var axes = getAxes(polygon1, polygon2),
+        overlappingOnAllAxes = !find(axes, function (axis) {
+            return isPolygonsOverlappingOnAxis(axis, polygon1, polygon2);
+        });
+    return overlappingOnAllAxes;
+};
+
+var movePolygon = function (deltaX, deltaY, polygon) {
+    return map(polygon, function (point) {
+        return [
+            point[0] + deltaX,
+            point[1] + deltaY
+        ];
+    });
+};
+
+var collision = {
+    getBoundingBoxFromPolygon: getBoundingBoxFromPolygon,
+    getPolygon: getPolygon,
+    isPolygonsColliding: isPolygonsColliding,
+    movePolygon: movePolygon,
+    rotate2DToOrigin: rotate2DToOrigin,
+    rotate2DToPoint: rotate2DToPoint
+};
+
+export default collision;

+import H from '../parts/Globals.js';
+var each = H.each,
+    extend = H.extend,
+    isArray = H.isArray,
+    isBoolean = function (x) {
+        return typeof x === 'boolean';
+    },
+    isFn = function (x) {
+        return typeof x === 'function';
+    },
+    isObject = H.isObject,
+    isNumber = H.isNumber,
+    merge = H.merge,
+    pick = H.pick,
+    reduce = H.reduce;
+// TODO Combine buildTree and buildNode with setTreeValues
+// TODO Remove logic from Treemap and make it utilize this mixin.
+var setTreeValues = function setTreeValues(tree, options) {
+    var before = options.before,
+        idRoot = options.idRoot,
+        mapIdToNode = options.mapIdToNode,
+        nodeRoot = mapIdToNode[idRoot],
+        levelIsConstant = (
+            isBoolean(options.levelIsConstant) ?
+            options.levelIsConstant :
+            true
+        ),
+        points = options.points,
+        point = points[tree.i],
+        optionsPoint = point && point.options || {},
+        childrenTotal = 0,
+        children = [],
+        value;
+    extend(tree, {
+        levelDynamic: tree.level - (levelIsConstant ? 0 : nodeRoot.level),
+        name: pick(point && point.name, ''),
+        visible: (
+            idRoot === tree.id ||
+            (isBoolean(options.visible) ? options.visible : false)
+        )
+    });
+    if (isFn(before)) {
+        tree = before(tree, options);
+    }
+    // First give the children some values
+    each(tree.children, function (child, i) {
+        var newOptions = extend({}, options);
+        extend(newOptions, {
+            index: i,
+            siblings: tree.children.length,
+            visible: tree.visible
+        });
+        child = setTreeValues(child, newOptions);
+        children.push(child);
+        if (child.visible) {
+            childrenTotal += child.val;
+        }
+    });
+    tree.visible = childrenTotal > 0 || tree.visible;
+    // Set the values
+    value = pick(optionsPoint.value, childrenTotal);
+    extend(tree, {
+        children: children,
+        childrenTotal: childrenTotal,
+        isLeaf: tree.visible && !childrenTotal,
+        val: value
+    });
+    return tree;
+};
+
+var getColor = function getColor(node, options) {
+    var index = options.index,
+        mapOptionsToLevel = options.mapOptionsToLevel,
+        parentColor = options.parentColor,
+        parentColorIndex = options.parentColorIndex,
+        series = options.series,
+        colors = options.colors,
+        siblings = options.siblings,
+        points = series.points,
+        getColorByPoint,
+        point,
+        level,
+        colorByPoint,
+        colorIndexByPoint,
+        color,
+        colorIndex;
+    function variation(color) {
+        var colorVariation = level && level.colorVariation;
+        if (colorVariation) {
+            if (colorVariation.key === 'brightness') {
+                return H.color(color).brighten(
+                    colorVariation.to * (index / siblings)
+                ).get();
+            }
+        }
+
+        return color;
+    }
+
+    if (node) {
+        point = points[node.i];
+        level = mapOptionsToLevel[node.level] || {};
+        getColorByPoint = point && level.colorByPoint;
+
+        if (getColorByPoint) {
+            colorIndexByPoint = point.index % (colors ?
+                colors.length :
+                series.chart.options.chart.colorCount
+            );
+            colorByPoint = colors && colors[colorIndexByPoint];
+        }
+
+        
+        // Select either point color, level color or inherited color.
+        color = pick(
+            point && point.options.color,
+            level && level.color,
+            colorByPoint,
+            parentColor && variation(parentColor),
+            series.color
+        );
+        
+        colorIndex = pick(
+            point && point.options.colorIndex,
+            level && level.colorIndex,
+            colorIndexByPoint,
+            parentColorIndex,
+            options.colorIndex
+        );
+    }
+    return {
+        color: color,
+        colorIndex: colorIndex
+    };
+};
+
+/**
+ * getLevelOptions - Creates a map from level number to its given options.
+ * @param {Object} params Object containing parameters.
+ * @param {Object} params.defaults Object containing default options. The
+ * default options are merged with the userOptions to get the final options for
+ * a specific level.
+ * @param {Number} params.from The lowest level number.
+ * @param {Array} params.levels User options from series.levels.
+ * @param {Number} params.to The highest level number.
+ * @return {null|Object} Returns a map from level number to its given options.
+ * Returns null if invalid input parameters.
+ */
+var getLevelOptions = function getLevelOptions(params) {
+    var result = null,
+        defaults,
+        converted,
+        i,
+        from,
+        to,
+        levels;
+    if (isObject(params)) {
+        result = {};
+        from = isNumber(params.from) ? params.from : 1;
+        levels = params.levels;
+        converted = {};
+        defaults = isObject(params.defaults) ? params.defaults : {};
+        if (isArray(levels)) {
+            converted = reduce(levels, function (obj, item) {
+                var level,
+                    levelIsConstant,
+                    options;
+                if (isObject(item) && isNumber(item.level)) {
+                    options = merge({}, item);
+                    levelIsConstant = (
+                        isBoolean(options.levelIsConstant) ?
+                        options.levelIsConstant :
+                        defaults.levelIsConstant
+                    );
+                    // Delete redundant properties.
+                    delete options.levelIsConstant;
+                    delete options.level;
+                    // Calculate which level these options apply to.
+                    level = item.level + (levelIsConstant ? 0 : from - 1);
+                    if (isObject(obj[level])) {
+                        extend(obj[level], options);
+                    } else {
+                        obj[level] = options;
+                    }
+                }
+                return obj;
+            }, {});
+        }
+        to = isNumber(params.to) ? params.to : 1;
+        for (i = 0; i <= to; i++) {
+            result[i] = merge(
+                {},
+                defaults,
+                isObject(converted[i]) ? converted[i] : {}
+            );
+        }
+    }
+    return result;
+};
+
+/**
+ * Update the rootId property on the series. Also makes sure that it is
+ * accessible to exporting.
+ * @param {object} series The series to operate on.
+ * @returns Returns the resulting rootId after update.
+ */
+var updateRootId = function (series) {
+    var rootId,
+        options;
+    if (isObject(series)) {
+        // Get the series options.
+        options = isObject(series.options) ? series.options : {};
+
+        // Calculate the rootId.
+        rootId = pick(series.rootNode, options.rootId, '');
+
+        // Set rootId on series.userOptions to pick it up in exporting.
+        if (isObject(series.userOptions)) {
+            series.userOptions.rootId = rootId;
+        }
+        // Set rootId on series to pick it up on next update.
+        series.rootNode = rootId;
+    }
+    return rootId;
+};
+
+var result = {
+    getColor: getColor,
+    getLevelOptions: getLevelOptions,
+    setTreeValues: setTreeValues,
+    updateRootId: updateRootId
+};
+export default result;

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Sebastian Domas
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import derivedSeriesMixin from '../mixins/derived-series.js';
+
+var seriesType = H.seriesType,
+    correctFloat = H.correctFloat,
+    isNumber = H.isNumber,
+    merge = H.merge,
+    reduce = H.reduce;
+
+
+/** ****************************************************************************
+ *
+ * BELL CURVE
+ *
+ ******************************************************************************/
+
+function mean(data) {
+    var length = data.length,
+        sum = reduce(data, function (sum, value) {
+            return (sum += value);
+        }, 0);
+
+    return length > 0 && sum / length;
+}
+
+function standardDeviation(data, average) {
+    var len = data.length,
+        sum;
+
+    average = isNumber(average) ? average : mean(data);
+
+    sum = reduce(data, function (sum, value) {
+        var diff = value - average;
+        return (sum += diff * diff);
+    }, 0);
+
+    return len > 1 && Math.sqrt(sum / (len - 1));
+}
+
+function normalDensity(x, mean, standardDeviation) {
+    var translation = x - mean;
+    return Math.exp(
+        -(translation * translation) /
+        (2 * standardDeviation * standardDeviation)
+    ) / (standardDeviation * Math.sqrt(2 * Math.PI));
+}
+
+
+/**
+ * Bell curve class
+ *
+ * @constructor seriesTypes.bellcurve
+ * @augments seriesTypes.areaspline
+ * @mixes DerivedSeriesMixin
+ **/
+
+/**
+ * A bell curve is an areaspline series which represents the probability density
+ * function of the normal distribution. It calculates mean and standard
+ * deviation of the base series data and plots the curve according to the
+ * calculated parameters.
+ *
+ * @product      highcharts
+ * @sample       {highcharts} highcharts/demo/bellcurve/ Bell curve
+ * @since        6.0.0
+ * @extends      plotOptions.areaspline
+ * @excluding    boostThreshold,connectNulls,stacking,pointInterval,
+ *               pointIntervalUnit
+ * @optionparent plotOptions.bellcurve
+ **/
+seriesType('bellcurve', 'areaspline', {
+   /**
+    * This option allows to define the length of the bell curve. A unit of the
+    * length of the bell curve is standard deviation.
+    *
+    * @sample highcharts/plotoptions/bellcurve-intervals-pointsininterval
+    *         Intervals and points in interval
+    */
+    intervals: 3,
+
+   /**
+    * Defines how many points should be plotted within 1 interval. See
+    * `plotOptions.bellcurve.intervals`.
+    *
+    * @sample highcharts/plotoptions/bellcurve-intervals-pointsininterval
+    *         Intervals and points in interval
+    */
+    pointsInInterval: 3,
+
+    marker: {
+        enabled: false
+    }
+
+}, merge(derivedSeriesMixin, {
+    setMean: function () {
+        this.mean = correctFloat(mean(this.baseSeries.yData));
+    },
+
+    setStandardDeviation: function () {
+        this.standardDeviation = correctFloat(
+            standardDeviation(this.baseSeries.yData, this.mean)
+        );
+    },
+
+    setDerivedData: function () {
+        if (this.baseSeries.yData.length > 1) {
+            this.setMean();
+            this.setStandardDeviation();
+            this.setData(
+                this.derivedData(this.mean, this.standardDeviation), false
+            );
+        }
+    },
+
+    derivedData: function (mean, standardDeviation) {
+        var intervals = this.options.intervals,
+            pointsInInterval = this.options.pointsInInterval,
+            x = mean - intervals * standardDeviation,
+            stop = intervals * pointsInInterval * 2 + 1,
+            increment = standardDeviation / pointsInInterval,
+            data = [],
+            i;
+
+        for (i = 0; i < stop; i++) {
+            data.push([x, normalDensity(x, mean, standardDeviation)]);
+            x += increment;
+        }
+
+        return data;
+    }
+}));
+
+
+/**
+* A `bellcurve` series. If the [type](#series.bellcurve.type) option is not
+* specified, it is inherited from [chart.type](#chart.type).
+*
+* For options that apply to multiple series, it is recommended to add
+* them to the [plotOptions.series](#plotOptions.series) options structure.
+* To apply to all series of this specific type, apply it to
+* [plotOptions.bellcurve](#plotOptions.bellcurve).
+*
+* @type      {Object}
+* @since     6.0.0
+* @extends   series,plotOptions.bellcurve
+* @excluding dataParser,dataURL,data
+* @product   highcharts
+* @apioption series.bellcurve
+*/
+
+/**
+* An integer identifying the index to use for the base series, or a string
+* representing the id of the series.
+*
+* @type      {Number|String}
+* @default   undefined
+* @apioption series.bellcurve.baseSeries
+*/
+
+/**
+* An array of data points for the series. For the `bellcurve` series type,
+* points are calculated dynamically.
+*
+* @type      {Array<Object|Array>}
+* @since     6.0.0
+* @extends   series.areaspline.data
+* @product   highcharts
+* @apioption series.bellcurve.data
+*/

+/**
+ * @license  @product.name@ JS v@product.version@ (@product.date@)
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Sebastian Domas
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+import H from '../parts/Globals.js';
+import derivedSeriesMixin from '../mixins/derived-series.js';
+
+var each = H.each,
+    objectEach = H.objectEach,
+    seriesType = H.seriesType,
+    correctFloat = H.correctFloat,
+    isNumber = H.isNumber,
+    arrayMax = H.arrayMax,
+    arrayMin = H.arrayMin,
+    merge = H.merge,
+    map = H.map;
+
+/* ***************************************************************************
+ *
+ * HISTOGRAM
+ *
+ **************************************************************************** */
+
+/**
+ * A dictionary with formulas for calculating number of bins based on the
+ * base series
+ **/
+var binsNumberFormulas = {
+    'square-root': function (baseSeries) {
+        return Math.round(Math.sqrt(baseSeries.options.data.length));
+    },
+
+    'sturges': function (baseSeries) {
+        return Math.ceil(Math.log(baseSeries.options.data.length) * Math.LOG2E);
+    },
+
+    'rice': function (baseSeries) {
+        return Math.ceil(2 * Math.pow(baseSeries.options.data.length, 1 / 3));
+    }
+};
+
+/**
+ * Returns a function for mapping number to the closed (right opened) bins
+ *
+ * @param {number} binWidth - width of the bin
+ * @returns {function}
+ **/
+function fitToBinLeftClosed(bins) {
+    return function (y) {
+        var i = 1;
+        while (bins[i] <= y) {
+            i++;
+        }
+        return bins[--i];
+    };
+}
+
+/**
+ * Histogram class
+ *
+ * @constructor seriesTypes.histogram
+ * @augments seriesTypes.column
+ * @mixes DerivedSeriesMixin
+ **/
+
+/**
+ * A histogram is a column series which represents the distribution of the data
+ * set in the base series. Histogram splits data into bins and shows their
+ * frequencies.
+ *
+ * @product highcharts
+ * @sample {highcharts} highcharts/demo/histogram/ Histogram
+ * @since 6.0.0
+ * @extends plotOptions.column
+ * @excluding boostThreshold, pointInterval, pointIntervalUnit, stacking
+ * @optionparent plotOptions.histogram
+ **/
+seriesType('histogram', 'column', {
+    /**
+      * A preferable number of bins. It is a suggestion, so a histogram may have
+      * a different number of bins. By default it is set to the square root
+      * of the base series' data length. Available options are: `square-root`,
+      * `sturges`, `rice`. You can also define a function which takes a
+      * `baseSeries` as a parameter and should return a positive integer.
+     *
+     * @type {String|Number|Function}
+     * @validvalue ["square-root", "sturges", "rice"]
+     */
+    binsNumber: 'square-root',
+
+    /**
+     * Width of each bin. By default the bin's width is calculated as
+     * `(max - min) / number of bins`. This option takes precedence over
+     * [binsNumber](#plotOptions.histogram.binsNumber).
+     *
+     * @type {Number}
+     */
+    binWidth: undefined,
+    pointPadding: 0,
+    groupPadding: 0,
+    grouping: false,
+    pointPlacement: 'between',
+    tooltip: {
+        headerFormat: '',
+        pointFormat: '<span style="font-size:10px">{point.x} - {point.x2}' +
+            '</span><br/>' +
+            '<span style="color:{point.color}">\u25CF</span>' +
+            ' {series.name} <b>{point.y}</b><br/>'
+    }
+
+}, merge(derivedSeriesMixin, {
+    setDerivedData: function () {
+        var data = this.derivedData(
+            this.baseSeries.yData,
+            this.binsNumber(),
+            this.options.binWidth
+        );
+
+        this.setData(data, false);
+    },
+
+    derivedData: function (baseData, binsNumber, binWidth) {
+        var max = arrayMax(baseData),
+            min = arrayMin(baseData),
+            frequencies = [],
+            bins = {},
+            data = [],
+            x,
+            fitToBin;
+
+        binWidth = this.binWidth = correctFloat(
+            isNumber(binWidth) ?
+                (binWidth || 1) :
+                (max - min) / binsNumber
+        );
+
+        // If binWidth is 0 then max and min are equaled,
+        // increment the x with some positive value to quit the loop
+        for (x = min; x < max; x = correctFloat(x + binWidth)) {
+            frequencies.push(x);
+            bins[x] = 0;
+        }
+
+        if (bins[min] !== 0) {
+            frequencies.push(correctFloat(min));
+            bins[correctFloat(min)] = 0;
+        }
+
+        fitToBin = fitToBinLeftClosed(
+            map(frequencies, function (elem) {
+                return parseFloat(elem);
+            }));
+
+        each(baseData, function (y) {
+            var x = correctFloat(fitToBin(y));
+            bins[x]++;
+        });
+
+        objectEach(bins, function (frequency, x) {
+            data.push({
+                x: Number(x),
+                y: frequency,
+                x2: correctFloat(Number(x) + binWidth)
+            });
+        });
+
+        data.sort(function (a, b) {
+            return a.x - b.x;
+        });
+
+        return data;
+    },
+
+    binsNumber: function () {
+        var binsNumberOption = this.options.binsNumber;
+        var binsNumber = binsNumberFormulas[binsNumberOption] ||
+            // #7457
+            (typeof binsNumberOption === 'function' && binsNumberOption);
+
+        return Math.ceil(
+            (binsNumber && binsNumber(this.baseSeries)) ||
+            (
+                isNumber(binsNumberOption) ?
+                    binsNumberOption :
+                    binsNumberFormulas['square-root'](this.baseSeries)
+            )
+        );
+    }
+}));
+
+/**
+ * A `histogram` series. If the [type](#series.histogram.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @type {Object}
+ * @since 6.0.0
+ * @extends series,plotOptions.histogram
+ * @excluding dataParser,dataURL,data
+ * @product highcharts
+ * @apioption series.histogram
+ */
+
+/**
+ * An integer identifying the index to use for the base series, or a string
+ * representing the id of the series.
+ *
+ * @type {Number|String}
+ * @default undefined
+ * @apioption series.histogram.baseSeries
+ */
+
+/**
+ * An array of data points for the series. For the `histogram` series type,
+ * points are calculated dynamically. See
+ * [histogram.baseSeries](#series.histogram.baseSeries).
+ *
+ * @type {Array<Object|Array>}
+ * @since 6.0.0
+ * @extends series.column.data
+ * @product highcharts
+ * @apioption series.histogram.data
+ */

+/**
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * Item series type for Highcharts
+ *
+ * License: www.highcharts.com/license
+ */
+
+/**
+ * @todo
+ * - Check update, remove etc.
+ * - Custom icons like persons, carts etc. Either as images, font icons or
+ *   Highcharts symbols.
+ */
+'use strict';
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import '../parts/Series.js';
+var each = H.each,
+    extend = H.extend,
+    pick = H.pick,
+    seriesType = H.seriesType;
+
+seriesType('item', 'column', {
+    itemPadding: 0.2,
+    marker: {
+        symbol: 'circle',
+        states: {
+            hover: {},
+            select: {}
+        }
+    }
+}, {
+    drawPoints: function () {
+        var series = this,
+            renderer = series.chart.renderer,
+            seriesMarkerOptions = this.options.marker,
+            itemPaddingTranslated = this.yAxis.transA *
+                series.options.itemPadding,
+            borderWidth = this.borderWidth,
+            crisp = borderWidth % 2 ? 0.5 : 1;
+
+        each(this.points, function (point) {
+            var yPos,
+                attr,
+                graphics,
+                itemY,
+                pointAttr,
+                pointMarkerOptions = point.marker || {},
+                symbol = (
+                    pointMarkerOptions.symbol ||
+                    seriesMarkerOptions.symbol
+                ),
+                radius = pick(
+                    pointMarkerOptions.radius,
+                    seriesMarkerOptions.radius
+                ),
+                size,
+                yTop,
+                isSquare = symbol !== 'rect',
+                x,
+                y;
+
+            point.graphics = graphics = point.graphics || {};
+            pointAttr = point.pointAttr ?
+                (
+                    point.pointAttr[point.selected ? 'selected' : ''] ||
+                    series.pointAttr['']
+                ) :
+                series.pointAttribs(point, point.selected && 'select');
+            delete pointAttr.r;
+
+            if (point.y !== null) {
+
+                if (!point.graphic) {
+                    point.graphic = renderer.g('point').add(series.group);
+                }
+
+                itemY = point.y;
+                yTop = pick(point.stackY, point.y);
+                size = Math.min(
+                    point.pointWidth,
+                    series.yAxis.transA - itemPaddingTranslated
+                );
+                for (yPos = yTop; yPos > yTop - point.y; yPos--) {
+
+                    x = point.barX + (
+                        isSquare ?
+                            point.pointWidth / 2 - size / 2 :
+                            0
+                    );
+                    y = series.yAxis.toPixels(yPos, true) +
+                        itemPaddingTranslated / 2;
+
+                    if (series.options.crisp) {
+                        x = Math.round(x) - crisp;
+                        y = Math.round(y) + crisp;
+                    }
+                    attr = {
+                        x: x,
+                        y: y,
+                        width: Math.round(isSquare ? size : point.pointWidth),
+                        height: Math.round(size),
+                        r: radius
+                    };
+
+                    if (graphics[itemY]) {
+                        graphics[itemY].animate(attr);
+                    } else {
+                        graphics[itemY] = renderer.symbol(symbol)
+                            .attr(extend(attr, pointAttr))
+                            .add(point.graphic);
+                    }
+                    graphics[itemY].isActive = true;
+                    itemY--;
+                }
+            }
+            H.objectEach(graphics, function (graphic, key) {
+                if (!graphic.isActive) {
+                    graphic.destroy();
+                    delete graphic[key];
+                } else {
+                    graphic.isActive = false;
+                }
+            });
+        });
+
+    }
+});
+
+H.SVGRenderer.prototype.symbols.rect = function (x, y, w, h, options) {
+    return H.SVGRenderer.prototype.symbols.callout(x, y, w, h, options);
+};
+

+/**
+ * Plugin for displaying a message when there is no data visible in chart.
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Oystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import '../parts/Series.js';
+import '../parts/Options.js';
+
+var seriesTypes = H.seriesTypes,
+    chartPrototype = H.Chart.prototype,
+    defaultOptions = H.getOptions(),
+    extend = H.extend,
+    each = H.each;
+
+// Add language option
+extend(defaultOptions.lang, {
+    /**
+     * The text to display when the chart contains no data. Requires the
+     * no-data module, see [noData](#noData).
+     *
+     * @type {String}
+     * @default No data to display
+     * @since 3.0.8
+     * @product highcharts highstock
+     * @sample highcharts/no-data-to-display/no-data-line
+     *         No-data text
+     * @apioption lang.noData
+     */
+    noData: 'No data to display'
+});
+
+// Add default display options for message
+/**
+ * Options for displaying a message like "No data to display".
+ * This feature requires the file no-data-to-display.js to be loaded in the
+ * page. The actual text to display is set in the lang.noData option.
+ * @type {Object}
+ *
+ * @sample highcharts/no-data-to-display/no-data-line
+ *         Line chart with no-data module
+ * @sample highcharts/no-data-to-display/no-data-pie
+ *         Pie chart with no-data module
+ * @optionparent noData
+ */
+defaultOptions.noData = {
+
+    /**
+     * An object of additional SVG attributes for the no-data label.
+     *
+     * @type {Object}
+     * @since 3.0.8
+     * @product highcharts highstock gantt
+     * @apioption noData.attr
+     */
+
+    /**
+     * Whether to insert the label as HTML, or as pseudo-HTML rendered with
+     * SVG.
+     *
+     * @type {Boolean}
+     * @default false
+     * @since 4.1.10
+     * @product highcharts highstock gantt
+     * @apioption noData.useHTML
+     */
+
+    /**
+     * The position of the no-data label, relative to the plot area.
+     *
+     * @type {Object}
+     * @default { "x": 0, "y": 0, "align": "center", "verticalAlign": "middle" }
+     * @since 3.0.8
+     */
+    position: {
+
+        /**
+         * Horizontal offset of the label, in pixels.
+         *
+         * @type {Number}
+         * @default 0
+         * @product highcharts highstock gantt
+         */
+        x: 0,
+
+        /**
+         * Vertical offset of the label, in pixels.
+         *
+         * @type {Number}
+         * @default 0
+         * @product highcharts highstock gantt
+         */
+        y: 0,
+
+        /**
+         * Horizontal alignment of the label.
+         *
+         * @validvalue ["left", "center", "right"]
+         * @type {String}
+         * @default center
+         */
+        align: 'center',
+
+        /**
+         * Vertical alignment of the label.
+         *
+         * @validvalue ["top", "middle", "bottom"]
+         * @type {String}
+         * @default middle
+         * @product highcharts highstock gantt
+         */
+        verticalAlign: 'middle'
+    }
+};
+
+
+// Presentational
+/**
+ * CSS styles for the no-data label.
+ *
+ * @sample highcharts/no-data-to-display/no-data-line
+ *         Styled no-data text
+ * @optionparent noData.style
+ */
+defaultOptions.noData.style = {
+    fontWeight: 'bold',
+    fontSize: '12px',
+    color: '#666666'
+};
+
+
+
+// Define hasData function for non-cartesian seris. Returns true if the series
+// has points at all.
+each([
+    'bubble',
+    'gauge',
+    'heatmap',
+    'pie',
+    'sankey',
+    'treemap',
+    'waterfall'
+], function (type) {
+    if (seriesTypes[type]) {
+        seriesTypes[type].prototype.hasData = function () {
+            return !!this.points.length; // != 0
+        };
+    }
+});
+
+/**
+ * Define hasData functions for series. These return true if there are data
+ * points on this series within the plot area.
+ */
+H.Series.prototype.hasData = function () {
+    return (
+        this.visible &&
+        this.dataMax !== undefined &&
+        this.dataMin !== undefined // #3703
+    );
+};
+
+/**
+ * Display a no-data message.
+ *
+ * @param {String} str An optional message to show in place of the default one
+ */
+chartPrototype.showNoData = function (str) {
+    var chart = this,
+        options = chart.options,
+        text = str || (options && options.lang.noData),
+        noDataOptions = options && options.noData;
+
+    if (!chart.noDataLabel && chart.renderer) {
+        chart.noDataLabel = chart.renderer
+            .label(
+                text,
+                0,
+                0,
+                null,
+                null,
+                null,
+                noDataOptions.useHTML,
+                null,
+                'no-data'
+            );
+
+        
+        chart.noDataLabel
+            .attr(noDataOptions.attr)
+            .css(noDataOptions.style);
+        
+
+        chart.noDataLabel.add();
+
+        chart.noDataLabel.align(
+            extend(chart.noDataLabel.getBBox(), noDataOptions.position),
+            false,
+            'plotBox'
+        );
+    }
+};
+
+/**
+ * Hide no-data message
+ */
+chartPrototype.hideNoData = function () {
+    var chart = this;
+    if (chart.noDataLabel) {
+        chart.noDataLabel = chart.noDataLabel.destroy();
+    }
+};
+
+/**
+ * Returns true if there are data points within the plot area now
+ */
+chartPrototype.hasData = function () {
+    var chart = this,
+        series = chart.series || [],
+        i = series.length;
+
+    while (i--) {
+        if (series[i].hasData() && !series[i].options.isInternal) {
+            return true;
+        }
+    }
+
+    return chart.loadingShown; // #4588
+};
+
+/**
+ * Add event listener to handle automatic show or hide no-data message
+ */
+H.addEvent(H.Chart, 'render', function handleNoData() {
+    if (this.hasData()) {
+        this.hideNoData();
+    } else {
+        this.showNoData();
+    }
+});

+/**
+ * (c) 2009-2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import '../parts/Chart.js';
+
+/*
+ * Highcharts module to hide overlapping data labels. This module is included in
+ * Highcharts.
+ */
+
+var Chart = H.Chart,
+    each = H.each,
+    isArray = H.isArray,
+    objectEach = H.objectEach,
+    pick = H.pick,
+    addEvent = H.addEvent;
+
+// Collect potensial overlapping data labels. Stack labels probably don't need
+// to be considered because they are usually accompanied by data labels that lie
+// inside the columns.
+addEvent(Chart, 'render', function collectAndHide() {
+    var labels = [];
+    // Consider external label collectors
+    each(this.labelCollectors || [], function (collector) {
+        labels = labels.concat(collector());
+    });
+
+    each(this.yAxis || [], function (yAxis) {
+        if (
+            yAxis.options.stackLabels &&
+            !yAxis.options.stackLabels.allowOverlap
+        ) {
+            objectEach(yAxis.stacks, function (stack) {
+                objectEach(stack, function (stackItem) {
+                    labels.push(stackItem.label);
+                });
+            });
+        }
+    });
+
+    each(this.series || [], function (series) {
+        var dlOptions = series.options.dataLabels;
+
+        if (
+            series.visible &&
+            !(dlOptions.enabled === false && !series._hasPointLabels)
+        ) { // #3866
+            each(series.points, function (point) {
+                if (point.visible) {
+                    var dataLabels = (
+                        isArray(point.dataLabels) ?
+                        point.dataLabels :
+                        (point.dataLabel ? [point.dataLabel] : [])
+                    );
+                    each(dataLabels, function (label) {
+                        var options = label.options;
+                        label.labelrank = pick(
+                            options.labelrank,
+                            point.labelrank,
+                            point.shapeArgs && point.shapeArgs.height
+                        ); // #4118
+
+                        if (!options.allowOverlap) {
+                            labels.push(label);
+                        }
+                    });
+                }
+            });
+        }
+    });
+
+    this.hideOverlappingLabels(labels);
+});
+
+/**
+ * Hide overlapping labels. Labels are moved and faded in and out on zoom to
+ * provide a smooth visual imression.
+ *
+ * @private
+ * @function Highcharts.Chart#hideOverlappingLabels
+ *
+ * @param {Array<Highcharts.SVGElement>} labels
+ */
+Chart.prototype.hideOverlappingLabels = function (labels) {
+
+    var len = labels.length,
+        ren = this.renderer,
+        label,
+        i,
+        j,
+        label1,
+        label2,
+        isIntersecting,
+        box1,
+        box2,
+        intersectRect = function (x1, y1, w1, h1, x2, y2, w2, h2) {
+            return !(
+                x2 > x1 + w1 ||
+                x2 + w2 < x1 ||
+                y2 > y1 + h1 ||
+                y2 + h2 < y1
+            );
+        },
+
+        /**
+         * Get the box with its position inside the chart, as opposed to getBBox
+         * that only reports the position relative to the parent.
+         */
+        getAbsoluteBox = function (label) {
+            var pos,
+                parent,
+                bBox,
+                // Substract the padding if no background or border (#4333)
+                padding = label.box ? 0 : (label.padding || 0),
+                lineHeightCorrection = 0;
+
+            if (
+                label &&
+                (!label.alignAttr || label.placed)
+            ) {
+                pos = label.alignAttr || {
+                    x: label.attr('x'),
+                    y: label.attr('y')
+                };
+                parent = label.parentGroup;
+
+                // Get width and height if pure text nodes (stack labels)
+                if (!label.width) {
+                    bBox = label.getBBox();
+                    label.width = bBox.width;
+                    label.height = bBox.height;
+
+                    // Labels positions are computed from top left corner, so
+                    // we need to substract the text height from text nodes too.
+                    lineHeightCorrection = ren
+                        .fontMetrics(null, label.element).h;
+                }
+                return {
+                    x: pos.x + (parent.translateX || 0) + padding,
+                    y: pos.y + (parent.translateY || 0) + padding -
+                        lineHeightCorrection,
+                    width: label.width - 2 * padding,
+                    height: label.height - 2 * padding
+                };
+
+            }
+        };
+
+    for (i = 0; i < len; i++) {
+        label = labels[i];
+        if (label) {
+
+            // Mark with initial opacity
+            label.oldOpacity = label.opacity;
+            label.newOpacity = 1;
+
+            label.absoluteBox = getAbsoluteBox(label);
+
+        }
+    }
+
+    // Prevent a situation in a gradually rising slope, that each label will
+    // hide the previous one because the previous one always has lower rank.
+    labels.sort(function (a, b) {
+        return (b.labelrank || 0) - (a.labelrank || 0);
+    });
+
+    // Detect overlapping labels
+    for (i = 0; i < len; i++) {
+        label1 = labels[i];
+        box1 = label1 && label1.absoluteBox;
+
+        for (j = i + 1; j < len; ++j) {
+            label2 = labels[j];
+            box2 = label2 && label2.absoluteBox;
+
+            if (
+                box1 &&
+                box2 &&
+                label1 !== label2 && // #6465, polar chart with connectEnds
+                label1.newOpacity !== 0 &&
+                label2.newOpacity !== 0
+            ) {
+                isIntersecting = intersectRect(
+                    box1.x,
+                    box1.y,
+                    box1.width,
+                    box1.height,
+                    box2.x,
+                    box2.y,
+                    box2.width,
+                    box2.height
+                );
+
+
+                if (isIntersecting) {
+                    (label1.labelrank < label2.labelrank ? label1 : label2)
+                        .newOpacity = 0;
+                }
+            }
+        }
+    }
+
+    // Hide or show
+    each(labels, function (label) {
+        var complete,
+            newOpacity;
+
+        if (label) {
+            newOpacity = label.newOpacity;
+
+            if (label.oldOpacity !== newOpacity) {
+
+                // Make sure the label is completely hidden to avoid catching
+                // clicks (#4362)
+                if (label.alignAttr && label.placed) { // data labels
+                    if (newOpacity) {
+                        label.show(true);
+                    } else {
+                        complete = function () {
+                            label.hide();
+                        };
+                    }
+
+                    // Animate or set the opacity
+                    label.alignAttr.opacity = newOpacity;
+                    label[label.isOld ? 'animate' : 'attr'](
+                        label.alignAttr,
+                        null,
+                        complete
+                    );
+                } else { // other labels, tick labels
+                    label.attr({
+                        opacity: newOpacity
+                    });
+                }
+
+            }
+            label.isOld = true;
+        }
+    });
+};

+/**
+ * (c) 2010-2017 Sebastian Bochan
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import '../parts/Options.js';
+import derivedSeriesMixin from '../mixins/derived-series.js';
+
+var each = H.each,
+    correctFloat = H.correctFloat,
+    seriesType = H.seriesType,
+    merge = H.merge;
+
+
+/**
+ * The pareto series type.
+ *
+ * @constructor seriesTypes.pareto
+ * @augments seriesTypes.line
+ */
+
+/**
+ * A pareto diagram is a type of chart that contains both bars and a line graph,
+ * where individual values are represented in descending order by bars,
+ * and the cumulative total is represented by the line.
+ *
+ * @extends plotOptions.line
+ * @product highcharts
+ * @sample {highcharts} highcharts/demo/pareto/
+ *         Pareto diagram
+ * @since 6.0.0
+ * @excluding allAreas,boostThreshold,borderColor,borderRadius,
+ *         borderWidth,crisp,colorAxis,depth,data,edgeColor,edgeWidth,
+ *         findNearestPointBy,gapSize,gapUnit,grouping,groupPadding,
+ *         groupZPadding,maxPointWidth,keys,negativeColor,pointInterval,
+ *         pointIntervalUnit,pointPadding,pointPlacement,pointRange,pointStart,
+ *         pointWidth,shadow,step,softThreshold,
+ *         stacking,threshold,zoneAxis,zones
+ * @optionparent plotOptions.pareto
+ */
+
+seriesType('pareto', 'line', {
+    /**
+     * Higher zIndex than column series to draw line above shapes.
+     */
+    zIndex: 3
+}, merge(derivedSeriesMixin, {
+    /**
+     * calculate sum and return percent points
+     *
+     * @param  {Object} series
+     * @return {Array} Returns array of points [x,y]
+     */
+    setDerivedData: function () {
+        if (this.baseSeries.yData.length > 1) {
+            var xValues = this.baseSeries.xData,
+                yValues = this.baseSeries.yData,
+                sum = this.sumPointsPercents(yValues, xValues, null, true);
+
+            this.setData(
+                this.sumPointsPercents(yValues, xValues, sum, false),
+                false
+            );
+        }
+    },
+    /**
+     * calculate y sum and each percent point
+     *
+     * @param  {Array} yValues y values
+     * @param  {Array} xValues x values
+     * @param  {Number} sum of all y values
+     * @param  {Boolean} isSum declares if calculate sum of all points
+     * @return {Array} Returns sum of points or array of points [x,y]
+     */
+    sumPointsPercents: function (yValues, xValues, sum, isSum) {
+        var sumY = 0,
+            sumPercent = 0,
+            percentPoints = [],
+            percentPoint;
+
+        each(yValues, function (point, i) {
+            if (point !== null) {
+                if (isSum) {
+                    sumY += point;
+                } else {
+                    percentPoint = (point / sum) * 100;
+                    percentPoints.push(
+                        [xValues[i], correctFloat(sumPercent + percentPoint)]
+                    );
+                    sumPercent += percentPoint;
+                }
+            }
+        });
+
+        return isSum ? sumY : percentPoints;
+    }
+}));
+
+/**
+ * A `pareto` series. If the [type](#series.pareto.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @type {Object}
+ * @since 6.0.0
+ * @extends series,plotOptions.pareto
+ * @excluding data,dataParser,dataURL
+ * @product highcharts
+ * @apioption series.pareto
+ */
+
+/**
+ * An integer identifying the index to use for the base series, or a string
+ * representing the id of the series.
+ *
+ * @type {Number|String}
+ * @default undefined
+ * @apioption series.pareto.baseSeries
+ */
+
+/**
+ * An array of data points for the series. For the `pareto` series type,
+ * points are calculated dynamically.
+ *
+ * @type {Array<Object|Array>}
+ * @since 6.0.0
+ * @extends series.column.data
+ * @product highcharts
+ * @apioption series.pareto.data
+ */