highcharts 10.2.1 → 10.3.1

package/highcharts-more.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v10.2.1 (2022-08-29)
+ * @license Highcharts JS v10.3.1 (2022-10-31)
  *
  * (c) 2009-2021 Torstein Honsi
  *
@@ -46,6 +46,8 @@
          *
          * */
         var addEvent = U.addEvent,
+            correctFloat = U.correctFloat,
+            defined = U.defined,
             extend = U.extend,
             merge = U.merge,
             pick = U.pick,
@@ -389,21 +391,52 @@
          * Element's x coordinate
          * @param  {number} y
          * Element's y coordinate
+         * @param  {Array<number>} inverted
+         * `Chart.inverted` param
          * @param  {Array<number>} center
          * Pane's center (x, y) and diameter
-         */
-        function isInsidePane(x, y, center) {
-            return Math.sqrt(Math.pow(x - center[0], 2) + Math.pow(y - center[1], 2)) <= center[2] / 2;
+         * @param  {number} startAngle
+         * Pane's normalized start angle in radians (<-PI, PI>)
+         * @param  {number} endAngle
+         * Pane's normalized end angle in radians (<-PI, PI>)
+         */
+        function isInsidePane(x, y, center, startAngle, endAngle) {
+            var insideSlice = true;
+            var cx = center[0],
+                cy = center[1];
+            var distance = Math.sqrt(Math.pow(x - cx, 2) + Math.pow(y - cy, 2));
+            if (defined(startAngle) && defined(endAngle)) {
+                // Round angle to N-decimals to avoid numeric errors
+                var angle = Math.atan2(correctFloat(y - cy, 8),
+                    correctFloat(x - cx, 8));
+                // Ignore full circle panes:
+                if (endAngle !== startAngle) {
+                    // If normalized start angle is bigger than normalized end,
+                    // it means angles have different signs. In such situation we
+                    // check the <-PI, startAngle> and <endAngle, PI> ranges.
+                    if (startAngle > endAngle) {
+                        insideSlice = (angle >= startAngle &&
+                            angle <= Math.PI) || (angle <= endAngle &&
+                            angle >= -Math.PI);
+                    }
+                    else {
+                        // In this case, we simple check if angle is within the
+                        // <startAngle, endAngle> range
+                        insideSlice = angle >= startAngle &&
+                            angle <= correctFloat(endAngle, 8);
+                    }
+                }
+            }
+            // Round up radius because x and y values are rounded
+            return distance <= Math.ceil(center[2] / 2) && insideSlice;
         }
         Chart.prototype.getHoverPane = function (eventArgs) {
             var chart = this;
             var hoverPane;
             if (eventArgs) {
                 chart.pane.forEach(function (pane) {
-                    var plotX = eventArgs.chartX - chart.plotLeft,
-                        plotY = eventArgs.chartY - chart.plotTop,
-                        x = chart.inverted ? plotY : plotX,
-                        y = chart.inverted ? plotX : plotY;
+                    var x = eventArgs.chartX - chart.plotLeft,
+                        y = eventArgs.chartY - chart.plotTop;
                     if (isInsidePane(x, y, pane.center)) {
                         hoverPane = pane;
                     }
@@ -411,10 +444,17 @@
             }
             return hoverPane;
         };
+        // Check if (x, y) position is within pane for polar
         addEvent(Chart, 'afterIsInsidePlot', function (e) {
+            var _a;
             var chart = this;
             if (chart.polar) {
-                e.isInsidePlot = chart.pane.some(function (pane) { return isInsidePane(e.x, e.y, pane.center); });
+                var x_1 = e.x - (e.options.paneCoordinates ? chart.plotLeft : 0),
+                    y_1 = e.y - (e.options.paneCoordinates ? chart.plotTop : 0);
+                if (e.options.inverted) {
+                    _a = [y_1, x_1], x_1 = _a[0], y_1 = _a[1];
+                }
+                e.isInsidePlot = chart.pane.some(function (pane) { return isInsidePane(x_1, y_1, pane.center, pane.axis && pane.axis.normalizedStartAngleRad, pane.axis && pane.axis.normalizedEndAngleRad); });
             }
         });
         addEvent(Pointer, 'beforeGetHoverData', function (eventArgs) {
@@ -507,10 +547,6 @@
                  */
                 _this.low = void 0;
                 _this.options = void 0;
-                _this.plotHigh = void 0;
-                _this.plotLow = void 0;
-                _this.plotHighX = void 0;
-                _this.plotLowX = void 0;
                 _this.plotX = void 0;
                 _this.series = void 0;
                 return _this;
@@ -540,9 +576,9 @@
                     series.stateMarkerGraphic = series.upperStateMarkerGraphic;
                 }
                 // Change state also for the top marker
-                this.graphic = this.upperGraphic;
+                this.graphic = this.graphics && this.graphics[1];
                 this.plotY = this.plotHigh;
-                if (isPolar) {
+                if (isPolar && isNumber(this.plotHighX)) {
                     this.plotX = this.plotHighX;
                 }
                 // Top state:
@@ -550,8 +586,8 @@
                 this.state = prevState;
                 // Now restore defaults
                 this.plotY = this.plotLow;
-                this.graphic = this.lowerGraphic;
-                if (isPolar) {
+                this.graphic = this.graphics && this.graphics[0];
+                if (isPolar && isNumber(this.plotLowX)) {
                     this.plotX = this.plotLowX;
                 }
                 if (series.stateMarkerGraphic) {
@@ -568,7 +604,7 @@
                 var path = [];
                 // Bottom halo
                 this.plotY = this.plotLow;
-                if (isPolar) {
+                if (isPolar && isNumber(this.plotLowX)) {
                     this.plotX = this.plotLowX;
                 }
                 if (this.isInside) {
@@ -576,7 +612,7 @@
                 }
                 // Top halo
                 this.plotY = this.plotHigh;
-                if (isPolar) {
+                if (isPolar && isNumber(this.plotHighX)) {
                     this.plotX = this.plotHighX;
                 }
                 if (this.isTopInside) {
@@ -628,9 +664,11 @@
             AreaSeries = _a.area,
             areaProto = _a.area.prototype,
             columnProto = _a.column.prototype;
-        var defined = U.defined,
+        var addEvent = U.addEvent,
+            defined = U.defined,
             extend = U.extend,
             isArray = U.isArray,
+            isNumber = U.isNumber,
             pick = U.pick,
             merge = U.merge;
         /* *
@@ -699,6 +737,9 @@
                  * @private
                  */
                 lineWidth: 1,
+                /**
+                 * @type {number|null}
+                 */
                 threshold: null,
                 tooltip: {
                     pointFormat: '<span style="color:{series.color}">\u25CF</span> ' +
@@ -819,49 +860,11 @@
                 // Find the polar plotX and plotY
                 var chart = this.chart,
                     xy = this.xAxis.postTranslate(point.rectPlotX || 0,
-                    this.yAxis.len - point.plotHigh);
+                    this.yAxis.len - (point.plotHigh || 0));
                 point.plotHighX = xy.x - chart.plotLeft;
                 point.plotHigh = xy.y - chart.plotTop;
                 point.plotLowX = point.plotX;
             };
-            /**
-             * Translate data points from raw values x and y to plotX and plotY.
-             * @private
-             */
-            AreaRangeSeries.prototype.translate = function () {
-                var series = this;
-                areaProto.translate.apply(series);
-                // Set plotLow and plotHigh
-                series.points.forEach(function (point, i) {
-                    var high = point.high,
-                        plotY = point.plotY;
-                    if (point.isNull) {
-                        point.plotY = null;
-                    }
-                    else {
-                        var yAxis = series.chart.hasParallelCoordinates ?
-                                series.chart.yAxis[i] :
-                                series.yAxis;
-                        point.plotLow = plotY;
-                        // Calculate plotHigh value based on each yAxis scale (#15752)
-                        point.plotHigh = yAxis.translate(series.dataModify ?
-                            series.dataModify.modifyValue(high) : high, 0, 1, 0, 1);
-                        if (series.dataModify) {
-                            point.yBottom = point.plotHigh;
-                        }
-                    }
-                });
-                // Postprocess plotHigh
-                if (this.chart.polar) {
-                    this.points.forEach(function (point) {
-                        series.highToXY(point);
-                        point.tooltipPos = [
-                            (point.plotHighX + point.plotLowX) / 2,
-                            (point.plotHigh + point.plotLow) / 2
-                        ];
-                    });
-                }
-            };
             /**
              * Extend the line series' getSegmentPath method by applying the segment
              * path to both lower and higher values of the range.
@@ -1012,12 +1015,16 @@
                         while (i--) {
                             point = data[i];
                             if (point) {
+                                var _a = point.plotHigh,
+                                    plotHigh = _a === void 0 ? 0 : _a,
+                                    _b = point.plotLow,
+                                    plotLow = _b === void 0 ? 0 : _b;
                                 up = upperDataLabelOptions.inside ?
-                                    point.plotHigh < point.plotLow :
-                                    point.plotHigh > point.plotLow;
+                                    plotHigh < plotLow :
+                                    plotHigh > plotLow;
                                 point.y = point.high;
                                 point._plotY = point.plotY;
-                                point.plotY = point.plotHigh;
+                                point.plotY = plotHigh;
                                 // Store original data labels and set preliminary label
                                 // objects to be picked up in the uber method
                                 originalDataLabels[i] = point.dataLabel;
@@ -1065,9 +1072,13 @@
                         while (i--) {
                             point = data[i];
                             if (point) {
+                                var _c = point.plotHigh,
+                                    plotHigh = _c === void 0 ? 0 : _c,
+                                    _d = point.plotLow,
+                                    plotLow = _d === void 0 ? 0 : _d;
                                 up = lowerDataLabelOptions.inside ?
-                                    point.plotHigh < point.plotLow :
-                                    point.plotHigh > point.plotLow;
+                                    plotHigh < plotLow :
+                                    plotHigh > plotLow;
                                 // Set the default offset
                                 point.below = !up;
                                 if (inverted) {
@@ -1123,6 +1134,7 @@
                 i = 0;
                 while (i < pointLength) {
                     point = series.points[i];
+                    point.graphics = point.graphics || [];
                     // Save original props to be overridden by temporary props for top
                     // points
                     point.origProps = {
@@ -1133,8 +1145,10 @@
                         zone: point.zone,
                         y: point.y
                     };
-                    point.lowerGraphic = point.graphic;
-                    point.graphic = point.upperGraphic;
+                    if (point.graphic) {
+                        point.graphics[0] = point.graphic;
+                    }
+                    point.graphic = point.graphics[1];
                     point.plotY = point.plotHigh;
                     if (defined(point.plotHighX)) {
                         point.plotX = point.plotHighX;
@@ -1159,8 +1173,11 @@
                 i = 0;
                 while (i < pointLength) {
                     point = series.points[i];
-                    point.upperGraphic = point.graphic;
-                    point.graphic = point.lowerGraphic;
+                    point.graphics = point.graphics || [];
+                    if (point.graphic) {
+                        point.graphics[1] = point.graphic;
+                    }
+                    point.graphic = point.graphics[0];
                     if (point.origProps) {
                         extend(point, point.origProps);
                         delete point.origProps;
@@ -1171,6 +1188,44 @@
             AreaRangeSeries.defaultOptions = merge(AreaSeries.defaultOptions, areaRangeSeriesOptions);
             return AreaRangeSeries;
         }(AreaSeries));
+        addEvent(AreaRangeSeries, 'afterTranslate', function () {
+            // Set plotLow and plotHigh
+            var _this = this;
+            // Rules out lollipop, but lollipop should not inherit range series in the
+            // first place
+            if (this.pointArrayMap.join(',') === 'low,high') {
+                this.points.forEach(function (point) {
+                    var high = point.high,
+                        plotY = point.plotY;
+                    if (point.isNull) {
+                        point.plotY = void 0;
+                    }
+                    else {
+                        point.plotLow = plotY;
+                        // Calculate plotHigh value based on each yAxis scale (#15752)
+                        point.plotHigh = isNumber(high) ? _this.yAxis.translate(_this.dataModify ?
+                            _this.dataModify.modifyValue(high) : high, false, true, void 0, true) : void 0;
+                        if (_this.dataModify) {
+                            point.yBottom = point.plotHigh;
+                        }
+                    }
+                });
+            }
+        }, { order: 0 });
+        addEvent(AreaRangeSeries, 'afterTranslate', function () {
+            var _this = this;
+            // Postprocess after the PolarComposition's afterTranslate
+            if (this.chart.polar) {
+                this.points.forEach(function (point) {
+                    _this.highToXY(point);
+                    point.plotLow = point.plotY;
+                    point.tooltipPos = [
+                        ((point.plotHighX || 0) + (point.plotLowX || 0)) / 2,
+                        ((point.plotHigh || 0) + (point.plotLow || 0)) / 2
+                    ];
+                });
+            }
+        }, { order: 3 });
         extend(AreaRangeSeries.prototype, {
             deferTranslatePolar: true,
             pointArrayMap: ['low', 'high'],
@@ -1778,9 +1833,12 @@
              * @optionparent plotOptions.boxplot
              */
             BoxPlotSeries.defaultOptions = merge(ColumnSeries.defaultOptions, {
+                /**
+                 * @type {number|null}
+                 */
                 threshold: null,
                 tooltip: {
-                    pointFormat: '<span style="color:{point.color}">\u25CF</span> <b> ' +
+                    pointFormat: '<span style="color:{point.color}">\u25CF</span> <b>' +
                         '{series.name}</b><br/>' +
                         'Maximum: {point.high}<br/>' +
                         'Upper quartile: {point.q3}<br/>' +
@@ -2546,11 +2604,6 @@
                     this.chart = void 0;
                 this.fontMetrics = void 0;
                 this.legend = void 0;
-                this.legendGroup = void 0;
-                this.legendItem = void 0;
-                this.legendItemHeight = void 0;
-                this.legendItemWidth = void 0;
-                this.legendSymbol = void 0;
                 this.maxLabel = void 0;
                 this.movementX = void 0;
                 this.ranges = void 0;
@@ -2599,8 +2652,9 @@
              */
             BubbleLegendItem.prototype.drawLegendSymbol = function (legend) {
                 var chart = this.chart,
-                    options = this.options,
                     itemDistance = pick(legend.options.itemDistance, 20),
+                    legendItem = this.legendItem || {},
+                    options = this.options,
                     ranges = options.ranges,
                     connectorDistance = options.connectorDistance;
                 var connectorSpace;
@@ -2630,8 +2684,8 @@
                 this.maxLabel = maxLabel;
                 this.movementX = options.labels.align === 'left' ?
                     connectorSpace : 0;
-                this.legendItemWidth = size + connectorSpace + itemDistance;
-                this.legendItemHeight = size + this.fontMetrics.h / 2;
+                legendItem.labelWidth = size + connectorSpace + itemDistance;
+                legendItem.labelHeight = size + this.fontMetrics.h / 2;
             };
             /**
              * Set style options for each bubbleLegend range.
@@ -2705,11 +2759,12 @@
                 return bubbleSeries.getRadius.call(this, zMin, zMax, minSize, maxSize, value);
             };
             /**
-             * Render the legendSymbol group.
+             * Render the legendItem group.
              * @private
              */
             BubbleLegendItem.prototype.render = function () {
-                var renderer = this.chart.renderer,
+                var legendItem = this.legendItem || {},
+                    renderer = this.chart.renderer,
                     zThreshold = this.options.zThreshold;
                 if (!this.symbols) {
                     this.symbols = {
@@ -2719,19 +2774,20 @@
                     };
                 }
                 // Nesting SVG groups to enable handleOverflow
-                this.legendSymbol = renderer.g('bubble-legend');
-                this.legendItem = renderer.g('bubble-legend-item');
+                legendItem.symbol = renderer.g('bubble-legend');
+                legendItem.label = renderer.g('bubble-legend-item');
                 // To enable default 'hideOverlappingLabels' method
-                this.legendSymbol.translateX = 0;
-                this.legendSymbol.translateY = 0;
-                this.ranges.forEach(function (range) {
+                legendItem.symbol.translateX = 0;
+                legendItem.symbol.translateY = 0;
+                for (var _i = 0, _a = this.ranges; _i < _a.length; _i++) {
+                    var range = _a[_i];
                     if (range.value >= zThreshold) {
                         this.renderRange(range);
                     }
-                }, this);
+                }
                 // To use handleOverflow method
-                this.legendSymbol.add(this.legendItem);
-                this.legendItem.add(this.legendGroup);
+                legendItem.symbol.add(legendItem.label);
+                legendItem.label.add(legendItem.group);
                 this.hideOverlappingLabels();
             };
             /**
@@ -2787,7 +2843,7 @@
                         bubbleSeries.colorIndex + ' ' :
                     '') +
                     'highcharts-bubble-legend-symbol ' +
-                    (options.className || '')).add(this.legendSymbol));
+                    (options.className || '')).add(this.legendItem.symbol));
                 // Render connector
                 symbols.connectors.push(renderer
                     .path(renderer.crispLine([
@@ -2799,7 +2855,7 @@
                     'highcharts-color-' +
                         this.options.seriesIndex + ' ' : '') +
                     'highcharts-bubble-legend-connectors ' +
-                    (options.connectorClassName || '')).add(this.legendSymbol));
+                    (options.connectorClassName || '')).add(this.legendItem.symbol));
                 // Render label
                 var label = renderer
                         .text(this.formatLabel(range),
@@ -2808,7 +2864,7 @@
                         .attr((styledMode ? {} : range.labelAttribs))
                         .css(styledMode ? {} : labelsOptions.style)
                         .addClass('highcharts-bubble-legend-labels ' +
-                        (options.labels.className || '')).add(this.legendSymbol);
+                        (options.labels.className || '')).add(this.legendItem.symbol);
                 labels.push(label);
                 // To enable default 'hideOverlappingLabels' method
                 label.placed = true;
@@ -3034,7 +3090,7 @@
 
         return BubbleLegendItem;
     });
-    _registerModule(_modules, 'Series/Bubble/BubbleLegendComposition.js', [_modules['Series/Bubble/BubbleLegendDefaults.js'], _modules['Series/Bubble/BubbleLegendItem.js'], _modules['Core/DefaultOptions.js'], _modules['Core/Utilities.js']], function (BubbleLegendDefaults, BubbleLegendItem, D, U) {
+    _registerModule(_modules, 'Series/Bubble/BubbleLegendComposition.js', [_modules['Series/Bubble/BubbleLegendDefaults.js'], _modules['Series/Bubble/BubbleLegendItem.js'], _modules['Core/Defaults.js'], _modules['Core/Utilities.js']], function (BubbleLegendDefaults, BubbleLegendItem, D, U) {
         /* *
          *
          *  (c) 2010-2021 Highsoft AS
@@ -3070,7 +3126,8 @@
                 legend = chart.legend,
                 bubbleSeries = getVisibleBubbleSeriesIndex(chart) >= 0;
             var bubbleLegendOptions,
-                bubbleSizes;
+                bubbleSizes,
+                legendItem;
             if (legend && legend.options.enabled && legend.bubbleLegend &&
                 legend.options.bubbleLegend.autoRanges && bubbleSeries) {
                 bubbleLegendOptions = legend.bubbleLegend.options;
@@ -3080,7 +3137,10 @@
                 if (!bubbleLegendOptions.placed) {
                     legend.group.placed = false;
                     legend.allItems.forEach(function (item) {
-                        item.legendGroup.translateY = null;
+                        legendItem = item.legendItem || {};
+                        if (legendItem.group) {
+                            legendItem.group.translateY = null;
+                        }
                     });
                 }
                 // Create legend with bubbleLegend
@@ -3193,18 +3253,20 @@
                 lines = [],
                 length = items.length;
             var lastLine,
+                legendItem,
+                legendItem2,
                 i = 0,
                 j = 0;
             for (i = 0; i < length; i++) {
-                if (items[i].legendItemHeight) {
+                legendItem = items[i].legendItem || {};
+                legendItem2 = (items[i + 1] || {}).legendItem || {};
+                if (legendItem.labelHeight) {
                     // for bubbleLegend
-                    items[i].itemHeight = items[i].legendItemHeight;
+                    items[i].itemHeight = legendItem.labelHeight;
                 }
                 if ( // Line break
                 items[i] === items[length - 1] ||
-                    items[i + 1] &&
-                        items[i]._legendItemPos[1] !==
-                            items[i + 1]._legendItemPos[1]) {
+                    legendItem.y !== legendItem2.y) {
                     lines.push({ height: 0 });
                     lastLine = lines[lines.length - 1];
                     // Find the highest item in line
@@ -3291,25 +3353,29 @@
             var orgTranslateX,
                 orgTranslateY,
                 movementX,
+                legendItem,
                 actualLine = 0;
             items.forEach(function (item, index) {
-                orgTranslateX = item.legendGroup.translateX;
-                orgTranslateY = item._legendItemPos[1];
+                legendItem = item.legendItem || {};
+                if (!legendItem.group) {
+                    return;
+                }
+                orgTranslateX = legendItem.group.translateX || 0;
+                orgTranslateY = legendItem.y || 0;
                 movementX = item.movementX;
                 if (movementX || (rtl && item.ranges)) {
                     movementX = rtl ?
                         orgTranslateX - item.options.maxSize / 2 :
                         orgTranslateX + movementX;
-                    item.legendGroup.attr({ translateX: movementX });
+                    legendItem.group.attr({ translateX: movementX });
                 }
                 if (index > lines[actualLine].step) {
                     actualLine++;
                 }
-                item.legendGroup.attr({
+                legendItem.group.attr({
                     translateY: Math.round(orgTranslateY + lines[actualLine].height / 2)
                 });
-                item._legendItemPos[1] = orgTranslateY +
-                    lines[actualLine].height / 2;
+                legendItem.y = orgTranslateY + lines[actualLine].height / 2;
             });
         }
         /* *
@@ -4250,6 +4316,7 @@
             columnProto = _a.column.prototype;
         var clamp = U.clamp,
             extend = U.extend,
+            isNumber = U.isNumber,
             merge = U.merge,
             pick = U.pick;
         /* *
@@ -4357,45 +4424,51 @@
                 // Set plotLow and plotHigh
                 this.points.forEach(function (point) {
                     var shapeArgs = point.shapeArgs || {},
-                        minPointLength = _this.options.minPointLength;
-                    point.plotHigh = plotHigh = safeBounds(yAxis.translate(point.high, 0, 1, 0, 1));
-                    point.plotLow = safeBounds(point.plotY);
-                    // adjust shape
-                    y = plotHigh;
-                    height = pick(point.rectPlotY, point.plotY) - plotHigh;
-                    // Adjust for minPointLength
-                    if (Math.abs(height) < minPointLength) {
-                        heightDifference = (minPointLength - height);
-                        height += heightDifference;
-                        y -= heightDifference / 2;
-                        // Adjust for negative ranges or reversed Y axis (#1457)
-                    }
-                    else if (height < 0) {
-                        height *= -1;
-                        y -= height;
-                    }
-                    if (isRadial && _this.polar) {
-                        start = point.barX + startAngleRad;
-                        point.shapeType = 'arc';
-                        point.shapeArgs = _this.polar.arc(y + height, y, start, start + point.pointWidth);
-                    }
-                    else {
-                        shapeArgs.height = height;
-                        shapeArgs.y = y;
-                        var _a = shapeArgs.x,
-                            x = _a === void 0 ? 0 : _a,
-                            _b = shapeArgs.width,
-                            width = _b === void 0 ? 0 : _b;
-                        point.tooltipPos = chart.inverted ?
-                            [
-                                yAxis.len + yAxis.pos - chart.plotLeft - y - height / 2,
-                                xAxis.len + xAxis.pos - chart.plotTop - x - width / 2,
+                        minPointLength = _this.options.minPointLength,
+                        plotY = point.plotY,
+                        plotHigh = yAxis.translate(point.high, 0, 1, 0, 1);
+                    if (isNumber(plotHigh) && isNumber(plotY)) {
+                        point.plotHigh = safeBounds(plotHigh);
+                        point.plotLow = safeBounds(plotY);
+                        // adjust shape
+                        y = point.plotHigh;
+                        height = pick(point.rectPlotY, point.plotY) - point.plotHigh;
+                        // Adjust for minPointLength
+                        if (Math.abs(height) < minPointLength) {
+                            heightDifference = (minPointLength - height);
+                            height += heightDifference;
+                            y -= heightDifference / 2;
+                            // Adjust for negative ranges or reversed Y axis (#1457)
+                        }
+                        else if (height < 0) {
+                            height *= -1;
+                            y -= height;
+                        }
+                        if (isRadial && _this.polar) {
+                            start = point.barX + startAngleRad;
+                            point.shapeType = 'arc';
+                            point.shapeArgs = _this.polar.arc(y + height, y, start, start + point.pointWidth);
+                        }
+                        else {
+                            shapeArgs.height = height;
+                            shapeArgs.y = y;
+                            var _a = shapeArgs.x,
+                                x = _a === void 0 ? 0 : _a,
+                                _b = shapeArgs.width,
+                                width = _b === void 0 ? 0 : _b;
+                            point.tooltipPos = chart.inverted ?
+                                [
+                                    yAxis.len + yAxis.pos - chart.plotLeft - y -
+                                        height / 2,
+                                    xAxis.len + xAxis.pos - chart.plotTop - x -
+                                        width / 2,
+                                    height
+                                ] : [
+                                xAxis.left - chart.plotLeft + x + width / 2,
+                                yAxis.pos - chart.plotTop + y + height / 2,
                                 height
-                            ] : [
-                            xAxis.left - chart.plotLeft + x + width / 2,
-                            yAxis.pos - chart.plotTop + y + height / 2,
-                            height
-                        ]; // don't inherit from column tooltip position - #3372
+                            ]; // don't inherit from column tooltip position - #3372
+                        }
                     }
                 });
             };
@@ -4896,7 +4969,7 @@
 
         return ColumnPyramidSeries;
     });
-    _registerModule(_modules, 'Series/ErrorBar/ErrorBarSeries.js', [_modules['Series/BoxPlot/BoxPlotSeries.js'], _modules['Series/Column/ColumnSeries.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (BoxPlotSeries, ColumnSeries, SeriesRegistry, U) {
+    _registerModule(_modules, 'Series/ErrorBar/ErrorBarSeriesDefaults.js', [], function () {
         /* *
          *
          *  (c) 2010-2021 Torstein Honsi
@@ -4906,98 +4979,30 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        var __extends = (this && this.__extends) || (function () {
-                var extendStatics = function (d,
-            b) {
-                    extendStatics = Object.setPrototypeOf ||
-                        ({ __proto__: [] } instanceof Array && function (d,
-            b) { d.__proto__ = b; }) ||
-                        function (d,
-            b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-                return extendStatics(d, b);
-            };
-            return function (d, b) {
-                extendStatics(d, b);
-                function __() { this.constructor = d; }
-                d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-            };
-        })();
-        var AreaRangeSeries = SeriesRegistry.seriesTypes.arearange;
-        var merge = U.merge,
-            extend = U.extend;
-        /**
-         * Errorbar series type
+        /* *
          *
-         * @private
-         * @class
-         * @name Highcharts.seriesTypes.errorbar
+         *  API Options
          *
-         * @augments Highcharts.Series
+         * */
+        /**
+         * Error bars are a graphical representation of the variability of data and
+         * are used on graphs to indicate the error, or uncertainty in a reported
+         * measurement.
          *
+         * @sample highcharts/demo/error-bar/
+         *         Error bars on a column series
+         * @sample highcharts/series-errorbar/on-scatter/
+         *         Error bars on a scatter series
+         * @sample highcharts/series-errorbar/datalabels/
+         *         Error bars with data labels
+         *
+         * @extends      plotOptions.boxplot
+         * @excluding    boostBlending, boostThreshold
+         * @product      highcharts
+         * @requires     highcharts-more
+         * @optionparent plotOptions.errorbar
          */
-        var ErrorBarSeries = /** @class */ (function (_super) {
-                __extends(ErrorBarSeries, _super);
-            function ErrorBarSeries() {
-                /* *
-                 *
-                 *  Static properties
-                 *
-                 * */
-                var _this = _super !== null && _super.apply(this,
-                    arguments) || this;
-                /* *
-                 *
-                 *  Properties
-                 *
-                 * */
-                _this.data = void 0;
-                _this.options = void 0;
-                _this.points = void 0;
-                return _this;
-            }
-            /* *
-             *
-             *  Functions
-             *
-             * */
-            // Get the width and X offset, either on top of the linked series
-            // column or standalone
-            ErrorBarSeries.prototype.getColumnMetrics = function () {
-                return ((this.linkedParent && this.linkedParent.columnMetrics) ||
-                    ColumnSeries.prototype.getColumnMetrics.call(this));
-            };
-            ErrorBarSeries.prototype.drawDataLabels = function () {
-                var valKey = this.pointValKey;
-                if (AreaRangeSeries) {
-                    AreaRangeSeries.prototype.drawDataLabels.call(this);
-                    // Arearange drawDataLabels does not reset point.y to high,
-                    // but to low after drawing (#4133)
-                    this.data.forEach(function (point) {
-                        point.y = point[valKey];
-                    });
-                }
-            };
-            // return a plain array for speedy calculation
-            ErrorBarSeries.prototype.toYData = function (point) {
-                return [point.low, point.high];
-            };
-            /**
-             * Error bars are a graphical representation of the variability of data and
-             * are used on graphs to indicate the error, or uncertainty in a reported
-             * measurement.
-             *
-             * @sample highcharts/demo/error-bar/
-             *         Error bars on a column series
-             * @sample highcharts/series-errorbar/on-scatter/
-             *         Error bars on a scatter series
-             *
-             * @extends      plotOptions.boxplot
-             * @excluding    boostBlending, boostThreshold
-             * @product      highcharts highstock
-             * @requires     highcharts-more
-             * @optionparent plotOptions.errorbar
-             */
-            ErrorBarSeries.defaultOptions = merge(BoxPlotSeries.defaultOptions, {
+        var ErrorBarSeriesDefaults = {
                 /**
                  * The main color of the bars. This can be overridden by
                  * [stemColor](#plotOptions.errorbar.stemColor) and
@@ -5015,7 +5020,8 @@
                 grouping: false,
                 /**
                  * The parent series of the error bar. The default value links it to
-                 * the previous series. Otherwise, use the id of the parent series.
+                 * the previous series. Otherwise,
+            use the id of the parent series.
                  *
                  * @since   3.0
                  * @product highcharts
@@ -5025,8 +5031,10 @@
                     pointFormat: '<span style="color:{point.color}">\u25CF</span> {series.name}: <b>{point.low}</b> - <b>{point.high}</b><br/>'
                 },
                 /**
-                 * The line width of the whiskers, the horizontal lines marking
-                 * low and high values. When `null`, the general
+                 * The line width of the whiskers,
+            the horizontal lines marking
+                 * low and high values. When `null`,
+            the general
                  * [lineWidth](#plotOptions.errorbar.lineWidth) applies.
                  *
                  * @sample {highcharts} highcharts/plotoptions/error-bar-styling/
@@ -5037,26 +5045,7 @@
                  * @product highcharts
                  */
                 whiskerWidth: null
-            });
-            return ErrorBarSeries;
-        }(BoxPlotSeries));
-        extend(ErrorBarSeries.prototype, {
-            // array point configs are mapped to this
-            pointArrayMap: ['low', 'high'],
-            pointValKey: 'high',
-            doQuartiles: false
-        });
-        SeriesRegistry.registerSeriesType('errorbar', ErrorBarSeries);
-        /* *
-         *
-         *  Default export
-         *
-         * */
-        /* *
-         *
-         *  API options
-         *
-         * */
+            };
         /**
          * A `errorbar` series. If the [type](#series.errorbar.type) option
          * is not specified, it is inherited from [chart.type](#chart.type).
@@ -5124,6 +5113,125 @@
          * @apioption series.errorbar.data
          */
         ''; // adds doclets above to transpiled file
+        /* *
+         *
+         *  Default Export
+         *
+         * */
+
+        return ErrorBarSeriesDefaults;
+    });
+    _registerModule(_modules, 'Series/ErrorBar/ErrorBarSeries.js', [_modules['Series/BoxPlot/BoxPlotSeries.js'], _modules['Series/Column/ColumnSeries.js'], _modules['Series/ErrorBar/ErrorBarSeriesDefaults.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (BoxPlotSeries, ColumnSeries, ErrorBarSeriesDefaults, SeriesRegistry, U) {
+        /* *
+         *
+         *  (c) 2010-2021 Torstein Honsi
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        var __extends = (this && this.__extends) || (function () {
+                var extendStatics = function (d,
+            b) {
+                    extendStatics = Object.setPrototypeOf ||
+                        ({ __proto__: [] } instanceof Array && function (d,
+            b) { d.__proto__ = b; }) ||
+                        function (d,
+            b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+                return extendStatics(d, b);
+            };
+            return function (d, b) {
+                extendStatics(d, b);
+                function __() { this.constructor = d; }
+                d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+            };
+        })();
+        var AreaRangeSeries = SeriesRegistry.seriesTypes.arearange;
+        var addEvent = U.addEvent,
+            merge = U.merge,
+            extend = U.extend;
+        /* *
+         *
+         *  Class
+         *
+         * */
+        /**
+         * Errorbar series type
+         *
+         * @private
+         * @class
+         * @name Highcharts.seriesTypes.errorbar
+         *
+         * @augments Highcharts.Series
+         *
+         */
+        var ErrorBarSeries = /** @class */ (function (_super) {
+                __extends(ErrorBarSeries, _super);
+            function ErrorBarSeries() {
+                /* *
+                 *
+                 *  Static Properties
+                 *
+                 * */
+                var _this = _super !== null && _super.apply(this,
+                    arguments) || this;
+                /* *
+                 *
+                 *  Properties
+                 *
+                 * */
+                _this.data = void 0;
+                _this.options = void 0;
+                _this.points = void 0;
+                return _this;
+            }
+            /* *
+             *
+             *  Functions
+             *
+             * */
+            ErrorBarSeries.prototype.getColumnMetrics = function () {
+                // Get the width and X offset, either on top of the linked series
+                // column or standalone
+                return ((this.linkedParent && this.linkedParent.columnMetrics) ||
+                    ColumnSeries.prototype.getColumnMetrics.call(this));
+            };
+            ErrorBarSeries.prototype.drawDataLabels = function () {
+                var valKey = this.pointValKey;
+                if (AreaRangeSeries) {
+                    AreaRangeSeries.prototype.drawDataLabels.call(this);
+                    // Arearange drawDataLabels does not reset point.y to high,
+                    // but to low after drawing (#4133)
+                    this.data.forEach(function (point) {
+                        point.y = point[valKey];
+                    });
+                }
+            };
+            ErrorBarSeries.prototype.toYData = function (point) {
+                // return a plain array for speedy calculation
+                return [point.low, point.high];
+            };
+            ErrorBarSeries.defaultOptions = merge(BoxPlotSeries.defaultOptions, ErrorBarSeriesDefaults);
+            return ErrorBarSeries;
+        }(BoxPlotSeries));
+        addEvent(ErrorBarSeries, 'afterTranslate', function () {
+            this.points.forEach(function (point) {
+                point.plotLow = point.plotY;
+            });
+        }, { order: 0 });
+        extend(ErrorBarSeries.prototype, {
+            // pointClass: ErrorBarPoint, // just a declaration
+            pointArrayMap: ['low', 'high'],
+            pointValKey: 'high',
+            doQuartiles: false
+        });
+        SeriesRegistry.registerSeriesType('errorbar', ErrorBarSeries);
+        /* *
+         *
+         *  Default Export
+         *
+         * */
 
         return ErrorBarSeries;
     });
@@ -6268,6 +6376,8 @@
          * @since        7.0.0
          * @requires     highcharts-more
          * @optionparent plotOptions.packedbubble
+         *
+         * @private
          */
         var PackedBubbleSeriesDefaults = {
                 /**
@@ -8424,6 +8534,7 @@
              * */
             PackedBubbleSeries.compose = function (AxisClass, ChartClass, LegendClass, SeriesClass) {
                 BubbleSeries.compose(AxisClass, ChartClass, LegendClass, SeriesClass);
+                DragNodesComposition.compose(ChartClass);
                 PackedBubbleLayout.compose(ChartClass);
             };
             /* *
@@ -8691,20 +8802,11 @@
              * @private
              */
             PackedBubbleSeries.prototype.drawDataLabels = function () {
-                var textPath = this.options.dataLabels.textPath,
-                    points = this.points;
-                // Render node labels:
-                seriesProto.drawDataLabels.apply(this, arguments);
+                seriesProto.drawDataLabels.call(this, this.points);
                 // Render parentNode labels:
                 if (this.parentNode) {
                     this.parentNode.formatPrefix = 'parentNode';
-                    this.points = [this.parentNode];
-                    this.options.dataLabels.textPath =
-                        this.options.dataLabels.parentNodeTextPath;
-                    seriesProto.drawDataLabels.apply(this, arguments);
-                    // Restore nodes
-                    this.points = points;
-                    this.options.dataLabels.textPath = textPath;
+                    seriesProto.drawDataLabels.call(this, [this.parentNode]);
                 }
             };
             /**
@@ -10601,7 +10703,7 @@
 
         return WaterfallSeries;
     });
-    _registerModule(_modules, 'Core/Axis/RadialAxis.js', [_modules['Core/Axis/AxisDefaults.js'], _modules['Core/DefaultOptions.js'], _modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (AxisDefaults, D, H, U) {
+    _registerModule(_modules, 'Core/Axis/RadialAxis.js', [_modules['Core/Axis/AxisDefaults.js'], _modules['Core/Defaults.js'], _modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (AxisDefaults, D, H, U) {
         /* *
          *
          *  (c) 2010-2021 Torstein Honsi
@@ -11226,16 +11328,34 @@
                     pane = this.pane,
                     paneOptions = pane && pane.options;
                 if (!isHidden && pane && (chart.angular || chart.polar)) {
-                    // Start and end angle options are given in degrees relative to
-                    // top, while internal computations are in radians relative to
-                    // right (like SVG).
+                    var fullCircle = Math.PI * 2, 
+                        // Start and end angle options are given in degrees relative to
+                        // top, while internal computations are in radians relative to
+                        // right (like SVG).
+                        start = (pick(paneOptions.startAngle, 0) - 90) * Math.PI / 180,
+                        end = (pick(paneOptions.endAngle,
+                        pick(paneOptions.startAngle, 0) + 360) - 90) * Math.PI / 180;
                     // Y axis in polar charts
                     this.angleRad = (options.angle || 0) * Math.PI / 180;
                     // Gauges
-                    this.startAngleRad =
-                        (paneOptions.startAngle - 90) * Math.PI / 180;
-                    this.endAngleRad = (pick(paneOptions.endAngle, paneOptions.startAngle + 360) - 90) * Math.PI / 180; // Gauges
+                    this.startAngleRad = start;
+                    this.endAngleRad = end;
                     this.offset = options.offset || 0;
+                    // Normalize Start and End to <0, 2*PI> range
+                    // (in degrees: <0,360>)
+                    var normalizedStart = (start % fullCircle + fullCircle) %
+                            fullCircle,
+                        normalizedEnd = (end % fullCircle + fullCircle) % fullCircle;
+                    // Move normalized angles to <-PI, PI> range (<-180, 180>)
+                    // to match values returned by Math.atan2()
+                    if (normalizedStart > Math.PI) {
+                        normalizedStart -= fullCircle;
+                    }
+                    if (normalizedEnd > Math.PI) {
+                        normalizedEnd -= fullCircle;
+                    }
+                    this.normalizedStartAngleRad = normalizedStart;
+                    this.normalizedEndAngleRad = normalizedEnd;
                 }
             }
             /**
@@ -11314,7 +11434,6 @@
                 // Disable certain features on angular and polar axes
                 if (angular || polar) {
                     this.isRadial = true;
-                    chartOptions.chart.zooming.type = null;
                     if (!this.labelCollector) {
                         this.labelCollector = this.createLabelCollector();
                     }
@@ -11627,6 +11746,20 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
+        var __spreadArray = (this && this.__spreadArray) || function (to,
+            from,
+            pack) {
+                if (pack || arguments.length === 2) for (var i = 0,
+            l = from.length,
+            ar; i < l; i++) {
+                    if (ar || !(i in from)) {
+                        if (!ar) ar = Array.prototype.slice.call(from, 0,
+            i);
+                    ar[i] = from[i];
+                }
+            }
+            return to.concat(ar || Array.prototype.slice.call(from));
+        };
         var animObject = A.animObject;
         var addEvent = U.addEvent,
             defined = U.defined,
@@ -11785,6 +11918,26 @@
                 pane.render();
             });
         }
+        /**
+         * If polar has polygonal grid lines, force start and endOnTick on radial axis
+         * @private
+         */
+        function onChartAfterInit(event) {
+            var xAxis = event.args[0].xAxis,
+                yAxis = event.args[0].yAxis,
+                chart = event.args[0].chart;
+            if (xAxis && yAxis) {
+                if (yAxis.gridLineInterpolation === 'polygon') {
+                    xAxis.startOnTick = true;
+                    xAxis.endOnTick = true;
+                }
+                else if (xAxis.gridLineInterpolation === 'polygon' &&
+                    chart.inverted) {
+                    yAxis.startOnTick = true;
+                    yAxis.endOnTick = true;
+                }
+            }
+        }
         function onChartGetAxes() {
             var _this = this;
             if (!this.pane) {
@@ -11796,6 +11949,194 @@
                 paneOptions, _this);
             }, this);
         }
+        /**
+         * Get selection dimensions
+         * @private
+         */
+        function onPointerGetSelectionBox(event) {
+            var marker = event.args.marker,
+                xAxis = this.chart.xAxis[0],
+                yAxis = this.chart.yAxis[0],
+                inverted = this.chart.inverted,
+                radialAxis = inverted ? yAxis : xAxis,
+                linearAxis = inverted ? xAxis : yAxis;
+            if (this.chart.polar) {
+                event.preventDefault();
+                var start = (marker.attr ? marker.attr('start') : marker.start) - radialAxis.startAngleRad;
+                var r = (marker.attr ? marker.attr('r') : marker.r);
+                var end = (marker.attr ? marker.attr('end') : marker.end) - radialAxis.startAngleRad;
+                var innerR = (marker.attr ? marker.attr('innerR') : marker.innerR);
+                event.result.x = start + radialAxis.pos;
+                event.result.width = end - start;
+                // innerR goes from pane's center but toValue computes values from top
+                event.result.y = linearAxis.len + linearAxis.pos - innerR;
+                event.result.height = innerR - r;
+            }
+        }
+        /**
+         * Get attrs for Polar selection marker
+         * @private
+         */
+        function onPointerGetSelectionMarkerAttrs(event) {
+            var chart = this.chart;
+            if (chart.polar && chart.hoverPane && chart.hoverPane.axis) {
+                event.preventDefault();
+                var center = chart.hoverPane.center,
+                    mouseDownX = (this.mouseDownX || 0),
+                    mouseDownY = (this.mouseDownY || 0),
+                    chartY = event.args.chartY,
+                    chartX = event.args.chartX,
+                    fullCircle = Math.PI * 2,
+                    startAngleRad = chart.hoverPane.axis.startAngleRad,
+                    endAngleRad = chart.hoverPane.axis.endAngleRad,
+                    linearAxis = chart.inverted ? chart.xAxis[0] : chart.yAxis[0],
+                    attrs = {};
+                var shapeType = 'arc';
+                attrs.x = center[0] + chart.plotLeft;
+                attrs.y = center[1] + chart.plotTop;
+                // Adjust the width of the selection marker
+                if (this.zoomHor) {
+                    var paneRadRange = startAngleRad > 0 ?
+                            endAngleRad - startAngleRad :
+                            Math.abs(startAngleRad) + Math.abs(endAngleRad);
+                    var startAngle = Math.atan2(mouseDownY - chart.plotTop - center[1],
+                        mouseDownX - chart.plotLeft - center[0]) - startAngleRad,
+                        endAngle = Math.atan2(chartY - chart.plotTop - center[1],
+                        chartX - chart.plotLeft - center[0]) - startAngleRad;
+                    attrs.r = center[2] / 2;
+                    attrs.innerR = center[3] / 2;
+                    if (startAngle <= 0) {
+                        startAngle += fullCircle;
+                    }
+                    if (endAngle <= 0) {
+                        endAngle += fullCircle;
+                    }
+                    if (endAngle < startAngle) {
+                        // Swapping angles
+                        endAngle = [startAngle, startAngle = endAngle][0];
+                    }
+                    // If pane is not a full circle we need to let users zoom to the min
+                    // We do this by swapping angles after pointer crosses
+                    // middle angle (swapAngle) of the missing slice of the pane
+                    if (paneRadRange < fullCircle) {
+                        var swapAngle = endAngleRad + (fullCircle - paneRadRange) / 2;
+                        if (startAngleRad + endAngle > swapAngle) {
+                            endAngle = startAngle;
+                            startAngle = startAngleRad <= 0 ? startAngleRad : 0;
+                        }
+                    }
+                    var start = attrs.start =
+                            Math.max(startAngle + startAngleRad,
+                        startAngleRad),
+                        end = attrs.end =
+                            Math.min(endAngle + startAngleRad,
+                        endAngleRad);
+                    // Adjust the selection shape for polygon grid lines
+                    if (linearAxis.options.gridLineInterpolation === 'polygon') {
+                        var radialAxis = chart.hoverPane.axis,
+                            tickInterval = radialAxis.tickInterval,
+                            min = start - radialAxis.startAngleRad + radialAxis.pos,
+                            max = end - start;
+                        var path = linearAxis.getPlotLinePath({
+                                value: linearAxis.max
+                            }),
+                            pathStart = radialAxis.toValue(min),
+                            pathEnd = radialAxis.toValue(min + max);
+                        if (pathStart < radialAxis.getExtremes().min) {
+                            var _a = radialAxis.getExtremes(),
+                                min_1 = _a.min,
+                                max_1 = _a.max;
+                            pathStart = max_1 - (min_1 - pathStart);
+                        }
+                        if (pathEnd < radialAxis.getExtremes().min) {
+                            var _b = radialAxis.getExtremes(),
+                                min_2 = _b.min,
+                                max_2 = _b.max;
+                            pathEnd = max_2 - (min_2 - pathEnd);
+                        }
+                        if (pathEnd < pathStart) {
+                            // Swapping angles
+                            pathEnd = [pathStart, pathStart = pathEnd][0];
+                        }
+                        // Get trimmed path
+                        path = trimPath(path, pathStart, pathEnd, radialAxis);
+                        // Add center to the path
+                        path.push([
+                            'L', center[0] + chart.plotLeft,
+                            chart.plotTop + center[1]
+                        ]);
+                        attrs.d = path;
+                        shapeType = 'path';
+                    }
+                }
+                // Adjust the height of the selection marker
+                if (this.zoomVert) {
+                    var linearAxis_1 = chart.inverted ? chart.xAxis[0] : chart.yAxis[0];
+                    var innerR = Math.sqrt(Math.pow(mouseDownX - chart.plotLeft - center[0], 2) +
+                            Math.pow(mouseDownY - chart.plotTop - center[1], 2)),
+                        r = Math.sqrt(Math.pow(chartX - chart.plotLeft - center[0], 2) +
+                            Math.pow(chartY - chart.plotTop - center[1], 2));
+                    if (r < innerR) {
+                        // Swapping angles
+                        innerR = [r, r = innerR][0];
+                    }
+                    if (r > center[2] / 2) {
+                        r = center[2] / 2;
+                    }
+                    if (innerR < center[3] / 2) {
+                        innerR = center[3] / 2;
+                    }
+                    if (!this.zoomHor) {
+                        attrs.start = startAngleRad;
+                        attrs.end = endAngleRad;
+                    }
+                    attrs.r = r;
+                    attrs.innerR = innerR;
+                    if (linearAxis_1.options.gridLineInterpolation === 'polygon') {
+                        var end = linearAxis_1.toValue(linearAxis_1.len + linearAxis_1.pos - innerR),
+                            start = linearAxis_1.toValue(linearAxis_1.len + linearAxis_1.pos - r),
+                            path = linearAxis_1.getPlotLinePath({
+                                value: start
+                            }).concat(linearAxis_1.getPlotLinePath({
+                                value: end,
+                                reverse: true
+                            }));
+                        attrs.d = path;
+                        shapeType = 'path';
+                    }
+                }
+                if (this.zoomHor &&
+                    this.zoomVert &&
+                    linearAxis.options.gridLineInterpolation === 'polygon') {
+                    var radialAxis = chart.hoverPane.axis,
+                        start = attrs.start || 0,
+                        end = attrs.end || 0,
+                        min = start - radialAxis.startAngleRad + radialAxis.pos,
+                        max = end - start,
+                        pathStart = radialAxis.toValue(min),
+                        pathEnd = radialAxis.toValue(min + max);
+                    // Trim path
+                    if (attrs.d instanceof Array) {
+                        var innerPath = attrs.d.slice(0,
+                            attrs.d.length / 2),
+                            outerPath = attrs.d.slice(attrs.d.length / 2,
+                            attrs.d.length);
+                        outerPath = __spreadArray([], outerPath, true).reverse();
+                        var radialAxis_1 = chart.hoverPane.axis;
+                        innerPath = trimPath(innerPath, pathStart, pathEnd, radialAxis_1);
+                        outerPath = trimPath(outerPath, pathStart, pathEnd, radialAxis_1);
+                        if (outerPath) {
+                            (outerPath[0][0]) = 'L';
+                        }
+                        outerPath = __spreadArray([], outerPath, true).reverse();
+                        attrs.d = innerPath.concat(outerPath);
+                        shapeType = 'path';
+                    }
+                }
+                event.attrs = attrs;
+                event.shapeType = shapeType;
+            }
+        }
         /**
          * @private
          */
@@ -11832,21 +12173,29 @@
                 else {
                     series.options.findNearestPointBy = 'xy';
                 }
-                // Postprocess plot coordinates
-                if (!series.preventPostTranslate) {
-                    var points = series.points;
-                    var i = points.length,
-                        point = void 0;
-                    while (i--) {
-                        point = points[i];
-                        // Translate plotX, plotY from angle and radius to true plot
-                        // coordinates
-                        series.polar.toXY(point);
-                        // Treat points below Y axis min as null (#10082)
-                        if (!chart_1.hasParallelCoordinates &&
-                            !series.yAxis.reversed &&
-                            point.y < series.yAxis.min) {
-                            point.isNull = true;
+                var points = series.points;
+                var i = points.length;
+                while (i--) {
+                    // Translate plotX, plotY from angle and radius to true plot
+                    // coordinates
+                    if (!series.preventPostTranslate) {
+                        series.polar.toXY(points[i]);
+                    }
+                    // Treat points below Y axis min as null (#10082)
+                    if (!chart_1.hasParallelCoordinates &&
+                        !series.yAxis.reversed) {
+                        if (pick(points[i].y, Number.MIN_VALUE) < series.yAxis.min ||
+                            points[i].x < series.xAxis.min ||
+                            points[i].x > series.xAxis.max) {
+                            // Destroy markers
+                            points[i].isNull = true;
+                            // Destroy column's graphic
+                            points[i].plotY = NaN;
+                        }
+                        else {
+                            // Restore isNull flag
+                            points[i].isNull =
+                                points[i].isValid && !points[i].isValid();
                         }
                     }
                 }
@@ -11892,6 +12241,33 @@
                 clientX: 180 + (Math.atan2(plotX, plotY) * (-180 / Math.PI))
             });
         }
+        /**
+         * Trim polygonal path
+         * @private
+         */
+        function trimPath(path, start, end, radialAxis) {
+            var tickInterval = radialAxis.tickInterval,
+                ticks = radialAxis.tickPositions;
+            var lastTick = find(ticks,
+                function (tick) { return tick >= end; }),
+                firstTick = find(__spreadArray([],
+                ticks,
+                true).reverse(),
+                function (tick) { return tick <= start; });
+            if (!defined(lastTick)) {
+                lastTick = ticks[ticks.length - 1];
+            }
+            if (!defined(firstTick)) {
+                firstTick = ticks[0];
+                lastTick += tickInterval;
+                path[0][0] = 'L';
+                // To do: figure out why -3 or -2
+                path.unshift(path[path.length - 3]);
+            }
+            path = path.slice(ticks.indexOf(firstTick), ticks.indexOf(lastTick) + 1);
+            path[0][0] = 'M';
+            return path;
+        }
         /**
          * Extend chart.get to also search in panes. Used internally in
          * responsiveness and chart.update.
@@ -11922,7 +12298,7 @@
                 else { // Required corrections for data labels of inverted bars
                     // The plotX and plotY are correctly set therefore they
                     // don't need to be swapped (inverted argument is false)
-                    this.forceDL = chart.isInsidePlot(point.plotX, Math.round(point.plotY));
+                    this.forceDL = chart.isInsidePlot(point.plotX, point.plotY);
                     // Checks if labels should be positioned inside
                     if (inside && point.shapeArgs) {
                         shapeArgs = point.shapeArgs;
@@ -12236,6 +12612,16 @@
             }
             return ret;
         }
+        /**
+         * Prevent zooming on mobile devices
+         * @private
+         */
+        function wrapPointerPinch(proceed, e) {
+            if (this.chart.polar) {
+                return;
+            }
+            proceed.call(this, e);
+        }
         /**
          * Define the animate method for regular series
          * @private
@@ -12398,6 +12784,7 @@
                     composedClasses.push(ChartClass);
                     addEvent(ChartClass, 'afterDrawChartBox', onChartAfterDrawChartBox);
                     addEvent(ChartClass, 'getAxes', onChartGetAxes);
+                    addEvent(ChartClass, 'init', onChartAfterInit);
                     var chartProto = ChartClass.prototype;
                     wrap(chartProto, 'get', wrapChartGet);
                 }
@@ -12405,6 +12792,9 @@
                     composedClasses.push(PointerClass);
                     var pointerProto = PointerClass.prototype;
                     wrap(pointerProto, 'getCoordinates', wrapPointerGetCoordinates);
+                    wrap(pointerProto, 'pinch', wrapPointerPinch);
+                    addEvent(PointerClass, 'getSelectionMarkerAttrs', onPointerGetSelectionMarkerAttrs);
+                    addEvent(PointerClass, 'getSelectionBox', onPointerGetSelectionBox);
                 }
                 if (composedClasses.indexOf(SeriesClass) === -1) {
                     composedClasses.push(SeriesClass);