highcharts-rails 5.0.9 → 5.0.10

data/app/assets/javascripts/highcharts/highcharts-3d.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v5.0.9 (2017-03-08)
+ * @license Highcharts JS v5.0.10 (2017-03-31)
  *
  * 3D features for Highcharts JS
  *
@@ -15,7 +15,7 @@
 }(function(Highcharts) {
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -137,7 +137,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -477,11 +477,14 @@
                 customAttribs = ['x', 'y', 'r', 'innerR', 'start', 'end'];
 
             /**
-             * Get custom attributes. Mutate the original object and return an object with only custom attr.
+             * Get custom attributes. Don't mutate the original object and return an object with only custom attr.
              */
             function suckOutCustom(params) {
                 var hasCA = false,
                     ca = {};
+
+                params = merge(params); // Don't mutate the original object
+
                 for (var key in params) {
                     if (inArray(key, customAttribs) !== -1) {
                         ca[key] = params[key];
@@ -638,7 +641,6 @@
                 anim = animObject(pick(animation, this.renderer.globalAnimation));
 
                 if (anim.duration) {
-                    params = merge(params); // Don't mutate the original object
                     ca = suckOutCustom(params);
                     params.dummy = 1; // Params need to have a property in order for the step to run (#5765)
 
@@ -871,7 +873,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1109,7 +1111,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1527,7 +1529,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1782,7 +1784,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1972,7 +1974,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -2087,7 +2089,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */

data/app/assets/javascripts/highcharts/highcharts-more.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v5.0.9 (2017-03-08)
+ * @license Highcharts JS v5.0.10 (2017-03-31)
  *
  * (c) 2009-2016 Torstein Honsi
  *
@@ -15,11 +15,12 @@
 }(function(Highcharts) {
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
-        var each = H.each,
+        var CenteredSeriesMixin = H.CenteredSeriesMixin,
+            each = H.each,
             extend = H.extend,
             merge = H.merge,
             splat = H.splat;
@@ -27,53 +28,116 @@
          * The Pane object allows options that are common to a set of X and Y axes.
          *
          * In the future, this can be extended to basic Highcharts and Highstock.
+         *
          */
-        function Pane(options, chart, firstAxis) {
-            this.init(options, chart, firstAxis);
+        function Pane(options, chart) {
+            this.init(options, chart);
         }
 
         // Extend the Pane prototype
         extend(Pane.prototype, {
 
+            coll: 'pane', // Member of chart.pane
+
             /**
              * Initiate the Pane object
              */
-            init: function(options, chart, firstAxis) {
-                var pane = this,
-                    backgroundOption,
-                    defaultOptions = pane.defaultOptions;
+            init: function(options, chart) {
+                this.chart = chart;
+                this.background = [];
 
-                pane.chart = chart;
+                chart.pane.push(this);
+
+                this.setOptions(options);
+            },
+
+            setOptions: function(options) {
 
                 // Set options. Angular charts have a default background (#3318)
-                pane.options = options = merge(defaultOptions, chart.angular ? {
-                    background: {}
-                } : undefined, options);
+                this.options = options = merge(
+                    this.defaultOptions,
+                    this.chart.angular ? {
+                        background: {}
+                    } : undefined,
+                    options
+                );
+            },
 
-                backgroundOption = options.background;
+            /**
+             * Render the pane with its backgrounds.
+             */
+            render: function() {
 
-                // To avoid having weighty logic to place, update and remove the backgrounds,
-                // push them to the first axis' plot bands and borrow the existing logic there.
-                if (backgroundOption) {
-                    each([].concat(splat(backgroundOption)).reverse(), function(config) {
-                        var mConfig,
-                            axisUserOptions = firstAxis.userOptions;
-                        mConfig = merge(pane.defaultBackgroundOptions, config);
+                var options = this.options,
+                    backgroundOption = this.options.background,
+                    renderer = this.chart.renderer,
+                    len,
+                    i;
+
+                if (!this.group) {
+                    this.group = renderer.g('pane-group')
+                        .attr({
+                            zIndex: options.zIndex || 0
+                        })
+                        .add();
+                }
 
+                this.updateCenter();
 
-                        if (config.backgroundColor) {
-                            mConfig.backgroundColor = config.backgroundColor;
+                // Render the backgrounds
+                if (backgroundOption) {
+                    backgroundOption = splat(backgroundOption);
+                    len = Math.max(
+                        backgroundOption.length,
+                        this.background.length || 0
+                    );
+
+                    for (i = 0; i < len; i++) {
+                        if (backgroundOption[i]) {
+                            this.renderBackground(
+                                merge(
+                                    this.defaultBackgroundOptions,
+                                    backgroundOption[i]
+                                ),
+                                i
+                            );
+                        } else if (this.background[i]) {
+                            this.background[i] = this.background[i].destroy();
+                            this.background.splice(i, 1);
                         }
-                        mConfig.color = mConfig.backgroundColor; // due to naming in plotBands
+                    }
+                }
+            },
 
+            /**
+             * Render an individual pane background.
+             * @param  {Object} backgroundOptions Background options
+             * @param  {number} i The index of the background in this.backgrounds
+             */
+            renderBackground: function(backgroundOptions, i) {
+                var method = 'animate';
 
-                        firstAxis.options.plotBands.unshift(mConfig);
-                        axisUserOptions.plotBands = axisUserOptions.plotBands || []; // #3176
-                        if (axisUserOptions.plotBands !== firstAxis.options.plotBands) {
-                            axisUserOptions.plotBands.unshift(mConfig);
-                        }
-                    });
+                if (!this.background[i]) {
+                    this.background[i] = this.chart.renderer.path()
+                        .add(this.group);
+                    method = 'attr';
                 }
+
+                this.background[i][method]({
+                    'd': this.axis.getPlotBandPath(
+                        backgroundOptions.from,
+                        backgroundOptions.to,
+                        backgroundOptions
+                    )
+                }).attr({
+
+                    'fill': backgroundOptions.backgroundColor,
+                    'stroke': backgroundOptions.borderColor,
+                    'stroke-width': backgroundOptions.borderWidth,
+
+                    'class': 'highcharts-pane ' + (backgroundOptions.className || '')
+                });
+
             },
 
             /**
@@ -91,7 +155,7 @@
              * The default background options
              */
             defaultBackgroundOptions: {
-                className: 'highcharts-pane',
+                //className: 'highcharts-pane',
                 shape: 'circle',
 
                 borderWidth: 1,
@@ -113,6 +177,44 @@
                 innerRadius: 0,
                 to: Number.MAX_VALUE, // corrected to axis max
                 outerRadius: '105%'
+            },
+
+            /**
+             * Gets the center for the pane and its axis.
+             */
+            updateCenter: function(axis) {
+                this.center = (axis || this.axis || {}).center =
+                    CenteredSeriesMixin.getCenter.call(this);
+            },
+
+            /**
+             * Destroy the pane item
+             * /
+            destroy: function () {
+            	H.erase(this.chart.pane, this);
+            	each(this.background, function (background) {
+            		background.destroy();
+            	});
+            	this.background.length = 0;
+            	this.group = this.group.destroy();
+            },
+            */
+
+            /**
+             * Update the pane item with new options
+             * @param  {Object} options New pane options
+             */
+            update: function(options, redraw) {
+
+                merge(true, this.options, options);
+                this.setOptions(this.options);
+                this.render();
+                each(this.chart.axes, function(axis) {
+                    if (axis.pane === this) {
+                        axis.pane = null;
+                        axis.update({}, redraw);
+                    }
+                }, this);
             }
 
         });
@@ -122,22 +224,19 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
         var Axis = H.Axis,
-            CenteredSeriesMixin = H.CenteredSeriesMixin,
             each = H.each,
             extend = H.extend,
             map = H.map,
             merge = H.merge,
             noop = H.noop,
-            Pane = H.Pane,
             pick = H.pick,
             pInt = H.pInt,
             Tick = H.Tick,
-            splat = H.splat,
             wrap = H.wrap,
 
 
@@ -250,8 +349,6 @@
                 // Title or label offsets are not counted
                 this.chart.axisOffset[this.side] = 0;
 
-                // Set the center array
-                this.center = this.pane.center = CenteredSeriesMixin.getCenter.call(this.pane);
             },
 
 
@@ -342,7 +439,7 @@
                 if (this.isRadial) {
 
                     // Set the center array
-                    this.center = this.pane.center = CenteredSeriesMixin.getCenter.call(this.pane);
+                    this.pane.updateCenter(this);
 
                     // The sector is used in Axis.translate to compute the translation of reversed axis points (#2570)
                     if (this.isCircular) {
@@ -534,8 +631,7 @@
          * Override axisProto.init to mix in special axis instance functions and function overrides
          */
         wrap(axisProto, 'init', function(proceed, chart, userOptions) {
-            var axis = this,
-                angular = chart.angular,
+            var angular = chart.angular,
                 polar = chart.polar,
                 isX = userOptions.isX,
                 isHidden = angular && isX,
@@ -543,8 +639,8 @@
                 options,
                 chartOptions = chart.options,
                 paneIndex = userOptions.pane || 0,
-                pane,
-                paneOptions;
+                pane = this.pane = chart.pane[paneIndex],
+                paneOptions = pane.options;
 
             // Before prototype.init
             if (angular) {
@@ -570,23 +666,17 @@
                 this.isRadial = false;
             }
 
+            // A pointer back to this axis to borrow geometry
+            if (isCircular) {
+                pane.axis = this;
+            }
+
             // Run prototype.init
             proceed.call(this, chart, userOptions);
 
             if (!isHidden && (angular || polar)) {
                 options = this.options;
 
-                // Create the pane and set the pane options.
-                if (!chart.panes) {
-                    chart.panes = [];
-                }
-                this.pane = pane = chart.panes[paneIndex] = chart.panes[paneIndex] || new Pane(
-                    splat(chartOptions.pane)[paneIndex],
-                    chart,
-                    axis
-                );
-                paneOptions = pane.options;
-
                 // Start and end angle options are
                 // given in degrees relative to top, while internal computations are
                 // in radians relative to right (like SVG).
@@ -706,7 +796,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1023,7 +1113,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1041,7 +1131,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1150,7 +1240,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1414,7 +1504,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1583,36 +1673,38 @@
                             point.medianShape = renderer.path(medianPath)
                                 .addClass('highcharts-boxplot-median')
                                 .add(graphic);
+                        }
 
 
 
 
-                            // Stem attributes
-                            stemAttr.stroke = point.stemColor || options.stemColor || color;
-                            stemAttr['stroke-width'] = pick(point.stemWidth, options.stemWidth, options.lineWidth);
-                            stemAttr.dashstyle = point.stemDashStyle || options.stemDashStyle;
-                            point.stem.attr(stemAttr);
 
-                            // Whiskers attributes
-                            if (whiskerLength) {
-                                whiskersAttr.stroke = point.whiskerColor || options.whiskerColor || color;
-                                whiskersAttr['stroke-width'] = pick(point.whiskerWidth, options.whiskerWidth, options.lineWidth);
-                                point.whiskers.attr(whiskersAttr);
-                            }
 
-                            if (doQuartiles) {
-                                boxAttr = series.pointAttribs(point);
-                                point.box.attr(boxAttr);
-                            }
+                        // Stem attributes
+                        stemAttr.stroke = point.stemColor || options.stemColor || color;
+                        stemAttr['stroke-width'] = pick(point.stemWidth, options.stemWidth, options.lineWidth);
+                        stemAttr.dashstyle = point.stemDashStyle || options.stemDashStyle;
+                        point.stem.attr(stemAttr);
+
+                        // Whiskers attributes
+                        if (whiskerLength) {
+                            whiskersAttr.stroke = point.whiskerColor || options.whiskerColor || color;
+                            whiskersAttr['stroke-width'] = pick(point.whiskerWidth, options.whiskerWidth, options.lineWidth);
+                            point.whiskers.attr(whiskersAttr);
+                        }
 
+                        if (doQuartiles) {
+                            boxAttr = series.pointAttribs(point);
+                            point.box.attr(boxAttr);
+                        }
 
-                            // Median attributes
-                            medianAttr.stroke = point.medianColor || options.medianColor || color;
-                            medianAttr['stroke-width'] = pick(point.medianWidth, options.medianWidth, options.lineWidth);
-                            point.medianShape.attr(medianAttr);
+
+                        // Median attributes
+                        medianAttr.stroke = point.medianColor || options.medianColor || color;
+                        medianAttr['stroke-width'] = pick(point.medianWidth, options.medianWidth, options.lineWidth);
+                        point.medianShape.attr(medianAttr);
 
 
-                        }
 
 
 
@@ -1717,7 +1809,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -1776,13 +1868,12 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
         var correctFloat = H.correctFloat,
             isNumber = H.isNumber,
-            noop = H.noop,
             pick = H.pick,
             Point = H.Point,
             Series = H.Series,
@@ -1838,7 +1929,7 @@
                     tooltipY;
 
                 // run column series translate
-                seriesTypes.column.prototype.translate.apply(this);
+                seriesTypes.column.prototype.translate.apply(series);
 
                 previousY = previousIntermediate = threshold;
                 points = series.points;
@@ -1846,14 +1937,18 @@
                 for (i = 0, len = points.length; i < len; i++) {
                     // cache current point object
                     point = points[i];
-                    yValue = this.processedYData[i];
+                    yValue = series.processedYData[i];
                     shapeArgs = point.shapeArgs;
 
                     // get current stack
                     stack = stacking && yAxis.stacks[(series.negStacks && yValue < threshold ? '-' : '') + series.stackKey];
-                    stackIndicator = series.getStackIndicator(stackIndicator, point.x);
+                    stackIndicator = series.getStackIndicator(
+                        stackIndicator,
+                        point.x,
+                        series.index
+                    );
                     range = stack ?
-                        stack[point.x].points[series.index + ',' + i + ',' + stackIndicator.index] : [0, yValue];
+                        stack[point.x].points[stackIndicator.key] : [0, yValue];
 
                     // override point value for sums
                     // #3710 Update point does not propagate to sum
@@ -1866,7 +1961,6 @@
                     y = Math.max(previousY, previousY + point.y) + range[0];
                     shapeArgs.y = yAxis.toPixels(y, true);
 
-
                     // sum points
                     if (point.isSum) {
                         shapeArgs.y = yAxis.toPixels(range[1], true);
@@ -1885,8 +1979,10 @@
                         shapeArgs.height = yValue > 0 ?
                             yAxis.toPixels(previousY, true) - shapeArgs.y :
                             yAxis.toPixels(previousY, true) - yAxis.toPixels(previousY - yValue, true);
-                        previousY += yValue;
+
+                        previousY += stack && stack[point.x] ? stack[point.x].total : yValue;
                     }
+
                     // #3952 Negative sum or intermediate sum not rendered correctly
                     if (shapeArgs.height < 0) {
                         shapeArgs.y += shapeArgs.height;
@@ -1959,9 +2055,11 @@
 
                 Series.prototype.processData.call(this, force);
 
-                // Record extremes
-                series.dataMin = dataMin;
-                series.dataMax = dataMax;
+                // Record extremes only if stacking was not set:
+                if (!series.options.stacking) {
+                    series.dataMin = dataMin;
+                    series.dataMax = dataMax;
+                }
             },
 
             /**
@@ -2060,9 +2158,39 @@
             },
 
             /**
-             * Extremes are recorded in processData
+             * Waterfall has stacking along the x-values too.
+             */
+            setStackedPoints: function() {
+                var series = this,
+                    options = series.options,
+                    stackedYLength,
+                    i;
+
+                Series.prototype.setStackedPoints.apply(series, arguments);
+
+                stackedYLength = series.stackedYData ? series.stackedYData.length : 0;
+
+                // Start from the second point:
+                for (i = 1; i < stackedYLength; i++) {
+                    if (!options.data[i].isSum &&
+                        !options.data[i].isIntermediateSum
+                    ) {
+                        // Sum previous stacked data as waterfall can grow up/down:
+                        series.stackedYData[i] += series.stackedYData[i - 1];
+                    }
+                }
+            },
+
+            /**
+             * Extremes for a non-stacked series are recorded in processData.
+             * In case of stacking, use Series.stackedYData to calculate extremes.
              */
-            getExtremes: noop
+            getExtremes: function() {
+                if (this.options.stacking) {
+                    return Series.prototype.getExtremes.apply(this, arguments);
+                }
+            }
+
 
             // Point members
         }, {
@@ -2092,7 +2220,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -2151,7 +2279,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -2223,6 +2351,7 @@
             trackerGroups: ['markerGroup', 'dataLabelsGroup'],
             bubblePadding: true,
             zoneAxis: 'z',
+            directTouch: true,
 
 
             pointAttribs: function(point, state) {
@@ -2493,7 +2622,7 @@
     }(Highcharts));
     (function(H) {
         /**
-         * (c) 2010-2016 Torstein Honsi
+         * (c) 2010-2017 Torstein Honsi
          *
          * License: www.highcharts.com/license
          */
@@ -2532,6 +2661,96 @@
 
         };
 
+        /**
+         * #6212 Calculate connectors for spline series in polar chart. 
+         * @param {Boolean} calculateNeighbours - Check if connectors should be calculated for neighbour points as well
+         * allows short recurence
+         */
+        seriesProto.getConnectors = function(segment, index, calculateNeighbours, connectEnds) {
+
+            var i,
+                prevPointInd,
+                nextPointInd,
+                previousPoint,
+                nextPoint,
+                previousX,
+                previousY,
+                nextX,
+                nextY,
+                plotX,
+                plotY,
+                ret,
+                smoothing = 1.5, // 1 means control points midway between points, 2 means 1/3 from the point, 3 is 1/4 etc;
+                denom = smoothing + 1,
+                leftContX,
+                leftContY,
+                rightContX,
+                rightContY,
+                dLControlPoint, //distance left control point
+                dRControlPoint,
+                leftContAngle,
+                rightContAngle,
+                jointAngle,
+                addedNumber = connectEnds ? 1 : 0;
+
+            /** calculate final index of points depending on the initial index value.
+             * Because of calculating neighbours, index may be outisde segment array.
+             */
+            if (index >= 0 && index <= segment.length - 1) {
+                i = index;
+            } else if (index < 0) {
+                i = segment.length - 1 + index;
+            } else {
+                i = 0;
+            }
+
+            prevPointInd = (i - 1 < 0) ? segment.length - (1 + addedNumber) : i - 1;
+            nextPointInd = (i + 1 > segment.length - 1) ? addedNumber : i + 1;
+            previousPoint = segment[prevPointInd];
+            nextPoint = segment[nextPointInd];
+            previousX = previousPoint.plotX;
+            previousY = previousPoint.plotY;
+            nextX = nextPoint.plotX;
+            nextY = nextPoint.plotY;
+            plotX = segment[i].plotX; // actual point
+            plotY = segment[i].plotY;
+            leftContX = (smoothing * plotX + previousX) / denom;
+            leftContY = (smoothing * plotY + previousY) / denom;
+            rightContX = (smoothing * plotX + nextX) / denom;
+            rightContY = (smoothing * plotY + nextY) / denom;
+            dLControlPoint = Math.sqrt(Math.pow(leftContX - plotX, 2) + Math.pow(leftContY - plotY, 2));
+            dRControlPoint = Math.sqrt(Math.pow(rightContX - plotX, 2) + Math.pow(rightContY - plotY, 2));
+            leftContAngle = Math.atan2(leftContY - plotY, leftContX - plotX);
+            rightContAngle = Math.atan2(rightContY - plotY, rightContX - plotX);
+            jointAngle = (Math.PI / 2) + ((leftContAngle + rightContAngle) / 2);
+            // Ensure the right direction, jointAngle should be in the same quadrant as leftContAngle
+            if (Math.abs(leftContAngle - jointAngle) > Math.PI / 2) {
+                jointAngle -= Math.PI;
+            }
+            // Find the corrected control points for a spline straight through the point
+            leftContX = plotX + Math.cos(jointAngle) * dLControlPoint;
+            leftContY = plotY + Math.sin(jointAngle) * dLControlPoint;
+            rightContX = plotX + Math.cos(Math.PI + jointAngle) * dRControlPoint;
+            rightContY = plotY + Math.sin(Math.PI + jointAngle) * dRControlPoint;
+
+            // push current point's connectors into returned object
+
+            ret = {
+                rightContX: rightContX,
+                rightContY: rightContY,
+                leftContX: leftContX,
+                leftContY: leftContY,
+                plotX: plotX,
+                plotY: plotY
+            };
+
+            // calculate connectors for previous and next point and push them inside returned object 
+            if (calculateNeighbours) {
+                ret.prevPointCont = this.getConnectors(segment, prevPointInd, false, connectEnds);
+            }
+            return ret;
+        };
+
         /**
          * Wrap the buildKDTree function so that it searches by angle (clientX) in case of shared tooltip,
          * and by two dimensional distance in case of non-shared.
@@ -2541,7 +2760,7 @@
                 if (this.kdByAngle) {
                     this.searchPoint = this.searchPointByAngle;
                 } else {
-                    this.kdDimensions = 2;
+                    this.options.findNearestPointBy = 'xy';
                 }
             }
             proceed.apply(this);
@@ -2585,104 +2804,35 @@
              * Overridden method for calculating a spline from one point to the next
              */
             wrap(seriesTypes.spline.prototype, 'getPointSpline', function(proceed, segment, point, i) {
-
                 var ret,
-                    smoothing = 1.5, // 1 means control points midway between points, 2 means 1/3 from the point, 3 is 1/4 etc;
-                    denom = smoothing + 1,
-                    plotX,
-                    plotY,
-                    lastPoint,
-                    nextPoint,
-                    lastX,
-                    lastY,
-                    nextX,
-                    nextY,
-                    leftContX,
-                    leftContY,
-                    rightContX,
-                    rightContY,
-                    distanceLeftControlPoint,
-                    distanceRightControlPoint,
-                    leftContAngle,
-                    rightContAngle,
-                    jointAngle;
-
+                    connectors;
 
                 if (this.chart.polar) {
-
-                    plotX = point.plotX;
-                    plotY = point.plotY;
-                    lastPoint = segment[i - 1];
-                    nextPoint = segment[i + 1];
-
-                    // Connect ends
-                    if (this.connectEnds) {
-                        if (!lastPoint) {
-                            lastPoint = segment[segment.length - 2]; // not the last but the second last, because the segment is already connected
-                        }
-                        if (!nextPoint) {
-                            nextPoint = segment[1];
-                        }
-                    }
-
-                    // find control points
-                    if (lastPoint && nextPoint) {
-
-                        lastX = lastPoint.plotX;
-                        lastY = lastPoint.plotY;
-                        nextX = nextPoint.plotX;
-                        nextY = nextPoint.plotY;
-                        leftContX = (smoothing * plotX + lastX) / denom;
-                        leftContY = (smoothing * plotY + lastY) / denom;
-                        rightContX = (smoothing * plotX + nextX) / denom;
-                        rightContY = (smoothing * plotY + nextY) / denom;
-                        distanceLeftControlPoint = Math.sqrt(Math.pow(leftContX - plotX, 2) + Math.pow(leftContY - plotY, 2));
-                        distanceRightControlPoint = Math.sqrt(Math.pow(rightContX - plotX, 2) + Math.pow(rightContY - plotY, 2));
-                        leftContAngle = Math.atan2(leftContY - plotY, leftContX - plotX);
-                        rightContAngle = Math.atan2(rightContY - plotY, rightContX - plotX);
-                        jointAngle = (Math.PI / 2) + ((leftContAngle + rightContAngle) / 2);
-
-
-                        // Ensure the right direction, jointAngle should be in the same quadrant as leftContAngle
-                        if (Math.abs(leftContAngle - jointAngle) > Math.PI / 2) {
-                            jointAngle -= Math.PI;
-                        }
-
-                        // Find the corrected control points for a spline straight through the point
-                        leftContX = plotX + Math.cos(jointAngle) * distanceLeftControlPoint;
-                        leftContY = plotY + Math.sin(jointAngle) * distanceLeftControlPoint;
-                        rightContX = plotX + Math.cos(Math.PI + jointAngle) * distanceRightControlPoint;
-                        rightContY = plotY + Math.sin(Math.PI + jointAngle) * distanceRightControlPoint;
-
-                        // Record for drawing in next point
-                        point.rightContX = rightContX;
-                        point.rightContY = rightContY;
-
-                    }
-
-
                     // moveTo or lineTo
                     if (!i) {
-                        ret = ['M', plotX, plotY];
+                        ret = ['M', point.plotX, point.plotY];
                     } else { // curve from last point to this
+                        connectors = this.getConnectors(segment, i, true, this.connectEnds);
                         ret = [
                             'C',
-                            lastPoint.rightContX || lastPoint.plotX,
-                            lastPoint.rightContY || lastPoint.plotY,
-                            leftContX || plotX,
-                            leftContY || plotY,
-                            plotX,
-                            plotY
+                            connectors.prevPointCont.rightContX,
+                            connectors.prevPointCont.rightContY,
+                            connectors.leftContX,
+                            connectors.leftContY,
+                            connectors.plotX,
+                            connectors.plotY
                         ];
-                        lastPoint.rightContX = lastPoint.rightContY = null; // reset for updating series later
                     }
-
-
                 } else {
                     ret = proceed.call(this, segment, point, i);
                 }
                 return ret;
             });
+
+            // #6430 Areasplinerange series use unwrapped getPointSpline method, so we need to set this method again.
+            if (seriesTypes.areasplinerange) {
+                seriesTypes.areasplinerange.prototype.getPointSpline = seriesTypes.spline.prototype.getPointSpline;
+            }
         }
 
         /**
@@ -2721,7 +2871,8 @@
         wrap(seriesProto, 'getGraphPath', function(proceed, points) {
             var series = this,
                 i,
-                firstValid;
+                firstValid,
+                popLastPoint;
 
             // Connect the path
             if (this.chart.polar) {
@@ -2737,6 +2888,7 @@
                 if (this.options.connectEnds !== false && firstValid !== undefined) {
                     this.connectEnds = true; // re-used in splines
                     points.splice(points.length, 0, points[firstValid]);
+                    popLastPoint = true;
                 }
 
                 // For area charts, pseudo points are added to the graph, now we need to translate these
@@ -2748,8 +2900,15 @@
             }
 
             // Run uber method
-            return proceed.apply(this, [].slice.call(arguments, 1));
+            var ret = proceed.apply(this, [].slice.call(arguments, 1));
 
+            /** #6212 points.splice method is adding points to an array. In case of areaspline getGraphPath method is used two times
+             * and in both times points are added to an array. That is why points.pop is used, to get unmodified points.
+             */
+            if (popLastPoint) {
+                points.pop();
+            }
+            return ret;
         });
 
 
@@ -2958,5 +3117,38 @@
             return ret;
         });
 
+        wrap(H.Chart.prototype, 'getAxes', function(proceed) {
+
+            if (!this.pane) {
+                this.pane = [];
+            }
+            each(H.splat(this.options.pane), function(paneOptions) {
+                new H.Pane( // eslint-disable-line no-new
+                    paneOptions,
+                    this
+                );
+            }, this);
+
+            proceed.call(this);
+        });
+
+        wrap(H.Chart.prototype, 'drawChartBox', function(proceed) {
+            proceed.call(this);
+
+            each(this.pane, function(pane) {
+                pane.render();
+            });
+        });
+
+        /**
+         * Extend chart.get to also search in panes. Used internally in responsiveness
+         * and chart.update.
+         */
+        wrap(H.Chart.prototype, 'get', function(proceed, id) {
+            return H.find(this.pane, function(pane) {
+                return pane.options.id === id;
+            }) || proceed.call(this, id);
+        });
+
     }(Highcharts));
 }));