aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/modules/datagrouping.js

@@ -0,0 +1,25 @@
+/*
+  Highcharts JS v7.0.3 (2019-02-06)
+
+ Data grouping module
+
+ (c) 2010-2019 Torstein Hnsi
+
+ License: www.highcharts.com/license
+*/
+(function(e){"object"===typeof module&&module.exports?(e["default"]=e,module.exports=e):"function"===typeof define&&define.amd?define(function(){return e}):e("undefined"!==typeof Highcharts?Highcharts:void 0)})(function(e){return function(d){var e=d.addEvent,H=d.arrayMax,I=d.arrayMin,v=d.Axis,J=d.defaultPlotOptions,C=d.defined,K=d.extend,L=d.format,n=d.isNumber,D=d.merge,w=d.pick,M=d.Point,x=d.Series,N=d.Tooltip,h=d.approximations={sum:function(a){var c=a.length,b;if(!c&&a.hasNulls)b=null;else if(c)for(b=
+0;c--;)b+=a[c];return b},average:function(a){var c=a.length;a=h.sum(a);n(a)&&c&&(a/=c);return a},averages:function(){var a=[];[].forEach.call(arguments,function(c){a.push(h.average(c))});return void 0===a[0]?void 0:a},open:function(a){return a.length?a[0]:a.hasNulls?null:void 0},high:function(a){return a.length?H(a):a.hasNulls?null:void 0},low:function(a){return a.length?I(a):a.hasNulls?null:void 0},close:function(a){return a.length?a[a.length-1]:a.hasNulls?null:void 0},ohlc:function(a,c,b,k){a=h.open(a);
+c=h.high(c);b=h.low(b);k=h.close(k);if(n(a)||n(c)||n(b)||n(k))return[a,c,b,k]},range:function(a,c){a=h.low(a);c=h.high(c);if(n(a)||n(c))return[a,c];if(null===a&&null===c)return null}},F=function(a,c,b,k){var f=this,d=f.data,r=f.options&&f.options.data,E=[],l=[],p=[],m=a.length,g,e,t=!!c,u=[],y=f.pointArrayMap,v=y&&y.length,z=["x"].concat(y||["y"]),A=0,w=0,x,q;k="function"===typeof k?k:h[k]?h[k]:h[f.getDGApproximation&&f.getDGApproximation()||"average"];v?y.forEach(function(){u.push([])}):u.push([]);
+x=v||1;for(q=0;q<=m&&!(a[q]>=b[0]);q++);for(q;q<=m;q++){for(;void 0!==b[A+1]&&a[q]>=b[A+1]||q===m;){g=b[A];f.dataGroupInfo={start:f.cropStart+w,length:u[0].length};e=k.apply(f,u);f.pointClass&&!C(f.dataGroupInfo.options)&&(f.dataGroupInfo.options=D(f.pointClass.prototype.optionsToObject.call({series:f},f.options.data[f.cropStart+w])),z.forEach(function(a){delete f.dataGroupInfo.options[a]}));void 0!==e&&(E.push(g),l.push(e),p.push(f.dataGroupInfo));w=q;for(g=0;g<x;g++)u[g].length=0,u[g].hasNulls=
+!1;A+=1;if(q===m)break}if(q===m)break;if(y){g=f.cropStart+q;e=d&&d[g]||f.pointClass.prototype.applyOptions.apply({series:f},[r[g]]);var B;for(g=0;g<v;g++)B=e[y[g]],n(B)?u[g].push(B):null===B&&(u[g].hasNulls=!0)}else g=t?c[q]:null,n(g)?u[0].push(g):null===g&&(u[0].hasNulls=!0)}return{groupedXData:E,groupedYData:l,groupMap:p}},O={approximations:h,groupData:F},t=x.prototype,P=t.processData,Q=t.generatePoints,z={groupPixelWidth:2,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"]}},G={line:{},spline:{},area:{},areaspline:{},column:{groupPixelWidth:10},columnrange:{groupPixelWidth:10},candlestick:{groupPixelWidth:10},ohlc:{groupPixelWidth:5}},
+R=d.defaultDataGroupingUnits=[["millisecond",[1,2,5,10,20,25,50,100,200,500]],["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]];t.getDGApproximation=function(){return d.seriesTypes.arearange&&this instanceof d.seriesTypes.arearange?"range":d.seriesTypes.ohlc&&this instanceof d.seriesTypes.ohlc?"ohlc":d.seriesTypes.column&&this instanceof d.seriesTypes.column?"sum":"average"};t.groupData=F;t.processData=function(){var a=
+this.chart,c=this.options.dataGrouping,b=!1!==this.allowDG&&c&&w(c.enabled,a.options.isStock),k=this.visible||!a.options.chart.ignoreHiddenSeries,f,d=this.currentDataGrouping,r,e=!1;this.forceCrop=b;this.groupPixelWidth=null;this.hasProcessed=!0;b&&!this.requireSorting&&(this.requireSorting=e=!0);b=!1===P.apply(this,arguments)||!b;e&&(this.requireSorting=!1);if(!b){this.destroyGroupedData();var l,b=c.groupAll?this.xData:this.processedXData,p=c.groupAll?this.yData:this.processedYData,m=a.plotSizeX,
+a=this.xAxis,g=a.options.ordinal,h=this.groupPixelWidth=a.getGroupPixelWidth&&a.getGroupPixelWidth();if(h){this.isDirty=f=!0;this.points=null;e=a.getExtremes();r=e.min;var e=e.max,g=g&&a.getGroupIntervalFactor(r,e,this)||1,h=h*(e-r)/m*g,m=a.getTimeTicks(a.normalizeTimeTickInterval(h,c.units||R),Math.min(r,b[0]),Math.max(e,b[b.length-1]),a.options.startOfWeek,b,this.closestPointRange),p=t.groupData.apply(this,[b,p,m,c.approximation]),b=p.groupedXData,g=p.groupedYData,n=0;if(c.smoothed&&b.length){l=
+b.length-1;for(b[l]=Math.min(b[l],e);l--&&0<l;)b[l]+=h/2;b[0]=Math.max(b[0],r)}for(l=1;l<m.length;l++)m.info.segmentStarts&&-1!==m.info.segmentStarts.indexOf(l)||(n=Math.max(m[l]-m[l-1],n));r=m.info;r.gapSize=n;this.closestPointRange=m.info.totalRange;this.groupMap=p.groupMap;if(C(b[0])&&b[0]<a.dataMin&&k){if(!C(a.options.min)&&a.min<=a.dataMin||a.min===a.dataMin)a.min=b[0];a.dataMin=b[0]}c.groupAll&&(c=this.cropData(b,g,a.min,a.max,1),b=c.xData,g=c.yData);this.processedXData=b;this.processedYData=
+g}else this.groupMap=null;this.hasGroupedData=f;this.currentDataGrouping=r;this.preventGraphAnimation=(d&&d.totalRange)!==(r&&r.totalRange)}};t.destroyGroupedData=function(){var a=this.groupedData;(a||[]).forEach(function(c,b){c&&(a[b]=c.destroy?c.destroy():null)});this.groupedData=null};t.generatePoints=function(){Q.apply(this);this.destroyGroupedData();this.groupedData=this.hasGroupedData?this.points:null};e(M,"update",function(){if(this.dataGroup)return d.error(24,!1,this.series.chart),!1});e(N,
+"headerFormatter",function(a){var c=this.chart.time,b=a.labelConfig,k=b.series,f=k.tooltipOptions,e=k.options.dataGrouping,d=f.xDateFormat,h,l=k.xAxis,p,m=f[(a.isFooter?"footer":"header")+"Format"];l&&"datetime"===l.options.type&&e&&n(b.key)&&(p=k.currentDataGrouping,e=e.dateTimeLabelFormats||z.dateTimeLabelFormats,p?(f=e[p.unitName],1===p.count?d=f[0]:(d=f[1],h=f[2])):!d&&e&&(d=this.getXDateFormat(b,f,l)),d=c.dateFormat(d,b.key),h&&(d+=c.dateFormat(h,b.key+p.totalRange-1)),k.chart.styledMode&&(m=
+this.styledModeFormat(m)),a.text=L(m,{point:K(b.point,{key:d}),series:k},c),a.preventDefault())});e(x,"destroy",t.destroyGroupedData);e(x,"afterSetOptions",function(a){a=a.options;var c=this.type,b=this.chart.options.plotOptions,d=J[c].dataGrouping,f=this.useCommonDataGrouping&&z;if(G[c]||f)d||(d=D(z,G[c])),a.dataGrouping=D(f,d,b.series&&b.series.dataGrouping,b[c].dataGrouping,this.userOptions.dataGrouping)});e(v,"afterSetScale",function(){this.series.forEach(function(a){a.hasProcessed=!1})});v.prototype.getGroupPixelWidth=
+function(){var a=this.series,c=a.length,b,d=0,f=!1,e;for(b=c;b--;)(e=a[b].options.dataGrouping)&&(d=Math.max(d,w(e.groupPixelWidth,z.groupPixelWidth)));for(b=c;b--;)(e=a[b].options.dataGrouping)&&a[b].hasProcessed&&(c=(a[b].processedXData||a[b].data).length,a[b].groupPixelWidth||c>this.chart.plotSizeX/d||c&&e.forced)&&(f=!0);return f?d:0};v.prototype.setDataGrouping=function(a,c){var b;c=w(c,!0);a||(a={forced:!1,units:null});if(this instanceof v)for(b=this.series.length;b--;)this.series[b].update({dataGrouping:a},
+!1);else this.chart.options.series.forEach(function(b){b.dataGrouping=a},!1);this.ordinalSlope=null;c&&this.chart.redraw()};return d.dataGrouping=O}(e)});
+//# sourceMappingURL=datagrouping.js.map

data/vendor/assets/javascripts/highstock/modules/datagrouping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datagrouping.js.map","lineCount":24,"mappings":"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","sources":["datagrouping.src.js"],"names":["factory","module","exports","define","amd","Highcharts","undefined","H","addEvent","arrayMax","arrayMin","Axis","defaultPlotOptions","defined","extend","format","isNumber","merge","pick","Point","Series","Tooltip","approximations","sum","arr","len","length","ret","hasNulls","average","averages","forEach","call","arguments","push","open","high","low","close","ohlc","range","groupData","xData","yData","groupPositions","approximation","series","data","dataOptions","options","groupedXData","groupedYData","groupMap","dataLength","pointX","groupedY","handleYData","values","pointArrayMap","pointArrayMapLength","extendedPointArrayMap","concat","pos","start","valuesLen","i","getDGApproximation","dataGroupInfo","cropStart","approximationFn","apply","pointClass","prototype","optionsToObject","key","j","index","point","applyOptions","val","pointY","dataGrouping","seriesProto","baseProcessData","processData","baseGeneratePoints","generatePoints","commonOptions","groupPixelWidth","dateTimeLabelFormats","millisecond","second","minute","hour","day","week","month","year","specificOptions","line","spline","area","areaspline","column","columnrange","candlestick","defaultDataGroupingUnits","seriesProto.getDGApproximation","seriesTypes","arearange","seriesProto.processData","chart","dataGroupingOptions","groupingEnabled","allowDG","enabled","isStock","visible","ignoreHiddenSeries","hasGroupedData","lastDataGrouping","currentDataGrouping","revertRequireSorting","forceCrop","hasProcessed","requireSorting","skip","destroyGroupedData","processedXData","groupAll","processedYData","plotSizeX","xAxis","ordinal","getGroupPixelWidth","isDirty","points","extremes","getExtremes","xMin","min","xMax","max","groupIntervalFactor","getGroupIntervalFactor","interval","getTimeTicks","normalizeTimeTickInterval","units","Math","startOfWeek","closestPointRange","groupedData","gapSize","smoothed","info","segmentStarts","indexOf","totalRange","dataMin","croppedData","cropData","preventGraphAnimation","seriesProto.destroyGroupedData","destroy","seriesProto.generatePoints","dataGroup","error","e","time","labelConfig","tooltipOptions","xDateFormat","xDateFormatEnd","formatString","isFooter","type","labelFormats","unitName","count","tooltip","getXDateFormat","formattedKey","dateFormat","styledMode","styledModeFormat","text","preventDefault","plotOptions","defaultOptions","baseOptions","useCommonDataGrouping","userOptions","Axis.prototype.getGroupPixelWidth","doGrouping","dgOptions","forced","setDataGrouping","Axis.prototype.setDataGrouping","redraw","update","seriesOptions","ordinalSlope"]}

data/vendor/assets/javascripts/highstock/modules/datagrouping.src.js

@@ -0,0 +1,1140 @@
+/**
+ * @license  Highcharts JS v7.0.3 (2019-02-06)
+ *
+ * Data grouping module
+ *
+ * (c) 2010-2019 Torstein Hønsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+(function (factory) {
+    if (typeof module === 'object' && module.exports) {
+        factory['default'] = factory;
+        module.exports = factory;
+    } else if (typeof define === 'function' && define.amd) {
+        define(function () {
+            return factory;
+        });
+    } else {
+        factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
+    }
+}(function (Highcharts) {
+    var dataGrouping = (function (H) {
+        /* *
+         *
+         *  (c) 2010-2019 Torstein Honsi
+         *
+         *  License: www.highcharts.com/license
+         *
+         * */
+
+
+
+        var addEvent = H.addEvent,
+            arrayMax = H.arrayMax,
+            arrayMin = H.arrayMin,
+            Axis = H.Axis,
+            defaultPlotOptions = H.defaultPlotOptions,
+            defined = H.defined,
+            extend = H.extend,
+            format = H.format,
+            isNumber = H.isNumber,
+            merge = H.merge,
+            pick = H.pick,
+            Point = H.Point,
+            Series = H.Series,
+            Tooltip = H.Tooltip;
+
+        /* ************************************************************************** *
+         *  Start data grouping module                                                *
+         * ************************************************************************** */
+
+        /**
+         * Data grouping is the concept of sampling the data values into larger
+         * blocks in order to ease readability and increase performance of the
+         * JavaScript charts. Highstock by default applies data grouping when
+         * the points become closer than a certain pixel value, determined by
+         * the `groupPixelWidth` option.
+         *
+         * If data grouping is applied, the grouping information of grouped
+         * points can be read from the [Point.dataGroup](
+         * /class-reference/Highcharts.Point#dataGroup). If point options other than
+         * the data itself are set, for example `name` or `color` or custom properties,
+         * the grouping logic doesn't know how to group it. In this case the options of
+         * the first point instance are copied over to the group point. This can be
+         * altered through a custom `approximation` callback function.
+         *
+         * @product   highstock
+         * @apioption plotOptions.series.dataGrouping
+         */
+
+        /**
+         * The method of approximation inside a group. When for example 30 days
+         * are grouped into one month, this determines what value should represent
+         * the group. Possible values are "average", "averages", "open", "high",
+         * "low", "close" and "sum". For OHLC and candlestick series the approximation
+         * is "ohlc" by default, which finds the open, high, low and close values
+         * within all the grouped data. For ranges, the approximation is "range",
+         * which finds the low and high values. For multi-dimensional data,
+         * like ranges and OHLC, "averages" will compute the average for each
+         * dimension.
+         *
+         * Custom aggregate methods can be added by assigning a callback function
+         * as the approximation. This function takes a numeric array as the
+         * argument and should return a single numeric value or `null`. Note
+         * that the numeric array will never contain null values, only true
+         * numbers. Instead, if null values are present in the raw data, the
+         * numeric array will have an `.hasNulls` property set to `true`. For
+         * single-value data sets the data is available in the first argument
+         * of the callback function. For OHLC data sets, all the open values
+         * are in the first argument, all high values in the second etc.
+         *
+         * Since v4.2.7, grouping meta data is available in the approximation
+         * callback from `this.dataGroupInfo`. It can be used to extract information
+         * from the raw data.
+         *
+         * Defaults to `average` for line-type series, `sum` for columns, `range`
+         * for range series and `ohlc` for OHLC and candlestick.
+         *
+         * @sample {highstock} stock/plotoptions/series-datagrouping-approximation
+         *         Approximation callback with custom data
+         *
+         * @type       {string|Function}
+         * @validvalue ["average", "averages", "open", "high", "low", "close", "sum"]
+         * @product    highstock
+         * @apioption  plotOptions.series.dataGrouping.approximation
+         */
+
+        /**
+         * Datetime formats for the header of the tooltip in a stock chart.
+         * The format can vary within a chart depending on the currently selected
+         * time range and the current data grouping.
+         *
+         * The default formats are:
+         *
+         * <pre>{
+         *     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']
+         * }</pre>
+         *
+         * For each of these array definitions, the first item is the format
+         * used when the active time span is one unit. For instance, if the
+         * current data applies to one week, the first item of the week array
+         * is used. The second and third items are used when the active time
+         * span is more than two units. For instance, if the current data applies
+         * to two weeks, the second and third item of the week array are used,
+         *  and applied to the start and end date of the time span.
+         *
+         * @type      {object}
+         * @product   highstock
+         * @apioption plotOptions.series.dataGrouping.dateTimeLabelFormats
+         */
+
+        /**
+         * Enable or disable data grouping.
+         *
+         * @type      {boolean}
+         * @default   true
+         * @product   highstock
+         * @apioption plotOptions.series.dataGrouping.enabled
+         */
+
+        /**
+         * When data grouping is forced, it runs no matter how small the intervals
+         * are. This can be handy for example when the sum should be calculated
+         * for values appearing at random times within each hour.
+         *
+         * @type      {boolean}
+         * @default   false
+         * @product   highstock
+         * @apioption plotOptions.series.dataGrouping.forced
+         */
+
+        /**
+         * The approximate pixel width of each group. If for example a series
+         * with 30 points is displayed over a 600 pixel wide plot area, no grouping
+         * is performed. If however the series contains so many points that
+         * the spacing is less than the groupPixelWidth, Highcharts will try
+         * to group it into appropriate groups so that each is more or less
+         * two pixels wide. If multiple series with different group pixel widths
+         * are drawn on the same x axis, all series will take the greatest width.
+         * For example, line series have 2px default group width, while column
+         * series have 10px. If combined, both the line and the column will
+         * have 10px by default.
+         *
+         * @type      {number}
+         * @default   2
+         * @product   highstock
+         * @apioption plotOptions.series.dataGrouping.groupPixelWidth
+         */
+
+        /**
+         * By default only points within the visible range are grouped. Enabling this
+         * option will force data grouping to calculate all grouped points for a given
+         * dataset. That option prevents for example a column series from calculating
+         * a grouped point partially. The effect is similar to
+         * [Series.getExtremesFromAll](#plotOptions.series.getExtremesFromAll) but does
+         * not affect yAxis extremes.
+         *
+         * @sample {highstock} stock/plotoptions/series-datagrouping-groupall/
+         *         Two series with the same data but different groupAll setting
+         *
+         * @type      {boolean}
+         * @default   false
+         * @since     6.1.0
+         * @product   highstock
+         * @apioption plotOptions.series.dataGrouping.groupAll
+         */
+
+        /**
+         * Normally, a group is indexed by the start of that group, so for example
+         * when 30 daily values are grouped into one month, that month's x value
+         * will be the 1st of the month. This apparently shifts the data to
+         * the left. When the smoothed option is true, this is compensated for.
+         * The data is shifted to the middle of the group, and min and max
+         * values are preserved. Internally, this is used in the Navigator series.
+         *
+         * @type      {boolean}
+         * @default   false
+         * @product   highstock
+         * @apioption plotOptions.series.dataGrouping.smoothed
+         */
+
+        /**
+         * An array determining what time intervals the data is allowed to be
+         * grouped to. Each array item is an array where the first value is
+         * the time unit and the second value another array of allowed multiples.
+         * Defaults to:
+         *
+         * <pre>units: [[
+         *     'millisecond', // unit name
+         *     [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
+         * ]]</pre>
+         *
+         * @type      {Array<Array<string,(Array<number>|null)>>}
+         * @product   highstock
+         * @apioption plotOptions.series.dataGrouping.units
+         */
+
+        /**
+         * The approximate pixel width of each group. If for example a series
+         * with 30 points is displayed over a 600 pixel wide plot area, no grouping
+         * is performed. If however the series contains so many points that
+         * the spacing is less than the groupPixelWidth, Highcharts will try
+         * to group it into appropriate groups so that each is more or less
+         * two pixels wide. Defaults to `10`.
+         *
+         * @sample {highstock} stock/plotoptions/series-datagrouping-grouppixelwidth/
+         *         Two series with the same data density but different groupPixelWidth
+         *
+         * @type      {number}
+         * @default   10
+         * @product   highstock
+         * @apioption plotOptions.column.dataGrouping.groupPixelWidth
+         */
+
+
+        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
+                } else if (len) {
+                    ret = 0;
+                    while (len--) {
+                        ret += arr[len];
+                    }
+                }
+                // 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 = ret / len;
+                }
+
+                return ret;
+            },
+            // The same as average, but for series with multiple values, like area
+            // ranges.
+            averages: function () { // #5479
+                var ret = [];
+
+                [].forEach.call(arguments, function (arr) {
+                    ret.push(approximations.average(arr));
+                });
+
+                // Return undefined when first elem. is undefined and let
+                // sum method handle null (#7377)
+                return ret[0] === undefined ? undefined : ret;
+            },
+            open: function (arr) {
+                return arr.length ? arr[0] : (arr.hasNulls ? null : undefined);
+            },
+            high: function (arr) {
+                return arr.length ?
+                    arrayMax(arr) :
+                    (arr.hasNulls ? null : undefined);
+            },
+            low: function (arr) {
+                return arr.length ?
+                    arrayMin(arr) :
+                    (arr.hasNulls ? null : undefined);
+            },
+            close: function (arr) {
+                return arr.length ?
+                    arr[arr.length - 1] :
+                    (arr.hasNulls ? null : undefined);
+            },
+            // ohlc and range are special cases where a multidimensional array is
+            // input and an array is output
+            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];
+                }
+                // else, return is undefined
+            },
+            range: function (low, high) {
+                low = approximations.low(low);
+                high = approximations.high(high);
+                if (isNumber(low) || isNumber(high)) {
+                    return [low, high];
+                }
+                if (low === null && high === null) {
+                    return null;
+                }
+                // else, return is undefined
+            }
+        };
+
+        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,
+                // 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']),
+                pos = 0,
+                start = 0,
+                valuesLen,
+                i,
+                j;
+
+            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);
+
+            // Calculate values array size from pointArrayMap length
+            if (pointArrayMapLength) {
+                pointArrayMap.forEach(function () {
+                    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;
+                }
+            }
+
+            for (i; i <= dataLength; i++) {
+
+                // when a new group is entered, summarize and initialize
+                // the previous group
+                while (
+                    (
+                        groupPositions[pos + 1] !== undefined &&
+                        xData[i] >= groupPositions[pos + 1]
+                    ) ||
+                    i === dataLength
+                ) { // get the last group
+
+                    // get group x and y
+                    pointX = groupPositions[pos];
+                    series.dataGroupInfo = {
+                        start: series.cropStart + start,
+                        length: values[0].length
+                    };
+                    groupedY = approximationFn.apply(series, values);
+
+                    // By default, let options of the first grouped point be passed over
+                    // to the grouped point. This allows preserving properties like
+                    // `name` and `color` or custom properties. Implementers can
+                    // override this from the approximation function, where they can
+                    // write custom options to `this.dataGroupInfo.options`.
+                    if (series.pointClass && !defined(series.dataGroupInfo.options)) {
+                        // Convert numbers and arrays into objects
+                        series.dataGroupInfo.options = merge(
+                            series.pointClass.prototype
+                                .optionsToObject.call(
+                                    { series: series },
+                                    series.options.data[series.cropStart + start]
+                                )
+                        );
+
+                        // Make sure the raw data (x, y, open, high etc) is not copied
+                        // over and overwriting approximated data.
+                        extendedPointArrayMap.forEach(function (key) { // eslint-disable-line
+                            delete series.dataGroupInfo.options[key];
+                        });
+                    }
+
+                    // push the grouped data
+                    if (groupedY !== undefined) {
+                        groupedXData.push(pointX);
+                        groupedYData.push(groupedY);
+                        groupMap.push(series.dataGroupInfo);
+                    }
+
+                    // reset the aggregate arrays
+                    start = i;
+                    for (j = 0; j < valuesLen; j++) {
+                        values[j].length = 0; // faster than values[j] = []
+                        values[j].hasNulls = false;
+                    }
+
+                    // Advance on the group positions
+                    pos += 1;
+
+                    // don't loop beyond the last group
+                    if (i === dataLength) {
+                        break;
+                    }
+                }
+
+                // break out
+                if (i === dataLength) {
+                    break;
+                }
+
+                // for each raw data point, push it to an array that contains all values
+                // for this specific group
+                if (pointArrayMap) {
+
+                    var index = series.cropStart + i,
+                        point = (data && data[index]) ||
+                            series.pointClass.prototype.applyOptions.apply({
+                                series: series
+                            }, [dataOptions[index]]),
+                        val;
+
+                    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 dataGrouping = {
+            approximations: approximations,
+            groupData: groupData
+        };
+
+
+        // -----------------------------------------------------------------------------
+        // The following code applies to implementation of data grouping on a Series
+
+        var seriesProto = Series.prototype,
+            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 = { // extends common options
+                line: {},
+                spline: {},
+                area: {},
+                areaspline: {},
+                column: {
+                    groupPixelWidth: 10
+                },
+                columnrange: {
+                    groupPixelWidth: 10
+                },
+                candlestick: {
+                    groupPixelWidth: 10
+                },
+                ohlc: {
+                    groupPixelWidth: 5
+                }
+            },
+
+            // units are defined in a separate array to allow complete overriding in
+            // case of a user option
+            defaultDataGroupingUnits = H.defaultDataGroupingUnits = [
+                [
+                    'millisecond', // unit name
+                    [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 (H.seriesTypes.arearange && this instanceof H.seriesTypes.arearange) {
+                return 'range';
+            }
+            if (H.seriesTypes.ohlc && this instanceof H.seriesTypes.ohlc) {
+                return 'ohlc';
+            }
+            if (H.seriesTypes.column && this instanceof H.seriesTypes.column) {
+                return 'sum';
+            }
+            return 'average';
+        };
+
+        /**
+         * Define the available approximation types. The data grouping
+         * approximations takes an array or numbers as the first parameter. In case
+         * of ohlc, four arrays are sent in as four parameters. Each array consists
+         * only of numbers. In case null values belong to the group, the property
+         * .hasNulls will be set to true on the array.
+         *
+         * @product highstock
+         *
+         * @private
+         * @name Highcharts.approximations
+         * @type {Highcharts.Dictionary<Function>}
+         */
+
+        /**
+         * 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
+         *
+         * @param {Array<number>} xData
+         *
+         * @param {Array<number>} yData
+         *
+         * @param {boolean} groupPositions
+         *
+         * @param {string|Function} approximation
+         *
+         * @return {Array<Array<number>,Array<number>,Array<object>>}
+         */
+        seriesProto.groupData = groupData;
+
+        // Extend the basic processData method, that crops the data to the current zoom
+        // range, with data grouping logic.
+        seriesProto.processData = function () {
+            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;
+
+            // Run base method
+            series.forceCrop = groupingEnabled; // #334
+            series.groupPixelWidth = null; // #2110
+            series.hasProcessed = true; // #2692
+
+            // Data needs to be sorted for dataGrouping
+            if (groupingEnabled && !series.requireSorting) {
+                series.requireSorting = revertRequireSorting = true;
+            }
+
+            // Skip if processData returns false or if grouping is disabled (in that
+            // order)
+            skip = (
+                baseProcessData.apply(series, arguments) === false ||
+                !groupingEnabled
+            );
+
+            // Revert original requireSorting value if changed
+            if (revertRequireSorting) {
+                series.requireSorting = false;
+            }
+
+            if (!skip) {
+                series.destroyGroupedData();
+
+                var i,
+                    processedXData = dataGroupingOptions.groupAll ? series.xData :
+                        series.processedXData,
+                    processedYData = dataGroupingOptions.groupAll ? series.yData :
+                        series.processedYData,
+                    plotSizeX = chart.plotSizeX,
+                    xAxis = series.xAxis,
+                    ordinal = xAxis.options.ordinal,
+                    groupPixelWidth = series.groupPixelWidth =
+                        xAxis.getGroupPixelWidth && xAxis.getGroupPixelWidth();
+
+                // Execute grouping if the amount of points is greater than the limit
+                // defined in groupPixelWidth
+                if (groupPixelWidth) {
+                    hasGroupedData = true;
+
+                    // Force recreation of point instances in series.translate, #5699
+                    series.isDirty = true;
+                    series.points = null; // #6709
+
+                    var extremes = xAxis.getExtremes(),
+                        xMin = extremes.min,
+                        xMax = extremes.max,
+                        groupIntervalFactor = (
+                            ordinal &&
+                            xAxis.getGroupIntervalFactor(xMin, xMax, series)
+                        ) || 1,
+                        interval =
+                            (groupPixelWidth * (xMax - xMin) / plotSizeX) *
+                            groupIntervalFactor,
+                        groupPositions = xAxis.getTimeTicks(
+                            xAxis.normalizeTimeTickInterval(
+                                interval,
+                                dataGroupingOptions.units || defaultDataGroupingUnits
+                            ),
+                            // Processed data may extend beyond axis (#4907)
+                            Math.min(xMin, processedXData[0]),
+                            Math.max(xMax, processedXData[processedXData.length - 1]),
+                            xAxis.options.startOfWeek,
+                            processedXData,
+                            series.closestPointRange
+                        ),
+                        groupedData = seriesProto.groupData.apply(
+                            series,
+                            [
+                                processedXData,
+                                processedYData,
+                                groupPositions,
+                                dataGroupingOptions.approximation
+                            ]
+                        ),
+                        groupedXData = groupedData.groupedXData,
+                        groupedYData = groupedData.groupedYData,
+                        gapSize = 0;
+
+                    // Prevent the smoothed data to spill out left and right, and make
+                    // sure data is not shifted to the left
+                    if (dataGroupingOptions.smoothed && groupedXData.length) {
+                        i = groupedXData.length - 1;
+                        groupedXData[i] = Math.min(groupedXData[i], xMax);
+                        while (i-- && i > 0) {
+                            groupedXData[i] += interval / 2;
+                        }
+                        groupedXData[0] = Math.max(groupedXData[0], xMin);
+                    }
+
+                    // Record what data grouping values were used
+                    for (i = 1; i < groupPositions.length; i++) {
+                        // The grouped gapSize needs to be the largest distance between
+                        // the group to capture varying group sizes like months or DST
+                        // crossing (#10000). Also check that the gap is not at the
+                        // start of a segment.
+                        if (
+                            !groupPositions.info.segmentStarts ||
+                            groupPositions.info.segmentStarts.indexOf(i) === -1
+                        ) {
+                            gapSize = Math.max(
+                                groupPositions[i] - groupPositions[i - 1],
+                                gapSize
+                            );
+                        }
+                    }
+                    currentDataGrouping = groupPositions.info;
+                    currentDataGrouping.gapSize = gapSize;
+                    series.closestPointRange = groupPositions.info.totalRange;
+                    series.groupMap = groupedData.groupMap;
+
+                    // Make sure the X axis extends to show the first group (#2533)
+                    // But only for visible series (#5493, #6393)
+                    if (
+                        defined(groupedXData[0]) &&
+                        groupedXData[0] < xAxis.dataMin &&
+                        visible
+                    ) {
+                        if (
+                            (
+                                !defined(xAxis.options.min) &&
+                                xAxis.min <= xAxis.dataMin
+                            ) ||
+                            xAxis.min === xAxis.dataMin
+                        ) {
+                            xAxis.min = groupedXData[0];
+                        }
+                        xAxis.dataMin = groupedXData[0];
+                    }
+
+                    // We calculated all group positions but we should render
+                    // only the ones within the visible range
+                    if (dataGroupingOptions.groupAll) {
+                        croppedData = series.cropData(
+                            groupedXData,
+                            groupedYData,
+                            xAxis.min,
+                            xAxis.max,
+                            1 // Ordinal xAxis will remove left-most points otherwise
+                        );
+                        groupedXData = croppedData.xData;
+                        groupedYData = croppedData.yData;
+                    }
+                    // Set series props
+                    series.processedXData = groupedXData;
+                    series.processedYData = groupedYData;
+                } else {
+                    series.groupMap = null;
+                }
+                series.hasGroupedData = hasGroupedData;
+                series.currentDataGrouping = currentDataGrouping;
+
+                series.preventGraphAnimation =
+                    (lastDataGrouping && lastDataGrouping.totalRange) !==
+                    (currentDataGrouping && currentDataGrouping.totalRange);
+            }
+        };
+
+        // Destroy the grouped data points. #622, #740
+        seriesProto.destroyGroupedData = function () {
+
+            var groupedData = this.groupedData;
+
+            // clear previous groups
+            (groupedData || []).forEach(function (point, i) {
+                if (point) {
+                    groupedData[i] = point.destroy ? point.destroy() : null;
+                }
+            });
+            this.groupedData = null;
+        };
+
+        // 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;
+        };
+
+        // Override point prototype to throw a warning when trying to update grouped
+        // points.
+        addEvent(Point, 'update', function () {
+            if (this.dataGroup) {
+                H.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,
+                time = this.chart.time,
+                labelConfig = e.labelConfig,
+                series = labelConfig.series,
+                options = series.options,
+                tooltipOptions = series.tooltipOptions,
+                dataGroupingOptions = options.dataGrouping,
+                xDateFormat = tooltipOptions.xDateFormat,
+                xDateFormatEnd,
+                xAxis = series.xAxis,
+                currentDataGrouping,
+                dateTimeLabelFormats,
+                labelFormats,
+                formattedKey,
+                formatString = tooltipOptions[
+                    (e.isFooter ? 'footer' : 'header') + 'Format'
+                ];
+
+            // apply only to grouped series
+            if (
+                xAxis &&
+                xAxis.options.type === 'datetime' &&
+                dataGroupingOptions &&
+                isNumber(labelConfig.key)
+            ) {
+
+                // set variables
+                currentDataGrouping = series.currentDataGrouping;
+                dateTimeLabelFormats = dataGroupingOptions.dateTimeLabelFormats ||
+                    // Fallback to commonOptions (#9693)
+                    commonOptions.dateTimeLabelFormats;
+
+                // if we have grouped data, use the grouping information to get the
+                // right format
+                if (currentDataGrouping) {
+                    labelFormats = dateTimeLabelFormats[currentDataGrouping.unitName];
+                    if (currentDataGrouping.count === 1) {
+                        xDateFormat = labelFormats[0];
+                    } else {
+                        xDateFormat = labelFormats[1];
+                        xDateFormatEnd = labelFormats[2];
+                    }
+                // if not grouped, and we don't have set the xDateFormat option, get the
+                // best fit, so if the least distance between points is one minute, show
+                // it, but if the least distance is one day, skip hours and minutes etc.
+                } else if (!xDateFormat && dateTimeLabelFormats) {
+                    xDateFormat = tooltip.getXDateFormat(
+                        labelConfig,
+                        tooltipOptions,
+                        xAxis
+                    );
+                }
+
+                // now format the key
+                formattedKey = time.dateFormat(xDateFormat, labelConfig.key);
+                if (xDateFormatEnd) {
+                    formattedKey += time.dateFormat(
+                        xDateFormatEnd,
+                        labelConfig.key + currentDataGrouping.totalRange - 1
+                    );
+                }
+
+                // Replace default header style with class name
+                if (series.chart.styledMode) {
+                    formatString = this.styledModeFormat(formatString);
+                }
+
+                // return the replaced format
+                e.text = format(
+                    formatString, {
+                        point: extend(labelConfig.point, { key: formattedKey }),
+                        series: series
+                    },
+                    time
+                );
+
+                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 = defaultPlotOptions[type].dataGrouping,
+                // External series, for example technical indicators should also
+                // inherit commonOptions which are not available outside this module
+                baseOptions = this.useCommonDataGrouping && commonOptions;
+
+            if (specificOptions[type] || baseOptions) { // #1284
+                if (!defaultOptions) {
+                    defaultOptions = merge(commonOptions, specificOptions[type]);
+                }
+
+                options.dataGrouping = merge(
+                    baseOptions,
+                    defaultOptions,
+                    plotOptions.series && plotOptions.series.dataGrouping, // #1228
+                    plotOptions[type].dataGrouping, // Set by the StockChart constructor
+                    this.userOptions.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;
+            });
+        });
+
+        // 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 && series[i].hasProcessed) { // #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;
+                    }
+                }
+            }
+
+            return doGrouping ? groupPixelWidth : 0;
+        };
+
+        /**
+         * Highstock only. Force data grouping on all the axis' series.
+         *
+         * @product highstock
+         *
+         * @function Highcharts.Axis#setDataGrouping
+         *
+         * @param {boolean|Highcharts.PlotSeriesDataGroupingOptions} [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}.
+         */
+        Axis.prototype.setDataGrouping = function (dataGrouping, redraw) {
+            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) {
+                    seriesOptions.dataGrouping = dataGrouping;
+                }, false);
+            }
+
+            // Clear ordinal slope, so we won't accidentaly use the old one (#7827)
+            this.ordinalSlope = null;
+
+            if (redraw) {
+                this.chart.redraw();
+            }
+        };
+
+        H.dataGrouping = dataGrouping;
+
+        /* ************************************************************************** *
+         *  End data grouping module                                                  *
+         * ************************************************************************** */
+
+        return dataGrouping;
+    }(Highcharts));
+    return (function (dataGrouping) {
+
+
+        return dataGrouping;
+    }(dataGrouping));
+}));