highcharts-rails 5.0.7 → 5.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 607c053da0b9fc8e51b7392df545aa6e5d297a34
-  data.tar.gz: 2e1f5f66fe81be42f4a96afdf21ca8ad5bc12697
+  metadata.gz: c07fdfe881d82631125b0d41f3308e896b0b0c39
+  data.tar.gz: 4763f46c66ebd67f143b07553efa26b16dba9926
 SHA512:
-  metadata.gz: abfc4475e26229dca060b337a77bf1564bfb55c66ed2d13ce8e2d156ec81811977117f3fe623a5c4bf147552a7653426c96e4e607be266ba8413e60e0af62e6c
-  data.tar.gz: a8be44f809d4987373a16f6a2383667f066ab4c9c82b6862922e5da10ba7955ca5c1e2a3bdc6482b32c7e9cf176e970dd5b6908810ff75b5e37977b283512885
+  metadata.gz: 62691100992c685c381e7fc5eaf9c0c884bb1008d7aad489e4b48d5119eb72a94ef24571ada79f01b3c94c6710ac5c0b8c012f374f4e6ece510890fe0117a36d
+  data.tar.gz: 196d2a3665e69acb6db35981518c9694a48a761a0d97d9cd8a1bccd684f5eb8aecf84b87da1b658fca9ed4c5d1563d08e076e5b243fc4a3b96e067ca15f7cd4a

data/CHANGELOG.markdown

@@ -1,3 +1,44 @@
+# 5.0.8 / 2017-11-10
+
+* Updated Highcharts to 5.0.8 (2017-03-08)
+  * Added a refactored Boost module based on WebGL. Details and API to be announced.
+  * Added animation on graph mouse over and mouse out.
+  * Added hooks so that users can define their own log axis conversion functions, and can advertise that the log axis should allow negative values.
+  * Added new option, solidgauge.rounded.
+  * Added support for relative chart.height as a percentage of the width. This allows for fixed aspect ratio.
+  * Bug fixes
+    * Fixed #223, pie chart data labels overflowed after pie reached minimum size.
+    * Fixed #2322, updating series type caused remnants of the original series type after multiple updates.
+    * Fixed #4916, data values were lost in export after updating a point from a numeric or array configuration to an object configuration.
+    * Fixed #5915, returning false from tooltip formatter only hid the tooltip when it was present from before.
+    * Fixed #6087, minPointLength shifted next points rendering.
+    * Fixed #6173, another case of unwanted inline CSS in style mode.
+    * Fixed #6187, navigator jumped back after dragging on touch devices.
+    * Fixed #6254, Point.update did not apply new class names.
+    * Fixed #6264, enabling individual bubble markers did not work.
+    * Fixed #6272, inverted stack area chart was badly drawn when containing nulls.
+    * Fixed #6274, allowDecimals: false was ignored with flat data.
+    * Fixed #6278, missing ticks before DST crossover in some cases.
+    * Fixed #6282, text-align did not take effect on data labels with useHTML.
+    * Fixed #6291, multiple responsive rules were applied an unapplied in wrong order when resizing.
+    * Fixed #6301, legend width option caused wrong alignment when aligned right.
+    * Fixed #6305, accessible keyboard navigation in polar charts not working correctly.
+    * Fixed #6314, treemap series failed with error in styled mode.
+    * Fixed #6321, bubbles were hidden when close and marker.enabled set to null.
+    * Fixed #6322, legend navigation arrows did not update correctly on responsiveness.
+    * Fixed #6328, issue with disabled tooltip in accessibility module.
+    * Fixed #6330, minor ticks affecting the computed extremes of Y axes in some cases.
+    * Fixed #6330, minor ticks were not applied outside major ticks on a logarithmic axis.
+    * Fixed #6347, error on applying responsive rules where series or axis length was greater than the existing chart.
+    * Fixed #6356, legend.maxHeight not respected after chart update.
+    * Fixed #6361, accessibility failing for IE8 and older.
+    * Fixed #6370, category axis with breaks was rendered incorrectly.
+    * Fixed #6384, Point.update didn't work with slice: false.
+    * Fixed #6387, graph and area rendered differently on area splines next to null points.
+    * Fixed #6399, treemap legend item had incorrect color after point was hidden.
+    * Fixed #6401, point.states didn't work for maps.
+    * Fixed #6402, treemap ignoreHiddenPoint is now true by default.
+
 # 5.0.7 / 2017-01-25
 
 * Updated Highcharts to 5.0.7 (2017-01-17)

data/README.markdown

@@ -26,14 +26,9 @@ In your JavaScript manifest (e.g. `application.js`)
     // to get the new features in 2.3.0:
     //= require highcharts/highcharts-more
 
-To include one of the other adapters
-
-    //= require highcharts/adapters/standalone-framework
-
-Or the modules
+Including the modules you want and need
 
     //= require highcharts/modules/annotations
-    //= require highcharts/modules/canvas-tools
     //= require highcharts/modules/data
     //= require highcharts/modules/drilldown
     //= require highcharts/modules/exporting
@@ -50,6 +45,8 @@ Or one of the themes
     //= require highcharts/themes/grid
     //= require highcharts/themes/skies
 
+Some of the modules are meant to be loaded by Highcharts on-demand, such as `canvas-tools` (https://github.com/highcharts/highcharts/issues/2311#issuecomment-25685317), so don't require them on your own.
+
 Other than that, refer to the [Highcharts documentation](http://www.highcharts.com/docs)
 
 ## Licensing

data/app/assets/javascripts/highcharts.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v5.0.7 (2017-01-17)
+ * @license Highcharts JS v5.0.8 (2017-03-08)
  *
  * (c) 2009-2016 Torstein Honsi
  *
@@ -21,7 +21,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         /* global window */
         var win = window,
             doc = win.document;
@@ -36,7 +35,7 @@
 
         var Highcharts = win.Highcharts ? win.Highcharts.error(16, true) : {
             product: 'Highcharts',
-            version: '5.0.7',
+            version: '5.0.8',
             deg2rad: Math.PI * 2 / 360,
             doc: doc,
             hasBidiBug: hasBidiBug,
@@ -67,7 +66,6 @@
          * License: www.highcharts.com/license
          */
         /* eslint max-len: ["warn", 80, 4] */
-        'use strict';
 
         /**
          * The Highcharts object is the placeholder for all other members, and various
@@ -1597,9 +1595,10 @@
          * @function #each
          * @memberOf Highcharts
          * @param {Array} arr - The array to iterate over.
-         * @param {Function} fn - The iterator callback. It passes two arguments:
+         * @param {Function} fn - The iterator callback. It passes three arguments:
          * * item - The array item.
          * * index - The item's index in the array.
+         * * arr - The array that each is being applied to.
          * @param {Object} [ctx] The context.
          */
         H.each = function(arr, fn, ctx) { // modern browsers
@@ -1890,7 +1889,7 @@
                 if (!end) {
                     end = params[prop];
                 }
-                if (end.match && end.match('px')) {
+                if (end && end.match && end.match('px')) {
                     end = end.replace(/px/g, ''); // #4351
                 }
                 fx.run(start, end, unit);
@@ -2096,7 +2095,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var each = H.each,
             isNumber = H.isNumber,
             map = H.map,
@@ -2133,12 +2131,6 @@
                 parse: function(result) {
                     return [pInt(result[1]), pInt(result[2]), pInt(result[3]), parseFloat(result[4], 10)];
                 }
-            }, {
-                // HEX color
-                regex: /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/,
-                parse: function(result) {
-                    return [pInt(result[1], 16), pInt(result[2], 16), pInt(result[3], 16), 1];
-                }
             }, {
                 // RGB color
                 regex: /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/,
@@ -2162,7 +2154,8 @@
                 var result,
                     rgba,
                     i,
-                    parser;
+                    parser,
+                    len;
 
                 this.input = input = this.names[input] || input;
 
@@ -2174,12 +2167,46 @@
 
                     // Solid colors
                 } else {
-                    i = this.parsers.length;
-                    while (i-- && !rgba) {
-                        parser = this.parsers[i];
-                        result = parser.regex.exec(input);
-                        if (result) {
-                            rgba = parser.parse(result);
+
+                    // Check if it's possible to do bitmasking instead of regex
+                    if (input && input[0] === '#') {
+
+                        len = input.length;
+                        input = parseInt(input.substr(1), 16);
+
+                        // Handle long-form, e.g. #AABBCC
+                        if (len === 7) {
+
+                            rgba = [
+                                (input & 0xFF0000) >> 16,
+                                (input & 0xFF00) >> 8,
+                                (input & 0xFF),
+                                1
+                            ];
+
+                            // Handle short-form, e.g. #ABC
+                            // In short form, the value is assumed to be the same 
+                            // for both nibbles for each component. e.g. #ABC = #AABBCC
+                        } else if (len === 4) {
+
+                            rgba = [
+                                ((input & 0xF00) >> 4) | (input & 0xF00) >> 8,
+                                ((input & 0xF0) >> 4) | (input & 0xF0),
+                                ((input & 0xF) << 4) | (input & 0xF),
+                                1
+                            ];
+                        }
+                    }
+
+                    // Otherwise, check regex parsers
+                    if (!rgba) {
+                        i = this.parsers.length;
+                        while (i-- && !rgba) {
+                            parser = this.parsers[i];
+                            result = parser.regex.exec(input);
+                            if (result) {
+                                rgba = parser.parse(result);
+                            }
                         }
                     }
                 }
@@ -2265,7 +2292,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var SVGElement,
             SVGRenderer,
 
@@ -2336,8 +2362,8 @@
              * @type {Array.<string>}
              */
             textProps: ['direction', 'fontSize', 'fontWeight', 'fontFamily',
-                'fontStyle', 'color', 'lineHeight', 'width', 'textDecoration',
-                'textOverflow', 'textOutline'
+                'fontStyle', 'color', 'lineHeight', 'width', 'textAlign',
+                'textDecoration', 'textOverflow', 'textOutline'
             ],
 
             /**
@@ -2385,6 +2411,9 @@
                     animate(this, params, animOptions);
                 } else {
                     this.attr(params, null, complete);
+                    if (animOptions.step) {
+                        animOptions.step.call(this);
+                    }
                 }
                 return this;
             },
@@ -2946,10 +2975,9 @@
              * @returns {SVGElement} Return the SVG element for chaining.
              */
             css: function(styles) {
-                var elemWrapper = this,
-                    oldStyles = elemWrapper.styles,
+                var oldStyles = this.styles,
                     newStyles = {},
-                    elem = elemWrapper.element,
+                    elem = this.element,
                     textWidth,
                     n,
                     serializedCss = '',
@@ -2976,9 +3004,6 @@
                     }
                 }
                 if (hasNew) {
-                    textWidth = elemWrapper.textWidth =
-                        (styles && styles.width && elem.nodeName.toLowerCase() === 'text' && pInt(styles.width)) ||
-                        elemWrapper.textWidth; // #3501
 
                     // Merge the new styles with the old ones
                     if (oldStyles) {
@@ -2988,16 +3013,25 @@
                         );
                     }
 
+                    // Get the text width from style
+                    textWidth = this.textWidth = (
+                        styles &&
+                        styles.width &&
+                        styles.width !== 'auto' &&
+                        elem.nodeName.toLowerCase() === 'text' &&
+                        pInt(styles.width)
+                    );
+
                     // store object
-                    elemWrapper.styles = styles;
+                    this.styles = styles;
 
-                    if (textWidth && (!svg && elemWrapper.renderer.forExport)) {
+                    if (textWidth && (!svg && this.renderer.forExport)) {
                         delete styles.width;
                     }
 
                     // serialize and set style attribute
                     if (isMS && !svg) {
-                        css(elemWrapper.element, styles);
+                        css(this.element, styles);
                     } else {
                         hyphenate = function(a, b) {
                             return '-' + b.toLowerCase();
@@ -3015,20 +3049,22 @@
                     }
 
 
-                    if (elemWrapper.added) {
-                        // Rebuild text after added
-                        if (textWidth) {
-                            elemWrapper.renderer.buildText(elemWrapper);
+                    if (this.added) {
+
+                        // Rebuild text after added. Cache mechanisms in the buildText
+                        // will prevent building if there are no significant changes.
+                        if (this.element.nodeName === 'text') {
+                            this.renderer.buildText(this);
                         }
 
                         // Apply text outline after added
                         if (styles && styles.textOutline) {
-                            elemWrapper.applyTextOutline(styles.textOutline);
+                            this.applyTextOutline(styles.textOutline);
                         }
                     }
                 }
 
-                return elemWrapper;
+                return this;
             },
 
 
@@ -3986,7 +4022,7 @@
                         'class': 'highcharts-root'
                     })
 
-                .css(this.getStyle(style));
+                    .css(this.getStyle(style));
                 element = boxWrapper.element;
                 container.appendChild(element);
 
@@ -4025,7 +4061,7 @@
 
                 // Add description
                 desc = this.createElement('desc').add();
-                desc.element.appendChild(doc.createTextNode('Created with Highcharts 5.0.7'));
+                desc.element.appendChild(doc.createTextNode('Created with Highcharts 5.0.8'));
 
 
                 renderer.defs = this.createElement('defs').add();
@@ -4262,8 +4298,10 @@
 
                     if (hasMarkup) {
                         lines = textStr
+
                             .replace(/<(b|strong)>/g, '<span style="font-weight:bold">')
                             .replace(/<(i|em)>/g, '<span style="font-style:italic">')
+
                             .replace(/<a/g, '<span')
                             .replace(/<\/(b|strong|i|em|a)>/g, '</span>')
                             .split(/<br.*?>/g);
@@ -4723,24 +4761,28 @@
              * @returns {SVGElement} The generated wrapper element.
              */
             arc: function(x, y, r, innerR, start, end) {
-                var arc;
+                var arc,
+                    options;
 
                 if (isObject(x)) {
-                    y = x.y;
-                    r = x.r;
-                    innerR = x.innerR;
-                    start = x.start;
-                    end = x.end;
-                    x = x.x;
+                    options = x;
+                    y = options.y;
+                    r = options.r;
+                    innerR = options.innerR;
+                    start = options.start;
+                    end = options.end;
+                    x = options.x;
+                } else {
+                    options = {
+                        innerR: innerR,
+                        start: start,
+                        end: end
+                    };
                 }
 
                 // Arcs are defined as symbols for the ability to set
                 // attributes in attr and animate
-                arc = this.symbol('arc', x || 0, y || 0, r || 0, r || 0, {
-                    innerR: innerR || 0,
-                    start: start || 0,
-                    end: end || 0
-                });
+                arc = this.symbol('arc', x, y, r, r, options);
                 arc.r = r; // #959
                 return arc;
             },
@@ -5596,7 +5638,7 @@
 
                 // only change local variables
                 wrapper.widthSetter = function(value) {
-                    width = value;
+                    width = H.isNumber(value) ? value : null; // width:auto => null
                 };
                 wrapper.heightSetter = function(value) {
                     height = value;
@@ -5769,7 +5811,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var attr = H.attr,
             createElement = H.createElement,
             css = H.css,
@@ -6132,7 +6173,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
 
         var VMLRenderer,
             VMLRendererExtension,
@@ -7284,7 +7324,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var color = H.color,
             each = H.each,
             getTZOffset = H.getTZOffset,
@@ -7327,7 +7366,7 @@
                 useUTC: true,
                 //timezoneOffset: 0,
 
-                VMLRadialGradientURL: 'http://code.highcharts.com/5.0.7/gfx/vml-radial-gradient.png'
+                VMLRadialGradientURL: 'http://code.highcharts.com/5.0.8/gfx/vml-radial-gradient.png'
 
             },
             chart: {
@@ -7377,8 +7416,8 @@
                 backgroundColor: '#ffffff',
                 //plotBackgroundColor: null,
                 plotBorderColor: '#cccccc'
-                    //plotBorderWidth: 0,
-                    //plotShadow: false
+                //plotBorderWidth: 0,
+                //plotShadow: false
 
             },
             title: {
@@ -7673,7 +7712,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var arrayMax = H.arrayMax,
             arrayMin = H.arrayMin,
             defined = H.defined,
@@ -8000,7 +8038,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var correctFloat = H.correctFloat,
             defined = H.defined,
             destroyObjectProperties = H.destroyObjectProperties,
@@ -8084,10 +8121,10 @@
                             labelOptions.useHTML
                         )
 
-                    // without position absolute, IE export sometimes is wrong
-                    .css(merge(labelOptions.style))
+                        // without position absolute, IE export sometimes is wrong
+                        .css(merge(labelOptions.style))
 
-                    .add(axis.labelGroup):
+                        .add(axis.labelGroup) :
                         null;
                     tick.labelLength = label && label.getBBox().width; // Un-rotated length
                     tick.rotation = 0; // Base value to detect change for new calls to getBBox
@@ -8261,51 +8298,31 @@
             },
 
             /**
-             * Put everything in place
-             *
-             * @param index {Number}
-             * @param old {Boolean} Use old coordinates to prepare an animation into new position
+             * Renders the gridLine.
+             * @param  {Boolean} old         Whether or not the tick is old
+             * @param  {number} opacity      The opacity of the grid line
+             * @param  {number} reverseCrisp Modifier for avoiding overlapping 1 or -1
+             * @return {undefined}
              */
-            render: function(index, old, opacity) {
+            renderGridLine: function(old, opacity, reverseCrisp) {
                 var tick = this,
                     axis = tick.axis,
                     options = axis.options,
-                    chart = axis.chart,
-                    renderer = chart.renderer,
-                    horiz = axis.horiz,
-                    type = tick.type,
-                    label = tick.label,
-                    pos = tick.pos,
-                    labelOptions = options.labels,
                     gridLine = tick.gridLine,
-                    tickPrefix = type ? type + 'Tick' : 'tick',
-                    tickSize = axis.tickSize(tickPrefix),
                     gridLinePath,
-                    mark = tick.mark,
-                    isNewMark = !mark,
-                    step = labelOptions.step,
                     attribs = {},
-                    show = true,
+                    pos = tick.pos,
+                    type = tick.type,
                     tickmarkOffset = axis.tickmarkOffset,
-                    xy = tick.getPosition(horiz, pos, tickmarkOffset, old),
-                    x = xy.x,
-                    y = xy.y,
-                    reverseCrisp = ((horiz && x === axis.pos + axis.len) ||
-                        (!horiz && y === axis.pos)) ? -1 : 1; // #1480, #1687
+                    renderer = axis.chart.renderer;
 
 
                 var gridPrefix = type ? type + 'Grid' : 'grid',
                     gridLineWidth = options[gridPrefix + 'LineWidth'],
                     gridLineColor = options[gridPrefix + 'LineColor'],
-                    dashStyle = options[gridPrefix + 'LineDashStyle'],
-                    tickWidth = pick(options[tickPrefix + 'Width'], !type && axis.isXAxis ? 1 : 0), // X axis defaults to 1
-                    tickColor = options[tickPrefix + 'Color'];
-
+                    dashStyle = options[gridPrefix + 'LineDashStyle'];
 
-                opacity = pick(opacity, 1);
-                this.isActive = true;
 
-                // Create the grid line
                 if (!gridLine) {
 
                     attribs.stroke = gridLineColor;
@@ -8322,14 +8339,20 @@
                     }
                     tick.gridLine = gridLine = renderer.path()
                         .attr(attribs)
-                        .addClass('highcharts-' + (type ? type + '-' : '') + 'grid-line')
+                        .addClass(
+                            'highcharts-' + (type ? type + '-' : '') + 'grid-line'
+                        )
                         .add(axis.gridGroup);
                 }
 
                 // If the parameter 'old' is set, the current call will be followed
                 // by another call, therefore do not do any animations this time
                 if (!old && gridLine) {
-                    gridLinePath = axis.getPlotLinePath(pos + tickmarkOffset, gridLine.strokeWidth() * reverseCrisp, old, true);
+                    gridLinePath = axis.getPlotLinePath(
+                        pos + tickmarkOffset,
+                        gridLine.strokeWidth() * reverseCrisp,
+                        old, true
+                    );
                     if (gridLinePath) {
                         gridLine[tick.isNew ? 'attr' : 'animate']({
                             d: gridLinePath,
@@ -8337,8 +8360,37 @@
                         });
                     }
                 }
+            },
+
+            /**
+             * Renders the tick mark.
+             * @param  {Object} xy           The position vector of the mark
+             * @param  {number} xy.x         The x position of the mark
+             * @param  {number} xy.y         The y position of the mark
+             * @param  {number} opacity      The opacity of the mark
+             * @param  {number} reverseCrisp Modifier for avoiding overlapping 1 or -1
+             * @return {undefined}
+             */
+            renderMark: function(xy, opacity, reverseCrisp) {
+                var tick = this,
+                    axis = tick.axis,
+                    options = axis.options,
+                    renderer = axis.chart.renderer,
+                    type = tick.type,
+                    tickPrefix = type ? type + 'Tick' : 'tick',
+                    tickSize = axis.tickSize(tickPrefix),
+                    mark = tick.mark,
+                    isNewMark = !mark,
+                    x = xy.x,
+                    y = xy.y;
+
+
+                var tickWidth = pick(
+                        options[tickPrefix + 'Width'], !type && axis.isXAxis ? 1 : 0
+                    ), // X axis defaults to 1
+                    tickColor = options[tickPrefix + 'Color'];
+
 
-                // create the tick mark
                 if (tickSize) {
 
                     // negate the length
@@ -8360,20 +8412,70 @@
 
                     }
                     mark[isNewMark ? 'attr' : 'animate']({
-                        d: tick.getMarkPath(x, y, tickSize[0], mark.strokeWidth() * reverseCrisp, horiz, renderer),
+                        d: tick.getMarkPath(
+                            x,
+                            y,
+                            tickSize[0],
+                            mark.strokeWidth() * reverseCrisp,
+                            axis.horiz,
+                            renderer),
                         opacity: opacity
                     });
 
                 }
+            },
 
-                // the label is created on init - now move it into place
+            /**
+             * Renders the tick label.
+             * Note: The label should already be created in init(), so it should only
+             * have to be moved into place.
+             * @param  {Object} xy      The position vector of the label
+             * @param  {number} xy.x    The x position of the label
+             * @param  {number} xy.y    The y position of the label
+             * @param  {Boolean} old    Whether or not the tick is old
+             * @param  {number} opacity The opacity of the label
+             * @param  {number} index   The index of the tick
+             * @return {undefined}
+             */
+            renderLabel: function(xy, old, opacity, index) {
+                var tick = this,
+                    axis = tick.axis,
+                    horiz = axis.horiz,
+                    options = axis.options,
+                    label = tick.label,
+                    labelOptions = options.labels,
+                    step = labelOptions.step,
+                    tickmarkOffset = axis.tickmarkOffset,
+                    show = true,
+                    x = xy.x,
+                    y = xy.y;
                 if (label && isNumber(x)) {
-                    label.xy = xy = tick.getLabelPosition(x, y, label, horiz, labelOptions, tickmarkOffset, index, step);
+                    label.xy = xy = tick.getLabelPosition(
+                        x,
+                        y,
+                        label,
+                        horiz,
+                        labelOptions,
+                        tickmarkOffset,
+                        index,
+                        step
+                    );
 
-                    // Apply show first and show last. If the tick is both first and last, it is
-                    // a single centered tick, in which case we show the label anyway (#2100).
-                    if ((tick.isFirst && !tick.isLast && !pick(options.showFirstLabel, 1)) ||
-                        (tick.isLast && !tick.isFirst && !pick(options.showLastLabel, 1))) {
+                    // Apply show first and show last. If the tick is both first and
+                    // last, it is a single centered tick, in which case we show the
+                    // label anyway (#2100).
+                    if (
+                        (
+                            tick.isFirst &&
+                            !tick.isLast &&
+                            !pick(options.showFirstLabel, 1)
+                        ) ||
+                        (
+                            tick.isLast &&
+                            !tick.isFirst &&
+                            !pick(options.showLastLabel, 1)
+                        )
+                    ) {
                         show = false;
 
                         // Handle label overflow and show or hide accordingly
@@ -8399,6 +8501,38 @@
                 }
             },
 
+            /**
+             * Put everything in place
+             *
+             * @param index {Number}
+             * @param old {Boolean} Use old coordinates to prepare an animation into new
+             *                      position
+             */
+            render: function(index, old, opacity) {
+                var tick = this,
+                    axis = tick.axis,
+                    horiz = axis.horiz,
+                    pos = tick.pos,
+                    tickmarkOffset = axis.tickmarkOffset,
+                    xy = tick.getPosition(horiz, pos, tickmarkOffset, old),
+                    x = xy.x,
+                    y = xy.y,
+                    reverseCrisp = ((horiz && x === axis.pos + axis.len) ||
+                        (!horiz && y === axis.pos)) ? -1 : 1; // #1480, #1687
+
+                opacity = pick(opacity, 1);
+                this.isActive = true;
+
+                // Create the grid line
+                this.renderGridLine(old, opacity, reverseCrisp);
+
+                // create the tick mark
+                this.renderMark(xy, opacity, reverseCrisp);
+
+                // the label is created on init - now move it into place
+                this.renderLabel(xy, old, opacity, index);
+            },
+
             /**
              * Destructor for the tick prototype
              */
@@ -8414,7 +8548,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
 
         var addEvent = H.addEvent,
             animObject = H.animObject,
@@ -8491,10 +8624,10 @@
                     },
 
                     x: 0
-                        //y: undefined
-                        /*formatter: function () {
-                        	return this.value;
-                        },*/
+                    //y: undefined
+                    /*formatter: function () {
+                    	return this.value;
+                    },*/
                 },
                 //linkedTo: null,
                 //max: undefined,
@@ -8556,7 +8689,7 @@
                 // gridLineDashStyle: 'solid',
                 // gridLineWidth: 0,
                 tickColor: '#ccd6eb'
-                    // tickWidth: 1
+                // tickWidth: 1
 
             },
 
@@ -8600,7 +8733,7 @@
 
                 gridLineWidth: 1,
                 lineWidth: 0
-                    // tickWidth: 0
+                // tickWidth: 0
 
             },
 
@@ -8635,8 +8768,8 @@
                 labels: {
                     autoRotation: [-45],
                     x: 0
-                        // overflow: undefined,
-                        // staggerLines: null
+                    // overflow: undefined,
+                    // staggerLines: null
                 },
                 title: {
                     rotation: 0
@@ -8649,8 +8782,8 @@
                 labels: {
                     autoRotation: [-45],
                     x: 0
-                        // overflow: undefined
-                        // staggerLines: null
+                    // overflow: undefined
+                    // staggerLines: null
                 },
                 title: {
                     rotation: 0
@@ -8714,6 +8847,7 @@
                 // Shorthand types
                 axis.isLog = type === 'logarithmic';
                 axis.isDatetimeAxis = isDatetimeAxis;
+                axis.positiveValuesOnly = axis.isLog && !axis.allowNegativeLog;
 
                 // Flag, if axis is linked to another axis
                 axis.isLinked = defined(options.linkedTo);
@@ -8812,6 +8946,7 @@
                 }
 
                 // extend logarithmic axis
+                axis.lin2log = options.linearToLogConverter || axis.lin2log;
                 if (axis.isLog) {
                     axis.val2lin = axis.log2lin;
                     axis.lin2val = axis.lin2log;
@@ -8851,7 +8986,7 @@
                     formatOption = axis.options.labels.format,
 
                     // make sure the same symbol is added for all labels on a linear axis
-                    numericSymbolDetector = axis.isLog ? value : axis.tickInterval;
+                    numericSymbolDetector = axis.isLog ? Math.abs(value) : axis.tickInterval;
 
                 if (formatOption) {
                     ret = format(formatOption, this);
@@ -8915,7 +9050,7 @@
                         axis.hasVisibleSeries = true;
 
                         // Validate threshold in logarithmic axes
-                        if (axis.isLog && threshold <= 0) {
+                        if (axis.positiveValuesOnly && threshold <= 0) {
                             threshold = null;
                         }
 
@@ -8960,7 +9095,7 @@
                                 axis.threshold = threshold;
                             }
                             // If any series has a hard threshold, it takes precedence
-                            if (!seriesOptions.softThreshold || axis.isLog) {
+                            if (!seriesOptions.softThreshold || axis.positiveValuesOnly) {
                                 axis.softThreshold = false;
                             }
                         }
@@ -9107,8 +9242,9 @@
                     roundedMax = correctFloat(Math.ceil(max / tickInterval) * tickInterval),
                     tickPositions = [];
 
-                // For single points, add a tick regardless of the relative position (#2662)
-                if (min === max && isNumber(min)) {
+                // For single points, add a tick regardless of the relative position
+                // (#2662, #6274)
+                if (this.single) {
                     return [min];
                 }
 
@@ -9145,23 +9281,31 @@
                     minorTickInterval = axis.minorTickInterval,
                     minorTickPositions = [],
                     pos,
-                    i,
                     pointRangePadding = axis.pointRangePadding || 0,
                     min = axis.min - pointRangePadding, // #1498
                     max = axis.max + pointRangePadding, // #1498
-                    range = max - min,
-                    len;
+                    range = max - min;
 
                 // If minor ticks get too dense, they are hard to read, and may cause long running script. So we don't draw them.
                 if (range && range / minorTickInterval < axis.len / 3) { // #3875
 
                     if (axis.isLog) {
-                        len = tickPositions.length;
-                        for (i = 1; i < len; i++) {
-                            minorTickPositions = minorTickPositions.concat(
-                                axis.getLogTickPositions(minorTickInterval, tickPositions[i - 1], tickPositions[i], true)
-                            );
-                        }
+                        // For each interval in the major ticks, compute the minor ticks
+                        // separately.
+                        each(this.paddedTicks, function(pos, i, paddedTicks) {
+                            if (i) {
+                                minorTickPositions.push.apply(
+                                    minorTickPositions,
+                                    axis.getLogTickPositions(
+                                        minorTickInterval,
+                                        paddedTicks[i - 1],
+                                        paddedTicks[i],
+                                        true
+                                    )
+                                );
+                            }
+                        });
+
                     } else if (axis.isDatetimeAxis && options.minorTickInterval === 'auto') { // #1314
                         minorTickPositions = minorTickPositions.concat(
                             axis.getTimeTicks(
@@ -9184,8 +9328,8 @@
                     }
                 }
 
-                if (minorTickPositions.length !== 0) { // don't change the extremes, when there is no minor ticks
-                    axis.trimTicks(minorTickPositions, options.startOnTick, options.endOnTick); // #3652 #3743 #1498
+                if (minorTickPositions.length !== 0) {
+                    axis.trimTicks(minorTickPositions); // #3652 #3743 #1498 #6330
                 }
                 return minorTickPositions;
             },
@@ -9435,7 +9579,9 @@
                 if (saveOld) {
                     axis.oldTransA = transA;
                 }
-                axis.translationSlope = axis.transA = transA = axis.len / ((range + pointRangePadding) || 1);
+                axis.translationSlope = axis.transA = transA =
+                    axis.options.staticScale ||
+                    axis.len / ((range + pointRangePadding) || 1);
                 axis.transB = axis.horiz ? axis.left : axis.bottom; // translation addend
                 axis.minPixelPadding = transA * minPointOffset;
             },
@@ -9510,7 +9656,11 @@
                 }
 
                 if (isLog) {
-                    if (!secondPass && Math.min(axis.min, pick(axis.dataMin, axis.min)) <= 0) { // #978
+                    if (
+                        axis.positiveValuesOnly &&
+                        !secondPass &&
+                        Math.min(axis.min, pick(axis.dataMin, axis.min)) <= 0
+                    ) { // #978
                         H.error(10, 1); // Can't plot negative values on log axis
                     }
                     // The correctFloat cures #934, float errors on full tens. But it
@@ -9659,8 +9809,7 @@
                     tickPositionsOption = options.tickPositions,
                     tickPositioner = options.tickPositioner,
                     startOnTick = options.startOnTick,
-                    endOnTick = options.endOnTick,
-                    single;
+                    endOnTick = options.endOnTick;
 
                 // Set the tickmarkOffset
                 this.tickmarkOffset = (this.categories && options.tickmarkPlacement === 'between' &&
@@ -9671,6 +9820,13 @@
                 this.minorTickInterval = options.minorTickInterval === 'auto' && this.tickInterval ?
                     this.tickInterval / 5 : options.minorTickInterval;
 
+                // When there is only one point, or all points have the same value on
+                // this axis, then min and max are equal and tickPositions.length is 0
+                // or 1. In this case, add some padding in order to center the point,
+                // but leave it with one tick. #1337.
+                this.single = this.min === this.max && defined(this.min) &&
+                    !this.tickAmount && options.allowDecimals !== false;
+
                 // Find the tick positions
                 this.tickPositions = tickPositions = tickPositionsOption && tickPositionsOption.slice(); // Work on a copy (#1565)
                 if (!tickPositions) {
@@ -9708,19 +9864,16 @@
 
                 }
 
-                // reset min/max or remove extremes based on start/end on tick
+                // Reset min/max or remove extremes based on start/end on tick
+                this.paddedTicks = tickPositions.slice(0); // Used for logarithmic minor
                 this.trimTicks(tickPositions, startOnTick, endOnTick);
                 if (!this.isLinked) {
-                    // When there is only one point, or all points have the same value on this axis, then min
-                    // and max are equal and tickPositions.length is 0 or 1. In this case, add some padding
-                    // in order to center the point, but leave it with one tick. #1337.
-                    if (this.min === this.max && defined(this.min) && !this.tickAmount) {
-                        // Substract half a unit (#2619, #2846, #2515, #3390)
-                        single = true;
+
+                    // Substract half a unit (#2619, #2846, #2515, #3390)
+                    if (this.single) {
                         this.min -= 0.5;
                         this.max += 0.5;
                     }
-                    this.single = single;
                     if (!tickPositionsOption && !tickPositioner) {
                         this.adjustTickAmount();
                     }
@@ -10392,9 +10545,9 @@
                         })
                         .addClass('highcharts-axis-title')
 
-                    .css(axisTitleOptions.style)
+                        .css(axisTitleOptions.style)
 
-                    .add(axis.axisGroup);
+                        .add(axis.axisGroup);
                     axis.axisTitle.isNew = true;
                 }
 
@@ -10557,7 +10710,9 @@
                     axisOffset[side],
                     axis.axisTitleMargin + titleOffset + directionFactor * axis.offset,
                     labelOffsetPadded, // #3027
-                    hasData && tickPositions.length && tickSize ? tickSize[0] : 0 // #4866
+                    hasData && tickPositions.length && tickSize ?
+                    tickSize[0] + directionFactor * axis.offset :
+                    0 // #4866
                 );
 
                 // Decide the clipping needed to keep the graph inside the plot area and axis lines
@@ -11052,7 +11207,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var Axis = H.Axis,
             Date = H.Date,
             dateFormat = H.dateFormat,
@@ -11082,7 +11236,7 @@
                 higherRanks = {},
                 useUTC = defaultOptions.global.useUTC,
                 minYear, // used in months and years as a basis for Date.UTC()
-                minDate = new Date(min - getTZOffset(min)),
+                minDate = new Date(min - Math.abs(getTZOffset(min))), // #6278
                 makeTime = Date.hcMakeTime,
                 interval = normalizedInterval.unitRange,
                 count = normalizedInterval.count,
@@ -11313,7 +11467,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var Axis = H.Axis,
             getMagnitude = H.getMagnitude,
             map = H.map,
@@ -11437,7 +11590,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var dateFormat = H.dateFormat,
             each = H.each,
             extend = H.extend,
@@ -11828,21 +11980,20 @@
 
             /**
              * Refresh the tooltip's text and position.
-             * @param {Object} point
+             * @param {Object|Array} pointOrPoints Rither a point or an array of points
              */
-            refresh: function(point, mouseEvent) {
+            refresh: function(pointOrPoints, mouseEvent) {
                 var tooltip = this,
-                    chart = tooltip.chart,
                     label,
                     options = tooltip.options,
                     x,
                     y,
+                    point = pointOrPoints,
                     anchor,
                     textConfig = {},
                     text,
                     pointConfig = [],
                     formatter = options.formatter || tooltip.defaultFormatter,
-                    hoverPoints = chart.hoverPoints,
                     shared = tooltip.shared,
                     currentSeries;
 
@@ -11856,16 +12007,6 @@
 
                 // shared tooltip, array is sent over
                 if (shared && !(point.series && point.series.noSharedTooltip)) {
-
-                    // hide previous hoverPoints and set new
-
-                    chart.hoverPoints = point;
-                    if (hoverPoints) {
-                        each(hoverPoints, function(point) {
-                            point.setState();
-                        });
-                    }
-
                     each(point, function(item) {
                         item.setState('hover');
 
@@ -11906,7 +12047,7 @@
 
                     // update text
                     if (tooltip.split) {
-                        this.renderSplit(text, chart.hoverPoints);
+                        this.renderSplit(text, pointOrPoints);
                     } else {
                         label.attr({
                             text: text && text.join ? text.join('') : text
@@ -12201,7 +12342,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var addEvent = H.addEvent,
             attr = H.attr,
             charts = H.charts,
@@ -12338,91 +12478,57 @@
                 });
                 return coordinates;
             },
-
             /**
-             * With line type charts with a single tracker, get the point closest to the mouse.
-             * Run Point.onMouseOver and display tooltip for the point or points.
+             * Collects the points closest to a mouseEvent
+             * @param  {Array} series Array of series to gather points from
+             * @param  {Boolean} shared True if shared tooltip, otherwise false
+             * @param  {Object} e Mouse event which possess a position to compare against
+             * @return {Array} KDPoints sorted by distance
              */
-            runPointActions: function(e) {
-
-                var pointer = this,
-                    chart = pointer.chart,
-                    series = chart.series,
-                    tooltip = chart.tooltip,
-                    shared = tooltip ? tooltip.shared : false,
-                    followPointer,
-                    updatePosition = true,
-                    hoverPoint = chart.hoverPoint,
-                    hoverSeries = chart.hoverSeries,
-                    i,
-                    anchor,
+            getKDPoints: function(series, shared, e) {
+                var kdpoints = [],
                     noSharedTooltip,
-                    stickToHoverSeries,
                     directTouch,
-                    kdpoints = [],
-                    kdpointT;
-
-                // For hovering over the empty parts of the plot area (hoverSeries is undefined).
-                // If there is one series with point tracking (combo chart), don't go to nearest neighbour.
-                if (!shared && !hoverSeries) {
-                    for (i = 0; i < series.length; i++) {
-                        if (series[i].directTouch || !series[i].options.stickyTracking) {
-                            series = [];
-                        }
-                    }
-                }
-
-                // If it has a hoverPoint and that series requires direct touch (like columns, #3899), or we're on
-                // a noSharedTooltip series among shared tooltip series (#4546), use the hoverPoint . Otherwise,
-                // search the k-d tree.
-                stickToHoverSeries = hoverSeries && (shared ? hoverSeries.noSharedTooltip : hoverSeries.directTouch);
-                if (stickToHoverSeries && hoverPoint) {
-                    kdpoints = [hoverPoint];
+                    kdpointT,
+                    i;
 
-                    // Handle shared tooltip or cases where a series is not yet hovered
-                } else {
-                    // When we have non-shared tooltip and sticky tracking is disabled,
-                    // search for the closest point only on hovered series: #5533, #5476
-                    if (!shared && hoverSeries && !hoverSeries.options.stickyTracking) {
-                        series = [hoverSeries];
-                    }
-                    // Find nearest points on all series
-                    each(series, function(s) {
-                        // Skip hidden series
-                        noSharedTooltip = s.noSharedTooltip && shared;
-                        directTouch = !shared && s.directTouch;
-                        if (s.visible && !noSharedTooltip && !directTouch && pick(s.options.enableMouseTracking, true)) { // #3821
-                            kdpointT = s.searchPoint(e, !noSharedTooltip && s.kdDimensions === 1); // #3828
-                            if (kdpointT && kdpointT.series) { // Point.series becomes null when reset and before redraw (#5197)
-                                kdpoints.push(kdpointT);
-                            }
+                // Find nearest points on all series
+                each(series, function(s) {
+                    // Skip hidden series
+                    noSharedTooltip = s.noSharedTooltip && shared;
+                    directTouch = !shared && s.directTouch;
+                    if (s.visible && !noSharedTooltip && !directTouch && pick(s.options.enableMouseTracking, true)) { // #3821
+                        kdpointT = s.searchPoint(e, !noSharedTooltip && s.kdDimensions === 1); // #3828
+                        if (kdpointT && kdpointT.series) { // Point.series becomes null when reset and before redraw (#5197)
+                            kdpoints.push(kdpointT);
                         }
-                    });
-
-                    // Sort kdpoints by distance to mouse pointer
-                    kdpoints.sort(function(p1, p2) {
-                        var isCloserX = p1.distX - p2.distX,
-                            isCloser = p1.dist - p2.dist,
-                            isAbove = (p2.series.group && p2.series.group.zIndex) -
-                            (p1.series.group && p1.series.group.zIndex);
+                    }
+                });
 
-                        // We have two points which are not in the same place on xAxis and shared tooltip:
-                        if (isCloserX !== 0 && shared) { // #5721
-                            return isCloserX;
-                        }
+                // Sort kdpoints by distance to mouse pointer
+                kdpoints.sort(function(p1, p2) {
+                    var isCloserX = p1.distX - p2.distX,
+                        isCloser = p1.dist - p2.dist,
+                        isAbove =
+                        (p2.series.group && p2.series.group.zIndex) -
+                        (p1.series.group && p1.series.group.zIndex),
+                        result;
+
+                    // We have two points which are not in the same place on xAxis and shared tooltip:
+                    if (isCloserX !== 0 && shared) { // #5721
+                        result = isCloserX;
                         // Points are not exactly in the same place on x/yAxis:
-                        if (isCloser !== 0) {
-                            return isCloser;
-                        }
+                    } else if (isCloser !== 0) {
+                        result = isCloser;
                         // The same xAxis and yAxis position, sort by z-index:
-                        if (isAbove !== 0) {
-                            return isAbove;
-                        }
-
+                    } else if (isAbove !== 0) {
+                        result = isAbove;
                         // The same zIndex, sort by array index:
-                        return p1.series.index > p2.series.index ? -1 : 1;
-                    });
-                }
+                    } else {
+                        result = p1.series.index > p2.series.index ? -1 : 1;
+                    }
+                    return result;
+                });
 
                 // Remove points with different x-positions, required for shared tooltip and crosshairs (#4645):
                 if (shared) {
@@ -12433,57 +12539,173 @@
                         }
                     }
                 }
+                return kdpoints;
+            },
+            getPointFromEvent: function(e) {
+                var target = e.target,
+                    point;
+
+                while (target && !point) {
+                    point = target.point;
+                    target = target.parentNode;
+                }
+                return point;
+            },
 
-                // Refresh tooltip for kdpoint if new hover point or tooltip was hidden // #3926, #4200
-                if (kdpoints[0] && (kdpoints[0] !== this.prevKDPoint || (tooltip && tooltip.isHidden))) {
-                    // Draw tooltip if necessary
-                    if (shared && !kdpoints[0].series.noSharedTooltip) {
-                        // Do mouseover on all points (#3919, #3985, #4410, #5622)
-                        for (i = 0; i < kdpoints.length; i++) {
-                            kdpoints[i].onMouseOver(e, kdpoints[i] !== ((hoverSeries && hoverSeries.directTouch && hoverPoint) || kdpoints[0]));
-                        }
+            getHoverData: function(existingHoverPoint, existingHoverSeries, series, isDirectTouch, shared, e) {
+                var i,
+                    hoverPoint = existingHoverPoint,
+                    hoverSeries = existingHoverSeries,
+                    hoverPoints;
 
-                        if (kdpoints.length && tooltip) {
-                            // Keep the order of series in tooltip:
-                            tooltip.refresh(kdpoints.sort(function(p1, p2) {
-                                return p1.series.index - p2.series.index;
-                            }), e);
+                // If it has a hoverPoint and that series requires direct touch (like columns, #3899), or we're on
+                // a noSharedTooltip series among shared tooltip series (#4546), use the hoverPoint . Otherwise,
+                // search the k-d tree.
+                // Handle shared tooltip or cases where a series is not yet hovered
+                if (isDirectTouch) {
+                    if (shared) {
+                        hoverPoints = [];
+                        each(series, function(s) {
+                            // Skip hidden series
+                            var noSharedTooltip = s.noSharedTooltip && shared,
+                                directTouch = !shared && s.directTouch,
+                                kdpointT;
+                            if (s.visible && !noSharedTooltip && !directTouch && pick(s.options.enableMouseTracking, true)) { // #3821
+                                kdpointT = s.searchKDTree({
+                                    clientX: hoverPoint.clientX,
+                                    plotY: hoverPoint.plotY
+                                }, !noSharedTooltip && s.kdDimensions === 1);
+                                if (kdpointT && kdpointT.series) { // Point.series becomes null when reset and before redraw (#5197)
+                                    hoverPoints.push(kdpointT);
+                                }
+                            }
+                        });
+                        // If kdTree is not built
+                        if (hoverPoints.length === 0) {
+                            hoverPoints = [hoverPoint];
                         }
                     } else {
-                        if (tooltip) {
-                            tooltip.refresh(kdpoints[0], e);
-                        }
-                        if (!hoverSeries || !hoverSeries.directTouch) { // #4448
-                            kdpoints[0].onMouseOver(e);
+                        hoverPoints = [hoverPoint];
+                    }
+                } else if (hoverSeries && !hoverSeries.options.stickyTracking) {
+                    hoverPoints = this.getKDPoints([hoverSeries], shared, e);
+                    hoverPoint = hoverPoints[0];
+                    hoverSeries = hoverPoint && hoverPoint.series;
+                } else {
+                    if (!shared) {
+                        // For hovering over the empty parts of the plot area (hoverSeries is undefined).
+                        // If there is one series with point tracking (combo chart), don't go to nearest neighbour.
+                        if (!hoverSeries) {
+                            for (i = 0; i < series.length; i++) {
+                                if (series[i].directTouch || !series[i].options.stickyTracking) {
+                                    series = [];
+                                }
+                            }
+                            // When we have non-shared tooltip and sticky tracking is disabled,
+                            // search for the closest point only on hovered series: #5533, #5476
+                        } else if (!hoverSeries.options.stickyTracking) {
+                            series = [hoverSeries];
                         }
                     }
-                    this.prevKDPoint = kdpoints[0];
-                    updatePosition = false;
+                    hoverPoints = this.getKDPoints(series, shared, e);
+                    hoverPoint = hoverPoints[0];
+                    hoverSeries = hoverPoint && hoverPoint.series;
                 }
-                // Update positions (regardless of kdpoint or hoverPoint)
-                if (updatePosition) {
-                    followPointer = hoverSeries && hoverSeries.tooltipOptions.followPointer;
-                    if (tooltip && followPointer && !tooltip.isHidden) {
-                        anchor = tooltip.getAnchor([{}], e);
-                        tooltip.updatePosition({
-                            plotX: anchor[0],
-                            plotY: anchor[1]
-                        });
+                // Keep the order of series in tooltip
+                // Must be done after assigning of hoverPoint
+                hoverPoints.sort(function(p1, p2) {
+                    return p1.series.index - p2.series.index;
+                });
+
+                return {
+                    hoverPoint: hoverPoint,
+                    hoverSeries: hoverSeries,
+                    hoverPoints: hoverPoints
+                };
+            },
+            /**
+             * With line type charts with a single tracker, get the point closest to the mouse.
+             * Run Point.onMouseOver and display tooltip for the point or points.
+             */
+            runPointActions: function(e, p) {
+                var pointer = this,
+                    chart = pointer.chart,
+                    series = chart.series,
+                    tooltip = chart.tooltip,
+                    shared = tooltip ? tooltip.shared : false,
+                    hoverPoint = p || chart.hoverPoint,
+                    hoverSeries = hoverPoint && hoverPoint.series || chart.hoverSeries,
+                    // onMouseOver or already hovering a series with directTouch
+                    isDirectTouch = !!p || (hoverSeries && hoverSeries.directTouch),
+                    hoverData = this.getHoverData(hoverPoint, hoverSeries, series, isDirectTouch, shared, e),
+                    useSharedTooltip,
+                    followPointer,
+                    anchor,
+                    points;
+
+                // Update variables from hoverData.
+                hoverPoint = hoverData.hoverPoint;
+                hoverSeries = hoverData.hoverSeries;
+                followPointer = hoverSeries && hoverSeries.tooltipOptions.followPointer;
+                useSharedTooltip = shared && hoverPoint && !hoverPoint.series.noSharedTooltip;
+                points = useSharedTooltip ? hoverData.hoverPoints : [hoverPoint];
+
+                // Refresh tooltip for kdpoint if new hover point or tooltip was hidden // #3926, #4200
+                if (
+                    hoverPoint &&
+                    // !(hoverSeries && hoverSeries.directTouch) &&
+                    (hoverPoint !== chart.hoverPoint || (tooltip && tooltip.isHidden))
+                ) {
+                    each(chart.hoverPoints || [], function(p) {
+                        if (H.inArray(p, points) === -1) {
+                            p.setState();
+                        }
+                    });
+                    // Do mouseover on all points (#3919, #3985, #4410, #5622)
+                    each(points || [], function(p) {
+                        p.setState('hover');
+                    });
+                    // set normal state to previous series
+                    if (chart.hoverSeries !== hoverSeries) {
+                        hoverSeries.onMouseOver();
+                    }
+
+                    // If tracking is on series in stead of on each point, 
+                    // fire mouseOver on hover point. 
+                    if (hoverSeries && !hoverSeries.directTouch) { // #4448
+                        if (chart.hoverPoint) {
+                            chart.hoverPoint.firePointEvent('mouseOut');
+                        }
+                        hoverPoint.firePointEvent('mouseOver');
                     }
+                    chart.hoverPoints = points;
+                    chart.hoverPoint = hoverPoint;
+                    // Draw tooltip if necessary
+                    if (tooltip) {
+                        tooltip.refresh(useSharedTooltip ? points : hoverPoint, e);
+                    }
+                    // Update positions (regardless of kdpoint or hoverPoint)
+                } else if (followPointer && tooltip && !tooltip.isHidden) {
+                    anchor = tooltip.getAnchor([{}], e);
+                    tooltip.updatePosition({
+                        plotX: anchor[0],
+                        plotY: anchor[1]
+                    });
                 }
 
                 // Start the event listener to pick up the tooltip and crosshairs
                 if (!pointer.unDocMouseMove) {
                     pointer.unDocMouseMove = addEvent(doc, 'mousemove', function(e) {
-                        if (charts[H.hoverChartIndex]) {
-                            charts[H.hoverChartIndex].pointer.onDocumentMouseMove(e);
+                        var chart = charts[H.hoverChartIndex];
+                        if (chart) {
+                            chart.pointer.onDocumentMouseMove(e);
                         }
                     });
                 }
 
                 // Crosshair. For each hover point, loop over axes and draw cross if that point
                 // belongs to the axis (#4927).
-                each(shared ? kdpoints : [pick(hoverPoint, kdpoints[0])], function drawPointCrosshair(point) { // #5269
+                each(points, function drawPointCrosshair(point) { // #5269
                     each(chart.axes, function drawAxisCrosshair(axis) {
                         // In case of snap = false, point is undefined, and we draw the crosshair anyway (#5066)
                         if (!point || point.series && point.series[axis.coll] === axis) { // #5658
@@ -12560,7 +12782,7 @@
                         axis.hideCrosshair();
                     });
 
-                    pointer.hoverX = pointer.prevKDPoint = chart.hoverPoints = chart.hoverPoint = null;
+                    pointer.hoverX = chart.hoverPoints = chart.hoverPoint = null;
                 }
             },
 
@@ -12981,7 +13203,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var charts = H.charts,
             each = H.each,
             extend = H.extend,
@@ -13259,7 +13480,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var addEvent = H.addEvent,
             charts = H.charts,
             css = H.css,
@@ -13379,7 +13599,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var Legend,
 
             addEvent = H.addEvent,
@@ -13387,7 +13606,6 @@
             discardElement = H.discardElement,
             defined = H.defined,
             each = H.each,
-            extend = H.extend,
             isFirefox = H.isFirefox,
             marginNames = H.marginNames,
             merge = H.merge,
@@ -13580,7 +13798,17 @@
                     each(['legendItem', 'legendGroup'], destroyItems, item);
                 });
 
-                each(['box', 'title', 'group'], destroyItems, this);
+                // Destroy legend elements
+                each([
+                    'clipRect',
+                    'up',
+                    'down',
+                    'pager',
+                    'nav',
+                    'box',
+                    'title',
+                    'group'
+                ], destroyItems, this);
                 this.display = null; // Reset in .render on update.
             },
 
@@ -13628,9 +13856,9 @@
                                 zIndex: 1
                             })
 
-                        .css(titleOptions.style)
+                            .css(titleOptions.style)
 
-                        .add(this.group);
+                            .add(this.group);
                     }
                     bBox = this.title.getBBox();
                     titleHeight = bBox.height;
@@ -13702,15 +13930,15 @@
 
                     // Generate the list item text and add it to the group
                     item.legendItem = li = renderer.text(
-                        '',
-                        ltr ? symbolWidth + symbolPadding : -symbolPadding,
-                        legend.baseline || 0,
-                        useHTML
-                    )
+                            '',
+                            ltr ? symbolWidth + symbolPadding : -symbolPadding,
+                            legend.baseline || 0,
+                            useHTML
+                        )
 
-                    .css(merge(item.visible ? itemStyle : itemHiddenStyle)) // merge to prevent modifying original (#1021)
+                        .css(merge(item.visible ? itemStyle : itemHiddenStyle)) // merge to prevent modifying original (#1021)
 
-                    .attr({
+                        .attr({
                             align: ltr ? 'left' : 'right',
                             zIndex: 2
                         })
@@ -13982,10 +14210,10 @@
                 }*/
 
                 if (display) {
-                    legendGroup.align(extend({
+                    legendGroup.align(merge(options, {
                         width: legendWidth,
                         height: legendHeight
-                    }, options), true, 'spacingBox');
+                    }), true, 'spacingBox');
                 }
 
                 if (!chart.isResizing) {
@@ -14093,9 +14321,9 @@
                         this.pager = renderer.text('', 15, 10)
                             .addClass('highcharts-legend-navigation')
 
-                        .css(navOptions.style)
+                            .css(navOptions.style)
 
-                        .add(nav);
+                            .add(nav);
                         this.down = renderer.symbol('triangle-down', 0, 0, arrowSize, arrowSize)
                             .on('click', function() {
                                 legend.scroll(1, animation);
@@ -14111,7 +14339,7 @@
                     // Reset
                 } else if (nav) {
                     clipToHeight();
-                    nav.hide();
+                    this.nav = nav.destroy(); // #6322
                     this.scrollGroup.attr({
                         translateY: 1
                     });
@@ -14329,7 +14557,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var addEvent = H.addEvent,
             animate = H.animate,
             animObject = H.animObject,
@@ -14416,7 +14643,6 @@
                 options = merge(defaultOptions, userOptions); // do the merge
                 options.series = userOptions.series = seriesOptions; // set back the series data
                 this.userOptions = userOptions;
-                this.respRules = [];
 
                 var optionsChart = options.chart;
 
@@ -14565,8 +14791,7 @@
                     hasDirtyStacks,
                     hasCartesianSeries = chart.hasCartesianSeries,
                     isDirtyBox = chart.isDirtyBox,
-                    seriesLength = series.length,
-                    i = seriesLength,
+                    i,
                     serie,
                     renderer = chart.renderer,
                     isHiddenChart = renderer.isHidden(),
@@ -14587,6 +14812,7 @@
                 chart.layOutTitles();
 
                 // link stacked series
+                i = series.length;
                 while (i--) {
                     serie = series[i];
 
@@ -14600,7 +14826,7 @@
                     }
                 }
                 if (hasDirtyStacks) { // mark others as dirty
-                    i = seriesLength;
+                    i = series.length;
                     while (i--) {
                         serie = series[i];
                         if (serie.options.stacking) {
@@ -14948,7 +15174,10 @@
                 );
                 chart.chartHeight = Math.max(
                     0,
-                    heightOption || chart.containerHeight || 400
+                    H.relativeLength(
+                        heightOption,
+                        chart.chartWidth
+                    ) || chart.containerHeight || 400
                 );
             },
 
@@ -15735,9 +15964,9 @@
                             zIndex: 8
                         })
 
-                    .css(credits.style)
+                        .css(credits.style)
 
-                    .add()
+                        .add()
                         .align(credits.position);
 
                     // Dynamically update
@@ -15931,7 +16160,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var Point,
 
             each = H.each,
@@ -16282,7 +16510,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var addEvent = H.addEvent,
             animObject = H.animObject,
             arrayMax = H.arrayMax,
@@ -16415,6 +16642,9 @@
             states: { // states for the entire series
                 hover: {
                     //enabled: false,
+                    animation: {
+                        duration: 50
+                    },
                     lineWidthPlus: 1,
                     marker: {
                         // lineWidth: base + 1,
@@ -16440,7 +16670,7 @@
             //ySuffix: ''
             //}
             turboThreshold: 1000
-                // zIndex: null
+            // zIndex: null
 
 
         }, /** @lends Series.prototype */ {
@@ -17122,7 +17352,7 @@
 
                     // For points within the visible range, including the first point outside the
                     // visible range, consider y extremes
-                    validValue = (isNumber(y, true) || isArray(y)) && (!yAxis.isLog || (y.length || y > 0));
+                    validValue = (isNumber(y, true) || isArray(y)) && (!yAxis.positiveValuesOnly || (y.length || y > 0));
                     withinRange = this.getExtremesFromAll || this.options.getExtremesFromAll || this.cropped ||
                         ((xData[i + 1] || x) >= xMin && (xData[i - 1] || x) <= xMax);
 
@@ -17196,7 +17426,7 @@
                         stackValues;
 
                     // Discard disallowed y values for log axes (#3434)
-                    if (yAxis.isLog && yValue !== null && yValue <= 0) {
+                    if (yAxis.positiveValuesOnly && yValue !== null && yValue <= 0) {
                         point.isNull = true;
                     }
 
@@ -17224,7 +17454,7 @@
                         if (yBottom === stackThreshold && stackIndicator.key === stack[xValue].base) {
                             yBottom = pick(threshold, yAxis.min);
                         }
-                        if (yAxis.isLog && yBottom <= 0) { // #1200, #1232
+                        if (yAxis.positiveValuesOnly && yBottom <= 0) { // #1200, #1232
                             yBottom = null;
                         }
 
@@ -17431,7 +17661,8 @@
                     globallyEnabled = pick(
                         seriesMarkerOptions.enabled,
                         xAxis.isRadial ? true : null,
-                        series.closestPointRangePx > 2 * seriesMarkerOptions.radius
+                        // Use larger or equal as radius is null in bubbles (#6321)
+                        series.closestPointRangePx >= 2 * seriesMarkerOptions.radius
                     );
 
                 if (seriesMarkerOptions.enabled !== false || series._hasPointMarkers) {
@@ -17982,6 +18213,15 @@
                 function setInvert() {
                     each(['group', 'markerGroup'], function(groupName) {
                         if (series[groupName]) {
+
+                            // VML/HTML needs explicit attributes for flipping
+                            if (chart.renderer.isVML) {
+                                series[groupName].attr({
+                                    width: series.yAxis.len,
+                                    height: series.xAxis.len
+                                });
+                            }
+
                             series[groupName].width = series.yAxis.len;
                             series[groupName].height = series.xAxis.len;
                             series[groupName].invert(inverted);
@@ -18329,7 +18569,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var Axis = H.Axis,
             Chart = H.Chart,
             correctFloat = H.correctFloat,
@@ -18815,7 +19054,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var addEvent = H.addEvent,
             animate = H.animate,
             Axis = H.Axis,
@@ -19063,6 +19301,7 @@
                 // options.title => chart.title
                 // options.tooltip => chart.tooltip
                 // options.subtitle => chart.subtitle
+                // options.mapNavigation => chart.mapNavigation
                 // options.navigator => chart.navigator
                 // options.scrollbar => chart.scrollbar
                 for (key in options) {
@@ -19094,7 +19333,6 @@
                 // item in the collection, so setting one series without an id, will
                 // update the first series in the chart. Setting two series without
                 // an id will update the first and the second respectively (#6019)
-                // // docs: New behaviour for unidentified items, add it to docs for 
                 // chart.update and responsive.
                 each(['xAxis', 'yAxis', 'series'], function(coll) {
                     if (options[coll]) {
@@ -19194,9 +19432,15 @@
                     i = point.index;
                     series.updateParallelArrays(point, i);
 
-                    // Record the options to options.data. If there is an object from before,
-                    // use point options, otherwise use raw options. (#4701)
-                    seriesOptions.data[i] = isObject(seriesOptions.data[i], true) ? point.options : options;
+                    // Record the options to options.data. If the old or the new config
+                    // is an object, use point options, otherwise use raw options
+                    // (#4701, #4916).
+                    seriesOptions.data[i] = (
+                            isObject(seriesOptions.data[i], true) ||
+                            isObject(options, true)
+                        ) ?
+                        point.options :
+                        options;
 
                     // redraw
                     series.isDirty = series.isDirtyData = true;
@@ -19403,7 +19647,7 @@
                     // must use user options when changing type because this.options is merged
                     // in with type specific plotOptions
                     oldOptions = this.userOptions,
-                    oldType = this.type,
+                    oldType = this.oldType || this.type,
                     newType = newOptions.type || oldOptions.type || chart.options.chart.type,
                     proto = seriesTypes[oldType].prototype,
                     preserve = ['group', 'markerGroup', 'dataLabelsGroup'],
@@ -19443,6 +19687,7 @@
                 });
 
                 this.init(chart, newOptions);
+                this.oldType = oldType;
                 chart.linkSeries(); // Links are lost in this.remove (#3028)
                 if (pick(redraw, true)) {
                     chart.redraw(false);
@@ -19533,7 +19778,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var color = H.color,
             each = H.each,
             LegendSymbolMixin = H.LegendSymbolMixin,
@@ -19550,10 +19794,10 @@
         seriesType('area', 'line', {
             softThreshold: false,
             threshold: 0
-                // trackByArea: false,
-                // lineColor: null, // overrides color, but lets fillColor be unaltered
-                // fillOpacity: 0.75,
-                // fillColor: null
+            // trackByArea: false,
+            // lineColor: null, // overrides color, but lets fillColor be unaltered
+            // fillOpacity: 0.75,
+            // fillColor: null
         }, /** @lends seriesTypes.area.prototype */ {
             singleStacks: false,
             /** 
@@ -19658,11 +19902,11 @@
                                 // When reversedStacks is true, loop up, else loop down
                                 i += upOrDown;
                             }
-
-                            y = yAxis.toPixels(y, true);
+                            y = yAxis.translate(y, 0, 1, 0, 1); // #6272
                             segment.push({
                                 isNull: true,
-                                plotX: xAxis.toPixels(x, true),
+                                plotX: xAxis.translate(x, 0, 0, 0, 1), // #6272
+                                x: x,
                                 plotY: y,
                                 yBottom: y
                             });
@@ -19723,7 +19967,8 @@
                             graphPoints.push({
                                 plotX: plotX,
                                 plotY: top === null ? translatedThreshold : yAxis.getThreshold(top),
-                                isNull: isNull
+                                isNull: isNull,
+                                isCliff: true
                             });
                             bottomPoints.push({
                                 plotX: plotX,
@@ -19780,6 +20025,7 @@
 
                 areaPath.xMap = topPath.xMap;
                 this.areaPath = areaPath;
+
                 return graphPath;
             },
 
@@ -19863,7 +20109,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var pick = H.pick,
             seriesType = H.seriesType;
 
@@ -19890,7 +20135,10 @@
                     ret;
 
                 function doCurve(otherPoint) {
-                    return otherPoint && !otherPoint.isNull && otherPoint.doCurve !== false;
+                    return otherPoint &&
+                        !otherPoint.isNull &&
+                        otherPoint.doCurve !== false &&
+                        !point.isCliff; // #6387, area splines next to null
                 }
 
                 // Find control points
@@ -19999,7 +20247,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var areaProto = H.seriesTypes.area.prototype,
             defaultPlotOptions = H.defaultPlotOptions,
             LegendSymbolMixin = H.LegendSymbolMixin,
@@ -20022,7 +20269,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var animObject = H.animObject,
             color = H.color,
             each = H.each,
@@ -20082,7 +20328,7 @@
             threshold: 0,
 
             borderColor: '#ffffff'
-                // borderWidth: 1
+            // borderWidth: 1
 
 
         }, /** @lends seriesTypes.column.prototype */ {
@@ -20343,7 +20589,10 @@
 
                 // Select or hover states
                 if (state) {
-                    stateOptions = options.states[state];
+                    stateOptions = merge(
+                        options.states[state],
+                        point.options.states && point.options.states[state] || {} // #6401
+                    );
                     brightness = stateOptions.brightness;
                     fill = stateOptions.color ||
                         (brightness !== undefined && color(fill).brighten(stateOptions.brightness).get()) ||
@@ -20398,9 +20647,6 @@
 
                         } else {
                             point.graphic = graphic = renderer[point.shapeType](shapeArgs)
-                                .attr({
-                                    'class': point.getClassName()
-                                })
                                 .add(point.group || series.group);
                         }
 
@@ -20411,6 +20657,9 @@
                             .shadow(options.shadow, null, options.stacking && !options.borderRadius);
 
 
+                        graphic.addClass(point.getClassName(), true);
+
+
                     } else if (graphic) {
                         point.graphic = graphic.destroy(); // #1269
                     }
@@ -20486,7 +20735,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
 
         var seriesType = H.seriesType;
 
@@ -20504,7 +20752,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var Series = H.Series,
             seriesType = H.seriesType;
         /**
@@ -20545,7 +20792,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var pick = H.pick,
             relativeLength = H.relativeLength;
 
@@ -20595,7 +20841,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var addEvent = H.addEvent,
             CenteredSeriesMixin = H.CenteredSeriesMixin,
             defined = H.defined,
@@ -20633,7 +20878,7 @@
                 },
                 // softConnector: true,
                 x: 0
-                    // y: 0
+                // y: 0
             },
             ignoreHiddenPoint: true,
             //innerSize: 0,
@@ -20880,8 +21125,9 @@
                         shapeArgs = point.shapeArgs;
 
 
-                        // if the point is sliced, use special translation, else use plot area traslation
-                        groupTranslation = point.sliced ? point.slicedTranslation : {};
+                        // If the point is sliced, use special translation, else use
+                        // plot area traslation
+                        groupTranslation = point.getTranslate();
 
 
                         // Put the shadow behind all points
@@ -20902,13 +21148,12 @@
                             graphic
                                 .setRadialReference(series.center)
 
-                            .attr(pointAttr)
+                                .attr(pointAttr)
 
-                            .animate(extend(shapeArgs, groupTranslation));
+                                .animate(extend(shapeArgs, groupTranslation));
                         } else {
 
                             point.graphic = graphic = renderer[point.shapeType](shapeArgs)
-                                .addClass(point.getClassName())
                                 .setRadialReference(series.center)
                                 .attr(groupTranslation)
                                 .add(series.group);
@@ -20928,6 +21173,9 @@
                                 .shadow(shadow, shadowGroup);
 
                         }
+
+                        graphic.addClass(point.getClassName());
+
                     }
                 });
 
@@ -21043,8 +21291,7 @@
             slice: function(sliced, redraw, animation) {
                 var point = this,
                     series = point.series,
-                    chart = series.chart,
-                    translation;
+                    chart = series.chart;
 
                 setAnimation(animation, chart);
 
@@ -21055,20 +21302,22 @@
                 point.sliced = point.options.sliced = sliced = defined(sliced) ? sliced : !point.sliced;
                 series.options.data[inArray(point, series.data)] = point.options; // update userOptions.data
 
-                translation = sliced ? point.slicedTranslation : {
-                    translateX: 0,
-                    translateY: 0
-                };
-
-                point.graphic.animate(translation);
+                point.graphic.animate(this.getTranslate());
 
 
                 if (point.shadowGroup) {
-                    point.shadowGroup.animate(translation);
+                    point.shadowGroup.animate(this.getTranslate());
                 }
 
             },
 
+            getTranslate: function() {
+                return this.sliced ? this.slicedTranslation : {
+                    translateX: 0,
+                    translateY: 0
+                };
+            },
+
             haloPath: function(size) {
                 var shapeArgs = this.shapeArgs;
 
@@ -21093,7 +21342,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var addEvent = H.addEvent,
             arrayMax = H.arrayMax,
             defined = H.defined,
@@ -21584,6 +21832,21 @@
                     return;
                 }
 
+                // Reset all labels that have been shortened
+                each(data, function(point) {
+                    if (point.dataLabel && point.visible && point.dataLabel.shortened) {
+                        point.dataLabel
+                            .attr({
+                                width: 'auto'
+                            }).css({
+                                width: 'auto',
+                                textOverflow: 'clip'
+                            });
+                        point.dataLabel.shortened = false;
+                    }
+                });
+
+
                 // run parent method
                 Series.prototype.drawDataLabels.apply(series);
 
@@ -21608,6 +21871,7 @@
                         length = points.length,
                         positions,
                         naturalY,
+                        sideOverflow,
                         size;
 
                     if (!length) {
@@ -21683,24 +21947,39 @@
 
                         // Detect overflowing data labels
                         if (series.options.size === null) {
-                            dataLabelWidth = dataLabel.width;
+                            dataLabelWidth = dataLabel.getBBox().width;
+
+                            sideOverflow = null;
                             // Overflow left
                             if (x - dataLabelWidth < connectorPadding) {
-                                overflow[3] = Math.max(Math.round(dataLabelWidth - x + connectorPadding), overflow[3]);
+                                sideOverflow = Math.round(
+                                    dataLabelWidth - x + connectorPadding
+                                );
+                                overflow[3] = Math.max(sideOverflow, overflow[3]);
 
                                 // Overflow right
                             } else if (x + dataLabelWidth > plotWidth - connectorPadding) {
-                                overflow[1] = Math.max(Math.round(x + dataLabelWidth - plotWidth + connectorPadding), overflow[1]);
+                                sideOverflow = Math.round(
+                                    x + dataLabelWidth - plotWidth + connectorPadding
+                                );
+                                overflow[1] = Math.max(sideOverflow, overflow[1]);
                             }
 
                             // Overflow top
                             if (y - labelHeight / 2 < 0) {
-                                overflow[0] = Math.max(Math.round(-y + labelHeight / 2), overflow[0]);
+                                overflow[0] = Math.max(
+                                    Math.round(-y + labelHeight / 2),
+                                    overflow[0]
+                                );
 
                                 // Overflow left
                             } else if (y + labelHeight / 2 > plotHeight) {
-                                overflow[2] = Math.max(Math.round(y + labelHeight / 2 - plotHeight), overflow[2]);
+                                overflow[2] = Math.max(
+                                    Math.round(y + labelHeight / 2 - plotHeight),
+                                    overflow[2]
+                                );
                             }
+                            dataLabel.sideOverflow = sideOverflow;
                         }
                     } // for each point
                 }); // for each half
@@ -21784,10 +22063,22 @@
                 each(this.points, function(point) {
                     var dataLabel = point.dataLabel,
                         _pos;
-
                     if (dataLabel && point.visible) {
                         _pos = dataLabel._pos;
                         if (_pos) {
+
+                            // Shorten data labels with ellipsis if they still overflow
+                            // after the pie has reached minSize (#223).
+                            if (dataLabel.sideOverflow) {
+                                dataLabel._attr.width =
+                                    dataLabel.getBBox().width - dataLabel.sideOverflow;
+                                dataLabel.css({
+                                    width: dataLabel._attr.width + 'px',
+                                    textOverflow: 'ellipsis'
+                                });
+                                dataLabel.shortened = true;
+                            }
+
                             dataLabel.attr(dataLabel._attr);
                             dataLabel[dataLabel.moved ? 'animate' : 'attr'](_pos);
                             dataLabel.moved = true;
@@ -21797,7 +22088,7 @@
                             });
                         }
                     }
-                });
+                }, this);
             };
 
             seriesTypes.pie.prototype.alignDataLabel = noop;
@@ -21930,7 +22221,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         /**
          * Highcharts module to hide overlapping data labels. This module is included in Highcharts.
          */
@@ -21945,7 +22235,7 @@
             function collectAndHide() {
                 var labels = [];
 
-                each(chart.series, function(series) {
+                each(chart.series || [], function(series) {
                     var dlOptions = series.options.dataLabels,
                         collections = series.dataLabelCollections || ['dataLabel']; // Range series have two collections
                     if ((dlOptions.enabled || series._hasPointLabels) && !dlOptions.allowOverlap && series.visible) { // #3866
@@ -22079,7 +22369,6 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var addEvent = H.addEvent,
             Chart = H.Chart,
             createElement = H.createElement,
@@ -22116,15 +22405,10 @@
                     chart = series.chart,
                     pointer = chart.pointer,
                     onMouseOver = function(e) {
-                        var target = e.target,
-                            point;
+                        var point = pointer.getPointFromEvent(e);
 
-                        while (target && !point) {
-                            point = target.point;
-                            target = target.parentNode;
-                        }
-
-                        if (point !== undefined && point !== chart.hoverPoint) { // undefined on graph in scatterchart
+                        // undefined on graph in scatterchart
+                        if (point !== undefined) {
                             point.onMouseOver(e);
                         }
                     };
@@ -22299,7 +22583,7 @@
 
             setItemEvents: function(item, legendItem, useHTML) {
                 var legend = this,
-                    chart = legend.chart,
+                    boxWrapper = legend.chart.renderer.boxWrapper,
                     activeClass = 'highcharts-legend-' + (item.series ? 'point' : 'series') + '-active';
 
                 // Set the events on the item group, or in case of useHTML, the item itself (#1249)
@@ -22307,7 +22591,7 @@
                         item.setState('hover');
 
                         // A CSS class to dim or hide other than the hovered series
-                        chart.seriesGroup.addClass(activeClass);
+                        boxWrapper.addClass(activeClass);
 
 
                         legendItem.css(legend.options.itemHoverStyle);
@@ -22319,7 +22603,7 @@
 
 
                         // A CSS class to dim or hide other than the hovered series
-                        chart.seriesGroup.removeClass(activeClass);
+                        boxWrapper.removeClass(activeClass);
 
                         item.setState();
                     })
@@ -22501,8 +22785,14 @@
                         flipped = panMax < panMin,
                         newMin = flipped ? panMax : panMin,
                         newMax = flipped ? panMin : panMax,
-                        distMin = Math.min(extremes.dataMin, extremes.min) - newMin,
-                        distMax = newMax - Math.max(extremes.dataMax, extremes.max);
+                        paddedMin = axis.toValue(
+                            axis.toPixels(extremes.min) - axis.minPixelPadding
+                        ),
+                        paddedMax = axis.toValue(
+                            axis.toPixels(extremes.max) + axis.minPixelPadding
+                        ),
+                        distMin = Math.min(extremes.dataMin, paddedMin) - newMin,
+                        distMax = newMax - Math.max(extremes.dataMax, paddedMax);
 
                     // Negative distMin and distMax means that we're still inside the
                     // data range.
@@ -22572,58 +22862,29 @@
 
             /**
              * Runs on mouse over the point
-             *
+             * 
              * @param {Object} e The event arguments
-             * @param {Boolean} byProximity Falsy for kd points that are closest to the mouse, or to
-             *        actually hovered points. True for other points in shared tooltip.
              */
-            onMouseOver: function(e, byProximity) {
+            onMouseOver: function(e) {
                 var point = this,
                     series = point.series,
                     chart = series.chart,
-                    tooltip = chart.tooltip,
-                    hoverPoint = chart.hoverPoint;
-
-                if (point.series) { // It may have been destroyed, #4130
-                    // In shared tooltip, call mouse over when point/series is actually hovered: (#5766)
-                    if (!byProximity) {
-                        // set normal state to previous series
-                        if (hoverPoint && hoverPoint !== point) {
-                            hoverPoint.onMouseOut();
-                        }
-                        if (chart.hoverSeries !== series) {
-                            series.onMouseOver();
-                        }
-                        chart.hoverPoint = point;
-                    }
-
-                    // update the tooltip
-                    if (tooltip && (!tooltip.shared || series.noSharedTooltip)) {
-                        // hover point only for non shared points: (#5766)
-                        point.setState('hover');
-                        tooltip.refresh(point, e);
-                    } else if (!tooltip) {
-                        point.setState('hover');
-                    }
-
-                    // trigger the event
-                    point.firePointEvent('mouseOver');
-                }
+                    pointer = chart.pointer;
+                point.firePointEvent('mouseOver');
+                pointer.runPointActions(e, point);
             },
 
             /**
              * Runs on mouse out from the point
              */
             onMouseOut: function() {
-                var chart = this.series.chart,
-                    hoverPoints = chart.hoverPoints;
-
-                this.firePointEvent('mouseOut');
-
-                if (!hoverPoints || inArray(this, hoverPoints) === -1) { // #887, #2240
-                    this.setState();
-                    chart.hoverPoint = null;
-                }
+                var point = this,
+                    chart = point.series.chart;
+                point.firePointEvent('mouseOut');
+                each(chart.hoverPoints || [], function(p) {
+                    p.setState();
+                });
+                chart.hoverPoints = chart.hoverPoint = null;
             },
 
             /**
@@ -22909,7 +23170,11 @@
                 if (series.state !== state) {
 
                     // Toggle class names
-                    each([series.group, series.markerGroup], function(group) {
+                    each([
+                        series.group,
+                        series.markerGroup,
+                        series.dataLabelsGroup
+                    ], function(group) {
                         if (group) {
                             // Old state
                             if (series.state) {
@@ -22938,8 +23203,16 @@
                         attribs = {
                             'stroke-width': lineWidth
                         };
-                        // use attr because animate will cause any other animation on the graph to stop
-                        graph.attr(attribs);
+
+                        // Animate the graph stroke-width. By default a quick animation
+                        // to hover, slower to un-hover.
+                        graph.animate(
+                            attribs,
+                            pick(
+                                series.chart.options.chart.animation,
+                                stateOptions[state] && stateOptions[state].animation
+                            )
+                        );
                         while (series['zone-graph-' + i]) {
                             series['zone-graph-' + i].attr(attribs);
                             i = i + 1;
@@ -23055,34 +23328,76 @@
          *
          * License: www.highcharts.com/license
          */
-        'use strict';
         var Chart = H.Chart,
             each = H.each,
             inArray = H.inArray,
+            isArray = H.isArray,
             isObject = H.isObject,
             pick = H.pick,
             splat = H.splat;
 
         /**
-         * Update the chart based on the current chart/document size and options for responsiveness
+         * Update the chart based on the current chart/document size and options for
+         * responsiveness.
          */
         Chart.prototype.setResponsive = function(redraw) {
-            var options = this.options.responsive;
+            var options = this.options.responsive,
+                ruleIds = [],
+                currentResponsive = this.currentResponsive,
+                currentRuleIds;
 
             if (options && options.rules) {
                 each(options.rules, function(rule) {
-                    this.matchResponsiveRule(rule, redraw);
+                    if (rule._id === undefined) {
+                        rule._id = H.uniqueKey();
+                    }
+
+                    this.matchResponsiveRule(rule, ruleIds, redraw);
                 }, this);
             }
+
+            // Merge matching rules
+            var mergedOptions = H.merge.apply(0, H.map(ruleIds, function(ruleId) {
+                return H.find(options.rules, function(rule) {
+                    return rule._id === ruleId;
+                }).chartOptions;
+            }));
+
+            // Stringified key for the rules that currently apply.
+            ruleIds = ruleIds.toString() || undefined;
+            currentRuleIds = currentResponsive && currentResponsive.ruleIds;
+
+
+            // Changes in what rules apply
+            if (ruleIds !== currentRuleIds) {
+
+                // Undo previous rules. Before we apply a new set of rules, we need to
+                // roll back completely to base options (#6291).
+                if (currentResponsive) {
+                    this.update(currentResponsive.undoOptions, redraw);
+                }
+
+                if (ruleIds) {
+                    // Get undo-options for matching rules
+                    this.currentResponsive = {
+                        ruleIds: ruleIds,
+                        mergedOptions: mergedOptions,
+                        undoOptions: this.currentOptions(mergedOptions)
+                    };
+
+                    this.update(mergedOptions, redraw);
+
+                } else {
+                    this.currentResponsive = undefined;
+                }
+            }
         };
 
         /**
          * Handle a single responsiveness rule
          */
-        Chart.prototype.matchResponsiveRule = function(rule, redraw) {
-            var respRules = this.respRules,
-                condition = rule.condition,
-                matches,
+        Chart.prototype.matchResponsiveRule = function(rule, matches) {
+            var condition = rule.condition,
                 fn = condition.callback || function() {
                     return this.chartWidth <= pick(condition.maxWidth, Number.MAX_VALUE) &&
                         this.chartHeight <= pick(condition.maxHeight, Number.MAX_VALUE) &&
@@ -23090,27 +23405,10 @@
                         this.chartHeight >= pick(condition.minHeight, 0);
                 };
 
-
-            if (rule._id === undefined) {
-                rule._id = H.uniqueKey();
+            if (fn.call(this)) {
+                matches.push(rule._id);
             }
-            matches = fn.call(this);
-
-            // Apply a rule
-            if (!respRules[rule._id] && matches) {
-
-                // Store the current state of the options
-                if (rule.chartOptions) {
-                    respRules[rule._id] = this.currentOptions(rule.chartOptions);
-                    this.update(rule.chartOptions, redraw);
-                }
 
-                // Unapply a rule based on the previous options before the rule
-                // was applied
-            } else if (respRules[rule._id] && !matches) {
-                this.update(respRules[rule._id], redraw);
-                delete respRules[rule._id];
-            }
         };
 
         /**
@@ -23133,17 +23431,22 @@
                         options[key] = splat(options[key]);
 
                         ret[key] = [];
+
+                        // Iterate over collections like series, xAxis or yAxis and map
+                        // the items by index.
                         for (i = 0; i < options[key].length; i++) {
-                            ret[key][i] = {};
-                            getCurrent(
-                                options[key][i],
-                                curr[key][i],
-                                ret[key][i],
-                                depth + 1
-                            );
+                            if (curr[key][i]) { // Item exists in current data (#6347)
+                                ret[key][i] = {};
+                                getCurrent(
+                                    options[key][i],
+                                    curr[key][i],
+                                    ret[key][i],
+                                    depth + 1
+                                );
+                            }
                         }
                     } else if (isObject(options[key])) {
-                        ret[key] = {};
+                        ret[key] = isArray(options[key]) ? [] : {};
                         getCurrent(
                             options[key],
                             curr[key] || {},