highcharts 9.2.2 → 9.3.0

package/es-modules/Accessibility/Components/SeriesComponent/SeriesKeyboardNavigation.js

@@ -10,7 +10,6 @@
  *
  * */
 'use strict';
-import Chart from '../../../Core/Chart/Chart.js';
 import Point from '../../../Core/Series/Point.js';
 import Series from '../../../Core/Series/Series.js';
 import SeriesRegistry from '../../../Core/Series/SeriesRegistry.js';
@@ -18,24 +17,17 @@ var seriesTypes = SeriesRegistry.seriesTypes;
 import H from '../../../Core/Globals.js';
 var doc = H.doc;
 import U from '../../../Core/Utilities.js';
-var defined = U.defined, extend = U.extend, fireEvent = U.fireEvent;
+var defined = U.defined, fireEvent = U.fireEvent;
 import KeyboardNavigationHandler from '../../KeyboardNavigationHandler.js';
 import EventProvider from '../../Utils/EventProvider.js';
 import ChartUtilities from '../../Utils/ChartUtilities.js';
 var getPointFromXY = ChartUtilities.getPointFromXY, getSeriesFromName = ChartUtilities.getSeriesFromName, scrollToPoint = ChartUtilities.scrollToPoint;
-import '../../../Series/Column/ColumnSeries.js';
-import '../../../Series/Pie/PieSeries.js';
-/* eslint-disable no-invalid-this, valid-jsdoc */
-/*
- * Set for which series types it makes sense to move to the closest point with
- * up/down arrows, and which series types should just move to next series.
- */
-Series.prototype.keyboardMoveVertical = true;
-['column', 'pie'].forEach(function (type) {
-    if (seriesTypes[type]) {
-        seriesTypes[type].prototype.keyboardMoveVertical = false;
-    }
-});
+/* *
+ *
+ *  Functions
+ *
+ * */
+/* eslint-disable valid-jsdoc */
 /**
  * Get the index of a point in a series. This is needed when using e.g. data
  * grouping.
@@ -107,273 +99,7 @@ function isSkipPoint(point) {
         isSkipSeries(point.series);
 }
 /**
- * Get the point in a series that is closest (in pixel distance) to a reference
- * point. Optionally supply weight factors for x and y directions.
- *
- * @private
- * @function getClosestPoint
- *
- * @param {Highcharts.Point} point
- * @param {Highcharts.Series} series
- * @param {number} [xWeight]
- * @param {number} [yWeight]
- *
- * @return {Highcharts.Point|undefined}
- */
-function getClosestPoint(point, series, xWeight, yWeight) {
-    var minDistance = Infinity, dPoint, minIx, distance, i = series.points.length;
-    var hasUndefinedPosition = function (point) {
-        return !(defined(point.plotX) && defined(point.plotY));
-    };
-    if (hasUndefinedPosition(point)) {
-        return;
-    }
-    while (i--) {
-        dPoint = series.points[i];
-        if (hasUndefinedPosition(dPoint)) {
-            continue;
-        }
-        distance = (point.plotX - dPoint.plotX) *
-            (point.plotX - dPoint.plotX) *
-            (xWeight || 1) +
-            (point.plotY - dPoint.plotY) *
-                (point.plotY - dPoint.plotY) *
-                (yWeight || 1);
-        if (distance < minDistance) {
-            minDistance = distance;
-            minIx = i;
-        }
-    }
-    return defined(minIx) ? series.points[minIx] : void 0;
-}
-/**
- * Highlights a point (show tooltip and display hover state).
- *
- * @private
- * @function Highcharts.Point#highlight
- *
- * @return {Highcharts.Point}
- *         This highlighted point.
- */
-Point.prototype.highlight = function () {
-    var chart = this.series.chart;
-    if (!this.isNull) {
-        this.onMouseOver(); // Show the hover marker and tooltip
-    }
-    else {
-        if (chart.tooltip) {
-            chart.tooltip.hide(0);
-        }
-        // Don't call blur on the element, as it messes up the chart div's focus
-    }
-    scrollToPoint(this);
-    // We focus only after calling onMouseOver because the state change can
-    // change z-index and mess up the element.
-    if (this.graphic) {
-        chart.setFocusToElement(this.graphic);
-    }
-    chart.highlightedPoint = this;
-    return this;
-};
-/**
- * Function to highlight next/previous point in chart.
- *
  * @private
- * @function Highcharts.Chart#highlightAdjacentPoint
- *
- * @param {boolean} next
- *        Flag for the direction.
- *
- * @return {Highcharts.Point|boolean}
- *         Returns highlighted point on success, false on failure (no adjacent
- *         point to highlight in chosen direction).
- */
-Chart.prototype.highlightAdjacentPoint = function (next) {
-    var chart = this, series = chart.series, curPoint = chart.highlightedPoint, curPointIndex = curPoint && getPointIndex(curPoint) || 0, curPoints = (curPoint && curPoint.series.points), lastSeries = chart.series && chart.series[chart.series.length - 1], lastPoint = lastSeries && lastSeries.points &&
-        lastSeries.points[lastSeries.points.length - 1];
-    var newSeries, newPoint;
-    // If no points, return false
-    if (!series[0] || !series[0].points) {
-        return false;
-    }
-    if (!curPoint) {
-        // No point is highlighted yet. Try first/last point depending on move
-        // direction
-        newPoint = next ? series[0].points[0] : lastPoint;
-    }
-    else {
-        // We have a highlighted point.
-        // Grab next/prev point & series
-        newSeries = series[curPoint.series.index + (next ? 1 : -1)];
-        newPoint = curPoints[curPointIndex + (next ? 1 : -1)];
-        if (!newPoint && newSeries) {
-            // Done with this series, try next one
-            newPoint = newSeries.points[next ? 0 : newSeries.points.length - 1];
-        }
-        // If there is no adjacent point, we return false
-        if (!newPoint) {
-            return false;
-        }
-    }
-    // Recursively skip points
-    if (isSkipPoint(newPoint)) {
-        // If we skip this whole series, move to the end of the series before we
-        // recurse, just to optimize
-        newSeries = newPoint.series;
-        if (isSkipSeries(newSeries)) {
-            chart.highlightedPoint = next ?
-                newSeries.points[newSeries.points.length - 1] :
-                newSeries.points[0];
-        }
-        else {
-            // Otherwise, just move one point
-            chart.highlightedPoint = newPoint;
-        }
-        // Retry
-        return chart.highlightAdjacentPoint(next);
-    }
-    // There is an adjacent point, highlight it
-    return newPoint.highlight();
-};
-/**
- * Highlight first valid point in a series. Returns the point if successfully
- * highlighted, otherwise false. If there is a highlighted point in the series,
- * use that as starting point.
- *
- * @private
- * @function Highcharts.Series#highlightFirstValidPoint
- *
- * @return {boolean|Highcharts.Point}
- */
-Series.prototype.highlightFirstValidPoint = function () {
-    var curPoint = this.chart.highlightedPoint, start = (curPoint && curPoint.series) === this ?
-        getPointIndex(curPoint) :
-        0, points = this.points, len = points.length;
-    if (points && len) {
-        for (var i = start; i < len; ++i) {
-            if (!isSkipPoint(points[i])) {
-                return points[i].highlight();
-            }
-        }
-        for (var j = start; j >= 0; --j) {
-            if (!isSkipPoint(points[j])) {
-                return points[j].highlight();
-            }
-        }
-    }
-    return false;
-};
-/**
- * Highlight next/previous series in chart. Returns false if no adjacent series
- * in the direction, otherwise returns new highlighted point.
- *
- * @private
- * @function Highcharts.Chart#highlightAdjacentSeries
- *
- * @param {boolean} down
- *
- * @return {Highcharts.Point|boolean}
- */
-Chart.prototype.highlightAdjacentSeries = function (down) {
-    var chart = this, curPoint = chart.highlightedPoint, lastSeries = chart.series && chart.series[chart.series.length - 1], lastPoint = lastSeries && lastSeries.points &&
-        lastSeries.points[lastSeries.points.length - 1];
-    var newSeries, newPoint, adjacentNewPoint;
-    // If no point is highlighted, highlight the first/last point
-    if (!chart.highlightedPoint) {
-        newSeries = down ? (chart.series && chart.series[0]) : lastSeries;
-        newPoint = down ?
-            (newSeries && newSeries.points && newSeries.points[0]) : lastPoint;
-        return newPoint ? newPoint.highlight() : false;
-    }
-    newSeries = chart.series[curPoint.series.index + (down ? -1 : 1)];
-    if (!newSeries) {
-        return false;
-    }
-    // We have a new series in this direction, find the right point
-    // Weigh xDistance as counting much higher than Y distance
-    newPoint = getClosestPoint(curPoint, newSeries, 4);
-    if (!newPoint) {
-        return false;
-    }
-    // New series and point exists, but we might want to skip it
-    if (isSkipSeries(newSeries)) {
-        // Skip the series
-        newPoint.highlight();
-        adjacentNewPoint = chart.highlightAdjacentSeries(down); // Try recurse
-        if (!adjacentNewPoint) {
-            // Recurse failed
-            curPoint.highlight();
-            return false;
-        }
-        // Recurse succeeded
-        return adjacentNewPoint;
-    }
-    // Highlight the new point or any first valid point back or forwards from it
-    newPoint.highlight();
-    return newPoint.series.highlightFirstValidPoint();
-};
-/**
- * Highlight the closest point vertically.
- *
- * @private
- * @function Highcharts.Chart#highlightAdjacentPointVertical
- *
- * @param {boolean} down
- *
- * @return {Highcharts.Point|boolean}
- */
-Chart.prototype.highlightAdjacentPointVertical = function (down) {
-    var curPoint = this.highlightedPoint;
-    var minDistance = Infinity, bestPoint;
-    if (!defined(curPoint.plotX) || !defined(curPoint.plotY)) {
-        return false;
-    }
-    this.series.forEach(function (series) {
-        if (isSkipSeries(series)) {
-            return;
-        }
-        series.points.forEach(function (point) {
-            if (!defined(point.plotY) || !defined(point.plotX) ||
-                point === curPoint) {
-                return;
-            }
-            var yDistance = point.plotY - curPoint.plotY;
-            var width = Math.abs(point.plotX - curPoint.plotX), distance = Math.abs(yDistance) * Math.abs(yDistance) +
-                width * width * 4; // Weigh horizontal distance highly
-            // Reverse distance number if axis is reversed
-            if (series.yAxis && series.yAxis.reversed) {
-                yDistance *= -1;
-            }
-            if (yDistance <= 0 && down || yDistance >= 0 && !down || // Chk dir
-                distance < 5 || // Points in same spot => infinite loop
-                isSkipPoint(point)) {
-                return;
-            }
-            if (distance < minDistance) {
-                minDistance = distance;
-                bestPoint = point;
-            }
-        });
-    });
-    return bestPoint ? bestPoint.highlight() : false;
-};
-/**
- * @private
- * @param {Highcharts.Chart} chart
- * @return {Highcharts.Point|boolean}
- */
-function highlightFirstValidPointInChart(chart) {
-    var res = false;
-    delete chart.highlightedPoint;
-    res = chart.series.reduce(function (acc, cur) {
-        return acc || cur.highlightFirstValidPoint();
-    }, false);
-    return res;
-}
-/**
- * @private
- * @param {Highcharts.Chart} chart
- * @return {Highcharts.Point|boolean}
  */
 function highlightLastValidPointInChart(chart) {
     var numSeries = chart.series.length;
@@ -392,7 +118,6 @@ function highlightLastValidPointInChart(chart) {
 }
 /**
  * @private
- * @param {Highcharts.Chart} chart
  */
 function updateChartFocusAfterDrilling(chart) {
     highlightFirstValidPointInChart(chart);
@@ -400,20 +125,45 @@ function updateChartFocusAfterDrilling(chart) {
         chart.focusElement.removeFocusBorder();
     }
 }
+/**
+ * @private
+ */
+function highlightFirstValidPointInChart(chart) {
+    var res = false;
+    delete chart.highlightedPoint;
+    res = chart.series.reduce(function (acc, cur) { return acc || cur.highlightFirstValidPoint(); }, false);
+    return res;
+}
+/* *
+ *
+ *  Class
+ *
+ * */
 /**
  * @private
  * @class
  * @name Highcharts.SeriesKeyboardNavigation
  */
-function SeriesKeyboardNavigation(chart, keyCodes) {
-    this.keyCodes = keyCodes;
-    this.chart = chart;
-}
-extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardNavigation */ {
+var SeriesKeyboardNavigation = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    function SeriesKeyboardNavigation(chart, keyCodes) {
+        this.keyCodes = keyCodes;
+        this.chart = chart;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /* eslint-disable valid-jsdoc */
     /**
      * Init the keyboard navigation
      */
-    init: function () {
+    SeriesKeyboardNavigation.prototype.init = function () {
         var keyboardNavigation = this, chart = this.chart, e = this.eventProvider = new EventProvider();
         e.addEvent(Series, 'destroy', function () {
             return keyboardNavigation.onSeriesDestroy(this);
@@ -439,15 +189,27 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
         e.addEvent(Point, 'afterSetState', function () {
             var point = this;
             var pointEl = point.graphic && point.graphic.element;
+            var focusedElement = doc.activeElement;
+            // VO brings focus with it to container, causing series nav to run.
+            // If then navigating with virtual cursor, it is possible to leave
+            // keyboard nav module state on the data points and still activate
+            // proxy buttons.
+            var focusedElClassName = focusedElement && focusedElement.getAttribute('class');
+            var isProxyFocused = focusedElClassName &&
+                focusedElClassName.indexOf('highcharts-a11y-proxy-button') > -1;
             if (chart.highlightedPoint === point &&
-                doc.activeElement !== pointEl &&
+                focusedElement !== pointEl &&
+                !isProxyFocused &&
                 pointEl &&
                 pointEl.focus) {
                 pointEl.focus();
             }
         });
-    },
-    onDrillupAll: function () {
+    };
+    /**
+     * @private
+     */
+    SeriesKeyboardNavigation.prototype.onDrillupAll = function () {
         // After drillup we want to find the point that was drilled down to and
         // highlight it.
         var last = this.lastDrilledDownPoint, chart = this.chart, series = last && getSeriesFromName(chart, last.seriesName);
@@ -465,11 +227,11 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
         if (chart.focusElement) {
             chart.focusElement.removeFocusBorder();
         }
-    },
+    };
     /**
      * @return {Highcharts.KeyboardNavigationHandler}
      */
-    getKeyboardNavigationHandler: function () {
+    SeriesKeyboardNavigation.prototype.getKeyboardNavigationHandler = function () {
         var keyboardNavigation = this, keys = this.keyCodes, chart = this.chart, inverted = chart.inverted;
         return new KeyboardNavigationHandler(chart, {
             keyCodeMap: [
@@ -487,16 +249,29 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
                             point.firePointEvent('click');
                         }
                         return this.response.success;
+                    }],
+                [[keys.home], function () {
+                        highlightFirstValidPointInChart(chart);
+                        return this.response.success;
+                    }],
+                [[keys.end], function () {
+                        highlightLastValidPointInChart(chart);
+                        return this.response.success;
+                    }],
+                [[keys.pageDown, keys.pageUp], function (keyCode) {
+                        chart.highlightAdjacentSeries(keyCode === keys.pageDown);
+                        return this.response.success;
                     }]
             ],
-            init: function (dir) {
-                return keyboardNavigation.onHandlerInit(this, dir);
+            init: function () {
+                highlightFirstValidPointInChart(chart);
+                return this.response.success;
             },
             terminate: function () {
                 return keyboardNavigation.onHandlerTerminate();
             }
         });
-    },
+    };
     /**
      * @private
      * @param {Highcharts.KeyboardNavigationHandler} handler
@@ -504,10 +279,10 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
      * @return {number}
      * response
      */
-    onKbdSideways: function (handler, keyCode) {
+    SeriesKeyboardNavigation.prototype.onKbdSideways = function (handler, keyCode) {
         var keys = this.keyCodes, isNext = keyCode === keys.right || keyCode === keys.down;
         return this.attemptHighlightAdjacentPoint(handler, isNext);
-    },
+    };
     /**
      * @private
      * @param {Highcharts.KeyboardNavigationHandler} handler
@@ -515,7 +290,7 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
      * @return {number}
      * response
      */
-    onKbdVertical: function (handler, keyCode) {
+    SeriesKeyboardNavigation.prototype.onKbdVertical = function (handler, keyCode) {
         var chart = this.chart, keys = this.keyCodes, isNext = keyCode === keys.down || keyCode === keys.right, navOptions = chart.options.accessibility.keyboardNavigation
             .seriesNavigation;
         // Handle serialized mode, act like left/right
@@ -529,28 +304,11 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
             'highlightAdjacentSeries';
         chart[highlightMethod](isNext);
         return handler.response.success;
-    },
-    /**
-     * @private
-     * @param {Highcharts.KeyboardNavigationHandler} handler
-     * @param {number} initDirection
-     * @return {number}
-     * response
-     */
-    onHandlerInit: function (handler, initDirection) {
-        var chart = this.chart;
-        if (initDirection > 0) {
-            highlightFirstValidPointInChart(chart);
-        }
-        else {
-            highlightLastValidPointInChart(chart);
-        }
-        return handler.response.success;
-    },
+    };
     /**
      * @private
      */
-    onHandlerTerminate: function () {
+    SeriesKeyboardNavigation.prototype.onHandlerTerminate = function () {
         var chart = this.chart;
         if (chart.tooltip) {
             chart.tooltip.hide(0);
@@ -563,7 +321,7 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
             chart.highlightedPoint.onMouseOut();
         }
         delete chart.highlightedPoint;
-    },
+    };
     /**
      * Function that attempts to highlight next/prev point. Handles wrap around.
      * @private
@@ -572,7 +330,7 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
      * @return {number}
      * response
      */
-    attemptHighlightAdjacentPoint: function (handler, directionIsNext) {
+    SeriesKeyboardNavigation.prototype.attemptHighlightAdjacentPoint = function (handler, directionIsNext) {
         var chart = this.chart, wrapAround = chart.options.accessibility.keyboardNavigation
             .wrapAround, highlightSuccessful = chart.highlightAdjacentPoint(directionIsNext);
         if (!highlightSuccessful) {
@@ -582,11 +340,11 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
             return handler.response[directionIsNext ? 'next' : 'prev'];
         }
         return handler.response.success;
-    },
+    };
     /**
      * @private
      */
-    onSeriesDestroy: function (series) {
+    SeriesKeyboardNavigation.prototype.onSeriesDestroy = function (series) {
         var chart = this.chart, currentHighlightedPointDestroyed = chart.highlightedPoint &&
             chart.highlightedPoint.series === series;
         if (currentHighlightedPointDestroyed) {
@@ -595,12 +353,309 @@ extend(SeriesKeyboardNavigation.prototype, /** @lends Highcharts.SeriesKeyboardN
                 chart.focusElement.removeFocusBorder();
             }
         }
-    },
+    };
     /**
      * @private
      */
-    destroy: function () {
+    SeriesKeyboardNavigation.prototype.destroy = function () {
         this.eventProvider.removeAddedEvents();
+    };
+    return SeriesKeyboardNavigation;
+}());
+/* *
+ *
+ *  Class Namespace
+ *
+ * */
+(function (SeriesKeyboardNavigation) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    var composedClasses = [];
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Function to highlight next/previous point in chart.
+     *
+     * @private
+     * @function Highcharts.Chart#highlightAdjacentPoint
+     *
+     * @param {boolean} next
+     * Flag for the direction.
+     *
+     * @return {Highcharts.Point|boolean}
+     * Returns highlighted point on success, false on failure (no adjacent point
+     * to highlight in chosen direction).
+     */
+    function chartHighlightAdjacentPoint(next) {
+        var chart = this, series = chart.series, curPoint = chart.highlightedPoint, curPointIndex = curPoint && getPointIndex(curPoint) || 0, curPoints = curPoint && curPoint.series.points || [], lastSeries = chart.series && chart.series[chart.series.length - 1], lastPoint = lastSeries && lastSeries.points && lastSeries.points[lastSeries.points.length - 1];
+        var newSeries, newPoint;
+        // If no points, return false
+        if (!series[0] || !series[0].points) {
+            return false;
+        }
+        if (!curPoint) {
+            // No point is highlighted yet. Try first/last point depending on
+            // move direction
+            newPoint = next ? series[0].points[0] : lastPoint;
+        }
+        else {
+            // We have a highlighted point.
+            // Grab next/prev point & series
+            newSeries = series[curPoint.series.index + (next ? 1 : -1)];
+            newPoint = curPoints[curPointIndex + (next ? 1 : -1)];
+            if (!newPoint && newSeries) {
+                // Done with this series, try next one
+                newPoint = newSeries.points[next ? 0 : newSeries.points.length - 1];
+            }
+            // If there is no adjacent point, we return false
+            if (!newPoint) {
+                return false;
+            }
+        }
+        // Recursively skip points
+        if (isSkipPoint(newPoint)) {
+            // If we skip this whole series, move to the end of the series
+            // before we recurse, just to optimize
+            newSeries = newPoint.series;
+            if (isSkipSeries(newSeries)) {
+                chart.highlightedPoint = next ?
+                    newSeries.points[newSeries.points.length - 1] :
+                    newSeries.points[0];
+            }
+            else {
+                // Otherwise, just move one point
+                chart.highlightedPoint = newPoint;
+            }
+            // Retry
+            return chart.highlightAdjacentPoint(next);
+        }
+        // There is an adjacent point, highlight it
+        return newPoint.highlight();
     }
-});
+    /**
+     * Highlight the closest point vertically.
+     * @private
+     */
+    function chartHighlightAdjacentPointVertical(down) {
+        var curPoint = this.highlightedPoint;
+        var minDistance = Infinity, bestPoint;
+        if (!defined(curPoint.plotX) || !defined(curPoint.plotY)) {
+            return false;
+        }
+        this.series.forEach(function (series) {
+            if (isSkipSeries(series)) {
+                return;
+            }
+            series.points.forEach(function (point) {
+                if (!defined(point.plotY) || !defined(point.plotX) ||
+                    point === curPoint) {
+                    return;
+                }
+                var yDistance = point.plotY - curPoint.plotY;
+                var width = Math.abs(point.plotX - curPoint.plotX), distance = Math.abs(yDistance) * Math.abs(yDistance) +
+                    width * width * 4; // Weigh horizontal distance highly
+                // Reverse distance number if axis is reversed
+                if (series.yAxis && series.yAxis.reversed) {
+                    yDistance *= -1;
+                }
+                if (yDistance <= 0 && down || yDistance >= 0 && !down || // Chk dir
+                    distance < 5 || // Points in same spot => infinite loop
+                    isSkipPoint(point)) {
+                    return;
+                }
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    bestPoint = point;
+                }
+            });
+        });
+        return bestPoint ? bestPoint.highlight() : false;
+    }
+    /**
+     * Highlight next/previous series in chart. Returns false if no adjacent
+     * series in the direction, otherwise returns new highlighted point.
+     * @private
+     */
+    function chartHighlightAdjacentSeries(down) {
+        var chart = this, curPoint = chart.highlightedPoint, lastSeries = chart.series && chart.series[chart.series.length - 1], lastPoint = lastSeries && lastSeries.points &&
+            lastSeries.points[lastSeries.points.length - 1];
+        var newSeries, newPoint, adjacentNewPoint;
+        // If no point is highlighted, highlight the first/last point
+        if (!chart.highlightedPoint) {
+            newSeries = down ? (chart.series && chart.series[0]) : lastSeries;
+            newPoint = down ?
+                (newSeries && newSeries.points && newSeries.points[0]) : lastPoint;
+            return newPoint ? newPoint.highlight() : false;
+        }
+        newSeries = chart.series[curPoint.series.index + (down ? -1 : 1)];
+        if (!newSeries) {
+            return false;
+        }
+        // We have a new series in this direction, find the right point
+        // Weigh xDistance as counting much higher than Y distance
+        newPoint = getClosestPoint(curPoint, newSeries, 4);
+        if (!newPoint) {
+            return false;
+        }
+        // New series and point exists, but we might want to skip it
+        if (isSkipSeries(newSeries)) {
+            // Skip the series
+            newPoint.highlight();
+            adjacentNewPoint = chart.highlightAdjacentSeries(down); // Try recurse
+            if (!adjacentNewPoint) {
+                // Recurse failed
+                curPoint.highlight();
+                return false;
+            }
+            // Recurse succeeded
+            return adjacentNewPoint;
+        }
+        // Highlight the new point or any first valid point back or forwards
+        // from it
+        newPoint.highlight();
+        return newPoint.series.highlightFirstValidPoint();
+    }
+    /**
+     * @private
+     */
+    function compose(ChartClass, PointClass, SeriesClass) {
+        if (composedClasses.indexOf(ChartClass) === -1) {
+            composedClasses.push(ChartClass);
+            var chartProto = ChartClass.prototype;
+            chartProto.highlightAdjacentPoint = chartHighlightAdjacentPoint;
+            chartProto.highlightAdjacentPointVertical = chartHighlightAdjacentPointVertical;
+            chartProto.highlightAdjacentSeries = chartHighlightAdjacentSeries;
+        }
+        if (composedClasses.indexOf(PointClass) === -1) {
+            composedClasses.push(PointClass);
+            var pointProto = PointClass.prototype;
+            pointProto.highlight = pointHighlight;
+        }
+        if (composedClasses.indexOf(SeriesClass) === -1) {
+            composedClasses.push(SeriesClass);
+            var seriesProto = SeriesClass.prototype;
+            /**
+             * Set for which series types it makes sense to move to the closest
+             * point with up/down arrows, and which series types should just
+             * move to next series.
+             * @private
+             */
+            seriesProto.keyboardMoveVertical = true;
+            [
+                'column',
+                'gantt',
+                'pie'
+            ].forEach(function (type) {
+                if (seriesTypes[type]) {
+                    seriesTypes[type].prototype.keyboardMoveVertical = false;
+                }
+            });
+            seriesProto.highlightFirstValidPoint = seriesHighlightFirstValidPoint;
+        }
+    }
+    SeriesKeyboardNavigation.compose = compose;
+    /**
+     * Get the point in a series that is closest (in pixel distance) to a
+     * reference point. Optionally supply weight factors for x and y directions.
+     * @private
+     */
+    function getClosestPoint(point, series, xWeight, yWeight) {
+        var minDistance = Infinity, dPoint, minIx, distance, i = series.points.length;
+        var hasUndefinedPosition = function (point) { return (!(defined(point.plotX) && defined(point.plotY))); };
+        if (hasUndefinedPosition(point)) {
+            return;
+        }
+        while (i--) {
+            dPoint = series.points[i];
+            if (hasUndefinedPosition(dPoint)) {
+                continue;
+            }
+            distance = (point.plotX - dPoint.plotX) *
+                (point.plotX - dPoint.plotX) *
+                (xWeight || 1) +
+                (point.plotY - dPoint.plotY) *
+                    (point.plotY - dPoint.plotY) *
+                    (yWeight || 1);
+            if (distance < minDistance) {
+                minDistance = distance;
+                minIx = i;
+            }
+        }
+        return defined(minIx) ? series.points[minIx] : void 0;
+    }
+    /**
+     * Highlights a point (show tooltip and display hover state).
+     *
+     * @private
+     * @function Highcharts.Point#highlight
+     *
+     * @return {Highcharts.Point}
+     *         This highlighted point.
+     */
+    function pointHighlight() {
+        var chart = this.series.chart;
+        if (!this.isNull) {
+            this.onMouseOver(); // Show the hover marker and tooltip
+        }
+        else {
+            if (chart.tooltip) {
+                chart.tooltip.hide(0);
+            }
+            // Do not call blur on the element, as it messes up the focus of the
+            // div element of the chart
+        }
+        scrollToPoint(this);
+        // We focus only after calling onMouseOver because the state change can
+        // change z-index and mess up the element.
+        if (this.graphic) {
+            chart.setFocusToElement(this.graphic);
+        }
+        chart.highlightedPoint = this;
+        return this;
+    }
+    /**
+     * Highlight first valid point in a series. Returns the point if
+     * successfully highlighted, otherwise false. If there is a highlighted
+     * point in the series, use that as starting point.
+     *
+     * @private
+     * @function Highcharts.Series#highlightFirstValidPoint
+     *
+     * @return {boolean|Highcharts.Point}
+     */
+    function seriesHighlightFirstValidPoint() {
+        var curPoint = this.chart.highlightedPoint, start = (curPoint && curPoint.series) === this ?
+            getPointIndex(curPoint) :
+            0, points = this.points, len = points.length;
+        if (points && len) {
+            for (var i = start; i < len; ++i) {
+                if (!isSkipPoint(points[i])) {
+                    return points[i].highlight();
+                }
+            }
+            for (var j = start; j >= 0; --j) {
+                if (!isSkipPoint(points[j])) {
+                    return points[j].highlight();
+                }
+            }
+        }
+        return false;
+    }
+})(SeriesKeyboardNavigation || (SeriesKeyboardNavigation = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
 export default SeriesKeyboardNavigation;