highcharts 8.1.0 → 8.2.2

package/modules/gantt.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts Gantt JS v8.1.0 (2020-05-05)
+ * @license Highcharts Gantt JS v8.2.2 (2020-10-22)
  *
  * Gantt series
  *
@@ -28,187 +28,7 @@
             obj[path] = fn.apply(null, args);
         }
     }
-    _registerModule(_modules, 'parts-gantt/CurrentDateIndicator.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js'], _modules['parts/PlotLineOrBand.js']], function (H, U, PlotLineOrBand) {
-        /* *
-         *
-         *  (c) 2016-2020 Highsoft AS
-         *
-         *  Author: Lars A. V. Cabrera
-         *
-         *  License: www.highcharts.com/license
-         *
-         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
-         *
-         * */
-        var addEvent = U.addEvent,
-            merge = U.merge,
-            wrap = U.wrap;
-        var Axis = H.Axis;
-        var defaultConfig = {
-                /**
-                 * Show an indicator on the axis for the current date and time. Can be a
-                 * boolean or a configuration object similar to
-                 * [xAxis.plotLines](#xAxis.plotLines).
-                 *
-                 * @sample gantt/current-date-indicator/demo
-                 *         Current date indicator enabled
-                 * @sample gantt/current-date-indicator/object-config
-                 *         Current date indicator with custom options
-                 *
-                 * @declare   Highcharts.AxisCurrentDateIndicatorOptions
-                 * @type      {boolean|*}
-                 * @default   true
-                 * @extends   xAxis.plotLines
-                 * @excluding value
-                 * @product   gantt
-                 * @apioption xAxis.currentDateIndicator
-                 */
-                currentDateIndicator: true,
-                color: '#ccd6eb',
-                width: 2,
-                /**
-                 * @declare Highcharts.AxisCurrentDateIndicatorLabelOptions
-                 */
-                label: {
-                    /**
-                     * Format of the label. This options is passed as the fist argument to
-                     * [dateFormat](/class-reference/Highcharts#dateFormat) function.
-                     *
-                     * @type      {string}
-                     * @default   '%a, %b %d %Y, %H:%M'
-                     * @product   gantt
-                     * @apioption xAxis.currentDateIndicator.label.format
-                     */
-                    format: '%a, %b %d %Y, %H:%M',
-                    formatter: function (value, format) {
-                        return H.dateFormat(format, value);
-                },
-                rotation: 0,
-                /**
-                 * @type {Highcharts.CSSObject}
-                 */
-                style: {
-                    /** @internal */
-                    fontSize: '10px'
-                }
-            }
-        };
-        /* eslint-disable no-invalid-this */
-        addEvent(Axis, 'afterSetOptions', function () {
-            var options = this.options,
-                cdiOptions = options.currentDateIndicator;
-            if (cdiOptions) {
-                cdiOptions = typeof cdiOptions === 'object' ?
-                    merge(defaultConfig, cdiOptions) : merge(defaultConfig);
-                cdiOptions.value = new Date();
-                if (!options.plotLines) {
-                    options.plotLines = [];
-                }
-                options.plotLines.push(cdiOptions);
-            }
-        });
-        addEvent(PlotLineOrBand, 'render', function () {
-            // If the label already exists, update its text
-            if (this.label) {
-                this.label.attr({
-                    text: this.getLabelText(this.options.label)
-                });
-            }
-        });
-        wrap(PlotLineOrBand.prototype, 'getLabelText', function (defaultMethod, defaultLabelOptions) {
-            var options = this.options;
-            if (options.currentDateIndicator && options.label &&
-                typeof options.label.formatter === 'function') {
-                options.value = new Date();
-                return options.label.formatter
-                    .call(this, options.value, options.label.format);
-            }
-            return defaultMethod.call(this, defaultLabelOptions);
-        });
-
-    });
-    _registerModule(_modules, 'modules/static-scale.src.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
-        /* *
-         *
-         *  (c) 2016-2020 Torstein Honsi, Lars Cabrera
-         *
-         *  License: www.highcharts.com/license
-         *
-         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
-         *
-         * */
-        var addEvent = U.addEvent,
-            defined = U.defined,
-            isNumber = U.isNumber,
-            pick = U.pick;
-        var Chart = H.Chart;
-        /* eslint-disable no-invalid-this */
-        /**
-         * For vertical axes only. Setting the static scale ensures that each tick unit
-         * is translated into a fixed pixel height. For example, setting the static
-         * scale to 24 results in each Y axis category taking up 24 pixels, and the
-         * height of the chart adjusts. Adding or removing items will make the chart
-         * resize.
-         *
-         * @sample gantt/xrange-series/demo/
-         *         X-range series with static scale
-         *
-         * @type      {number}
-         * @default   50
-         * @since     6.2.0
-         * @product   gantt
-         * @apioption yAxis.staticScale
-         */
-        addEvent(H.Axis, 'afterSetOptions', function () {
-            var chartOptions = this.chart.options && this.chart.options.chart;
-            if (!this.horiz &&
-                isNumber(this.options.staticScale) &&
-                (!chartOptions.height ||
-                    (chartOptions.scrollablePlotArea &&
-                        chartOptions.scrollablePlotArea.minHeight))) {
-                this.staticScale = this.options.staticScale;
-            }
-        });
-        Chart.prototype.adjustHeight = function () {
-            if (this.redrawTrigger !== 'adjustHeight') {
-                (this.axes || []).forEach(function (axis) {
-                    var chart = axis.chart,
-                        animate = !!chart.initiatedScale &&
-                            chart.options.animation,
-                        staticScale = axis.options.staticScale,
-                        height,
-                        diff;
-                    if (axis.staticScale && defined(axis.min)) {
-                        height = pick(axis.brokenAxis && axis.brokenAxis.unitLength, axis.max + axis.tickInterval - axis.min) * staticScale;
-                        // Minimum height is 1 x staticScale.
-                        height = Math.max(height, staticScale);
-                        diff = height - chart.plotHeight;
-                        if (Math.abs(diff) >= 1) {
-                            chart.plotHeight = height;
-                            chart.redrawTrigger = 'adjustHeight';
-                            chart.setSize(void 0, chart.chartHeight + diff, animate);
-                        }
-                        // Make sure clip rects have the right height before initial
-                        // animation.
-                        axis.series.forEach(function (series) {
-                            var clipRect = series.sharedClipKey &&
-                                    chart[series.sharedClipKey];
-                            if (clipRect) {
-                                clipRect.attr({
-                                    height: chart.plotHeight
-                                });
-                            }
-                        });
-                    }
-                });
-                this.initiatedScale = true;
-            }
-            this.redrawTrigger = null;
-        };
-        addEvent(Chart, 'render', Chart.prototype.adjustHeight);
-
-    });
-    _registerModule(_modules, 'parts-gantt/Tree.js', [_modules['parts/Utilities.js']], function (U) {
+    _registerModule(_modules, 'Gantt/Tree.js', [_modules['Core/Utilities.js']], function (U) {
         /* *
          *
          *  (c) 2016-2020 Highsoft AS
@@ -342,7 +162,7 @@
 
         return Tree;
     });
-    _registerModule(_modules, 'parts-gantt/TreeGridTick.js', [_modules['parts/Utilities.js']], function (U) {
+    _registerModule(_modules, 'Core/Axis/TreeGridTick.js', [_modules['Core/Utilities.js']], function (U) {
         /* *
          *
          *  (c) 2016 Highsoft AS
@@ -695,7 +515,7 @@
 
         return TreeGridTick;
     });
-    _registerModule(_modules, 'mixins/tree-series.js', [_modules['parts/Color.js'], _modules['parts/Utilities.js']], function (Color, U) {
+    _registerModule(_modules, 'Mixins/TreeSeries.js', [_modules['Core/Color/Color.js'], _modules['Core/Utilities.js']], function (Color, U) {
         /* *
          *
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
@@ -923,7 +743,7 @@
 
         return result;
     });
-    _registerModule(_modules, 'parts-gantt/GridAxis.js', [_modules['parts/Axis.js'], _modules['parts/Globals.js'], _modules['parts/Tick.js'], _modules['parts/Utilities.js']], function (Axis, H, Tick, U) {
+    _registerModule(_modules, 'Core/Axis/GridAxis.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Globals.js'], _modules['Core/Options.js'], _modules['Core/Axis/Tick.js'], _modules['Core/Utilities.js']], function (Axis, H, O, Tick, U) {
         /* *
          *
          *  (c) 2016 Highsoft AS
@@ -934,6 +754,7 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
+        var dateFormat = O.dateFormat;
         var addEvent = U.addEvent,
             defined = U.defined,
             erase = U.erase,
@@ -946,7 +767,7 @@
             wrap = U.wrap;
         var argsToArray = function (args) {
                 return Array.prototype.slice.call(args, 1);
-        }, dateFormat = H.dateFormat, isObject = function (x) {
+        }, isObject = function (x) {
             // Always use strict mode
             return U.isObject(x, true);
         }, Chart = H.Chart;
@@ -971,6 +792,27 @@
             axis.labelRotation = 0;
             options.labels.rotation = 0;
         };
+        /**
+         * @productdesc {gantt}
+         * For grid axes (like in Gantt charts),
+         * it is possible to declare as a list to provide different
+         * formats depending on available space.
+         *
+         * Defaults to:
+         * ```js
+         * {
+         *     hour: { list: ['%H:%M', '%H'] },
+         *     day: { list: ['%A, %e. %B', '%a, %e. %b', '%E'] },
+         *     week: { list: ['Week %W', 'W%W'] },
+         *     month: { list: ['%B', '%b', '%o'] }
+         * }
+         * ```
+         *
+         * @sample {gantt} gantt/grid-axis/date-time-label-formats
+         *         Gantt chart with custom axis date format.
+         *
+         * @apioption xAxis.dateTimeLabelFormats
+         */
         /**
          * Set grid options for the axis labels. Requires Highcharts Gantt.
          *
@@ -1045,23 +887,28 @@
                 };
             tickPositions.forEach(function (pos) {
                 var tick = ticks[pos],
-                    tickHeight = 0,
-                    tickWidth = 0,
+                    labelHeight = 0,
+                    labelWidth = 0,
                     label;
                 if (isObject(tick)) {
                     label = isObject(tick.label) ? tick.label : {};
-                    // Find width and height of tick
-                    tickHeight = label.getBBox ? label.getBBox().height : 0;
+                    // Find width and height of label
+                    labelHeight = label.getBBox ? label.getBBox().height : 0;
                     if (label.textStr && !isNumber(label.textPxLength)) {
                         label.textPxLength = label.getBBox().width;
                     }
-                    tickWidth = isNumber(label.textPxLength) ?
+                    labelWidth = isNumber(label.textPxLength) ?
                         // Math.round ensures crisp lines
                         Math.round(label.textPxLength) :
                         0;
+                    if (label.textStr) {
+                        // Set the tickWidth same as the label width after ellipsis
+                        // applied #10281
+                        labelWidth = Math.round(label.getBBox().width);
+                    }
                     // Update the result if width and/or height are larger
-                    dimensions.height = Math.max(tickHeight, dimensions.height);
-                    dimensions.width = Math.max(tickWidth, dimensions.width);
+                    dimensions.height = Math.max(labelHeight, dimensions.height);
+                    dimensions.width = Math.max(labelWidth, dimensions.width);
                 }
             });
             return dimensions;
@@ -1084,7 +931,7 @@
         };
         // First letter of the day of the week, e.g. 'M' for 'Monday'.
         H.dateFormats.E = function (timestamp) {
-            return dateFormat('%a', timestamp, true).charAt(0);
+            return this.dateFormat('%a', timestamp, true).charAt(0);
         };
         /* eslint-disable no-invalid-this */
         addEvent(Chart, 'afterSetChartSize', function () {
@@ -1247,6 +1094,32 @@
                 return (lastIndex === thisIndex &&
                     (isNumber(columnIndex) ? columns.length === columnIndex : true));
             };
+            /**
+             * Add extra border based on the provided path.
+             *  *
+             * @private
+             *
+             * @param {SVGPath} path
+             * The path of the border.
+             *
+             * @return {Highcharts.SVGElement}
+             */
+            GridAxisAdditions.prototype.renderBorder = function (path) {
+                var axis = this.axis,
+                    renderer = axis.chart.renderer,
+                    options = axis.options,
+                    extraBorderLine = renderer.path(path)
+                        .addClass('highcharts-axis-line')
+                        .add(axis.axisBorder);
+                if (!renderer.styledMode) {
+                    extraBorderLine.attr({
+                        stroke: options.lineColor,
+                        'stroke-width': options.lineWidth,
+                        zIndex: 7
+                    });
+                }
+                return extraBorderLine;
+            };
             return GridAxisAdditions;
         }());
         /**
@@ -1369,11 +1242,18 @@
                             function (p) {
                                 return p[axis.isXAxis ? 'x' : 'y'] === value;
                         });
+                        var pointCopy;
+                        if (point && series.is('gantt')) {
+                            // For the Gantt set point aliases to the pointCopy
+                            // to do not change the original point
+                            pointCopy = merge(point);
+                            H.seriesTypes.gantt.prototype.setGanttPointAliases(pointCopy);
+                        }
                         // Make additional properties available for the
                         // formatter
                         this.isFirst = isFirst;
                         this.isLast = isLast;
-                        this.point = point;
+                        this.point = pointCopy;
                         // Call original labelFormatter
                         return proceed.call(this);
                     });
@@ -1388,7 +1268,11 @@
                             gridOptions.columns[gridOptions.columns.length - columnIndex - 1], {
                                 linkedTo: 0,
                                 // Force to behave like category axis
-                                type: 'category'
+                                type: 'category',
+                                // Disable by default the scrollbar on the grid axis
+                                scrollbar: {
+                                    enabled: false
+                                }
                             });
                         delete columnOptions.grid.columns; // Prevent recursion
                         var column = new Axis(axis.chart,
@@ -1417,15 +1301,11 @@
              * @private
              */
             GridAxis.onAfterRender = function () {
-                var axis = this;
-                var grid = axis.grid;
-                var options = axis.options;
-                var renderer = axis.chart.renderer;
-                var gridOptions = options.grid || {};
-                var yStartIndex,
-                    yEndIndex,
-                    xStartIndex,
-                    xEndIndex;
+                var _a;
+                var axis = this,
+                    grid = axis.grid,
+                    options = axis.options,
+                    gridOptions = options.grid || {};
                 if (gridOptions.enabled === true) {
                     // @todo acutual label padding (top, bottom, left, right)
                     axis.maxLabelDimensions = axis.getMaxLabelDimensions(axis.ticks, axis.tickPositions);
@@ -1444,13 +1324,13 @@
                     if (axis.grid && axis.grid.isOuterAxis() && axis.axisLine) {
                         var lineWidth = options.lineWidth;
                         if (lineWidth) {
-                            var linePath = axis.getLinePath(lineWidth);
-                            var startPoint = linePath[0];
-                            var endPoint = linePath[1];
-                            // Negate distance if top or left axis
-                            // Subtract 1px to draw the line at the end of the tick
-                            var tickLength = (axis.tickSize('tick') || [1])[0];
-                            var distance = (tickLength - 1) * ((axis.side === GridAxis.Side.top ||
+                            var linePath = axis.getLinePath(lineWidth),
+                                startPoint = linePath[0],
+                                endPoint = linePath[1], 
+                                // Negate distance if top or left axis
+                                // Subtract 1px to draw the line at the end of the tick
+                                tickLength = (axis.tickSize('tick') || [1])[0],
+                                distance = (tickLength - 1) * ((axis.side === GridAxis.Side.top ||
                                     axis.side === GridAxis.Side.left) ? -1 : 1);
                             // If axis is horizontal, reposition line path vertically
                             if (startPoint[0] === 'M' && endPoint[0] === 'L') {
@@ -1459,27 +1339,36 @@
                                     endPoint[2] += distance;
                                 }
                                 else {
-                                    // If axis is vertical, reposition line path
-                                    // horizontally
                                     startPoint[1] += distance;
                                     endPoint[1] += distance;
                                 }
                             }
-                            if (!axis.grid.axisLineExtra) {
-                                axis.grid.axisLineExtra = renderer
-                                    .path(linePath)
-                                    .attr({
-                                    zIndex: 7
-                                })
-                                    .addClass('highcharts-axis-line')
-                                    .add(axis.axisGroup);
-                                if (!renderer.styledMode) {
-                                    axis.grid.axisLineExtra.attr({
-                                        stroke: options.lineColor,
-                                        'stroke-width': lineWidth
+                            // If it doesn't exist, add an upper and lower border
+                            // for the vertical grid axis.
+                            if (!axis.horiz && axis.chart.marginRight) {
+                                var upperBorderStartPoint = startPoint, upperBorderEndPoint = ['L', axis.left, startPoint[2]], upperBorderPath = [upperBorderStartPoint, upperBorderEndPoint], lowerBorderEndPoint = ['L', axis.chart.chartWidth - axis.chart.marginRight, axis.toPixels(axis.max + axis.tickmarkOffset)], lowerBorderStartPoint = ['M', endPoint[1], axis.toPixels(axis.max + axis.tickmarkOffset)], lowerBorderPath = [lowerBorderStartPoint, lowerBorderEndPoint];
+                                if (!axis.grid.upperBorder && axis.min % 1 !== 0) {
+                                    axis.grid.upperBorder = axis.grid.renderBorder(upperBorderPath);
+                                }
+                                if (axis.grid.upperBorder) {
+                                    axis.grid.upperBorder.animate({
+                                        d: upperBorderPath
+                                    });
+                                }
+                                if (!axis.grid.lowerBorder && axis.max % 1 !== 0) {
+                                    axis.grid.lowerBorder = axis.grid.renderBorder(lowerBorderPath);
+                                }
+                                if (axis.grid.lowerBorder) {
+                                    axis.grid.lowerBorder.animate({
+                                        d: lowerBorderPath
                                     });
                                 }
                             }
+                            // Render an extra line parallel to the existing axes,
+                            // to close the grid.
+                            if (!axis.grid.axisLineExtra) {
+                                axis.grid.axisLineExtra = axis.grid.renderBorder(linePath);
+                            }
                             else {
                                 axis.grid.axisLineExtra.animate({
                                     d: linePath
@@ -1493,12 +1382,42 @@
                     (grid && grid.columns || []).forEach(function (column) {
                         column.render();
                     });
+                    // Manipulate the tick mark visibility
+                    // based on the axis.max- allows smooth scrolling.
+                    if (!axis.horiz && axis.chart.hasRendered && (axis.scrollbar || ((_a = axis.linkedParent) === null || _a === void 0 ? void 0 : _a.scrollbar))) {
+                        var max = axis.max,
+                            min = axis.min,
+                            tickmarkOffset = axis.tickmarkOffset,
+                            lastTick = axis.tickPositions[axis.tickPositions.length - 1],
+                            firstTick = axis.tickPositions[0];
+                        // Hide/show firts tick label.
+                        if (min - firstTick > tickmarkOffset) {
+                            axis.ticks[firstTick].label.hide();
+                        }
+                        else {
+                            axis.ticks[firstTick].label.show();
+                        }
+                        // Hide/show last tick mark/label.
+                        if (lastTick - max > tickmarkOffset) {
+                            axis.ticks[lastTick].label.hide();
+                        }
+                        else {
+                            axis.ticks[lastTick].label.show();
+                        }
+                        if (lastTick - max < tickmarkOffset && lastTick - max > 0 && axis.ticks[lastTick].isLast) {
+                            axis.ticks[lastTick].mark.hide();
+                        }
+                        else {
+                            axis.ticks[lastTick - 1].mark.show();
+                        }
+                    }
                 }
             };
             /**
              * @private
              */
             GridAxis.onAfterSetAxisTranslation = function () {
+                var _a;
                 var axis = this;
                 var tickInfo = axis.tickPositions && axis.tickPositions.info;
                 var options = axis.options;
@@ -1527,6 +1446,13 @@
                         }
                     }
                 }
+                else {
+                    // Don't trim ticks which not in min/max range but
+                    // they are still in the min/max plus tickInterval.
+                    if (this.options.type !== 'treegrid' && ((_a = axis.grid) === null || _a === void 0 ? void 0 : _a.columns)) {
+                        this.minPointOffset = this.tickInterval;
+                    }
+                }
             };
             /**
              * Creates a left and right wall on horizontal axes:
@@ -1837,7 +1763,7 @@
 
         return GridAxis;
     });
-    _registerModule(_modules, 'modules/broken-axis.src.js', [_modules['parts/Axis.js'], _modules['parts/Globals.js'], _modules['parts/Utilities.js'], _modules['parts/Stacking.js']], function (Axis, H, U, StackItem) {
+    _registerModule(_modules, 'Core/Axis/BrokenAxis.js', [_modules['Core/Axis/Axis.js'], _modules['Series/LineSeries.js'], _modules['Extensions/Stacking.js'], _modules['Core/Utilities.js']], function (Axis, LineSeries, StackItem, U) {
         /* *
          *
          *  (c) 2009-2020 Torstein Honsi
@@ -1853,7 +1779,6 @@
             isArray = U.isArray,
             isNumber = U.isNumber,
             pick = U.pick;
-        var Series = H.Series;
         /* eslint-disable valid-jsdoc */
         /**
          * Provides support for broken axes.
@@ -2180,7 +2105,7 @@
                  */
                 BrokenAxis.compose = function (AxisClass, SeriesClass) {
                     AxisClass.keepProps.push('brokenAxis');
-                var seriesProto = Series.prototype;
+                var seriesProto = LineSeries.prototype;
                 /**
                  * @private
                  */
@@ -2413,11 +2338,11 @@
             };
             return BrokenAxis;
         }());
-        BrokenAxis.compose(Axis, Series); // @todo remove automatism
+        BrokenAxis.compose(Axis, LineSeries); // @todo remove automatism
 
         return BrokenAxis;
     });
-    _registerModule(_modules, 'parts-gantt/TreeGridAxis.js', [_modules['parts/Axis.js'], _modules['parts/Tick.js'], _modules['parts-gantt/Tree.js'], _modules['parts-gantt/TreeGridTick.js'], _modules['mixins/tree-series.js'], _modules['parts/Utilities.js']], function (Axis, Tick, Tree, TreeGridTick, TreeSeriesMixin, U) {
+    _registerModule(_modules, 'Core/Axis/TreeGridAxis.js', [_modules['Core/Globals.js'], _modules['Core/Axis/Axis.js'], _modules['Core/Axis/Tick.js'], _modules['Gantt/Tree.js'], _modules['Core/Axis/TreeGridTick.js'], _modules['Mixins/TreeSeries.js'], _modules['Core/Utilities.js']], function (H, Axis, Tick, Tree, TreeGridTick, mixinTreeSeries, U) {
         /* *
          *
          *  (c) 2016 Highsoft AS
@@ -2428,9 +2353,11 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
+        var getLevelOptions = mixinTreeSeries.getLevelOptions;
         var addEvent = U.addEvent,
             find = U.find,
             fireEvent = U.fireEvent,
+            isArray = U.isArray,
             isNumber = U.isNumber,
             isObject = U.isObject,
             isString = U.isString,
@@ -2573,6 +2500,7 @@
                             mapOfPosToGridNode[pos] = gridNode = {
                                 depth: parentGridNode ? parentGridNode.depth + 1 : 0,
                                 name: name,
+                                id: data.id,
                                 nodes: [node],
                                 children: [],
                                 pos: pos
@@ -2666,7 +2594,8 @@
                         numberOfSeries = 0,
                         isDirty,
                         data,
-                        treeGrid;
+                        treeGrid,
+                        max = options.max;
                     // Check whether any of series is rendering for the first time,
                     // visibility has changed, or its data is dirty,
                     // and only then update. #10570, #10580
@@ -2683,6 +2612,11 @@
                             if (s.visible) {
                                 // Push all data to array
                                 (s.options.data || []).forEach(function (data) {
+                                    // For using keys - rebuild the data structure
+                                    if (s.options.keys && s.options.keys.length) {
+                                        data = s.pointClass.prototype.optionsToObject.call({ series: s }, data);
+                                        H.seriesTypes.gantt.prototype.setGanttPointAliases(data);
+                                    }
                                     if (isObject(data, true)) {
                                         // Set series index on data. Removed again
                                         // after use.
@@ -2697,6 +2631,17 @@
                             }
                             return arr;
                         }, []);
+                        // If max is higher than set data - add a
+                        // dummy data to render categories #10779
+                        if (max && data.length < max) {
+                            for (var i = data.length; i <= max; i++) {
+                                data.push({
+                                    // Use the zero-width character
+                                    // to avoid conflict with uniqueNames
+                                    name: i + '\u200B'
+                                });
+                            }
+                        }
                         // setScale is fired after all the series is initialized,
                         // which is an ideal time to update the axis.categories.
                         treeGrid = getTreeGridFromData(data, uniqueNames || false, (uniqueNames === true) ? numberOfSeries : 1);
@@ -2707,18 +2652,26 @@
                         axis.treeGrid.tree = treeGrid.tree;
                         // Update yData now that we have calculated the y values
                         axis.series.forEach(function (series) {
-                            var data = (series.options.data || []).map(function (d) {
-                                    return isObject(d,
-                                true) ? merge(d) : d;
+                            var axisData = (series.options.data || []).map(function (d) {
+                                    if (isArray(d) && series.options.keys && series.options.keys.length) {
+                                        // Get the axisData from the data array used to
+                                        // build the treeGrid where has been modified
+                                        data.forEach(function (point) {
+                                            if (d.indexOf(point.x) >= 0 && d.indexOf(point.x2) >= 0) {
+                                                d = point;
+                                        }
+                                    });
+                                }
+                                return isObject(d, true) ? merge(d) : d;
                             });
                             // Avoid destroying points when series is not visible
                             if (series.visible) {
-                                series.setData(data, false);
+                                series.setData(axisData, false);
                             }
                         });
                         // Calculate the label options for each level in the tree.
                         axis.treeGrid.mapOptionsToLevel =
-                            TreeSeriesMixin.getLevelOptions({
+                            getLevelOptions({
                                 defaults: labelOptions,
                                 from: 1,
                                 levels: labelOptions && labelOptions.levels,
@@ -2848,6 +2801,15 @@
                             });
                         }
                     });
+                    // If staticScale is not defined on the yAxis
+                    // and chart height is set, set axis.isDirty
+                    // to ensure collapsing works (#12012)
+                    addEvent(axis, 'afterBreaks', function () {
+                        var _a;
+                        if (axis.coll === 'yAxis' && !axis.staticScale && ((_a = axis.chart.options.chart) === null || _a === void 0 ? void 0 : _a.height)) {
+                            axis.isDirty = true;
+                        }
+                    });
                     userOptions = merge({
                         // Default options
                         grid: {
@@ -2995,6 +2957,32 @@
                  *  Functions
                  *
                  * */
+                /**
+                 * Set the collapse status.
+                 *
+                 * @private
+                 *
+                 * @param {Highcharts.Axis} axis
+                 * The axis to check against.
+                 *
+                 * @param {Highcharts.GridNode} node
+                 * The node to collapse.
+                 */
+                Additions.prototype.setCollapsedStatus = function (node) {
+                    var axis = this.axis,
+                        chart = axis.chart;
+                    axis.series.forEach(function (series) {
+                        var data = series.options.data;
+                        if (node.id && data) {
+                            var point = chart.get(node.id),
+                                dataPoint = data[series.data.indexOf(point)];
+                            if (point && dataPoint) {
+                                point.collapsed = node.collapsed;
+                                dataPoint.collapsed = node.collapsed;
+                            }
+                        }
+                    });
+                };
                 /**
                  * Calculates the new axis breaks to collapse a node.
                  *
@@ -3018,6 +3006,9 @@
                         obj = getBreakFromNode(node,
                         axis.max);
                     breaks.push(obj);
+                    // Change the collapsed flag #13838
+                    node.collapsed = true;
+                    axis.treeGrid.setCollapsedStatus(node);
                     return breaks;
                 };
                 /**
@@ -3042,6 +3033,9 @@
                         breaks = (axis.options.breaks || []),
                         obj = getBreakFromNode(node,
                         axis.max);
+                    // Change the collapsed flag #13838
+                    node.collapsed = false;
+                    axis.treeGrid.setCollapsedStatus(node);
                     // Remove the break from the axis breaks array.
                     return breaks.reduce(function (arr, b) {
                         if (b.to !== obj.to || b.from !== obj.from) {
@@ -3060,11 +3054,13 @@
                  * List of positions.
                  */
                 Additions.prototype.getTickPositions = function () {
-                    var axis = this.axis;
+                    var axis = this.axis,
+                        roundedMin = Math.floor(axis.min / axis.tickInterval) * axis.tickInterval,
+                        roundedMax = Math.ceil(axis.max / axis.tickInterval) * axis.tickInterval;
                     return Object.keys(axis.treeGrid.mapOfPosToGridNode || {}).reduce(function (arr, key) {
                         var pos = +key;
-                        if (axis.min <= pos &&
-                            axis.max >= pos &&
+                        if (pos >= roundedMin &&
+                            pos <= roundedMax &&
                             !(axis.brokenAxis && axis.brokenAxis.isInAnyBreak(pos))) {
                             arr.push(pos);
                         }
@@ -3130,767 +3126,218 @@
 
         return TreeGridAxis;
     });
-    _registerModule(_modules, 'parts-gantt/PathfinderAlgorithms.js', [_modules['parts/Utilities.js']], function (U) {
+    _registerModule(_modules, 'Extensions/CurrentDateIndication.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Utilities.js'], _modules['Core/Axis/PlotLineOrBand.js']], function (Axis, U, PlotLineOrBand) {
         /* *
          *
-         *  (c) 2016 Highsoft AS
-         *  Author: Øystein Moseng
+         *  (c) 2016-2020 Highsoft AS
+         *
+         *  Author: Lars A. V. Cabrera
          *
          *  License: www.highcharts.com/license
          *
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        var extend = U.extend,
-            pick = U.pick;
-        var min = Math.min,
-            max = Math.max,
-            abs = Math.abs;
-        /**
-         * Get index of last obstacle before xMin. Employs a type of binary search, and
-         * thus requires that obstacles are sorted by xMin value.
+        var addEvent = U.addEvent,
+            merge = U.merge,
+            wrap = U.wrap;
+        var defaultConfig = {
+                /**
+                 * Show an indicator on the axis for the current date and time. Can be a
+                 * boolean or a configuration object similar to
+                 * [xAxis.plotLines](#xAxis.plotLines).
+                 *
+                 * @sample gantt/current-date-indicator/demo
+                 *         Current date indicator enabled
+                 * @sample gantt/current-date-indicator/object-config
+                 *         Current date indicator with custom options
+                 *
+                 * @declare   Highcharts.AxisCurrentDateIndicatorOptions
+                 * @type      {boolean|*}
+                 * @default   true
+                 * @extends   xAxis.plotLines
+                 * @excluding value
+                 * @product   gantt
+                 * @apioption xAxis.currentDateIndicator
+                 */
+                currentDateIndicator: true,
+                color: '#ccd6eb',
+                width: 2,
+                /**
+                 * @declare Highcharts.AxisCurrentDateIndicatorLabelOptions
+                 */
+                label: {
+                    /**
+                     * Format of the label. This options is passed as the fist argument to
+                     * [dateFormat](/class-reference/Highcharts#dateFormat) function.
+                     *
+                     * @type      {string}
+                     * @default   %a, %b %d %Y, %H:%M
+                     * @product   gantt
+                     * @apioption xAxis.currentDateIndicator.label.format
+                     */
+                    format: '%a, %b %d %Y, %H:%M',
+                    formatter: function (value, format) {
+                        return this.axis.chart.time.dateFormat(format, value);
+                },
+                rotation: 0,
+                /**
+                 * @type {Highcharts.CSSObject}
+                 */
+                style: {
+                    /** @internal */
+                    fontSize: '10px'
+                }
+            }
+        };
+        /* eslint-disable no-invalid-this */
+        addEvent(Axis, 'afterSetOptions', function () {
+            var options = this.options,
+                cdiOptions = options.currentDateIndicator;
+            if (cdiOptions) {
+                cdiOptions = typeof cdiOptions === 'object' ?
+                    merge(defaultConfig, cdiOptions) : merge(defaultConfig);
+                cdiOptions.value = new Date();
+                if (!options.plotLines) {
+                    options.plotLines = [];
+                }
+                options.plotLines.push(cdiOptions);
+            }
+        });
+        addEvent(PlotLineOrBand, 'render', function () {
+            // If the label already exists, update its text
+            if (this.label) {
+                this.label.attr({
+                    text: this.getLabelText(this.options.label)
+                });
+            }
+        });
+        wrap(PlotLineOrBand.prototype, 'getLabelText', function (defaultMethod, defaultLabelOptions) {
+            var options = this.options;
+            if (options.currentDateIndicator && options.label &&
+                typeof options.label.formatter === 'function') {
+                options.value = new Date();
+                return options.label.formatter
+                    .call(this, options.value, options.label.format);
+            }
+            return defaultMethod.call(this, defaultLabelOptions);
+        });
+
+    });
+    _registerModule(_modules, 'Extensions/StaticScale.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Chart/Chart.js'], _modules['Core/Utilities.js']], function (Axis, Chart, U) {
+        /* *
          *
-         * @private
-         * @function findLastObstacleBefore
+         *  (c) 2016-2020 Torstein Honsi, Lars Cabrera
          *
-         * @param {Array<object>} obstacles
-         *        Array of obstacles to search in.
+         *  License: www.highcharts.com/license
          *
-         * @param {number} xMin
-         *        The xMin threshold.
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
-         * @param {number} [startIx]
-         *        Starting index to search from. Must be within array range.
+         * */
+        var addEvent = U.addEvent,
+            defined = U.defined,
+            isNumber = U.isNumber,
+            pick = U.pick;
+        /* eslint-disable no-invalid-this */
+        /**
+         * For vertical axes only. Setting the static scale ensures that each tick unit
+         * is translated into a fixed pixel height. For example, setting the static
+         * scale to 24 results in each Y axis category taking up 24 pixels, and the
+         * height of the chart adjusts. Adding or removing items will make the chart
+         * resize.
          *
-         * @return {number}
-         *         The index of the last obstacle element before xMin.
+         * @sample gantt/xrange-series/demo/
+         *         X-range series with static scale
+         *
+         * @type      {number}
+         * @default   50
+         * @since     6.2.0
+         * @product   gantt
+         * @apioption yAxis.staticScale
          */
-        function findLastObstacleBefore(obstacles, xMin, startIx) {
-            var left = startIx || 0, // left limit
-                right = obstacles.length - 1, // right limit
-                min = xMin - 0.0000001, // Make sure we include all obstacles at xMin
-                cursor,
-                cmp;
-            while (left <= right) {
-                cursor = (right + left) >> 1;
-                cmp = min - obstacles[cursor].xMin;
-                if (cmp > 0) {
-                    left = cursor + 1;
-                }
-                else if (cmp < 0) {
-                    right = cursor - 1;
-                }
-                else {
-                    return cursor;
-                }
+        addEvent(Axis, 'afterSetOptions', function () {
+            var chartOptions = this.chart.options && this.chart.options.chart;
+            if (!this.horiz &&
+                isNumber(this.options.staticScale) &&
+                (!chartOptions.height ||
+                    (chartOptions.scrollablePlotArea &&
+                        chartOptions.scrollablePlotArea.minHeight))) {
+                this.staticScale = this.options.staticScale;
             }
-            return left > 0 ? left - 1 : 0;
-        }
-        /**
-         * Test if a point lays within an obstacle.
+        });
+        Chart.prototype.adjustHeight = function () {
+            if (this.redrawTrigger !== 'adjustHeight') {
+                (this.axes || []).forEach(function (axis) {
+                    var chart = axis.chart,
+                        animate = !!chart.initiatedScale &&
+                            chart.options.animation,
+                        staticScale = axis.options.staticScale,
+                        height,
+                        diff;
+                    if (axis.staticScale && defined(axis.min)) {
+                        height = pick(axis.brokenAxis && axis.brokenAxis.unitLength, axis.max + axis.tickInterval - axis.min) * staticScale;
+                        // Minimum height is 1 x staticScale.
+                        height = Math.max(height, staticScale);
+                        diff = height - chart.plotHeight;
+                        if (Math.abs(diff) >= 1) {
+                            chart.plotHeight = height;
+                            chart.redrawTrigger = 'adjustHeight';
+                            chart.setSize(void 0, chart.chartHeight + diff, animate);
+                        }
+                        // Make sure clip rects have the right height before initial
+                        // animation.
+                        axis.series.forEach(function (series) {
+                            var clipRect = series.sharedClipKey &&
+                                    chart[series.sharedClipKey];
+                            if (clipRect) {
+                                clipRect.attr({
+                                    height: chart.plotHeight
+                                });
+                            }
+                        });
+                    }
+                });
+                this.initiatedScale = true;
+            }
+            this.redrawTrigger = null;
+        };
+        addEvent(Chart, 'render', Chart.prototype.adjustHeight);
+
+    });
+    _registerModule(_modules, 'Extensions/ArrowSymbols.js', [_modules['Core/Renderer/SVG/SVGRenderer.js']], function (SVGRenderer) {
+        /* *
          *
-         * @private
-         * @function pointWithinObstacle
+         *  (c) 2017 Highsoft AS
+         *  Authors: Lars A. V. Cabrera
          *
-         * @param {object} obstacle
-         *        Obstacle to test.
+         *  License: www.highcharts.com/license
          *
-         * @param {Highcharts.Point} point
-         *        Point with x/y props.
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
-         * @return {boolean}
-         *         Whether point is within the obstacle or not.
-         */
-        function pointWithinObstacle(obstacle, point) {
-            return (point.x <= obstacle.xMax &&
-                point.x >= obstacle.xMin &&
-                point.y <= obstacle.yMax &&
-                point.y >= obstacle.yMin);
-        }
+         * */
         /**
-         * Find the index of an obstacle that wraps around a point.
-         * Returns -1 if not found.
+         * Creates an arrow symbol. Like a triangle, except not filled.
+         * ```
+         *                   o
+         *             o
+         *       o
+         * o
+         *       o
+         *             o
+         *                   o
+         * ```
          *
          * @private
-         * @function findObstacleFromPoint
-         *
-         * @param {Array<object>} obstacles
-         *        Obstacles to test.
+         * @function
          *
-         * @param {Highcharts.Point} point
-         *        Point with x/y props.
+         * @param {number} x
+         *        x position of the arrow
          *
-         * @return {number}
-         *         Ix of the obstacle in the array, or -1 if not found.
-         */
-        function findObstacleFromPoint(obstacles, point) {
-            var i = findLastObstacleBefore(obstacles,
-                point.x + 1) + 1;
-            while (i--) {
-                if (obstacles[i].xMax >= point.x &&
-                    // optimization using lazy evaluation
-                    pointWithinObstacle(obstacles[i], point)) {
-                    return i;
-                }
-            }
-            return -1;
-        }
-        /**
-         * Get SVG path array from array of line segments.
+         * @param {number} y
+         *        y position of the arrow
          *
-         * @private
-         * @function pathFromSegments
-         *
-         * @param {Array<object>} segments
-         *        The segments to build the path from.
-         *
-         * @return {Highcharts.SVGPathArray}
-         *         SVG path array as accepted by the SVG Renderer.
-         */
-        function pathFromSegments(segments) {
-            var path = [];
-            if (segments.length) {
-                path.push(['M', segments[0].start.x, segments[0].start.y]);
-                for (var i = 0; i < segments.length; ++i) {
-                    path.push(['L', segments[i].end.x, segments[i].end.y]);
-                }
-            }
-            return path;
-        }
-        /**
-         * Limits obstacle max/mins in all directions to bounds. Modifies input
-         * obstacle.
-         *
-         * @private
-         * @function limitObstacleToBounds
-         *
-         * @param {object} obstacle
-         *        Obstacle to limit.
-         *
-         * @param {object} bounds
-         *        Bounds to use as limit.
-         *
-         * @return {void}
-         */
-        function limitObstacleToBounds(obstacle, bounds) {
-            obstacle.yMin = max(obstacle.yMin, bounds.yMin);
-            obstacle.yMax = min(obstacle.yMax, bounds.yMax);
-            obstacle.xMin = max(obstacle.xMin, bounds.xMin);
-            obstacle.xMax = min(obstacle.xMax, bounds.xMax);
-        }
-        // Define the available pathfinding algorithms.
-        // Algorithms take up to 3 arguments: starting point, ending point, and an
-        // options object.
-        var algorithms = {
-                /**
-                 * Get an SVG path from a starting coordinate to an ending coordinate.
-                 * Draws a straight line.
-                 *
-                 * @function Highcharts.Pathfinder.algorithms.straight
-                 *
-                 * @param {Highcharts.PositionObject} start
-                 *        Starting coordinate,
-            object with x/y props.
-                 *
-                 * @param {Highcharts.PositionObject} end
-                 *        Ending coordinate,
-            object with x/y props.
-                 *
-                 * @return {object}
-                 *         An object with the SVG path in Array form as accepted by the SVG
-                 *         renderer,
-            as well as an array of new obstacles making up this
-                 *         path.
-                 */
-                straight: function (start,
-            end) {
-                    return {
-                        path: [
-                            ['M',
-            start.x,
-            start.y],
-                            ['L',
-            end.x,
-            end.y]
-                        ],
-                        obstacles: [{ start: start,
-            end: end }]
-                    };
-            },
-            /**
-             * Find a path from a starting coordinate to an ending coordinate, using
-             * right angles only, and taking only starting/ending obstacle into
-             * consideration.
-             *
-             * @function Highcharts.Pathfinder.algorithms.simpleConnect
-             *
-             * @param {Highcharts.PositionObject} start
-             *        Starting coordinate, object with x/y props.
-             *
-             * @param {Highcharts.PositionObject} end
-             *        Ending coordinate, object with x/y props.
-             *
-             * @param {object} options
-             *        Options for the algorithm:
-             *        - chartObstacles: Array of chart obstacles to avoid
-             *        - startDirectionX: Optional. True if starting in the X direction.
-             *          If not provided, the algorithm starts in the direction that is
-             *          the furthest between start/end.
-             *
-             * @return {object}
-             *         An object with the SVG path in Array form as accepted by the SVG
-             *         renderer, as well as an array of new obstacles making up this
-             *         path.
-             */
-            simpleConnect: extend(function (start, end, options) {
-                var segments = [],
-                    endSegment,
-                    dir = pick(options.startDirectionX,
-                    abs(end.x - start.x) > abs(end.y - start.y)) ? 'x' : 'y',
-                    chartObstacles = options.chartObstacles,
-                    startObstacleIx = findObstacleFromPoint(chartObstacles,
-                    start),
-                    endObstacleIx = findObstacleFromPoint(chartObstacles,
-                    end),
-                    startObstacle,
-                    endObstacle,
-                    prevWaypoint,
-                    waypoint,
-                    waypoint2,
-                    useMax,
-                    endPoint;
-                // eslint-disable-next-line valid-jsdoc
-                /**
-                 * Return a clone of a point with a property set from a target object,
-                 * optionally with an offset
-                 * @private
-                 */
-                function copyFromPoint(from, fromKey, to, toKey, offset) {
-                    var point = {
-                            x: from.x,
-                            y: from.y
-                        };
-                    point[fromKey] = to[toKey || fromKey] + (offset || 0);
-                    return point;
-                }
-                // eslint-disable-next-line valid-jsdoc
-                /**
-                 * Return waypoint outside obstacle.
-                 * @private
-                 */
-                function getMeOut(obstacle, point, direction) {
-                    var useMax = abs(point[direction] - obstacle[direction + 'Min']) >
-                            abs(point[direction] - obstacle[direction + 'Max']);
-                    return copyFromPoint(point, direction, obstacle, direction + (useMax ? 'Max' : 'Min'), useMax ? 1 : -1);
-                }
-                // Pull out end point
-                if (endObstacleIx > -1) {
-                    endObstacle = chartObstacles[endObstacleIx];
-                    waypoint = getMeOut(endObstacle, end, dir);
-                    endSegment = {
-                        start: waypoint,
-                        end: end
-                    };
-                    endPoint = waypoint;
-                }
-                else {
-                    endPoint = end;
-                }
-                // If an obstacle envelops the start point, add a segment to get out,
-                // and around it.
-                if (startObstacleIx > -1) {
-                    startObstacle = chartObstacles[startObstacleIx];
-                    waypoint = getMeOut(startObstacle, start, dir);
-                    segments.push({
-                        start: start,
-                        end: waypoint
-                    });
-                    // If we are going back again, switch direction to get around start
-                    // obstacle.
-                    if (
-                    // Going towards max from start:
-                    waypoint[dir] >= start[dir] ===
-                        // Going towards min to end:
-                        waypoint[dir] >= endPoint[dir]) {
-                        dir = dir === 'y' ? 'x' : 'y';
-                        useMax = start[dir] < end[dir];
-                        segments.push({
-                            start: waypoint,
-                            end: copyFromPoint(waypoint, dir, startObstacle, dir + (useMax ? 'Max' : 'Min'), useMax ? 1 : -1)
-                        });
-                        // Switch direction again
-                        dir = dir === 'y' ? 'x' : 'y';
-                    }
-                }
-                // We are around the start obstacle. Go towards the end in one
-                // direction.
-                prevWaypoint = segments.length ?
-                    segments[segments.length - 1].end :
-                    start;
-                waypoint = copyFromPoint(prevWaypoint, dir, endPoint);
-                segments.push({
-                    start: prevWaypoint,
-                    end: waypoint
-                });
-                // Final run to end point in the other direction
-                dir = dir === 'y' ? 'x' : 'y';
-                waypoint2 = copyFromPoint(waypoint, dir, endPoint);
-                segments.push({
-                    start: waypoint,
-                    end: waypoint2
-                });
-                // Finally add the endSegment
-                segments.push(endSegment);
-                return {
-                    path: pathFromSegments(segments),
-                    obstacles: segments
-                };
-            }, {
-                requiresObstacles: true
-            }),
-            /**
-             * Find a path from a starting coordinate to an ending coordinate, taking
-             * obstacles into consideration. Might not always find the optimal path,
-             * but is fast, and usually good enough.
-             *
-             * @function Highcharts.Pathfinder.algorithms.fastAvoid
-             *
-             * @param {Highcharts.PositionObject} start
-             *        Starting coordinate, object with x/y props.
-             *
-             * @param {Highcharts.PositionObject} end
-             *        Ending coordinate, object with x/y props.
-             *
-             * @param {object} options
-             *        Options for the algorithm.
-             *        - chartObstacles:  Array of chart obstacles to avoid
-             *        - lineObstacles:   Array of line obstacles to jump over
-             *        - obstacleMetrics: Object with metrics of chartObstacles cached
-             *        - hardBounds:      Hard boundaries to not cross
-             *        - obstacleOptions: Options for the obstacles, including margin
-             *        - startDirectionX: Optional. True if starting in the X direction.
-             *                           If not provided, the algorithm starts in the
-             *                           direction that is the furthest between
-             *                           start/end.
-             *
-             * @return {object}
-             *         An object with the SVG path in Array form as accepted by the SVG
-             *         renderer, as well as an array of new obstacles making up this
-             *         path.
-             */
-            fastAvoid: extend(function (start, end, options) {
-                /*
-                    Algorithm rules/description
-                    - Find initial direction
-                    - Determine soft/hard max for each direction.
-                    - Move along initial direction until obstacle.
-                    - Change direction.
-                    - If hitting obstacle, first try to change length of previous line
-                      before changing direction again.
-
-                    Soft min/max x = start/destination x +/- widest obstacle + margin
-                    Soft min/max y = start/destination y +/- tallest obstacle + margin
-
-                    @todo:
-                        - Make retrospective, try changing prev segment to reduce
-                          corners
-                        - Fix logic for breaking out of end-points - not always picking
-                          the best direction currently
-                        - When going around the end obstacle we should not always go the
-                          shortest route, rather pick the one closer to the end point
-                */
-                var dirIsX = pick(options.startDirectionX,
-                    abs(end.x - start.x) > abs(end.y - start.y)),
-                    dir = dirIsX ? 'x' : 'y',
-                    segments,
-                    useMax,
-                    extractedEndPoint,
-                    endSegments = [],
-                    forceObstacleBreak = false, // Used in clearPathTo to keep track of
-                    // when to force break through an obstacle.
-                    // Boundaries to stay within. If beyond soft boundary, prefer to
-                    // change direction ASAP. If at hard max, always change immediately.
-                    metrics = options.obstacleMetrics,
-                    softMinX = min(start.x,
-                    end.x) - metrics.maxWidth - 10,
-                    softMaxX = max(start.x,
-                    end.x) + metrics.maxWidth + 10,
-                    softMinY = min(start.y,
-                    end.y) - metrics.maxHeight - 10,
-                    softMaxY = max(start.y,
-                    end.y) + metrics.maxHeight + 10, 
-                    // Obstacles
-                    chartObstacles = options.chartObstacles,
-                    startObstacleIx = findLastObstacleBefore(chartObstacles,
-                    softMinX),
-                    endObstacleIx = findLastObstacleBefore(chartObstacles,
-                    softMaxX);
-                // eslint-disable-next-line valid-jsdoc
-                /**
-                 * How far can you go between two points before hitting an obstacle?
-                 * Does not work for diagonal lines (because it doesn't have to).
-                 * @private
-                 */
-                function pivotPoint(fromPoint, toPoint, directionIsX) {
-                    var firstPoint,
-                        lastPoint,
-                        highestPoint,
-                        lowestPoint,
-                        i,
-                        searchDirection = fromPoint.x < toPoint.x ? 1 : -1;
-                    if (fromPoint.x < toPoint.x) {
-                        firstPoint = fromPoint;
-                        lastPoint = toPoint;
-                    }
-                    else {
-                        firstPoint = toPoint;
-                        lastPoint = fromPoint;
-                    }
-                    if (fromPoint.y < toPoint.y) {
-                        lowestPoint = fromPoint;
-                        highestPoint = toPoint;
-                    }
-                    else {
-                        lowestPoint = toPoint;
-                        highestPoint = fromPoint;
-                    }
-                    // Go through obstacle range in reverse if toPoint is before
-                    // fromPoint in the X-dimension.
-                    i = searchDirection < 0 ?
-                        // Searching backwards, start at last obstacle before last point
-                        min(findLastObstacleBefore(chartObstacles, lastPoint.x), chartObstacles.length - 1) :
-                        // Forwards. Since we're not sorted by xMax, we have to look
-                        // at all obstacles.
-                        0;
-                    // Go through obstacles in this X range
-                    while (chartObstacles[i] && (searchDirection > 0 && chartObstacles[i].xMin <= lastPoint.x ||
-                        searchDirection < 0 && chartObstacles[i].xMax >= firstPoint.x)) {
-                        // If this obstacle is between from and to points in a straight
-                        // line, pivot at the intersection.
-                        if (chartObstacles[i].xMin <= lastPoint.x &&
-                            chartObstacles[i].xMax >= firstPoint.x &&
-                            chartObstacles[i].yMin <= highestPoint.y &&
-                            chartObstacles[i].yMax >= lowestPoint.y) {
-                            if (directionIsX) {
-                                return {
-                                    y: fromPoint.y,
-                                    x: fromPoint.x < toPoint.x ?
-                                        chartObstacles[i].xMin - 1 :
-                                        chartObstacles[i].xMax + 1,
-                                    obstacle: chartObstacles[i]
-                                };
-                            }
-                            // else ...
-                            return {
-                                x: fromPoint.x,
-                                y: fromPoint.y < toPoint.y ?
-                                    chartObstacles[i].yMin - 1 :
-                                    chartObstacles[i].yMax + 1,
-                                obstacle: chartObstacles[i]
-                            };
-                        }
-                        i += searchDirection;
-                    }
-                    return toPoint;
-                }
-                /**
-                 * Decide in which direction to dodge or get out of an obstacle.
-                 * Considers desired direction, which way is shortest, soft and hard
-                 * bounds.
-                 *
-                 * (? Returns a string, either xMin, xMax, yMin or yMax.)
-                 *
-                 * @private
-                 * @function
-                 *
-                 * @param {object} obstacle
-                 *        Obstacle to dodge/escape.
-                 *
-                 * @param {object} fromPoint
-                 *        Point with x/y props that's dodging/escaping.
-                 *
-                 * @param {object} toPoint
-                 *        Goal point.
-                 *
-                 * @param {boolean} dirIsX
-                 *        Dodge in X dimension.
-                 *
-                 * @param {object} bounds
-                 *        Hard and soft boundaries.
-                 *
-                 * @return {boolean}
-                 *         Use max or not.
-                 */
-                function getDodgeDirection(obstacle, fromPoint, toPoint, dirIsX, bounds) {
-                    var softBounds = bounds.soft, hardBounds = bounds.hard, dir = dirIsX ? 'x' : 'y', toPointMax = { x: fromPoint.x, y: fromPoint.y }, toPointMin = { x: fromPoint.x, y: fromPoint.y }, minPivot, maxPivot, maxOutOfSoftBounds = obstacle[dir + 'Max'] >=
-                            softBounds[dir + 'Max'], minOutOfSoftBounds = obstacle[dir + 'Min'] <=
-                            softBounds[dir + 'Min'], maxOutOfHardBounds = obstacle[dir + 'Max'] >=
-                            hardBounds[dir + 'Max'], minOutOfHardBounds = obstacle[dir + 'Min'] <=
-                            hardBounds[dir + 'Min'], 
-                        // Find out if we should prefer one direction over the other if
-                        // we can choose freely
-                        minDistance = abs(obstacle[dir + 'Min'] - fromPoint[dir]), maxDistance = abs(obstacle[dir + 'Max'] - fromPoint[dir]), 
-                        // If it's a small difference, pick the one leading towards dest
-                        // point. Otherwise pick the shortest distance
-                        useMax = abs(minDistance - maxDistance) < 10 ?
-                            fromPoint[dir] < toPoint[dir] :
-                            maxDistance < minDistance;
-                    // Check if we hit any obstacles trying to go around in either
-                    // direction.
-                    toPointMin[dir] = obstacle[dir + 'Min'];
-                    toPointMax[dir] = obstacle[dir + 'Max'];
-                    minPivot = pivotPoint(fromPoint, toPointMin, dirIsX)[dir] !==
-                        toPointMin[dir];
-                    maxPivot = pivotPoint(fromPoint, toPointMax, dirIsX)[dir] !==
-                        toPointMax[dir];
-                    useMax = minPivot ?
-                        (maxPivot ? useMax : true) :
-                        (maxPivot ? false : useMax);
-                    // useMax now contains our preferred choice, bounds not taken into
-                    // account. If both or neither direction is out of bounds we want to
-                    // use this.
-                    // Deal with soft bounds
-                    useMax = minOutOfSoftBounds ?
-                        (maxOutOfSoftBounds ? useMax : true) : // Out on min
-                        (maxOutOfSoftBounds ? false : useMax); // Not out on min
-                    // Deal with hard bounds
-                    useMax = minOutOfHardBounds ?
-                        (maxOutOfHardBounds ? useMax : true) : // Out on min
-                        (maxOutOfHardBounds ? false : useMax); // Not out on min
-                    return useMax;
-                }
-                // eslint-disable-next-line valid-jsdoc
-                /**
-                 * Find a clear path between point.
-                 * @private
-                 */
-                function clearPathTo(fromPoint, toPoint, dirIsX) {
-                    // Don't waste time if we've hit goal
-                    if (fromPoint.x === toPoint.x && fromPoint.y === toPoint.y) {
-                        return [];
-                    }
-                    var dir = dirIsX ? 'x' : 'y',
-                        pivot,
-                        segments,
-                        waypoint,
-                        waypointUseMax,
-                        envelopingObstacle,
-                        secondEnvelopingObstacle,
-                        envelopWaypoint,
-                        obstacleMargin = options.obstacleOptions.margin,
-                        bounds = {
-                            soft: {
-                                xMin: softMinX,
-                                xMax: softMaxX,
-                                yMin: softMinY,
-                                yMax: softMaxY
-                            },
-                            hard: options.hardBounds
-                        };
-                    // If fromPoint is inside an obstacle we have a problem. Break out
-                    // by just going to the outside of this obstacle. We prefer to go to
-                    // the nearest edge in the chosen direction.
-                    envelopingObstacle =
-                        findObstacleFromPoint(chartObstacles, fromPoint);
-                    if (envelopingObstacle > -1) {
-                        envelopingObstacle = chartObstacles[envelopingObstacle];
-                        waypointUseMax = getDodgeDirection(envelopingObstacle, fromPoint, toPoint, dirIsX, bounds);
-                        // Cut obstacle to hard bounds to make sure we stay within
-                        limitObstacleToBounds(envelopingObstacle, options.hardBounds);
-                        envelopWaypoint = dirIsX ? {
-                            y: fromPoint.y,
-                            x: envelopingObstacle[waypointUseMax ? 'xMax' : 'xMin'] +
-                                (waypointUseMax ? 1 : -1)
-                        } : {
-                            x: fromPoint.x,
-                            y: envelopingObstacle[waypointUseMax ? 'yMax' : 'yMin'] +
-                                (waypointUseMax ? 1 : -1)
-                        };
-                        // If we crashed into another obstacle doing this, we put the
-                        // waypoint between them instead
-                        secondEnvelopingObstacle = findObstacleFromPoint(chartObstacles, envelopWaypoint);
-                        if (secondEnvelopingObstacle > -1) {
-                            secondEnvelopingObstacle = chartObstacles[secondEnvelopingObstacle];
-                            // Cut obstacle to hard bounds
-                            limitObstacleToBounds(secondEnvelopingObstacle, options.hardBounds);
-                            // Modify waypoint to lay between obstacles
-                            envelopWaypoint[dir] = waypointUseMax ? max(envelopingObstacle[dir + 'Max'] - obstacleMargin + 1, (secondEnvelopingObstacle[dir + 'Min'] +
-                                envelopingObstacle[dir + 'Max']) / 2) :
-                                min((envelopingObstacle[dir + 'Min'] + obstacleMargin - 1), ((secondEnvelopingObstacle[dir + 'Max'] +
-                                    envelopingObstacle[dir + 'Min']) / 2));
-                            // We are not going anywhere. If this happens for the first
-                            // time, do nothing. Otherwise, try to go to the extreme of
-                            // the obstacle pair in the current direction.
-                            if (fromPoint.x === envelopWaypoint.x &&
-                                fromPoint.y === envelopWaypoint.y) {
-                                if (forceObstacleBreak) {
-                                    envelopWaypoint[dir] = waypointUseMax ?
-                                        max(envelopingObstacle[dir + 'Max'], secondEnvelopingObstacle[dir + 'Max']) + 1 :
-                                        min(envelopingObstacle[dir + 'Min'], secondEnvelopingObstacle[dir + 'Min']) - 1;
-                                }
-                                // Toggle on if off, and the opposite
-                                forceObstacleBreak = !forceObstacleBreak;
-                            }
-                            else {
-                                // This point is not identical to previous.
-                                // Clear break trigger.
-                                forceObstacleBreak = false;
-                            }
-                        }
-                        segments = [{
-                                start: fromPoint,
-                                end: envelopWaypoint
-                            }];
-                    }
-                    else { // If not enveloping, use standard pivot calculation
-                        pivot = pivotPoint(fromPoint, {
-                            x: dirIsX ? toPoint.x : fromPoint.x,
-                            y: dirIsX ? fromPoint.y : toPoint.y
-                        }, dirIsX);
-                        segments = [{
-                                start: fromPoint,
-                                end: {
-                                    x: pivot.x,
-                                    y: pivot.y
-                                }
-                            }];
-                        // Pivot before goal, use a waypoint to dodge obstacle
-                        if (pivot[dirIsX ? 'x' : 'y'] !== toPoint[dirIsX ? 'x' : 'y']) {
-                            // Find direction of waypoint
-                            waypointUseMax = getDodgeDirection(pivot.obstacle, pivot, toPoint, !dirIsX, bounds);
-                            // Cut waypoint to hard bounds
-                            limitObstacleToBounds(pivot.obstacle, options.hardBounds);
-                            waypoint = {
-                                x: dirIsX ?
-                                    pivot.x :
-                                    pivot.obstacle[waypointUseMax ? 'xMax' : 'xMin'] +
-                                        (waypointUseMax ? 1 : -1),
-                                y: dirIsX ?
-                                    pivot.obstacle[waypointUseMax ? 'yMax' : 'yMin'] +
-                                        (waypointUseMax ? 1 : -1) :
-                                    pivot.y
-                            };
-                            // We're changing direction here, store that to make sure we
-                            // also change direction when adding the last segment array
-                            // after handling waypoint.
-                            dirIsX = !dirIsX;
-                            segments = segments.concat(clearPathTo({
-                                x: pivot.x,
-                                y: pivot.y
-                            }, waypoint, dirIsX));
-                        }
-                    }
-                    // Get segments for the other direction too
-                    // Recursion is our friend
-                    segments = segments.concat(clearPathTo(segments[segments.length - 1].end, toPoint, !dirIsX));
-                    return segments;
-                }
-                // eslint-disable-next-line valid-jsdoc
-                /**
-                 * Extract point to outside of obstacle in whichever direction is
-                 * closest. Returns new point outside obstacle.
-                 * @private
-                 */
-                function extractFromObstacle(obstacle, point, goalPoint) {
-                    var dirIsX = min(obstacle.xMax - point.x,
-                        point.x - obstacle.xMin) <
-                            min(obstacle.yMax - point.y,
-                        point.y - obstacle.yMin),
-                        bounds = {
-                            soft: options.hardBounds,
-                            hard: options.hardBounds
-                        },
-                        useMax = getDodgeDirection(obstacle,
-                        point,
-                        goalPoint,
-                        dirIsX,
-                        bounds);
-                    return dirIsX ? {
-                        y: point.y,
-                        x: obstacle[useMax ? 'xMax' : 'xMin'] + (useMax ? 1 : -1)
-                    } : {
-                        x: point.x,
-                        y: obstacle[useMax ? 'yMax' : 'yMin'] + (useMax ? 1 : -1)
-                    };
-                }
-                // Cut the obstacle array to soft bounds for optimization in large
-                // datasets.
-                chartObstacles =
-                    chartObstacles.slice(startObstacleIx, endObstacleIx + 1);
-                // If an obstacle envelops the end point, move it out of there and add
-                // a little segment to where it was.
-                if ((endObstacleIx = findObstacleFromPoint(chartObstacles, end)) > -1) {
-                    extractedEndPoint = extractFromObstacle(chartObstacles[endObstacleIx], end, start);
-                    endSegments.push({
-                        end: end,
-                        start: extractedEndPoint
-                    });
-                    end = extractedEndPoint;
-                }
-                // If it's still inside one or more obstacles, get out of there by
-                // force-moving towards the start point.
-                while ((endObstacleIx = findObstacleFromPoint(chartObstacles, end)) > -1) {
-                    useMax = end[dir] - start[dir] < 0;
-                    extractedEndPoint = {
-                        x: end.x,
-                        y: end.y
-                    };
-                    extractedEndPoint[dir] = chartObstacles[endObstacleIx][useMax ? dir + 'Max' : dir + 'Min'] + (useMax ? 1 : -1);
-                    endSegments.push({
-                        end: end,
-                        start: extractedEndPoint
-                    });
-                    end = extractedEndPoint;
-                }
-                // Find the path
-                segments = clearPathTo(start, end, dirIsX);
-                // Add the end-point segments
-                segments = segments.concat(endSegments.reverse());
-                return {
-                    path: pathFromSegments(segments),
-                    obstacles: segments
-                };
-            }, {
-                requiresObstacles: true
-            })
-        };
-
-        return algorithms;
-    });
-    _registerModule(_modules, 'parts-gantt/ArrowSymbols.js', [_modules['parts/Globals.js']], function (H) {
-        /* *
-         *
-         *  (c) 2017 Highsoft AS
-         *  Authors: Lars A. V. Cabrera
-         *
-         *  License: www.highcharts.com/license
-         *
-         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
-         *
-         * */
-        /**
-         * Creates an arrow symbol. Like a triangle, except not filled.
-         * ```
-         *                   o
-         *             o
-         *       o
-         * o
-         *       o
-         *             o
-         *                   o
-         * ```
-         *
-         * @private
-         * @function
-         *
-         * @param {number} x
-         *        x position of the arrow
-         *
-         * @param {number} y
-         *        y position of the arrow
-         *
-         * @param {number} w
-         *        width of the arrow
+         * @param {number} w
+         *        width of the arrow
          *
          * @param {number} h
          *        height of the arrow
@@ -3898,7 +3345,7 @@
          * @return {Highcharts.SVGPathArray}
          *         Path array
          */
-        H.SVGRenderer.prototype.symbols.arrow = function (x, y, w, h) {
+        SVGRenderer.prototype.symbols.arrow = function (x, y, w, h) {
             return [
                 ['M', x, y + h / 2],
                 ['L', x + w, y],
@@ -3934,8 +3381,8 @@
          * @return {Highcharts.SVGPathArray}
          *         Path array
          */
-        H.SVGRenderer.prototype.symbols['arrow-half'] = function (x, y, w, h) {
-            return H.SVGRenderer.prototype.symbols.arrow(x, y, w / 2, h);
+        SVGRenderer.prototype.symbols['arrow-half'] = function (x, y, w, h) {
+            return SVGRenderer.prototype.symbols.arrow(x, y, w / 2, h);
         };
         /**
          * Creates a left-oriented triangle.
@@ -3965,7 +3412,7 @@
          * @return {Highcharts.SVGPathArray}
          *         Path array
          */
-        H.SVGRenderer.prototype.symbols['triangle-left'] = function (x, y, w, h) {
+        SVGRenderer.prototype.symbols['triangle-left'] = function (x, y, w, h) {
             return [
                 ['M', x + w, y],
                 ['L', x, y + h / 2],
@@ -3994,8 +3441,7 @@
          * @return {Highcharts.SVGPathArray}
          *         Path array
          */
-        H.SVGRenderer.prototype.symbols['arrow-filled'] =
-            H.SVGRenderer.prototype.symbols['triangle-left'];
+        SVGRenderer.prototype.symbols['arrow-filled'] = SVGRenderer.prototype.symbols['triangle-left'];
         /**
          * Creates a half-width, left-oriented triangle.
          * ```
@@ -4024,8 +3470,8 @@
          * @return {Highcharts.SVGPathArray}
          *         Path array
          */
-        H.SVGRenderer.prototype.symbols['triangle-left-half'] = function (x, y, w, h) {
-            return H.SVGRenderer.prototype.symbols['triangle-left'](x, y, w / 2, h);
+        SVGRenderer.prototype.symbols['triangle-left-half'] = function (x, y, w, h) {
+            return SVGRenderer.prototype.symbols['triangle-left'](x, y, w / 2, h);
         };
         /**
          * Alias function for triangle-left-half.
@@ -4048,11 +3494,10 @@
          * @return {Highcharts.SVGPathArray}
          *         Path array
          */
-        H.SVGRenderer.prototype.symbols['arrow-filled-half'] =
-            H.SVGRenderer.prototype.symbols['triangle-left-half'];
+        SVGRenderer.prototype.symbols['arrow-filled-half'] = SVGRenderer.prototype.symbols['triangle-left-half'];
 
     });
-    _registerModule(_modules, 'parts-gantt/Pathfinder.js', [_modules['parts/Globals.js'], _modules['parts/Point.js'], _modules['parts/Utilities.js'], _modules['parts-gantt/PathfinderAlgorithms.js']], function (H, Point, U, pathfinderAlgorithms) {
+    _registerModule(_modules, 'Gantt/Connection.js', [_modules['Core/Globals.js'], _modules['Core/Options.js'], _modules['Core/Series/Point.js'], _modules['Core/Utilities.js']], function (H, O, Point, U) {
         /* *
          *
          *  (c) 2016 Highsoft AS
@@ -4086,6 +3531,7 @@
          * @typedef {"fastAvoid"|"simpleConnect"|"straight"|string} Highcharts.PathfinderTypeValue
          */
         ''; // detach doclets above
+        var defaultOptions = O.defaultOptions;
         var addEvent = U.addEvent,
             defined = U.defined,
             error = U.error,
@@ -4104,7 +3550,7 @@
                and rendering it
         */
         // Set default Pathfinder options
-        extend(H.defaultOptions, {
+        extend(defaultOptions, {
             /**
              * The Pathfinder module allows you to define connections between any two
              * points, represented as lines - optionally with markers for the start
@@ -4463,10 +3909,20 @@
          * @param {Highcharts.ConnectorsOptions} [options]
          *        Connection options.
          */
-        function Connection(from, to, options) {
-            this.init(from, to, options);
-        }
-        Connection.prototype = {
+        var Connection = /** @class */ (function () {
+                function Connection(from, to, options) {
+                    /* *
+                    *
+                    * Properties
+                    *
+                    * */
+                    this.chart = void 0;
+                this.fromPoint = void 0;
+                this.graphics = void 0;
+                this.pathfinder = void 0;
+                this.toPoint = void 0;
+                this.init(from, to, options);
+            }
             /**
              * Initialize the Connection object. Used as constructor only.
              *
@@ -4481,13 +3937,13 @@
              * @param {Highcharts.ConnectorsOptions} [options]
              *        Connection options.
              */
-            init: function (from, to, options) {
+            Connection.prototype.init = function (from, to, options) {
                 this.fromPoint = from;
                 this.toPoint = to;
                 this.options = options;
                 this.chart = from.series.chart;
                 this.pathfinder = this.chart.pathfinder;
-            },
+            };
             /**
              * Add (or update) this connection's path on chart. Stores reference to the
              * created element on this.graphics.path.
@@ -4500,10 +3956,10 @@
              * @param {Highcharts.SVGAttributes} [attribs]
              *        SVG attributes for the path.
              *
-             * @param {Highcharts.AnimationOptionsObject} [animation]
+             * @param {Partial<Highcharts.AnimationOptionsObject>} [animation]
              *        Animation options for the rendering.
              */
-            renderPath: function (path, attribs, animation) {
+            Connection.prototype.renderPath = function (path, attribs, animation) {
                 var connection = this,
                     chart = this.chart,
                     styledMode = chart.styledMode,
@@ -4542,7 +3998,7 @@
                 // Store reference on connection
                 this.graphics = this.graphics || {};
                 this.graphics.path = pathGraphic;
-            },
+            };
             /**
              * Calculate and add marker graphics for connection to the chart. The
              * created/updated elements are stored on this.graphics.start and
@@ -4561,7 +4017,7 @@
              *        Connection path in array format. This is used to calculate the
              *        rotation angle of the markers.
              */
-            addMarker: function (type, options, path) {
+            Connection.prototype.addMarker = function (type, options, path) {
                 var connection = this,
                     chart = connection.fromPoint.series.chart,
                     pathfinder = chart.pathfinder,
@@ -4644,7 +4100,7 @@
                         connection.graphics[type].animate(box);
                     }
                 }
-            },
+            };
             /**
              * Calculate and return connection path.
              * Note: Recalculates chart obstacles on demand if they aren't calculated.
@@ -4657,14 +4113,17 @@
              * @return {object|undefined}
              *         Calculated SVG path data in array format.
              */
-            getPath: function (options) {
+            Connection.prototype.getPath = function (options) {
                 var pathfinder = this.pathfinder,
                     chart = this.chart,
                     algorithm = pathfinder.algorithms[options.type],
                     chartObstacles = pathfinder.chartObstacles;
                 if (typeof algorithm !== 'function') {
                     error('"' + options.type + '" is not a Pathfinder algorithm.');
-                    return;
+                    return {
+                        path: [],
+                        obstacles: []
+                    };
                 }
                 // This function calculates obstacles on demand if they don't exist
                 if (algorithm.requiresObstacles && !chartObstacles) {
@@ -4679,92 +4138,1393 @@
                     pathfinder.chartObstacleMetrics =
                         pathfinder.getObstacleMetrics(chartObstacles);
                 }
-                // Get the SVG path
-                return algorithm(
-                // From
-                this.fromPoint.getPathfinderAnchorPoint(options.startMarker), 
-                // To
-                this.toPoint.getPathfinderAnchorPoint(options.endMarker), merge({
-                    chartObstacles: chartObstacles,
-                    lineObstacles: pathfinder.lineObstacles || [],
-                    obstacleMetrics: pathfinder.chartObstacleMetrics,
-                    hardBounds: {
-                        xMin: 0,
-                        xMax: chart.plotWidth,
-                        yMin: 0,
-                        yMax: chart.plotHeight
-                    },
-                    obstacleOptions: {
-                        margin: options.algorithmMargin
-                    },
-                    startDirectionX: pathfinder.getAlgorithmStartDirection(options.startMarker)
-                }, options));
-            },
-            /**
-             * (re)Calculate and (re)draw the connection.
-             *
-             * @function Highcharts.Connection#render
-             */
-            render: function () {
-                var connection = this,
-                    fromPoint = connection.fromPoint,
-                    series = fromPoint.series,
-                    chart = series.chart,
-                    pathfinder = chart.pathfinder,
-                    pathResult,
-                    path,
-                    options = merge(chart.options.connectors,
-                    series.options.connectors,
-                    fromPoint.options.connectors,
-                    connection.options),
-                    attribs = {};
-                // Set path attribs
-                if (!chart.styledMode) {
-                    attribs.stroke = options.lineColor || fromPoint.color;
-                    attribs['stroke-width'] = options.lineWidth;
-                    if (options.dashStyle) {
-                        attribs.dashstyle = options.dashStyle;
+                // Get the SVG path
+                return algorithm(
+                // From
+                this.fromPoint.getPathfinderAnchorPoint(options.startMarker), 
+                // To
+                this.toPoint.getPathfinderAnchorPoint(options.endMarker), merge({
+                    chartObstacles: chartObstacles,
+                    lineObstacles: pathfinder.lineObstacles || [],
+                    obstacleMetrics: pathfinder.chartObstacleMetrics,
+                    hardBounds: {
+                        xMin: 0,
+                        xMax: chart.plotWidth,
+                        yMin: 0,
+                        yMax: chart.plotHeight
+                    },
+                    obstacleOptions: {
+                        margin: options.algorithmMargin
+                    },
+                    startDirectionX: pathfinder.getAlgorithmStartDirection(options.startMarker)
+                }, options));
+            };
+            /**
+             * (re)Calculate and (re)draw the connection.
+             *
+             * @function Highcharts.Connection#render
+             */
+            Connection.prototype.render = function () {
+                var connection = this,
+                    fromPoint = connection.fromPoint,
+                    series = fromPoint.series,
+                    chart = series.chart,
+                    pathfinder = chart.pathfinder,
+                    pathResult,
+                    path,
+                    options = merge(chart.options.connectors,
+                    series.options.connectors,
+                    fromPoint.options.connectors,
+                    connection.options),
+                    attribs = {};
+                // Set path attribs
+                if (!chart.styledMode) {
+                    attribs.stroke = options.lineColor || fromPoint.color;
+                    attribs['stroke-width'] = options.lineWidth;
+                    if (options.dashStyle) {
+                        attribs.dashstyle = options.dashStyle;
+                    }
+                }
+                attribs['class'] = // eslint-disable-line dot-notation
+                    'highcharts-point-connecting-path ' +
+                        'highcharts-color-' + fromPoint.colorIndex;
+                options = merge(attribs, options);
+                // Set common marker options
+                if (!defined(options.marker.radius)) {
+                    options.marker.radius = min(max(Math.ceil((options.algorithmMargin || 8) / 2) - 1, 1), 5);
+                }
+                // Get the path
+                pathResult = connection.getPath(options);
+                path = pathResult.path;
+                // Always update obstacle storage with obstacles from this path.
+                // We don't know if future calls will need this for their algorithm.
+                if (pathResult.obstacles) {
+                    pathfinder.lineObstacles =
+                        pathfinder.lineObstacles || [];
+                    pathfinder.lineObstacles =
+                        pathfinder.lineObstacles.concat(pathResult.obstacles);
+                }
+                // Add the calculated path to the pathfinder group
+                connection.renderPath(path, attribs, series.options.animation);
+                // Render the markers
+                connection.addMarker('start', merge(options.marker, options.startMarker), path);
+                connection.addMarker('end', merge(options.marker, options.endMarker), path);
+            };
+            /**
+             * Destroy connection by destroying the added graphics elements.
+             *
+             * @function Highcharts.Connection#destroy
+             */
+            Connection.prototype.destroy = function () {
+                if (this.graphics) {
+                    objectEach(this.graphics, function (val) {
+                        val.destroy();
+                    });
+                    delete this.graphics;
+                }
+            };
+            return Connection;
+        }());
+        // Add to Highcharts namespace
+        H.Connection = Connection;
+        // Add pathfinding capabilities to Points
+        extend(Point.prototype, /** @lends Point.prototype */ {
+            /**
+             * Get coordinates of anchor point for pathfinder connection.
+             *
+             * @private
+             * @function Highcharts.Point#getPathfinderAnchorPoint
+             *
+             * @param {Highcharts.ConnectorsMarkerOptions} markerOptions
+             *        Connection options for position on point.
+             *
+             * @return {Highcharts.PositionObject}
+             *         An object with x/y properties for the position. Coordinates are
+             *         in plot values, not relative to point.
+             */
+            getPathfinderAnchorPoint: function (markerOptions) {
+                var bb = getPointBB(this),
+                    x,
+                    y;
+                switch (markerOptions.align) { // eslint-disable-line default-case
+                    case 'right':
+                        x = 'xMax';
+                        break;
+                    case 'left':
+                        x = 'xMin';
+                }
+                switch (markerOptions.verticalAlign) { // eslint-disable-line default-case
+                    case 'top':
+                        y = 'yMin';
+                        break;
+                    case 'bottom':
+                        y = 'yMax';
+                }
+                return {
+                    x: x ? bb[x] : (bb.xMin + bb.xMax) / 2,
+                    y: y ? bb[y] : (bb.yMin + bb.yMax) / 2
+                };
+            },
+            /**
+             * Utility to get the angle from one point to another.
+             *
+             * @private
+             * @function Highcharts.Point#getRadiansToVector
+             *
+             * @param {Highcharts.PositionObject} v1
+             *        The first vector, as an object with x/y properties.
+             *
+             * @param {Highcharts.PositionObject} v2
+             *        The second vector, as an object with x/y properties.
+             *
+             * @return {number}
+             *         The angle in degrees
+             */
+            getRadiansToVector: function (v1, v2) {
+                var box;
+                if (!defined(v2)) {
+                    box = getPointBB(this);
+                    if (box) {
+                        v2 = {
+                            x: (box.xMin + box.xMax) / 2,
+                            y: (box.yMin + box.yMax) / 2
+                        };
+                    }
+                }
+                return Math.atan2(v2.y - v1.y, v1.x - v2.x);
+            },
+            /**
+             * Utility to get the position of the marker, based on the path angle and
+             * the marker's radius.
+             *
+             * @private
+             * @function Highcharts.Point#getMarkerVector
+             *
+             * @param {number} radians
+             *        The angle in radians from the point center to another vector.
+             *
+             * @param {number} markerRadius
+             *        The radius of the marker, to calculate the additional distance to
+             *        the center of the marker.
+             *
+             * @param {object} anchor
+             *        The anchor point of the path and marker as an object with x/y
+             *        properties.
+             *
+             * @return {object}
+             *         The marker vector as an object with x/y properties.
+             */
+            getMarkerVector: function (radians, markerRadius, anchor) {
+                var twoPI = Math.PI * 2.0,
+                    theta = radians,
+                    bb = getPointBB(this),
+                    rectWidth = bb.xMax - bb.xMin,
+                    rectHeight = bb.yMax - bb.yMin,
+                    rAtan = Math.atan2(rectHeight,
+                    rectWidth),
+                    tanTheta = 1,
+                    leftOrRightRegion = false,
+                    rectHalfWidth = rectWidth / 2.0,
+                    rectHalfHeight = rectHeight / 2.0,
+                    rectHorizontalCenter = bb.xMin + rectHalfWidth,
+                    rectVerticalCenter = bb.yMin + rectHalfHeight,
+                    edgePoint = {
+                        x: rectHorizontalCenter,
+                        y: rectVerticalCenter
+                    },
+                    markerPoint = {},
+                    xFactor = 1,
+                    yFactor = 1;
+                while (theta < -Math.PI) {
+                    theta += twoPI;
+                }
+                while (theta > Math.PI) {
+                    theta -= twoPI;
+                }
+                tanTheta = Math.tan(theta);
+                if ((theta > -rAtan) && (theta <= rAtan)) {
+                    // Right side
+                    yFactor = -1;
+                    leftOrRightRegion = true;
+                }
+                else if (theta > rAtan && theta <= (Math.PI - rAtan)) {
+                    // Top side
+                    yFactor = -1;
+                }
+                else if (theta > (Math.PI - rAtan) || theta <= -(Math.PI - rAtan)) {
+                    // Left side
+                    xFactor = -1;
+                    leftOrRightRegion = true;
+                }
+                else {
+                    // Bottom side
+                    xFactor = -1;
+                }
+                // Correct the edgePoint according to the placement of the marker
+                if (leftOrRightRegion) {
+                    edgePoint.x += xFactor * (rectHalfWidth);
+                    edgePoint.y += yFactor * (rectHalfWidth) * tanTheta;
+                }
+                else {
+                    edgePoint.x += xFactor * (rectHeight / (2.0 * tanTheta));
+                    edgePoint.y += yFactor * (rectHalfHeight);
+                }
+                if (anchor.x !== rectHorizontalCenter) {
+                    edgePoint.x = anchor.x;
+                }
+                if (anchor.y !== rectVerticalCenter) {
+                    edgePoint.y = anchor.y;
+                }
+                markerPoint.x = edgePoint.x + (markerRadius * Math.cos(theta));
+                markerPoint.y = edgePoint.y - (markerRadius * Math.sin(theta));
+                return markerPoint;
+            }
+        });
+        /**
+         * Warn if using legacy options. Copy the options over. Note that this will
+         * still break if using the legacy options in chart.update, addSeries etc.
+         * @private
+         */
+        function warnLegacy(chart) {
+            if (chart.options.pathfinder ||
+                chart.series.reduce(function (acc, series) {
+                    if (series.options) {
+                        merge(true, (series.options.connectors = series.options.connectors ||
+                            {}), series.options.pathfinder);
+                    }
+                    return acc || series.options && series.options.pathfinder;
+                }, false)) {
+                merge(true, (chart.options.connectors = chart.options.connectors || {}), chart.options.pathfinder);
+                error('WARNING: Pathfinder options have been renamed. ' +
+                    'Use "chart.connectors" or "series.connectors" instead.');
+            }
+        }
+
+        return Connection;
+    });
+    _registerModule(_modules, 'Gantt/PathfinderAlgorithms.js', [_modules['Core/Utilities.js']], function (U) {
+        /* *
+         *
+         *  (c) 2016 Highsoft AS
+         *  Author: Øystein Moseng
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        var extend = U.extend,
+            pick = U.pick;
+        var min = Math.min,
+            max = Math.max,
+            abs = Math.abs;
+        /**
+         * Get index of last obstacle before xMin. Employs a type of binary search, and
+         * thus requires that obstacles are sorted by xMin value.
+         *
+         * @private
+         * @function findLastObstacleBefore
+         *
+         * @param {Array<object>} obstacles
+         *        Array of obstacles to search in.
+         *
+         * @param {number} xMin
+         *        The xMin threshold.
+         *
+         * @param {number} [startIx]
+         *        Starting index to search from. Must be within array range.
+         *
+         * @return {number}
+         *         The index of the last obstacle element before xMin.
+         */
+        function findLastObstacleBefore(obstacles, xMin, startIx) {
+            var left = startIx || 0, // left limit
+                right = obstacles.length - 1, // right limit
+                min = xMin - 0.0000001, // Make sure we include all obstacles at xMin
+                cursor,
+                cmp;
+            while (left <= right) {
+                cursor = (right + left) >> 1;
+                cmp = min - obstacles[cursor].xMin;
+                if (cmp > 0) {
+                    left = cursor + 1;
+                }
+                else if (cmp < 0) {
+                    right = cursor - 1;
+                }
+                else {
+                    return cursor;
+                }
+            }
+            return left > 0 ? left - 1 : 0;
+        }
+        /**
+         * Test if a point lays within an obstacle.
+         *
+         * @private
+         * @function pointWithinObstacle
+         *
+         * @param {object} obstacle
+         *        Obstacle to test.
+         *
+         * @param {Highcharts.Point} point
+         *        Point with x/y props.
+         *
+         * @return {boolean}
+         *         Whether point is within the obstacle or not.
+         */
+        function pointWithinObstacle(obstacle, point) {
+            return (point.x <= obstacle.xMax &&
+                point.x >= obstacle.xMin &&
+                point.y <= obstacle.yMax &&
+                point.y >= obstacle.yMin);
+        }
+        /**
+         * Find the index of an obstacle that wraps around a point.
+         * Returns -1 if not found.
+         *
+         * @private
+         * @function findObstacleFromPoint
+         *
+         * @param {Array<object>} obstacles
+         *        Obstacles to test.
+         *
+         * @param {Highcharts.Point} point
+         *        Point with x/y props.
+         *
+         * @return {number}
+         *         Ix of the obstacle in the array, or -1 if not found.
+         */
+        function findObstacleFromPoint(obstacles, point) {
+            var i = findLastObstacleBefore(obstacles,
+                point.x + 1) + 1;
+            while (i--) {
+                if (obstacles[i].xMax >= point.x &&
+                    // optimization using lazy evaluation
+                    pointWithinObstacle(obstacles[i], point)) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+        /**
+         * Get SVG path array from array of line segments.
+         *
+         * @private
+         * @function pathFromSegments
+         *
+         * @param {Array<object>} segments
+         *        The segments to build the path from.
+         *
+         * @return {Highcharts.SVGPathArray}
+         *         SVG path array as accepted by the SVG Renderer.
+         */
+        function pathFromSegments(segments) {
+            var path = [];
+            if (segments.length) {
+                path.push(['M', segments[0].start.x, segments[0].start.y]);
+                for (var i = 0; i < segments.length; ++i) {
+                    path.push(['L', segments[i].end.x, segments[i].end.y]);
+                }
+            }
+            return path;
+        }
+        /**
+         * Limits obstacle max/mins in all directions to bounds. Modifies input
+         * obstacle.
+         *
+         * @private
+         * @function limitObstacleToBounds
+         *
+         * @param {object} obstacle
+         *        Obstacle to limit.
+         *
+         * @param {object} bounds
+         *        Bounds to use as limit.
+         *
+         * @return {void}
+         */
+        function limitObstacleToBounds(obstacle, bounds) {
+            obstacle.yMin = max(obstacle.yMin, bounds.yMin);
+            obstacle.yMax = min(obstacle.yMax, bounds.yMax);
+            obstacle.xMin = max(obstacle.xMin, bounds.xMin);
+            obstacle.xMax = min(obstacle.xMax, bounds.xMax);
+        }
+        /**
+         * Get an SVG path from a starting coordinate to an ending coordinate.
+         * Draws a straight line.
+         *
+         * @function Highcharts.Pathfinder.algorithms.straight
+         *
+         * @param {Highcharts.PositionObject} start
+         *        Starting coordinate, object with x/y props.
+         *
+         * @param {Highcharts.PositionObject} end
+         *        Ending coordinate, object with x/y props.
+         *
+         * @return {object}
+         *         An object with the SVG path in Array form as accepted by the SVG
+         *         renderer, as well as an array of new obstacles making up this
+         *         path.
+         */
+        function straight(start, end) {
+            return {
+                path: [
+                    ['M', start.x, start.y],
+                    ['L', end.x, end.y]
+                ],
+                obstacles: [{ start: start, end: end }]
+            };
+        }
+        /**
+         * Find a path from a starting coordinate to an ending coordinate, using
+         * right angles only, and taking only starting/ending obstacle into
+         * consideration.
+         *
+         * @function Highcharts.Pathfinder.algorithms.simpleConnect
+         *
+         * @param {Highcharts.PositionObject} start
+         *        Starting coordinate, object with x/y props.
+         *
+         * @param {Highcharts.PositionObject} end
+         *        Ending coordinate, object with x/y props.
+         *
+         * @param {object} options
+         *        Options for the algorithm:
+         *        - chartObstacles: Array of chart obstacles to avoid
+         *        - startDirectionX: Optional. True if starting in the X direction.
+         *          If not provided, the algorithm starts in the direction that is
+         *          the furthest between start/end.
+         *
+         * @return {object}
+         *         An object with the SVG path in Array form as accepted by the SVG
+         *         renderer, as well as an array of new obstacles making up this
+         *         path.
+         */
+        var simpleConnect = extend(function (start,
+            end,
+            options) {
+                var segments = [],
+            endSegment,
+            dir = pick(options.startDirectionX,
+            abs(end.x - start.x) > abs(end.y - start.y)) ? 'x' : 'y',
+            chartObstacles = options.chartObstacles,
+            startObstacleIx = findObstacleFromPoint(chartObstacles,
+            start),
+            endObstacleIx = findObstacleFromPoint(chartObstacles,
+            end),
+            startObstacle,
+            endObstacle,
+            prevWaypoint,
+            waypoint,
+            waypoint2,
+            useMax,
+            endPoint;
+            // eslint-disable-next-line valid-jsdoc
+            /**
+             * Return a clone of a point with a property set from a target object,
+             * optionally with an offset
+             * @private
+             */
+            function copyFromPoint(from, fromKey, to, toKey, offset) {
+                var point = {
+                        x: from.x,
+                        y: from.y
+                    };
+                point[fromKey] = to[toKey || fromKey] + (offset || 0);
+                return point;
+            }
+            // eslint-disable-next-line valid-jsdoc
+            /**
+             * Return waypoint outside obstacle.
+             * @private
+             */
+            function getMeOut(obstacle, point, direction) {
+                var useMax = abs(point[direction] - obstacle[direction + 'Min']) >
+                        abs(point[direction] - obstacle[direction + 'Max']);
+                return copyFromPoint(point, direction, obstacle, direction + (useMax ? 'Max' : 'Min'), useMax ? 1 : -1);
+            }
+            // Pull out end point
+            if (endObstacleIx > -1) {
+                endObstacle = chartObstacles[endObstacleIx];
+                waypoint = getMeOut(endObstacle, end, dir);
+                endSegment = {
+                    start: waypoint,
+                    end: end
+                };
+                endPoint = waypoint;
+            }
+            else {
+                endPoint = end;
+            }
+            // If an obstacle envelops the start point, add a segment to get out,
+            // and around it.
+            if (startObstacleIx > -1) {
+                startObstacle = chartObstacles[startObstacleIx];
+                waypoint = getMeOut(startObstacle, start, dir);
+                segments.push({
+                    start: start,
+                    end: waypoint
+                });
+                // If we are going back again, switch direction to get around start
+                // obstacle.
+                if (
+                // Going towards max from start:
+                waypoint[dir] >= start[dir] ===
+                    // Going towards min to end:
+                    waypoint[dir] >= endPoint[dir]) {
+                    dir = dir === 'y' ? 'x' : 'y';
+                    useMax = start[dir] < end[dir];
+                    segments.push({
+                        start: waypoint,
+                        end: copyFromPoint(waypoint, dir, startObstacle, dir + (useMax ? 'Max' : 'Min'), useMax ? 1 : -1)
+                    });
+                    // Switch direction again
+                    dir = dir === 'y' ? 'x' : 'y';
+                }
+            }
+            // We are around the start obstacle. Go towards the end in one
+            // direction.
+            prevWaypoint = segments.length ?
+                segments[segments.length - 1].end :
+                start;
+            waypoint = copyFromPoint(prevWaypoint, dir, endPoint);
+            segments.push({
+                start: prevWaypoint,
+                end: waypoint
+            });
+            // Final run to end point in the other direction
+            dir = dir === 'y' ? 'x' : 'y';
+            waypoint2 = copyFromPoint(waypoint, dir, endPoint);
+            segments.push({
+                start: waypoint,
+                end: waypoint2
+            });
+            // Finally add the endSegment
+            segments.push(endSegment);
+            return {
+                path: pathFromSegments(segments),
+                obstacles: segments
+            };
+        }, {
+            requiresObstacles: true
+        });
+        /**
+         * Find a path from a starting coordinate to an ending coordinate, taking
+         * obstacles into consideration. Might not always find the optimal path,
+         * but is fast, and usually good enough.
+         *
+         * @function Highcharts.Pathfinder.algorithms.fastAvoid
+         *
+         * @param {Highcharts.PositionObject} start
+         *        Starting coordinate, object with x/y props.
+         *
+         * @param {Highcharts.PositionObject} end
+         *        Ending coordinate, object with x/y props.
+         *
+         * @param {object} options
+         *        Options for the algorithm.
+         *        - chartObstacles:  Array of chart obstacles to avoid
+         *        - lineObstacles:   Array of line obstacles to jump over
+         *        - obstacleMetrics: Object with metrics of chartObstacles cached
+         *        - hardBounds:      Hard boundaries to not cross
+         *        - obstacleOptions: Options for the obstacles, including margin
+         *        - startDirectionX: Optional. True if starting in the X direction.
+         *                           If not provided, the algorithm starts in the
+         *                           direction that is the furthest between
+         *                           start/end.
+         *
+         * @return {object}
+         *         An object with the SVG path in Array form as accepted by the SVG
+         *         renderer, as well as an array of new obstacles making up this
+         *         path.
+         */
+        var fastAvoid = extend(function (start,
+            end,
+            options) {
+                /*
+                    Algorithm rules/description
+                    - Find initial direction
+                    - Determine soft/hard max for each direction.
+                    - Move along initial direction until obstacle.
+                    - Change direction.
+                    - If hitting obstacle,
+            first try to change length of previous line
+                        before changing direction again.
+    
+                    Soft min/max x = start/destination x +/- widest obstacle + margin
+                    Soft min/max y = start/destination y +/- tallest obstacle + margin
+    
+                    @todo:
+                        - Make retrospective,
+            try changing prev segment to reduce
+                            corners
+                        - Fix logic for breaking out of end-points - not always picking
+                            the best direction currently
+                        - When going around the end obstacle we should not always go the
+                            shortest route,
+            rather pick the one closer to the end point
+                */
+                var dirIsX = pick(options.startDirectionX,
+            abs(end.x - start.x) > abs(end.y - start.y)),
+            dir = dirIsX ? 'x' : 'y',
+            segments,
+            useMax,
+            extractedEndPoint,
+            endSegments = [],
+            forceObstacleBreak = false, // Used in clearPathTo to keep track of
+                // when to force break through an obstacle.
+                // Boundaries to stay within. If beyond soft boundary, prefer to
+                // change direction ASAP. If at hard max, always change immediately.
+                metrics = options.obstacleMetrics,
+            softMinX = min(start.x,
+            end.x) - metrics.maxWidth - 10,
+            softMaxX = max(start.x,
+            end.x) + metrics.maxWidth + 10,
+            softMinY = min(start.y,
+            end.y) - metrics.maxHeight - 10,
+            softMaxY = max(start.y,
+            end.y) + metrics.maxHeight + 10, 
+                // Obstacles
+                chartObstacles = options.chartObstacles,
+            startObstacleIx = findLastObstacleBefore(chartObstacles,
+            softMinX),
+            endObstacleIx = findLastObstacleBefore(chartObstacles,
+            softMaxX);
+            // eslint-disable-next-line valid-jsdoc
+            /**
+             * How far can you go between two points before hitting an obstacle?
+             * Does not work for diagonal lines (because it doesn't have to).
+             * @private
+             */
+            function pivotPoint(fromPoint, toPoint, directionIsX) {
+                var firstPoint,
+                    lastPoint,
+                    highestPoint,
+                    lowestPoint,
+                    i,
+                    searchDirection = fromPoint.x < toPoint.x ? 1 : -1;
+                if (fromPoint.x < toPoint.x) {
+                    firstPoint = fromPoint;
+                    lastPoint = toPoint;
+                }
+                else {
+                    firstPoint = toPoint;
+                    lastPoint = fromPoint;
+                }
+                if (fromPoint.y < toPoint.y) {
+                    lowestPoint = fromPoint;
+                    highestPoint = toPoint;
+                }
+                else {
+                    lowestPoint = toPoint;
+                    highestPoint = fromPoint;
+                }
+                // Go through obstacle range in reverse if toPoint is before
+                // fromPoint in the X-dimension.
+                i = searchDirection < 0 ?
+                    // Searching backwards, start at last obstacle before last point
+                    min(findLastObstacleBefore(chartObstacles, lastPoint.x), chartObstacles.length - 1) :
+                    // Forwards. Since we're not sorted by xMax, we have to look
+                    // at all obstacles.
+                    0;
+                // Go through obstacles in this X range
+                while (chartObstacles[i] && (searchDirection > 0 && chartObstacles[i].xMin <= lastPoint.x ||
+                    searchDirection < 0 && chartObstacles[i].xMax >= firstPoint.x)) {
+                    // If this obstacle is between from and to points in a straight
+                    // line, pivot at the intersection.
+                    if (chartObstacles[i].xMin <= lastPoint.x &&
+                        chartObstacles[i].xMax >= firstPoint.x &&
+                        chartObstacles[i].yMin <= highestPoint.y &&
+                        chartObstacles[i].yMax >= lowestPoint.y) {
+                        if (directionIsX) {
+                            return {
+                                y: fromPoint.y,
+                                x: fromPoint.x < toPoint.x ?
+                                    chartObstacles[i].xMin - 1 :
+                                    chartObstacles[i].xMax + 1,
+                                obstacle: chartObstacles[i]
+                            };
+                        }
+                        // else ...
+                        return {
+                            x: fromPoint.x,
+                            y: fromPoint.y < toPoint.y ?
+                                chartObstacles[i].yMin - 1 :
+                                chartObstacles[i].yMax + 1,
+                            obstacle: chartObstacles[i]
+                        };
+                    }
+                    i += searchDirection;
+                }
+                return toPoint;
+            }
+            /**
+             * Decide in which direction to dodge or get out of an obstacle.
+             * Considers desired direction, which way is shortest, soft and hard
+             * bounds.
+             *
+             * (? Returns a string, either xMin, xMax, yMin or yMax.)
+             *
+             * @private
+             * @function
+             *
+             * @param {object} obstacle
+             *        Obstacle to dodge/escape.
+             *
+             * @param {object} fromPoint
+             *        Point with x/y props that's dodging/escaping.
+             *
+             * @param {object} toPoint
+             *        Goal point.
+             *
+             * @param {boolean} dirIsX
+             *        Dodge in X dimension.
+             *
+             * @param {object} bounds
+             *        Hard and soft boundaries.
+             *
+             * @return {boolean}
+             *         Use max or not.
+             */
+            function getDodgeDirection(obstacle, fromPoint, toPoint, dirIsX, bounds) {
+                var softBounds = bounds.soft, hardBounds = bounds.hard, dir = dirIsX ? 'x' : 'y', toPointMax = { x: fromPoint.x, y: fromPoint.y }, toPointMin = { x: fromPoint.x, y: fromPoint.y }, minPivot, maxPivot, maxOutOfSoftBounds = obstacle[dir + 'Max'] >=
+                        softBounds[dir + 'Max'], minOutOfSoftBounds = obstacle[dir + 'Min'] <=
+                        softBounds[dir + 'Min'], maxOutOfHardBounds = obstacle[dir + 'Max'] >=
+                        hardBounds[dir + 'Max'], minOutOfHardBounds = obstacle[dir + 'Min'] <=
+                        hardBounds[dir + 'Min'], 
+                    // Find out if we should prefer one direction over the other if
+                    // we can choose freely
+                    minDistance = abs(obstacle[dir + 'Min'] - fromPoint[dir]), maxDistance = abs(obstacle[dir + 'Max'] - fromPoint[dir]), 
+                    // If it's a small difference, pick the one leading towards dest
+                    // point. Otherwise pick the shortest distance
+                    useMax = abs(minDistance - maxDistance) < 10 ?
+                        fromPoint[dir] < toPoint[dir] :
+                        maxDistance < minDistance;
+                // Check if we hit any obstacles trying to go around in either
+                // direction.
+                toPointMin[dir] = obstacle[dir + 'Min'];
+                toPointMax[dir] = obstacle[dir + 'Max'];
+                minPivot = pivotPoint(fromPoint, toPointMin, dirIsX)[dir] !==
+                    toPointMin[dir];
+                maxPivot = pivotPoint(fromPoint, toPointMax, dirIsX)[dir] !==
+                    toPointMax[dir];
+                useMax = minPivot ?
+                    (maxPivot ? useMax : true) :
+                    (maxPivot ? false : useMax);
+                // useMax now contains our preferred choice, bounds not taken into
+                // account. If both or neither direction is out of bounds we want to
+                // use this.
+                // Deal with soft bounds
+                useMax = minOutOfSoftBounds ?
+                    (maxOutOfSoftBounds ? useMax : true) : // Out on min
+                    (maxOutOfSoftBounds ? false : useMax); // Not out on min
+                // Deal with hard bounds
+                useMax = minOutOfHardBounds ?
+                    (maxOutOfHardBounds ? useMax : true) : // Out on min
+                    (maxOutOfHardBounds ? false : useMax); // Not out on min
+                return useMax;
+            }
+            // eslint-disable-next-line valid-jsdoc
+            /**
+             * Find a clear path between point.
+             * @private
+             */
+            function clearPathTo(fromPoint, toPoint, dirIsX) {
+                // Don't waste time if we've hit goal
+                if (fromPoint.x === toPoint.x && fromPoint.y === toPoint.y) {
+                    return [];
+                }
+                var dir = dirIsX ? 'x' : 'y',
+                    pivot,
+                    segments,
+                    waypoint,
+                    waypointUseMax,
+                    envelopingObstacle,
+                    secondEnvelopingObstacle,
+                    envelopWaypoint,
+                    obstacleMargin = options.obstacleOptions.margin,
+                    bounds = {
+                        soft: {
+                            xMin: softMinX,
+                            xMax: softMaxX,
+                            yMin: softMinY,
+                            yMax: softMaxY
+                        },
+                        hard: options.hardBounds
+                    };
+                // If fromPoint is inside an obstacle we have a problem. Break out
+                // by just going to the outside of this obstacle. We prefer to go to
+                // the nearest edge in the chosen direction.
+                envelopingObstacle =
+                    findObstacleFromPoint(chartObstacles, fromPoint);
+                if (envelopingObstacle > -1) {
+                    envelopingObstacle = chartObstacles[envelopingObstacle];
+                    waypointUseMax = getDodgeDirection(envelopingObstacle, fromPoint, toPoint, dirIsX, bounds);
+                    // Cut obstacle to hard bounds to make sure we stay within
+                    limitObstacleToBounds(envelopingObstacle, options.hardBounds);
+                    envelopWaypoint = dirIsX ? {
+                        y: fromPoint.y,
+                        x: envelopingObstacle[waypointUseMax ? 'xMax' : 'xMin'] +
+                            (waypointUseMax ? 1 : -1)
+                    } : {
+                        x: fromPoint.x,
+                        y: envelopingObstacle[waypointUseMax ? 'yMax' : 'yMin'] +
+                            (waypointUseMax ? 1 : -1)
+                    };
+                    // If we crashed into another obstacle doing this, we put the
+                    // waypoint between them instead
+                    secondEnvelopingObstacle = findObstacleFromPoint(chartObstacles, envelopWaypoint);
+                    if (secondEnvelopingObstacle > -1) {
+                        secondEnvelopingObstacle = chartObstacles[secondEnvelopingObstacle];
+                        // Cut obstacle to hard bounds
+                        limitObstacleToBounds(secondEnvelopingObstacle, options.hardBounds);
+                        // Modify waypoint to lay between obstacles
+                        envelopWaypoint[dir] = waypointUseMax ? max(envelopingObstacle[dir + 'Max'] - obstacleMargin + 1, (secondEnvelopingObstacle[dir + 'Min'] +
+                            envelopingObstacle[dir + 'Max']) / 2) :
+                            min((envelopingObstacle[dir + 'Min'] + obstacleMargin - 1), ((secondEnvelopingObstacle[dir + 'Max'] +
+                                envelopingObstacle[dir + 'Min']) / 2));
+                        // We are not going anywhere. If this happens for the first
+                        // time, do nothing. Otherwise, try to go to the extreme of
+                        // the obstacle pair in the current direction.
+                        if (fromPoint.x === envelopWaypoint.x &&
+                            fromPoint.y === envelopWaypoint.y) {
+                            if (forceObstacleBreak) {
+                                envelopWaypoint[dir] = waypointUseMax ?
+                                    max(envelopingObstacle[dir + 'Max'], secondEnvelopingObstacle[dir + 'Max']) + 1 :
+                                    min(envelopingObstacle[dir + 'Min'], secondEnvelopingObstacle[dir + 'Min']) - 1;
+                            }
+                            // Toggle on if off, and the opposite
+                            forceObstacleBreak = !forceObstacleBreak;
+                        }
+                        else {
+                            // This point is not identical to previous.
+                            // Clear break trigger.
+                            forceObstacleBreak = false;
+                        }
+                    }
+                    segments = [{
+                            start: fromPoint,
+                            end: envelopWaypoint
+                        }];
+                }
+                else { // If not enveloping, use standard pivot calculation
+                    pivot = pivotPoint(fromPoint, {
+                        x: dirIsX ? toPoint.x : fromPoint.x,
+                        y: dirIsX ? fromPoint.y : toPoint.y
+                    }, dirIsX);
+                    segments = [{
+                            start: fromPoint,
+                            end: {
+                                x: pivot.x,
+                                y: pivot.y
+                            }
+                        }];
+                    // Pivot before goal, use a waypoint to dodge obstacle
+                    if (pivot[dirIsX ? 'x' : 'y'] !== toPoint[dirIsX ? 'x' : 'y']) {
+                        // Find direction of waypoint
+                        waypointUseMax = getDodgeDirection(pivot.obstacle, pivot, toPoint, !dirIsX, bounds);
+                        // Cut waypoint to hard bounds
+                        limitObstacleToBounds(pivot.obstacle, options.hardBounds);
+                        waypoint = {
+                            x: dirIsX ?
+                                pivot.x :
+                                pivot.obstacle[waypointUseMax ? 'xMax' : 'xMin'] +
+                                    (waypointUseMax ? 1 : -1),
+                            y: dirIsX ?
+                                pivot.obstacle[waypointUseMax ? 'yMax' : 'yMin'] +
+                                    (waypointUseMax ? 1 : -1) :
+                                pivot.y
+                        };
+                        // We're changing direction here, store that to make sure we
+                        // also change direction when adding the last segment array
+                        // after handling waypoint.
+                        dirIsX = !dirIsX;
+                        segments = segments.concat(clearPathTo({
+                            x: pivot.x,
+                            y: pivot.y
+                        }, waypoint, dirIsX));
+                    }
+                }
+                // Get segments for the other direction too
+                // Recursion is our friend
+                segments = segments.concat(clearPathTo(segments[segments.length - 1].end, toPoint, !dirIsX));
+                return segments;
+            }
+            // eslint-disable-next-line valid-jsdoc
+            /**
+             * Extract point to outside of obstacle in whichever direction is
+             * closest. Returns new point outside obstacle.
+             * @private
+             */
+            function extractFromObstacle(obstacle, point, goalPoint) {
+                var dirIsX = min(obstacle.xMax - point.x,
+                    point.x - obstacle.xMin) <
+                        min(obstacle.yMax - point.y,
+                    point.y - obstacle.yMin),
+                    bounds = {
+                        soft: options.hardBounds,
+                        hard: options.hardBounds
+                    },
+                    useMax = getDodgeDirection(obstacle,
+                    point,
+                    goalPoint,
+                    dirIsX,
+                    bounds);
+                return dirIsX ? {
+                    y: point.y,
+                    x: obstacle[useMax ? 'xMax' : 'xMin'] + (useMax ? 1 : -1)
+                } : {
+                    x: point.x,
+                    y: obstacle[useMax ? 'yMax' : 'yMin'] + (useMax ? 1 : -1)
+                };
+            }
+            // Cut the obstacle array to soft bounds for optimization in large
+            // datasets.
+            chartObstacles =
+                chartObstacles.slice(startObstacleIx, endObstacleIx + 1);
+            // If an obstacle envelops the end point, move it out of there and add
+            // a little segment to where it was.
+            if ((endObstacleIx = findObstacleFromPoint(chartObstacles, end)) > -1) {
+                extractedEndPoint = extractFromObstacle(chartObstacles[endObstacleIx], end, start);
+                endSegments.push({
+                    end: end,
+                    start: extractedEndPoint
+                });
+                end = extractedEndPoint;
+            }
+            // If it's still inside one or more obstacles, get out of there by
+            // force-moving towards the start point.
+            while ((endObstacleIx = findObstacleFromPoint(chartObstacles, end)) > -1) {
+                useMax = end[dir] - start[dir] < 0;
+                extractedEndPoint = {
+                    x: end.x,
+                    y: end.y
+                };
+                extractedEndPoint[dir] = chartObstacles[endObstacleIx][useMax ? dir + 'Max' : dir + 'Min'] + (useMax ? 1 : -1);
+                endSegments.push({
+                    end: end,
+                    start: extractedEndPoint
+                });
+                end = extractedEndPoint;
+            }
+            // Find the path
+            segments = clearPathTo(start, end, dirIsX);
+            // Add the end-point segments
+            segments = segments.concat(endSegments.reverse());
+            return {
+                path: pathFromSegments(segments),
+                obstacles: segments
+            };
+        }, {
+            requiresObstacles: true
+        });
+        // Define the available pathfinding algorithms.
+        // Algorithms take up to 3 arguments: starting point, ending point, and an
+        // options object.
+        var algorithms = {
+                fastAvoid: fastAvoid,
+                straight: straight,
+                simpleConnect: simpleConnect
+            };
+
+        return algorithms;
+    });
+    _registerModule(_modules, 'Gantt/Pathfinder.js', [_modules['Gantt/Connection.js'], _modules['Core/Chart/Chart.js'], _modules['Core/Globals.js'], _modules['Core/Options.js'], _modules['Core/Series/Point.js'], _modules['Core/Utilities.js'], _modules['Gantt/PathfinderAlgorithms.js']], function (Connection, Chart, H, O, Point, U, pathfinderAlgorithms) {
+        /* *
+         *
+         *  (c) 2016 Highsoft AS
+         *  Authors: Øystein Moseng, Lars A. V. Cabrera
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        /**
+         * The default pathfinder algorithm to use for a chart. It is possible to define
+         * your own algorithms by adding them to the
+         * `Highcharts.Pathfinder.prototype.algorithms`
+         * object before the chart has been created.
+         *
+         * The default algorithms are as follows:
+         *
+         * `straight`:      Draws a straight line between the connecting
+         *                  points. Does not avoid other points when drawing.
+         *
+         * `simpleConnect`: Finds a path between the points using right angles
+         *                  only. Takes only starting/ending points into
+         *                  account, and will not avoid other points.
+         *
+         * `fastAvoid`:     Finds a path between the points using right angles
+         *                  only. Will attempt to avoid other points, but its
+         *                  focus is performance over accuracy. Works well with
+         *                  less dense datasets.
+         *
+         * @typedef {"fastAvoid"|"simpleConnect"|"straight"|string} Highcharts.PathfinderTypeValue
+         */
+        ''; // detach doclets above
+        var defaultOptions = O.defaultOptions;
+        var addEvent = U.addEvent,
+            defined = U.defined,
+            error = U.error,
+            extend = U.extend,
+            merge = U.merge,
+            objectEach = U.objectEach,
+            pick = U.pick,
+            splat = U.splat;
+        var deg2rad = H.deg2rad,
+            max = Math.max,
+            min = Math.min;
+        /*
+         @todo:
+             - Document how to write your own algorithms
+             - Consider adding a Point.pathTo method that wraps creating a connection
+               and rendering it
+        */
+        // Set default Pathfinder options
+        extend(defaultOptions, {
+            /**
+             * The Pathfinder module allows you to define connections between any two
+             * points, represented as lines - optionally with markers for the start
+             * and/or end points. Multiple algorithms are available for calculating how
+             * the connecting lines are drawn.
+             *
+             * Connector functionality requires Highcharts Gantt to be loaded. In Gantt
+             * charts, the connectors are used to draw dependencies between tasks.
+             *
+             * @see [dependency](series.gantt.data.dependency)
+             *
+             * @sample gantt/pathfinder/demo
+             *         Pathfinder connections
+             *
+             * @declare      Highcharts.ConnectorsOptions
+             * @product      gantt
+             * @optionparent connectors
+             */
+            connectors: {
+                /**
+                 * Enable connectors for this chart. Requires Highcharts Gantt.
+                 *
+                 * @type      {boolean}
+                 * @default   true
+                 * @since     6.2.0
+                 * @apioption connectors.enabled
+                 */
+                /**
+                 * Set the default dash style for this chart's connecting lines.
+                 *
+                 * @type      {string}
+                 * @default   solid
+                 * @since     6.2.0
+                 * @apioption connectors.dashStyle
+                 */
+                /**
+                 * Set the default color for this chart's Pathfinder connecting lines.
+                 * Defaults to the color of the point being connected.
+                 *
+                 * @type      {Highcharts.ColorString}
+                 * @since     6.2.0
+                 * @apioption connectors.lineColor
+                 */
+                /**
+                 * Set the default pathfinder margin to use, in pixels. Some Pathfinder
+                 * algorithms attempt to avoid obstacles, such as other points in the
+                 * chart. These algorithms use this margin to determine how close lines
+                 * can be to an obstacle. The default is to compute this automatically
+                 * from the size of the obstacles in the chart.
+                 *
+                 * To draw connecting lines close to existing points, set this to a low
+                 * number. For more space around existing points, set this number
+                 * higher.
+                 *
+                 * @sample gantt/pathfinder/algorithm-margin
+                 *         Small algorithmMargin
+                 *
+                 * @type      {number}
+                 * @since     6.2.0
+                 * @apioption connectors.algorithmMargin
+                 */
+                /**
+                 * Set the default pathfinder algorithm to use for this chart. It is
+                 * possible to define your own algorithms by adding them to the
+                 * Highcharts.Pathfinder.prototype.algorithms object before the chart
+                 * has been created.
+                 *
+                 * The default algorithms are as follows:
+                 *
+                 * `straight`:      Draws a straight line between the connecting
+                 *                  points. Does not avoid other points when drawing.
+                 *
+                 * `simpleConnect`: Finds a path between the points using right angles
+                 *                  only. Takes only starting/ending points into
+                 *                  account, and will not avoid other points.
+                 *
+                 * `fastAvoid`:     Finds a path between the points using right angles
+                 *                  only. Will attempt to avoid other points, but its
+                 *                  focus is performance over accuracy. Works well with
+                 *                  less dense datasets.
+                 *
+                 * Default value: `straight` is used as default for most series types,
+                 * while `simpleConnect` is used as default for Gantt series, to show
+                 * dependencies between points.
+                 *
+                 * @sample gantt/pathfinder/demo
+                 *         Different types used
+                 *
+                 * @type    {Highcharts.PathfinderTypeValue}
+                 * @default undefined
+                 * @since   6.2.0
+                 */
+                type: 'straight',
+                /**
+                 * Set the default pixel width for this chart's Pathfinder connecting
+                 * lines.
+                 *
+                 * @since 6.2.0
+                 */
+                lineWidth: 1,
+                /**
+                 * Marker options for this chart's Pathfinder connectors. Note that
+                 * this option is overridden by the `startMarker` and `endMarker`
+                 * options.
+                 *
+                 * @declare Highcharts.ConnectorsMarkerOptions
+                 * @since   6.2.0
+                 */
+                marker: {
+                    /**
+                     * Set the radius of the connector markers. The default is
+                     * automatically computed based on the algorithmMargin setting.
+                     *
+                     * Setting marker.width and marker.height will override this
+                     * setting.
+                     *
+                     * @type      {number}
+                     * @since     6.2.0
+                     * @apioption connectors.marker.radius
+                     */
+                    /**
+                     * Set the width of the connector markers. If not supplied, this
+                     * is inferred from the marker radius.
+                     *
+                     * @type      {number}
+                     * @since     6.2.0
+                     * @apioption connectors.marker.width
+                     */
+                    /**
+                     * Set the height of the connector markers. If not supplied, this
+                     * is inferred from the marker radius.
+                     *
+                     * @type      {number}
+                     * @since     6.2.0
+                     * @apioption connectors.marker.height
+                     */
+                    /**
+                     * Set the color of the connector markers. By default this is the
+                     * same as the connector color.
+                     *
+                     * @type      {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
+                     * @since     6.2.0
+                     * @apioption connectors.marker.color
+                     */
+                    /**
+                     * Set the line/border color of the connector markers. By default
+                     * this is the same as the marker color.
+                     *
+                     * @type      {Highcharts.ColorString}
+                     * @since     6.2.0
+                     * @apioption connectors.marker.lineColor
+                     */
+                    /**
+                     * Enable markers for the connectors.
+                     */
+                    enabled: false,
+                    /**
+                     * Horizontal alignment of the markers relative to the points.
+                     *
+                     * @type {Highcharts.AlignValue}
+                     */
+                    align: 'center',
+                    /**
+                     * Vertical alignment of the markers relative to the points.
+                     *
+                     * @type {Highcharts.VerticalAlignValue}
+                     */
+                    verticalAlign: 'middle',
+                    /**
+                     * Whether or not to draw the markers inside the points.
+                     */
+                    inside: false,
+                    /**
+                     * Set the line/border width of the pathfinder markers.
+                     */
+                    lineWidth: 1
+                },
+                /**
+                 * Marker options specific to the start markers for this chart's
+                 * Pathfinder connectors. Overrides the generic marker options.
+                 *
+                 * @declare Highcharts.ConnectorsStartMarkerOptions
+                 * @extends connectors.marker
+                 * @since   6.2.0
+                 */
+                startMarker: {
+                    /**
+                     * Set the symbol of the connector start markers.
+                     */
+                    symbol: 'diamond'
+                },
+                /**
+                 * Marker options specific to the end markers for this chart's
+                 * Pathfinder connectors. Overrides the generic marker options.
+                 *
+                 * @declare Highcharts.ConnectorsEndMarkerOptions
+                 * @extends connectors.marker
+                 * @since   6.2.0
+                 */
+                endMarker: {
+                    /**
+                     * Set the symbol of the connector end markers.
+                     */
+                    symbol: 'arrow-filled'
+                }
+            }
+        });
+        /**
+         * Override Pathfinder connector options for a series. Requires Highcharts Gantt
+         * to be loaded.
+         *
+         * @declare   Highcharts.SeriesConnectorsOptionsObject
+         * @extends   connectors
+         * @since     6.2.0
+         * @excluding enabled, algorithmMargin
+         * @product   gantt
+         * @apioption plotOptions.series.connectors
+         */
+        /**
+         * Connect to a point. This option can be either a string, referring to the ID
+         * of another point, or an object, or an array of either. If the option is an
+         * array, each element defines a connection.
+         *
+         * @sample gantt/pathfinder/demo
+         *         Different connection types
+         *
+         * @declare   Highcharts.XrangePointConnectorsOptionsObject
+         * @type      {string|Array<string|*>|*}
+         * @extends   plotOptions.series.connectors
+         * @since     6.2.0
+         * @excluding enabled
+         * @product   gantt
+         * @requires  highcharts-gantt
+         * @apioption series.xrange.data.connect
+         */
+        /**
+         * The ID of the point to connect to.
+         *
+         * @type      {string}
+         * @since     6.2.0
+         * @product   gantt
+         * @apioption series.xrange.data.connect.to
+         */
+        /**
+         * Get point bounding box using plotX/plotY and shapeArgs. If using
+         * graphic.getBBox() directly, the bbox will be affected by animation.
+         *
+         * @private
+         * @function
+         *
+         * @param {Highcharts.Point} point
+         *        The point to get BB of.
+         *
+         * @return {Highcharts.Dictionary<number>|null}
+         *         Result xMax, xMin, yMax, yMin.
+         */
+        function getPointBB(point) {
+            var shapeArgs = point.shapeArgs,
+                bb;
+            // Prefer using shapeArgs (columns)
+            if (shapeArgs) {
+                return {
+                    xMin: shapeArgs.x,
+                    xMax: shapeArgs.x + shapeArgs.width,
+                    yMin: shapeArgs.y,
+                    yMax: shapeArgs.y + shapeArgs.height
+                };
+            }
+            // Otherwise use plotX/plotY and bb
+            bb = point.graphic && point.graphic.getBBox();
+            return bb ? {
+                xMin: point.plotX - bb.width / 2,
+                xMax: point.plotX + bb.width / 2,
+                yMin: point.plotY - bb.height / 2,
+                yMax: point.plotY + bb.height / 2
+            } : null;
+        }
+        /**
+         * Calculate margin to place around obstacles for the pathfinder in pixels.
+         * Returns a minimum of 1 pixel margin.
+         *
+         * @private
+         * @function
+         *
+         * @param {Array<object>} obstacles
+         *        Obstacles to calculate margin from.
+         *
+         * @return {number}
+         *         The calculated margin in pixels. At least 1.
+         */
+        function calculateObstacleMargin(obstacles) {
+            var len = obstacles.length,
+                i = 0,
+                j,
+                obstacleDistance,
+                distances = [], 
+                // Compute smallest distance between two rectangles
+                distance = function (a,
+                b,
+                bbMargin) {
+                    // Count the distance even if we are slightly off
+                    var margin = pick(bbMargin, 10),
+                yOverlap = a.yMax + margin > b.yMin - margin &&
+                        a.yMin - margin < b.yMax + margin,
+                xOverlap = a.xMax + margin > b.xMin - margin &&
+                        a.xMin - margin < b.xMax + margin,
+                xDistance = yOverlap ? (a.xMin > b.xMax ? a.xMin - b.xMax : b.xMin - a.xMax) : Infinity,
+                yDistance = xOverlap ? (a.yMin > b.yMax ? a.yMin - b.yMax : b.yMin - a.yMax) : Infinity;
+                // If the rectangles collide, try recomputing with smaller margin.
+                // If they collide anyway, discard the obstacle.
+                if (xOverlap && yOverlap) {
+                    return (margin ?
+                        distance(a, b, Math.floor(margin / 2)) :
+                        Infinity);
+                }
+                return min(xDistance, yDistance);
+            };
+            // Go over all obstacles and compare them to the others.
+            for (; i < len; ++i) {
+                // Compare to all obstacles ahead. We will already have compared this
+                // obstacle to the ones before.
+                for (j = i + 1; j < len; ++j) {
+                    obstacleDistance = distance(obstacles[i], obstacles[j]);
+                    // TODO: Magic number 80
+                    if (obstacleDistance < 80) { // Ignore large distances
+                        distances.push(obstacleDistance);
                     }
                 }
-                attribs['class'] = // eslint-disable-line dot-notation
-                    'highcharts-point-connecting-path ' +
-                        'highcharts-color-' + fromPoint.colorIndex;
-                options = merge(attribs, options);
-                // Set common marker options
-                if (!defined(options.marker.radius)) {
-                    options.marker.radius = min(max(Math.ceil((options.algorithmMargin || 8) / 2) - 1, 1), 5);
-                }
-                // Get the path
-                pathResult = connection.getPath(options);
-                path = pathResult.path;
-                // Always update obstacle storage with obstacles from this path.
-                // We don't know if future calls will need this for their algorithm.
-                if (pathResult.obstacles) {
-                    pathfinder.lineObstacles =
-                        pathfinder.lineObstacles || [];
-                    pathfinder.lineObstacles =
-                        pathfinder.lineObstacles.concat(pathResult.obstacles);
-                }
-                // Add the calculated path to the pathfinder group
-                connection.renderPath(path, attribs, series.options.animation);
-                // Render the markers
-                connection.addMarker('start', merge(options.marker, options.startMarker), path);
-                connection.addMarker('end', merge(options.marker, options.endMarker), path);
-            },
-            /**
-             * Destroy connection by destroying the added graphics elements.
-             *
-             * @function Highcharts.Connection#destroy
-             */
-            destroy: function () {
-                if (this.graphics) {
-                    objectEach(this.graphics, function (val) {
-                        val.destroy();
-                    });
-                    delete this.graphics;
-                }
             }
-        };
+            // Ensure we always have at least one value, even in very spaceous charts
+            distances.push(80);
+            return max(Math.floor(distances.sort(function (a, b) {
+                return (a - b);
+            })[
+            // Discard first 10% of the relevant distances, and then grab
+            // the smallest one.
+            Math.floor(distances.length / 10)] / 2 - 1 // Divide the distance by 2 and subtract 1.
+            ), 1 // 1 is the minimum margin
+            );
+        }
+        /* eslint-disable no-invalid-this, valid-jsdoc */
         /**
          * The Pathfinder class.
          *
@@ -4775,15 +5535,25 @@
          * @param {Highcharts.Chart} chart
          *        The chart to operate on.
          */
-        function Pathfinder(chart) {
-            this.init(chart);
-        }
-        Pathfinder.prototype = {
+        var Pathfinder = /** @class */ (function () {
+                function Pathfinder(chart) {
+                    /* *
+                     *
+                     * Properties
+                     *
+                     * */
+                    this.chart = void 0;
+                this.chartObstacles = void 0;
+                this.chartObstacleMetrics = void 0;
+                this.connections = void 0;
+                this.group = void 0;
+                this.lineObstacles = void 0;
+                this.init(chart);
+            }
             /**
              * @name Highcharts.Pathfinder#algorithms
              * @type {Highcharts.Dictionary<Function>}
              */
-            algorithms: pathfinderAlgorithms,
             /**
              * Initialize the Pathfinder object.
              *
@@ -4792,7 +5562,7 @@
              * @param {Highcharts.Chart} chart
              *        The chart context.
              */
-            init: function (chart) {
+            Pathfinder.prototype.init = function (chart) {
                 // Initialize pathfinder with chart context
                 this.chart = chart;
                 // Init connection reference list
@@ -4801,7 +5571,7 @@
                 addEvent(chart, 'redraw', function () {
                     this.pathfinder.update();
                 });
-            },
+            };
             /**
              * Update Pathfinder connections from scratch.
              *
@@ -4811,7 +5581,7 @@
              *        Whether or not to defer rendering of connections until
              *        series.afterAnimate event has fired. Used on first render.
              */
-            update: function (deferRender) {
+            Pathfinder.prototype.update = function (deferRender) {
                 var chart = this.chart,
                     pathfinder = this,
                     oldConnections = pathfinder.connections;
@@ -4820,6 +5590,12 @@
                 chart.series.forEach(function (series) {
                     if (series.visible && !series.options.isInternal) {
                         series.points.forEach(function (point) {
+                            var ganttPointOptions = point.options;
+                            // For Gantt series the connect could be
+                            // defined as a dependency
+                            if (ganttPointOptions && ganttPointOptions.dependency) {
+                                ganttPointOptions.connect = ganttPointOptions.dependency;
+                            }
                             var to,
                                 connects = (point.options &&
                                     point.options.connect &&
@@ -4869,7 +5645,7 @@
                 delete this.lineObstacles;
                 // Draw the pending connections
                 pathfinder.renderConnections(deferRender);
-            },
+            };
             /**
              * Draw the chart's connecting paths.
              *
@@ -4879,7 +5655,7 @@
              *        Whether or not to defer render until series animation is finished.
              *        Used on first render.
              */
-            renderConnections: function (deferRender) {
+            Pathfinder.prototype.renderConnections = function (deferRender) {
                 if (deferRender) {
                     // Render after series are done animating
                     this.chart.series.forEach(function (series) {
@@ -4913,7 +5689,7 @@
                         connection.render();
                     });
                 }
-            },
+            };
             /**
              * Get obstacles for the points in the chart. Does not include connecting
              * lines from Pathfinder. Applies algorithmMargin to the obstacles.
@@ -4928,7 +5704,7 @@
              *         An array of calculated obstacles. Each obstacle is defined as an
              *         object with xMin, xMax, yMin and yMax properties.
              */
-            getChartObstacles: function (options) {
+            Pathfinder.prototype.getChartObstacles = function (options) {
                 var obstacles = [],
                     series = this.chart.series,
                     margin = pick(options.algorithmMargin, 0),
@@ -4968,7 +5744,7 @@
                     });
                 }
                 return obstacles;
-            },
+            };
             /**
              * Utility function to get metrics for obstacles:
              * - Widest obstacle width
@@ -4983,7 +5759,7 @@
              *         The calculated metrics, as an object with maxHeight and maxWidth
              *         properties.
              */
-            getObstacleMetrics: function (obstacles) {
+            Pathfinder.prototype.getObstacleMetrics = function (obstacles) {
                 var maxWidth = 0,
                     maxHeight = 0,
                     width,
@@ -5003,7 +5779,7 @@
                     maxHeight: maxHeight,
                     maxWidth: maxWidth
                 };
-            },
+            };
             /**
              * Utility to get which direction to start the pathfinding algorithm
              * (X vs Y), calculated from a set of marker options.
@@ -5016,17 +5792,18 @@
              * @return {boolean}
              *         Returns true for X, false for Y, and undefined for autocalculate.
              */
-            getAlgorithmStartDirection: function (markerOptions) {
+            Pathfinder.prototype.getAlgorithmStartDirection = function (markerOptions) {
                 var xCenter = markerOptions.align !== 'left' &&
                         markerOptions.align !== 'right', yCenter = markerOptions.verticalAlign !== 'top' &&
                         markerOptions.verticalAlign !== 'bottom', undef;
                 return xCenter ?
                     (yCenter ? undef : false) : // x is centered
                     (yCenter ? true : undef); // x is off-center
-            }
-        };
+            };
+            return Pathfinder;
+        }());
+        Pathfinder.prototype.algorithms = pathfinderAlgorithms;
         // Add to Highcharts namespace
-        H.Connection = Connection;
         H.Pathfinder = Pathfinder;
         // Add pathfinding capabilities to Points
         extend(Point.prototype, /** @lends Point.prototype */ {
@@ -5201,7 +5978,7 @@
             }
         }
         // Initialize Pathfinder for charts
-        H.Chart.prototype.callbacks.push(function (chart) {
+        Chart.prototype.callbacks.push(function (chart) {
             var options = chart.options;
             if (options.connectors.enabled !== false) {
                 warnLegacy(chart);
@@ -5210,8 +5987,9 @@
             }
         });
 
+        return Pathfinder;
     });
-    _registerModule(_modules, 'modules/xrange.src.js', [_modules['parts/Globals.js'], _modules['parts/Color.js'], _modules['parts/Point.js'], _modules['parts/Utilities.js']], function (H, Color, Point, U) {
+    _registerModule(_modules, 'Series/XRangeSeries.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Series/Series.js'], _modules['Core/Globals.js'], _modules['Core/Color/Color.js'], _modules['Core/Series/Point.js'], _modules['Core/Utilities.js']], function (Axis, BaseSeries, H, Color, Point, U) {
         /* *
          *
          *  X-range series module
@@ -5223,14 +6001,6 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        /* *
-         * @interface Highcharts.PointOptionsObject in parts/Point.ts
-         */ /**
-        * The ending X value of the range point.
-        * @name Highcharts.PointOptionsObject#x2
-        * @type {number|undefined}
-        * @requires modules/xrange
-        */
         var color = Color.parse;
         var addEvent = U.addEvent,
             clamp = U.clamp,
@@ -5240,12 +6010,18 @@
             isNumber = U.isNumber,
             isObject = U.isObject,
             merge = U.merge,
-            pick = U.pick,
-            seriesType = U.seriesType;
-        var columnType = H.seriesTypes.column,
-            seriesTypes = H.seriesTypes,
-            Axis = H.Axis,
-            Series = H.Series;
+            pick = U.pick;
+        /* *
+         * @interface Highcharts.PointOptionsObject in parts/Point.ts
+         */ /**
+        * The ending X value of the range point.
+        * @name Highcharts.PointOptionsObject#x2
+        * @type {number|undefined}
+        * @requires modules/xrange
+        */
+        var Series = H.Series,
+            seriesTypes = BaseSeries.seriesTypes,
+            columnType = seriesTypes.column;
         /**
          * Return color of a point based on its category.
          *
@@ -5280,7 +6056,7 @@
          *
          * @augments Highcharts.Series
          */
-        seriesType('xrange', 'column'
+        BaseSeries.seriesType('xrange', 'column'
         /**
          * The X-range series displays ranges on the X axis, typically time
          * intervals with a start and end date.
@@ -5299,7 +6075,7 @@
          *               edgeWidth, findNearestPointBy, getExtremesFromAll,
          *               negativeColor, pointInterval, pointIntervalUnit,
          *               pointPlacement, pointRange, pointStart, softThreshold,
-         *               stacking, threshold, data, dataSorting
+         *               stacking, threshold, data, dataSorting, boostBlending
          * @requires     modules/xrange
          * @optionparent plotOptions.xrange
          */
@@ -5679,7 +6455,7 @@
                                 pfOptions = {};
                             }
                             if (isObject(seriesOpts.partialFill)) {
-                                pfOptions = merge(pfOptions, seriesOpts.partialFill);
+                                pfOptions = merge(seriesOpts.partialFill, pfOptions);
                             }
                             fill = (pfOptions.fill ||
                                 color(pointAttr.fill).brighten(-0.3).get() ||
@@ -5856,7 +6632,8 @@
          * @excluding boostThreshold, crisp, cropThreshold, depth, edgeColor, edgeWidth,
          *            findNearestPointBy, getExtremesFromAll, negativeColor,
          *            pointInterval, pointIntervalUnit, pointPlacement, pointRange,
-         *            pointStart, softThreshold, stacking, threshold, dataSorting
+         *            pointStart, softThreshold, stacking, threshold, dataSorting,
+         *            boostBlending
          * @product   highcharts highstock gantt
          * @requires  modules/xrange
          * @apioption series.xrange
@@ -5953,7 +6730,7 @@
         ''; // adds doclets above to transpiled file
 
     });
-    _registerModule(_modules, 'parts-gantt/GanttSeries.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Series/GanttSeries.js', [_modules['Core/Series/Series.js'], _modules['Core/Globals.js'], _modules['Core/Options.js'], _modules['Core/Utilities.js']], function (BaseSeries, H, O, U) {
         /* *
          *
          *  (c) 2016-2020 Highsoft AS
@@ -5965,14 +6742,13 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
+        var dateFormat = O.dateFormat;
         var isNumber = U.isNumber,
             merge = U.merge,
             pick = U.pick,
-            seriesType = U.seriesType,
             splat = U.splat;
-        var dateFormat = H.dateFormat,
-            seriesTypes = H.seriesTypes,
-            Series = H.Series,
+        var Series = H.Series,
+            seriesTypes = BaseSeries.seriesTypes,
             parent = seriesTypes.xrange;
         /**
          * @private
@@ -5981,7 +6757,7 @@
          *
          * @augments Highcharts.Series
          */
-        seriesType('gantt', 'xrange'
+        BaseSeries.seriesType('gantt', 'xrange'
         /**
          * A `gantt` series. If the [type](#series.gantt.type) option is not specified,
          * it is inherited from [chart.type](#chart.type).
@@ -6019,8 +6795,8 @@
                     if (!format) {
                         format = splat(tooltip.getDateFormat(xAxis.closestPointRange, point.start, startOfWeek, formats))[0];
                     }
-                    start = dateFormat(format, point.start);
-                    end = dateFormat(format, point.end);
+                    start = series.chart.time.dateFormat(format, point.start);
+                    end = series.chart.time.dateFormat(format, point.end);
                     retVal += '<br/>';
                     if (!milestone) {
                         retVal += 'Start: ' + start + '<br/>';
@@ -6151,7 +6927,6 @@
                 addIfExists('x', pick(options.start, options.x));
                 addIfExists('x2', pick(options.end, options.x2));
                 addIfExists('partialFill', pick(options.completed, options.partialFill));
-                addIfExists('connect', pick(options.dependency, options.connect));
             }
             /* eslint-enable valid-jsdoc */
         }, merge(parent.prototype.pointClass.prototype, {
@@ -6175,11 +6950,11 @@
              */
             applyOptions: function (options, x) {
                 var point = this,
-                    retVal = merge(options);
-                H.seriesTypes.gantt.prototype.setGanttPointAliases(retVal);
-                retVal = parent.prototype.pointClass.prototype.applyOptions
-                    .call(point, retVal, x);
-                return retVal;
+                    ganttPoint;
+                ganttPoint = parent.prototype.pointClass.prototype.applyOptions
+                    .call(point, options, x);
+                H.seriesTypes.gantt.prototype.setGanttPointAliases(ganttPoint);
+                return ganttPoint;
             },
             isValid: function () {
                 return ((typeof this.start === 'number' ||
@@ -6207,7 +6982,7 @@
          * @declare   Highcharts.GanttPointOptionsObject
          * @type      {Array<*>}
          * @extends   series.xrange.data
-         * @excluding className, color, colorIndex, connect, dataLabels, events, id,
+         * @excluding className, color, colorIndex, connect, dataLabels, events,
          *            partialFill, selected, x, x2
          * @product   gantt
          * @apioption series.gantt.data
@@ -6327,7 +7102,7 @@
         ''; // adds doclets above to the transpiled file
 
     });
-    _registerModule(_modules, 'parts-gantt/GanttChart.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Core/Chart/GanttChart.js', [_modules['Core/Chart/Chart.js'], _modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (Chart, H, U) {
         /* *
          *
          *  (c) 2016-2020 Highsoft AS
@@ -6339,10 +7114,10 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        var isArray = U.isArray,
+        var getOptions = U.getOptions,
+            isArray = U.isArray,
             merge = U.merge,
             splat = U.splat;
-        var Chart = H.Chart;
         /**
          * Factory function for Gantt charts.
          *
@@ -6377,7 +7152,7 @@
         H.ganttChart = function (renderTo, options, callback) {
             var hasRenderToArg = typeof renderTo === 'string' || renderTo.nodeName,
                 seriesOptions = options.series,
-                defaultOptions = H.getOptions(),
+                defaultOptions = getOptions(),
                 defaultLinkedTo,
                 userOptions = options;
             options = arguments[hasRenderToArg ? 1 : 0];
@@ -6427,6 +7202,13 @@
                 },
                 legend: {
                     enabled: false
+                },
+                navigator: {
+                    series: { type: 'gantt' },
+                    // Bars were clipped, #14060.
+                    yAxis: {
+                        type: 'category'
+                    }
                 }
             }, options, // user's options
             // forced options
@@ -6434,18 +7216,13 @@
                 isGantt: true
             });
             options.series = userOptions.series = seriesOptions;
-            options.series.forEach(function (series) {
-                series.data.forEach(function (point) {
-                    H.seriesTypes.gantt.prototype.setGanttPointAliases(point);
-                });
-            });
             return hasRenderToArg ?
                 new Chart(renderTo, options, callback) :
                 new Chart(options, options); // @todo does not look correct
         };
 
     });
-    _registerModule(_modules, 'parts/ScrollbarAxis.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Core/Axis/ScrollbarAxis.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (H, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -6630,7 +7407,7 @@
 
         return ScrollbarAxis;
     });
-    _registerModule(_modules, 'parts/Scrollbar.js', [_modules['parts/Axis.js'], _modules['parts/Globals.js'], _modules['parts/ScrollbarAxis.js'], _modules['parts/Utilities.js']], function (Axis, H, ScrollbarAxis, U) {
+    _registerModule(_modules, 'Core/Scrollbar.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Globals.js'], _modules['Core/Axis/ScrollbarAxis.js'], _modules['Core/Utilities.js'], _modules['Core/Options.js']], function (Axis, H, ScrollbarAxis, U, O) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -6648,8 +7425,8 @@
             merge = U.merge,
             pick = U.pick,
             removeEvent = U.removeEvent;
-        var defaultOptions = H.defaultOptions,
-            hasTouch = H.hasTouch,
+        var defaultOptions = O.defaultOptions;
+        var hasTouch = H.hasTouch,
             isTouchDevice = H.isTouchDevice;
         /**
          * When we have vertical scrollbar, rifles and arrow in buttons should be
@@ -7494,7 +8271,7 @@
 
         return H.Scrollbar;
     });
-    _registerModule(_modules, 'parts/RangeSelector.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Extensions/RangeSelector.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Chart/Chart.js'], _modules['Core/Globals.js'], _modules['Core/Options.js'], _modules['Core/Renderer/SVG/SVGElement.js'], _modules['Core/Utilities.js']], function (Axis, Chart, H, O, SVGElement, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -7504,6 +8281,21 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
+        var defaultOptions = O.defaultOptions;
+        var addEvent = U.addEvent,
+            createElement = U.createElement,
+            css = U.css,
+            defined = U.defined,
+            destroyObjectProperties = U.destroyObjectProperties,
+            discardElement = U.discardElement,
+            extend = U.extend,
+            fireEvent = U.fireEvent,
+            isNumber = U.isNumber,
+            merge = U.merge,
+            objectEach = U.objectEach,
+            pick = U.pick,
+            pInt = U.pInt,
+            splat = U.splat;
         /**
          * Define the time span for the button
          *
@@ -7532,23 +8324,6 @@
          * @return {number}
          *         Parsed JavaScript time value.
          */
-        var addEvent = U.addEvent,
-            createElement = U.createElement,
-            css = U.css,
-            defined = U.defined,
-            destroyObjectProperties = U.destroyObjectProperties,
-            discardElement = U.discardElement,
-            extend = U.extend,
-            fireEvent = U.fireEvent,
-            isNumber = U.isNumber,
-            merge = U.merge,
-            objectEach = U.objectEach,
-            pick = U.pick,
-            pInt = U.pInt,
-            splat = U.splat;
-        var Axis = H.Axis,
-            Chart = H.Chart,
-            defaultOptions = H.defaultOptions;
         /* ************************************************************************** *
          * Start Range Selector code                                                  *
          * ************************************************************************** */
@@ -7855,6 +8630,8 @@
                 /**
                  * A custom callback function to parse values entered in the input boxes
                  * and return a valid JavaScript time as milliseconds since 1970.
+                 * The first argument passed is a value to parse,
+                 * second is a boolean indicating use of the UTC time.
                  *
                  * @sample {highstock} stock/rangeselector/input-format/
                  *         Milliseconds in the range selector
@@ -8029,11 +8806,20 @@
          * @name Highcharts.RangeSelector
          * @param {Highcharts.Chart} chart
          */
-        function RangeSelector(chart) {
-            // Run RangeSelector
-            this.init(chart);
-        }
-        RangeSelector.prototype = {
+        var RangeSelector = /** @class */ (function () {
+                function RangeSelector(chart) {
+                    /* *
+                     *
+                     * Properties
+                     *
+                     * */
+                    this.buttons = void 0;
+                this.buttonOptions = RangeSelector.prototype.defaultButtons;
+                this.options = void 0;
+                this.chart = chart;
+                // Run RangeSelector
+                this.init(chart);
+            }
             /**
              * The method to run when one of the buttons in the range selectors is
              * clicked
@@ -8045,7 +8831,7 @@
              * @param {boolean} [redraw]
              * @return {void}
              */
-            clickButton: function (i, redraw) {
+            RangeSelector.prototype.clickButton = function (i, redraw) {
                 var rangeSelector = this,
                     chart = rangeSelector.chart,
                     rangeOptions = rangeSelector.buttonOptions[i],
@@ -8140,8 +8926,12 @@
                     newMin = dataMin;
                     newMax = dataMax;
                 }
-                newMin += rangeOptions._offsetMin;
-                newMax += rangeOptions._offsetMax;
+                if (defined(newMin)) {
+                    newMin += rangeOptions._offsetMin;
+                }
+                if (defined(newMax)) {
+                    newMax += rangeOptions._offsetMax;
+                }
                 rangeSelector.setSelected(i);
                 // Update the chart
                 if (!baseAxis) {
@@ -8165,7 +8955,7 @@
                         rangeSelectorButton: rangeOptions
                     });
                 }
-            },
+            };
             /**
              * Set the selected option. This method only sets the internal flag, it
              * doesn't update the buttons or the actual zoomed range.
@@ -8175,35 +8965,9 @@
              * @param {number} [selected]
              * @return {void}
              */
-            setSelected: function (selected) {
+            RangeSelector.prototype.setSelected = function (selected) {
                 this.selected = this.options.selected = selected;
-            },
-            /**
-             * The default buttons for pre-selecting time frames
-             */
-            defaultButtons: [{
-                    type: 'month',
-                    count: 1,
-                    text: '1m'
-                }, {
-                    type: 'month',
-                    count: 3,
-                    text: '3m'
-                }, {
-                    type: 'month',
-                    count: 6,
-                    text: '6m'
-                }, {
-                    type: 'ytd',
-                    text: 'YTD'
-                }, {
-                    type: 'year',
-                    count: 1,
-                    text: '1y'
-                }, {
-                    type: 'all',
-                    text: 'All'
-                }],
+            };
             /**
              * Initialize the range selector
              *
@@ -8212,11 +8976,10 @@
              * @param {Highcharts.Chart} chart
              * @return {void}
              */
-            init: function (chart) {
+            RangeSelector.prototype.init = function (chart) {
                 var rangeSelector = this,
                     options = chart.options.rangeSelector,
-                    buttonOptions = options.buttons ||
-                        [].concat(rangeSelector.defaultButtons),
+                    buttonOptions = options.buttons || rangeSelector.defaultButtons.slice(),
                     selectedOption = options.selected,
                     blurInputs = function () {
                         var minInput = rangeSelector.minInput,
@@ -8258,7 +9021,7 @@
                         });
                     }
                 });
-            },
+            };
             /**
              * Dynamically update the range selector buttons after a new range has been
              * set
@@ -8267,7 +9030,7 @@
              * @function Highcharts.RangeSelector#updateButtonStates
              * @return {void}
              */
-            updateButtonStates: function () {
+            RangeSelector.prototype.updateButtonStates = function () {
                 var rangeSelector = this,
                     chart = this.chart,
                     baseAxis = chart.xAxis[0],
@@ -8357,7 +9120,7 @@
                         }
                     }
                 });
-            },
+            };
             /**
              * Compute and cache the range for an individual button
              *
@@ -8366,7 +9129,7 @@
              * @param {Highcharts.RangeSelectorButtonsOptions} rangeOptions
              * @return {void}
              */
-            computeButtonRange: function (rangeOptions) {
+            RangeSelector.prototype.computeButtonRange = function (rangeOptions) {
                 var type = rangeOptions.type,
                     count = rangeOptions.count || 1, 
                     // these time intervals have a fixed number of milliseconds, as
@@ -8393,7 +9156,7 @@
                 rangeOptions._offsetMax = pick(rangeOptions.offsetMax, 0);
                 rangeOptions._range +=
                     rangeOptions._offsetMax - rangeOptions._offsetMin;
-            },
+            };
             /**
              * Set the internal and displayed value of a HTML input for the dates
              *
@@ -8403,7 +9166,7 @@
              * @param {number} [inputTime]
              * @return {void}
              */
-            setInputValue: function (name, inputTime) {
+            RangeSelector.prototype.setInputValue = function (name, inputTime) {
                 var options = this.chart.options.rangeSelector,
                     time = this.chart.time,
                     input = this[name + 'Input'];
@@ -8415,14 +9178,14 @@
                 this[name + 'DateBox'].attr({
                     text: time.dateFormat(options.inputDateFormat || '%b %e, %Y', input.HCTime)
                 });
-            },
+            };
             /**
              * @private
              * @function Highcharts.RangeSelector#showInput
              * @param {string} name
              * @return {void}
              */
-            showInput: function (name) {
+            RangeSelector.prototype.showInput = function (name) {
                 var inputGroup = this.inputGroup,
                     dateBox = this[name + 'DateBox'];
                 css(this[name + 'Input'], {
@@ -8432,21 +9195,35 @@
                     height: (dateBox.height - 2) + 'px',
                     border: '2px solid silver'
                 });
-            },
+            };
             /**
              * @private
              * @function Highcharts.RangeSelector#hideInput
              * @param {string} name
              * @return {void}
              */
-            hideInput: function (name) {
+            RangeSelector.prototype.hideInput = function (name) {
                 css(this[name + 'Input'], {
                     border: 0,
                     width: '1px',
                     height: '1px'
                 });
                 this.setInputValue(name);
-            },
+            };
+            /**
+             * @private
+             * @function Highcharts.RangeSelector#defaultInputDateParser
+             */
+            RangeSelector.prototype.defaultInputDateParser = function (inputDate, useUTC) {
+                var date = new Date();
+                if (H.isSafari) {
+                    return Date.parse(inputDate.split(' ').join('T'));
+                }
+                if (useUTC) {
+                    return Date.parse(inputDate + 'Z');
+                }
+                return Date.parse(inputDate) - date.getTimezoneOffset() * 60 * 1000;
+            };
             /**
              * Draw either the 'from' or the 'to' HTML input box of the range selector
              *
@@ -8455,7 +9232,7 @@
              * @param {string} name
              * @return {void}
              */
-            drawInput: function (name) {
+            RangeSelector.prototype.drawInput = function (name) {
                 var rangeSelector = this,
                     chart = rangeSelector.chart,
                     chartStyle = chart.renderer.style || {},
@@ -8467,19 +9244,21 @@
                     input,
                     label,
                     dateBox,
-                    inputGroup = this.inputGroup;
+                    inputGroup = this.inputGroup,
+                    defaultInputDateParser = this.defaultInputDateParser;
                 /**
                  * @private
                  */
                 function updateExtremes() {
                     var inputValue = input.value,
-                        value = (options.inputDateParser || Date.parse)(inputValue),
+                        value,
                         chartAxis = chart.xAxis[0],
                         dataAxis = chart.scroller && chart.scroller.xAxis ?
                             chart.scroller.xAxis :
                             chartAxis,
                         dataMin = dataAxis.dataMin,
                         dataMax = dataAxis.dataMax;
+                    value = (options.inputDateParser || defaultInputDateParser)(inputValue, chart.time.useUTC);
                     if (value !== input.previousValue) {
                         input.previousValue = value;
                         // If the value isn't parsed directly to a value by the
@@ -8605,7 +9384,7 @@
                         updateExtremes();
                     }
                 };
-            },
+            };
             /**
              * Get the position of the range selector buttons and inputs. This can be
              * overridden from outside for custom positioning.
@@ -8615,7 +9394,7 @@
              *
              * @return {Highcharts.Dictionary<number>}
              */
-            getPosition: function () {
+            RangeSelector.prototype.getPosition = function () {
                 var chart = this.chart,
                     options = chart.options.rangeSelector,
                     top = options.verticalAlign === 'top' ?
@@ -8625,7 +9404,7 @@
                         buttonTop: top + options.buttonPosition.y,
                         inputTop: top + options.inputPosition.y - 10
                     };
-            },
+            };
             /**
              * Get the extremes of YTD. Will choose dataMax if its value is lower than
              * the current timestamp. Will choose dataMin if its value is higher than
@@ -8641,7 +9420,7 @@
              * @return {*}
              *         Returns min and max for the YTD
              */
-            getYTDExtremes: function (dataMax, dataMin, useUTC) {
+            RangeSelector.prototype.getYTDExtremes = function (dataMax, dataMin, useUTC) {
                 var time = this.chart.time,
                     min,
                     now = new time.Date(dataMax),
@@ -8656,7 +9435,7 @@
                     max: Math.min(dataMax || now, now),
                     min: min
                 };
-            },
+            };
             /**
              * Render the range selector including the buttons and the inputs. The first
              * time render is called, the elements are created and positioned. On
@@ -8670,7 +9449,7 @@
              *        X axis maximum
              * @return {void}
              */
-            render: function (min, max) {
+            RangeSelector.prototype.render = function (min, max) {
                 var rangeSelector = this,
                     chart = rangeSelector.chart,
                     renderer = chart.renderer,
@@ -8940,7 +9719,7 @@
                         rangeSelector.group.translateY + 'px';
                 }
                 rangeSelector.rendered = true;
-            },
+            };
             /**
              * Extracts height of range selector
              *
@@ -8949,7 +9728,7 @@
              * @return {number}
              *         Returns rangeSelector height
              */
-            getHeight: function () {
+            RangeSelector.prototype.getHeight = function () {
                 var rangeSelector = this,
                     options = rangeSelector.options,
                     rangeSelectorGroup = rangeSelector.group,
@@ -8974,7 +9753,7 @@
                     rangeSelectorHeight += Math.abs(minPosition);
                 }
                 return rangeSelectorHeight;
-            },
+            };
             /**
              * Detect collision with title or subtitle
              *
@@ -8986,10 +9765,10 @@
              * @return {boolean}
              *         Returns collision status
              */
-            titleCollision: function (chart) {
+            RangeSelector.prototype.titleCollision = function (chart) {
                 return !(chart.options.title.text ||
                     chart.options.subtitle.text);
-            },
+            };
             /**
              * Update the range selector with new options
              *
@@ -8998,20 +9777,20 @@
              * @param {Highcharts.RangeSelectorOptions} options
              * @return {void}
              */
-            update: function (options) {
+            RangeSelector.prototype.update = function (options) {
                 var chart = this.chart;
                 merge(true, chart.options.rangeSelector, options);
                 this.destroy();
                 this.init(chart);
                 chart.rangeSelector.render();
-            },
+            };
             /**
              * Destroys allocated elements.
              *
              * @private
              * @function Highcharts.RangeSelector#destroy
              */
-            destroy: function () {
+            RangeSelector.prototype.destroy = function () {
                 var rSelector = this,
                     minInput = rSelector.minInput,
                     maxInput = rSelector.maxInput;
@@ -9029,21 +9808,48 @@
                 // Destroy HTML and SVG elements
                 objectEach(rSelector, function (val, key) {
                     if (val && key !== 'chart') {
-                        if (val.destroy) {
+                        if (val instanceof SVGElement) {
                             // SVGElement
                             val.destroy();
                         }
-                        else if (val.nodeType) {
+                        else if (val instanceof window.HTMLElement) {
                             // HTML element
-                            discardElement(this[key]);
+                            discardElement(val);
                         }
                     }
                     if (val !== RangeSelector.prototype[key]) {
                         rSelector[key] = null;
                     }
                 }, this);
-            }
-        };
+            };
+            return RangeSelector;
+        }());
+        /**
+         * The default buttons for pre-selecting time frames
+         */
+        RangeSelector.prototype.defaultButtons = [{
+                type: 'month',
+                count: 1,
+                text: '1m'
+            }, {
+                type: 'month',
+                count: 3,
+                text: '3m'
+            }, {
+                type: 'month',
+                count: 6,
+                text: '6m'
+            }, {
+                type: 'ytd',
+                text: 'YTD'
+            }, {
+                type: 'year',
+                count: 1,
+                text: '1y'
+            }, {
+                type: 'all',
+                text: 'All'
+            }];
         /**
          * Get the axis min value based on the range option and the current max. For
          * stock charts this is extended via the {@link RangeSelector} so that if the
@@ -9254,8 +10060,9 @@
             H.RangeSelector = RangeSelector;
         }
 
+        return H.RangeSelector;
     });
-    _registerModule(_modules, 'parts/NavigatorAxis.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Core/Axis/NavigatorAxis.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (H, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -9431,7 +10238,7 @@
 
         return NavigatorAxis;
     });
-    _registerModule(_modules, 'parts/Navigator.js', [_modules['parts/Axis.js'], _modules['parts/Color.js'], _modules['parts/Globals.js'], _modules['parts/NavigatorAxis.js'], _modules['parts/Scrollbar.js'], _modules['parts/Utilities.js']], function (Axis, Color, H, NavigatorAxis, Scrollbar, U) {
+    _registerModule(_modules, 'Core/Navigator.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Series/Series.js'], _modules['Core/Chart/Chart.js'], _modules['Core/Color/Color.js'], _modules['Core/Globals.js'], _modules['Series/LineSeries.js'], _modules['Core/Axis/NavigatorAxis.js'], _modules['Core/Options.js'], _modules['Core/Scrollbar.js'], _modules['Core/Utilities.js']], function (Axis, BaseSeries, Chart, Color, H, LineSeries, NavigatorAxis, O, Scrollbar, U) {
         /* *
          *
          *  (c) 2010-2020 Torstein Honsi
@@ -9441,7 +10248,11 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
+        var seriesTypes = BaseSeries.seriesTypes;
         var color = Color.parse;
+        var hasTouch = H.hasTouch,
+            isTouchDevice = H.isTouchDevice;
+        var defaultOptions = O.defaultOptions;
         var addEvent = U.addEvent,
             clamp = U.clamp,
             correctFloat = U.correctFloat,
@@ -9456,13 +10267,7 @@
             pick = U.pick,
             removeEvent = U.removeEvent,
             splat = U.splat;
-        var Chart = H.Chart,
-            defaultOptions = H.defaultOptions,
-            hasTouch = H.hasTouch,
-            isTouchDevice = H.isTouchDevice,
-            Series = H.Series,
-            seriesTypes = H.seriesTypes,
-            defaultSeriesType, 
+        var defaultSeriesType, 
             // Finding the min or max of a set of variables where we don't know if they
             // are defined, is a pattern that is repeated several places in Highcharts.
             // Consider making this a global utility method.
@@ -9724,8 +10529,7 @@
                  */
                 series: {
                     /**
-                     * The type of the navigator series. Defaults to `areaspline` if
-                     * defined, otherwise `line`.
+                     * The type of the navigator series.
                      *
                      * Heads up:
                      * In column-type navigator, zooming is limited to at least one
@@ -9735,7 +10539,8 @@
                      *         Column type navigator
                      *
                      * @type    {string}
-                     * @default areaspline
+                     * @default {highstock} `areaspline` if defined, otherwise `line`
+                     * @default {gantt} gantt
                      */
                     type: defaultSeriesType,
                     /**
@@ -9939,9 +10744,9 @@
          *         Path to be used in a handle
          */
         H.Renderer.prototype.symbols['navigator-handle'] = function (x, y, w, h, options) {
-            var halfWidth = options.width / 2,
+            var halfWidth = (options && options.width || 0) / 2,
                 markerPosition = Math.round(halfWidth / 3) + 0.5,
-                height = options.height || 0;
+                height = options && options.height || 0;
             return [
                 ['M', -halfWidth - 1, 0.5],
                 ['L', halfWidth, 0.5],
@@ -10654,8 +11459,8 @@
                     inverted = chart.inverted,
                     verb = navigator.rendered && !navigator.hasDragged ?
                         'animate' : 'attr',
-                    zoomedMax = Math.round(navigator.zoomedMax),
-                    zoomedMin = Math.round(navigator.zoomedMin),
+                    zoomedMax,
+                    zoomedMin,
                     unionExtremes,
                     fixedMin,
                     fixedMax,
@@ -10706,7 +11511,11 @@
                                 navigator.hasDragged = navigator.dragOffset = null;
                 }
                 // Update position of navigator shades, outline and handles (#12573)
-                if (navigator.navigatorEnabled) {
+                if (navigator.navigatorEnabled &&
+                    isNumber(navigator.zoomedMin) &&
+                    isNumber(navigator.zoomedMax)) {
+                    zoomedMin = Math.round(navigator.zoomedMin);
+                    zoomedMax = Math.round(navigator.zoomedMax);
                     if (navigator.shades) {
                         navigator.drawMasks(zoomedMin, zoomedMax, inverted, verb);
                     }
@@ -10828,6 +11637,7 @@
                         offset: 0,
                         index: yAxisIndex,
                         isInternal: true,
+                        reversed: pick((navigatorOptions.yAxis && navigatorOptions.yAxis.reversed), (chart.yAxis[0] && chart.yAxis[0].reversed), false),
                         zoomEnabled: false
                     }, chart.inverted ? {
                         width: height
@@ -11427,6 +12237,7 @@
                                     0) -
                                 ((legendOptions &&
                                     legendOptions.verticalAlign === 'bottom' &&
+                                    legendOptions.layout !== 'proximate' && // #13392
                                     legendOptions.enabled &&
                                     !legendOptions.floating) ?
                                     legend.legendHeight +
@@ -11477,7 +12288,7 @@
                 }
             });
             // Handle updating series
-            addEvent(Series, 'afterUpdate', function () {
+            addEvent(LineSeries, 'afterUpdate', function () {
                 if (this.chart.navigator && !this.options.isInternal) {
                     this.chart.navigator.setBaseSeries(null, false);
                 }