@progress/kendo-charts 2.7.2-dev.202502101310 → 2.7.2-develop.1

package/dist/es/chart/plotarea/plotarea-base.js

@@ -11,11 +11,11 @@ import { append, deepExtend, defined, getSpacing, getTemplate, inArray, isFuncti
     limitValue, round, setDefaultOptions, last, cycleIndex } from '../../common';
 import { TRENDLINE_SERIES } from '../constants';
 
-var visiblePoint = function (point) { return point.options.visible !== false; };
+const visiblePoint = (point) => point.options.visible !== false;
 
-var PlotAreaBase = (function (ChartElement) {
-    function PlotAreaBase(series, options, chartService) {
-        ChartElement.call(this, options);
+class PlotAreaBase extends ChartElement {
+    constructor(series, options, chartService) {
+        super(options);
 
         this.initFields(series, options);
         this.series = series;
@@ -35,115 +35,106 @@ var PlotAreaBase = (function (ChartElement) {
         this.createCrosshairs();
     }
 
-    if ( ChartElement ) PlotAreaBase.__proto__ = ChartElement;
-    PlotAreaBase.prototype = Object.create( ChartElement && ChartElement.prototype );
-    PlotAreaBase.prototype.constructor = PlotAreaBase;
+    initFields() { }
 
-    PlotAreaBase.prototype.initFields = function initFields () { };
+    initSeries() {
+        const series = this.series;
 
-    PlotAreaBase.prototype.initSeries = function initSeries () {
-        var series = this.series;
-
-        for (var i = 0; i < series.length; i++) {
+        for (let i = 0; i < series.length; i++) {
             series[i].index = i;
         }
-    };
+    }
 
-    PlotAreaBase.prototype.bindPoint = function bindPoint (series, pointIx, item) {
-        var cached = this._bindCache.get(series);
+    bindPoint(series, pointIx, item) {
+        let cached = this._bindCache.get(series);
         if (!cached) {
             cached = [];
             this._bindCache.set(series, cached);
         }
 
-        var data = cached[pointIx];
+        let data = cached[pointIx];
         if (!data) {
             data = cached[pointIx] = SeriesBinder.current.bindPoint(series, pointIx, item);
         }
 
         return data;
-    };
-
-    PlotAreaBase.prototype.createPanes = function createPanes () {
-        var this$1 = this;
+    }
 
-        var titleOptions = this.options.title || {};
-        var paneDefaults = this.options.paneDefaults;
-        var paneOptions = this.options.panes || [];
-        var panesLength = Math.max(paneOptions.length, 1);
-        var panes = [];
+    createPanes() {
+        const titleOptions = this.options.title || {};
+        const paneDefaults = this.options.paneDefaults;
+        const paneOptions = this.options.panes || [];
+        const panesLength = Math.max(paneOptions.length, 1);
+        const panes = [];
 
-        var defaults = deepExtend({
+        const defaults = deepExtend({
             title: {
                 color: titleOptions.color
             }
         }, paneDefaults);
 
-        for (var i = 0; i < panesLength; i++) {
-            var options = deepExtend({}, defaults, paneOptions[i]);
+        for (let i = 0; i < panesLength; i++) {
+            const options = deepExtend({}, defaults, paneOptions[i]);
             if (isString(options.title)) {
                 options.title = deepExtend({ text: options.title }, defaults.title);
             }
 
-            var currentPane = new Pane(options);
+            const currentPane = new Pane(options);
             currentPane.paneIndex = i;
 
             panes.push(currentPane);
-            this$1.append(currentPane);
+            this.append(currentPane);
         }
 
         this.panes = panes;
-    };
+    }
 
-    PlotAreaBase.prototype.crosshairOptions = function crosshairOptions (axis) {
+    crosshairOptions(axis) {
         return axis.options.crosshair;
-    };
-
-    PlotAreaBase.prototype.createCrosshairs = function createCrosshairs (panes) {
-        var this$1 = this;
-        if ( panes === void 0 ) panes = this.panes;
+    }
 
-        for (var i = 0; i < panes.length; i++) {
-            var pane = panes[i];
-            for (var j = 0; j < pane.axes.length; j++) {
-                var axis = pane.axes[j];
-                var options = this$1.crosshairOptions(axis);
+    createCrosshairs(panes = this.panes) {
+        for (let i = 0; i < panes.length; i++) {
+            const pane = panes[i];
+            for (let j = 0; j < pane.axes.length; j++) {
+                const axis = pane.axes[j];
+                const options = this.crosshairOptions(axis);
                 if (options && options.visible) {
-                    var currentCrosshair = new Crosshair(this$1.chartService, axis, options);
+                    const currentCrosshair = new Crosshair(this.chartService, axis, options);
 
-                    this$1.crosshairs.push(currentCrosshair);
+                    this.crosshairs.push(currentCrosshair);
                     pane.content.append(currentCrosshair);
                 }
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.removeCrosshairs = function removeCrosshairs (pane) {
-        var crosshairs = this.crosshairs;
-        var axes = pane.axes;
+    removeCrosshairs(pane) {
+        const crosshairs = this.crosshairs;
+        const axes = pane.axes;
 
-        for (var i = crosshairs.length - 1; i >= 0; i--) {
-            for (var j = 0; j < axes.length; j++) {
+        for (let i = crosshairs.length - 1; i >= 0; i--) {
+            for (let j = 0; j < axes.length; j++) {
                 if (crosshairs[i].axis === axes[j]) {
                     crosshairs.splice(i, 1);
                     break;
                 }
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.hideCrosshairs = function hideCrosshairs () {
-        var crosshairs = this.crosshairs;
-        for (var idx = 0; idx < crosshairs.length; idx++) {
+    hideCrosshairs() {
+        const crosshairs = this.crosshairs;
+        for (let idx = 0; idx < crosshairs.length; idx++) {
             crosshairs[idx].hide();
         }
-    };
+    }
 
-    PlotAreaBase.prototype.findPane = function findPane (name) {
-        var panes = this.panes;
-        var matchingPane;
+    findPane(name) {
+        const panes = this.panes;
+        let matchingPane;
 
-        for (var i = 0; i < panes.length; i++) {
+        for (let i = 0; i < panes.length; i++) {
             if (panes[i].options.name === name) {
                 matchingPane = panes[i];
                 break;
@@ -151,13 +142,13 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         return matchingPane || panes[0];
-    };
+    }
 
-    PlotAreaBase.prototype.findPointPane = function findPointPane (point) {
-        var panes = this.panes;
-        var matchingPane;
+    findPointPane(point) {
+        const panes = this.panes;
+        let matchingPane;
 
-        for (var i = 0; i < panes.length; i++) {
+        for (let i = 0; i < panes.length; i++) {
             if (panes[i].box.containsPoint(point)) {
                 matchingPane = panes[i];
                 break;
@@ -165,23 +156,21 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         return matchingPane;
-    };
+    }
 
-    PlotAreaBase.prototype.appendAxis = function appendAxis (axis) {
-        var pane = this.findPane(axis.options.pane);
+    appendAxis(axis) {
+        const pane = this.findPane(axis.options.pane);
 
         pane.appendAxis(axis);
         this.axes.push(axis);
         axis.plotArea = this;
-    };
-
-    PlotAreaBase.prototype.removeAxis = function removeAxis (axisToRemove) {
-        var this$1 = this;
+    }
 
-        var filteredAxes = [];
+    removeAxis(axisToRemove) {
+        const filteredAxes = [];
 
-        for (var i = 0; i < this.axes.length; i++) {
-            var axis = this$1.axes[i];
+        for (let i = 0; i < this.axes.length; i++) {
+            const axis = this.axes[i];
             if (axisToRemove !== axis) {
                 filteredAxes.push(axis);
             } else {
@@ -190,24 +179,22 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         this.axes = filteredAxes;
-    };
+    }
 
-    PlotAreaBase.prototype.appendChart = function appendChart (chart, pane) {
+    appendChart(chart, pane) {
         this.charts.push(chart);
         if (pane) {
             pane.appendChart(chart);
         } else {
             this.append(chart);
         }
-    };
-
-    PlotAreaBase.prototype.removeChart = function removeChart (chartToRemove) {
-        var this$1 = this;
+    }
 
-        var filteredCharts = [];
+    removeChart(chartToRemove) {
+        const filteredCharts = [];
 
-        for (var i = 0; i < this.charts.length; i++) {
-            var chart = this$1.charts[i];
+        for (let i = 0; i < this.charts.length; i++) {
+            const chart = this.charts[i];
             if (chart !== chartToRemove) {
                 filteredCharts.push(chart);
             } else {
@@ -216,25 +203,25 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         this.charts = filteredCharts;
-    };
-
-    PlotAreaBase.prototype.addToLegend = function addToLegend (series) {
-        var count = series.length;
-        var legend = this.options.legend;
-        var labels = legend.labels || {};
-        var inactiveItems = legend.inactiveItems || {};
-        var inactiveItemsLabels = inactiveItems.labels || {};
-        var data = [];
-
-        for (var i = 0; i < count; i++) {
-            var currentSeries = series[i];
-            var seriesVisible = currentSeries.visible !== false;
+    }
+
+    addToLegend(series) {
+        const count = series.length;
+        const legend = this.options.legend;
+        const labels = legend.labels || {};
+        const inactiveItems = legend.inactiveItems || {};
+        const inactiveItemsLabels = inactiveItems.labels || {};
+        const data = [];
+
+        for (let i = 0; i < count; i++) {
+            const currentSeries = series[i];
+            const seriesVisible = currentSeries.visible !== false;
             if (currentSeries.visibleInLegend === false) {
                 continue;
             }
 
-            var text = currentSeries.name;
-            var labelTemplate = seriesVisible ? getTemplate(labels) : getTemplate(inactiveItemsLabels) || getTemplate(labels);
+            let text = currentSeries.name;
+            const labelTemplate = seriesVisible ? getTemplate(labels) : getTemplate(inactiveItemsLabels) || getTemplate(labels);
             if (labelTemplate) {
                 text = labelTemplate({
                     text: hasValue(text) ? text : "",
@@ -242,13 +229,13 @@ var PlotAreaBase = (function (ChartElement) {
                 });
             }
 
-            var defaults = currentSeries._defaults;
-            var color = currentSeries.color;
+            const defaults = currentSeries._defaults;
+            let color = currentSeries.color;
             if (isFunction(color) && defaults) {
                 color = defaults.color;
             }
 
-            var itemLabelOptions = (void 0), markerColor = (void 0);
+            let itemLabelOptions, markerColor;
             if (seriesVisible) {
                 itemLabelOptions = {};
                 markerColor = color;
@@ -272,16 +259,16 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         append(legend.data, data);
-    };
+    }
 
-    PlotAreaBase.prototype.groupAxes = function groupAxes (panes) {
-        var xAxes = [];
-        var yAxes = [];
+    groupAxes(panes) {
+        const xAxes = [];
+        const yAxes = [];
 
-        for (var paneIx = 0; paneIx < panes.length; paneIx++) {
-            var paneAxes = panes[paneIx].axes;
-            for (var axisIx = 0; axisIx < paneAxes.length; axisIx++) {
-                var axis = paneAxes[axisIx];
+        for (let paneIx = 0; paneIx < panes.length; paneIx++) {
+            const paneAxes = panes[paneIx].axes;
+            for (let axisIx = 0; axisIx < paneAxes.length; axisIx++) {
+                const axis = paneAxes[axisIx];
                 if (axis.options.vertical) {
                     yAxes.push(axis);
                 } else {
@@ -291,17 +278,15 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         return { x: xAxes, y: yAxes, any: xAxes.concat(yAxes) };
-    };
-
-    PlotAreaBase.prototype.groupSeriesByPane = function groupSeriesByPane () {
-        var this$1 = this;
+    }
 
-        var series = this.series;
-        var seriesByPane = {};
+    groupSeriesByPane() {
+        const series = this.series;
+        const seriesByPane = {};
 
-        for (var i = 0; i < series.length; i++) {
-            var currentSeries = series[i];
-            var pane = this$1.seriesPaneName(currentSeries);
+        for (let i = 0; i < series.length; i++) {
+            const currentSeries = series[i];
+            const pane = this.seriesPaneName(currentSeries);
 
             if (seriesByPane[pane]) {
                 seriesByPane[pane].push(currentSeries);
@@ -311,25 +296,25 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         return seriesByPane;
-    };
+    }
 
-    PlotAreaBase.prototype.filterVisibleSeries = function filterVisibleSeries (series) {
-        var result = [];
+    filterVisibleSeries(series) {
+        const result = [];
 
-        for (var i = 0; i < series.length; i++) {
-            var currentSeries = series[i];
+        for (let i = 0; i < series.length; i++) {
+            const currentSeries = series[i];
             if (currentSeries.visible !== false) {
                 result.push(currentSeries);
             }
         }
 
         return result;
-    };
+    }
 
-    PlotAreaBase.prototype.reflow = function reflow (targetBox) {
-        var options = this.options.plotArea;
-        var panes = this.panes;
-        var margin = getSpacing(options.margin);
+    reflow(targetBox) {
+        const options = this.options.plotArea;
+        const panes = this.panes;
+        const margin = getSpacing(options.margin);
 
         this.box = targetBox.clone().unpad(margin);
         this.reflowPanes();
@@ -337,22 +322,20 @@ var PlotAreaBase = (function (ChartElement) {
         this.detachLabels();
         this.reflowAxes(panes);
         this.reflowCharts(panes);
-    };
-
-    PlotAreaBase.prototype.redraw = function redraw (panes) {
-        var this$1 = this;
+    }
 
-        var panesArray = [].concat(panes);
+    redraw(panes) {
+        const panesArray = [].concat(panes);
         this.initSeries();
 
         //prevents leak during partial redraws. the cached gradients observers retain reference to the destroyed elements.
-        var root = this.getRoot();
+        const root = this.getRoot();
         if (root) {
             root.cleanGradients();
         }
 
-        for (var i = 0; i < panesArray.length; i++) {
-            this$1.removeCrosshairs(panesArray[i]);
+        for (let i = 0; i < panesArray.length; i++) {
+            this.removeCrosshairs(panesArray[i]);
             panesArray[i].empty();
         }
 
@@ -365,32 +348,32 @@ var PlotAreaBase = (function (ChartElement) {
 
         this.createCrosshairs(panesArray);
 
-        for (var i$1 = 0; i$1 < panesArray.length; i$1++) {
-            panesArray[i$1].refresh();
+        for (let i = 0; i < panesArray.length; i++) {
+            panesArray[i].refresh();
         }
-    };
+    }
 
-    PlotAreaBase.prototype.axisCrossingValues = function axisCrossingValues (axis, crossingAxes) {
-        var options = axis.options;
-        var crossingValues = [].concat(
+    axisCrossingValues(axis, crossingAxes) {
+        const options = axis.options;
+        const crossingValues = [].concat(
             options.axisCrossingValues || options.axisCrossingValue
         );
-        var valuesToAdd = crossingAxes.length - crossingValues.length;
-        var defaultValue = crossingValues[0] || 0;
+        const valuesToAdd = crossingAxes.length - crossingValues.length;
+        const defaultValue = crossingValues[0] || 0;
 
-        for (var i = 0; i < valuesToAdd; i++) {
+        for (let i = 0; i < valuesToAdd; i++) {
             crossingValues.push(defaultValue);
         }
 
         return crossingValues;
-    };
-
-    PlotAreaBase.prototype.alignAxisTo = function alignAxisTo (axis, targetAxis, crossingValue, targetCrossingValue) {
-        var slot = axis.getSlot(crossingValue, crossingValue, true);
-        var slotEdge = axis.options.reverse ? 2 : 1;
-        var targetSlot = targetAxis.getSlot(targetCrossingValue, targetCrossingValue, true);
-        var targetEdge = targetAxis.options.reverse ? 2 : 1;
-        var axisBox = axis.box.translate(
+    }
+
+    alignAxisTo(axis, targetAxis, crossingValue, targetCrossingValue) {
+        const slot = axis.getSlot(crossingValue, crossingValue, true);
+        const slotEdge = axis.options.reverse ? 2 : 1;
+        const targetSlot = targetAxis.getSlot(targetCrossingValue, targetCrossingValue, true);
+        const targetEdge = targetAxis.options.reverse ? 2 : 1;
+        const axisBox = axis.box.translate(
             targetSlot[X + targetEdge] - slot[X + slotEdge],
             targetSlot[Y + targetEdge] - slot[Y + slotEdge]
         );
@@ -400,35 +383,33 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         axis.reflow(axisBox);
-    };
-
-    PlotAreaBase.prototype.alignAxes = function alignAxes (xAxes, yAxes) {
-        var this$1 = this;
-
-        var xAnchor = xAxes[0];
-        var yAnchor = yAxes[0];
-        var xAnchorCrossings = this.axisCrossingValues(xAnchor, yAxes);
-        var yAnchorCrossings = this.axisCrossingValues(yAnchor, xAxes);
-        var leftAnchors = {};
-        var rightAnchors = {};
-        var topAnchors = {};
-        var bottomAnchors = {};
-
-        for (var i = 0; i < yAxes.length; i++) {
-            var axis = yAxes[i];
-            var pane = axis.pane;
-            var paneId = pane.id;
-            var visible = axis.options.visible !== false;
+    }
+
+    alignAxes(xAxes, yAxes) {
+        const xAnchor = xAxes[0];
+        const yAnchor = yAxes[0];
+        const xAnchorCrossings = this.axisCrossingValues(xAnchor, yAxes);
+        const yAnchorCrossings = this.axisCrossingValues(yAnchor, xAxes);
+        const leftAnchors = {};
+        const rightAnchors = {};
+        const topAnchors = {};
+        const bottomAnchors = {};
+
+        for (let i = 0; i < yAxes.length; i++) {
+            const axis = yAxes[i];
+            const pane = axis.pane;
+            const paneId = pane.id;
+            const visible = axis.options.visible !== false;
 
             // Locate pane anchor, if any, and use its axisCrossingValues
-            var anchor = paneAnchor(xAxes, pane) || xAnchor;
-            var anchorCrossings = xAnchorCrossings;
+            const anchor = paneAnchor(xAxes, pane) || xAnchor;
+            let anchorCrossings = xAnchorCrossings;
 
             if (anchor !== xAnchor) {
-                anchorCrossings = this$1.axisCrossingValues(anchor, yAxes);
+                anchorCrossings = this.axisCrossingValues(anchor, yAxes);
             }
 
-            this$1.alignAxisTo(axis, anchor, yAnchorCrossings[i], anchorCrossings[i]);
+            this.alignAxisTo(axis, anchor, yAnchorCrossings[i], anchorCrossings[i]);
 
             if (axis.options._overlap) {
                 continue;
@@ -455,7 +436,7 @@ var PlotAreaBase = (function (ChartElement) {
                     axis._mirrored = true;
                 }
 
-                this$1.alignAxisTo(axis, anchor, yAnchorCrossings[i], anchorCrossings[i]);
+                this.alignAxisTo(axis, anchor, yAnchorCrossings[i], anchorCrossings[i]);
 
                 // Push the axis to the right the previous y-axis so they don't overlap
                 if (rightAnchors[paneId]) {
@@ -471,81 +452,81 @@ var PlotAreaBase = (function (ChartElement) {
             }
 
             // Locate pane anchor, if any, and align the axis to it
-            var paneYAnchor = paneAnchor(yAxes, pane) || yAnchor;
+            const paneYAnchor = paneAnchor(yAxes, pane) || yAnchor;
             if (paneYAnchor !== axis) {
                 axis.alignTo(paneYAnchor);
                 axis.reflow(axis.box);
             }
         }
 
-        for (var i$1 = 0; i$1 < xAxes.length; i$1++) {
-            var axis$1 = xAxes[i$1];
-            var pane$1 = axis$1.pane;
-            var paneId$1 = pane$1.id;
-            var visible$1 = axis$1.options.visible !== false;
+        for (let i = 0; i < xAxes.length; i++) {
+            const axis = xAxes[i];
+            const pane = axis.pane;
+            const paneId = pane.id;
+            const visible = axis.options.visible !== false;
 
             // Locate pane anchor and use its axisCrossingValues
-            var anchor$1 = paneAnchor(yAxes, pane$1) || yAnchor;
-            var anchorCrossings$1 = yAnchorCrossings;
-            if (anchor$1 !== yAnchor) {
-                anchorCrossings$1 = this$1.axisCrossingValues(anchor$1, xAxes);
+            const anchor = paneAnchor(yAxes, pane) || yAnchor;
+            let anchorCrossings = yAnchorCrossings;
+            if (anchor !== yAnchor) {
+                anchorCrossings = this.axisCrossingValues(anchor, xAxes);
             }
 
-            this$1.alignAxisTo(axis$1, anchor$1, xAnchorCrossings[i$1], anchorCrossings$1[i$1]);
+            this.alignAxisTo(axis, anchor, xAnchorCrossings[i], anchorCrossings[i]);
 
-            if (axis$1.options._overlap) {
+            if (axis.options._overlap) {
                 continue;
             }
 
-            if (round(axis$1.lineBox().y1) === round(anchor$1.lineBox().y1)) {
+            if (round(axis.lineBox().y1) === round(anchor.lineBox().y1)) {
                 // Flip the labels on top if we're at the top of the pane
-                if (!axis$1._mirrored) {
-                    axis$1.options.labels.mirror = !axis$1.options.labels.mirror;
-                    axis$1._mirrored = true;
+                if (!axis._mirrored) {
+                    axis.options.labels.mirror = !axis.options.labels.mirror;
+                    axis._mirrored = true;
                 }
-                this$1.alignAxisTo(axis$1, anchor$1, xAnchorCrossings[i$1], anchorCrossings$1[i$1]);
+                this.alignAxisTo(axis, anchor, xAnchorCrossings[i], anchorCrossings[i]);
 
                 // Push the axis above the previous x-axis so they don't overlap
-                if (topAnchors[paneId$1]) {
-                    axis$1.reflow(axis$1.box
-                        .alignTo(topAnchors[paneId$1].box, TOP)
-                        .translate(0, -axis$1.options.margin)
+                if (topAnchors[paneId]) {
+                    axis.reflow(axis.box
+                        .alignTo(topAnchors[paneId].box, TOP)
+                        .translate(0, -axis.options.margin)
                     );
                 }
 
-                if (visible$1) {
-                    topAnchors[paneId$1] = axis$1;
+                if (visible) {
+                    topAnchors[paneId] = axis;
                 }
             }
 
-            if (round(axis$1.lineBox().y2, COORD_PRECISION) === round(anchor$1.lineBox().y2, COORD_PRECISION)) {
+            if (round(axis.lineBox().y2, COORD_PRECISION) === round(anchor.lineBox().y2, COORD_PRECISION)) {
                 // Push the axis below the previous x-axis so they don't overlap
-                if (bottomAnchors[paneId$1]) {
-                    axis$1.reflow(axis$1.box
-                        .alignTo(bottomAnchors[paneId$1].box, BOTTOM)
-                        .translate(0, axis$1.options.margin)
+                if (bottomAnchors[paneId]) {
+                    axis.reflow(axis.box
+                        .alignTo(bottomAnchors[paneId].box, BOTTOM)
+                        .translate(0, axis.options.margin)
                     );
                 }
 
-                if (visible$1) {
-                    bottomAnchors[paneId$1] = axis$1;
+                if (visible) {
+                    bottomAnchors[paneId] = axis;
                 }
             }
 
-            if (i$1 !== 0) {
-                axis$1.alignTo(xAnchor);
-                axis$1.reflow(axis$1.box);
+            if (i !== 0) {
+                axis.alignTo(xAnchor);
+                axis.reflow(axis.box);
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.shrinkAxisWidth = function shrinkAxisWidth (panes) {
-        var axes = this.groupAxes(panes).any;
-        var axisBox = axisGroupBox(axes);
-        var overflowX = 0;
+    shrinkAxisWidth(panes) {
+        const axes = this.groupAxes(panes).any;
+        const axisBox = axisGroupBox(axes);
+        let overflowX = 0;
 
-        for (var i = 0; i < panes.length; i++) {
-            var currentPane = panes[i];
+        for (let i = 0; i < panes.length; i++) {
+            const currentPane = panes[i];
 
             if (currentPane.axes.length > 0) {
                 overflowX = Math.max(
@@ -556,27 +537,27 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         if (overflowX !== 0) {
-            for (var i$1 = 0; i$1 < axes.length; i$1++) {
-                var currentAxis = axes[i$1];
+            for (let i = 0; i < axes.length; i++) {
+                const currentAxis = axes[i];
 
                 if (!currentAxis.options.vertical) {
                     currentAxis.reflow(currentAxis.box.shrink(overflowX, 0));
                 }
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.shrinkAxisHeight = function shrinkAxisHeight (panes) {
-        var shrinked;
+    shrinkAxisHeight(panes) {
+        let shrinked;
 
-        for (var i = 0; i < panes.length; i++) {
-            var currentPane = panes[i];
-            var axes = currentPane.axes;
-            var overflowY = Math.max(0, axisGroupBox(axes).height() - currentPane.contentBox.height());
+        for (let i = 0; i < panes.length; i++) {
+            const currentPane = panes[i];
+            const axes = currentPane.axes;
+            const overflowY = Math.max(0, axisGroupBox(axes).height() - currentPane.contentBox.height());
 
             if (overflowY !== 0) {
-                for (var j = 0; j < axes.length; j++) {
-                    var currentAxis = axes[j];
+                for (let j = 0; j < axes.length; j++) {
+                    const currentAxis = axes[j];
 
                     if (currentAxis.options.vertical) {
                         currentAxis.reflow(
@@ -589,28 +570,28 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         return shrinked;
-    };
+    }
 
-    PlotAreaBase.prototype.fitAxes = function fitAxes (panes) {
-        var axes = this.groupAxes(panes).any;
-        var offsetX = 0;
+    fitAxes(panes) {
+        const axes = this.groupAxes(panes).any;
+        let offsetX = 0;
 
-        for (var i = 0; i < panes.length; i++) {
-            var currentPane = panes[i];
-            var paneAxes = currentPane.axes;
-            var paneBox = currentPane.contentBox;
+        for (let i = 0; i < panes.length; i++) {
+            const currentPane = panes[i];
+            const paneAxes = currentPane.axes;
+            const paneBox = currentPane.contentBox;
 
             if (paneAxes.length > 0) {
-                var axisBox = axisGroupBox(paneAxes);
+                const axisBox = axisGroupBox(paneAxes);
                 // OffsetY is calculated and applied per pane
-                var offsetY = Math.max(paneBox.y1 - axisBox.y1, paneBox.y2 - axisBox.y2);
+                const offsetY = Math.max(paneBox.y1 - axisBox.y1, paneBox.y2 - axisBox.y2);
 
                 // OffsetX is calculated and applied globally
                 offsetX = Math.max(offsetX, paneBox.x1 - axisBox.x1);
 
 
-                for (var j = 0; j < paneAxes.length; j++) {
-                    var currentAxis = paneAxes[j];
+                for (let j = 0; j < paneAxes.length; j++) {
+                    const currentAxis = paneAxes[j];
 
                     currentAxis.reflow(
                         currentAxis.box.translate(0, offsetY)
@@ -619,22 +600,20 @@ var PlotAreaBase = (function (ChartElement) {
             }
         }
 
-        for (var i$1 = 0; i$1 < axes.length; i$1++) {
-            var currentAxis$1 = axes[i$1];
+        for (let i = 0; i < axes.length; i++) {
+            const currentAxis = axes[i];
 
-            currentAxis$1.reflow(
-                currentAxis$1.box.translate(offsetX, 0)
+            currentAxis.reflow(
+                currentAxis.box.translate(offsetX, 0)
             );
         }
-    };
-
-    PlotAreaBase.prototype.reflowAxes = function reflowAxes (panes) {
-        var this$1 = this;
+    }
 
-        var axes = this.groupAxes(panes);
+    reflowAxes(panes) {
+        const axes = this.groupAxes(panes);
 
-        for (var i = 0; i < panes.length; i++) {
-            this$1.reflowPaneAxes(panes[i]);
+        for (let i = 0; i < panes.length; i++) {
+            this.reflowPaneAxes(panes[i]);
         }
 
         if (axes.x.length > 0 && axes.y.length > 0) {
@@ -657,26 +636,23 @@ var PlotAreaBase = (function (ChartElement) {
 
             this.fitAxes(panes);
         }
-    };
-
-    PlotAreaBase.prototype.autoRotateAxisLabels = function autoRotateAxisLabels (groupedAxes) {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var panes = ref.panes;
-        var axes = allPaneAxes(panes);
-        var rotated;
+    autoRotateAxisLabels(groupedAxes) {
+        const { panes } = this;
+        const axes = allPaneAxes(panes);
+        let rotated;
 
-        for (var idx = 0; idx < axes.length; idx++) {
-            var axis = axes[idx];
+        for (let idx = 0; idx < axes.length; idx++) {
+            const axis = axes[idx];
             if (axis.autoRotateLabels()) {
                 rotated = true;
             }
         }
 
         if (rotated) {
-            for (var idx$1 = 0; idx$1 < panes.length; idx$1++) {
-                this$1.reflowPaneAxes(panes[idx$1]);
+            for (let idx = 0; idx < panes.length; idx++) {
+                this.reflowPaneAxes(panes[idx]);
             }
 
             if (groupedAxes.x.length > 0 && groupedAxes.y.length > 0) {
@@ -684,44 +660,42 @@ var PlotAreaBase = (function (ChartElement) {
                 this.shrinkAxisWidth(panes);
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.reflowPaneAxes = function reflowPaneAxes (pane) {
-        var axes = pane.axes;
-        var length = axes.length;
+    reflowPaneAxes(pane) {
+        const axes = pane.axes;
+        const length = axes.length;
 
         if (length > 0) {
-            for (var i = 0; i < length; i++) {
+            for (let i = 0; i < length; i++) {
                 axes[i].reflow(pane.contentBox);
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.reflowCharts = function reflowCharts (panes) {
-        var charts = this.charts;
-        var count = charts.length;
-        var box = this.box;
+    reflowCharts(panes) {
+        const charts = this.charts;
+        const count = charts.length;
+        const box = this.box;
 
-        for (var i = 0; i < count; i++) {
-            var chartPane = charts[i].pane;
+        for (let i = 0; i < count; i++) {
+            const chartPane = charts[i].pane;
             if (!chartPane || inArray(chartPane, panes)) {
                 charts[i].reflow(box);
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.reflowPanes = function reflowPanes () {
-        var ref = this;
-        var box = ref.box;
-        var panes = ref.panes;
-        var panesLength = panes.length;
-        var remainingHeight = box.height();
-        var autoHeightPanes = 0;
-        var top = box.y1;
+    reflowPanes() {
+        const { box, panes } = this;
+        const panesLength = panes.length;
+        let remainingHeight = box.height();
+        let autoHeightPanes = 0;
+        let top = box.y1;
 
-        for (var i = 0; i < panesLength; i++) {
-            var currentPane = panes[i];
-            var height = currentPane.options.height;
+        for (let i = 0; i < panesLength; i++) {
+            const currentPane = panes[i];
+            const height = currentPane.options.height;
 
             currentPane.options.width = box.width();
 
@@ -729,7 +703,7 @@ var PlotAreaBase = (function (ChartElement) {
                 autoHeightPanes++;
             } else {
                 if (height.indexOf && height.indexOf("%")) {
-                    var percents = parseInt(height, 10) / 100;
+                    const percents = parseInt(height, 10) / 100;
                     currentPane.options.height = percents * box.height();
                 }
 
@@ -739,39 +713,39 @@ var PlotAreaBase = (function (ChartElement) {
             }
         }
 
-        for (var i$1 = 0; i$1 < panesLength; i$1++) {
-            var currentPane$1 = panes[i$1];
+        for (let i = 0; i < panesLength; i++) {
+            const currentPane = panes[i];
 
-            if (!currentPane$1.options.height) {
-                currentPane$1.options.height = remainingHeight / autoHeightPanes;
+            if (!currentPane.options.height) {
+                currentPane.options.height = remainingHeight / autoHeightPanes;
             }
         }
 
-        for (var i$2 = 0; i$2 < panesLength; i$2++) {
-            var currentPane$2 = panes[i$2];
-            var paneBox = box
+        for (let i = 0; i < panesLength; i++) {
+            const currentPane = panes[i];
+            const paneBox = box
                 .clone()
                 .move(box.x1, top);
 
-            currentPane$2.reflow(paneBox);
+            currentPane.reflow(paneBox);
 
-            top += currentPane$2.options.height;
+            top += currentPane.options.height;
         }
-    };
+    }
 
-    PlotAreaBase.prototype.backgroundBox = function backgroundBox () {
-        var axes = this.axes;
-        var axesCount = axes.length;
-        var box;
+    backgroundBox() {
+        const axes = this.axes;
+        const axesCount = axes.length;
+        let box;
 
-        for (var i = 0; i < axesCount; i++) {
-            var axisA = axes[i];
+        for (let i = 0; i < axesCount; i++) {
+            const axisA = axes[i];
 
-            for (var j = 0; j < axesCount; j++) {
-                var axisB = axes[j];
+            for (let j = 0; j < axesCount; j++) {
+                const axisB = axes[j];
 
                 if (axisA.options.vertical !== axisB.options.vertical) {
-                    var lineBox = axisA.lineBox().clone().wrap(axisB.lineBox());
+                    const lineBox = axisA.lineBox().clone().wrap(axisB.lineBox());
 
                     if (!box) {
                         box = lineBox;
@@ -783,48 +757,46 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         return box || this.box;
-    };
+    }
 
-    PlotAreaBase.prototype.chartsBoxes = function chartsBoxes () {
-        var panes = this.panes;
-        var boxes = [];
+    chartsBoxes() {
+        const panes = this.panes;
+        const boxes = [];
 
-        for (var idx = 0; idx < panes.length; idx++) {
+        for (let idx = 0; idx < panes.length; idx++) {
             boxes.push(panes[idx].chartsBox());
         }
 
         return boxes;
-    };
+    }
 
-    PlotAreaBase.prototype.addBackgroundPaths = function addBackgroundPaths (multipath) {
-        var boxes = this.chartsBoxes();
-        for (var idx = 0; idx < boxes.length; idx++) {
+    addBackgroundPaths(multipath) {
+        const boxes = this.chartsBoxes();
+        for (let idx = 0; idx < boxes.length; idx++) {
             multipath.paths.push(draw.Path.fromRect(boxes[idx].toRect()));
         }
-    };
+    }
 
-    PlotAreaBase.prototype.backgroundContainsPoint = function backgroundContainsPoint (point) {
-        var boxes = this.chartsBoxes();
-        for (var idx = 0; idx < boxes.length; idx++) {
+    backgroundContainsPoint(point) {
+        const boxes = this.chartsBoxes();
+        for (let idx = 0; idx < boxes.length; idx++) {
             if (boxes[idx].containsPoint(point)) {
                 return true;
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.createVisual = function createVisual () {
-        ChartElement.prototype.createVisual.call(this);
+    createVisual() {
+        super.createVisual();
 
-        var options = this.options.plotArea;
-        var opacity = options.opacity;
-        var background = options.background;
-        var border = options.border; if ( border === void 0 ) border = {};
+        const options = this.options.plotArea;
+        let { opacity, background, border = {} } = options;
         if (isTransparent(background)) {
             background = WHITE;
             opacity = 0;
         }
 
-        var bg = this._bgVisual = new draw.MultiPath({
+        const bg = this._bgVisual = new draw.MultiPath({
             fill: {
                 color: background,
                 opacity: opacity
@@ -840,24 +812,24 @@ var PlotAreaBase = (function (ChartElement) {
         this.addBackgroundPaths(bg);
 
         this.appendVisual(bg);
-    };
+    }
 
-    PlotAreaBase.prototype.pointsByCategoryIndex = function pointsByCategoryIndex (categoryIndex) {
-        var charts = this.charts;
-        var result = [];
+    pointsByCategoryIndex(categoryIndex) {
+        const charts = this.charts;
+        const result = [];
 
         if (categoryIndex !== null) {
-            for (var i = 0; i < charts.length; i++) {
-                var chart = charts[i];
+            for (let i = 0; i < charts.length; i++) {
+                const chart = charts[i];
 
                 if (chart.pane.options.name === "_navigator") {
                     continue;
                 }
 
-                var points = charts[i].categoryPoints[categoryIndex];
+                const points = charts[i].categoryPoints[categoryIndex];
                 if (points && points.length) {
-                    for (var j = 0; j < points.length; j++) {
-                        var point = points[j];
+                    for (let j = 0; j < points.length; j++) {
+                        const point = points[j];
                         if (point && defined(point.value) && point.value !== null) {
                             result.push(point);
                         }
@@ -867,35 +839,35 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         return result;
-    };
+    }
 
-    PlotAreaBase.prototype.pointsBySeriesIndex = function pointsBySeriesIndex (seriesIndex) {
+    pointsBySeriesIndex(seriesIndex) {
         return this.filterPoints(function(point) {
             return point.series.index === seriesIndex;
         });
-    };
+    }
 
-    PlotAreaBase.prototype.pointsByPointIndex = function pointsByPointIndex (pointIndex) {
+    pointsByPointIndex(pointIndex) {
         return this.filterPoints(function(point) {
             return point.getIndex() === pointIndex;
         });
-    };
+    }
 
-    PlotAreaBase.prototype.pointsBySeriesName = function pointsBySeriesName (name) {
+    pointsBySeriesName(name) {
         return this.filterPoints(function(point) {
             return point.series.name === name;
         });
-    };
+    }
 
-    PlotAreaBase.prototype.filterPoints = function filterPoints (callback) {
-        var charts = this.charts;
-        var result = [];
+    filterPoints(callback) {
+        const charts = this.charts;
+        const result = [];
 
-        for (var i = 0; i < charts.length; i++) {
-            var chart = charts[i];
-            var points = chart.points;
-            for (var j = 0; j < points.length; j++) {
-                var point = points[j];
+        for (let i = 0; i < charts.length; i++) {
+            const chart = charts[i];
+            const points = chart.points;
+            for (let j = 0; j < points.length; j++) {
+                const point = points[j];
                 if (point && point.visible !== false && callback(point)) {
                     result.push(point);
                 }
@@ -903,81 +875,79 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         return result;
-    };
+    }
 
-    PlotAreaBase.prototype.findPoint = function findPoint (callback) {
-        var charts = this.charts;
+    findPoint(callback) {
+        const charts = this.charts;
 
-        for (var i = 0; i < charts.length; i++) {
-            var chart = charts[i];
-            var points = chart.points;
-            for (var j = 0; j < points.length; j++) {
-                var point = points[j];
+        for (let i = 0; i < charts.length; i++) {
+            const chart = charts[i];
+            const points = chart.points;
+            for (let j = 0; j < points.length; j++) {
+                const point = points[j];
                 if (point && point.visible !== false && callback(point)) {
                     return point;
                 }
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.paneByPoint = function paneByPoint (point) {
-        var panes = this.panes;
+    paneByPoint(point) {
+        const panes = this.panes;
 
-        for (var i = 0; i < panes.length; i++) {
-            var pane = panes[i];
+        for (let i = 0; i < panes.length; i++) {
+            const pane = panes[i];
             if (pane.box.containsPoint(point)) {
                 return pane;
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.detachLabels = function detachLabels () {
-        var axes = this.groupAxes(this.panes);
-        var xAxes = axes.x;
-        var yAxes = axes.y;
+    detachLabels() {
+        const axes = this.groupAxes(this.panes);
+        const xAxes = axes.x;
+        const yAxes = axes.y;
 
         this.detachAxisGroupLabels(yAxes, xAxes);
         this.detachAxisGroupLabels(xAxes, yAxes);
-    };
-
-    PlotAreaBase.prototype.detachAxisGroupLabels = function detachAxisGroupLabels (axes, crossingAxes) {
-        var this$1 = this;
+    }
 
-        var labelAxisCount = 0;
+    detachAxisGroupLabels(axes, crossingAxes) {
+        let labelAxisCount = 0;
 
-        for (var i = 0; i < axes.length; i++) {
-            var axis = axes[i];
-            var pane = axis.pane;
-            var anchor = paneAnchor(crossingAxes, pane) || crossingAxes[0];
-            var axisIndex = i + labelAxisCount;
-            var labelAxis = this$1.createLabelAxis(axis, axisIndex, anchor);
+        for (let i = 0; i < axes.length; i++) {
+            const axis = axes[i];
+            const pane = axis.pane;
+            const anchor = paneAnchor(crossingAxes, pane) || crossingAxes[0];
+            const axisIndex = i + labelAxisCount;
+            const labelAxis = this.createLabelAxis(axis, axisIndex, anchor);
 
             if (labelAxis) {
                 labelAxisCount++;
 
-                var pos = pane.axes.indexOf(axis) + labelAxisCount;
+                const pos = pane.axes.indexOf(axis) + labelAxisCount;
                 pane.appendAxisAt(labelAxis, pos);
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.createLabelAxis = function createLabelAxis (axis, axisIndex, anchor) {
-        var labelOptions = axis.options.labels;
-        var position = labelOptions.position;
-        var onAxis = position !== END && position !== START;
-        var visible = labelOptions.visible;
+    createLabelAxis(axis, axisIndex, anchor) {
+        const labelOptions = axis.options.labels;
+        const position = labelOptions.position;
+        const onAxis = position !== END && position !== START;
+        const visible = labelOptions.visible;
 
         if (onAxis || visible === false) {
             return null;
         }
 
-        var allAxes = this.groupAxes(this.panes);
-        var crossingAxes = anchor.options.vertical ? allAxes.x : allAxes.y;
-        var anchorCrossings = this.axisCrossingValues(anchor, crossingAxes);
-        var end = position === END;
-        var range = anchor.range();
-        var edge = end ? range.max : range.min;
-        var crossingValue = limitValue(anchorCrossings[axisIndex], range.min, range.max);
+        const allAxes = this.groupAxes(this.panes);
+        const crossingAxes = anchor.options.vertical ? allAxes.x : allAxes.y;
+        const anchorCrossings = this.axisCrossingValues(anchor, crossingAxes);
+        const end = position === END;
+        const range = anchor.range();
+        const edge = end ? range.max : range.min;
+        const crossingValue = limitValue(anchorCrossings[axisIndex], range.min, range.max);
 
         if (crossingValue - edge === 0) {
             return null;
@@ -986,7 +956,7 @@ var PlotAreaBase = (function (ChartElement) {
         anchorCrossings.splice(axisIndex + 1, 0, edge);
         anchor.options.axisCrossingValues = anchorCrossings;
 
-        var labelAxis = axis.clone();
+        const labelAxis = axis.clone();
         axis.clear();
 
         labelAxis.options.name = undefined;
@@ -997,34 +967,32 @@ var PlotAreaBase = (function (ChartElement) {
         labelAxis.options.plotBands = undefined;
 
         return labelAxis;
-    };
+    }
 
-    PlotAreaBase.prototype.isTrendline = function isTrendline (series) {
+    isTrendline(series) {
         return series && inArray(series.type, TRENDLINE_SERIES);
-    };
-
-    PlotAreaBase.prototype.trendlineFactory = function trendlineFactory () { /* abstract */ };
+    }
 
-    PlotAreaBase.prototype.createTrendlineSeries = function createTrendlineSeries () {
-        var this$1 = this;
+    trendlineFactory() { /* abstract */ }
 
-        var modifiedSeries = [];
+    createTrendlineSeries() {
+        const modifiedSeries = [];
 
-        this.series = this.series.map(function (series) {
-            if (!this$1.isTrendline(series)) {
+        this.series = this.series.map(series => {
+            if (!this.isTrendline(series)) {
                 return series;
             }
 
-            var forSeries = this$1.seriesByName(series.for);
+            const forSeries = this.seriesByName(series.for);
             if (!forSeries) {
                 throw new Error('Invalid Configuration: Unable to locate linked series ' +
-                    "\"" + (series.for) + "\" for trendline \"" + (series.name) + "\".");
+                    `"${series.for}" for trendline "${series.name}".`);
             }
 
-            var valueFields = SeriesBinder.current.valueFields(forSeries);
-            var field = last(valueFields); // Use the last field for multi-field series
+            const valueFields = SeriesBinder.current.valueFields(forSeries);
+            const field = last(valueFields); // Use the last field for multi-field series
 
-            var trendlineSeries = this$1.trendlineFactory(Object.assign({}, {field: field}, series), forSeries);
+            const trendlineSeries = this.trendlineFactory(Object.assign({}, {field}, series), forSeries);
             if (trendlineSeries) {
                 if (forSeries.visible === false) {
                     trendlineSeries.visible = false;
@@ -1038,56 +1006,52 @@ var PlotAreaBase = (function (ChartElement) {
             }
 
             return trendlineSeries;
-        }).filter(function (series) { return series !== null; });
+        }).filter(series => series !== null);
 
         return modifiedSeries;
-    };
-
-    PlotAreaBase.prototype.seriesByName = function seriesByName (name) {
-        return this.series.find(function (series) { return series.name === name; });
-    };
+    }
 
-    PlotAreaBase.prototype.getFirstPoint = function getFirstPoint () {
-        var this$1 = this;
+    seriesByName(name) {
+        return this.series.find(series => series.name === name);
+    }
 
-        for (var i = 0; i < this.series.length; i++) {
-            var points = this$1.pointsBySeriesIndex(i);
-            var point = points.find(visiblePoint);
+    getFirstPoint() {
+        for (let i = 0; i < this.series.length; i++) {
+            const points = this.pointsBySeriesIndex(i);
+            const point = points.find(visiblePoint);
             if (point) {
                 return point;
             }
         }
-    };
+    }
 
-    PlotAreaBase.prototype.getPointBelow = function getPointBelow (point) {
+    getPointBelow(point) {
         return this._getNextPoint(point, this._pointsByVertical, 1);
-    };
+    }
 
-    PlotAreaBase.prototype.getPointAbove = function getPointAbove (point) {
+    getPointAbove(point) {
         return this._getNextPoint(point, this._pointsByVertical, -1);
-    };
+    }
 
-    PlotAreaBase.prototype.getPointToTheRight = function getPointToTheRight (point) {
+    getPointToTheRight(point) {
         return this._getNextPoint(point, this._pointsByHorizontal, 1);
-    };
+    }
 
-    PlotAreaBase.prototype.getPointToTheLeft = function getPointToTheLeft (point) {
+    getPointToTheLeft(point) {
         return this._getNextPoint(point, this._pointsByHorizontal, -1);
-    };
-
-    PlotAreaBase.prototype._getNextPoint = function _getNextPoint (point, getPointsFunc, increment) {
-        var this$1 = this;
+    }
 
-        var points = getPointsFunc.call(this, point).filter(visiblePoint);
-        var pointIndex = points.indexOf(point);
-        var nextIndex = pointIndex + increment;
-        var loopPoints = function (direction) {
+    _getNextPoint(point, getPointsFunc, increment) {
+        let points = getPointsFunc.call(this, point).filter(visiblePoint);
+        const pointIndex = points.indexOf(point);
+        let nextIndex = pointIndex + increment;
+        const loopPoints = (direction) => {
             // loop over to last non-empty collection
-            var result;
-            var offset = 0;
+            let result;
+            let offset = 0;
             do {
                 offset += direction;
-                result = getPointsFunc.call(this$1, point, offset).filter(visiblePoint);
+                result = getPointsFunc.call(this, point, offset).filter(visiblePoint);
             } while (result.length === 0);
 
             return result;
@@ -1104,36 +1068,33 @@ var PlotAreaBase = (function (ChartElement) {
         }
 
         return points[nextIndex];
-    };
+    }
 
-    PlotAreaBase.prototype._pointsByVertical = function _pointsByVertical (basePoint) {
+    _pointsByVertical(basePoint) {
         return this.pointsByPointIndex(basePoint.getIndex());
-    };
-
-    PlotAreaBase.prototype._pointsByHorizontal = function _pointsByHorizontal (basePoint, offset) {
-        if ( offset === void 0 ) offset = 0;
+    }
 
-        var index = cycleIndex(basePoint.series.index + offset, this.series.length);
+    _pointsByHorizontal(basePoint, offset = 0) {
+        let index = cycleIndex(basePoint.series.index + offset, this.series.length);
         return this.pointsBySeriesIndex(index);
-    };
-
-    return PlotAreaBase;
-}(ChartElement));
+    }
+}
 
 function isSingleAxis(axis) {
-    return !axis.pane.axes.some(function (a) { return a.options.vertical === axis.options.vertical && a !== axis && a.options.visible !== false; }
+    return !axis.pane.axes.some((a) =>
+        a.options.vertical === axis.options.vertical && a !== axis && a.options.visible !== false
     );
 }
 
 function axisGroupBox(axes) {
-    var length = axes.length;
-    var box;
+    const length = axes.length;
+    let box;
 
-    for (var i = 0; i < length; i++) {
-        var axis = axes[i];
-        var visible = axis.options.visible !== false;
+    for (let i = 0; i < length; i++) {
+        const axis = axes[i];
+        const visible = axis.options.visible !== false;
         if (visible || isSingleAxis(axis)) {
-            var axisBox = visible ? axis.contentBox() : axis.lineBox();
+            const axisBox = visible ? axis.contentBox() : axis.lineBox();
 
             if (!box) {
                 box = axisBox.clone();
@@ -1147,8 +1108,8 @@ function axisGroupBox(axes) {
 }
 
 function paneAnchor(axes, pane) {
-    for (var i = 0; i < axes.length; i++) {
-        var anchor = axes[i];
+    for (let i = 0; i < axes.length; i++) {
+        const anchor = axes[i];
         if (anchor && anchor.pane === pane) {
             return anchor;
         }
@@ -1159,7 +1120,7 @@ function isTransparent(color) {
     return color === "" || color === null || color === "none" || color === "transparent" || !defined(color);
 }
 
-var allPaneAxes = function (panes) { return panes.reduce(function (acc, pane) { return acc.concat(pane.axes); }, []); };
+const allPaneAxes = (panes) => panes.reduce((acc, pane) => acc.concat(pane.axes), []);
 
 setDefaultOptions(PlotAreaBase, {
     series: [],