highcharts 9.1.1 → 9.2.2

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

@@ -9,19 +9,572 @@
  * */
 'use strict';
 import Axis from './Axis.js';
-import Chart from '../Chart/Chart.js';
 import H from '../Globals.js';
 import Series from '../Series/Series.js';
 import U from '../Utilities.js';
-var addEvent = U.addEvent, css = U.css, defined = U.defined, error = U.error, pick = U.pick, timeUnits = U.timeUnits;
-// Has a dependency on Navigator due to the use of Axis.toFixedRange
-import '../Navigator.js';
+var addEvent = U.addEvent, correctFloat = U.correctFloat, css = U.css, defined = U.defined, error = U.error, pick = U.pick, timeUnits = U.timeUnits;
+/* *
+ *
+ *  Constants
+ *
+ * */
+var composedClasses = [];
+/* eslint-disable valid-jsdoc */
+/* *
+ *
+ *  Composition
+ *
+ * */
 /**
  * Extends the axis with ordinal support.
  * @private
  */
 var OrdinalAxis;
 (function (OrdinalAxis) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Extends the axis with ordinal support.
+     *
+     * @private
+     *
+     * @param AxisClass
+     * Axis class to extend.
+     *
+     * @param ChartClass
+     * Chart class to use.
+     *
+     * @param SeriesClass
+     * Series class to use.
+     */
+    function compose(AxisClass, SeriesClass, ChartClass) {
+        if (composedClasses.indexOf(AxisClass) === -1) {
+            composedClasses.push(AxisClass);
+            var axisProto = AxisClass.prototype;
+            axisProto.getTimeTicks = getTimeTicks;
+            axisProto.index2val = index2val;
+            axisProto.lin2val = lin2val;
+            axisProto.val2lin = val2lin;
+            // Record this to prevent overwriting by broken-axis module (#5979)
+            axisProto.ordinal2lin = axisProto.val2lin;
+            addEvent(AxisClass, 'afterInit', onAxisAfterInit);
+            addEvent(AxisClass, 'foundExtremes', onAxisFoundExtremes);
+            addEvent(AxisClass, 'afterSetScale', onAxisAfterSetScale);
+            addEvent(AxisClass, 'initialAxisTranslation', onAxisInitialAxisTranslation);
+        }
+        if (composedClasses.indexOf(ChartClass) === -1) {
+            composedClasses.push(ChartClass);
+            addEvent(ChartClass, 'pan', onChartPan);
+        }
+        if (composedClasses.indexOf(SeriesClass) === -1) {
+            composedClasses.push(SeriesClass);
+            addEvent(SeriesClass, 'updatedData', onSeriesUpdatedData);
+        }
+        /* eslint-enable no-invalid-this */
+        return AxisClass;
+    }
+    OrdinalAxis.compose = compose;
+    /**
+     * In an ordinal axis, there might be areas with dense consentrations of
+     * points, then large gaps between some. Creating equally distributed
+     * ticks over this entire range may lead to a huge number of ticks that
+     * will later be removed. So instead, break the positions up in
+     * segments, find the tick positions for each segment then concatenize
+     * them. This method is used from both data grouping logic and X axis
+     * tick position logic.
+     * @private
+     */
+    function getTimeTicks(normalizedInterval, min, max, startOfWeek, positions, closestDistance, findHigherRanks) {
+        if (positions === void 0) { positions = []; }
+        if (closestDistance === void 0) { closestDistance = 0; }
+        var higherRanks = {}, tickPixelIntervalOption = this.options.tickPixelInterval, time = this.chart.time, 
+        // Record all the start positions of a segment, to use when
+        // deciding what's a gap in the data.
+        segmentStarts = [];
+        var end, segmentPositions, hasCrossedHigherRank, info, outsideMax, start = 0, groupPositions = [], lastGroupPosition = -Number.MAX_VALUE;
+        // The positions are not always defined, for example for ordinal
+        // positions when data has regular interval (#1557, #2090)
+        if ((!this.options.ordinal && !this.options.breaks) ||
+            !positions ||
+            positions.length < 3 ||
+            typeof min === 'undefined') {
+            return time.getTimeTicks.apply(time, arguments);
+        }
+        // Analyze the positions array to split it into segments on gaps
+        // larger than 5 times the closest distance. The closest distance is
+        // already found at this point, so we reuse that instead of
+        // computing it again.
+        var posLength = positions.length;
+        for (end = 0; end < posLength; end++) {
+            outsideMax = end && positions[end - 1] > max;
+            if (positions[end] < min) { // Set the last position before min
+                start = end;
+            }
+            if (end === posLength - 1 ||
+                positions[end + 1] - positions[end] > closestDistance * 5 ||
+                outsideMax) {
+                // For each segment, calculate the tick positions from the
+                // getTimeTicks utility function. The interval will be the
+                // same regardless of how long the segment is.
+                if (positions[end] > lastGroupPosition) { // #1475
+                    segmentPositions = time.getTimeTicks(normalizedInterval, positions[start], positions[end], startOfWeek);
+                    // Prevent duplicate groups, for example for multiple
+                    // segments within one larger time frame (#1475)
+                    while (segmentPositions.length &&
+                        segmentPositions[0] <= lastGroupPosition) {
+                        segmentPositions.shift();
+                    }
+                    if (segmentPositions.length) {
+                        lastGroupPosition =
+                            segmentPositions[segmentPositions.length - 1];
+                    }
+                    segmentStarts.push(groupPositions.length);
+                    groupPositions = groupPositions.concat(segmentPositions);
+                }
+                // Set start of next segment
+                start = end + 1;
+            }
+            if (outsideMax) {
+                break;
+            }
+        }
+        // Get the grouping info from the last of the segments. The info is
+        // the same for all segments.
+        if (segmentPositions) {
+            info = segmentPositions.info;
+            // Optionally identify ticks with higher rank, for example
+            // when the ticks have crossed midnight.
+            if (findHigherRanks && info.unitRange <= timeUnits.hour) {
+                end = groupPositions.length - 1;
+                // Compare points two by two
+                for (start = 1; start < end; start++) {
+                    if (time.dateFormat('%d', groupPositions[start]) !==
+                        time.dateFormat('%d', groupPositions[start - 1])) {
+                        higherRanks[groupPositions[start]] = 'day';
+                        hasCrossedHigherRank = true;
+                    }
+                }
+                // If the complete array has crossed midnight, we want
+                // to mark the first positions also as higher rank
+                if (hasCrossedHigherRank) {
+                    higherRanks[groupPositions[0]] = 'day';
+                }
+                info.higherRanks = higherRanks;
+            }
+            // Save the info
+            info.segmentStarts = segmentStarts;
+            groupPositions.info = info;
+        }
+        else {
+            error(12, false, this.chart);
+        }
+        // Don't show ticks within a gap in the ordinal axis, where the
+        // space between two points is greater than a portion of the tick
+        // pixel interval
+        if (findHigherRanks && defined(tickPixelIntervalOption)) {
+            var length_1 = groupPositions.length, translatedArr = [], distances = [];
+            var itemToRemove = void 0, translated = void 0, lastTranslated = void 0, medianDistance = void 0, distance = void 0, i = length_1;
+            // Find median pixel distance in order to keep a reasonably even
+            // distance between ticks (#748)
+            while (i--) {
+                translated = this.translate(groupPositions[i]);
+                if (lastTranslated) {
+                    distances[i] = lastTranslated - translated;
+                }
+                translatedArr[i] = lastTranslated = translated;
+            }
+            distances.sort();
+            medianDistance = distances[Math.floor(distances.length / 2)];
+            if (medianDistance < tickPixelIntervalOption * 0.6) {
+                medianDistance = null;
+            }
+            // Now loop over again and remove ticks where needed
+            i = groupPositions[length_1 - 1] > max ? length_1 - 1 : length_1; // #817
+            lastTranslated = void 0;
+            while (i--) {
+                translated = translatedArr[i];
+                distance = Math.abs(lastTranslated - translated);
+                // #4175 - when axis is reversed, the distance, is negative
+                // but tickPixelIntervalOption positive, so we need to
+                // compare the same values
+                // Remove ticks that are closer than 0.6 times the pixel
+                // interval from the one to the right, but not if it is
+                // close to the median distance (#748).
+                if (lastTranslated &&
+                    distance < tickPixelIntervalOption * 0.8 &&
+                    (medianDistance === null || distance < medianDistance * 0.8)) {
+                    // Is this a higher ranked position with a normal
+                    // position to the right?
+                    if (higherRanks[groupPositions[i]] &&
+                        !higherRanks[groupPositions[i + 1]]) {
+                        // Yes: remove the lower ranked neighbour to the
+                        // right
+                        itemToRemove = i + 1;
+                        lastTranslated = translated; // #709
+                    }
+                    else {
+                        // No: remove this one
+                        itemToRemove = i;
+                    }
+                    groupPositions.splice(itemToRemove, 1);
+                }
+                else {
+                    lastTranslated = translated;
+                }
+            }
+        }
+        return groupPositions;
+    }
+    /**
+     * Get axis position of given index of the extended ordinal positions.
+     * Used only when panning an ordinal axis.
+     *
+     * @private
+     * @function Highcharts.Axis#index2val
+     *
+     * @param {number} index
+     *        The index value of searched point
+     *
+     * @return {number}
+     */
+    function index2val(index) {
+        var axis = this, ordinal = axis.ordinal, 
+        // Context could be changed to extendedOrdinalPositions.
+        ordinalPositions = ordinal.positions;
+        // The visible range contains only equally spaced values.
+        if (!ordinalPositions) {
+            return index;
+        }
+        var i = ordinalPositions.length - 1, distance;
+        if (index < 0) { // out of range, in effect panning to the left
+            index = ordinalPositions[0];
+        }
+        else if (index > i) { // out of range, panning to the right
+            index = ordinalPositions[i];
+        }
+        else { // split it up
+            i = Math.floor(index);
+            distance = index - i; // the decimal
+        }
+        if (typeof distance !== 'undefined' &&
+            typeof ordinalPositions[i] !== 'undefined') {
+            return ordinalPositions[i] + (distance ?
+                distance *
+                    (ordinalPositions[i + 1] - ordinalPositions[i]) :
+                0);
+        }
+        return index;
+    }
+    /**
+     * Translate from linear (internal) to axis value.
+     *
+     * @private
+     * @function Highcharts.Axis#lin2val
+     *
+     * @param {number} val
+     *        The linear abstracted value.
+     *
+     * @return {number}
+     */
+    function lin2val(val) {
+        var axis = this, ordinal = axis.ordinal, localMin = axis.old ? axis.old.min : axis.min, localA = axis.old ? axis.old.transA : axis.transA;
+        var positions = ordinal.positions; // for the current visible range
+        // The visible range contains only equally spaced values.
+        if (!positions) {
+            return val;
+        }
+        // Convert back from modivied value to pixels. // #15970
+        var pixelVal = (val - localMin) * localA + axis.minPixelPadding, isInside = pixelVal > 0 && pixelVal < axis.left + axis.len;
+        // If the value is not inside the plot area,
+        // use the extended positions.
+        // (array contains also points that are outside of the plotArea).
+        if (!isInside) {
+            // When iterating for the first time,
+            // get the extended ordinal positional and assign them.
+            if (!ordinal.extendedOrdinalPositions) {
+                ordinal.extendedOrdinalPositions = ordinal.getExtendedPositions();
+            }
+            positions = ordinal.extendedOrdinalPositions;
+        }
+        // In some cases (especially in early stages of the chart creation)
+        // the getExtendedPositions might return undefined.
+        if (positions && positions.length) {
+            var index = ordinal.getIndexOfPoint(pixelVal, positions), mantissa = correctFloat(index % 1);
+            // Check if the index is inside position array.
+            // If true, read/approximate value for that exact index.
+            if (index >= 0 && index < positions.length) {
+                var leftNeighbour = positions[Math.floor(index)], rightNeighbour = positions[Math.ceil(index)], distance = rightNeighbour - leftNeighbour;
+                return positions[Math.floor(index)] + mantissa * distance;
+            }
+            // For cases when the index is not in the extended ordinal
+            // position array, like when the value we are looking
+            // for exceed the available data,
+            // approximate that value based on the calculated slope.
+            var positionsLength = positions.length, firstPositionsValue = positions[0], lastPositionsValue = positions[positionsLength - 1], slope = (lastPositionsValue - firstPositionsValue) / (positionsLength - 1);
+            if (index < 0) {
+                return firstPositionsValue + slope * index;
+            }
+            return lastPositionsValue + slope * (index - positionsLength);
+        }
+        return val;
+    }
+    /**
+     * Internal function to calculate the precise index
+     * in ordinalPositions array.
+     * @private
+     */
+    function getIndexInArray(ordinalPositions, val) {
+        var index = OrdinalAxis.Additions.findIndexOf(ordinalPositions, val, true);
+        if (ordinalPositions[index] === val) {
+            return index;
+        }
+        var percent = (val - ordinalPositions[index]) /
+            (ordinalPositions[index + 1] - ordinalPositions[index]);
+        return index + percent;
+    }
+    /**
+    * @private
+    */
+    function onAxisAfterInit() {
+        var axis = this;
+        if (!axis.ordinal) {
+            axis.ordinal = new OrdinalAxis.Additions(axis);
+        }
+    }
+    /**
+     * @private
+     */
+    function onAxisFoundExtremes() {
+        var axis = this;
+        if (axis.isXAxis &&
+            defined(axis.options.overscroll) &&
+            axis.max === axis.dataMax &&
+            (
+            // Panning is an execption. We don't want to apply
+            // overscroll when panning over the dataMax
+            !axis.chart.mouseIsDown ||
+                axis.isInternal) && (
+        // Scrollbar buttons are the other execption:
+        !axis.eventArgs ||
+            axis.eventArgs && axis.eventArgs.trigger !== 'navigator')) {
+            axis.max += axis.options.overscroll;
+            // Live data and buttons require translation for the min:
+            if (!axis.isInternal && defined(axis.userMin)) {
+                axis.min += axis.options.overscroll;
+            }
+        }
+    }
+    /**
+     * For ordinal axis, that loads data async, redraw axis after data is
+     * loaded. If we don't do that, axis will have the same extremes as
+     * previously, but ordinal positions won't be calculated. See #10290
+     * @private
+     */
+    function onAxisAfterSetScale() {
+        var axis = this;
+        if (axis.horiz && !axis.isDirty) {
+            axis.isDirty = axis.isOrdinal &&
+                axis.chart.navigator &&
+                !axis.chart.navigator.adaptToUpdatedData;
+        }
+    }
+    /**
+     * @private
+     */
+    function onAxisInitialAxisTranslation() {
+        var axis = this;
+        if (axis.ordinal) {
+            axis.ordinal.beforeSetTickPositions();
+            axis.tickInterval = axis.ordinal.postProcessTickInterval(axis.tickInterval);
+        }
+    }
+    /**
+     * @private
+     *
+     * Extending the Chart.pan method for ordinal axes
+     */
+    function onChartPan(e) {
+        var chart = this, xAxis = chart.xAxis[0], overscroll = xAxis.options.overscroll, chartX = e.originalEvent.chartX, panning = chart.options.chart.panning;
+        var runBase = false;
+        if (panning &&
+            panning.type !== 'y' &&
+            xAxis.options.ordinal &&
+            xAxis.series.length) {
+            var mouseDownX = chart.mouseDownX, extremes = xAxis.getExtremes(), dataMax = extremes.dataMax, min = extremes.min, max = extremes.max, hoverPoints = chart.hoverPoints, closestPointRange = (xAxis.closestPointRange ||
+                (xAxis.ordinal && xAxis.ordinal.overscrollPointsRange)), pointPixelWidth = (xAxis.translationSlope *
+                (xAxis.ordinal.slope || closestPointRange)), 
+            // how many ordinal units did we move?
+            movedUnits = (mouseDownX - chartX) / pointPixelWidth, 
+            // get index of all the chart's points
+            extendedAxis = { ordinal: { positions: xAxis.ordinal.getExtendedPositions() } }, index2val_1 = xAxis.index2val, val2lin_1 = xAxis.val2lin;
+            var trimmedRange = void 0, ordinalPositions = void 0, searchAxisLeft = void 0, searchAxisRight = void 0;
+            // we have an ordinal axis, but the data is equally spaced
+            if (!extendedAxis.ordinal.positions) {
+                runBase = true;
+            }
+            else if (Math.abs(movedUnits) > 1) {
+                // Remove active points for shared tooltip
+                if (hoverPoints) {
+                    hoverPoints.forEach(function (point) {
+                        point.setState();
+                    });
+                }
+                if (movedUnits < 0) {
+                    searchAxisLeft = extendedAxis;
+                    searchAxisRight = xAxis.ordinal.positions ? xAxis : extendedAxis;
+                }
+                else {
+                    searchAxisLeft = xAxis.ordinal.positions ? xAxis : extendedAxis;
+                    searchAxisRight = extendedAxis;
+                }
+                // In grouped data series, the last ordinal position
+                // represents the grouped data, which is to the left of the
+                // real data max. If we don't compensate for this, we will
+                // be allowed to pan grouped data series passed the right of
+                // the plot area.
+                ordinalPositions = searchAxisRight.ordinal.positions;
+                if (dataMax >
+                    ordinalPositions[ordinalPositions.length - 1]) {
+                    ordinalPositions.push(dataMax);
+                }
+                // Get the new min and max values by getting the ordinal
+                // index for the current extreme, then add the moved units
+                // and translate back to values. This happens on the
+                // extended ordinal positions if the new position is out of
+                // range, else it happens on the current x axis which is
+                // smaller and faster.
+                chart.fixedRange = max - min;
+                trimmedRange = xAxis.navigatorAxis.toFixedRange(null, null, index2val_1.apply(searchAxisLeft, [
+                    val2lin_1.apply(searchAxisLeft, [min, true]) + movedUnits
+                ]), index2val_1.apply(searchAxisRight, [
+                    val2lin_1.apply(searchAxisRight, [max, true]) + movedUnits
+                ]));
+                // Apply it if it is within the available data range
+                if (trimmedRange.min >= Math.min(extremes.dataMin, min) &&
+                    trimmedRange.max <= Math.max(dataMax, max) + overscroll) {
+                    xAxis.setExtremes(trimmedRange.min, trimmedRange.max, true, false, { trigger: 'pan' });
+                }
+                chart.mouseDownX = chartX; // set new reference for next run
+                css(chart.container, { cursor: 'move' });
+            }
+        }
+        else {
+            runBase = true;
+        }
+        // revert to the linear chart.pan version
+        if (runBase || (panning && /y/.test(panning.type))) {
+            if (overscroll) {
+                xAxis.max = xAxis.dataMax + overscroll;
+            }
+        }
+        else {
+            e.preventDefault();
+        }
+    }
+    /**
+     * @private
+     */
+    function onSeriesUpdatedData() {
+        var xAxis = this.xAxis;
+        // Destroy the extended ordinal index on updated data
+        // and destroy extendedOrdinalPositions, #16055.
+        if (xAxis && xAxis.options.ordinal) {
+            delete xAxis.ordinal.index;
+            delete xAxis.ordinal.extendedOrdinalPositions;
+        }
+    }
+    /**
+     * Translate from a linear axis value to the corresponding ordinal axis
+     * position. If there are no gaps in the ordinal axis this will be the
+     * same. The translated value is the value that the point would have if
+     * the axis was linear, using the same min and max.
+     *
+     * @private
+     * @function Highcharts.Axis#val2lin
+     *
+     * @param {number} val
+     * The axis value.
+     *
+     * @param {boolean} [toIndex]
+     * Whether to return the index in the ordinalPositions or the new value.
+     *
+     * @return {number}
+     */
+    function val2lin(val, toIndex) {
+        var axis = this, ordinal = axis.ordinal, ordinalPositions = ordinal.positions;
+        var slope = ordinal.slope, extendedOrdinalPositions = ordinal.extendedOrdinalPositions;
+        if (!ordinalPositions) {
+            return val;
+        }
+        var ordinalLength = ordinalPositions.length;
+        var ordinalIndex;
+        // If the searched value is inside visible plotArea, ivastigate the
+        // value basing on ordinalPositions.
+        if (ordinalPositions[0] <= val &&
+            ordinalPositions[ordinalLength - 1] >= val) {
+            ordinalIndex = getIndexInArray(ordinalPositions, val);
+            // final return value is based on ordinalIndex
+        }
+        else {
+            if (!extendedOrdinalPositions) {
+                extendedOrdinalPositions =
+                    ordinal.getExtendedPositions &&
+                        ordinal.getExtendedPositions();
+                ordinal.extendedOrdinalPositions = extendedOrdinalPositions;
+            }
+            if (!(extendedOrdinalPositions && extendedOrdinalPositions.length)) {
+                return val;
+            }
+            var length_2 = extendedOrdinalPositions.length;
+            if (!slope) {
+                slope =
+                    (extendedOrdinalPositions[length_2 - 1] -
+                        extendedOrdinalPositions[0]) /
+                        length_2;
+            }
+            // OriginalPointReference is equal to the index of
+            // first point of ordinalPositions in extendedOrdinalPositions.
+            var originalPositionsReference = getIndexInArray(extendedOrdinalPositions, ordinalPositions[0]);
+            // If the searched value is outside the visiblePlotArea,
+            // check if it is inside extendedOrdinalPositions.
+            if (val >= extendedOrdinalPositions[0] &&
+                val <=
+                    extendedOrdinalPositions[length_2 - 1]) {
+                // Return Value
+                ordinalIndex = getIndexInArray(extendedOrdinalPositions, val) - originalPositionsReference;
+            }
+            else {
+                // Since ordinal.slope is the average distance between 2
+                // points on visible plotArea, this can be used to calculete
+                // the approximate position of the point, which is outside
+                // the extededOrdinalPositions.
+                if (val < extendedOrdinalPositions[0]) {
+                    var diff = extendedOrdinalPositions[0] - val, approximateIndexOffset = diff / slope;
+                    ordinalIndex =
+                        -originalPositionsReference -
+                            approximateIndexOffset;
+                }
+                else {
+                    var diff = val -
+                        extendedOrdinalPositions[length_2 - 1], approximateIndexOffset = diff / slope;
+                    ordinalIndex =
+                        approximateIndexOffset +
+                            length_2 -
+                            originalPositionsReference;
+                }
+            }
+        }
+        return toIndex ? ordinalIndex : slope * (ordinalIndex || 0) +
+            ordinal.offset;
+    }
     /* *
      *
      *  Classes
@@ -30,7 +583,7 @@ var OrdinalAxis;
     /**
      * @private
      */
-    var Composition = /** @class */ (function () {
+    var Additions = /** @class */ (function () {
         /* *
          *
          *  Constructors
@@ -39,7 +592,7 @@ var OrdinalAxis;
         /**
          * @private
          */
-        function Composition(axis) {
+        function Additions(axis) {
             this.index = {};
             this.axis = axis;
         }
@@ -50,11 +603,11 @@ var OrdinalAxis;
         * */
         /**
          * Calculate the ordinal positions before tick positions are calculated.
-         *
          * @private
          */
-        Composition.prototype.beforeSetTickPositions = function () {
-            var axis = this.axis, ordinal = axis.ordinal, len, ordinalPositions = [], uniqueOrdinalPositions, useOrdinal = false, dist, extremes = axis.getExtremes(), min = extremes.min, max = extremes.max, minIndex, maxIndex, slope, hasBreaks = axis.isXAxis && !!axis.options.breaks, isOrdinal = axis.options.ordinal, overscrollPointsRange = Number.MAX_VALUE, ignoreHiddenSeries = axis.chart.options.chart.ignoreHiddenSeries, i, hasBoostedSeries;
+        Additions.prototype.beforeSetTickPositions = function () {
+            var axis = this.axis, ordinal = axis.ordinal, extremes = axis.getExtremes(), min = extremes.min, max = extremes.max, hasBreaks = axis.isXAxis && !!axis.options.breaks, isOrdinal = axis.options.ordinal, ignoreHiddenSeries = axis.chart.options.chart.ignoreHiddenSeries;
+            var len, uniqueOrdinalPositions, dist, minIndex, maxIndex, slope, i, hasBoostedSeries, ordinalPositions = [], overscrollPointsRange = Number.MAX_VALUE, useOrdinal = false;
             // Apply the ordinal logic
             if (isOrdinal || hasBreaks) { // #4167 YAxis is never ordinal ?
                 axis.series.forEach(function (series, i) {
@@ -170,6 +723,39 @@ var OrdinalAxis;
             axis.isOrdinal = isOrdinal && useOrdinal; // #3818, #4196, #4926
             ordinal.groupIntervalFactor = null; // reset for next run
         };
+        /**
+         * Faster way of using the Array.indexOf method.
+         * Works for sorted arrays only with unique values.
+         *
+         * @param {Array} sortedArray
+         *        The sorted array inside which we are looking for.
+         * @param {number} key
+         *        The key to being found.
+         * @param {boolean} indirectSearch
+         *        In case of lack of the point in the array, should return
+         *        value be equal to -1 or the closest smaller index.
+         *  @private
+         */
+        Additions.findIndexOf = function (sortedArray, key, indirectSearch) {
+            var start = 0, end = sortedArray.length - 1, middle;
+            while (start < end) {
+                middle = Math.ceil((start + end) / 2);
+                // Key found as the middle element.
+                if (sortedArray[middle] <= key) {
+                    // Continue searching to the right.
+                    start = middle;
+                }
+                else {
+                    // Continue searching to the left.
+                    end = middle - 1;
+                }
+            }
+            if (sortedArray[start] === key) {
+                return start;
+            }
+            // Key could not be found.
+            return !indirectSearch ? -1 : start;
+        };
         /**
          * Get the ordinal positions for the entire data set. This is necessary
          * in chart panning because we need to find out what points or data
@@ -177,13 +763,13 @@ var OrdinalAxis;
          * operation starts, if an index for the given grouping does not exists,
          * it is created and cached. This index is deleted on updated data, so
          * it will be regenerated the next time a panning operation starts.
-         *
          * @private
          */
-        Composition.prototype.getExtendedPositions = function () {
-            var ordinal = this, axis = ordinal.axis, axisProto = axis.constructor.prototype, chart = axis.chart, grouping = axis.series[0].currentDataGrouping, ordinalIndex = ordinal.index, key = grouping ?
+        Additions.prototype.getExtendedPositions = function () {
+            var ordinal = this, axis = ordinal.axis, axisProto = axis.constructor.prototype, chart = axis.chart, grouping = axis.series[0].currentDataGrouping, key = grouping ?
                 grouping.count + grouping.unitName :
-                'raw', overscroll = axis.options.overscroll, extremes = axis.getExtremes(), fakeAxis, fakeSeries;
+                'raw', overscroll = axis.options.overscroll, extremes = axis.getExtremes();
+            var fakeAxis, fakeSeries = void 0, ordinalIndex = ordinal.index;
             // If this is the first time, or the ordinal index is deleted by
             // updatedData,
             // create it.
@@ -212,6 +798,7 @@ var OrdinalAxis;
                         getGroupIntervalFactor: this.getGroupIntervalFactor
                     },
                     ordinal2lin: axisProto.ordinal2lin,
+                    getIndexOfPoint: axisProto.getIndexOfPoint,
                     val2lin: axisProto.val2lin // #2590
                 };
                 fakeAxis.ordinal.axis = fakeAxis;
@@ -223,11 +810,15 @@ var OrdinalAxis;
                         xData: series.xData.slice(),
                         chart: chart,
                         destroyGroupedData: H.noop,
-                        getProcessedData: Series.prototype.getProcessedData
+                        getProcessedData: Series.prototype.getProcessedData,
+                        applyGrouping: Series.prototype.applyGrouping
                     };
                     fakeSeries.xData = fakeSeries.xData.concat(ordinal.getOverscrollPositions());
                     fakeSeries.options = {
                         dataGrouping: grouping ? {
+                            firstAnchor: 'firstPoint',
+                            anchor: 'middle',
+                            lastAnchor: 'lastPoint',
                             enabled: true,
                             forced: true,
                             // doesn't matter which, use the fastest
@@ -242,12 +833,15 @@ var OrdinalAxis;
                     };
                     fakeAxis.series.push(fakeSeries);
                     series.processData.apply(fakeSeries);
-                    // Force to use the ordinal when points are evenly spaced
-                    // (e.g. weeks), #3825.
-                    if (fakeSeries.closestPointRange !== fakeSeries.basePointRange && fakeSeries.currentDataGrouping) {
-                        fakeAxis.forceOrdinal = true;
-                    }
                 });
+                // Apply grouping if needed.
+                axis.applyGrouping.call(fakeAxis);
+                // Force to use the ordinal when points are evenly spaced
+                // (e.g. weeks), #3825.
+                if (fakeSeries.closestPointRange !== fakeSeries.basePointRange &&
+                    fakeSeries.currentDataGrouping) {
+                    fakeAxis.forceOrdinal = true;
+                }
                 // Run beforeSetTickPositions to compute the ordinalPositions
                 axis.ordinal.beforeSetTickPositions.apply({ axis: fakeAxis });
                 // Cache it
@@ -276,11 +870,11 @@ var OrdinalAxis;
          * logic, where we do another run with a greater interval if the number
          * of data groups is more than a certain fraction of the desired group
          * count.
-         *
          * @private
          */
-        Composition.prototype.getGroupIntervalFactor = function (xMin, xMax, series) {
-            var ordinal = this, axis = ordinal.axis, i, processedXData = series.processedXData, len = processedXData.length, distances = [], median, groupIntervalFactor = ordinal.groupIntervalFactor;
+        Additions.prototype.getGroupIntervalFactor = function (xMin, xMax, series) {
+            var ordinal = this, axis = ordinal.axis, processedXData = series.processedXData, len = processedXData.length, distances = [];
+            var median, i, groupIntervalFactor = ordinal.groupIntervalFactor;
             // Only do this computation for the first series, let the other
             // inherit it (#2416)
             if (!groupIntervalFactor) {
@@ -304,6 +898,45 @@ var OrdinalAxis;
             // Return the factor needed for data grouping
             return groupIntervalFactor;
         };
+        /**
+         * Get index of point inside the ordinal positions array.
+         *
+         * @private
+         * @param {number} val
+         *        The pixel value of a point.
+         *
+         * @param {Array<number>} [ordinallArray]
+         *        An array of all points available on the axis
+         *        for the given data set.
+         *        Either ordinalPositions if the value is inside the plotArea
+         *        or extendedOrdinalPositions if not.
+         *
+         * @return {number}
+         */
+        Additions.prototype.getIndexOfPoint = function (val, ordinalArray) {
+            var ordinal = this, axis = ordinal.axis, firstPointVal = ordinal.positions ? ordinal.positions[0] : 0;
+            var firstPointX = axis.series[0].points &&
+                axis.series[0].points[0] &&
+                axis.series[0].points[0].plotX ||
+                axis.minPixelPadding; // #15987
+            // When more series assign to axis, find the smallest one, #15987.
+            if (axis.series.length > 1) {
+                axis.series.forEach(function (series) {
+                    if (defined(series.points[0]) &&
+                        defined(series.points[0].plotX) &&
+                        series.points[0].plotX < firstPointX) {
+                        firstPointX = series.points[0].plotX;
+                    }
+                });
+            }
+            // Distance in pixels between two points
+            // on the ordinal axis in the current zoom.
+            var ordinalPointPixelInterval = axis.translationSlope *
+                (ordinal.slope || axis.closestPointRange || ordinal.overscrollPointsRange), 
+            // toValue for the first point.
+            shiftIndex = (val - firstPointX) / ordinalPointPixelInterval;
+            return Additions.findIndexOf(ordinalArray, firstPointVal) + shiftIndex;
+        };
         /**
          * Get ticks for an ordinal axis within a range where points don't
          * exist. It is required when overscroll is enabled. We can't base on
@@ -311,14 +944,12 @@ var OrdinalAxis;
          * pointRange and generate these ticks between Axis.dataMax,
          * Axis.dataMax + Axis.overscroll evenly spaced. Used in panning and
          * navigator scrolling.
-         *
          * @private
          */
-        Composition.prototype.getOverscrollPositions = function () {
+        Additions.prototype.getOverscrollPositions = function () {
             var ordinal = this, axis = ordinal.axis, extraRange = axis.options.overscroll, distance = ordinal.overscrollPointsRange, positions = [], max = axis.dataMax;
             if (defined(distance)) {
                 // Max + pointRange because we need to scroll to the last
-                positions.push(max);
                 while (max <= axis.dataMax + extraRange) {
                     max += distance;
                     positions.push(max);
@@ -329,17 +960,17 @@ var OrdinalAxis;
         /**
          * Make the tick intervals closer because the ordinal gaps make the
          * ticks spread out or cluster.
-         *
          * @private
          */
-        Composition.prototype.postProcessTickInterval = function (tickInterval) {
+        Additions.prototype.postProcessTickInterval = function (tickInterval) {
             // Problem: https://jsfiddle.net/highcharts/FQm4E/1/
             // This is a case where this algorithm doesn't work optimally. In
             // this case, the tick labels are spread out per week, but all the
             // gaps reside within weeks. So we have a situation where the labels
             // are courser than the ordinal gaps, and thus the tick interval
             // should not be altered.
-            var ordinal = this, axis = ordinal.axis, ordinalSlope = ordinal.slope, ret;
+            var ordinal = this, axis = ordinal.axis, ordinalSlope = ordinal.slope;
+            var ret;
             if (ordinalSlope) {
                 if (!axis.options.breaks) {
                     ret = tickInterval / (ordinalSlope / axis.closestPointRange);
@@ -353,438 +984,13 @@ var OrdinalAxis;
             }
             return ret;
         };
-        return Composition;
+        return Additions;
     }());
-    OrdinalAxis.Composition = Composition;
-    /* *
-     *
-     *  Functions
-     *
-     * */
-    /**
-     * Extends the axis with ordinal support.
-     *
-     * @private
-     *
-     * @param AxisClass
-     * Axis class to extend.
-     *
-     * @param ChartClass
-     * Chart class to use.
-     *
-     * @param SeriesClass
-     * Series class to use.
-     */
-    function compose(AxisClass, ChartClass, SeriesClass) {
-        AxisClass.keepProps.push('ordinal');
-        var axisProto = AxisClass.prototype;
-        /**
-         * In an ordinal axis, there might be areas with dense consentrations of
-         * points, then large gaps between some. Creating equally distributed
-         * ticks over this entire range may lead to a huge number of ticks that
-         * will later be removed. So instead, break the positions up in
-         * segments, find the tick positions for each segment then concatenize
-         * them. This method is used from both data grouping logic and X axis
-         * tick position logic.
-         *
-         * @private
-         */
-        AxisClass.prototype.getTimeTicks = function (normalizedInterval, min, max, startOfWeek, positions, closestDistance, findHigherRanks) {
-            if (positions === void 0) { positions = []; }
-            if (closestDistance === void 0) { closestDistance = 0; }
-            var start = 0, end, segmentPositions, higherRanks = {}, hasCrossedHigherRank, info, posLength, outsideMax, groupPositions = [], lastGroupPosition = -Number.MAX_VALUE, tickPixelIntervalOption = this.options.tickPixelInterval, time = this.chart.time, 
-            // Record all the start positions of a segment, to use when
-            // deciding what's a gap in the data.
-            segmentStarts = [];
-            // The positions are not always defined, for example for ordinal
-            // positions when data has regular interval (#1557, #2090)
-            if ((!this.options.ordinal && !this.options.breaks) ||
-                !positions ||
-                positions.length < 3 ||
-                typeof min === 'undefined') {
-                return time.getTimeTicks.apply(time, arguments);
-            }
-            // Analyze the positions array to split it into segments on gaps
-            // larger than 5 times the closest distance. The closest distance is
-            // already found at this point, so we reuse that instead of
-            // computing it again.
-            posLength = positions.length;
-            for (end = 0; end < posLength; end++) {
-                outsideMax = end && positions[end - 1] > max;
-                if (positions[end] < min) { // Set the last position before min
-                    start = end;
-                }
-                if (end === posLength - 1 ||
-                    positions[end + 1] - positions[end] > closestDistance * 5 ||
-                    outsideMax) {
-                    // For each segment, calculate the tick positions from the
-                    // getTimeTicks utility function. The interval will be the
-                    // same regardless of how long the segment is.
-                    if (positions[end] > lastGroupPosition) { // #1475
-                        segmentPositions = time.getTimeTicks(normalizedInterval, positions[start], positions[end], startOfWeek);
-                        // Prevent duplicate groups, for example for multiple
-                        // segments within one larger time frame (#1475)
-                        while (segmentPositions.length &&
-                            segmentPositions[0] <= lastGroupPosition) {
-                            segmentPositions.shift();
-                        }
-                        if (segmentPositions.length) {
-                            lastGroupPosition =
-                                segmentPositions[segmentPositions.length - 1];
-                        }
-                        segmentStarts.push(groupPositions.length);
-                        groupPositions = groupPositions.concat(segmentPositions);
-                    }
-                    // Set start of next segment
-                    start = end + 1;
-                }
-                if (outsideMax) {
-                    break;
-                }
-            }
-            // Get the grouping info from the last of the segments. The info is
-            // the same for all segments.
-            if (segmentPositions) {
-                info = segmentPositions.info;
-                // Optionally identify ticks with higher rank, for example
-                // when the ticks have crossed midnight.
-                if (findHigherRanks && info.unitRange <= timeUnits.hour) {
-                    end = groupPositions.length - 1;
-                    // Compare points two by two
-                    for (start = 1; start < end; start++) {
-                        if (time.dateFormat('%d', groupPositions[start]) !==
-                            time.dateFormat('%d', groupPositions[start - 1])) {
-                            higherRanks[groupPositions[start]] = 'day';
-                            hasCrossedHigherRank = true;
-                        }
-                    }
-                    // If the complete array has crossed midnight, we want
-                    // to mark the first positions also as higher rank
-                    if (hasCrossedHigherRank) {
-                        higherRanks[groupPositions[0]] = 'day';
-                    }
-                    info.higherRanks = higherRanks;
-                }
-                // Save the info
-                info.segmentStarts = segmentStarts;
-                groupPositions.info = info;
-            }
-            else {
-                error(12, false, this.chart);
-            }
-            // Don't show ticks within a gap in the ordinal axis, where the
-            // space between two points is greater than a portion of the tick
-            // pixel interval
-            if (findHigherRanks && defined(tickPixelIntervalOption)) {
-                var length_1 = groupPositions.length, i = length_1, itemToRemove = void 0, translated = void 0, translatedArr = [], lastTranslated = void 0, medianDistance = void 0, distance = void 0, distances = [];
-                // Find median pixel distance in order to keep a reasonably even
-                // distance between ticks (#748)
-                while (i--) {
-                    translated = this.translate(groupPositions[i]);
-                    if (lastTranslated) {
-                        distances[i] = lastTranslated - translated;
-                    }
-                    translatedArr[i] = lastTranslated = translated;
-                }
-                distances.sort();
-                medianDistance = distances[Math.floor(distances.length / 2)];
-                if (medianDistance < tickPixelIntervalOption * 0.6) {
-                    medianDistance = null;
-                }
-                // Now loop over again and remove ticks where needed
-                i = groupPositions[length_1 - 1] > max ? length_1 - 1 : length_1; // #817
-                lastTranslated = void 0;
-                while (i--) {
-                    translated = translatedArr[i];
-                    distance = Math.abs(lastTranslated - translated);
-                    // #4175 - when axis is reversed, the distance, is negative
-                    // but tickPixelIntervalOption positive, so we need to
-                    // compare the same values
-                    // Remove ticks that are closer than 0.6 times the pixel
-                    // interval from the one to the right, but not if it is
-                    // close to the median distance (#748).
-                    if (lastTranslated &&
-                        distance < tickPixelIntervalOption * 0.8 &&
-                        (medianDistance === null || distance < medianDistance * 0.8)) {
-                        // Is this a higher ranked position with a normal
-                        // position to the right?
-                        if (higherRanks[groupPositions[i]] &&
-                            !higherRanks[groupPositions[i + 1]]) {
-                            // Yes: remove the lower ranked neighbour to the
-                            // right
-                            itemToRemove = i + 1;
-                            lastTranslated = translated; // #709
-                        }
-                        else {
-                            // No: remove this one
-                            itemToRemove = i;
-                        }
-                        groupPositions.splice(itemToRemove, 1);
-                    }
-                    else {
-                        lastTranslated = translated;
-                    }
-                }
-            }
-            return groupPositions;
-        };
-        /**
-         * Translate from linear (internal) to axis value.
-         *
-         * @private
-         * @function Highcharts.Axis#lin2val
-         *
-         * @param {number} val
-         *        The linear abstracted value.
-         *
-         * @param {boolean} [fromIndex]
-         *        Translate from an index in the ordinal positions rather than a
-         *        value.
-         *
-         * @return {number}
-         */
-        axisProto.lin2val = function (val, fromIndex) {
-            var axis = this, ordinal = axis.ordinal, ordinalPositions = ordinal.positions, ret;
-            // the visible range contains only equally spaced values
-            if (!ordinalPositions) {
-                ret = val;
-            }
-            else {
-                var ordinalSlope = ordinal.slope, ordinalOffset = ordinal.offset, i = ordinalPositions.length - 1, linearEquivalentLeft = void 0, linearEquivalentRight = void 0, distance = void 0;
-                // Handle the case where we translate from the index directly,
-                // used only when panning an ordinal axis
-                if (fromIndex) {
-                    if (val < 0) { // out of range, in effect panning to the left
-                        val = ordinalPositions[0];
-                    }
-                    else if (val > i) { // out of range, panning to the right
-                        val = ordinalPositions[i];
-                    }
-                    else { // split it up
-                        i = Math.floor(val);
-                        distance = val - i; // the decimal
-                    }
-                    // Loop down along the ordinal positions. When the linear
-                    // equivalent of i matches an ordinal position, interpolate
-                    // between the left and right values.
-                }
-                else {
-                    while (i--) {
-                        linearEquivalentLeft =
-                            (ordinalSlope * i) + ordinalOffset;
-                        if (val >= linearEquivalentLeft) {
-                            linearEquivalentRight =
-                                (ordinalSlope *
-                                    (i + 1)) +
-                                    ordinalOffset;
-                            // something between 0 and 1
-                            distance = (val - linearEquivalentLeft) /
-                                (linearEquivalentRight - linearEquivalentLeft);
-                            break;
-                        }
-                    }
-                }
-                // If the index is within the range of the ordinal positions,
-                // return the associated or interpolated value. If not, just
-                // return the value.
-                return (typeof distance !== 'undefined' &&
-                    typeof ordinalPositions[i] !== 'undefined' ?
-                    ordinalPositions[i] + (distance ?
-                        distance *
-                            (ordinalPositions[i + 1] - ordinalPositions[i]) :
-                        0) :
-                    val);
-            }
-            return ret;
-        };
-        /**
-         * Translate from a linear axis value to the corresponding ordinal axis
-         * position. If there are no gaps in the ordinal axis this will be the
-         * same. The translated value is the value that the point would have if
-         * the axis were linear, using the same min and max.
-         *
-         * @private
-         * @function Highcharts.Axis#val2lin
-         *
-         * @param {number} val
-         * The axis value.
-         *
-         * @param {boolean} [toIndex]
-         * Whether to return the index in the ordinalPositions or the new value.
-         *
-         * @return {number}
-         */
-        axisProto.val2lin = function (val, toIndex) {
-            var axis = this, ordinal = axis.ordinal, ordinalPositions = ordinal.positions, ret;
-            if (!ordinalPositions) {
-                ret = val;
-            }
-            else {
-                var ordinalLength = ordinalPositions.length, i = void 0, distance = void 0, ordinalIndex = void 0;
-                // first look for an exact match in the ordinalpositions array
-                i = ordinalLength;
-                while (i--) {
-                    if (ordinalPositions[i] === val) {
-                        ordinalIndex = i;
-                        break;
-                    }
-                }
-                // if that failed, find the intermediate position between the
-                // two nearest values
-                i = ordinalLength - 1;
-                while (i--) {
-                    if (val > ordinalPositions[i] || i === 0) { // interpolate
-                        // something between 0 and 1
-                        distance = (val - ordinalPositions[i]) /
-                            (ordinalPositions[i + 1] - ordinalPositions[i]);
-                        ordinalIndex = i + distance;
-                        break;
-                    }
-                }
-                ret = toIndex ?
-                    ordinalIndex :
-                    ordinal.slope *
-                        (ordinalIndex || 0) +
-                        ordinal.offset;
-            }
-            return ret;
-        };
-        // Record this to prevent overwriting by broken-axis module (#5979)
-        axisProto.ordinal2lin = axisProto.val2lin;
-        /* eslint-disable no-invalid-this */
-        addEvent(AxisClass, 'afterInit', function () {
-            var axis = this;
-            if (!axis.ordinal) {
-                axis.ordinal = new OrdinalAxis.Composition(axis);
-            }
-        });
-        addEvent(AxisClass, 'foundExtremes', function () {
-            var axis = this;
-            if (axis.isXAxis &&
-                defined(axis.options.overscroll) &&
-                axis.max === axis.dataMax &&
-                (
-                // Panning is an execption. We don't want to apply
-                // overscroll when panning over the dataMax
-                !axis.chart.mouseIsDown ||
-                    axis.isInternal) && (
-            // Scrollbar buttons are the other execption:
-            !axis.eventArgs ||
-                axis.eventArgs && axis.eventArgs.trigger !== 'navigator')) {
-                axis.max += axis.options.overscroll;
-                // Live data and buttons require translation for the min:
-                if (!axis.isInternal && defined(axis.userMin)) {
-                    axis.min += axis.options.overscroll;
-                }
-            }
-        });
-        // For ordinal axis, that loads data async, redraw axis after data is
-        // loaded. If we don't do that, axis will have the same extremes as
-        // previously, but ordinal positions won't be calculated. See #10290
-        addEvent(AxisClass, 'afterSetScale', function () {
-            var axis = this;
-            if (axis.horiz && !axis.isDirty) {
-                axis.isDirty = axis.isOrdinal &&
-                    axis.chart.navigator &&
-                    !axis.chart.navigator.adaptToUpdatedData;
-            }
-        });
-        addEvent(AxisClass, 'initialAxisTranslation', function () {
-            var axis = this;
-            if (axis.ordinal) {
-                axis.ordinal.beforeSetTickPositions();
-                axis.tickInterval = axis.ordinal.postProcessTickInterval(axis.tickInterval);
-            }
-        });
-        // Extending the Chart.pan method for ordinal axes
-        addEvent(ChartClass, 'pan', function (e) {
-            var chart = this, xAxis = chart.xAxis[0], overscroll = xAxis.options.overscroll, chartX = e.originalEvent.chartX, panning = chart.options.chart.panning, runBase = false;
-            if (panning &&
-                panning.type !== 'y' &&
-                xAxis.options.ordinal &&
-                xAxis.series.length) {
-                var mouseDownX = chart.mouseDownX, extremes = xAxis.getExtremes(), dataMax = extremes.dataMax, min = extremes.min, max = extremes.max, trimmedRange = void 0, hoverPoints = chart.hoverPoints, closestPointRange = (xAxis.closestPointRange ||
-                    (xAxis.ordinal && xAxis.ordinal.overscrollPointsRange)), pointPixelWidth = (xAxis.translationSlope *
-                    (xAxis.ordinal.slope || closestPointRange)), 
-                // how many ordinal units did we move?
-                movedUnits = (mouseDownX - chartX) / pointPixelWidth, 
-                // get index of all the chart's points
-                extendedAxis = { ordinal: { positions: xAxis.ordinal.getExtendedPositions() } }, ordinalPositions = void 0, searchAxisLeft = void 0, lin2val = xAxis.lin2val, val2lin = xAxis.val2lin, searchAxisRight = void 0;
-                // we have an ordinal axis, but the data is equally spaced
-                if (!extendedAxis.ordinal.positions) {
-                    runBase = true;
-                }
-                else if (Math.abs(movedUnits) > 1) {
-                    // Remove active points for shared tooltip
-                    if (hoverPoints) {
-                        hoverPoints.forEach(function (point) {
-                            point.setState();
-                        });
-                    }
-                    if (movedUnits < 0) {
-                        searchAxisLeft = extendedAxis;
-                        searchAxisRight = xAxis.ordinal.positions ? xAxis : extendedAxis;
-                    }
-                    else {
-                        searchAxisLeft = xAxis.ordinal.positions ? xAxis : extendedAxis;
-                        searchAxisRight = extendedAxis;
-                    }
-                    // In grouped data series, the last ordinal position
-                    // represents the grouped data, which is to the left of the
-                    // real data max. If we don't compensate for this, we will
-                    // be allowed to pan grouped data series passed the right of
-                    // the plot area.
-                    ordinalPositions = searchAxisRight.ordinal.positions;
-                    if (dataMax >
-                        ordinalPositions[ordinalPositions.length - 1]) {
-                        ordinalPositions.push(dataMax);
-                    }
-                    // Get the new min and max values by getting the ordinal
-                    // index for the current extreme, then add the moved units
-                    // and translate back to values. This happens on the
-                    // extended ordinal positions if the new position is out of
-                    // range, else it happens on the current x axis which is
-                    // smaller and faster.
-                    chart.fixedRange = max - min;
-                    trimmedRange = xAxis.navigatorAxis.toFixedRange(null, null, lin2val.apply(searchAxisLeft, [
-                        val2lin.apply(searchAxisLeft, [min, true]) + movedUnits,
-                        true // translate from index
-                    ]), lin2val.apply(searchAxisRight, [
-                        val2lin.apply(searchAxisRight, [max, true]) + movedUnits,
-                        true // translate from index
-                    ]));
-                    // Apply it if it is within the available data range
-                    if (trimmedRange.min >= Math.min(extremes.dataMin, min) &&
-                        trimmedRange.max <= Math.max(dataMax, max) + overscroll) {
-                        xAxis.setExtremes(trimmedRange.min, trimmedRange.max, true, false, { trigger: 'pan' });
-                    }
-                    chart.mouseDownX = chartX; // set new reference for next run
-                    css(chart.container, { cursor: 'move' });
-                }
-            }
-            else {
-                runBase = true;
-            }
-            // revert to the linear chart.pan version
-            if (runBase || (panning && /y/.test(panning.type))) {
-                if (overscroll) {
-                    xAxis.max = xAxis.dataMax + overscroll;
-                }
-            }
-            else {
-                e.preventDefault();
-            }
-        });
-        addEvent(SeriesClass, 'updatedData', function () {
-            var xAxis = this.xAxis;
-            // Destroy the extended ordinal index on updated data
-            if (xAxis && xAxis.options.ordinal) {
-                delete xAxis.ordinal.index;
-            }
-        });
-        /* eslint-enable no-invalid-this */
-    }
-    OrdinalAxis.compose = compose;
+    OrdinalAxis.Additions = Additions;
 })(OrdinalAxis || (OrdinalAxis = {}));
-OrdinalAxis.compose(Axis, Chart, Series); // @todo move to StockChart, remove from master
+/* *
+ *
+ *  Default Export
+ *
+ * */
 export default OrdinalAxis;