highcharts 10.2.1 → 10.3.1

package/modules/datagrouping.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highstock JS v10.2.1 (2022-08-29)
+ * @license Highstock JS v10.3.1 (2022-10-31)
  *
  * Data grouping module
  *
@@ -37,7 +37,7 @@
             }
         }
     }
-    _registerModule(_modules, 'Extensions/DataGrouping.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Axis/DateTimeAxis.js'], _modules['Core/FormatUtilities.js'], _modules['Core/Globals.js'], _modules['Core/Series/Point.js'], _modules['Core/Series/Series.js'], _modules['Core/Tooltip.js'], _modules['Core/DefaultOptions.js'], _modules['Core/Utilities.js']], function (Axis, DateTimeAxis, F, H, Point, Series, Tooltip, D, U) {
+    _registerModule(_modules, 'Extensions/DataGrouping/ApproximationRegistry.js', [], function () {
         /* *
          *
          *  (c) 2010-2021 Torstein Honsi
@@ -47,22 +47,11 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        var format = F.format;
-        var seriesProto = Series.prototype;
-        var addEvent = U.addEvent,
-            arrayMax = U.arrayMax,
-            arrayMin = U.arrayMin,
-            correctFloat = U.correctFloat,
-            defined = U.defined,
-            error = U.error,
-            extend = U.extend,
-            isNumber = U.isNumber,
-            merge = U.merge,
-            pick = U.pick;
-        /* ************************************************************************** *
-         *  Start data grouping module                                                *
-         * ************************************************************************** */
-        /* eslint-disable no-invalid-this, valid-jsdoc */
+        /* *
+         *
+         *  Constants
+         *
+         * */
         /**
          * Define the available approximation types. The data grouping
          * approximations takes an array or numbers as the first parameter. In case
@@ -73,133 +62,669 @@
          * @product highstock
          *
          * @private
-         * @name Highcharts.approximations
-         * @type {Highcharts.Dictionary<Function>}
          */
-        var approximations = H.approximations = {
-                sum: function (arr) {
-                    var len = arr.length,
-            ret;
-                // 1. it consists of nulls exclusive
-                if (!len && arr.hasNulls) {
-                    ret = null;
-                    // 2. it has a length and real values
+        var ApproximationRegistry = {
+            // approximations added programmatically
+            };
+        /* *
+         *
+         *  Default Export
+         *
+         * */
+
+        return ApproximationRegistry;
+    });
+    _registerModule(_modules, 'Extensions/DataGrouping/ApproximationDefaults.js', [_modules['Extensions/DataGrouping/ApproximationRegistry.js'], _modules['Core/Utilities.js']], function (ApproximationRegistry, U) {
+        /* *
+         *
+         *  (c) 2010-2021 Torstein Honsi
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        var arrayMax = U.arrayMax,
+            arrayMin = U.arrayMin,
+            correctFloat = U.correctFloat,
+            extend = U.extend,
+            isNumber = U.isNumber;
+        /* *
+         *
+         *  Functions
+         *
+         * */
+        /**
+         * @private
+         */
+        function average(arr) {
+            var len = arr.length;
+            var ret = sum(arr);
+            // If we have a number, return it divided by the length. If not,
+            // return null or undefined based on what the sum method finds.
+            if (isNumber(ret) && len) {
+                ret = correctFloat(ret / len);
+            }
+            return ret;
+        }
+        /**
+         * The same as average, but for series with multiple values, like area ranges.
+         * @private
+         */
+        function averages() {
+            var ret = [];
+            [].forEach.call(arguments, function (arr) {
+                ret.push(average(arr));
+            });
+            // Return undefined when first elem. is undefined and let
+            // sum method handle null (#7377)
+            return typeof ret[0] === 'undefined' ? void 0 : ret;
+        }
+        /**
+         * @private
+         */
+        function close(arr) {
+            return arr.length ?
+                arr[arr.length - 1] :
+                (arr.hasNulls ? null : void 0);
+        }
+        /**
+         * @private
+         */
+        function high(arr) {
+            return arr.length ?
+                arrayMax(arr) :
+                (arr.hasNulls ? null : void 0);
+        }
+        /**
+         * HLC, OHLC and range are special cases where a multidimensional array is input
+         * and an array is output.
+         * @private
+         */
+        function hlc(high, low, close) {
+            high = ApproximationRegistry.high(high);
+            low = ApproximationRegistry.low(low);
+            close = ApproximationRegistry.close(close);
+            if (isNumber(high) ||
+                isNumber(low) ||
+                isNumber(close)) {
+                return [high, low, close];
+            }
+        }
+        /**
+         * @private
+         */
+        function low(arr) {
+            return arr.length ?
+                arrayMin(arr) :
+                (arr.hasNulls ? null : void 0);
+        }
+        /**
+         * @private
+         */
+        function ohlc(open, high, low, close) {
+            open = ApproximationRegistry.open(open);
+            high = ApproximationRegistry.high(high);
+            low = ApproximationRegistry.low(low);
+            close = ApproximationRegistry.close(close);
+            if (isNumber(open) ||
+                isNumber(high) ||
+                isNumber(low) ||
+                isNumber(close)) {
+                return [open, high, low, close];
+            }
+        }
+        /**
+         * @private
+         */
+        function open(arr) {
+            return arr.length ? arr[0] : (arr.hasNulls ? null : void 0);
+        }
+        /**
+         * @private
+         */
+        function range(low, high) {
+            low = ApproximationRegistry.low(low);
+            high = ApproximationRegistry.high(high);
+            if (isNumber(low) || isNumber(high)) {
+                return [low, high];
+            }
+            if (low === null && high === null) {
+                return null;
+            }
+            // else, return is undefined
+        }
+        /**
+         * @private
+         */
+        function sum(arr) {
+            var len = arr.length,
+                ret;
+            // 1. it consists of nulls exclusive
+            if (!len && arr.hasNulls) {
+                ret = null;
+                // 2. it has a length and real values
+            }
+            else if (len) {
+                ret = 0;
+                while (len--) {
+                    ret += arr[len];
+                }
+            }
+            // 3. it has zero length, so just return undefined
+            // => doNothing()
+            return ret;
+        }
+        /* *
+         *
+         *  Default Export
+         *
+         * */
+        var ApproximationDefaults = {
+                average: average,
+                averages: averages,
+                close: close,
+                high: high,
+                hlc: hlc,
+                low: low,
+                ohlc: ohlc,
+                open: open,
+                range: range,
+                sum: sum
+            };
+        extend(ApproximationRegistry, ApproximationDefaults);
+
+        return ApproximationDefaults;
+    });
+    _registerModule(_modules, 'Extensions/DataGrouping/DataGroupingDefaults.js', [], function () {
+        /* *
+         *
+         *  (c) 2010-2021 Torstein Honsi
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        /* *
+         *
+         *  Constants
+         *
+         * */
+        /**
+         * Common options
+         * @private
+         */
+        var common = {
+                // enabled: null, // (true for stock charts, false for basic),
+                // forced: undefined,
+                groupPixelWidth: 2,
+                // the first one is the point or start value, the second is the start
+                // value if we're dealing with range, the third one is the end value if
+                // dealing with a range
+                dateTimeLabelFormats: {
+                    millisecond: [
+                        '%A, %b %e, %H:%M:%S.%L',
+                        '%A, %b %e, %H:%M:%S.%L',
+                        '-%H:%M:%S.%L'
+                    ],
+                    second: [
+                        '%A, %b %e, %H:%M:%S',
+                        '%A, %b %e, %H:%M:%S',
+                        '-%H:%M:%S'
+                    ],
+                    minute: [
+                        '%A, %b %e, %H:%M',
+                        '%A, %b %e, %H:%M',
+                        '-%H:%M'
+                    ],
+                    hour: [
+                        '%A, %b %e, %H:%M',
+                        '%A, %b %e, %H:%M',
+                        '-%H:%M'
+                    ],
+                    day: [
+                        '%A, %b %e, %Y',
+                        '%A, %b %e',
+                        '-%A, %b %e, %Y'
+                    ],
+                    week: [
+                        'Week from %A, %b %e, %Y',
+                        '%A, %b %e',
+                        '-%A, %b %e, %Y'
+                    ],
+                    month: [
+                        '%B %Y',
+                        '%B',
+                        '-%B %Y'
+                    ],
+                    year: [
+                        '%Y',
+                        '%Y',
+                        '-%Y'
+                    ]
+                }
+                // smoothed = false, // enable this for navigator series only
+            };
+        /**
+         * Extends common options
+         * @private
+         */
+        var seriesSpecific = {
+                line: {},
+                spline: {},
+                area: {},
+                areaspline: {},
+                arearange: {},
+                column: {
+                    groupPixelWidth: 10
+                },
+                columnrange: {
+                    groupPixelWidth: 10
+                },
+                candlestick: {
+                    groupPixelWidth: 10
+                },
+                ohlc: {
+                    groupPixelWidth: 5
+                },
+                hlc: {
+                    groupPixelWidth: 5
+                    // Move to HeikinAshiSeries.ts aftre refactoring data grouping.
+                },
+                heikinashi: {
+                    groupPixelWidth: 10
                 }
-                else if (len) {
-                    ret = 0;
-                    while (len--) {
-                        ret += arr[len];
+            };
+        /**
+         * Units are defined in a separate array to allow complete overriding in
+         * case of a user option.
+         * @private
+         */
+        var units = [
+                [
+                    'millisecond',
+                    [1, 2, 5, 10, 20, 25, 50, 100, 200, 500] // allowed multiples
+                ],
+            [
+                    'second',
+                    [1, 2, 5, 10, 15, 30]
+                ],
+            [
+                    'minute',
+                    [1, 2, 5, 10, 15, 30]
+                ],
+            [
+                    'hour',
+                    [1, 2, 3, 4, 6, 8, 12]
+                ],
+            [
+                    'day',
+                    [1]
+                ],
+            [
+                    'week',
+                    [1]
+                ],
+            [
+                    'month',
+                    [1, 3, 6]
+                ],
+            [
+                    'year',
+                    null
+                ]
+            ];
+        /* *
+         *
+         *  Default Export
+         *
+         * */
+        var DataGroupingDefaults = {
+                common: common,
+                seriesSpecific: seriesSpecific,
+                units: units
+            };
+
+        return DataGroupingDefaults;
+    });
+    _registerModule(_modules, 'Extensions/DataGrouping/DataGroupingAxisComposition.js', [_modules['Extensions/DataGrouping/DataGroupingDefaults.js'], _modules['Core/Utilities.js']], function (DataGroupingDefaults, U) {
+        /* *
+         *
+         *  (c) 2010-2021 Torstein Honsi
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        var addEvent = U.addEvent,
+            extend = U.extend,
+            merge = U.merge,
+            pick = U.pick;
+        /* *
+         *
+         *  Constants
+         *
+         * */
+        var composedMembers = [];
+        /* *
+         *
+         *  Variables
+         *
+         * */
+        var AxisConstructor;
+        /* *
+         *
+         *  Functions
+         *
+         * */
+        /**
+         * Check the groupPixelWidth and apply the grouping if needed.
+         * Fired only after processing the data.
+         *
+         * @product highstock
+         *
+         * @function Highcharts.Axis#applyGrouping
+         */
+        function applyGrouping(e) {
+            var axis = this,
+                series = axis.series;
+            // Reset the groupPixelWidth for all series, #17141.
+            series.forEach(function (series) {
+                series.groupPixelWidth = void 0; // #2110
+            });
+            series.forEach(function (series) {
+                series.groupPixelWidth = (axis.getGroupPixelWidth &&
+                    axis.getGroupPixelWidth());
+                if (series.groupPixelWidth) {
+                    series.hasProcessed = true; // #2692
+                }
+                // Fire independing on series.groupPixelWidth to always set a proper
+                // dataGrouping state, (#16238)
+                series.applyGrouping(!!e.hasExtremesChanged);
+            });
+        }
+        /**
+         * @private
+         */
+        function compose(AxisClass) {
+            AxisConstructor = AxisClass;
+            if (composedMembers.indexOf(AxisClass) === -1) {
+                composedMembers.push(AxisClass);
+                addEvent(AxisClass, 'afterSetScale', onAfterSetScale);
+                // When all series are processed, calculate the group pixel width and
+                // then if this value is different than zero apply groupings.
+                addEvent(AxisClass, 'postProcessData', applyGrouping);
+                extend(AxisClass.prototype, {
+                    applyGrouping: applyGrouping,
+                    getGroupPixelWidth: getGroupPixelWidth,
+                    setDataGrouping: setDataGrouping
+                });
+            }
+        }
+        /**
+         * Get the data grouping pixel width based on the greatest defined individual
+         * width of the axis' series, and if whether one of the axes need grouping.
+         * @private
+         */
+        function getGroupPixelWidth() {
+            var series = this.series;
+            var i = series.length,
+                groupPixelWidth = 0,
+                doGrouping = false,
+                dataLength,
+                dgOptions;
+            // If one of the series needs grouping, apply it to all (#1634)
+            while (i--) {
+                dgOptions = series[i].options.dataGrouping;
+                if (dgOptions) { // #2692
+                    // If multiple series are compared on the same x axis, give them the
+                    // same group pixel width (#334)
+                    groupPixelWidth = Math.max(groupPixelWidth, 
+                    // Fallback to commonOptions (#9693)
+                    pick(dgOptions.groupPixelWidth, DataGroupingDefaults.common.groupPixelWidth));
+                    dataLength = (series[i].processedXData || series[i].data).length;
+                    // Execute grouping if the amount of points is greater than the
+                    // limit defined in groupPixelWidth
+                    if (series[i].groupPixelWidth ||
+                        (dataLength >
+                            (this.chart.plotSizeX / groupPixelWidth)) ||
+                        (dataLength && dgOptions.forced)) {
+                        doGrouping = true;
                     }
                 }
-                // 3. it has zero length, so just return undefined
-                // => doNothing()
-                return ret;
-            },
-            average: function (arr) {
-                var len = arr.length,
-                    ret = approximations.sum(arr);
-                // If we have a number, return it divided by the length. If not,
-                // return null or undefined based on what the sum method finds.
-                if (isNumber(ret) && len) {
-                    ret = correctFloat(ret / len);
+            }
+            return doGrouping ? groupPixelWidth : 0;
+        }
+        /**
+         * When resetting the scale reset the hasProccessed flag to avoid taking
+         * previous data grouping of neighbour series into accound when determining
+         * group pixel width (#2692).
+         * @private
+         */
+        function onAfterSetScale() {
+            this.series.forEach(function (series) {
+                series.hasProcessed = false;
+            });
+        }
+        /**
+         * Highcharts Stock only. Force data grouping on all the axis' series.
+         *
+         * @product highstock
+         *
+         * @function Highcharts.Axis#setDataGrouping
+         *
+         * @param {boolean|Highcharts.DataGroupingOptionsObject} [dataGrouping]
+         *        A `dataGrouping` configuration. Use `false` to disable data grouping
+         *        dynamically.
+         *
+         * @param {boolean} [redraw=true]
+         *        Whether to redraw the chart or wait for a later call to
+         *        {@link Chart#redraw}.
+         */
+        function setDataGrouping(dataGrouping, redraw) {
+            var axis = this;
+            var i;
+            redraw = pick(redraw, true);
+            if (!dataGrouping) {
+                dataGrouping = {
+                    forced: false,
+                    units: null
+                };
+            }
+            // Axis is instantiated, update all series
+            if (this instanceof AxisConstructor) {
+                i = this.series.length;
+                while (i--) {
+                    this.series[i].update({
+                        dataGrouping: dataGrouping
+                    }, false);
                 }
-                return ret;
-            },
-            // The same as average, but for series with multiple values, like area
-            // ranges.
-            averages: function () {
-                var ret = [];
-                [].forEach.call(arguments, function (arr) {
-                    ret.push(approximations.average(arr));
+                // Axis not yet instanciated, alter series options
+            }
+            else {
+                this.chart.options.series.forEach(function (seriesOptions) {
+                    // Merging dataGrouping options with already defined options #16759
+                    seriesOptions.dataGrouping = typeof dataGrouping === 'boolean' ?
+                        dataGrouping :
+                        merge(dataGrouping, seriesOptions.dataGrouping);
                 });
-                // Return undefined when first elem. is undefined and let
-                // sum method handle null (#7377)
-                return typeof ret[0] === 'undefined' ? void 0 : ret;
-            },
-            open: function (arr) {
-                return arr.length ? arr[0] : (arr.hasNulls ? null : void 0);
-            },
-            high: function (arr) {
-                return arr.length ?
-                    arrayMax(arr) :
-                    (arr.hasNulls ? null : void 0);
-            },
-            low: function (arr) {
-                return arr.length ?
-                    arrayMin(arr) :
-                    (arr.hasNulls ? null : void 0);
-            },
-            close: function (arr) {
-                return arr.length ?
-                    arr[arr.length - 1] :
-                    (arr.hasNulls ? null : void 0);
-            },
-            // HLC, OHLC and range are special cases where a multidimensional array is
-            // input and an array is output.
-            hlc: function (high, low, close) {
-                high = approximations.high(high);
-                low = approximations.low(low);
-                close = approximations.close(close);
-                if (isNumber(high) ||
-                    isNumber(low) ||
-                    isNumber(close)) {
-                    return [high, low, close];
+            }
+            // Clear ordinal slope, so we won't accidentaly use the old one (#7827)
+            if (axis.ordinal) {
+                axis.ordinal.slope = void 0;
+            }
+            if (redraw) {
+                this.chart.redraw();
+            }
+        }
+        /* *
+         *
+         *  Default Export
+         *
+         * */
+        var DataGroupingAxisComposition = {
+                compose: compose
+            };
+
+        return DataGroupingAxisComposition;
+    });
+    _registerModule(_modules, 'Extensions/DataGrouping/DataGroupingSeriesComposition.js', [_modules['Extensions/DataGrouping/ApproximationRegistry.js'], _modules['Extensions/DataGrouping/DataGroupingDefaults.js'], _modules['Core/Axis/DateTimeAxis.js'], _modules['Core/Defaults.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (ApproximationRegistry, DataGroupingDefaults, DateTimeAxis, D, SeriesRegistry, U) {
+        /* *
+         *
+         *  (c) 2010-2021 Torstein Honsi
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        var seriesProto = SeriesRegistry.series.prototype;
+        var addEvent = U.addEvent,
+            defined = U.defined,
+            error = U.error,
+            extend = U.extend,
+            isNumber = U.isNumber,
+            merge = U.merge,
+            pick = U.pick;
+        /* *
+         *
+         *  Constants
+         *
+         * */
+        var baseGeneratePoints = seriesProto.generatePoints;
+        var composedMembers = [];
+        /* *
+         *
+         *  Functions
+         *
+         * */
+        /**
+         * @private
+         */
+        function adjustExtremes(xAxis, groupedXData) {
+            // Make sure the X axis extends to show the first group (#2533)
+            // But only for visible series (#5493, #6393)
+            if (defined(groupedXData[0]) &&
+                isNumber(xAxis.min) &&
+                isNumber(xAxis.dataMin) &&
+                groupedXData[0] < xAxis.min) {
+                if ((!defined(xAxis.options.min) &&
+                    xAxis.min <= xAxis.dataMin) ||
+                    xAxis.min === xAxis.dataMin) {
+                    xAxis.min = Math.min(groupedXData[0], xAxis.min);
+                }
+                xAxis.dataMin = Math.min(groupedXData[0], xAxis.dataMin);
+            }
+            // When the last anchor set, change the extremes that
+            // the last point is visible (#12455).
+            if (defined(groupedXData[groupedXData.length - 1]) &&
+                isNumber(xAxis.max) &&
+                isNumber(xAxis.dataMax) &&
+                groupedXData[groupedXData.length - 1] > xAxis.max) {
+                if ((!defined(xAxis.options.max) &&
+                    isNumber(xAxis.dataMax) &&
+                    xAxis.max >= xAxis.dataMax) || xAxis.max === xAxis.dataMax) {
+                    xAxis.max = Math.max(groupedXData[groupedXData.length - 1], xAxis.max);
                 }
-            },
-            ohlc: function (open, high, low, close) {
-                open = approximations.open(open);
-                high = approximations.high(high);
-                low = approximations.low(low);
-                close = approximations.close(close);
-                if (isNumber(open) ||
-                    isNumber(high) ||
-                    isNumber(low) ||
-                    isNumber(close)) {
-                    return [open, high, low, close];
+                xAxis.dataMax = Math.max(groupedXData[groupedXData.length - 1], xAxis.dataMax);
+            }
+        }
+        /**
+         * @private
+         */
+        function anchorPoints(series, groupedXData, xMax) {
+            var options = series.options,
+                dataGroupingOptions = options.dataGrouping,
+                totalRange = (series.currentDataGrouping && series.currentDataGrouping.gapSize);
+            var i;
+            // DataGrouping x-coordinates.
+            if (dataGroupingOptions && series.xData && totalRange && series.groupMap) {
+                var groupedDataLength = groupedXData.length - 1,
+                    anchor = dataGroupingOptions.anchor,
+                    firstAnchor = pick(dataGroupingOptions.firstAnchor,
+                    anchor),
+                    lastAnchor = pick(dataGroupingOptions.lastAnchor,
+                    anchor);
+                // Anchor points that are not extremes.
+                if (anchor && anchor !== 'start') {
+                    var shiftInterval = (totalRange *
+                            { middle: 0.5,
+                        end: 1 }[anchor]);
+                    i = groupedXData.length - 1;
+                    while (i-- && i > 0) {
+                        groupedXData[i] += shiftInterval;
+                    }
                 }
-            },
-            range: function (low, high) {
-                low = approximations.low(low);
-                high = approximations.high(high);
-                if (isNumber(low) || isNumber(high)) {
-                    return [low, high];
+                // Change the first point position, but only when it is
+                // the first point in the data set not in the current zoom.
+                if (firstAnchor &&
+                    firstAnchor !== 'start' &&
+                    series.xData[0] >= groupedXData[0]) {
+                    var groupStart = series.groupMap[0].start,
+                        groupLength = series.groupMap[0].length;
+                    var firstGroupstEnd = void 0;
+                    if (isNumber(groupStart) && isNumber(groupLength)) {
+                        firstGroupstEnd = groupStart + (groupLength - 1);
+                    }
+                    groupedXData[0] = {
+                        middle: groupedXData[0] + 0.5 * totalRange,
+                        end: groupedXData[0] + totalRange,
+                        firstPoint: series.xData[0],
+                        lastPoint: firstGroupstEnd && series.xData[firstGroupstEnd]
+                    }[firstAnchor];
                 }
-                if (low === null && high === null) {
-                    return null;
+                // Change the last point position but only when it is
+                // the last point in the data set not in the current zoom.
+                if (lastAnchor &&
+                    lastAnchor !== 'start' &&
+                    totalRange &&
+                    groupedXData[groupedDataLength] >= xMax - totalRange) {
+                    var lastGroupStart = series.groupMap[series.groupMap.length - 1].start;
+                    groupedXData[groupedDataLength] = {
+                        middle: groupedXData[groupedDataLength] + 0.5 * totalRange,
+                        end: groupedXData[groupedDataLength] + totalRange,
+                        firstPoint: lastGroupStart && series.xData[lastGroupStart],
+                        lastPoint: series.xData[series.xData.length - 1]
+                    }[lastAnchor];
                 }
-                // else, return is undefined
             }
-        };
-        var applyGrouping = function (hasExtemesChanged) {
-                var series = this,
-            chart = series.chart,
-            options = series.options,
-            dataGroupingOptions = options.dataGrouping,
-            groupingEnabled = series.allowDG !== false && dataGroupingOptions &&
+        }
+        /**
+         * For the processed data, calculate the grouped data if needed.
+         *
+         * @private
+         * @function Highcharts.Series#applyGrouping
+         */
+        function applyGrouping(hasExtremesChanged) {
+            var series = this,
+                chart = series.chart,
+                options = series.options,
+                dataGroupingOptions = options.dataGrouping,
+                groupingEnabled = series.allowDG !== false && dataGroupingOptions &&
                     pick(dataGroupingOptions.enabled,
-            chart.options.isStock),
-            visible = (series.visible || !chart.options.chart.ignoreHiddenSeries),
-            hasGroupedData,
-            skip,
-            lastDataGrouping = this.currentDataGrouping,
-            currentDataGrouping,
-            croppedData,
-            revertRequireSorting = false;
+                chart.options.isStock),
+                visible = (series.visible || !chart.options.chart.ignoreHiddenSeries),
+                lastDataGrouping = this.currentDataGrouping;
+            var currentDataGrouping,
+                croppedData,
+                revertRequireSorting = false;
             // Data needs to be sorted for dataGrouping
             if (groupingEnabled && !series.requireSorting) {
                 series.requireSorting = revertRequireSorting = true;
             }
             // Skip if skipDataGrouping method returns false or if grouping is disabled
             // (in that order).
-            skip = skipDataGrouping(series, hasExtemesChanged) === false || !groupingEnabled;
+            var skip = skipDataGrouping(series,
+                hasExtremesChanged) === false || !groupingEnabled;
             // Revert original requireSorting value if changed
             if (revertRequireSorting) {
                 series.requireSorting = false;
             }
             if (!skip) {
                 series.destroyGroupedData();
-                var i = void 0,
-                    processedXData = dataGroupingOptions.groupAll ?
+                var processedXData = dataGroupingOptions.groupAll ?
                         series.xData :
                         series.processedXData,
                     processedYData = dataGroupingOptions.groupAll ?
@@ -209,6 +734,8 @@
                     xAxis = series.xAxis,
                     ordinal = xAxis.options.ordinal,
                     groupPixelWidth = series.groupPixelWidth;
+                var i = void 0,
+                    hasGroupedData = void 0;
                 // Execute grouping if the amount of points is greater than the limit
                 // defined in groupPixelWidth
                 if (groupPixelWidth &&
@@ -230,7 +757,7 @@
                             groupIntervalFactor,
                         groupPositions = xAxis.getTimeTicks(DateTimeAxis.Additions.prototype.normalizeTimeTickInterval(interval,
                         dataGroupingOptions.units ||
-                            defaultDataGroupingUnits), 
+                            DataGroupingDefaults.units), 
                         // Processed data may extend beyond axis (#4907)
                         Math.min(xMin,
                         processedXData[0]),
@@ -245,8 +772,8 @@
                             processedYData,
                             groupPositions,
                             dataGroupingOptions.approximation
-                        ]),
-                        groupedXData = groupedData.groupedXData,
+                        ]);
+                    var groupedXData = groupedData.groupedXData,
                         groupedYData = groupedData.groupedYData,
                         gapSize = 0;
                     // The smoothed option is deprecated, instead, there is a fallback
@@ -305,75 +832,150 @@
                     (lastDataGrouping && lastDataGrouping.totalRange) !==
                         (currentDataGrouping && currentDataGrouping.totalRange);
             }
-        };
-        var skipDataGrouping = function (series,
-            force) {
-                return !(series.isCartesian &&
-                    !series.isDirty &&
-                    !series.xAxis.isDirty &&
-                    !series.yAxis.isDirty &&
-                    !force);
-        };
-        var groupData = function (xData,
-            yData,
-            groupPositions,
-            approximation) {
-                var series = this,
-            data = series.data,
-            dataOptions = series.options && series.options.data,
-            groupedXData = [],
-            groupedYData = [],
-            groupMap = [],
-            dataLength = xData.length,
-            pointX,
-            pointY,
-            groupedY, 
+        }
+        /**
+         * @private
+         */
+        function compose(SeriesClass) {
+            var PointClass = SeriesClass.prototype.pointClass;
+            if (composedMembers.indexOf(PointClass) === -1) {
+                composedMembers.push(PointClass);
+                // Override point prototype to throw a warning when trying to update
+                // grouped points.
+                addEvent(PointClass, 'update', function () {
+                    if (this.dataGroup) {
+                        error(24, false, this.series.chart);
+                        return false;
+                    }
+                });
+            }
+            if (composedMembers.indexOf(SeriesClass) === -1) {
+                composedMembers.push(SeriesClass);
+                addEvent(SeriesClass, 'afterSetOptions', onAfterSetOptions);
+                addEvent(SeriesClass, 'destroy', destroyGroupedData);
+                extend(SeriesClass.prototype, {
+                    applyGrouping: applyGrouping,
+                    destroyGroupedData: destroyGroupedData,
+                    generatePoints: generatePoints,
+                    getDGApproximation: getDGApproximation,
+                    groupData: groupData
+                });
+            }
+        }
+        /**
+         * Destroy the grouped data points. #622, #740
+         * @private
+         */
+        function destroyGroupedData() {
+            // Clear previous groups
+            if (this.groupedData) {
+                this.groupedData.forEach(function (point, i) {
+                    if (point) {
+                        this.groupedData[i] = point.destroy ?
+                            point.destroy() : null;
+                    }
+                }, this);
+                // Clears all:
+                // - `this.groupedData`
+                // - `this.points`
+                // - `preserve` object in series.update()
+                this.groupedData.length = 0;
+            }
+        }
+        /**
+         * Override the generatePoints method by adding a reference to grouped data
+         * @private
+         */
+        function generatePoints() {
+            baseGeneratePoints.apply(this);
+            // Record grouped data in order to let it be destroyed the next time
+            // processData runs
+            this.destroyGroupedData(); // #622
+            this.groupedData = this.hasGroupedData ? this.points : null;
+        }
+        /**
+         * Set default approximations to the prototypes if present. Properties are
+         * inherited down. Can be overridden for individual series types.
+         * @private
+         */
+        function getDGApproximation() {
+            if (this.is('arearange')) {
+                return 'range';
+            }
+            if (this.is('ohlc')) {
+                return 'ohlc';
+            }
+            if (this.is('hlc')) {
+                return 'hlc';
+            }
+            if (this.is('column')) {
+                return 'sum';
+            }
+            return 'average';
+        }
+        /**
+         * Highcharts Stock only. Takes parallel arrays of x and y data and groups the
+         * data into intervals defined by groupPositions, a collection of starting x
+         * values for each group.
+         *
+         * @product highstock
+         *
+         * @function Highcharts.Series#groupData
+         * @param {Array<number>} xData
+         *        Parallel array of x data.
+         * @param {Array<(number|null|undefined)>|Array<Array<(number|null|undefined)>>} yData
+         *        Parallel array of y data.
+         * @param {Array<number>} groupPositions
+         *        Group positions.
+         * @param {string|Function} [approximation]
+         *        Approximation to use.
+         * @return {Highcharts.DataGroupingResultObject}
+         *         Mapped groups.
+         */
+        function groupData(xData, yData, groupPositions, approximation) {
+            var series = this,
+                data = series.data,
+                dataOptions = series.options && series.options.data,
+                groupedXData = [],
+                groupedYData = [],
+                groupMap = [],
+                dataLength = xData.length, 
                 // when grouping the fake extended axis for panning,
                 // we don't need to consider y
                 handleYData = !!yData,
-            values = [],
-            approximationFn,
-            pointArrayMap = series.pointArrayMap,
-            pointArrayMapLength = pointArrayMap && pointArrayMap.length,
-            extendedPointArrayMap = ['x'].concat(pointArrayMap || ['y']),
-            groupAll = (this.options.dataGrouping &&
-                    this.options.dataGrouping.groupAll),
-            pos = 0,
-            start = 0,
-            valuesLen,
-            i,
-            j;
-            /**
-             * @private
-             */
-            function getApproximation(approx) {
-                if (typeof approx === 'function') {
-                    return approx;
-                }
-                if (approximations[approx]) {
-                    return approximations[approx];
-                }
-                return approximations[(series.getDGApproximation && series.getDGApproximation()) ||
-                    'average'];
-            }
-            approximationFn = getApproximation(approximation);
+                values = [],
+                pointArrayMap = series.pointArrayMap,
+                pointArrayMapLength = pointArrayMap && pointArrayMap.length,
+                extendedPointArrayMap = ['x'].concat(pointArrayMap || ['y']),
+                groupAll = (this.options.dataGrouping &&
+                    this.options.dataGrouping.groupAll);
+            var pointX,
+                pointY,
+                groupedY,
+                pos = 0,
+                start = 0;
+            var approximationFn = (typeof approximation === 'function' ?
+                    approximation :
+                    approximation && ApproximationRegistry[approximation] ?
+                        ApproximationRegistry[approximation] :
+                        ApproximationRegistry[(series.getDGApproximation && series.getDGApproximation() ||
+                            'average')]);
             // Calculate values array size from pointArrayMap length
             if (pointArrayMapLength) {
-                pointArrayMap.forEach(function () {
+                var len = pointArrayMap.length;
+                while (len--) {
                     values.push([]);
-                });
+                }
             }
             else {
                 values.push([]);
             }
-            valuesLen = pointArrayMapLength || 1;
-            // Start with the first point within the X axis range (#2696)
-            for (i = 0; i <= dataLength; i++) {
-                if (xData[i] >= groupPositions[0]) {
-                    break;
+            var valuesLen = pointArrayMapLength || 1;
+            for (var i = 0; i <= dataLength; i++) {
+                // Start with the first point within the X axis range (#2696)
+                if (xData[i] < groupPositions[0]) {
+                    continue; // with next point
                 }
-            }
-            for (i; i <= dataLength; i++) {
                 // when a new group is entered, summarize and initialize
                 // the previous group
                 while ((typeof groupPositions[pos + 1] !== 'undefined' &&
@@ -409,7 +1011,7 @@
                     }
                     // reset the aggregate arrays
                     start = i;
-                    for (j = 0; j < valuesLen; j++) {
+                    for (var j = 0; j < valuesLen; j++) {
                         values[j].length = 0; // faster than values[j] = []
                         values[j].hasNulls = false;
                     }
@@ -432,448 +1034,138 @@
                             i : series.cropStart + i),
                         point = (data && data[index]) ||
                             series.pointClass.prototype.applyOptions.apply({
-                                series: series
-                            },
-                        [dataOptions[index]]),
-                        val = void 0;
-                    for (j = 0; j < pointArrayMapLength; j++) {
-                        val = point[pointArrayMap[j]];
-                        if (isNumber(val)) {
-                            values[j].push(val);
-                        }
-                        else if (val === null) {
-                            values[j].hasNulls = true;
-                        }
-                    }
-                }
-                else {
-                    pointY = handleYData ? yData[i] : null;
-                    if (isNumber(pointY)) {
-                        values[0].push(pointY);
-                    }
-                    else if (pointY === null) {
-                        values[0].hasNulls = true;
-                    }
-                }
-            }
-            return {
-                groupedXData: groupedXData,
-                groupedYData: groupedYData,
-                groupMap: groupMap
-            };
-        };
-        var anchorPoints = function (series,
-            groupedXData,
-            xMax) {
-                var options = series.options,
-            dataGroupingOptions = options.dataGrouping,
-            totalRange = (series.currentDataGrouping && series.currentDataGrouping.gapSize);
-            var i;
-            // DataGrouping x-coordinates.
-            if (dataGroupingOptions && series.xData && totalRange && series.groupMap) {
-                var groupedDataLength = groupedXData.length - 1,
-                    anchor = dataGroupingOptions.anchor,
-                    firstAnchor = pick(dataGroupingOptions.firstAnchor,
-                    anchor),
-                    lastAnchor = pick(dataGroupingOptions.lastAnchor,
-                    anchor);
-                // Anchor points that are not extremes.
-                if (anchor && anchor !== 'start') {
-                    var shiftInterval = (totalRange *
-                            { middle: 0.5,
-                        end: 1 }[anchor]);
-                    i = groupedXData.length - 1;
-                    while (i-- && i > 0) {
-                        groupedXData[i] += shiftInterval;
-                    }
-                }
-                // Change the first point position, but only when it is
-                // the first point in the data set not in the current zoom.
-                if (firstAnchor &&
-                    firstAnchor !== 'start' &&
-                    series.xData[0] >= groupedXData[0]) {
-                    var groupStart = series.groupMap[0].start,
-                        groupLength = series.groupMap[0].length;
-                    var firstGroupstEnd = void 0;
-                    if (isNumber(groupStart) && isNumber(groupLength)) {
-                        firstGroupstEnd = groupStart + (groupLength - 1);
-                    }
-                    groupedXData[0] = {
-                        middle: groupedXData[0] + 0.5 * totalRange,
-                        end: groupedXData[0] + totalRange,
-                        firstPoint: series.xData[0],
-                        lastPoint: firstGroupstEnd && series.xData[firstGroupstEnd]
-                    }[firstAnchor];
-                }
-                // Change the last point position but only when it is
-                // the last point in the data set not in the current zoom.
-                if (lastAnchor &&
-                    lastAnchor !== 'start' &&
-                    totalRange &&
-                    groupedXData[groupedDataLength] >= xMax - totalRange) {
-                    var lastGroupStart = series.groupMap[series.groupMap.length - 1].start;
-                    groupedXData[groupedDataLength] = {
-                        middle: groupedXData[groupedDataLength] + 0.5 * totalRange,
-                        end: groupedXData[groupedDataLength] + totalRange,
-                        firstPoint: lastGroupStart && series.xData[lastGroupStart],
-                        lastPoint: series.xData[series.xData.length - 1]
-                    }[lastAnchor];
-                }
-            }
-        };
-        var adjustExtremes = function (xAxis,
-            groupedXData) {
-                // Make sure the X axis extends to show the first group (#2533)
-                // But only for visible series (#5493, #6393)
-                if (defined(groupedXData[0]) &&
-                    isNumber(xAxis.min) &&
-                    isNumber(xAxis.dataMin) &&
-                    groupedXData[0] < xAxis.min) {
-                    if ((!defined(xAxis.options.min) &&
-                        xAxis.min <= xAxis.dataMin) ||
-                        xAxis.min === xAxis.dataMin) {
-                        xAxis.min = Math.min(groupedXData[0],
-            xAxis.min);
-                }
-                xAxis.dataMin = Math.min(groupedXData[0], xAxis.dataMin);
-            }
-            // When the last anchor set, change the extremes that
-            // the last point is visible (#12455).
-            if (defined(groupedXData[groupedXData.length - 1]) &&
-                isNumber(xAxis.max) &&
-                isNumber(xAxis.dataMax) &&
-                groupedXData[groupedXData.length - 1] > xAxis.max) {
-                if ((!defined(xAxis.options.max) &&
-                    isNumber(xAxis.dataMax) &&
-                    xAxis.max >= xAxis.dataMax) || xAxis.max === xAxis.dataMax) {
-                    xAxis.max = Math.max(groupedXData[groupedXData.length - 1], xAxis.max);
-                }
-                xAxis.dataMax = Math.max(groupedXData[groupedXData.length - 1], xAxis.dataMax);
-            }
-        };
-        var dataGrouping = {
-                approximations: approximations,
-                groupData: groupData
-            };
-        // -----------------------------------------------------------------------------
-        // The following code applies to implementation of data grouping on a Series
-        var baseProcessData = seriesProto.processData, baseGeneratePoints = seriesProto.generatePoints, 
-            /** @ignore */
-            commonOptions = {
-                // enabled: null, // (true for stock charts, false for basic),
-                // forced: undefined,
-                groupPixelWidth: 2,
-                // the first one is the point or start value, the second is the start
-                // value if we're dealing with range, the third one is the end value if
-                // dealing with a range
-                dateTimeLabelFormats: {
-                    millisecond: [
-                        '%A, %b %e, %H:%M:%S.%L',
-                        '%A, %b %e, %H:%M:%S.%L',
-                        '-%H:%M:%S.%L'
-                    ],
-                    second: [
-                        '%A, %b %e, %H:%M:%S',
-                        '%A, %b %e, %H:%M:%S',
-                        '-%H:%M:%S'
-                    ],
-                    minute: [
-                        '%A, %b %e, %H:%M',
-                        '%A, %b %e, %H:%M',
-                        '-%H:%M'
-                    ],
-                    hour: [
-                        '%A, %b %e, %H:%M',
-                        '%A, %b %e, %H:%M',
-                        '-%H:%M'
-                    ],
-                    day: [
-                        '%A, %b %e, %Y',
-                        '%A, %b %e',
-                        '-%A, %b %e, %Y'
-                    ],
-                    week: [
-                        'Week from %A, %b %e, %Y',
-                        '%A, %b %e',
-                        '-%A, %b %e, %Y'
-                    ],
-                    month: [
-                        '%B %Y',
-                        '%B',
-                        '-%B %Y'
-                    ],
-                    year: [
-                        '%Y',
-                        '%Y',
-                        '-%Y'
-                    ]
-                }
-                // smoothed = false, // enable this for navigator series only
-            }, specificOptions = {
-                line: {},
-                spline: {},
-                area: {},
-                areaspline: {},
-                arearange: {},
-                column: {
-                    groupPixelWidth: 10
-                },
-                columnrange: {
-                    groupPixelWidth: 10
-                },
-                candlestick: {
-                    groupPixelWidth: 10
-                },
-                ohlc: {
-                    groupPixelWidth: 5
-                },
-                hlc: {
-                    groupPixelWidth: 5
-                    // Move to HeikinAshiSeries.ts aftre refactoring data grouping.
-                },
-                heikinashi: {
-                    groupPixelWidth: 10
+                                series: series
+                            },
+                        [dataOptions[index]]);
+                    var val = void 0;
+                    for (var j = 0; j < pointArrayMapLength; j++) {
+                        val = point[pointArrayMap[j]];
+                        if (isNumber(val)) {
+                            values[j].push(val);
+                        }
+                        else if (val === null) {
+                            values[j].hasNulls = true;
+                        }
+                    }
+                }
+                else {
+                    pointY = handleYData ? yData[i] : null;
+                    if (isNumber(pointY)) {
+                        values[0].push(pointY);
+                    }
+                    else if (pointY === null) {
+                        values[0].hasNulls = true;
+                    }
                 }
-            }, 
-            // units are defined in a separate array to allow complete overriding in
-            // case of a user option
-            defaultDataGroupingUnits = H.defaultDataGroupingUnits = [
-                [
-                    'millisecond',
-                    [1, 2, 5, 10, 20, 25, 50, 100, 200, 500] // allowed multiples
-                ], [
-                    'second',
-                    [1, 2, 5, 10, 15, 30]
-                ], [
-                    'minute',
-                    [1, 2, 5, 10, 15, 30]
-                ], [
-                    'hour',
-                    [1, 2, 3, 4, 6, 8, 12]
-                ], [
-                    'day',
-                    [1]
-                ], [
-                    'week',
-                    [1]
-                ], [
-                    'month',
-                    [1, 3, 6]
-                ], [
-                    'year',
-                    null
-                ]
-            ];
-        // Set default approximations to the prototypes if present. Properties are
-        // inherited down. Can be overridden for individual series types.
-        seriesProto.getDGApproximation = function () {
-            if (this.is('arearange')) {
-                return 'range';
-            }
-            if (this.is('ohlc')) {
-                return 'ohlc';
-            }
-            if (this.is('hlc')) {
-                return 'hlc';
             }
-            if (this.is('column')) {
-                return 'sum';
+            return {
+                groupedXData: groupedXData,
+                groupedYData: groupedYData,
+                groupMap: groupMap
+            };
+        }
+        /**
+         * Handle default options for data grouping. This must be set at runtime because
+         * some series types are defined after this.
+         * @private
+         */
+        function onAfterSetOptions(e) {
+            var options = e.options,
+                type = this.type,
+                plotOptions = this.chart.options.plotOptions, 
+                // External series, for example technical indicators should also inherit
+                // commonOptions which are not available outside this module
+                baseOptions = (this.useCommonDataGrouping &&
+                    DataGroupingDefaults.common),
+                seriesSpecific = DataGroupingDefaults.seriesSpecific;
+            var defaultOptions = D.defaultOptions.plotOptions[type].dataGrouping;
+            if (plotOptions && (seriesSpecific[type] || baseOptions)) { // #1284
+                var rangeSelector = this.chart.rangeSelector;
+                if (!defaultOptions) {
+                    defaultOptions = merge(DataGroupingDefaults.common, seriesSpecific[type]);
+                }
+                options.dataGrouping = merge(baseOptions, defaultOptions, plotOptions.series && plotOptions.series.dataGrouping, // #1228
+                // Set by the StockChart constructor:
+                plotOptions[type].dataGrouping, this.userOptions.dataGrouping, !options.isInternal &&
+                    rangeSelector &&
+                    isNumber(rangeSelector.selected) &&
+                    rangeSelector.buttonOptions[rangeSelector.selected].dataGrouping);
             }
-            return 'average';
-        };
+        }
         /**
-         * Takes parallel arrays of x and y data and groups the data into intervals
-         * defined by groupPositions, a collection of starting x values for each group.
-         *
          * @private
-         * @function Highcharts.Series#groupData
+         */
+        function skipDataGrouping(series, force) {
+            return !(series.isCartesian &&
+                !series.isDirty &&
+                !series.xAxis.isDirty &&
+                !series.yAxis.isDirty &&
+                !force);
+        }
+        /* *
          *
-         * @param {Array<number>} xData
+         *  Default Export
          *
-         * @param {Array<number>|Array<Array<number>>} yData
+         * */
+        var DataGroupingSeriesComposition = {
+                compose: compose,
+                groupData: groupData
+            };
+
+        return DataGroupingSeriesComposition;
+    });
+    _registerModule(_modules, 'Extensions/DataGrouping/DataGrouping.js', [_modules['Extensions/DataGrouping/DataGroupingAxisComposition.js'], _modules['Extensions/DataGrouping/DataGroupingDefaults.js'], _modules['Extensions/DataGrouping/DataGroupingSeriesComposition.js'], _modules['Core/FormatUtilities.js'], _modules['Core/Utilities.js']], function (DataGroupingAxisComposition, DataGroupingDefaults, DataGroupingSeriesComposition, F, U) {
+        /* *
          *
-         * @param {boolean} groupPositions
+         *  (c) 2010-2021 Torstein Honsi
          *
-         * @param {string|Function} approximation
+         *  License: www.highcharts.com/license
          *
-         * @return {void}
-         */
-        seriesProto.groupData = groupData;
-        /**
-         * For the processed data, calculate the grouped data if needed.
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
-         * @private
-         * @function Highcharts.Series#applyGrouping
+         * */
+        var format = F.format;
+        var addEvent = U.addEvent,
+            extend = U.extend,
+            isNumber = U.isNumber;
+        /* *
          *
-         * @return {void}
-         */
-        seriesProto.applyGrouping = applyGrouping;
-        // Destroy the grouped data points. #622, #740
-        seriesProto.destroyGroupedData = function () {
-            // Clear previous groups
-            if (this.groupedData) {
-                this.groupedData.forEach(function (point, i) {
-                    if (point) {
-                        this.groupedData[i] = point.destroy ?
-                            point.destroy() : null;
-                    }
-                }, this);
-                // Clears all:
-                // - `this.groupedData`
-                // - `this.points`
-                // - `preserve` object in series.update()
-                this.groupedData.length = 0;
-            }
-        };
-        // Override the generatePoints method by adding a reference to grouped data
-        seriesProto.generatePoints = function () {
-            baseGeneratePoints.apply(this);
-            // Record grouped data in order to let it be destroyed the next time
-            // processData runs
-            this.destroyGroupedData(); // #622
-            this.groupedData = this.hasGroupedData ? this.points : null;
-        };
-        /**
-         * Check the groupPixelWidth and apply the grouping if needed.
-         * Fired only after processing the data.
+         *  Constants
          *
-         * @product highstock
+         * */
+        var composedMembers = [];
+        /* *
          *
-         * @function Highcharts.Axis#applyGrouping
+         *  Functions
+         *
+         * */
+        /**
+         * @private
          */
-        Axis.prototype.applyGrouping = function (e) {
-            var axis = this,
-                series = axis.series;
-            // Reset the groupPixelWidth for all series, #17141.
-            series.forEach(function (series) {
-                series.groupPixelWidth = void 0; // #2110
-            });
-            series.forEach(function (series) {
-                series.groupPixelWidth = (axis.getGroupPixelWidth &&
-                    axis.getGroupPixelWidth());
-                if (series.groupPixelWidth) {
-                    series.hasProcessed = true; // #2692
-                }
-                // Fire independing on series.groupPixelWidth to always set a proper
-                // dataGrouping state, (#16238)
-                series.applyGrouping(!!e.hasExtemesChanged);
-            });
-        };
-        // Get the data grouping pixel width based on the greatest defined individual
-        // width of the axis' series, and if whether one of the axes need grouping.
-        Axis.prototype.getGroupPixelWidth = function () {
-            var series = this.series,
-                len = series.length,
-                i,
-                groupPixelWidth = 0,
-                doGrouping = false,
-                dataLength,
-                dgOptions;
-            // If multiple series are compared on the same x axis, give them the same
-            // group pixel width (#334)
-            i = len;
-            while (i--) {
-                dgOptions = series[i].options.dataGrouping;
-                if (dgOptions) {
-                    groupPixelWidth = Math.max(groupPixelWidth, 
-                    // Fallback to commonOptions (#9693)
-                    pick(dgOptions.groupPixelWidth, commonOptions.groupPixelWidth));
-                }
-            }
-            // If one of the series needs grouping, apply it to all (#1634)
-            i = len;
-            while (i--) {
-                dgOptions = series[i].options.dataGrouping;
-                if (dgOptions) { // #2692
-                    dataLength = (series[i].processedXData || series[i].data).length;
-                    // Execute grouping if the amount of points is greater than the
-                    // limit defined in groupPixelWidth
-                    if (series[i].groupPixelWidth ||
-                        (dataLength >
-                            (this.chart.plotSizeX / groupPixelWidth)) ||
-                        (dataLength && dgOptions.forced)) {
-                        doGrouping = true;
-                    }
-                }
+        function compose(AxisClass, SeriesClass, TooltipClass) {
+            DataGroupingAxisComposition.compose(AxisClass);
+            DataGroupingSeriesComposition.compose(SeriesClass);
+            if (composedMembers.indexOf(TooltipClass) === -1) {
+                composedMembers.push(TooltipClass);
+                addEvent(TooltipClass, 'headerFormatter', onTooltipHeaderFormatter);
             }
-            return doGrouping ? groupPixelWidth : 0;
-        };
+        }
         /**
-         * Highcharts Stock only. Force data grouping on all the axis' series.
-         *
-         * @product highstock
-         *
-         * @function Highcharts.Axis#setDataGrouping
-         *
-         * @param {boolean|Highcharts.DataGroupingOptionsObject} [dataGrouping]
-         *        A `dataGrouping` configuration. Use `false` to disable data grouping
-         *        dynamically.
-         *
-         * @param {boolean} [redraw=true]
-         *        Whether to redraw the chart or wait for a later call to
-         *        {@link Chart#redraw}.
+         * Extend the original method, make the tooltip's header reflect the grouped
+         * range.
+         * @private
          */
-        Axis.prototype.setDataGrouping = function (dataGrouping, redraw) {
-            var axis = this;
-            var i;
-            redraw = pick(redraw, true);
-            if (!dataGrouping) {
-                dataGrouping = {
-                    forced: false,
-                    units: null
-                };
-            }
-            // Axis is instantiated, update all series
-            if (this instanceof Axis) {
-                i = this.series.length;
-                while (i--) {
-                    this.series[i].update({
-                        dataGrouping: dataGrouping
-                    }, false);
-                }
-                // Axis not yet instanciated, alter series options
-            }
-            else {
-                this.chart.options.series.forEach(function (seriesOptions) {
-                    // Merging dataGrouping options with already defined options #16759
-                    seriesOptions.dataGrouping = typeof dataGrouping === 'boolean' ?
-                        dataGrouping :
-                        merge(dataGrouping, seriesOptions.dataGrouping);
-                });
-            }
-            // Clear ordinal slope, so we won't accidentaly use the old one (#7827)
-            if (axis.ordinal) {
-                axis.ordinal.slope = void 0;
-            }
-            if (redraw) {
-                this.chart.redraw();
-            }
-        };
-        // When all series are processed, calculate the group pixel width and then
-        // if this value is different than zero apply groupings.
-        addEvent(Axis, 'postProcessData', Axis.prototype.applyGrouping);
-        // Override point prototype to throw a warning when trying to update grouped
-        // points.
-        addEvent(Point, 'update', function () {
-            if (this.dataGroup) {
-                error(24, false, this.series.chart);
-                return false;
-            }
-        });
-        // Extend the original method, make the tooltip's header reflect the grouped
-        // range.
-        addEvent(Tooltip, 'headerFormatter', function (e) {
-            var tooltip = this,
-                chart = this.chart,
+        function onTooltipHeaderFormatter(e) {
+            var chart = this.chart,
                 time = chart.time,
                 labelConfig = e.labelConfig,
                 series = labelConfig.series,
                 options = series.options,
                 tooltipOptions = series.tooltipOptions,
                 dataGroupingOptions = options.dataGrouping,
-                xDateFormat = tooltipOptions.xDateFormat,
+                xAxis = series.xAxis;
+            var xDateFormat = tooltipOptions.xDateFormat,
                 xDateFormatEnd,
-                xAxis = series.xAxis,
                 currentDataGrouping,
                 dateTimeLabelFormats,
                 labelFormats,
@@ -888,7 +1180,7 @@
                 currentDataGrouping = series.currentDataGrouping;
                 dateTimeLabelFormats = dataGroupingOptions.dateTimeLabelFormats ||
                     // Fallback to commonOptions (#9693)
-                    commonOptions.dateTimeLabelFormats;
+                    DataGroupingDefaults.common.dateTimeLabelFormats;
                 // if we have grouped data, use the grouping information to get the
                 // right format
                 if (currentDataGrouping) {
@@ -924,47 +1216,16 @@
                 }, chart);
                 e.preventDefault();
             }
-        });
-        // Destroy grouped data on series destroy
-        addEvent(Series, 'destroy', seriesProto.destroyGroupedData);
-        // Handle default options for data grouping. This must be set at runtime because
-        // some series types are defined after this.
-        addEvent(Series, 'afterSetOptions', function (e) {
-            var options = e.options,
-                type = this.type,
-                plotOptions = this.chart.options.plotOptions,
-                defaultOptions = D.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);
-            if (plotOptions && (specificOptions[type] || baseOptions)) { // #1284
-                if (!defaultOptions) {
-                    defaultOptions = merge(commonOptions, specificOptions[type]);
-                }
-                var rangeSelector = this.chart.rangeSelector;
-                options.dataGrouping = merge(baseOptions, defaultOptions, plotOptions.series && plotOptions.series.dataGrouping, // #1228
-                // Set by the StockChart constructor:
-                plotOptions[type].dataGrouping, this.userOptions.dataGrouping, !options.isInternal &&
-                    rangeSelector &&
-                    isNumber(rangeSelector.selected) &&
-                    rangeSelector.buttonOptions[rangeSelector.selected].dataGrouping);
-            }
-        });
-        // When resetting the scale reset the hasProccessed flag to avoid taking
-        // previous data grouping of neighbour series into accound when determining
-        // group pixel width (#2692).
-        addEvent(Axis, 'afterSetScale', function () {
-            this.series.forEach(function (series) {
-                series.hasProcessed = false;
-            });
-        });
+        }
         /* *
          *
          *  Default Export
          *
          * */
-        // @todo move to master
-        H.dataGrouping = dataGrouping;
+        var DataGroupingComposition = {
+                compose: compose,
+                groupData: DataGroupingSeriesComposition.groupData
+            };
         /* *
          *
          *  API Declarations
@@ -998,6 +1259,21 @@
         * @name Highcharts.DataGroupingInfoObject#start
         * @type {number}
         */
+        /**
+         * Highcharts Stock only.
+         *
+         * @product highstock
+         * @interface Highcharts.DataGroupingResultObject
+         */ /**
+        * @name Highcharts.DataGroupingResultObject#groupedXData
+        * @type {Array<number>}
+        */ /**
+        * @name Highcharts.DataGroupingResultObject#groupedYData
+        * @type {Array<(number|null|undefined)>|Array<Array<(number|null|undefined)>>}
+        */ /**
+        * @name Highcharts.DataGroupingResultObject#groupMap
+        * @type {Array<DataGroupingInfoObject>}
+        */
         /**
          * Highcharts Stock only. If a point object is created by data
          * grouping, it doesn't reflect actual points in the raw
@@ -1317,11 +1593,16 @@
          */
         ''; // required by JSDoc parsing
 
-        return dataGrouping;
+        return DataGroupingComposition;
     });
-    _registerModule(_modules, 'masters/modules/datagrouping.src.js', [_modules['Extensions/DataGrouping.js']], function (dataGrouping) {
+    _registerModule(_modules, 'masters/modules/datagrouping.src.js', [_modules['Core/Globals.js'], _modules['Extensions/DataGrouping/ApproximationDefaults.js'], _modules['Extensions/DataGrouping/ApproximationRegistry.js'], _modules['Extensions/DataGrouping/DataGrouping.js']], function (Highcharts, ApproximationDefaults, ApproximationRegistry, DataGrouping) {
 
+        var G = Highcharts;
+        G.dataGrouping = {
+            approximationDefaults: ApproximationDefaults,
+            approximations: ApproximationRegistry
+        };
+        DataGrouping.compose(G.Axis, G.Series, G.Tooltip);
 
-        return dataGrouping;
     });
 }));