highcharts 9.3.2 → 10.1.0

package/es-modules/Core/Axis/Axis.js

@@ -20,7 +20,13 @@ import H from '../Globals.js';
 var deg2rad = H.deg2rad;
 import Tick from './Tick.js';
 import U from '../Utilities.js';
-var arrayMax = U.arrayMax, arrayMin = U.arrayMin, clamp = U.clamp, correctFloat = U.correctFloat, defined = U.defined, destroyObjectProperties = U.destroyObjectProperties, erase = U.erase, error = U.error, extend = U.extend, fireEvent = U.fireEvent, getMagnitude = U.getMagnitude, isArray = U.isArray, isNumber = U.isNumber, isString = U.isString, merge = U.merge, normalizeTickInterval = U.normalizeTickInterval, objectEach = U.objectEach, pick = U.pick, relativeLength = U.relativeLength, removeEvent = U.removeEvent, splat = U.splat, syncTimeout = U.syncTimeout;
+var arrayMax = U.arrayMax, arrayMin = U.arrayMin, clamp = U.clamp, correctFloat = U.correctFloat, defined = U.defined, destroyObjectProperties = U.destroyObjectProperties, erase = U.erase, error = U.error, extend = U.extend, fireEvent = U.fireEvent, isArray = U.isArray, isNumber = U.isNumber, isString = U.isString, merge = U.merge, normalizeTickInterval = U.normalizeTickInterval, objectEach = U.objectEach, pick = U.pick, relativeLength = U.relativeLength, removeEvent = U.removeEvent, splat = U.splat, syncTimeout = U.syncTimeout;
+var getNormalizedTickInterval = function (axis, tickInterval) { return normalizeTickInterval(tickInterval, void 0, void 0, pick(axis.options.allowDecimals, 
+// If the tick interval is greather than 0.5, avoid decimals, as
+// linear axes are often used to render discrete values (#3363). If
+// a tick amount is set, allow decimals by default, as it increases
+// the chances for a good fit.
+tickInterval < 0.5 || axis.tickAmount !== void 0), !!axis.tickAmount); };
 /* *
  *
  *  Class
@@ -67,7 +73,6 @@ var Axis = /** @class */ (function () {
     function Axis(chart, userOptions) {
         this.alternateBands = void 0;
         this.bottom = void 0;
-        this.categories = void 0;
         this.chart = void 0;
         this.closestPointRange = void 0;
         this.coll = void 0;
@@ -228,7 +233,7 @@ var Axis = /** @class */ (function () {
          * @type {Array<string>}
          * @readonly
          */
-        axis.categories = options.categories || axis.hasNames;
+        axis.categories = options.categories || (axis.hasNames ? [] : void 0);
         if (!axis.names) { // Preserve on update (#3830)
             axis.names = [];
             axis.names.keys = {};
@@ -546,8 +551,9 @@ var Axis = /** @class */ (function () {
             if (doPostTranslate) { // log, ordinal and broken axis
                 val = axis.val2lin(val);
             }
+            var value = sign * (val - localMin) * localA;
             returnValue = isNumber(localMin) ?
-                (sign * (val - localMin) * localA +
+                ((!axis.isRadial ? correctFloat(value) : value) +
                     cvsOffset +
                     (sign * minPixelPadding) +
                     (isNumber(pointPlacement) ?
@@ -902,18 +908,18 @@ var Axis = /** @class */ (function () {
      * The X value that the point is given.
      */
     Axis.prototype.nameToX = function (point) {
-        var explicitCategories = isArray(this.categories), names = explicitCategories ? this.categories : this.names;
+        var explicitCategories = isArray(this.options.categories), names = explicitCategories ? this.categories : this.names;
         var nameX = point.options.x, x;
         point.series.requireSorting = false;
         if (!defined(nameX)) {
-            nameX = this.options.uniqueNames ?
+            nameX = this.options.uniqueNames && names ?
                 (explicitCategories ?
                     names.indexOf(point.name) :
                     pick(names.keys[point.name], -1)) :
                 point.series.autoIncrement();
         }
         if (nameX === -1) { // Not found in currenct categories
-            if (!explicitCategories) {
+            if (!explicitCategories && names) {
                 x = names.length;
             }
         }
@@ -1280,15 +1286,9 @@ var Axis = /** @class */ (function () {
         if (!tickIntervalOption && axis.tickInterval < minTickInterval) {
             axis.tickInterval = minTickInterval;
         }
-        // for linear axes, get magnitude and normalize the interval
+        // For linear axes, normalize the interval
         if (!axis.dateTime && !axis.logarithmic && !tickIntervalOption) {
-            axis.tickInterval = normalizeTickInterval(axis.tickInterval, void 0, getMagnitude(axis.tickInterval), pick(options.allowDecimals, 
-            // If the tick interval is greather than 0.5, avoid
-            // decimals, as linear axes are often used to render
-            // discrete values. #3363. If a tick amount is set, allow
-            // decimals by default, as it increases the chances for a
-            // good fit.
-            axis.tickInterval < 0.5 || this.tickAmount !== void 0), !!this.tickAmount);
+            axis.tickInterval = getNormalizedTickInterval(axis, axis.tickInterval);
         }
         // Prevent ticks from getting so close that we can't draw the labels
         if (!this.tickAmount) {
@@ -1365,7 +1365,21 @@ var Axis = /** @class */ (function () {
                 tickPositions = axis.logarithmic.getLogTickPositions(this.tickInterval, this.min, this.max);
             }
             else {
-                tickPositions = this.getLinearTickPositions(this.tickInterval, this.min, this.max);
+                var startingTickInterval = this.tickInterval;
+                var adjustedTickInterval = startingTickInterval;
+                while (adjustedTickInterval <= startingTickInterval * 2) {
+                    tickPositions = this.getLinearTickPositions(this.tickInterval, this.min, this.max);
+                    // If there are more tick positions than the set tickAmount,
+                    // increase the tickInterval and continue until it fits.
+                    // (#17100)
+                    if (this.tickAmount &&
+                        tickPositions.length > this.tickAmount) {
+                        this.tickInterval = getNormalizedTickInterval(this, adjustedTickInterval *= 1.1);
+                    }
+                    else {
+                        break;
+                    }
+                }
             }
             // Too dense ticks, keep only the first and last (#4477)
             if (tickPositions.length > this.len) {
@@ -1461,38 +1475,87 @@ var Axis = /** @class */ (function () {
      * True if there are other axes.
      */
     Axis.prototype.alignToOthers = function () {
-        var axis = this, others = // Whether there is another axis to pair with this one
-         {}, options = axis.options;
+        var axis = this, alignedAxes = [this], options = axis.options, alignThresholds = (this.coll === 'yAxis' &&
+            this.chart.options.chart.alignThresholds), thresholdAlignments = [];
         var hasOther;
-        if (
-        // Only if alignTicks is true
-        this.chart.options.chart.alignTicks !== false &&
-            options.alignTicks &&
+        axis.thresholdAlignment = void 0;
+        if ((
+        // Only if alignTicks or alignThresholds is true
+        (this.chart.options.chart.alignTicks !== false &&
+            options.alignTicks) || (alignThresholds)) &&
             // Disabled when startOnTick or endOnTick are false (#7604)
             options.startOnTick !== false &&
             options.endOnTick !== false &&
             // Don't try to align ticks on a log axis, they are not evenly
             // spaced (#6021)
             !axis.logarithmic) {
-            this.chart[this.coll].forEach(function (axis) {
-                var otherOptions = axis.options, horiz = axis.horiz, key = [
-                    horiz ? otherOptions.left : otherOptions.top,
-                    otherOptions.width,
-                    otherOptions.height,
-                    otherOptions.pane
+            // Get a key identifying which pane the axis belongs to
+            var getKey_1 = function (axis) {
+                var horiz = axis.horiz, options = axis.options;
+                return [
+                    horiz ? options.left : options.top,
+                    options.width,
+                    options.height,
+                    options.pane
                 ].join(',');
-                if (axis.series.length) { // #4442
-                    if (others[key]) {
-                        hasOther = true; // #4201
-                    }
-                    else {
-                        others[key] = 1;
-                    }
+            };
+            var thisKey_1 = getKey_1(this);
+            this.chart[this.coll].forEach(function (otherAxis) {
+                var series = otherAxis.series;
+                if (
+                // #4442
+                series.length &&
+                    series.some(function (s) { return s.visible; }) &&
+                    otherAxis !== axis &&
+                    getKey_1(otherAxis) === thisKey_1) {
+                    hasOther = true; // #4201
+                    alignedAxes.push(otherAxis);
                 }
             });
         }
+        if (hasOther && alignThresholds) {
+            // Handle alignThresholds. The `thresholdAlignments` array keeps
+            // records of where each axis in the group wants its threshold, from
+            // 0 which is on `axis.min`, to 1 which is on `axis.max`.
+            alignedAxes.forEach(function (otherAxis) {
+                var threshAlign = otherAxis.getThresholdAlignment(axis);
+                if (isNumber(threshAlign)) {
+                    thresholdAlignments.push(threshAlign);
+                }
+            });
+            // For each of the axes in the group, record the average
+            // `thresholdAlignment`.
+            var thresholdAlignment_1 = thresholdAlignments.length > 1 ?
+                thresholdAlignments.reduce(function (sum, n) { return (sum += n); }, 0) / thresholdAlignments.length :
+                void 0;
+            alignedAxes.forEach(function (axis) {
+                axis.thresholdAlignment = thresholdAlignment_1;
+            });
+        }
         return hasOther;
     };
+    /**
+     * Where the axis wants its threshold, from 0 which is on `axis.min`, to 1 which
+     * is on `axis.max`.
+     *
+     * @private
+     * @function Highcharts.Axis#getThresholdAlignment
+     */
+    Axis.prototype.getThresholdAlignment = function (callerAxis) {
+        if (!isNumber(this.dataMin) ||
+            (this !== callerAxis &&
+                this.series.some(function (s) { return (s.isDirty || s.isDirtyData); }))) {
+            this.getSeriesExtremes();
+        }
+        if (isNumber(this.threshold)) {
+            var thresholdAlignment = clamp(((this.threshold - (this.dataMin || 0)) /
+                ((this.dataMax || 0) - (this.dataMin || 0))), 0, 1);
+            if (this.options.reversed) {
+                thresholdAlignment = 1 - thresholdAlignment;
+            }
+            return thresholdAlignment;
+        }
+    };
     /**
      * Find the max ticks of either the x and y axis collection, and record it
      * in `this.tickAmount`.
@@ -1534,39 +1597,89 @@ var Axis = /** @class */ (function () {
      * @function Highcharts.Axis#adjustTickAmount
      */
     Axis.prototype.adjustTickAmount = function () {
-        var axis = this, axisOptions = axis.options, tickInterval = axis.tickInterval, tickPositions = axis.tickPositions, tickAmount = axis.tickAmount, finalTickAmt = axis.finalTickAmt, currentTickAmount = tickPositions && tickPositions.length, threshold = pick(axis.threshold, axis.softThreshold ? 0 : null);
-        var len, i;
-        if (axis.hasData() &&
-            isNumber(axis.min) &&
-            isNumber(axis.max)) { // #14769
-            if (currentTickAmount < tickAmount) {
+        var axis = this, finalTickAmt = axis.finalTickAmt, max = axis.max, min = axis.min, options = axis.options, tickPositions = axis.tickPositions, tickAmount = axis.tickAmount, thresholdAlignment = axis.thresholdAlignment, currentTickAmount = tickPositions && tickPositions.length, threshold = pick(axis.threshold, axis.softThreshold ? 0 : null);
+        var len, i, tickInterval = axis.tickInterval, thresholdTickIndex;
+        var 
+        // Extend the tickPositions by appending a position
+        append = function () { return tickPositions.push(correctFloat(tickPositions[tickPositions.length - 1] +
+            tickInterval)); }, 
+        // Extend the tickPositions by prepending a position
+        prepend = function () { return tickPositions.unshift(correctFloat(tickPositions[0] - tickInterval)); };
+        // If `thresholdAlignment` is a number, it means the `alignThresholds`
+        // option is true. The `thresholdAlignment` is a scalar value between 0
+        // and 1 for where the threshold should be relative to `axis.min` and
+        // `axis.max`. Now that we know the tick amount, convert this to the
+        // tick index. Unless `thresholdAlignment` is exactly 0 or 1, avoid the
+        // first or last tick because that would lead to series being clipped.
+        if (isNumber(thresholdAlignment)) {
+            thresholdTickIndex = thresholdAlignment < 0.5 ?
+                Math.ceil(thresholdAlignment * (tickAmount - 1)) :
+                Math.floor(thresholdAlignment * (tickAmount - 1));
+            if (options.reversed) {
+                thresholdTickIndex = tickAmount - 1 - thresholdTickIndex;
+            }
+        }
+        if (axis.hasData() && isNumber(min) && isNumber(max)) { // #14769
+            // Adjust extremes and translation to the modified tick positions
+            var adjustExtremes = function () {
+                axis.transA *= (currentTickAmount - 1) / (tickAmount - 1);
+                // Do not crop when ticks are not extremes (#9841)
+                axis.min = options.startOnTick ?
+                    tickPositions[0] :
+                    Math.min(min, tickPositions[0]);
+                axis.max = options.endOnTick ?
+                    tickPositions[tickPositions.length - 1] :
+                    Math.max(max, tickPositions[tickPositions.length - 1]);
+            };
+            // When the axis is subject to the alignThresholds option. Use
+            // axis.threshold because the local threshold includes the
+            // `softThreshold`.
+            if (isNumber(thresholdTickIndex) && isNumber(axis.threshold)) {
+                // Throw away the previously computed tickPositions and start
+                // from scratch with only the threshold itself, then add ticks
+                // below the threshold first, then fill up above the threshold.
+                // If we are not able to fill up to axis.max, double the
+                // tickInterval and run again.
+                while (tickPositions[thresholdTickIndex] !== threshold ||
+                    tickPositions.length !== tickAmount ||
+                    tickPositions[0] > min ||
+                    tickPositions[tickPositions.length - 1] < max) {
+                    tickPositions.length = 0;
+                    tickPositions.push(axis.threshold);
+                    while (tickPositions.length < tickAmount) {
+                        if (
+                        // Start by prepending positions until the threshold
+                        // is at the required index...
+                        tickPositions[thresholdTickIndex] === void 0 ||
+                            tickPositions[thresholdTickIndex] > axis.threshold) {
+                            prepend();
+                        }
+                        else {
+                            // ... then append positions until we have the
+                            // required length
+                            append();
+                        }
+                    }
+                    // Safety vent
+                    if (tickInterval > axis.tickInterval * 8) {
+                        break;
+                    }
+                    tickInterval *= 2;
+                }
+                adjustExtremes();
+            }
+            else if (currentTickAmount < tickAmount) {
                 while (tickPositions.length < tickAmount) {
                     // Extend evenly for both sides unless we're on the
                     // threshold (#3965)
-                    if (tickPositions.length % 2 ||
-                        axis.min === threshold) {
-                        // to the end
-                        tickPositions.push(correctFloat(tickPositions[tickPositions.length - 1] +
-                            tickInterval));
+                    if (tickPositions.length % 2 || min === threshold) {
+                        append();
                     }
                     else {
-                        // to the start
-                        tickPositions.unshift(correctFloat(tickPositions[0] - tickInterval));
+                        prepend();
                     }
                 }
-                axis.transA *= (currentTickAmount - 1) / (tickAmount - 1);
-                // Do not crop when ticks are not extremes (#9841)
-                axis.min = axisOptions.startOnTick ?
-                    tickPositions[0] :
-                    Math.min(axis.min, tickPositions[0]);
-                axis.max = axisOptions.endOnTick ?
-                    tickPositions[tickPositions.length - 1] :
-                    Math.max(axis.max, tickPositions[tickPositions.length - 1]);
-                // We have too many ticks, run second pass to try to reduce ticks
-            }
-            else if (currentTickAmount > tickAmount) {
-                axis.tickInterval *= 2;
-                axis.setTickPositions();
+                adjustExtremes();
             }
             // The finalTickAmt property is set in getTickAmount
             if (defined(finalTickAmt)) {
@@ -2405,18 +2518,18 @@ var Axis = /** @class */ (function () {
         // The part of a multiline text that is below the baseline of the
         // first line. Subtract 1 to preserve pixel-perfectness from the
         // old behaviour (v5.0.12), where only one line was allowed.
-        textHeightOvershoot = Math.max(axisTitle.getBBox(null, 0).height - fontMetrics.h - 1, 0), 
+        textHeightOvershoot = axisTitle ? Math.max(axisTitle.getBBox(false, 0).height - fontMetrics.h - 1, 0) : 0, 
         // the position in the length direction of the axis
-        alongAxis = {
+        alongAxis = ({
             low: margin + (horiz ? 0 : axisLength),
             middle: margin + axisLength / 2,
             high: margin + (horiz ? axisLength : 0)
-        }[axisTitleOptions.align], 
+        })[axisTitleOptions.align], 
         // the position in the perpendicular direction of the axis
         offAxis = (horiz ? axisTop + this.height : axisLeft) +
             (horiz ? 1 : -1) * // horizontal axis reverses the margin
                 (opposite ? -1 : 1) * // so does opposite axes
-                this.axisTitleMargin +
+                (this.axisTitleMargin || 0) +
             [
                 -textHeightOvershoot,
                 textHeightOvershoot,
@@ -2618,14 +2731,8 @@ var Axis = /** @class */ (function () {
         }
         if (axisTitle && showAxis) {
             var titleXy = axis.getTitlePosition();
-            if (isNumber(titleXy.y)) {
-                axisTitle[axisTitle.isNew ? 'attr' : 'animate'](titleXy);
-                axisTitle.isNew = false;
-            }
-            else {
-                axisTitle.attr('y', -9999);
-                axisTitle.isNew = true;
-            }
+            axisTitle[axisTitle.isNew ? 'attr' : 'animate'](titleXy);
+            axisTitle.isNew = false;
         }
         // Stacked totals:
         if (stackLabelOptions && stackLabelOptions.enabled && axis.stacking) {

package/es-modules/Core/Axis/Color/ColorAxis.js

@@ -302,6 +302,16 @@ var ColorAxis = /** @class */ (function (_super) {
             axis.axisParent = group;
             // Call the base
             _super.prototype.getOffset.call(this);
+            var legend_1 = this.chart.legend;
+            // Adds `maxLabelLength` needed for label padding corrections done
+            // by `render()` and `getMargins()` (#15551).
+            legend_1.allItems.forEach(function (item) {
+                if (item instanceof ColorAxis) {
+                    item.drawLegendSymbol(legend_1, item);
+                }
+            });
+            legend_1.render();
+            this.chart.getMargins(true);
             // First time only
             if (!axis.added) {
                 axis.added = true;
@@ -344,17 +354,24 @@ var ColorAxis = /** @class */ (function (_super) {
         var horiz = axis.horiz;
         var width = pick(legendOptions.symbolWidth, horiz ? ColorAxis.defaultLegendLength : 12);
         var height = pick(legendOptions.symbolHeight, horiz ? 12 : ColorAxis.defaultLegendLength);
-        var labelPadding = pick(legendOptions.labelPadding, horiz ? 16 : 30);
+        var labelPadding = pick(
+        // @todo: This option is not documented, nor implemented when
+        // vertical
+        legendOptions.labelPadding, horiz ? 16 : 30);
         var itemDistance = pick(legendOptions.itemDistance, 10);
         this.setLegendColor();
         // Create the gradient
-        item.legendSymbol = this.chart.renderer.rect(0, legend.baseline - 11, width, height).attr({
-            zIndex: 1
-        }).add(item.legendGroup);
+        if (!item.legendSymbol) {
+            item.legendSymbol = this.chart.renderer.rect(0, legend.baseline - 11, width, height).attr({
+                zIndex: 1
+            }).add(item.legendGroup);
+        }
         // Set how much space this legend item takes up
         axis.legendItemWidth = (width +
             padding +
-            (horiz ? itemDistance : labelPadding));
+            (horiz ?
+                itemDistance :
+                this.options.labels.x + this.maxLabelLength));
         axis.legendItemHeight = height + padding + (horiz ? labelPadding : 0);
     };
     /**

package/es-modules/Core/Axis/GridAxis.js

@@ -357,7 +357,7 @@ var GridAxis;
                         });
                     }
                     // show or hide the line depending on options.showEmpty
-                    axis.axisLine[axis.showAxis ? 'show' : 'hide'](true);
+                    axis.axisLine[axis.showAxis ? 'show' : 'hide']();
                 }
             }
             (grid && grid.columns || []).forEach(function (column) {
@@ -370,10 +370,14 @@ var GridAxis;
                 (axis.scrollbar ||
                     (axis.linkedParent && axis.linkedParent.scrollbar))) {
                 var tickmarkOffset = axis.tickmarkOffset, lastTick = axis.tickPositions[axis.tickPositions.length - 1], firstTick = axis.tickPositions[0];
-                var label = void 0;
+                var label = void 0, tickMark = void 0;
                 while ((label = axis.hiddenLabels.pop()) && label.element) {
                     label.show(); // #15453
                 }
+                while ((tickMark = axis.hiddenMarks.pop()) &&
+                    tickMark.element) {
+                    tickMark.show(); // #16439
+                }
                 // Hide/show firts tick label.
                 label = axis.ticks[firstTick].label;
                 if (label) {
@@ -395,14 +399,10 @@ var GridAxis;
                     }
                 }
                 var mark = axis.ticks[lastTick].mark;
-                if (mark) {
-                    if (lastTick - max < tickmarkOffset &&
-                        lastTick - max > 0 && axis.ticks[lastTick].isLast) {
-                        mark.hide();
-                    }
-                    else if (axis.ticks[lastTick - 1]) {
-                        mark.show();
-                    }
+                if (mark &&
+                    lastTick - max < tickmarkOffset &&
+                    lastTick - max > 0 && axis.ticks[lastTick].isLast) {
+                    axis.hiddenMarks.push(mark.hide());
                 }
             }
         }
@@ -684,6 +684,7 @@ var GridAxis;
             axis.grid = new Additions(axis);
         }
         axis.hiddenLabels = [];
+        axis.hiddenMarks = [];
     }
     /**
      * Center tick labels in cells.
@@ -950,7 +951,10 @@ dateFormats.E = function (timestamp) {
 };
 // Adds week date format
 dateFormats.W = function (timestamp) {
-    var d = new this.Date(timestamp);
+    var time = this, d = new this.Date(timestamp), unitsToOmit = ['Hours', 'Milliseconds', 'Minutes', 'Seconds'];
+    unitsToOmit.forEach(function (format) {
+        time.set(format, d, 0);
+    });
     var firstDay = (this.get('Day', d) + 6) % 7;
     var thursday = new this.Date(d.valueOf());
     this.set('Date', thursday, this.get('Date', d) - firstDay + 3);

package/es-modules/Core/Axis/LogarithmicAxis.js

@@ -172,7 +172,7 @@ var LogarithmicAxis;
                     axisLength;
                 interval = pick(filteredTickIntervalOption, log.minorAutoInterval, (realMax - realMin) *
                     tickPixelIntervalOption / (totalPixelLength || 1));
-                interval = normalizeTickInterval(interval, void 0, getMagnitude(interval));
+                interval = normalizeTickInterval(interval);
                 positions = axis.getLinearTickPositions(interval, realMin, realMax).map(log.log2lin);
                 if (!minor) {
                     log.minorAutoInterval = interval / 5;

package/es-modules/Core/Axis/OrdinalAxis.js

@@ -407,9 +407,10 @@ var OrdinalAxis;
             // how many ordinal units did we move?
             movedUnits = (mouseDownX - chartX) / pointPixelWidth, 
             // get index of all the chart's points
-            extendedAxis = {
+            extendedOrdinalPositions = xAxis.ordinal.getExtendedPositions(), extendedAxis = {
                 ordinal: {
-                    positions: xAxis.ordinal.getExtendedPositions()
+                    positions: extendedOrdinalPositions,
+                    extendedOrdinalPositions: extendedOrdinalPositions
                 }
             }, index2val_1 = xAxis.index2val, val2lin_1 = xAxis.val2lin;
             var trimmedRange = void 0, ordinalPositions = void 0, searchAxisLeft = void 0, searchAxisRight = void 0;

package/es-modules/Core/Axis/PlotLineOrBand/PlotLineOrBand.js

@@ -145,7 +145,7 @@ var PlotLineOrBand = /** @class */ (function () {
         }
         else if (svgElem) {
             if (path) {
-                svgElem.show(true);
+                svgElem.show();
                 svgElem.animate({ d: path });
             }
             else if (svgElem.d) {

package/es-modules/Core/Axis/StackingAxis.js

@@ -185,7 +185,6 @@ var StackingAxis;
                 renderer
                     .g('stack-labels')
                     .attr({
-                    visibility: 'visible',
                     zIndex: 6,
                     opacity: 0
                 })

package/es-modules/Core/Axis/Tick.js

@@ -647,11 +647,11 @@ var Tick = /** @class */ (function () {
             // Set the new position, and show or hide
             if (show && isNumber(xy.y)) {
                 xy.opacity = opacity;
-                label[tick.isNewLabel ? 'attr' : 'animate'](xy);
+                label[tick.isNewLabel ? 'attr' : 'animate'](xy).show(true);
                 tick.isNewLabel = false;
             }
             else {
-                label.attr('y', -9999); // #1338
+                label.hide(); // #1338, #15863
                 tick.isNewLabel = true;
             }
         }

package/es-modules/Core/Axis/TreeGridTick.js

@@ -258,6 +258,17 @@ var TreeGridTick;
                 brokenAxis.setBreaks(breaks, pick(redraw, true));
             }
         };
+        /**
+         * Destroy remaining labelIcon if exist.
+         *
+         * @private
+         * @function Highcharts.Tick#destroy
+         */
+        Additions.prototype.destroy = function () {
+            if (this.labelIcon) {
+                this.labelIcon.destroy();
+            }
+        };
         /**
          * Expand the grid cell. Used when axis is of type treegrid.
          *

package/es-modules/Core/Chart/Chart.js

@@ -29,7 +29,7 @@ import SVGRenderer from '../Renderer/SVG/SVGRenderer.js';
 import Time from '../Time.js';
 import U from '../Utilities.js';
 import AST from '../Renderer/HTML/AST.js';
-var addEvent = U.addEvent, attr = U.attr, cleanRecursively = U.cleanRecursively, createElement = U.createElement, css = U.css, defined = U.defined, discardElement = U.discardElement, erase = U.erase, error = U.error, extend = U.extend, find = U.find, fireEvent = U.fireEvent, getStyle = U.getStyle, isArray = U.isArray, isFunction = U.isFunction, isNumber = U.isNumber, isObject = U.isObject, isString = U.isString, merge = U.merge, objectEach = U.objectEach, pick = U.pick, pInt = U.pInt, relativeLength = U.relativeLength, removeEvent = U.removeEvent, splat = U.splat, syncTimeout = U.syncTimeout, uniqueKey = U.uniqueKey;
+var addEvent = U.addEvent, attr = U.attr, cleanRecursively = U.cleanRecursively, createElement = U.createElement, css = U.css, defined = U.defined, discardElement = U.discardElement, erase = U.erase, error = U.error, extend = U.extend, find = U.find, fireEvent = U.fireEvent, getStyle = U.getStyle, isArray = U.isArray, isNumber = U.isNumber, isObject = U.isObject, isString = U.isString, merge = U.merge, objectEach = U.objectEach, pick = U.pick, pInt = U.pInt, relativeLength = U.relativeLength, removeEvent = U.removeEvent, splat = U.splat, syncTimeout = U.syncTimeout, uniqueKey = U.uniqueKey;
 /* *
  *
  *  Class
@@ -1943,9 +1943,27 @@ var Chart = /** @class */ (function () {
         if (defined(this.index)) {
             this.setReflow(this.options.chart.reflow);
         }
+        this.warnIfA11yModuleNotLoaded();
         // Don't run again
         this.hasLoaded = true;
     };
+    /**
+     * Emit console warning if the a11y module is not loaded.
+     */
+    Chart.prototype.warnIfA11yModuleNotLoaded = function () {
+        var _this = this;
+        setTimeout(function () {
+            var opts = _this && _this.options;
+            if (opts && !_this.accessibility &&
+                !(opts.accessibility && opts.accessibility.enabled === false)) {
+                error('Highcharts warning: Consider including the ' +
+                    '"accessibility.js" module to make your chart more ' +
+                    'usable for people with disabilities. Set the ' +
+                    '"accessibility.enabled" option to false to remove this ' +
+                    'warning. See https://www.highcharts.com/docs/accessibility/accessibility-module.', false, _this);
+            }
+        }, 100);
+    };
     /**
      * Add a series to the chart after render time. Note that this method should
      * never be used when adding data synchronously at chart render time, as it
@@ -2494,7 +2512,7 @@ var Chart = /** @class */ (function () {
      * @emits Highcharts.Chart#event:beforeShowResetZoom
      */
     Chart.prototype.showResetZoom = function () {
-        var chart = this, lang = defaultOptions.lang, btnOptions = chart.options.chart.resetZoomButton, theme = btnOptions.theme, states = theme.states, alignTo = (btnOptions.relativeTo === 'chart' ||
+        var chart = this, lang = defaultOptions.lang, btnOptions = chart.options.chart.resetZoomButton, theme = btnOptions.theme, alignTo = (btnOptions.relativeTo === 'chart' ||
             btnOptions.relativeTo === 'spacingBox' ?
             null :
             'scrollablePlotBox');
@@ -2506,7 +2524,7 @@ var Chart = /** @class */ (function () {
         }
         fireEvent(this, 'beforeShowResetZoom', null, function () {
             chart.resetZoomButton = chart.renderer
-                .button(lang.resetZoom, null, null, zoomOut, theme, states && states.hover)
+                .button(lang.resetZoom, null, null, zoomOut, theme)
                 .attr({
                 align: btnOptions.position.align,
                 title: lang.resetZoomTitle

package/es-modules/Core/Chart/Chart3D.js

@@ -1494,17 +1494,7 @@ var Chart3D;
      */
     function onAfterGetContainer() {
         if (this.styledMode) {
-            this.renderer.definition({
-                tagName: 'style',
-                textContent: '.highcharts-3d-top{' +
-                    'filter: url(#highcharts-brighter)' +
-                    '}\n' +
-                    '.highcharts-3d-side{' +
-                    'filter: url(#highcharts-darker)' +
-                    '}\n'
-            });
-            // Add add definitions used by brighter and darker faces of the
-            // cuboids.
+            // Add definitions used by brighter and darker faces of the cuboids.
             [{
                     name: 'darker',
                     slope: 0.6