highcharts 8.1.0 → 8.2.2

package/modules/stock.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highstock JS v8.1.0 (2020-05-05)
+ * @license Highstock JS v8.2.2 (2020-10-22)
  *
  * Highstock as a plugin for Highcharts
  *
@@ -28,7 +28,7 @@
             obj[path] = fn.apply(null, args);
         }
     }
-    _registerModule(_modules, 'parts/NavigatorAxis.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Core/Axis/NavigatorAxis.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (H, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -204,7 +204,7 @@
 
         return NavigatorAxis;
     });
-    _registerModule(_modules, 'parts/ScrollbarAxis.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Core/Axis/ScrollbarAxis.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (H, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -389,7 +389,7 @@
 
         return ScrollbarAxis;
     });
-    _registerModule(_modules, 'parts/Scrollbar.js', [_modules['parts/Axis.js'], _modules['parts/Globals.js'], _modules['parts/ScrollbarAxis.js'], _modules['parts/Utilities.js']], function (Axis, H, ScrollbarAxis, U) {
+    _registerModule(_modules, 'Core/Scrollbar.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Globals.js'], _modules['Core/Axis/ScrollbarAxis.js'], _modules['Core/Utilities.js'], _modules['Core/Options.js']], function (Axis, H, ScrollbarAxis, U, O) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -407,8 +407,8 @@
             merge = U.merge,
             pick = U.pick,
             removeEvent = U.removeEvent;
-        var defaultOptions = H.defaultOptions,
-            hasTouch = H.hasTouch,
+        var defaultOptions = O.defaultOptions;
+        var hasTouch = H.hasTouch,
             isTouchDevice = H.isTouchDevice;
         /**
          * When we have vertical scrollbar, rifles and arrow in buttons should be
@@ -1253,7 +1253,7 @@
 
         return H.Scrollbar;
     });
-    _registerModule(_modules, 'parts/Navigator.js', [_modules['parts/Axis.js'], _modules['parts/Color.js'], _modules['parts/Globals.js'], _modules['parts/NavigatorAxis.js'], _modules['parts/Scrollbar.js'], _modules['parts/Utilities.js']], function (Axis, Color, H, NavigatorAxis, Scrollbar, U) {
+    _registerModule(_modules, 'Core/Navigator.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Series/Series.js'], _modules['Core/Chart/Chart.js'], _modules['Core/Color/Color.js'], _modules['Core/Globals.js'], _modules['Series/LineSeries.js'], _modules['Core/Axis/NavigatorAxis.js'], _modules['Core/Options.js'], _modules['Core/Scrollbar.js'], _modules['Core/Utilities.js']], function (Axis, BaseSeries, Chart, Color, H, LineSeries, NavigatorAxis, O, Scrollbar, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -1263,7 +1263,11 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
+        var seriesTypes = BaseSeries.seriesTypes;
         var color = Color.parse;
+        var hasTouch = H.hasTouch,
+            isTouchDevice = H.isTouchDevice;
+        var defaultOptions = O.defaultOptions;
         var addEvent = U.addEvent,
             clamp = U.clamp,
             correctFloat = U.correctFloat,
@@ -1278,13 +1282,7 @@
             pick = U.pick,
             removeEvent = U.removeEvent,
             splat = U.splat;
-        var Chart = H.Chart,
-            defaultOptions = H.defaultOptions,
-            hasTouch = H.hasTouch,
-            isTouchDevice = H.isTouchDevice,
-            Series = H.Series,
-            seriesTypes = H.seriesTypes,
-            defaultSeriesType, 
+        var defaultSeriesType, 
             // Finding the min or max of a set of variables where we don't know if they
             // are defined, is a pattern that is repeated several places in Highcharts.
             // Consider making this a global utility method.
@@ -1546,8 +1544,7 @@
                  */
                 series: {
                     /**
-                     * The type of the navigator series. Defaults to `areaspline` if
-                     * defined, otherwise `line`.
+                     * The type of the navigator series.
                      *
                      * Heads up:
                      * In column-type navigator, zooming is limited to at least one
@@ -1557,7 +1554,8 @@
                      *         Column type navigator
                      *
                      * @type    {string}
-                     * @default areaspline
+                     * @default {highstock} `areaspline` if defined, otherwise `line`
+                     * @default {gantt} gantt
                      */
                     type: defaultSeriesType,
                     /**
@@ -1761,9 +1759,9 @@
          *         Path to be used in a handle
          */
         H.Renderer.prototype.symbols['navigator-handle'] = function (x, y, w, h, options) {
-            var halfWidth = options.width / 2,
+            var halfWidth = (options && options.width || 0) / 2,
                 markerPosition = Math.round(halfWidth / 3) + 0.5,
-                height = options.height || 0;
+                height = options && options.height || 0;
             return [
                 ['M', -halfWidth - 1, 0.5],
                 ['L', halfWidth, 0.5],
@@ -2476,8 +2474,8 @@
                     inverted = chart.inverted,
                     verb = navigator.rendered && !navigator.hasDragged ?
                         'animate' : 'attr',
-                    zoomedMax = Math.round(navigator.zoomedMax),
-                    zoomedMin = Math.round(navigator.zoomedMin),
+                    zoomedMax,
+                    zoomedMin,
                     unionExtremes,
                     fixedMin,
                     fixedMax,
@@ -2528,7 +2526,11 @@
                                 navigator.hasDragged = navigator.dragOffset = null;
                 }
                 // Update position of navigator shades, outline and handles (#12573)
-                if (navigator.navigatorEnabled) {
+                if (navigator.navigatorEnabled &&
+                    isNumber(navigator.zoomedMin) &&
+                    isNumber(navigator.zoomedMax)) {
+                    zoomedMin = Math.round(navigator.zoomedMin);
+                    zoomedMax = Math.round(navigator.zoomedMax);
                     if (navigator.shades) {
                         navigator.drawMasks(zoomedMin, zoomedMax, inverted, verb);
                     }
@@ -2650,6 +2652,7 @@
                         offset: 0,
                         index: yAxisIndex,
                         isInternal: true,
+                        reversed: pick((navigatorOptions.yAxis && navigatorOptions.yAxis.reversed), (chart.yAxis[0] && chart.yAxis[0].reversed), false),
                         zoomEnabled: false
                     }, chart.inverted ? {
                         width: height
@@ -3249,6 +3252,7 @@
                                     0) -
                                 ((legendOptions &&
                                     legendOptions.verticalAlign === 'bottom' &&
+                                    legendOptions.layout !== 'proximate' && // #13392
                                     legendOptions.enabled &&
                                     !legendOptions.floating) ?
                                     legend.legendHeight +
@@ -3299,7 +3303,7 @@
                 }
             });
             // Handle updating series
-            addEvent(Series, 'afterUpdate', function () {
+            addEvent(LineSeries, 'afterUpdate', function () {
                 if (this.chart.navigator && !this.options.isInternal) {
                     this.chart.navigator.setBaseSeries(null, false);
                 }
@@ -3318,7 +3322,7 @@
 
         return H.Navigator;
     });
-    _registerModule(_modules, 'parts/OrdinalAxis.js', [_modules['parts/Axis.js'], _modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (Axis, H, U) {
+    _registerModule(_modules, 'Core/Axis/OrdinalAxis.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Globals.js'], _modules['Core/Series/CartesianSeries.js'], _modules['Core/Utilities.js'], _modules['Core/Chart/Chart.js']], function (Axis, H, CartesianSeries, U, Chart) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -3334,259 +3338,45 @@
             pick = U.pick,
             timeUnits = U.timeUnits;
         // Has a dependency on Navigator due to the use of Axis.toFixedRange
-        var Chart = H.Chart,
-            Series = H.Series;
-        /* eslint-disable valid-jsdoc */
-        var OrdinalAxisAdditions = /** @class */ (function () {
-                /* *
-                 *
-                 *  Constructors
-                 *
-                 * */
-                /**
-                 * @private
-                 */
-                function OrdinalAxisAdditions(axis) {
-                    this.index = {};
-                this.axis = axis;
-            }
+        /**
+         * Extends the axis with ordinal support.
+         * @private
+         */
+        var OrdinalAxis;
+        (function (OrdinalAxis) {
             /* *
              *
-             *  Functions
+             *  Classes
              *
              * */
             /**
-             * 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
-             * groups are available outside the visible range. When a panning
-             * 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
              */
-            OrdinalAxisAdditions.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 ?
-                        grouping.count + grouping.unitName :
-                        'raw',
-                    overscroll = axis.options.overscroll,
-                    extremes = axis.getExtremes(),
-                    fakeAxis,
-                    fakeSeries;
-                // If this is the first time, or the ordinal index is deleted by
-                // updatedData,
-                // create it.
-                if (!ordinalIndex) {
-                    ordinalIndex = ordinal.index = {};
-                }
-                if (!ordinalIndex[key]) {
-                    // Create a fake axis object where the extended ordinal
-                    // positions are emulated
-                    fakeAxis = {
-                        series: [],
-                        chart: chart,
-                        getExtremes: function () {
-                            return {
-                                min: extremes.dataMin,
-                                max: extremes.dataMax + overscroll
-                            };
-                        },
-                        options: {
-                            ordinal: true
-                        },
-                        ordinal: {},
-                        ordinal2lin: axisProto.ordinal2lin,
-                        val2lin: axisProto.val2lin // #2590
-                    };
-                    fakeAxis.ordinal.axis = fakeAxis;
-                    // Add the fake series to hold the full data, then apply
-                    // processData to it
-                    axis.series.forEach(function (series) {
-                        fakeSeries = {
-                            xAxis: fakeAxis,
-                            xData: series.xData.slice(),
-                            chart: chart,
-                            destroyGroupedData: H.noop,
-                            getProcessedData: H.Series.prototype.getProcessedData
-                        };
-                        fakeSeries.xData = fakeSeries.xData.concat(ordinal.getOverscrollPositions());
-                        fakeSeries.options = {
-                            dataGrouping: grouping ? {
-                                enabled: true,
-                                forced: true,
-                                // doesn't matter which, use the fastest
-                                approximation: 'open',
-                                units: [[
-                                        grouping.unitName,
-                                        [grouping.count]
-                                    ]]
-                            } : {
-                                enabled: false
-                            }
-                        };
-                        series.processData.apply(fakeSeries);
-                        fakeAxis.series.push(fakeSeries);
-                    });
-                    // Run beforeSetTickPositions to compute the ordinalPositions
-                    axis.beforeSetTickPositions.apply(fakeAxis);
-                    // Cache it
-                    ordinalIndex[key] = fakeAxis.ordinal.positions;
-                }
-                return ordinalIndex[key];
-            };
-            /**
-             * Find the factor to estimate how wide the plot area would have been if
-             * ordinal gaps were included. This value is used to compute an imagined
-             * plot width in order to establish the data grouping interval.
-             *
-             * A real world case is the intraday-candlestick example. Without this
-             * logic, it would show the correct data grouping when viewing a range
-             * within each day, but once moving the range to include the gap between
-             * two days, the interval would include the cut-away night hours and the
-             * data grouping would be wrong. So the below method tries to compensate
-             * by identifying the most common point interval, in this case days.
-             *
-             * An opposite case is presented in issue #718. We have a long array of
-             * daily data, then one point is appended one hour after the last point.
-             * We expect the data grouping not to change.
-             *
-             * In the future, if we find cases where this estimation doesn't work
-             * optimally, we might need to add a second pass to the data grouping
-             * 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
-             */
-            OrdinalAxisAdditions.prototype.getGroupIntervalFactor = function (xMin, xMax, series) {
-                var ordinal = this,
-                    axis = ordinal.axis,
-                    i,
-                    processedXData = series.processedXData,
-                    len = processedXData.length,
-                    distances = [],
-                    median,
-                    groupIntervalFactor = ordinal.groupIntervalFactor;
-                // Only do this computation for the first series, let the other
-                // inherit it (#2416)
-                if (!groupIntervalFactor) {
-                    // Register all the distances in an array
-                    for (i = 0; i < len - 1; i++) {
-                        distances[i] =
-                            processedXData[i + 1] - processedXData[i];
-                    }
-                    // Sort them and find the median
-                    distances.sort(function (a, b) {
-                        return a - b;
-                    });
-                    median = distances[Math.floor(len / 2)];
-                    // Compensate for series that don't extend through the entire
-                    // axis extent. #1675.
-                    xMin = Math.max(xMin, processedXData[0]);
-                    xMax = Math.min(xMax, processedXData[len - 1]);
-                    ordinal.groupIntervalFactor = groupIntervalFactor =
-                        (len * median) / (xMax - xMin);
-                }
-                // Return the factor needed for data grouping
-                return groupIntervalFactor;
-            };
-            /**
-             * 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
-             * points, because we may not have any, so we use approximated
-             * pointRange and generate these ticks between Axis.dataMax,
-             * Axis.dataMax + Axis.overscroll evenly spaced. Used in panning and
-             * navigator scrolling.
-             *
-             * @private
-             */
-            OrdinalAxisAdditions.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);
-                    }
-                }
-                return positions;
-            };
-            /**
-             * Make the tick intervals closer because the ordinal gaps make the
-             * ticks spread out or cluster.
-             *
-             * @private
-             */
-            OrdinalAxisAdditions.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;
-                if (ordinalSlope) {
-                    if (!axis.options.breaks) {
-                        ret = tickInterval / (ordinalSlope / axis.closestPointRange);
-                    }
-                    else {
-                        ret = axis.closestPointRange || tickInterval; // #7275
-                    }
-                }
-                else {
-                    ret = tickInterval;
-                }
-                return ret;
-            };
-            return OrdinalAxisAdditions;
-        }());
-        /**
-         * Extends the axis with ordinal support.
-         *
-         * @private
-         */
-        var OrdinalAxis = /** @class */ (function () {
-                function OrdinalAxis() {
+            var Composition = /** @class */ (function () {
+                    /* *
+                     *
+                     *  Constructors
+                     *
+                     * */
+                    /**
+                     * @private
+                     */
+                    function Composition(axis) {
+                        this.index = {};
+                    this.axis = axis;
                 }
-                /**
-                 * 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.
-                 */
-                OrdinalAxis.compose = function (AxisClass, ChartClass, SeriesClass) {
-                    AxisClass.keepProps.push('ordinal');
-                var axisProto = AxisClass.prototype;
+                /* *
+                *
+                *  Functions
+                *
+                * */
                 /**
                  * Calculate the ordinal positions before tick positions are calculated.
                  *
                  * @private
                  */
-                axisProto.beforeSetTickPositions = function () {
-                    var axis = this,
+                Composition.prototype.beforeSetTickPositions = function () {
+                    var axis = this.axis,
                         ordinal = axis.ordinal,
                         len,
                         ordinalPositions = [],
@@ -3720,6 +3510,229 @@
                     axis.isOrdinal = isOrdinal && useOrdinal; // #3818, #4196, #4926
                     ordinal.groupIntervalFactor = null; // reset for next run
                 };
+                /**
+                 * 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
+                 * groups are available outside the visible range. When a panning
+                 * 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 ?
+                            grouping.count + grouping.unitName :
+                            'raw',
+                        overscroll = axis.options.overscroll,
+                        extremes = axis.getExtremes(),
+                        fakeAxis,
+                        fakeSeries;
+                    // If this is the first time, or the ordinal index is deleted by
+                    // updatedData,
+                    // create it.
+                    if (!ordinalIndex) {
+                        ordinalIndex = ordinal.index = {};
+                    }
+                    if (!ordinalIndex[key]) {
+                        // Create a fake axis object where the extended ordinal
+                        // positions are emulated
+                        fakeAxis = {
+                            series: [],
+                            chart: chart,
+                            getExtremes: function () {
+                                return {
+                                    min: extremes.dataMin,
+                                    max: extremes.dataMax + overscroll
+                                };
+                            },
+                            options: {
+                                ordinal: true
+                            },
+                            ordinal: {},
+                            ordinal2lin: axisProto.ordinal2lin,
+                            val2lin: axisProto.val2lin // #2590
+                        };
+                        fakeAxis.ordinal.axis = fakeAxis;
+                        // Add the fake series to hold the full data, then apply
+                        // processData to it
+                        axis.series.forEach(function (series) {
+                            fakeSeries = {
+                                xAxis: fakeAxis,
+                                xData: series.xData.slice(),
+                                chart: chart,
+                                destroyGroupedData: H.noop,
+                                getProcessedData: CartesianSeries.prototype.getProcessedData
+                            };
+                            fakeSeries.xData = fakeSeries.xData.concat(ordinal.getOverscrollPositions());
+                            fakeSeries.options = {
+                                dataGrouping: grouping ? {
+                                    enabled: true,
+                                    forced: true,
+                                    // doesn't matter which, use the fastest
+                                    approximation: 'open',
+                                    units: [[
+                                            grouping.unitName,
+                                            [grouping.count]
+                                        ]]
+                                } : {
+                                    enabled: false
+                                }
+                            };
+                            series.processData.apply(fakeSeries);
+                            fakeAxis.series.push(fakeSeries);
+                        });
+                        // Run beforeSetTickPositions to compute the ordinalPositions
+                        axis.ordinal.beforeSetTickPositions.apply({ axis: fakeAxis });
+                        // Cache it
+                        ordinalIndex[key] = fakeAxis.ordinal.positions;
+                    }
+                    return ordinalIndex[key];
+                };
+                /**
+                 * Find the factor to estimate how wide the plot area would have been if
+                 * ordinal gaps were included. This value is used to compute an imagined
+                 * plot width in order to establish the data grouping interval.
+                 *
+                 * A real world case is the intraday-candlestick example. Without this
+                 * logic, it would show the correct data grouping when viewing a range
+                 * within each day, but once moving the range to include the gap between
+                 * two days, the interval would include the cut-away night hours and the
+                 * data grouping would be wrong. So the below method tries to compensate
+                 * by identifying the most common point interval, in this case days.
+                 *
+                 * An opposite case is presented in issue #718. We have a long array of
+                 * daily data, then one point is appended one hour after the last point.
+                 * We expect the data grouping not to change.
+                 *
+                 * In the future, if we find cases where this estimation doesn't work
+                 * optimally, we might need to add a second pass to the data grouping
+                 * 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;
+                    // Only do this computation for the first series, let the other
+                    // inherit it (#2416)
+                    if (!groupIntervalFactor) {
+                        // Register all the distances in an array
+                        for (i = 0; i < len - 1; i++) {
+                            distances[i] =
+                                processedXData[i + 1] - processedXData[i];
+                        }
+                        // Sort them and find the median
+                        distances.sort(function (a, b) {
+                            return a - b;
+                        });
+                        median = distances[Math.floor(len / 2)];
+                        // Compensate for series that don't extend through the entire
+                        // axis extent. #1675.
+                        xMin = Math.max(xMin, processedXData[0]);
+                        xMax = Math.min(xMax, processedXData[len - 1]);
+                        ordinal.groupIntervalFactor = groupIntervalFactor =
+                            (len * median) / (xMax - xMin);
+                    }
+                    // Return the factor needed for data grouping
+                    return groupIntervalFactor;
+                };
+                /**
+                 * 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
+                 * points, because we may not have any, so we use approximated
+                 * 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 () {
+                    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);
+                        }
+                    }
+                    return positions;
+                };
+                /**
+                 * Make the tick intervals closer because the ordinal gaps make the
+                 * ticks spread out or cluster.
+                 *
+                 * @private
+                 */
+                Composition.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;
+                    if (ordinalSlope) {
+                        if (!axis.options.breaks) {
+                            ret = tickInterval / (ordinalSlope / axis.closestPointRange);
+                        }
+                        else {
+                            ret = axis.closestPointRange || tickInterval; // #7275
+                        }
+                    }
+                    else {
+                        ret = tickInterval;
+                    }
+                    return ret;
+                };
+                return Composition;
+            }());
+            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
@@ -4025,7 +4038,7 @@
                 addEvent(AxisClass, 'afterInit', function () {
                     var axis = this;
                     if (!axis.ordinal) {
-                        axis.ordinal = new OrdinalAxisAdditions(axis);
+                        axis.ordinal = new OrdinalAxis.Composition(axis);
                     }
                 });
                 addEvent(AxisClass, 'foundExtremes', function () {
@@ -4059,6 +4072,13 @@
                             !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,
@@ -4165,14 +4185,14 @@
                     }
                 });
                 /* eslint-enable no-invalid-this */
-            };
-            return OrdinalAxis;
-        }());
-        OrdinalAxis.compose(Axis, Chart, Series); // @todo move to StockChart, remove from master
+            }
+            OrdinalAxis.compose = compose;
+        })(OrdinalAxis || (OrdinalAxis = {}));
+        OrdinalAxis.compose(Axis, Chart, CartesianSeries); // @todo move to StockChart, remove from master
 
         return OrdinalAxis;
     });
-    _registerModule(_modules, 'modules/broken-axis.src.js', [_modules['parts/Axis.js'], _modules['parts/Globals.js'], _modules['parts/Utilities.js'], _modules['parts/Stacking.js']], function (Axis, H, U, StackItem) {
+    _registerModule(_modules, 'Core/Axis/BrokenAxis.js', [_modules['Core/Axis/Axis.js'], _modules['Series/LineSeries.js'], _modules['Extensions/Stacking.js'], _modules['Core/Utilities.js']], function (Axis, LineSeries, StackItem, U) {
         /* *
          *
          *  (c) 2009-2020 Torstein Honsi
@@ -4188,7 +4208,6 @@
             isArray = U.isArray,
             isNumber = U.isNumber,
             pick = U.pick;
-        var Series = H.Series;
         /* eslint-disable valid-jsdoc */
         /**
          * Provides support for broken axes.
@@ -4515,7 +4534,7 @@
                  */
                 BrokenAxis.compose = function (AxisClass, SeriesClass) {
                     AxisClass.keepProps.push('brokenAxis');
-                var seriesProto = Series.prototype;
+                var seriesProto = LineSeries.prototype;
                 /**
                  * @private
                  */
@@ -4748,7 +4767,7 @@
             };
             return BrokenAxis;
         }());
-        BrokenAxis.compose(Axis, Series); // @todo remove automatism
+        BrokenAxis.compose(Axis, LineSeries); // @todo remove automatism
 
         return BrokenAxis;
     });
@@ -4756,7 +4775,7 @@
 
 
     });
-    _registerModule(_modules, 'parts/DataGrouping.js', [_modules['parts/DateTimeAxis.js'], _modules['parts/Globals.js'], _modules['parts/Point.js'], _modules['parts/Tooltip.js'], _modules['parts/Utilities.js']], function (DateTimeAxis, H, Point, Tooltip, U) {
+    _registerModule(_modules, 'Extensions/DataGrouping.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Axis/DateTimeAxis.js'], _modules['Core/Globals.js'], _modules['Core/Options.js'], _modules['Core/Series/Point.js'], _modules['Core/Tooltip.js'], _modules['Core/Utilities.js']], function (Axis, DateTimeAxis, H, O, Point, Tooltip, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -4782,6 +4801,7 @@
         * @type {number}
         */
         ''; // detach doclets above
+        var defaultOptions = O.defaultOptions;
         var addEvent = U.addEvent,
             arrayMax = U.arrayMax,
             arrayMin = U.arrayMin,
@@ -4793,9 +4813,7 @@
             isNumber = U.isNumber,
             merge = U.merge,
             pick = U.pick;
-        var Axis = H.Axis,
-            defaultPlotOptions = H.defaultPlotOptions,
-            Series = H.Series;
+        var Series = H.Series;
         /* ************************************************************************** *
          *  Start data grouping module                                                *
          * ************************************************************************** */
@@ -5430,7 +5448,7 @@
             var options = e.options,
                 type = this.type,
                 plotOptions = this.chart.options.plotOptions,
-                defaultOptions = defaultPlotOptions[type].dataGrouping, 
+                defaultOptions = O.defaultOptions.plotOptions[type].dataGrouping, 
                 // External series, for example technical indicators should also
                 // inherit commonOptions which are not available outside this module
                 baseOptions = this.useCommonDataGrouping && commonOptions;
@@ -5745,7 +5763,7 @@
 
         return dataGrouping;
     });
-    _registerModule(_modules, 'parts/OHLCSeries.js', [_modules['parts/Globals.js'], _modules['parts/Point.js'], _modules['parts/Utilities.js']], function (H, Point, U) {
+    _registerModule(_modules, 'Series/OHLCSeries.js', [_modules['Core/Series/Series.js'], _modules['Core/Series/Point.js']], function (BaseSeries, Point) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -5755,8 +5773,7 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        var seriesType = U.seriesType;
-        var seriesTypes = H.seriesTypes;
+        var seriesTypes = BaseSeries.seriesTypes;
         /**
          * The ohlc series type.
          *
@@ -5766,7 +5783,7 @@
          *
          * @augments Highcharts.Series
          */
-        seriesType('ohlc', 'column'
+        BaseSeries.seriesType('ohlc', 'column'
         /**
          * An OHLC chart is a style of financial chart used to describe price
          * movements over time. It displays open, high, low and close values per
@@ -6117,7 +6134,7 @@
         ''; // adds doclets above to transpilat
 
     });
-    _registerModule(_modules, 'parts/CandlestickSeries.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Series/CandlestickSeries.js', [_modules['Core/Series/Series.js'], _modules['Core/Options.js'], _modules['Core/Utilities.js']], function (BaseSeries, O, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -6127,10 +6144,9 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        var merge = U.merge,
-            seriesType = U.seriesType;
-        var defaultPlotOptions = H.defaultPlotOptions,
-            seriesTypes = H.seriesTypes;
+        var defaultOptions = O.defaultOptions;
+        var merge = U.merge;
+        var columnProto = BaseSeries.seriesTypes.column.prototype;
         /**
          * A candlestick chart is a style of financial chart used to describe price
          * movements over time.
@@ -6179,7 +6195,7 @@
                 /**
                  * @extends plotOptions.ohlc.tooltip
                  */
-                tooltip: defaultPlotOptions.ohlc.tooltip,
+                tooltip: defaultOptions.plotOptions.ohlc.tooltip,
                 /**
                  * @type    {number|null}
                  * @product highstock
@@ -6244,7 +6260,7 @@
          *
          * @augments Highcharts.seriesTypes.ohlc
          */
-        seriesType('candlestick', 'ohlc', merge(defaultPlotOptions.column, candlestickOptions), 
+        BaseSeries.seriesType('candlestick', 'ohlc', merge(defaultOptions.plotOptions.column, candlestickOptions), 
         /**
          * @lends seriesTypes.candlestick
          */
@@ -6260,7 +6276,7 @@
              * @return {Highcharts.SVGAttributes}
              */
             pointAttribs: function (point, state) {
-                var attribs = seriesTypes.column.prototype.pointAttribs.call(this,
+                var attribs = columnProto.pointAttribs.call(this,
                     point,
                     state),
                     options = this.options,
@@ -6433,7 +6449,7 @@
         ''; // adds doclets above to transpilat
 
     });
-    _registerModule(_modules, 'mixins/on-series.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Mixins/OnSeries.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (H, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -6591,7 +6607,7 @@
 
         return onSeriesMixin;
     });
-    _registerModule(_modules, 'parts/FlagsSeries.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js'], _modules['mixins/on-series.js']], function (H, U, onSeriesMixin) {
+    _registerModule(_modules, 'Series/FlagsSeries.js', [_modules['Core/Series/Series.js'], _modules['Core/Globals.js'], _modules['Mixins/OnSeries.js'], _modules['Core/Renderer/SVG/SVGElement.js'], _modules['Core/Renderer/SVG/SVGRenderer.js'], _modules['Core/Utilities.js']], function (BaseSeries, H, OnSeriesMixin, SVGElement, SVGRenderer, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -6601,23 +6617,22 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        /**
-         * @typedef {"circlepin"|"flag"|"squarepin"} Highcharts.FlagsShapeValue
-         */
+        var noop = H.noop;
         var addEvent = U.addEvent,
             defined = U.defined,
             isNumber = U.isNumber,
             merge = U.merge,
             objectEach = U.objectEach,
-            seriesType = U.seriesType,
             wrap = U.wrap;
-        var noop = H.noop,
-            Renderer = H.Renderer,
+        var Renderer = H.Renderer,
             Series = H.Series,
-            SVGRenderer = H.SVGRenderer,
-            TrackerMixin = H.TrackerMixin,
+            TrackerMixin = H.TrackerMixin, // Interaction
             VMLRenderer = H.VMLRenderer,
             symbols = SVGRenderer.prototype.symbols;
+        /**
+         * @typedef {"circlepin"|"flag"|"squarepin"} Highcharts.FlagsShapeValue
+         */
+        ''; // detach doclets above
         /**
          * The Flags series.
          *
@@ -6627,7 +6642,7 @@
          *
          * @augments Highcharts.Series
          */
-        seriesType('flags', 'column'
+        BaseSeries.seriesType('flags', 'column'
         /**
          * Flags are used to mark events in stock charts. They can be added on the
          * timeline, or attached to a specific series.
@@ -6884,8 +6899,8 @@
                     'stroke-width': lineWidth || options.lineWidth || 0
                 };
             },
-            translate: onSeriesMixin.translate,
-            getPlotBox: onSeriesMixin.getPlotBox,
+            translate: OnSeriesMixin.translate,
+            getPlotBox: OnSeriesMixin.getPlotBox,
             /**
              * Draw the markers.
              *
@@ -7036,7 +7051,7 @@
                 // Can be a mix of SVG and HTML and we need events for both (#6303)
                 if (options.useHTML) {
                     wrap(series.markerGroup, 'on', function (proceed) {
-                        return H.SVGElement.prototype.on.apply(
+                        return SVGElement.prototype.on.apply(
                         // for HTML
                         proceed.apply(this, [].slice.call(arguments, 1)), 
                         // and for SVG
@@ -7275,7 +7290,7 @@
         ''; // adds doclets above to transpiled file
 
     });
-    _registerModule(_modules, 'parts/RangeSelector.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Extensions/RangeSelector.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Chart/Chart.js'], _modules['Core/Globals.js'], _modules['Core/Options.js'], _modules['Core/Renderer/SVG/SVGElement.js'], _modules['Core/Utilities.js']], function (Axis, Chart, H, O, SVGElement, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -7285,6 +7300,21 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
+        var defaultOptions = O.defaultOptions;
+        var addEvent = U.addEvent,
+            createElement = U.createElement,
+            css = U.css,
+            defined = U.defined,
+            destroyObjectProperties = U.destroyObjectProperties,
+            discardElement = U.discardElement,
+            extend = U.extend,
+            fireEvent = U.fireEvent,
+            isNumber = U.isNumber,
+            merge = U.merge,
+            objectEach = U.objectEach,
+            pick = U.pick,
+            pInt = U.pInt,
+            splat = U.splat;
         /**
          * Define the time span for the button
          *
@@ -7313,23 +7343,6 @@
          * @return {number}
          *         Parsed JavaScript time value.
          */
-        var addEvent = U.addEvent,
-            createElement = U.createElement,
-            css = U.css,
-            defined = U.defined,
-            destroyObjectProperties = U.destroyObjectProperties,
-            discardElement = U.discardElement,
-            extend = U.extend,
-            fireEvent = U.fireEvent,
-            isNumber = U.isNumber,
-            merge = U.merge,
-            objectEach = U.objectEach,
-            pick = U.pick,
-            pInt = U.pInt,
-            splat = U.splat;
-        var Axis = H.Axis,
-            Chart = H.Chart,
-            defaultOptions = H.defaultOptions;
         /* ************************************************************************** *
          * Start Range Selector code                                                  *
          * ************************************************************************** */
@@ -7636,6 +7649,8 @@
                 /**
                  * A custom callback function to parse values entered in the input boxes
                  * and return a valid JavaScript time as milliseconds since 1970.
+                 * The first argument passed is a value to parse,
+                 * second is a boolean indicating use of the UTC time.
                  *
                  * @sample {highstock} stock/rangeselector/input-format/
                  *         Milliseconds in the range selector
@@ -7810,11 +7825,20 @@
          * @name Highcharts.RangeSelector
          * @param {Highcharts.Chart} chart
          */
-        function RangeSelector(chart) {
-            // Run RangeSelector
-            this.init(chart);
-        }
-        RangeSelector.prototype = {
+        var RangeSelector = /** @class */ (function () {
+                function RangeSelector(chart) {
+                    /* *
+                     *
+                     * Properties
+                     *
+                     * */
+                    this.buttons = void 0;
+                this.buttonOptions = RangeSelector.prototype.defaultButtons;
+                this.options = void 0;
+                this.chart = chart;
+                // Run RangeSelector
+                this.init(chart);
+            }
             /**
              * The method to run when one of the buttons in the range selectors is
              * clicked
@@ -7826,7 +7850,7 @@
              * @param {boolean} [redraw]
              * @return {void}
              */
-            clickButton: function (i, redraw) {
+            RangeSelector.prototype.clickButton = function (i, redraw) {
                 var rangeSelector = this,
                     chart = rangeSelector.chart,
                     rangeOptions = rangeSelector.buttonOptions[i],
@@ -7921,8 +7945,12 @@
                     newMin = dataMin;
                     newMax = dataMax;
                 }
-                newMin += rangeOptions._offsetMin;
-                newMax += rangeOptions._offsetMax;
+                if (defined(newMin)) {
+                    newMin += rangeOptions._offsetMin;
+                }
+                if (defined(newMax)) {
+                    newMax += rangeOptions._offsetMax;
+                }
                 rangeSelector.setSelected(i);
                 // Update the chart
                 if (!baseAxis) {
@@ -7946,7 +7974,7 @@
                         rangeSelectorButton: rangeOptions
                     });
                 }
-            },
+            };
             /**
              * Set the selected option. This method only sets the internal flag, it
              * doesn't update the buttons or the actual zoomed range.
@@ -7956,35 +7984,9 @@
              * @param {number} [selected]
              * @return {void}
              */
-            setSelected: function (selected) {
+            RangeSelector.prototype.setSelected = function (selected) {
                 this.selected = this.options.selected = selected;
-            },
-            /**
-             * The default buttons for pre-selecting time frames
-             */
-            defaultButtons: [{
-                    type: 'month',
-                    count: 1,
-                    text: '1m'
-                }, {
-                    type: 'month',
-                    count: 3,
-                    text: '3m'
-                }, {
-                    type: 'month',
-                    count: 6,
-                    text: '6m'
-                }, {
-                    type: 'ytd',
-                    text: 'YTD'
-                }, {
-                    type: 'year',
-                    count: 1,
-                    text: '1y'
-                }, {
-                    type: 'all',
-                    text: 'All'
-                }],
+            };
             /**
              * Initialize the range selector
              *
@@ -7993,11 +7995,10 @@
              * @param {Highcharts.Chart} chart
              * @return {void}
              */
-            init: function (chart) {
+            RangeSelector.prototype.init = function (chart) {
                 var rangeSelector = this,
                     options = chart.options.rangeSelector,
-                    buttonOptions = options.buttons ||
-                        [].concat(rangeSelector.defaultButtons),
+                    buttonOptions = options.buttons || rangeSelector.defaultButtons.slice(),
                     selectedOption = options.selected,
                     blurInputs = function () {
                         var minInput = rangeSelector.minInput,
@@ -8039,7 +8040,7 @@
                         });
                     }
                 });
-            },
+            };
             /**
              * Dynamically update the range selector buttons after a new range has been
              * set
@@ -8048,7 +8049,7 @@
              * @function Highcharts.RangeSelector#updateButtonStates
              * @return {void}
              */
-            updateButtonStates: function () {
+            RangeSelector.prototype.updateButtonStates = function () {
                 var rangeSelector = this,
                     chart = this.chart,
                     baseAxis = chart.xAxis[0],
@@ -8138,7 +8139,7 @@
                         }
                     }
                 });
-            },
+            };
             /**
              * Compute and cache the range for an individual button
              *
@@ -8147,7 +8148,7 @@
              * @param {Highcharts.RangeSelectorButtonsOptions} rangeOptions
              * @return {void}
              */
-            computeButtonRange: function (rangeOptions) {
+            RangeSelector.prototype.computeButtonRange = function (rangeOptions) {
                 var type = rangeOptions.type,
                     count = rangeOptions.count || 1, 
                     // these time intervals have a fixed number of milliseconds, as
@@ -8174,7 +8175,7 @@
                 rangeOptions._offsetMax = pick(rangeOptions.offsetMax, 0);
                 rangeOptions._range +=
                     rangeOptions._offsetMax - rangeOptions._offsetMin;
-            },
+            };
             /**
              * Set the internal and displayed value of a HTML input for the dates
              *
@@ -8184,7 +8185,7 @@
              * @param {number} [inputTime]
              * @return {void}
              */
-            setInputValue: function (name, inputTime) {
+            RangeSelector.prototype.setInputValue = function (name, inputTime) {
                 var options = this.chart.options.rangeSelector,
                     time = this.chart.time,
                     input = this[name + 'Input'];
@@ -8196,14 +8197,14 @@
                 this[name + 'DateBox'].attr({
                     text: time.dateFormat(options.inputDateFormat || '%b %e, %Y', input.HCTime)
                 });
-            },
+            };
             /**
              * @private
              * @function Highcharts.RangeSelector#showInput
              * @param {string} name
              * @return {void}
              */
-            showInput: function (name) {
+            RangeSelector.prototype.showInput = function (name) {
                 var inputGroup = this.inputGroup,
                     dateBox = this[name + 'DateBox'];
                 css(this[name + 'Input'], {
@@ -8213,21 +8214,35 @@
                     height: (dateBox.height - 2) + 'px',
                     border: '2px solid silver'
                 });
-            },
+            };
             /**
              * @private
              * @function Highcharts.RangeSelector#hideInput
              * @param {string} name
              * @return {void}
              */
-            hideInput: function (name) {
+            RangeSelector.prototype.hideInput = function (name) {
                 css(this[name + 'Input'], {
                     border: 0,
                     width: '1px',
                     height: '1px'
                 });
                 this.setInputValue(name);
-            },
+            };
+            /**
+             * @private
+             * @function Highcharts.RangeSelector#defaultInputDateParser
+             */
+            RangeSelector.prototype.defaultInputDateParser = function (inputDate, useUTC) {
+                var date = new Date();
+                if (H.isSafari) {
+                    return Date.parse(inputDate.split(' ').join('T'));
+                }
+                if (useUTC) {
+                    return Date.parse(inputDate + 'Z');
+                }
+                return Date.parse(inputDate) - date.getTimezoneOffset() * 60 * 1000;
+            };
             /**
              * Draw either the 'from' or the 'to' HTML input box of the range selector
              *
@@ -8236,7 +8251,7 @@
              * @param {string} name
              * @return {void}
              */
-            drawInput: function (name) {
+            RangeSelector.prototype.drawInput = function (name) {
                 var rangeSelector = this,
                     chart = rangeSelector.chart,
                     chartStyle = chart.renderer.style || {},
@@ -8248,19 +8263,21 @@
                     input,
                     label,
                     dateBox,
-                    inputGroup = this.inputGroup;
+                    inputGroup = this.inputGroup,
+                    defaultInputDateParser = this.defaultInputDateParser;
                 /**
                  * @private
                  */
                 function updateExtremes() {
                     var inputValue = input.value,
-                        value = (options.inputDateParser || Date.parse)(inputValue),
+                        value,
                         chartAxis = chart.xAxis[0],
                         dataAxis = chart.scroller && chart.scroller.xAxis ?
                             chart.scroller.xAxis :
                             chartAxis,
                         dataMin = dataAxis.dataMin,
                         dataMax = dataAxis.dataMax;
+                    value = (options.inputDateParser || defaultInputDateParser)(inputValue, chart.time.useUTC);
                     if (value !== input.previousValue) {
                         input.previousValue = value;
                         // If the value isn't parsed directly to a value by the
@@ -8386,7 +8403,7 @@
                         updateExtremes();
                     }
                 };
-            },
+            };
             /**
              * Get the position of the range selector buttons and inputs. This can be
              * overridden from outside for custom positioning.
@@ -8396,7 +8413,7 @@
              *
              * @return {Highcharts.Dictionary<number>}
              */
-            getPosition: function () {
+            RangeSelector.prototype.getPosition = function () {
                 var chart = this.chart,
                     options = chart.options.rangeSelector,
                     top = options.verticalAlign === 'top' ?
@@ -8406,7 +8423,7 @@
                         buttonTop: top + options.buttonPosition.y,
                         inputTop: top + options.inputPosition.y - 10
                     };
-            },
+            };
             /**
              * Get the extremes of YTD. Will choose dataMax if its value is lower than
              * the current timestamp. Will choose dataMin if its value is higher than
@@ -8422,7 +8439,7 @@
              * @return {*}
              *         Returns min and max for the YTD
              */
-            getYTDExtremes: function (dataMax, dataMin, useUTC) {
+            RangeSelector.prototype.getYTDExtremes = function (dataMax, dataMin, useUTC) {
                 var time = this.chart.time,
                     min,
                     now = new time.Date(dataMax),
@@ -8437,7 +8454,7 @@
                     max: Math.min(dataMax || now, now),
                     min: min
                 };
-            },
+            };
             /**
              * Render the range selector including the buttons and the inputs. The first
              * time render is called, the elements are created and positioned. On
@@ -8451,7 +8468,7 @@
              *        X axis maximum
              * @return {void}
              */
-            render: function (min, max) {
+            RangeSelector.prototype.render = function (min, max) {
                 var rangeSelector = this,
                     chart = rangeSelector.chart,
                     renderer = chart.renderer,
@@ -8721,7 +8738,7 @@
                         rangeSelector.group.translateY + 'px';
                 }
                 rangeSelector.rendered = true;
-            },
+            };
             /**
              * Extracts height of range selector
              *
@@ -8730,7 +8747,7 @@
              * @return {number}
              *         Returns rangeSelector height
              */
-            getHeight: function () {
+            RangeSelector.prototype.getHeight = function () {
                 var rangeSelector = this,
                     options = rangeSelector.options,
                     rangeSelectorGroup = rangeSelector.group,
@@ -8755,7 +8772,7 @@
                     rangeSelectorHeight += Math.abs(minPosition);
                 }
                 return rangeSelectorHeight;
-            },
+            };
             /**
              * Detect collision with title or subtitle
              *
@@ -8767,10 +8784,10 @@
              * @return {boolean}
              *         Returns collision status
              */
-            titleCollision: function (chart) {
+            RangeSelector.prototype.titleCollision = function (chart) {
                 return !(chart.options.title.text ||
                     chart.options.subtitle.text);
-            },
+            };
             /**
              * Update the range selector with new options
              *
@@ -8779,20 +8796,20 @@
              * @param {Highcharts.RangeSelectorOptions} options
              * @return {void}
              */
-            update: function (options) {
+            RangeSelector.prototype.update = function (options) {
                 var chart = this.chart;
                 merge(true, chart.options.rangeSelector, options);
                 this.destroy();
                 this.init(chart);
                 chart.rangeSelector.render();
-            },
+            };
             /**
              * Destroys allocated elements.
              *
              * @private
              * @function Highcharts.RangeSelector#destroy
              */
-            destroy: function () {
+            RangeSelector.prototype.destroy = function () {
                 var rSelector = this,
                     minInput = rSelector.minInput,
                     maxInput = rSelector.maxInput;
@@ -8810,21 +8827,48 @@
                 // Destroy HTML and SVG elements
                 objectEach(rSelector, function (val, key) {
                     if (val && key !== 'chart') {
-                        if (val.destroy) {
+                        if (val instanceof SVGElement) {
                             // SVGElement
                             val.destroy();
                         }
-                        else if (val.nodeType) {
+                        else if (val instanceof window.HTMLElement) {
                             // HTML element
-                            discardElement(this[key]);
+                            discardElement(val);
                         }
                     }
                     if (val !== RangeSelector.prototype[key]) {
                         rSelector[key] = null;
                     }
                 }, this);
-            }
-        };
+            };
+            return RangeSelector;
+        }());
+        /**
+         * The default buttons for pre-selecting time frames
+         */
+        RangeSelector.prototype.defaultButtons = [{
+                type: 'month',
+                count: 1,
+                text: '1m'
+            }, {
+                type: 'month',
+                count: 3,
+                text: '3m'
+            }, {
+                type: 'month',
+                count: 6,
+                text: '6m'
+            }, {
+                type: 'ytd',
+                text: 'YTD'
+            }, {
+                type: 'year',
+                count: 1,
+                text: '1y'
+            }, {
+                type: 'all',
+                text: 'All'
+            }];
         /**
          * Get the axis min value based on the range option and the current max. For
          * stock charts this is extended via the {@link RangeSelector} so that if the
@@ -9035,8 +9079,9 @@
             H.RangeSelector = RangeSelector;
         }
 
+        return H.RangeSelector;
     });
-    _registerModule(_modules, 'parts/StockChart.js', [_modules['parts/Axis.js'], _modules['parts/Globals.js'], _modules['parts/Point.js'], _modules['parts/Utilities.js']], function (Axis, H, Point, U) {
+    _registerModule(_modules, 'Core/Chart/StockChart.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Chart/Chart.js'], _modules['Core/Globals.js'], _modules['Series/LineSeries.js'], _modules['Core/Series/Point.js'], _modules['Core/Renderer/SVG/SVGRenderer.js'], _modules['Core/Utilities.js']], function (Axis, Chart, H, LineSeries, Point, SVGRenderer, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -9054,6 +9099,7 @@
             extend = U.extend,
             find = U.find,
             format = U.format,
+            getOptions = U.getOptions,
             isNumber = U.isNumber,
             isString = U.isString,
             merge = U.merge,
@@ -9065,11 +9111,7 @@
         // defaultOptions.scrollbar
         // Has a dependency on RangeSelector due to the use of
         // defaultOptions.rangeSelector
-        var Chart = H.Chart,
-            Renderer = H.Renderer,
-            Series = H.Series,
-            SVGRenderer = H.SVGRenderer,
-            seriesProto = Series.prototype,
+        var seriesProto = LineSeries.prototype,
             seriesInit = seriesProto.init,
             seriesProcessData = seriesProto.processData,
             pointTooltipFormatter = Point.prototype.tooltipFormatter;
@@ -9168,7 +9210,7 @@
                 userOptions = options, 
                 // to increase performance, don't merge the data
                 seriesOptions = options.series,
-                defaultOptions = H.getOptions(),
+                defaultOptions = getOptions(),
                 opposite, 
                 // Always disable startOnTick:true on the main axis when the navigator
                 // is enabled (#1090)
@@ -9268,7 +9310,7 @@
         };
         // Handle som Stock-specific series defaults, override the plotOptions before
         // series options are handled.
-        addEvent(Series, 'setOptions', function (e) {
+        addEvent(LineSeries, 'setOptions', function (e) {
             var overrides;
             if (this.chart.options.isStock) {
                 if (this.is('column') || this.is('columnrange')) {
@@ -9574,13 +9616,15 @@
             });
             crossBox = crossLabel.getBBox();
             // now it is placed we can correct its position
-            if (horiz) {
-                if ((tickInside && !opposite) || (!tickInside && opposite)) {
-                    posy = crossLabel.y - crossBox.height;
+            if (isNumber(crossLabel.y)) {
+                if (horiz) {
+                    if ((tickInside && !opposite) || (!tickInside && opposite)) {
+                        posy = crossLabel.y - crossBox.height;
+                    }
+                }
+                else {
+                    posy = crossLabel.y - (crossBox.height / 2);
                 }
-            }
-            else {
-                posy = crossLabel.y - (crossBox.height / 2);
             }
             // check the edges
             if (horiz) {
@@ -9724,7 +9768,7 @@
             return;
         };
         // Modify series extremes
-        addEvent(Series, 'afterGetExtremes', function (e) {
+        addEvent(LineSeries, 'afterGetExtremes', function (e) {
             var dataExtremes = e.dataExtremes;
             if (this.modifyValue && dataExtremes) {
                 var extremes = [
@@ -9785,7 +9829,7 @@
         // Extend the Series prototype to create a separate series clip box. This is
         // related to using multiple panes, and a future pane logic should incorporate
         // this feature (#2754).
-        addEvent(Series, 'render', function () {
+        addEvent(LineSeries, 'render', function () {
             var chart = this.chart,
                 clipHeight;
             // Only do this on not 3d (#2939, #5904) nor polar (#6057) charts, and only
@@ -9807,7 +9851,7 @@
                     }
                 }
                 // First render, initial clip box
-                if (!this.clipBox && this.animate) {
+                if (!this.clipBox && !chart.hasRendered) {
                     this.clipBox = merge(chart.clipBox);
                     this.clipBox.width = this.xAxis.len;
                     this.clipBox.height = clipHeight;