highcharts-rails 6.0.1 → 6.0.2

data/app/assets/javascripts/highcharts/modules/broken-axis.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  *
  * (c) 2009-2017 Torstein Honsi
  *

data/app/assets/javascripts/highcharts/modules/bullet.js

@@ -1,5 +1,5 @@
 /**
- * @license  Highcharts JS v6.0.1 (2017-10-05)
+ * @license  Highcharts JS v6.0.2 (2017-10-20)
  *
  * Bullet graph series type for Highcharts
  *

data/app/assets/javascripts/highcharts/modules/data.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  * Data module
  *
  * (c) 2012-2017 Torstein Honsi
@@ -495,7 +495,7 @@
              */
             parseCSV: function(inOptions) {
                 var self = this,
-                    options = this.options || inOptions,
+                    options = inOptions || this.options,
                     csv = options.csv,
                     columns,
                     startRow = options.startRow || 0,
@@ -515,7 +515,7 @@
                         '\t': 0
                     };
 
-                columns = this.columns = this.columns || [];
+                columns = this.columns = [];
 
                 /*
                 	This implementation is quite verbose. It will be shortened once
@@ -562,6 +562,7 @@
                         cl = '',
                         cn = '',
                         token = '',
+                        actualColumn = 0,
                         column = 0;
 
                     function read(j) {
@@ -580,8 +581,10 @@
                     }
 
                     function push() {
-                        if (startColumn > column || column > endColumn) {
-                            // Skip this column
+                        if (startColumn > actualColumn || actualColumn > endColumn) {
+                            // Skip this column, but increment the column count (#7272)
+                            ++actualColumn;
+                            token = '';
                             return;
                         }
 
@@ -595,16 +598,20 @@
                             pushType('string');
                         }
 
+
                         if (columns.length < column + 1) {
                             columns.push([]);
                         }
 
                         if (!noAdd) {
-                            columns[column].push(token);
+                            // Don't push - if there's a varrying amount of columns
+                            // for each row, pushing will skew everything down n slots
+                            columns[column][rowNumber] = token;
                         }
 
                         token = '';
                         ++column;
+                        ++actualColumn;
                     }
 
                     if (!columnStr.trim().length) {
@@ -621,6 +628,7 @@
                         // Quoted string
                         if (c === '#') {
                             // The rest of the row is a comment
+                            push();
                             return;
                         } else if (c === '"') {
                             read(++i);
@@ -655,66 +663,87 @@
 
                     push();
 
-                    if (column < columns.length) {
-                        // There might be an issue.
-                        // This set is either
-
-                        // Fill in
-                        if (!noAdd) {
-                            for (var z = column; z < columns.length; z++) {
-                                columns[z].push(0);
-                            }
-                        }
-                    }
                 }
 
                 // Attempt to guess the delimiter
+                // We do a separate parse pass here because we need
+                // to count potential delimiters softly without making any assumptions.
                 function guessDelimiter(lines) {
                     var points = 0,
                         commas = 0,
-                        guessed = false,
-                        handler = function(c, token) {
+                        guessed = false;
+
+                    some(lines, function(columnStr, i) {
+                        var inStr = false,
+                            c,
+                            cn,
+                            cl,
+                            token = '';
+
+
+                        // We should be able to detect dateformats within 13 rows
+                        if (i > 13) {
+                            return true;
+                        }
+
+                        for (var j = 0; j < columnStr.length; j++) {
+                            c = columnStr[j];
+                            cn = columnStr[j + 1];
+                            cl = columnStr[j - 1];
+
+                            if (c === '#') {
+                                // Skip the rest of the line - it's a comment
+                                return;
+                            } else if (c === '"') {
+                                if (inStr) {
+                                    if (cl !== '"' && cn !== '"') {
+                                        while (cn === ' ' && j < columnStr.length) {
+                                            cn = columnStr[++j];
+                                        }
+
+                                        // After parsing a string, the next non-blank
+                                        // should be a delimiter if the CSV is properly
+                                        // formed.
+
+                                        if (typeof potDelimiters[cn] !== 'undefined') {
+                                            potDelimiters[cn]++;
+                                        }
+
+                                        inStr = false;
+                                    }
+                                } else {
+                                    inStr = true;
+                                }
+                            } else if (typeof potDelimiters[c] !== 'undefined') {
+
+                                token = token.trim();
+
+                                if (!isNaN(Date.parse(token))) {
+                                    potDelimiters[c]++;
+                                } else if (isNaN(token) || !isFinite(token)) {
+                                    potDelimiters[c]++;
+                                }
+
+                                token = '';
+
+                            } else {
+                                token += c;
+                            }
+
                             if (c === ',') {
                                 commas++;
                             }
+
                             if (c === '.') {
                                 points++;
                             }
-
-                            if (typeof potDelimiters[c] !== 'undefined') {
-                                // Check what we have in token now
-
-                                if (
-                                    // We can't make a deduction when token is a number,
-                                    // since the decimal delimiter may interfere.
-                                    (isNaN(parseFloat(token)) || !isFinite(token)) &&
-                                    (
-                                        // Highcharts.isString(token) ||
-                                        !isNaN(Date.parse(token))
-                                    )
-                                ) {
-                                    potDelimiters[c]++;
-                                    return true;
-                                }
-                            }
-                        },
-                        callbacks = {
-                            ';': handler,
-                            ',': handler,
-                            '\t': handler
-                        };
-
-                    some(lines, function(columnStr, i) {
-                        // We should be able to detect dateformats within 13 rows
-                        if (i > 13) {
-                            return true;
                         }
-                        parseRow(columnStr, i, true, callbacks);
                     });
 
                     // Count the potential delimiters.
                     // This could be improved by checking if the number of delimiters
                     // equals the number of columns - 1
+
                     if (potDelimiters[';'] > potDelimiters[',']) {
                         guessed = ';';
                     } else if (potDelimiters[','] > potDelimiters[';']) {
@@ -868,8 +897,8 @@
                         startRow = 0;
                     }
 
-                    if (!endRow || endRow > lines.length) {
-                        endRow = lines.length;
+                    if (!endRow || endRow >= lines.length) {
+                        endRow = lines.length - 1;
                     }
 
                     if (options.itemDelimiter) {
@@ -879,8 +908,14 @@
                         itemDelimiter = guessDelimiter(lines);
                     }
 
-                    for (rowIt = startRow; rowIt < endRow; rowIt++) {
-                        parseRow(lines[rowIt], rowIt);
+                    var offset = 0;
+
+                    for (rowIt = startRow; rowIt <= endRow; rowIt++) {
+                        if (lines[rowIt][0] === '#') {
+                            offset++;
+                        } else {
+                            parseRow(lines[rowIt], rowIt - startRow - offset);
+                        }
                     }
 
                     // //Make sure that there's header columns for everything
@@ -1191,13 +1226,7 @@
              */
             dateFormats: {
                 'YYYY-mm-dd': {
-                    regex: /^([0-9]{4})[\-\/\.]([0-9]{2})[\-\/\.]([0-9]{2})$/,
-                    parser: function(match) {
-                        return Date.UTC(+match[1], match[2] - 1, +match[3]);
-                    }
-                },
-                'YYYY/mm/dd': {
-                    regex: /^([0-9]{4})[\-\/\.]([0-9]{2})[\-\/\.]([0-9]{2})$/,
+                    regex: /^([0-9]{4})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{1,2})$/,
                     parser: function(match) {
                         return Date.UTC(+match[1], match[2] - 1, +match[3]);
                     }

data/app/assets/javascripts/highcharts/modules/drag-panes.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  * Drag-panes module
  *
  * (c) 2010-2017 Highsoft AS

data/app/assets/javascripts/highcharts/modules/drilldown.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  * Highcharts Drilldown module
  * 
  * Author: Torstein Honsi
@@ -448,7 +448,8 @@
                     xMax: xAxis && xAxis.userMax,
                     yMin: yAxis && yAxis.userMin,
                     yMax: yAxis && yAxis.userMax
-                }
+                },
+                resetZoomButton: this.resetZoomButton
             }, colorProp);
 
             // Push it to the lookup array
@@ -490,6 +491,14 @@
                     }
                 });
             }
+
+            // We have a reset zoom button. Hide it and detatch it from the chart. It
+            // is preserved to the layer config above.
+            if (this.resetZoomButton) {
+                this.resetZoomButton.hide();
+                delete this.resetZoomButton;
+            }
+
             this.pointer.reset();
             this.redraw();
             this.showDrillUpButton();
@@ -623,6 +632,13 @@
                         newSeries.xAxis.setExtremes(oldExtremes.xMin, oldExtremes.xMax, false);
                         newSeries.yAxis.setExtremes(oldExtremes.yMin, oldExtremes.yMax, false);
                     }
+
+                    // We have a resetZoomButton tucked away for this level. Attatch
+                    // it to the chart and show it.
+                    if (level.resetZoomButton) {
+                        chart.resetZoomButton = level.resetZoomButton;
+                        chart.resetZoomButton.show();
+                    }
                 }
             }
 
@@ -643,6 +659,13 @@
             this.ddDupes.length = []; // #3315
         };
 
+        // Don't show the reset button if we already are displaying the drillUp button.
+        wrap(Chart.prototype, 'showResetZoom', function(proceed) {
+            if (!this.drillUpButton) {
+                proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+            }
+        });
+
 
         /**
          * When drilling up, keep the upper series invisible until the lower series has

data/app/assets/javascripts/highcharts/modules/export-data.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  * Exporting module
  *
  * (c) 2010-2017 Torstein Honsi
@@ -120,7 +120,11 @@
         // Add an event listener to handle the showTable option
         Highcharts.Chart.prototype.callbacks.push(function(chart) {
             Highcharts.addEvent(chart, 'render', function() {
-                if (chart.options.exporting.showTable) {
+                if (
+                    chart.options &&
+                    chart.options.exporting &&
+                    chart.options.exporting.showTable
+                ) {
                     chart.viewData();
                 }
             });

data/app/assets/javascripts/highcharts/modules/exporting.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  * Exporting module
  *
  * (c) 2010-2017 Torstein Honsi

data/app/assets/javascripts/highcharts/modules/funnel.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  * Highcharts funnel module
  *
  * (c) 2010-2017 Torstein Honsi

data/app/assets/javascripts/highcharts/modules/gantt.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  * Gantt series
  *
  * (c) 2016 Lars A. V. Cabrera
@@ -583,7 +583,7 @@
          * @excluding boostThreshold,crisp,cropThreshold,depth,edgeColor,edgeWidth,
          *         findNearestPointBy,getExtremesFromAll,grouping,groupPadding,
          *         negativeColor,pointInterval,pointIntervalUnit,pointPlacement,
-         *         pointRange,pointStart,softThreshold,stacking,threshold
+         *         pointRange,pointStart,softThreshold,stacking,threshold,data
          * @product highcharts
          * @sample {highcharts} highcharts/demo/x-range/
          *         X-range

data/app/assets/javascripts/highcharts/modules/grid-axis.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  * GridAxis
  *
  * (c) 2016 Lars A. V. Cabrera

data/app/assets/javascripts/highcharts/modules/heatmap.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  *
  * (c) 2009-2017 Torstein Honsi
  *
@@ -33,949 +33,954 @@
             pick = H.pick,
             wrap = H.wrap;
 
-        /**
-         * The ColorAxis object for inclusion in gradient legends
-         */
-        ColorAxis = H.ColorAxis = function() {
-            this.init.apply(this, arguments);
-        };
-        extend(ColorAxis.prototype, Axis.prototype);
-        extend(ColorAxis.prototype, {
+        // If ColorAxis already exists, we may be loading the heatmap module on top of
+        // Highmaps.
+        if (!H.ColorAxis) {
+
             /**
-             * A color axis for choropleth maps and heat maps. Visually, the color axis
-             * will appear as a gradient or as separate items inside the legend,
-             * depending on whether the axis is scalar or based on data classes.
-             *
-             * For supported color formats, see the 
-             * [docs article about colors](http://www.highcharts.com/docs/chart-design-and-style/colors).
-             *
-             * A scalar color axis is represented by a gradient. The colors either range
-             * between the [minColor](#colorAxis.minColor) and the [maxColor](#colorAxis.maxColor),
-             * or for more fine grained control the colors can be
-             * defined in [stops](#colorAxis.stops). Often times, the color axis needs
-             * to be adjusted to get the right color spread for the data. In addition to
-             * stops, consider using a logarithmic [axis type](#colorAxis.type), or
-             * setting [min](#colorAxis.min) and [max](#colorAxis.max) to avoid the
-             * colors being determined by outliers.
-             *
-             * When [dataClasses](#colorAxis.dataClasses) are used, the ranges are
-             * subdivided into separate classes like categories based on their values.
-             * This can be used for ranges between two values, but also for a true
-             * category. However, when your data is categorized, it may be as convenient
-             * to add each category to a separate series.
-             *
-             * See [the Axis object](#Axis) for programmatic access to the axis.
-             * @extends {xAxis}
-             * @excluding allowDecimals,alternateGridColor,breaks,categories,crosshair,
-             *            dateTimeLabelFormats,lineWidth,linkedTo,maxZoom,minRange,
-             *            minTickInterval,offset,opposite,plotBands,plotLines,showEmpty,
-             *            title
-             * @product highcharts highmaps
-             * @optionparent colorAxis
+             * The ColorAxis object for inclusion in gradient legends
              */
-            defaultColorAxisOptions: {
-
+            ColorAxis = H.ColorAxis = function() {
+                this.init.apply(this, arguments);
+            };
+            extend(ColorAxis.prototype, Axis.prototype);
+            extend(ColorAxis.prototype, {
                 /**
-                 * Whether to allow decimals on the color axis.
-                 * @type {Boolean}
-                 * @default true
+                 * A color axis for choropleth maps and heat maps. Visually, the color axis
+                 * will appear as a gradient or as separate items inside the legend,
+                 * depending on whether the axis is scalar or based on data classes.
+                 *
+                 * For supported color formats, see the 
+                 * [docs article about colors](http://www.highcharts.com/docs/chart-design-and-style/colors).
+                 *
+                 * A scalar color axis is represented by a gradient. The colors either range
+                 * between the [minColor](#colorAxis.minColor) and the [maxColor](#colorAxis.maxColor),
+                 * or for more fine grained control the colors can be
+                 * defined in [stops](#colorAxis.stops). Often times, the color axis needs
+                 * to be adjusted to get the right color spread for the data. In addition to
+                 * stops, consider using a logarithmic [axis type](#colorAxis.type), or
+                 * setting [min](#colorAxis.min) and [max](#colorAxis.max) to avoid the
+                 * colors being determined by outliers.
+                 *
+                 * When [dataClasses](#colorAxis.dataClasses) are used, the ranges are
+                 * subdivided into separate classes like categories based on their values.
+                 * This can be used for ranges between two values, but also for a true
+                 * category. However, when your data is categorized, it may be as convenient
+                 * to add each category to a separate series.
+                 *
+                 * See [the Axis object](#Axis) for programmatic access to the axis.
+                 * @extends {xAxis}
+                 * @excluding allowDecimals,alternateGridColor,breaks,categories,crosshair,
+                 *            dateTimeLabelFormats,lineWidth,linkedTo,maxZoom,minRange,
+                 *            minTickInterval,offset,opposite,plotBands,plotLines,showEmpty,
+                 *            title
                  * @product highcharts highmaps
-                 * @apioption colorAxis.allowDecimals
+                 * @optionparent colorAxis
                  */
+                defaultColorAxisOptions: {
 
-                /**
-                 * Determines how to set each data class' color if no individual color
-                 * is set. The default value, `tween`, computes intermediate colors
-                 * between `minColor` and `maxColor`. The other possible value, `category`,
-                 * pulls colors from the global or chart specific [colors](#colors)
-                 * array.
-                 * 
-                 * @validvalue ["tween", "category"]
-                 * @type {String}
-                 * @sample {highmaps} maps/coloraxis/dataclasscolor/ Category colors
-                 * @default tween
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.dataClassColor
-                 */
+                    /**
+                     * Whether to allow decimals on the color axis.
+                     * @type {Boolean}
+                     * @default true
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.allowDecimals
+                     */
 
-                /**
-                 * An array of data classes or ranges for the choropleth map. If none
-                 * given, the color axis is scalar and values are distributed as a gradient
-                 * between the minimum and maximum colors.
-                 * 
-                 * @type {Array<Object>}
-                 * @sample {highmaps} maps/demo/data-class-ranges/ Multiple ranges
-                 * @sample {highmaps} maps/demo/data-class-two-ranges/ Two ranges
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.dataClasses
-                 */
+                    /**
+                     * Determines how to set each data class' color if no individual color
+                     * is set. The default value, `tween`, computes intermediate colors
+                     * between `minColor` and `maxColor`. The other possible value, `category`,
+                     * pulls colors from the global or chart specific [colors](#colors)
+                     * array.
+                     * 
+                     * @validvalue ["tween", "category"]
+                     * @type {String}
+                     * @sample {highmaps} maps/coloraxis/dataclasscolor/ Category colors
+                     * @default tween
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.dataClassColor
+                     */
 
-                /**
-                 * The color of each data class. If not set, the color is pulled from
-                 * the global or chart-specific [colors](#colors) array. In 
-                 * styled mode, this option is ignored. Instead, use colors defined in
-                 * CSS.
-                 * 
-                 * @type {Color}
-                 * @sample {highmaps} maps/demo/data-class-two-ranges/ Explicit colors
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.dataClasses.color
-                 */
+                    /**
+                     * An array of data classes or ranges for the choropleth map. If none
+                     * given, the color axis is scalar and values are distributed as a gradient
+                     * between the minimum and maximum colors.
+                     * 
+                     * @type {Array<Object>}
+                     * @sample {highmaps} maps/demo/data-class-ranges/ Multiple ranges
+                     * @sample {highmaps} maps/demo/data-class-two-ranges/ Two ranges
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.dataClasses
+                     */
 
-                /**
-                 * The start of the value range that the data class represents, relating
-                 * to the point value.
-                 * 
-                 * @type {Number}
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.dataClasses.from
-                 */
+                    /**
+                     * The color of each data class. If not set, the color is pulled from
+                     * the global or chart-specific [colors](#colors) array. In 
+                     * styled mode, this option is ignored. Instead, use colors defined in
+                     * CSS.
+                     * 
+                     * @type {Color}
+                     * @sample {highmaps} maps/demo/data-class-two-ranges/ Explicit colors
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.dataClasses.color
+                     */
 
-                /**
-                 * The name of the data class as it appears in the legend. If no name
-                 * is given, it is automatically created based on the `from` and `to`
-                 * values. For full programmatic control, [legend.labelFormatter](#legend.
-                 * labelFormatter) can be used. In the formatter, `this.from` and `this.
-                 * to` can be accessed.
-                 * 
-                 * @type {String}
-                 * @sample {highmaps} maps/coloraxis/dataclasses-name/ Named data classes
-                 * @sample {highmaps} maps/coloraxis/dataclasses-labelformatter/ Formatted data classes
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.dataClasses.name
-                 */
+                    /**
+                     * The start of the value range that the data class represents, relating
+                     * to the point value.
+                     * 
+                     * @type {Number}
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.dataClasses.from
+                     */
 
-                /**
-                 * The end of the value range that the data class represents, relating
-                 * to the point value.
-                 * 
-                 * @type {Number}
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.dataClasses.to
-                 */
+                    /**
+                     * The name of the data class as it appears in the legend. If no name
+                     * is given, it is automatically created based on the `from` and `to`
+                     * values. For full programmatic control, [legend.labelFormatter](#legend.
+                     * labelFormatter) can be used. In the formatter, `this.from` and `this.
+                     * to` can be accessed.
+                     * 
+                     * @type {String}
+                     * @sample {highmaps} maps/coloraxis/dataclasses-name/ Named data classes
+                     * @sample {highmaps} maps/coloraxis/dataclasses-labelformatter/ Formatted data classes
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.dataClasses.name
+                     */
 
-                /** @ignore */
-                lineWidth: 0,
+                    /**
+                     * The end of the value range that the data class represents, relating
+                     * to the point value.
+                     * 
+                     * @type {Number}
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.dataClasses.to
+                     */
 
-                /**
-                 * Padding of the min value relative to the length of the axis. A
-                 * padding of 0.05 will make a 100px axis 5px longer.
-                 * 
-                 * @type {Number}
-                 * @product highcharts highmaps
-                 */
-                minPadding: 0,
+                    /** @ignore */
+                    lineWidth: 0,
 
-                /**
-                 * The maximum value of the axis in terms of map point values. If `null`,
-                 * the max value is automatically calculated. If the `endOnTick` option
-                 * is true, the max value might be rounded up.
-                 * 
-                 * @type {Number}
-                 * @sample {highmaps} maps/coloraxis/gridlines/
-                 *         Explicit min and max to reduce the effect of outliers
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.max
-                 */
+                    /**
+                     * Padding of the min value relative to the length of the axis. A
+                     * padding of 0.05 will make a 100px axis 5px longer.
+                     * 
+                     * @type {Number}
+                     * @product highcharts highmaps
+                     */
+                    minPadding: 0,
 
-                /**
-                 * The minimum value of the axis in terms of map point values. If `null`,
-                 * the min value is automatically calculated. If the `startOnTick`
-                 * option is true, the min value might be rounded down.
-                 * 
-                 * @type {Number}
-                 * @sample {highmaps} maps/coloraxis/gridlines/
-                 *         Explicit min and max to reduce the effect of outliers
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.min
-                 */
+                    /**
+                     * The maximum value of the axis in terms of map point values. If `null`,
+                     * the max value is automatically calculated. If the `endOnTick` option
+                     * is true, the max value might be rounded up.
+                     * 
+                     * @type {Number}
+                     * @sample {highmaps} maps/coloraxis/gridlines/
+                     *         Explicit min and max to reduce the effect of outliers
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.max
+                     */
 
-                /**
-                 * Padding of the max value relative to the length of the axis. A
-                 * padding of 0.05 will make a 100px axis 5px longer.
-                 * 
-                 * @type {Number}
-                 * @product highcharts highmaps
-                 */
-                maxPadding: 0,
+                    /**
+                     * The minimum value of the axis in terms of map point values. If `null`,
+                     * the min value is automatically calculated. If the `startOnTick`
+                     * option is true, the min value might be rounded down.
+                     * 
+                     * @type {Number}
+                     * @sample {highmaps} maps/coloraxis/gridlines/
+                     *         Explicit min and max to reduce the effect of outliers
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.min
+                     */
 
-                /**
-                 * Color of the grid lines extending from the axis across the gradient.
-                 * 
-                 * @type {Color}
-                 * @sample {highmaps} maps/coloraxis/gridlines/ Grid lines demonstrated
-                 * @default #e6e6e6
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.gridLineColor
-                 */
+                    /**
+                     * Padding of the max value relative to the length of the axis. A
+                     * padding of 0.05 will make a 100px axis 5px longer.
+                     * 
+                     * @type {Number}
+                     * @product highcharts highmaps
+                     */
+                    maxPadding: 0,
 
-                /**
-                 * The width of the grid lines extending from the axis across the
-                 * gradient of a scalar color axis.
-                 * 
-                 * @type {Number}
-                 * @sample {highmaps} maps/coloraxis/gridlines/ Grid lines demonstrated
-                 * @default 1
-                 * @product highcharts highmaps
-                 */
-                gridLineWidth: 1,
+                    /**
+                     * Color of the grid lines extending from the axis across the gradient.
+                     * 
+                     * @type {Color}
+                     * @sample {highmaps} maps/coloraxis/gridlines/ Grid lines demonstrated
+                     * @default #e6e6e6
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.gridLineColor
+                     */
 
-                /**
-                 * The interval of the tick marks in axis units. When `null`, the tick
-                 * interval is computed to approximately follow the `tickPixelInterval`.
-                 * 
-                 * @type {Number}
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.tickInterval
-                 */
+                    /**
+                     * The width of the grid lines extending from the axis across the
+                     * gradient of a scalar color axis.
+                     * 
+                     * @type {Number}
+                     * @sample {highmaps} maps/coloraxis/gridlines/ Grid lines demonstrated
+                     * @default 1
+                     * @product highcharts highmaps
+                     */
+                    gridLineWidth: 1,
 
-                /**
-                 * If [tickInterval](#colorAxis.tickInterval) is `null` this option
-                 * sets the approximate pixel interval of the tick marks.
-                 * 
-                 * @type {Number}
-                 * @default 72
-                 * @product highcharts highmaps
-                 */
-                tickPixelInterval: 72,
+                    /**
+                     * The interval of the tick marks in axis units. When `null`, the tick
+                     * interval is computed to approximately follow the `tickPixelInterval`.
+                     * 
+                     * @type {Number}
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.tickInterval
+                     */
 
-                /**
-                 * Whether to force the axis to start on a tick. Use this option with
-                 * the `maxPadding` option to control the axis start.
-                 * 
-                 * @type {Boolean}
-                 * @default true
-                 * @product highcharts highmaps
-                 */
-                startOnTick: true,
+                    /**
+                     * If [tickInterval](#colorAxis.tickInterval) is `null` this option
+                     * sets the approximate pixel interval of the tick marks.
+                     * 
+                     * @type {Number}
+                     * @default 72
+                     * @product highcharts highmaps
+                     */
+                    tickPixelInterval: 72,
 
-                /**
-                 * Whether to force the axis to end on a tick. Use this option with
-                 * the [maxPadding](#colorAxis.maxPadding) option to control the axis
-                 * end.
-                 * 
-                 * @type {Boolean}
-                 * @default true
-                 * @product highcharts highmaps
-                 */
-                endOnTick: true,
+                    /**
+                     * Whether to force the axis to start on a tick. Use this option with
+                     * the `maxPadding` option to control the axis start.
+                     * 
+                     * @type {Boolean}
+                     * @default true
+                     * @product highcharts highmaps
+                     */
+                    startOnTick: true,
 
-                /**	@ignore */
-                offset: 0,
+                    /**
+                     * Whether to force the axis to end on a tick. Use this option with
+                     * the [maxPadding](#colorAxis.maxPadding) option to control the axis
+                     * end.
+                     * 
+                     * @type {Boolean}
+                     * @default true
+                     * @product highcharts highmaps
+                     */
+                    endOnTick: true,
 
-                /**
-                 * The triangular marker on a scalar color axis that points to the
-                 * value of the hovered area. To disable the marker, set `marker:
-                 * null`.
-                 * 
-                 * @type {Object}
-                 * @sample {highmaps} maps/coloraxis/marker/ Black marker
-                 * @product highcharts highmaps
-                 */
-                marker: {
+                    /**	@ignore */
+                    offset: 0,
 
                     /**
-                     * Animation for the marker as it moves between values. Set to `false`
-                     * to disable animation. Defaults to `{ duration: 50 }`.
+                     * The triangular marker on a scalar color axis that points to the
+                     * value of the hovered area. To disable the marker, set `marker:
+                     * null`.
                      * 
-                     * @type {Object|Boolean}
+                     * @type {Object}
+                     * @sample {highmaps} maps/coloraxis/marker/ Black marker
                      * @product highcharts highmaps
                      */
-                    animation: {
-                        duration: 50
+                    marker: {
+
+                        /**
+                         * Animation for the marker as it moves between values. Set to `false`
+                         * to disable animation. Defaults to `{ duration: 50 }`.
+                         * 
+                         * @type {Object|Boolean}
+                         * @product highcharts highmaps
+                         */
+                        animation: {
+                            duration: 50
+                        },
+
+                        /** @ignore */
+                        width: 0.01,
+
+
+                        /**
+                         * The color of the marker.
+                         * 
+                         * @type {Color}
+                         * @default #999999
+                         * @product highcharts highmaps
+                         */
+                        color: '#999999'
+
                     },
 
-                    /** @ignore */
-                    width: 0.01,
+                    /**
+                     * The axis labels show the number for each tick.
+                     * 
+                     * For more live examples on label options, see [xAxis.labels in the
+                     * Highcharts API.](/highcharts#xAxis.labels)
+                     * 
+                     * @type {Object}
+                     * @extends xAxis.labels
+                     * @product highcharts highmaps
+                     */
+                    labels: {
+
+                        /**
+                         * How to handle overflowing labels on horizontal color axis. Can be
+                         * undefined or "justify". If "justify", labels will not render
+                         * outside the legend area. If there is room to move it, it will be
+                         * aligned to the edge, else it will be removed.
+                         * 
+                         * @validvalue [null, "justify"]
+                         * @type {String}
+                         * @default justify
+                         * @product highcharts highmaps
+                         */
+                        overflow: 'justify',
+
+                        rotation: 0
+                    },
 
+                    /**
+                     * The color to represent the minimum of the color axis. Unless [dataClasses](#colorAxis.
+                     * dataClasses) or [stops](#colorAxis.stops) are set, the gradient
+                     * starts at this value.
+                     * 
+                     * If dataClasses are set, the color is based on minColor and maxColor
+                     * unless a color is set for each data class, or the [dataClassColor](#colorAxis.
+                     * dataClassColor) is set.
+                     * 
+                     * @type {Color}
+                     * @sample {highmaps} maps/coloraxis/mincolor-maxcolor/ Min and max colors on scalar (gradient) axis
+                     * @sample {highmaps} maps/coloraxis/mincolor-maxcolor-dataclasses/ On data classes
+                     * @default #e6ebf5
+                     * @product highcharts highmaps
+                     */
+                    minColor: '#e6ebf5',
 
                     /**
-                     * The color of the marker.
+                     * The color to represent the maximum of the color axis. Unless [dataClasses](#colorAxis.
+                     * dataClasses) or [stops](#colorAxis.stops) are set, the gradient
+                     * ends at this value.
+                     * 
+                     * If dataClasses are set, the color is based on minColor and maxColor
+                     * unless a color is set for each data class, or the [dataClassColor](#colorAxis.
+                     * dataClassColor) is set.
                      * 
                      * @type {Color}
-                     * @default #999999
+                     * @sample {highmaps} maps/coloraxis/mincolor-maxcolor/ Min and max colors on scalar (gradient) axis
+                     * @sample {highmaps} maps/coloraxis/mincolor-maxcolor-dataclasses/ On data classes
+                     * @default #003399
                      * @product highcharts highmaps
                      */
-                    color: '#999999'
+                    maxColor: '#003399',
 
-                },
+                    /**
+                     * Color stops for the gradient of a scalar color axis. Use this in
+                     * cases where a linear gradient between a `minColor` and `maxColor`
+                     * is not sufficient. The stops is an array of tuples, where the first
+                     * item is a float between 0 and 1 assigning the relative position in
+                     * the gradient, and the second item is the color.
+                     * 
+                     * @type {Array<Array>}
+                     * @sample {highmaps} maps/demo/heatmap/ Heatmap with three color stops
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.stops
+                     */
 
-                /**
-                 * The axis labels show the number for each tick.
-                 * 
-                 * For more live examples on label options, see [xAxis.labels in the
-                 * Highcharts API.](/highcharts#xAxis.labels)
-                 * 
-                 * @type {Object}
-                 * @extends xAxis.labels
-                 * @product highcharts highmaps
-                 */
-                labels: {
+                    /**
+                     * The pixel length of the main tick marks on the color axis.
+                     */
+                    tickLength: 5,
 
                     /**
-                     * How to handle overflowing labels on horizontal color axis. Can be
-                     * undefined or "justify". If "justify", labels will not render
-                     * outside the legend area. If there is room to move it, it will be
-                     * aligned to the edge, else it will be removed.
+                     * The type of interpolation to use for the color axis. Can be `linear`
+                     * or `logarithmic`.
                      * 
-                     * @validvalue [null, "justify"]
+                     * @validvalue ["linear", "logarithmic"]
                      * @type {String}
-                     * @default justify
+                     * @default linear
+                     * @product highcharts highmaps
+                     * @apioption colorAxis.type
+                     */
+
+                    /**
+                     * Whether to reverse the axis so that the highest number is closest
+                     * to the origin. Defaults to `false` in a horizontal legend and `true`
+                     * in a vertical legend, where the smallest value starts on top.
+                     * 
+                     * @type {Boolean}
                      * @product highcharts highmaps
+                     * @apioption colorAxis.reversed
                      */
-                    overflow: 'justify',
 
-                    rotation: 0
+                    /**
+                     * Whether to display the colorAxis in the legend.
+                     * 
+                     * @type {Boolean}
+                     * @see [heatmap.showInLegend](#series.heatmap.showInLegend)
+                     * @default true
+                     * @since 4.2.7
+                     * @product highcharts highmaps
+                     */
+                    showInLegend: true
                 },
 
-                /**
-                 * The color to represent the minimum of the color axis. Unless [dataClasses](#colorAxis.
-                 * dataClasses) or [stops](#colorAxis.stops) are set, the gradient
-                 * starts at this value.
-                 * 
-                 * If dataClasses are set, the color is based on minColor and maxColor
-                 * unless a color is set for each data class, or the [dataClassColor](#colorAxis.
-                 * dataClassColor) is set.
-                 * 
-                 * @type {Color}
-                 * @sample {highmaps} maps/coloraxis/mincolor-maxcolor/ Min and max colors on scalar (gradient) axis
-                 * @sample {highmaps} maps/coloraxis/mincolor-maxcolor-dataclasses/ On data classes
-                 * @default #e6ebf5
-                 * @product highcharts highmaps
-                 */
-                minColor: '#e6ebf5',
+                // Properties to preserve after destroy, for Axis.update (#5881, #6025)
+                keepProps: [
+                    'legendGroup',
+                    'legendItemHeight',
+                    'legendItemWidth',
+                    'legendItem',
+                    'legendSymbol'
+                ].concat(Axis.prototype.keepProps),
 
                 /**
-                 * The color to represent the maximum of the color axis. Unless [dataClasses](#colorAxis.
-                 * dataClasses) or [stops](#colorAxis.stops) are set, the gradient
-                 * ends at this value.
-                 * 
-                 * If dataClasses are set, the color is based on minColor and maxColor
-                 * unless a color is set for each data class, or the [dataClassColor](#colorAxis.
-                 * dataClassColor) is set.
-                 * 
-                 * @type {Color}
-                 * @sample {highmaps} maps/coloraxis/mincolor-maxcolor/ Min and max colors on scalar (gradient) axis
-                 * @sample {highmaps} maps/coloraxis/mincolor-maxcolor-dataclasses/ On data classes
-                 * @default #003399
-                 * @product highcharts highmaps
+                 * Initialize the color axis
                  */
-                maxColor: '#003399',
+                init: function(chart, userOptions) {
+                    var horiz = chart.options.legend.layout !== 'vertical',
+                        options;
+
+                    this.coll = 'colorAxis';
+
+                    // Build the options
+                    options = merge(this.defaultColorAxisOptions, {
+                        side: horiz ? 2 : 1,
+                        reversed: !horiz
+                    }, userOptions, {
+                        opposite: !horiz,
+                        showEmpty: false,
+                        title: null
+                    });
 
-                /**
-                 * Color stops for the gradient of a scalar color axis. Use this in
-                 * cases where a linear gradient between a `minColor` and `maxColor`
-                 * is not sufficient. The stops is an array of tuples, where the first
-                 * item is a float between 0 and 1 assigning the relative position in
-                 * the gradient, and the second item is the color.
-                 * 
-                 * @type {Array<Array>}
-                 * @sample {highmaps} maps/demo/heatmap/ Heatmap with three color stops
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.stops
-                 */
+                    Axis.prototype.init.call(this, chart, options);
 
-                /**
-                 * The pixel length of the main tick marks on the color axis.
-                 */
-                tickLength: 5,
+                    // Base init() pushes it to the xAxis array, now pop it again
+                    // chart[this.isXAxis ? 'xAxis' : 'yAxis'].pop();
 
-                /**
-                 * The type of interpolation to use for the color axis. Can be `linear`
-                 * or `logarithmic`.
-                 * 
-                 * @validvalue ["linear", "logarithmic"]
-                 * @type {String}
-                 * @default linear
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.type
-                 */
+                    // Prepare data classes
+                    if (userOptions.dataClasses) {
+                        this.initDataClasses(userOptions);
+                    }
+                    this.initStops();
 
-                /**
-                 * Whether to reverse the axis so that the highest number is closest
-                 * to the origin. Defaults to `false` in a horizontal legend and `true`
-                 * in a vertical legend, where the smallest value starts on top.
-                 * 
-                 * @type {Boolean}
-                 * @product highcharts highmaps
-                 * @apioption colorAxis.reversed
-                 */
+                    // Override original axis properties
+                    this.horiz = horiz;
+                    this.zoomEnabled = false;
 
-                /**
-                 * Whether to display the colorAxis in the legend.
-                 * 
-                 * @type {Boolean}
-                 * @see [heatmap.showInLegend](#series.heatmap.showInLegend)
-                 * @default true
-                 * @since 4.2.7
-                 * @product highcharts highmaps
-                 */
-                showInLegend: true
-            },
+                    // Add default values		
+                    this.defaultLegendLength = 200;
+                },
 
-            // Properties to preserve after destroy, for Axis.update (#5881, #6025)
-            keepProps: [
-                'legendGroup',
-                'legendItemHeight',
-                'legendItemWidth',
-                'legendItem',
-                'legendSymbol'
-            ].concat(Axis.prototype.keepProps),
+                initDataClasses: function(userOptions) {
+                    var chart = this.chart,
+                        dataClasses,
+                        colorCounter = 0,
+                        colorCount = chart.options.chart.colorCount,
+                        options = this.options,
+                        len = userOptions.dataClasses.length;
+                    this.dataClasses = dataClasses = [];
+                    this.legendItems = [];
 
-            /**
-             * Initialize the color axis
-             */
-            init: function(chart, userOptions) {
-                var horiz = chart.options.legend.layout !== 'vertical',
-                    options;
-
-                this.coll = 'colorAxis';
-
-                // Build the options
-                options = merge(this.defaultColorAxisOptions, {
-                    side: horiz ? 2 : 1,
-                    reversed: !horiz
-                }, userOptions, {
-                    opposite: !horiz,
-                    showEmpty: false,
-                    title: null
-                });
+                    each(userOptions.dataClasses, function(dataClass, i) {
+                        var colors;
 
-                Axis.prototype.init.call(this, chart, options);
+                        dataClass = merge(dataClass);
+                        dataClasses.push(dataClass);
 
-                // Base init() pushes it to the xAxis array, now pop it again
-                // chart[this.isXAxis ? 'xAxis' : 'yAxis'].pop();
 
-                // Prepare data classes
-                if (userOptions.dataClasses) {
-                    this.initDataClasses(userOptions);
-                }
-                this.initStops();
+                        if (dataClass.color) {
+                            return;
+                        }
 
-                // Override original axis properties
-                this.horiz = horiz;
-                this.zoomEnabled = false;
+                        if (options.dataClassColor === 'category') {
 
-                // Add default values		
-                this.defaultLegendLength = 200;
-            },
+                            colors = chart.options.colors;
+                            colorCount = colors.length;
+                            dataClass.color = colors[colorCounter];
 
-            initDataClasses: function(userOptions) {
-                var chart = this.chart,
-                    dataClasses,
-                    colorCounter = 0,
-                    colorCount = chart.options.chart.colorCount,
-                    options = this.options,
-                    len = userOptions.dataClasses.length;
-                this.dataClasses = dataClasses = [];
-                this.legendItems = [];
+                            dataClass.colorIndex = colorCounter;
 
-                each(userOptions.dataClasses, function(dataClass, i) {
-                    var colors;
+                            // increase and loop back to zero
+                            colorCounter++;
+                            if (colorCounter === colorCount) {
+                                colorCounter = 0;
+                            }
+                        } else {
+                            dataClass.color = color(options.minColor).tweenTo(
+                                color(options.maxColor),
+                                len < 2 ? 0.5 : i / (len - 1) // #3219
+                            );
+                        }
+                    });
+                },
 
-                    dataClass = merge(dataClass);
-                    dataClasses.push(dataClass);
+                /**
+                 * Override so that ticks are not added in data class axes (#6914)
+                 */
+                setTickPositions: function() {
+                    if (!this.dataClasses) {
+                        return Axis.prototype.setTickPositions.call(this);
+                    }
+                },
 
 
-                    if (dataClass.color) {
-                        return;
-                    }
+                initStops: function() {
+                    this.stops = this.options.stops || [
+                        [0, this.options.minColor],
+                        [1, this.options.maxColor]
+                    ];
+                    each(this.stops, function(stop) {
+                        stop.color = color(stop[1]);
+                    });
+                },
 
-                    if (options.dataClassColor === 'category') {
+                /**
+                 * Extend the setOptions method to process extreme colors and color
+                 * stops.
+                 */
+                setOptions: function(userOptions) {
+                    Axis.prototype.setOptions.call(this, userOptions);
+
+                    this.options.crosshair = this.options.marker;
+                },
 
-                        colors = chart.options.colors;
-                        colorCount = colors.length;
-                        dataClass.color = colors[colorCounter];
+                setAxisSize: function() {
+                    var symbol = this.legendSymbol,
+                        chart = this.chart,
+                        legendOptions = chart.options.legend || {},
+                        x,
+                        y,
+                        width,
+                        height;
+
+                    if (symbol) {
+                        this.left = x = symbol.attr('x');
+                        this.top = y = symbol.attr('y');
+                        this.width = width = symbol.attr('width');
+                        this.height = height = symbol.attr('height');
+                        this.right = chart.chartWidth - x - width;
+                        this.bottom = chart.chartHeight - y - height;
+
+                        this.len = this.horiz ? width : height;
+                        this.pos = this.horiz ? x : y;
+                    } else {
+                        // Fake length for disabled legend to avoid tick issues
+                        // and such (#5205)
+                        this.len = (
+                            this.horiz ?
+                            legendOptions.symbolWidth :
+                            legendOptions.symbolHeight
+                        ) || this.defaultLegendLength;
+                    }
+                },
 
-                        dataClass.colorIndex = colorCounter;
+                normalizedValue: function(value) {
+                    if (this.isLog) {
+                        value = this.val2lin(value);
+                    }
+                    return 1 - ((this.max - value) / ((this.max - this.min) || 1));
+                },
 
-                        // increase and loop back to zero
-                        colorCounter++;
-                        if (colorCounter === colorCount) {
-                            colorCounter = 0;
+                /**
+                 * Translate from a value to a color
+                 */
+                toColor: function(value, point) {
+                    var pos,
+                        stops = this.stops,
+                        from,
+                        to,
+                        color,
+                        dataClasses = this.dataClasses,
+                        dataClass,
+                        i;
+
+                    if (dataClasses) {
+                        i = dataClasses.length;
+                        while (i--) {
+                            dataClass = dataClasses[i];
+                            from = dataClass.from;
+                            to = dataClass.to;
+                            if (
+                                (from === undefined || value >= from) &&
+                                (to === undefined || value <= to)
+                            ) {
+
+                                color = dataClass.color;
+
+                                if (point) {
+                                    point.dataClass = i;
+                                    point.colorIndex = dataClass.colorIndex;
+                                }
+                                break;
+                            }
                         }
+
                     } else {
-                        dataClass.color = color(options.minColor).tweenTo(
-                            color(options.maxColor),
-                            len < 2 ? 0.5 : i / (len - 1) // #3219
+
+                        pos = this.normalizedValue(value);
+                        i = stops.length;
+                        while (i--) {
+                            if (pos > stops[i][0]) {
+                                break;
+                            }
+                        }
+                        from = stops[i] || stops[i + 1];
+                        to = stops[i + 1] || from;
+
+                        // The position within the gradient
+                        pos = 1 - (to[0] - pos) / ((to[0] - from[0]) || 1);
+
+                        color = from.color.tweenTo(
+                            to.color,
+                            pos
                         );
                     }
-                });
-            },
-
-            /**
-             * Override so that ticks are not added in data class axes (#6914)
-             */
-            setTickPositions: function() {
-                if (!this.dataClasses) {
-                    return Axis.prototype.setTickPositions.call(this);
-                }
-            },
+                    return color;
+                },
 
+                /**
+                 * Override the getOffset method to add the whole axis groups inside
+                 * the legend.
+                 */
+                getOffset: function() {
+                    var group = this.legendGroup,
+                        sideOffset = this.chart.axisOffset[this.side];
 
-            initStops: function() {
-                this.stops = this.options.stops || [
-                    [0, this.options.minColor],
-                    [1, this.options.maxColor]
-                ];
-                each(this.stops, function(stop) {
-                    stop.color = color(stop[1]);
-                });
-            },
+                    if (group) {
 
-            /**
-             * Extend the setOptions method to process extreme colors and color
-             * stops.
-             */
-            setOptions: function(userOptions) {
-                Axis.prototype.setOptions.call(this, userOptions);
+                        // Hook for the getOffset method to add groups to this parent group
+                        this.axisParent = group;
 
-                this.options.crosshair = this.options.marker;
-            },
+                        // Call the base
+                        Axis.prototype.getOffset.call(this);
 
-            setAxisSize: function() {
-                var symbol = this.legendSymbol,
-                    chart = this.chart,
-                    legendOptions = chart.options.legend || {},
-                    x,
-                    y,
-                    width,
-                    height;
-
-                if (symbol) {
-                    this.left = x = symbol.attr('x');
-                    this.top = y = symbol.attr('y');
-                    this.width = width = symbol.attr('width');
-                    this.height = height = symbol.attr('height');
-                    this.right = chart.chartWidth - x - width;
-                    this.bottom = chart.chartHeight - y - height;
-
-                    this.len = this.horiz ? width : height;
-                    this.pos = this.horiz ? x : y;
-                } else {
-                    // Fake length for disabled legend to avoid tick issues
-                    // and such (#5205)
-                    this.len = (
-                        this.horiz ?
-                        legendOptions.symbolWidth :
-                        legendOptions.symbolHeight
-                    ) || this.defaultLegendLength;
-                }
-            },
+                        // First time only
+                        if (!this.added) {
 
-            normalizedValue: function(value) {
-                if (this.isLog) {
-                    value = this.val2lin(value);
-                }
-                return 1 - ((this.max - value) / ((this.max - this.min) || 1));
-            },
+                            this.added = true;
 
-            /**
-             * Translate from a value to a color
-             */
-            toColor: function(value, point) {
-                var pos,
-                    stops = this.stops,
-                    from,
-                    to,
-                    color,
-                    dataClasses = this.dataClasses,
-                    dataClass,
-                    i;
-
-                if (dataClasses) {
-                    i = dataClasses.length;
-                    while (i--) {
-                        dataClass = dataClasses[i];
-                        from = dataClass.from;
-                        to = dataClass.to;
-                        if (
-                            (from === undefined || value >= from) &&
-                            (to === undefined || value <= to)
-                        ) {
-
-                            color = dataClass.color;
-
-                            if (point) {
-                                point.dataClass = i;
-                                point.colorIndex = dataClass.colorIndex;
-                            }
-                            break;
+                            this.labelLeft = 0;
+                            this.labelRight = this.width;
                         }
+                        // Reset it to avoid color axis reserving space
+                        this.chart.axisOffset[this.side] = sideOffset;
                     }
+                },
+
+                /**
+                 * Create the color gradient
+                 */
+                setLegendColor: function() {
+                    var grad,
+                        horiz = this.horiz,
+                        reversed = this.reversed,
+                        one = reversed ? 1 : 0,
+                        zero = reversed ? 0 : 1;
+
+                    grad = horiz ? [one, 0, zero, 0] : [0, zero, 0, one]; // #3190
+                    this.legendColor = {
+                        linearGradient: {
+                            x1: grad[0],
+                            y1: grad[1],
+                            x2: grad[2],
+                            y2: grad[3]
+                        },
+                        stops: this.stops
+                    };
+                },
+
+                /**
+                 * The color axis appears inside the legend and has its own legend symbol
+                 */
+                drawLegendSymbol: function(legend, item) {
+                    var padding = legend.padding,
+                        legendOptions = legend.options,
+                        horiz = this.horiz,
+                        width = pick(
+                            legendOptions.symbolWidth,
+                            horiz ? this.defaultLegendLength : 12
+                        ),
+                        height = pick(
+                            legendOptions.symbolHeight,
+                            horiz ? 12 : this.defaultLegendLength
+                        ),
+                        labelPadding = pick(legendOptions.labelPadding, horiz ? 16 : 30),
+                        itemDistance = pick(legendOptions.itemDistance, 10);
 
-                } else {
+                    this.setLegendColor();
 
-                    pos = this.normalizedValue(value);
-                    i = stops.length;
+                    // Create the gradient
+                    item.legendSymbol = this.chart.renderer.rect(
+                        0,
+                        legend.baseline - 11,
+                        width,
+                        height
+                    ).attr({
+                        zIndex: 1
+                    }).add(item.legendGroup);
+
+                    // Set how much space this legend item takes up
+                    this.legendItemWidth = width + padding +
+                        (horiz ? itemDistance : labelPadding);
+                    this.legendItemHeight = height + padding + (horiz ? labelPadding : 0);
+                },
+                /**
+                 * Fool the legend
+                 */
+                setState: noop,
+                visible: true,
+                setVisible: noop,
+                getSeriesExtremes: function() {
+                    var series = this.series,
+                        i = series.length;
+                    this.dataMin = Infinity;
+                    this.dataMax = -Infinity;
                     while (i--) {
-                        if (pos > stops[i][0]) {
-                            break;
+                        if (series[i].valueMin !== undefined) {
+                            this.dataMin = Math.min(this.dataMin, series[i].valueMin);
+                            this.dataMax = Math.max(this.dataMax, series[i].valueMax);
                         }
                     }
-                    from = stops[i] || stops[i + 1];
-                    to = stops[i + 1] || from;
+                },
+                drawCrosshair: function(e, point) {
+                    var plotX = point && point.plotX,
+                        plotY = point && point.plotY,
+                        crossPos,
+                        axisPos = this.pos,
+                        axisLen = this.len;
+
+                    if (point) {
+                        crossPos = this.toPixels(point[point.series.colorKey]);
+                        if (crossPos < axisPos) {
+                            crossPos = axisPos - 2;
+                        } else if (crossPos > axisPos + axisLen) {
+                            crossPos = axisPos + axisLen + 2;
+                        }
 
-                    // The position within the gradient
-                    pos = 1 - (to[0] - pos) / ((to[0] - from[0]) || 1);
+                        point.plotX = crossPos;
+                        point.plotY = this.len - crossPos;
+                        Axis.prototype.drawCrosshair.call(this, e, point);
+                        point.plotX = plotX;
+                        point.plotY = plotY;
 
-                    color = from.color.tweenTo(
-                        to.color,
-                        pos
-                    );
-                }
-                return color;
-            },
+                        if (this.cross) {
+                            this.cross
+                                .addClass('highcharts-coloraxis-marker')
+                                .add(this.legendGroup);
 
-            /**
-             * Override the getOffset method to add the whole axis groups inside
-             * the legend.
-             */
-            getOffset: function() {
-                var group = this.legendGroup,
-                    sideOffset = this.chart.axisOffset[this.side];
 
-                if (group) {
+                            this.cross.attr({
+                                fill: this.crosshair.color
+                            });
 
-                    // Hook for the getOffset method to add groups to this parent group
-                    this.axisParent = group;
 
-                    // Call the base
-                    Axis.prototype.getOffset.call(this);
+                        }
+                    }
+                },
+                getPlotLinePath: function(a, b, c, d, pos) {
+                    // crosshairs only
+                    return isNumber(pos) ? // pos can be 0 (#3969)
+                        (
+                            this.horiz ? [
+                                'M',
+                                pos - 4, this.top - 6,
+                                'L',
+                                pos + 4, this.top - 6,
+                                pos, this.top,
+                                'Z'
+                            ] : [
+                                'M',
+                                this.left, pos,
+                                'L',
+                                this.left - 6, pos + 6,
+                                this.left - 6, pos - 6,
+                                'Z'
+                            ]
+                        ) :
+                        Axis.prototype.getPlotLinePath.call(this, a, b, c, d);
+                },
 
-                    // First time only
-                    if (!this.added) {
+                update: function(newOptions, redraw) {
+                    var chart = this.chart,
+                        legend = chart.legend;
 
-                        this.added = true;
+                    each(this.series, function(series) {
+                        // Needed for Axis.update when choropleth colors change
+                        series.isDirtyData = true;
+                    });
 
-                        this.labelLeft = 0;
-                        this.labelRight = this.width;
+                    // When updating data classes, destroy old items and make sure new ones
+                    // are created (#3207)
+                    if (newOptions.dataClasses && legend.allItems) {
+                        each(legend.allItems, function(item) {
+                            if (item.isDataClass && item.legendGroup) {
+                                item.legendGroup.destroy();
+                            }
+                        });
+                        chart.isDirtyLegend = true;
                     }
-                    // Reset it to avoid color axis reserving space
-                    this.chart.axisOffset[this.side] = sideOffset;
-                }
-            },
 
-            /**
-             * Create the color gradient
-             */
-            setLegendColor: function() {
-                var grad,
-                    horiz = this.horiz,
-                    reversed = this.reversed,
-                    one = reversed ? 1 : 0,
-                    zero = reversed ? 0 : 1;
-
-                grad = horiz ? [one, 0, zero, 0] : [0, zero, 0, one]; // #3190
-                this.legendColor = {
-                    linearGradient: {
-                        x1: grad[0],
-                        y1: grad[1],
-                        x2: grad[2],
-                        y2: grad[3]
-                    },
-                    stops: this.stops
-                };
-            },
+                    // Keep the options structure updated for export. Unlike xAxis and
+                    // yAxis, the colorAxis is not an array. (#3207)
+                    chart.options[this.coll] = merge(this.userOptions, newOptions);
 
-            /**
-             * The color axis appears inside the legend and has its own legend symbol
-             */
-            drawLegendSymbol: function(legend, item) {
-                var padding = legend.padding,
-                    legendOptions = legend.options,
-                    horiz = this.horiz,
-                    width = pick(
-                        legendOptions.symbolWidth,
-                        horiz ? this.defaultLegendLength : 12
-                    ),
-                    height = pick(
-                        legendOptions.symbolHeight,
-                        horiz ? 12 : this.defaultLegendLength
-                    ),
-                    labelPadding = pick(legendOptions.labelPadding, horiz ? 16 : 30),
-                    itemDistance = pick(legendOptions.itemDistance, 10);
-
-                this.setLegendColor();
-
-                // Create the gradient
-                item.legendSymbol = this.chart.renderer.rect(
-                    0,
-                    legend.baseline - 11,
-                    width,
-                    height
-                ).attr({
-                    zIndex: 1
-                }).add(item.legendGroup);
-
-                // Set how much space this legend item takes up
-                this.legendItemWidth = width + padding +
-                    (horiz ? itemDistance : labelPadding);
-                this.legendItemHeight = height + padding + (horiz ? labelPadding : 0);
-            },
-            /**
-             * Fool the legend
-             */
-            setState: noop,
-            visible: true,
-            setVisible: noop,
-            getSeriesExtremes: function() {
-                var series = this.series,
-                    i = series.length;
-                this.dataMin = Infinity;
-                this.dataMax = -Infinity;
-                while (i--) {
-                    if (series[i].valueMin !== undefined) {
-                        this.dataMin = Math.min(this.dataMin, series[i].valueMin);
-                        this.dataMax = Math.max(this.dataMax, series[i].valueMax);
+                    Axis.prototype.update.call(this, newOptions, redraw);
+                    if (this.legendItem) {
+                        this.setLegendColor();
+                        legend.colorizeItem(this, true);
                     }
-                }
-            },
-            drawCrosshair: function(e, point) {
-                var plotX = point && point.plotX,
-                    plotY = point && point.plotY,
-                    crossPos,
-                    axisPos = this.pos,
-                    axisLen = this.len;
-
-                if (point) {
-                    crossPos = this.toPixels(point[point.series.colorKey]);
-                    if (crossPos < axisPos) {
-                        crossPos = axisPos - 2;
-                    } else if (crossPos > axisPos + axisLen) {
-                        crossPos = axisPos + axisLen + 2;
-                    }
-
-                    point.plotX = crossPos;
-                    point.plotY = this.len - crossPos;
-                    Axis.prototype.drawCrosshair.call(this, e, point);
-                    point.plotX = plotX;
-                    point.plotY = plotY;
+                },
 
-                    if (this.cross) {
-                        this.cross
-                            .addClass('highcharts-coloraxis-marker')
-                            .add(this.legendGroup);
+                /**
+                 * Extend basic axis remove by also removing the legend item.
+                 */
+                remove: function() {
+                    if (this.legendItem) {
+                        this.chart.legend.destroyItem(this);
+                    }
+                    Axis.prototype.remove.call(this);
+                },
 
+                /**
+                 * Get the legend item symbols for data classes
+                 */
+                getDataClassLegendSymbols: function() {
+                    var axis = this,
+                        chart = this.chart,
+                        legendItems = this.legendItems,
+                        legendOptions = chart.options.legend,
+                        valueDecimals = legendOptions.valueDecimals,
+                        valueSuffix = legendOptions.valueSuffix || '',
+                        name;
+
+                    if (!legendItems.length) {
+                        each(this.dataClasses, function(dataClass, i) {
+                            var vis = true,
+                                from = dataClass.from,
+                                to = dataClass.to;
+
+                            // Assemble the default name. This can be overridden
+                            // by legend.options.labelFormatter
+                            name = '';
+                            if (from === undefined) {
+                                name = '< ';
+                            } else if (to === undefined) {
+                                name = '> ';
+                            }
+                            if (from !== undefined) {
+                                name += H.numberFormat(from, valueDecimals) + valueSuffix;
+                            }
+                            if (from !== undefined && to !== undefined) {
+                                name += ' - ';
+                            }
+                            if (to !== undefined) {
+                                name += H.numberFormat(to, valueDecimals) + valueSuffix;
+                            }
+                            // Add a mock object to the legend items
+                            legendItems.push(extend({
+                                chart: chart,
+                                name: name,
+                                options: {},
+                                drawLegendSymbol: LegendSymbolMixin.drawRectangle,
+                                visible: true,
+                                setState: noop,
+                                isDataClass: true,
+                                setVisible: function() {
+                                    vis = this.visible = !vis;
+                                    each(axis.series, function(series) {
+                                        each(series.points, function(point) {
+                                            if (point.dataClass === i) {
+                                                point.setVisible(vis);
+                                            }
+                                        });
+                                    });
 
-                        this.cross.attr({
-                            fill: this.crosshair.color
+                                    chart.legend.colorizeItem(this, vis);
+                                }
+                            }, dataClass));
                         });
-
-
                     }
-                }
-            },
-            getPlotLinePath: function(a, b, c, d, pos) {
-                // crosshairs only
-                return isNumber(pos) ? // pos can be 0 (#3969)
-                    (
-                        this.horiz ? [
-                            'M',
-                            pos - 4, this.top - 6,
-                            'L',
-                            pos + 4, this.top - 6,
-                            pos, this.top,
-                            'Z'
-                        ] : [
-                            'M',
-                            this.left, pos,
-                            'L',
-                            this.left - 6, pos + 6,
-                            this.left - 6, pos - 6,
-                            'Z'
-                        ]
-                    ) :
-                    Axis.prototype.getPlotLinePath.call(this, a, b, c, d);
-            },
+                    return legendItems;
+                },
+                name: '' // Prevents 'undefined' in legend in IE8
+            });
 
-            update: function(newOptions, redraw) {
-                var chart = this.chart,
-                    legend = chart.legend;
+            /**
+             * Handle animation of the color attributes directly
+             */
+            each(['fill', 'stroke'], function(prop) {
+                H.Fx.prototype[prop + 'Setter'] = function() {
+                    this.elem.attr(
+                        prop,
+                        color(this.start).tweenTo(
+                            color(this.end),
+                            this.pos
+                        ),
+                        null,
+                        true
+                    );
+                };
+            });
 
-                each(this.series, function(series) {
-                    // Needed for Axis.update when choropleth colors change
-                    series.isDirtyData = true;
-                });
+            /**
+             * Extend the chart getAxes method to also get the color axis
+             */
+            wrap(Chart.prototype, 'getAxes', function(proceed) {
 
-                // When updating data classes, destroy old items and make sure new ones
-                // are created (#3207)
-                if (newOptions.dataClasses && legend.allItems) {
-                    each(legend.allItems, function(item) {
-                        if (item.isDataClass && item.legendGroup) {
-                            item.legendGroup.destroy();
-                        }
-                    });
-                    chart.isDirtyLegend = true;
-                }
+                var options = this.options,
+                    colorAxisOptions = options.colorAxis;
 
-                // Keep the options structure updated for export. Unlike xAxis and
-                // yAxis, the colorAxis is not an array. (#3207)
-                chart.options[this.coll] = merge(this.userOptions, newOptions);
+                proceed.call(this);
 
-                Axis.prototype.update.call(this, newOptions, redraw);
-                if (this.legendItem) {
-                    this.setLegendColor();
-                    legend.colorizeItem(this, true);
+                this.colorAxis = [];
+                if (colorAxisOptions) {
+                    new ColorAxis(this, colorAxisOptions); // eslint-disable-line no-new
                 }
-            },
+            });
 
-            /**
-             * Extend basic axis remove by also removing the legend item.
-             */
-            remove: function() {
-                if (this.legendItem) {
-                    this.chart.legend.destroyItem(this);
-                }
-                Axis.prototype.remove.call(this);
-            },
 
             /**
-             * Get the legend item symbols for data classes
+             * Wrap the legend getAllItems method to add the color axis. This also removes
+             * the axis' own series to prevent them from showing up individually.
              */
-            getDataClassLegendSymbols: function() {
-                var axis = this,
-                    chart = this.chart,
-                    legendItems = this.legendItems,
-                    legendOptions = chart.options.legend,
-                    valueDecimals = legendOptions.valueDecimals,
-                    valueSuffix = legendOptions.valueSuffix || '',
-                    name;
-
-                if (!legendItems.length) {
-                    each(this.dataClasses, function(dataClass, i) {
-                        var vis = true,
-                            from = dataClass.from,
-                            to = dataClass.to;
-
-                        // Assemble the default name. This can be overridden
-                        // by legend.options.labelFormatter
-                        name = '';
-                        if (from === undefined) {
-                            name = '< ';
-                        } else if (to === undefined) {
-                            name = '> ';
-                        }
-                        if (from !== undefined) {
-                            name += H.numberFormat(from, valueDecimals) + valueSuffix;
+            wrap(Legend.prototype, 'getAllItems', function(proceed) {
+                var allItems = [],
+                    colorAxis = this.chart.colorAxis[0];
+
+                if (colorAxis && colorAxis.options) {
+                    if (colorAxis.options.showInLegend) {
+                        // Data classes
+                        if (colorAxis.options.dataClasses) {
+                            allItems = allItems.concat(
+                                colorAxis.getDataClassLegendSymbols()
+                            );
+                            // Gradient legend
+                        } else {
+                            // Add this axis on top
+                            allItems.push(colorAxis);
                         }
-                        if (from !== undefined && to !== undefined) {
-                            name += ' - ';
-                        }
-                        if (to !== undefined) {
-                            name += H.numberFormat(to, valueDecimals) + valueSuffix;
-                        }
-                        // Add a mock object to the legend items
-                        legendItems.push(extend({
-                            chart: chart,
-                            name: name,
-                            options: {},
-                            drawLegendSymbol: LegendSymbolMixin.drawRectangle,
-                            visible: true,
-                            setState: noop,
-                            isDataClass: true,
-                            setVisible: function() {
-                                vis = this.visible = !vis;
-                                each(axis.series, function(series) {
-                                    each(series.points, function(point) {
-                                        if (point.dataClass === i) {
-                                            point.setVisible(vis);
-                                        }
-                                    });
-                                });
+                    }
 
-                                chart.legend.colorizeItem(this, vis);
-                            }
-                        }, dataClass));
+                    // Don't add the color axis' series
+                    each(colorAxis.series, function(series) {
+                        series.options.showInLegend = false;
                     });
                 }
-                return legendItems;
-            },
-            name: '' // Prevents 'undefined' in legend in IE8
-        });
-
-        /**
-         * Handle animation of the color attributes directly
-         */
-        each(['fill', 'stroke'], function(prop) {
-            H.Fx.prototype[prop + 'Setter'] = function() {
-                this.elem.attr(
-                    prop,
-                    color(this.start).tweenTo(
-                        color(this.end),
-                        this.pos
-                    ),
-                    null,
-                    true
-                );
-            };
-        });
-
-        /**
-         * Extend the chart getAxes method to also get the color axis
-         */
-        wrap(Chart.prototype, 'getAxes', function(proceed) {
-
-            var options = this.options,
-                colorAxisOptions = options.colorAxis;
-
-            proceed.call(this);
-
-            this.colorAxis = [];
-            if (colorAxisOptions) {
-                new ColorAxis(this, colorAxisOptions); // eslint-disable-line no-new
-            }
-        });
 
+                return allItems.concat(proceed.call(this));
+            });
 
-        /**
-         * Wrap the legend getAllItems method to add the color axis. This also removes
-         * the axis' own series to prevent them from showing up individually.
-         */
-        wrap(Legend.prototype, 'getAllItems', function(proceed) {
-            var allItems = [],
-                colorAxis = this.chart.colorAxis[0];
-
-            if (colorAxis && colorAxis.options) {
-                if (colorAxis.options.showInLegend) {
-                    // Data classes
-                    if (colorAxis.options.dataClasses) {
-                        allItems = allItems.concat(
-                            colorAxis.getDataClassLegendSymbols()
-                        );
-                        // Gradient legend
-                    } else {
-                        // Add this axis on top
-                        allItems.push(colorAxis);
-                    }
+            wrap(Legend.prototype, 'colorizeItem', function(proceed, item, visible) {
+                proceed.call(this, item, visible);
+                if (visible && item.legendColor) {
+                    item.legendSymbol.attr({
+                        fill: item.legendColor
+                    });
                 }
+            });
 
-                // Don't add the color axis' series
-                each(colorAxis.series, function(series) {
-                    series.options.showInLegend = false;
-                });
-            }
-
-            return allItems.concat(proceed.call(this));
-        });
-
-        wrap(Legend.prototype, 'colorizeItem', function(proceed, item, visible) {
-            proceed.call(this, item, visible);
-            if (visible && item.legendColor) {
-                item.legendSymbol.attr({
-                    fill: item.legendColor
-                });
-            }
-        });
+            // Updates in the legend need to be reflected in the color axis (6888)
+            wrap(Legend.prototype, 'update', function(proceed) {
+                proceed.apply(this, [].slice.call(arguments, 1));
 
-        // Updates in the legend need to be reflected in the color axis (6888)
-        wrap(Legend.prototype, 'update', function(proceed) {
-            proceed.apply(this, [].slice.call(arguments, 1));
-
-            if (this.chart.colorAxis[0]) {
-                this.chart.colorAxis[0].update({}, arguments[2]);
-            }
-        });
+                if (this.chart.colorAxis[0]) {
+                    this.chart.colorAxis[0].update({}, arguments[2]);
+                }
+            });
+        }
 
     }(Highcharts));
     (function(H) {
@@ -1409,18 +1414,19 @@
          */
 
         /**
-         * The x coordinate of the point.
+         * The x value of the point. For datetime axes,
+         * the X value is the timestamp in milliseconds since 1970.
          * 
          * @type {Number}
-         * @product highmaps
+         * @product highcharts highmaps
          * @apioption series.heatmap.data.x
          */
 
         /**
-         * The y coordinate of the point.
+         * The y value of the point.
          * 
          * @type {Number}
-         * @product highmaps
+         * @product highcharts highmaps
          * @apioption series.heatmap.data.y
          */