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

package/dist/es/chart/chart.js

@@ -33,24 +33,21 @@ import './animations';
 import './register-charts';
 import { parseDateCategory } from './utils';
 
-var AXIS_NAMES = [ CATEGORY, VALUE, X, Y ];
-
-var MOUSEDOWN = "mousedown";
-var MOUSEMOVE = "mousemove";
-var CONTEXTMENU = "contextmenu";
-var MOUSELEAVE = "mouseleave";
-var KEYDOWN = "keydown";
-var FOCUS = "focus";
-var BLUR = "blur";
-var MOUSEMOVE_DELAY = 20;
-var NO_DATA_OVERLAY_TOP_CLASS = "k-chart-overlay-top";
-
-var Chart = (function (Class) {
-    function Chart(element, userOptions, themeOptions, context) {
-        var this$1 = this;
-        if ( context === void 0 ) context = {};
-
-        Class.call(this);
+const AXIS_NAMES = [ CATEGORY, VALUE, X, Y ];
+
+const MOUSEDOWN = "mousedown";
+const MOUSEMOVE = "mousemove";
+const CONTEXTMENU = "contextmenu";
+const MOUSELEAVE = "mouseleave";
+const KEYDOWN = "keydown";
+const FOCUS = "focus";
+const BLUR = "blur";
+const MOUSEMOVE_DELAY = 20;
+const NO_DATA_OVERLAY_TOP_CLASS = "k-chart-overlay-top";
+
+class Chart extends Class {
+    constructor(element, userOptions, themeOptions, context = {}) {
+        super();
 
         this.observers = [];
         this.addObserver(context.observer);
@@ -59,7 +56,7 @@ var Chart = (function (Class) {
 
         this._initElement(element);
 
-        var options = deepExtend({}, this.options, userOptions);
+        const options = deepExtend({}, this.options, userOptions);
         this._originalOptions = deepExtend({}, options);
         this._theme = themeOptions;
         this._initTheme(options, themeOptions);
@@ -69,32 +66,26 @@ var Chart = (function (Class) {
         this._initSurface();
 
         this.bindCategories();
-        FontLoader.preloadFonts(userOptions, function () {
-            this$1.fontLoaded = true;
-            if (!this$1._destroyed) {
-                this$1.trigger('init');
-                this$1._redraw();
-                this$1._attachEvents();
-                this$1._restoreOverlayElement();
+        FontLoader.preloadFonts(userOptions, () => {
+            this.fontLoaded = true;
+            if (!this._destroyed) {
+                this.trigger('init');
+                this._redraw();
+                this._attachEvents();
+                this._restoreOverlayElement();
             }
         });
     }
 
-    if ( Class ) Chart.__proto__ = Class;
-    Chart.prototype = Object.create( Class && Class.prototype );
-    Chart.prototype.constructor = Chart;
-
-    Chart.prototype._initElement = function _initElement (element) {
-        var this$1 = this;
-
+    _initElement(element) {
         this._setElementClass(element);
         element.style.position = "relative";
         element.tabIndex = element.getAttribute("tabindex") ? element.getAttribute("tabindex") : 0;
         // To support user agents and assistive technologies based on the ARIA 1.0 specification, authors may wish to include the document role as a fallback value, in the form role="graphics-document document".
         element.setAttribute("role", "graphics-document document");
 
-        for (var i = element.childNodes.length - 1; i >= 0; i--) {
-            var child = element.childNodes[i];
+        for (let i = element.childNodes.length - 1; i >= 0; i--) {
+            const child = element.childNodes[i];
 
             if (!hasClasses(child, "k-chart-overlay")) {
                 element.removeChild(child);
@@ -102,18 +93,18 @@ var Chart = (function (Class) {
                 // this is necessary if the overlay is rendered server-side, e.g. in blazor
                 // but drawing the surface clears the contents of the element
                 // and thus the no data overlay is lost
-                this$1.overlayElement = child;
+                this.overlayElement = child;
             }
         }
 
         this.element = element;
-    };
+    }
 
-    Chart.prototype._setElementClass = function _setElementClass (element) {
+    _setElementClass(element) {
         addClass(element, "k-chart");
-    };
+    }
 
-    Chart.prototype._restoreOverlayElement = function _restoreOverlayElement () {
+    _restoreOverlayElement() {
         if (!this.overlayElement) {
             return;
         }
@@ -133,19 +124,19 @@ var Chart = (function (Class) {
         if (this.overlayElement.parentElement !== this.element) {
             this.element.appendChild(this.overlayElement);
         }
-    };
+    }
 
-    Chart.prototype._hasSeriesData = function _hasSeriesData () {
-        var series = this.options.series || [];
-        var hasData = series.length > 0 && series.some(function (x) { return x.data && x.data.length > 0; });
+    _hasSeriesData() {
+        const series = this.options.series || [];
+        const hasData = series.length > 0 && series.some(x => x.data && x.data.length > 0);
         return hasData;
-    };
+    }
 
-    Chart.prototype._initTheme = function _initTheme (options, themeOptions) {
-        var seriesCopies = [];
-        var series = options.series || [];
+    _initTheme(options, themeOptions) {
+        const seriesCopies = [];
+        const series = options.series || [];
 
-        for (var i = 0; i < series.length; i++) {
+        for (let i = 0; i < series.length; i++) {
             seriesCopies.push(Object.assign({}, series[i]));
         }
         options.series = seriesCopies;
@@ -164,89 +155,89 @@ var Chart = (function (Class) {
 
         this.options = deepExtend({}, themeOptions, options);
         this.applySeriesColors();
-    };
+    }
 
-    Chart.prototype.getSize = function getSize () {
-        var chartArea = this.options.chartArea || {};
-        var width = chartArea.width ? parseInt(chartArea.width, 10) : Math.floor(this.element.offsetWidth);
-        var height = chartArea.height ? parseInt(chartArea.height, 10) : Math.floor(this.element.offsetHeight);
+    getSize() {
+        const chartArea = this.options.chartArea || {};
+        const width = chartArea.width ? parseInt(chartArea.width, 10) : Math.floor(this.element.offsetWidth);
+        const height = chartArea.height ? parseInt(chartArea.height, 10) : Math.floor(this.element.offsetHeight);
 
         return {
             width: width,
             height: height
         };
-    };
+    }
 
-    Chart.prototype.resize = function resize (force) {
-        var size = this.getSize();
-        var currentSize = this._size;
-        var hasSize = size.width > 0 || size.height > 0;
+    resize(force) {
+        const size = this.getSize();
+        const currentSize = this._size;
+        const hasSize = size.width > 0 || size.height > 0;
 
         if (force || hasSize && (!currentSize || size.width !== currentSize.width || size.height !== currentSize.height)) {
             this._size = size;
             this._resize(size, force);
             this.trigger("resize", size);
-        } else if (hasSize && this._selections && find(this._selections, function (s) { return !s.visible; })) {
+        } else if (hasSize && this._selections && find(this._selections, s => !s.visible)) {
             this._destroySelections();
             this._setupSelection();
         }
-    };
+    }
 
-    Chart.prototype._resize = function _resize () {
+    _resize() {
         this._noTransitionsRedraw();
-    };
+    }
 
-    Chart.prototype.redraw = function redraw (paneName) {
+    redraw(paneName) {
         this.applyDefaults(this.options);
         this.applySeriesColors();
 
         if (paneName) {
-            var plotArea = this._model._plotArea;
-            var pane = plotArea.findPane(paneName);
+            const plotArea = this._model._plotArea;
+            const pane = plotArea.findPane(paneName);
             plotArea.redraw(pane);
         } else {
             this._redraw();
         }
-    };
+    }
 
-    Chart.prototype.getAxis = function getAxis (name) {
+    getAxis(name) {
         return findAxisByName(name, this._plotArea.axes);
-    };
+    }
 
-    Chart.prototype.findAxisByName = function findAxisByName (name) {
+    findAxisByName(name) {
         return this.getAxis(name);
-    };
+    }
 
-    Chart.prototype.findPaneByName = function findPaneByName (name) {
-        var panes = this._plotArea.panes;
+    findPaneByName(name) {
+        const panes = this._plotArea.panes;
 
-        for (var idx = 0; idx < panes.length; idx++) {
+        for (let idx = 0; idx < panes.length; idx++) {
             if (panes[idx].options.name === name) {
                 return new ChartPane(panes[idx]);
             }
         }
-    };
+    }
 
-    Chart.prototype.findPaneByIndex = function findPaneByIndex (idx) {
-        var panes = this._plotArea.panes;
+    findPaneByIndex(idx) {
+        const panes = this._plotArea.panes;
         if (panes[idx]) {
             return new ChartPane(panes[idx]);
         }
-    };
+    }
 
-    Chart.prototype.plotArea = function plotArea () {
+    plotArea() {
         return new ChartPlotArea(this._plotArea);
-    };
+    }
 
-    Chart.prototype.toggleHighlight = function toggleHighlight (show, filter) {
-        var plotArea = this._plotArea;
-        var firstSeries = (plotArea.srcSeries || plotArea.series || [])[0];
-        var points;
+    toggleHighlight(show, filter) {
+        const plotArea = this._plotArea;
+        const firstSeries = (plotArea.srcSeries || plotArea.series || [])[0];
+        let points;
 
         if (isFunction(filter)) {
             points = plotArea.filterPoints(filter);
         } else {
-            var seriesName, categoryName;
+            let seriesName, categoryName;
             if (isObject(filter)) {
                 seriesName = filter.series;
                 categoryName = filter.category;
@@ -266,21 +257,19 @@ var Chart = (function (Class) {
         if (points) {
             this.togglePointsHighlight(show, points);
         }
-    };
+    }
 
-    Chart.prototype.togglePointsHighlight = function togglePointsHighlight (show, points) {
-        var highlight = this._highlight;
-        for (var idx = 0; idx < points.length; idx++) {
+    togglePointsHighlight(show, points) {
+        const highlight = this._highlight;
+        for (let idx = 0; idx < points.length; idx++) {
             highlight.togglePointHighlight(points[idx], show);
         }
-    };
+    }
 
-    Chart.prototype.showTooltip = function showTooltip (filter) {
-        var shared = this._sharedTooltip();
-        var ref = this;
-        var tooltip = ref._tooltip;
-        var plotArea = ref._plotArea;
-        var point, categoryIndex;
+    showTooltip(filter) {
+        const shared = this._sharedTooltip();
+        const { _tooltip: tooltip, _plotArea: plotArea } = this;
+        let point, categoryIndex;
 
         if (isFunction(filter)) {
             point = plotArea.findPoint(filter);
@@ -293,23 +282,23 @@ var Chart = (function (Class) {
 
         if (shared) {
             if (categoryIndex >= 0) {
-                var points = this._plotArea.pointsByCategoryIndex(categoryIndex);
+                const points = this._plotArea.pointsByCategoryIndex(categoryIndex);
                 tooltip.showAt(points);
             }
         } else if (point) {
             tooltip.show(point);
         }
-    };
+    }
 
-    Chart.prototype.hideTooltip = function hideTooltip () {
+    hideTooltip() {
         this._tooltip.hide();
-    };
+    }
 
-    Chart.prototype._initSurface = function _initSurface () {
-        var surface = this.surface;
-        var wrap = this._surfaceWrap();
+    _initSurface() {
+        const surface = this.surface;
+        const wrap = this._surfaceWrap();
 
-        var chartArea = this.options.chartArea || {};
+        const chartArea = this.options.chartArea || {};
         if (chartArea.width) {
             elementSize(wrap, { width: chartArea.width });
         }
@@ -334,14 +323,14 @@ var Chart = (function (Class) {
 
         // Override the surface _kendoExportVisual in order to accept export options with size.
         this.element._kendoExportVisual = this._kendoExportVisual.bind(this);
-    };
+    }
 
-    Chart.prototype._surfaceWrap = function _surfaceWrap () {
+    _surfaceWrap() {
         return this.element;
-    };
+    }
 
-    Chart.prototype._redraw = function _redraw () {
-        var model = this._getModel();
+    _redraw() {
+        const model = this._getModel();
         this._size = {
             width: model.options.width,
             height: model.options.height
@@ -392,42 +381,39 @@ var Chart = (function (Class) {
         }
 
         this._redrawFocusHighlight();
-    };
+    }
 
-    Chart.prototype._setComputedStyles = function _setComputedStyles () {
-        var titleHeight = this.titleHeight();
-        this.element.style.setProperty('--kendo-chart-computed-title-height', (titleHeight + "px"));
-    };
+    _setComputedStyles() {
+        const titleHeight = this.titleHeight();
+        this.element.style.setProperty('--kendo-chart-computed-title-height', `${titleHeight}px`);
+    }
 
-    Chart.prototype._redrawFocusHighlight = function _redrawFocusHighlight () {
+    _redrawFocusHighlight() {
         if (this._destroyed) {
             return;
         }
 
-        var ref = this;
-        var ref_focusState = ref._focusState;
-        var legendInFocus = ref_focusState.legendInFocus;
-        var preserveHighlight = ref_focusState.preserveHighlight;
+        const { _focusState: { legendInFocus, preserveHighlight } } = this;
 
         if (legendInFocus && preserveHighlight) {
             this._focusElement(this._getFocusedLegendItem(), false);
             this._focusState.preserveHighlight = false;
         }
-    };
+    }
 
-    Chart.prototype._setElementAccessibilityAttributes = function _setElementAccessibilityAttributes () {
-        var titleOptions = this.options.title;
-        var title = isString(titleOptions) ? titleOptions : (titleOptions.description || titleOptions.text);
+    _setElementAccessibilityAttributes() {
+        let titleOptions = this.options.title;
+        let title = isString(titleOptions) ? titleOptions : (titleOptions.description || titleOptions.text);
 
         if (title) {
             this.element.setAttribute("aria-roledescription", title);
         }
-    };
+    }
 
-    Chart.prototype._kendoExportVisual = function _kendoExportVisual (size) {
+    _kendoExportVisual(size) {
         if (size && size.width && size.height) {
-            var chartArea = this._originalOptions.chartArea || {};
-            var exportOptions = {
+            const chartArea = this._originalOptions.chartArea || {};
+            const exportOptions = {
                 width: chartArea.width || size.width,
                 height: chartArea.height || size.height
             };
@@ -436,13 +422,13 @@ var Chart = (function (Class) {
         }
 
         return this.exportVisual();
-    };
+    }
 
-    Chart.prototype.exportVisual = function exportVisual (exportOptions) {
-        var visual;
+    exportVisual(exportOptions) {
+        let visual;
         if (exportOptions && (exportOptions.width || exportOptions.height || exportOptions.options)) {
-            var currentOptions = this.options;
-            var options = deepExtend({}, exportOptions.options, {
+            const currentOptions = this.options;
+            const options = deepExtend({}, exportOptions.options, {
                 chartArea: {
                     width: exportOptions.width,
                     height: exportOptions.height
@@ -454,7 +440,7 @@ var Chart = (function (Class) {
             this._initTheme(this.options, this._theme);
             this.bindCategories();
 
-            var model = this._getModel();
+            const model = this._getModel();
 
             model.renderVisual();
             triggerPaneRender(model._plotArea.panes);
@@ -467,43 +453,43 @@ var Chart = (function (Class) {
         }
 
         return visual;
-    };
+    }
 
-    Chart.prototype._sharedTooltip = function _sharedTooltip () {
+    _sharedTooltip() {
         return this._plotArea instanceof CategoricalPlotArea && this.options.tooltip && this.options.tooltip.shared;
-    };
+    }
 
-    Chart.prototype._createPannable = function _createPannable () {
-        var options = this.options;
+    _createPannable() {
+        const options = this.options;
         if (options.pannable !== false) {
             this._pannable = new Pannable(this._plotArea, options.pannable);
         }
-    };
+    }
 
-    Chart.prototype._createZoomSelection = function _createZoomSelection () {
-        var zoomable = this.options.zoomable;
-        var selection = (zoomable || {}).selection;
+    _createZoomSelection() {
+        const zoomable = this.options.zoomable;
+        const selection = (zoomable || {}).selection;
         if (zoomable !== false && selection !== false) {
             this._zoomSelection = new ZoomSelection(this, selection);
         }
-    };
+    }
 
-    Chart.prototype._createMousewheelZoom = function _createMousewheelZoom () {
-        var zoomable = this.options.zoomable;
-        var mousewheel = (zoomable || {}).mousewheel;
+    _createMousewheelZoom() {
+        const zoomable = this.options.zoomable;
+        const mousewheel = (zoomable || {}).mousewheel;
         if (zoomable !== false && mousewheel !== false) {
             this._mousewheelZoom = new MousewheelZoom(this, mousewheel);
         }
-    };
+    }
 
-    Chart.prototype._toggleDragZoomEvents = function _toggleDragZoomEvents () {
-        var pannable = this.options.pannable;
-        var zoomable = this.options.zoomable;
-        var selection = (zoomable || {}).selection;
-        var mousewheel = (zoomable || {}).mousewheel;
-        var allowDrag = !pannable && (zoomable === false || selection === false) && !this.requiresHandlers([ DRAG_START, DRAG, DRAG_END ]);
-        var allowZoom = (zoomable === false || mousewheel === false) && !this.requiresHandlers([ ZOOM_START, ZOOM, ZOOM_END ]);
-        var element = this.element;
+    _toggleDragZoomEvents() {
+        const pannable = this.options.pannable;
+        const zoomable = this.options.zoomable;
+        const selection = (zoomable || {}).selection;
+        const mousewheel = (zoomable || {}).mousewheel;
+        const allowDrag = !pannable && (zoomable === false || selection === false) && !this.requiresHandlers([ DRAG_START, DRAG, DRAG_END ]);
+        const allowZoom = (zoomable === false || mousewheel === false) && !this.requiresHandlers([ ZOOM_START, ZOOM, ZOOM_END ]);
+        const element = this.element;
 
         if (this._dragZoomEnabled && allowDrag && allowZoom) {
             element.style.touchAction = this._touchAction || '';
@@ -515,10 +501,10 @@ var Chart = (function (Class) {
         }
 
         this._toggleDomEvents(!allowDrag, !allowZoom);
-    };
+    }
 
-    Chart.prototype._toggleDomEvents = function _toggleDomEvents (drag, zoom) {
-        var domEvents = this.domEvents;
+    _toggleDomEvents(drag, zoom) {
+        const domEvents = this.domEvents;
         if (!domEvents) {
             return;
         }
@@ -530,12 +516,11 @@ var Chart = (function (Class) {
         if (domEvents.toggleZoom) {
             domEvents.toggleZoom(zoom);
         }
-    };
+    }
 
-    Chart.prototype._createTooltip = function _createTooltip () {
-        var ref = this;
-        var tooltipOptions = ref.options.tooltip;
-        var tooltip;
+    _createTooltip() {
+        const { options: { tooltip: tooltipOptions } } = this;
+        let tooltip;
 
         if (this._sharedTooltip()) {
             tooltip = this._createSharedTooltip(tooltipOptions);
@@ -544,50 +529,50 @@ var Chart = (function (Class) {
         }
 
         return tooltip;
-    };
+    }
 
-    Chart.prototype._createSharedTooltip = function _createSharedTooltip (options) {
+    _createSharedTooltip(options) {
         return new SharedTooltip(this._plotArea, options);
-    };
+    }
 
-    Chart.prototype.applyDefaults = function applyDefaults (options, themeOptions) {
+    applyDefaults(options, themeOptions) {
         applyAxisDefaults(options, themeOptions);
         applySeriesDefaults(options, themeOptions);
-    };
+    }
 
-    Chart.prototype.applySeriesColors = function applySeriesColors () {
-        var options = this.options;
-        var series = options.series;
-        var colors = options.seriesColors || [];
+    applySeriesColors() {
+        const options = this.options;
+        const series = options.series;
+        const colors = options.seriesColors || [];
 
-        for (var i = 0; i < series.length; i++) {
-            var currentSeries = series[i];
-            var seriesColor = colors[i % colors.length];
-            var defaults = currentSeries._defaults;
+        for (let i = 0; i < series.length; i++) {
+            const currentSeries = series[i];
+            const seriesColor = colors[i % colors.length];
+            const defaults = currentSeries._defaults;
 
             currentSeries.color = currentSeries.color || seriesColor;
             if (defaults) {
                 defaults.color = defaults.color || seriesColor;
             }
         }
-    };
+    }
 
-    Chart.prototype._getModel = function _getModel () {
-        var options = this.options;
-        var plotArea = this._createPlotArea();
-        var model = new RootElement(this._modelOptions());
+    _getModel() {
+        const options = this.options;
+        const plotArea = this._createPlotArea();
+        const model = new RootElement(this._modelOptions());
         model.chart = this;
         model._plotArea = plotArea;
 
-        var title = Title.buildTitle(options.title);
-        var subtitle = Title.buildTitle(options.subtitle, {
+        const title = Title.buildTitle(options.title);
+        const subtitle = Title.buildTitle(options.subtitle, {
             align: options.title.align,
             position: options.title.position
         });
         model.append.apply(model, Title.orderTitles([title, subtitle]));
 
         if (options.legend && options.legend.visible) {
-            var legend = new Legend(plotArea.options.legend, this.chartService);
+            const legend = new Legend(plotArea.options.legend, this.chartService);
             model.append(legend);
             model._legend = legend;
         }
@@ -597,81 +582,78 @@ var Chart = (function (Class) {
         this._setTitleBox(title, subtitle);
 
         return model;
-    };
+    }
 
-    Chart.prototype._setTitleBox = function _setTitleBox (title, subtitle) {
+    _setTitleBox(title, subtitle) {
         if (!title && !subtitle) {
             return;
         }
 
         this._titleBox = (title || subtitle).box.clone();
 
-        var titlePosition = title ? title.options.position : '';
-        var subtitlePosition = subtitle ? subtitle.options.position : '';
-        var samePosition = titlePosition === subtitlePosition;
-        var subtitleAtTop = subtitlePosition !== BOTTOM;
+        const titlePosition = title ? title.options.position : '';
+        const subtitlePosition = subtitle ? subtitle.options.position : '';
+        const samePosition = titlePosition === subtitlePosition;
+        const subtitleAtTop = subtitlePosition !== BOTTOM;
 
         if (samePosition && subtitle) {
             this._titleBox.wrap(subtitle.box);
         } else if (title && subtitle && subtitleAtTop) {
             this._titleBox = subtitle.box.clone();
         }
-    };
+    }
 
-    Chart.prototype._modelOptions = function _modelOptions () {
-        var options = this.options;
-        var size = this.getSize();
+    _modelOptions() {
+        const options = this.options;
+        const size = this.getSize();
 
         return deepExtend({
             transitions: options.transitions,
             width: size.width || DEFAULT_WIDTH,
             height: size.height || DEFAULT_HEIGHT
         }, options.chartArea);
-    };
+    }
 
-    Chart.prototype._createPlotArea = function _createPlotArea (skipSeries) {
-        var options = this.options;
+    _createPlotArea(skipSeries) {
+        const options = this.options;
 
-        var plotArea = PlotAreaFactory.current.create(skipSeries ? [] : options.series, options, this.chartService);
+        const plotArea = PlotAreaFactory.current.create(skipSeries ? [] : options.series, options, this.chartService);
 
         return plotArea;
-    };
-
-    Chart.prototype._setupSelection = function _setupSelection () {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var axes = ref._plotArea.axes;
-        var selections = this._selections = [];
+    _setupSelection() {
+        const { _plotArea: { axes } } = this;
+        const selections = this._selections = [];
 
-        for (var i = 0; i < axes.length; i++) {
-            var axis = axes[i];
-            var options = axis.options;
+        for (let i = 0; i < axes.length; i++) {
+            const axis = axes[i];
+            const options = axis.options;
             if (axis instanceof CategoryAxis && options.select && !options.vertical) {
-                var range = axis.range();
+                const range = axis.range();
 
-                var selection = new Selection(this$1, axis,
+                const selection = new Selection(this, axis,
                     deepExtend({ min: range.min, max: range.max }, options.select)
                 );
 
                 selections.push(selection);
             }
         }
-    };
+    }
 
-    Chart.prototype._selectStart = function _selectStart (e) {
+    _selectStart(e) {
         return this.trigger(SELECT_START, e);
-    };
+    }
 
-    Chart.prototype._select = function _select (e) {
+    _select(e) {
         return this.trigger(SELECT, e);
-    };
+    }
 
-    Chart.prototype._selectEnd = function _selectEnd (e) {
+    _selectEnd(e) {
         return this.trigger(SELECT_END, e);
-    };
+    }
 
-    Chart.prototype._initHandlers = function _initHandlers () {
+    _initHandlers() {
         this._clickHandler = this._click.bind(this);
         this._keydownHandler = this._keydown.bind(this);
         this._focusHandler = this._focus.bind(this);
@@ -686,33 +668,31 @@ var Chart = (function (Class) {
             this._mousemove.bind(this),
             MOUSEMOVE_DELAY
         );
-    };
+    }
 
-    Chart.prototype.addObserver = function addObserver (observer) {
+    addObserver(observer) {
         if (observer) {
             this.observers.push(observer);
         }
-    };
+    }
 
-    Chart.prototype.removeObserver = function removeObserver (observer) {
-        var index = this.observers.indexOf(observer);
+    removeObserver(observer) {
+        const index = this.observers.indexOf(observer);
         if (index >= 0) {
             this.observers.splice(index, 1);
         }
-    };
+    }
 
-    Chart.prototype.requiresHandlers = function requiresHandlers (eventNames) {
-        var observers = this.observers;
-        for (var idx = 0; idx < observers.length; idx++) {
+    requiresHandlers(eventNames) {
+        const observers = this.observers;
+        for (let idx = 0; idx < observers.length; idx++) {
             if (observers[idx].requiresHandlers(eventNames)) {
                 return true;
             }
         }
-    };
-
-    Chart.prototype.trigger = function trigger (name, args) {
-        if ( args === void 0 ) args = {};
+    }
 
+    trigger(name, args = {}) {
         args.sender = this;
 
         if (name === SHOW_TOOLTIP) {
@@ -728,36 +708,42 @@ var Chart = (function (Class) {
             this._focusLegendItem(args);
         }
 
-        var observers = this.observers;
-        var isDefaultPrevented = false;
-        for (var idx = 0; idx < observers.length; idx++) {
+        const observers = this.observers;
+        let isDefaultPrevented = false;
+        for (let idx = 0; idx < observers.length; idx++) {
             if (observers[idx].trigger(name, args)) {
                 isDefaultPrevented = true;
             }
         }
 
         return isDefaultPrevented;
-    };
+    }
 
-    Chart.prototype.titleHeight = function titleHeight () {
+    titleHeight() {
         if (!this._titleBox) {
             return 0;
         }
 
         return this._titleBox.height();
-    };
-
-    Chart.prototype._attachEvents = function _attachEvents () {
-        var obj, obj$1;
+    }
 
-        var element = this.element;
+    _attachEvents() {
+        const element = this.element;
 
         this._touchAction = element.style.touchAction;
 
-        bindEvents(element, ( obj = {}, obj[ CONTEXTMENU ] = this._clickHandler, obj[ MOUSEWHEEL ] = this._mousewheelHandler, obj[ MOUSELEAVE ] = this._mouseleaveHandler, obj[ KEYDOWN ] = this._keydownHandler, obj[ MOUSEDOWN ] = this._mousedownHandler, obj[ FOCUS ] = this._focusHandler, obj[ BLUR] = this._blurHandler, obj ));
+        bindEvents(element, {
+            [ CONTEXTMENU ]: this._clickHandler,
+            [ MOUSEWHEEL ]: this._mousewheelHandler,
+            [ MOUSELEAVE ]: this._mouseleaveHandler,
+            [ KEYDOWN ]: this._keydownHandler,
+            [ MOUSEDOWN ]: this._mousedownHandler,
+            [ FOCUS ]: this._focusHandler,
+            [ BLUR]: this._blurHandler
+        });
 
         if (this._shouldAttachMouseMove()) {
-            bindEvents(element, ( obj$1 = {}, obj$1[ MOUSEMOVE ] = this._mousemoveThrottled, obj$1 ));
+            bindEvents(element, { [ MOUSEMOVE ]: this._mousemoveThrottled });
         }
 
         this.domEvents = DomEventsBuilder.create(this.element, {
@@ -771,9 +757,9 @@ var Chart = (function (Class) {
         });
 
         this._toggleDragZoomEvents();
-    };
+    }
 
-    Chart.prototype._mouseleave = function _mouseleave (e) {
+    _mouseleave(e) {
         if (this._hoveredPoint) {
             this._hoveredPoint.out(this, e);
             this._hoveredPoint = null;
@@ -788,24 +774,24 @@ var Chart = (function (Class) {
             this._applySeriesOpacity(this._activeChartInstance.children, null, true);
             this._updateSeriesOpacity(null, true);
         }
-    };
+    }
 
-    Chart.prototype._cancelDomEvents = function _cancelDomEvents () {
+    _cancelDomEvents() {
         if (this.domEvents && this.domEvents.cancel) {
             this.domEvents.cancel();
         }
-    };
+    }
 
-    Chart.prototype._gesturestart = function _gesturestart (e) {
+    _gesturestart(e) {
         if (this._mousewheelZoom && !this._stopChartHandlers(e)) {
             this._gestureDistance = e.distance;
             this._unsetActivePoint();
             this._clearFocusedElement();
             this.surface.suspendTracking();
         }
-    };
+    }
 
-    Chart.prototype._gestureend = function _gestureend (e) {
+    _gestureend(e) {
         if (this._zooming && !this._stopChartHandlers(e)) {
             if (this.surface) {
                 this.surface.resumeTracking();
@@ -813,49 +799,49 @@ var Chart = (function (Class) {
             this._zooming = false;
             this.trigger(ZOOM_END, {});
         }
-    };
+    }
 
-    Chart.prototype._gesturechange = function _gesturechange (e) {
-        var mousewheelZoom = this._mousewheelZoom;
+    _gesturechange(e) {
+        const mousewheelZoom = this._mousewheelZoom;
 
         if (mousewheelZoom && !this._stopChartHandlers(e)) {
             e.preventDefault();
-            var previousGestureDistance = this._gestureDistance;
-            var scaleDelta = -e.distance / previousGestureDistance + 1;
+            const previousGestureDistance = this._gestureDistance;
+            let scaleDelta = -e.distance / previousGestureDistance + 1;
 
             if (Math.abs(scaleDelta) >= 0.1) {
                 scaleDelta = Math.round(scaleDelta * 10);
 
                 this._gestureDistance = e.distance;
-                var args = { delta: scaleDelta, axisRanges: axisRanges(this._plotArea.axes), originalEvent: e };
+                const args = { delta: scaleDelta, axisRanges: axisRanges(this._plotArea.axes), originalEvent: e };
                 if (this._zooming || !this.trigger(ZOOM_START, args)) {
-                    var coords = this._eventCoordinates(e);
+                    const coords = this._eventCoordinates(e);
 
                     if (!this._zooming) {
                         this._zooming = true;
                     }
 
-                    var ranges = args.axisRanges = mousewheelZoom.updateRanges(scaleDelta, coords);
+                    const ranges = args.axisRanges = mousewheelZoom.updateRanges(scaleDelta, coords);
                     if (ranges && !this.trigger(ZOOM, args)) {
                         mousewheelZoom.zoom();
                     }
                 }
             }
         }
-    };
+    }
 
-    Chart.prototype._mouseout = function _mouseout (e) {
+    _mouseout(e) {
         if (e.element) {
-            var element = this._drawingChartElement(e.element, e);
+            const element = this._drawingChartElement(e.element, e);
 
             if (element && element.leave) {
                 element.leave(this, e.originalEvent);
             }
         }
-    };
+    }
 
-    Chart.prototype._start = function _start (e) {
-        var coords = this._eventCoordinates(e);
+    _start(e) {
+        const coords = this._eventCoordinates(e);
 
         if (this._stopChartHandlers(e) || !this._plotArea.backgroundContainsPoint(coords)) {
             return;
@@ -879,43 +865,41 @@ var Chart = (function (Class) {
                 this.trigger(ZOOM_START, { axisRanges: axisRanges(this._plotArea.axes), originalEvent: e });
             }
         }
-    };
+    }
 
-    Chart.prototype._move = function _move (e) {
-        var ref = this;
-        var state = ref._navState;
-        var pannable = ref._pannable;
+    _move(e) {
+        let { _navState: state, _pannable: pannable } = this;
 
         if (this._stopChartHandlers(e)) {
             return;
         }
 
         if (pannable) {
-            var ranges = pannable.move(e);
+            const ranges = pannable.move(e);
 
             if (ranges && !this.trigger(DRAG, { axisRanges: ranges, originalEvent: e })) {
                 pannable.pan();
             }
         } else if (state) {
-            var ranges$1 = {};
-            var axes = state.axes;
+            const ranges = {};
+            const axes = state.axes;
 
-            for (var i = 0; i < axes.length; i++) {
-                var currentAxis = axes[i];
-                var axisName = currentAxis.options.name;
+            for (let i = 0; i < axes.length; i++) {
+                const currentAxis = axes[i];
+                const axisName = currentAxis.options.name;
                 if (axisName) {
-                    var axis = currentAxis.options.vertical ? e.y : e.x;
-                    var delta = axis.startLocation - axis.location;
+                    const axis = currentAxis.options.vertical ? e.y : e.x;
+                    const delta = axis.startLocation - axis.location;
 
                     if (delta !== 0) {
-                        ranges$1[currentAxis.options.name] = currentAxis.translateRange(delta);
+                        ranges[currentAxis.options.name] = currentAxis.translateRange(delta);
                     }
                 }
             }
 
-            state.axisRanges = ranges$1;
+            state.axisRanges = ranges;
             this.trigger(DRAG, {
-                axisRanges: ranges$1,
+                axisRanges: ranges,
                 originalEvent: e
             });
         }
@@ -923,14 +907,14 @@ var Chart = (function (Class) {
         if (this._zoomSelection) {
             this._zoomSelection.move(e);
         }
-    };
+    }
 
-    Chart.prototype._end = function _end (e) {
+    _end(e) {
         if (this._stopChartHandlers(e)) {
             return;
         }
 
-        var pannable = this._pannable;
+        const pannable = this._pannable;
         if (pannable && pannable.end(e)) {
             this.surface.resumeTracking();
             this.trigger(DRAG_END, {
@@ -944,50 +928,48 @@ var Chart = (function (Class) {
         }
 
         if (this._zoomSelection) {
-            var ranges = this._zoomSelection.end(e);
+            const ranges = this._zoomSelection.end(e);
             if (ranges && !this.trigger(ZOOM, { axisRanges: ranges, originalEvent: e })) {
                 this._zoomSelection.zoom();
                 this.trigger(ZOOM_END, { axisRanges: ranges, originalEvent: e });
             }
         }
-    };
+    }
 
-    Chart.prototype._stopChartHandlers = function _stopChartHandlers (e) {
-        var selections = this._selections || [];
+    _stopChartHandlers(e) {
+        const selections = this._selections || [];
         if (!selections.length) {
             return false;
         }
 
-        var coords = this._eventCoordinates(e);
-        var pane = this._plotArea.paneByPoint(coords);
+        const coords = this._eventCoordinates(e);
+        const pane = this._plotArea.paneByPoint(coords);
         if (pane) {
-            for (var idx = 0; idx < selections.length; idx++) {
+            for (let idx = 0; idx < selections.length; idx++) {
                 if (selections[idx].onPane(pane)) {
                     return true;
                 }
             }
         }
-    };
+    }
 
-    Chart.prototype._mousewheelZoomRate = function _mousewheelZoomRate () {
-        var zoomable = this.options.zoomable;
-        var mousewheel = (zoomable || {}).mousewheel || {};
+    _mousewheelZoomRate() {
+        const zoomable = this.options.zoomable;
+        const mousewheel = (zoomable || {}).mousewheel || {};
         return valueOrDefault(mousewheel.rate, MOUSEWHEEL_ZOOM_RATE);
-    };
-
-    Chart.prototype._mousewheel = function _mousewheel (e) {
-        var this$1 = this;
+    }
 
-        var delta = mousewheelDelta(e);
-        var mousewheelZoom = this._mousewheelZoom;
-        var coords = this._eventCoordinates(e);
+    _mousewheel(e) {
+        const delta = mousewheelDelta(e);
+        const mousewheelZoom = this._mousewheelZoom;
+        const coords = this._eventCoordinates(e);
 
         if (this._stopChartHandlers(e) || !this._plotArea.backgroundContainsPoint(coords)) {
             return;
         }
 
         if (mousewheelZoom) {
-            var args = { delta: delta, axisRanges: axisRanges(this._plotArea.axes), originalEvent: e };
+            const args = { delta: delta, axisRanges: axisRanges(this._plotArea.axes), originalEvent: e };
             if (this._zooming || !this.trigger(ZOOM_START, args)) {
                 e.preventDefault();
 
@@ -1007,35 +989,35 @@ var Chart = (function (Class) {
                     mousewheelZoom.zoom();
                 }
 
-                this._mwTimeout = setTimeout(function () {
-                    this$1.trigger(ZOOM_END, args);
-                    this$1._zooming = false;
-                    if (this$1.surface) {
-                        this$1.surface.resumeTracking();
+                this._mwTimeout = setTimeout(() => {
+                    this.trigger(ZOOM_END, args);
+                    this._zooming = false;
+                    if (this.surface) {
+                        this.surface.resumeTracking();
                     }
                 }, MOUSEWHEEL_DELAY);
             }
         } else {
-            var state = this._navState;
+            let state = this._navState;
             if (!state) {
-                var prevented = this._startNavigation(e, coords, ZOOM_START);
+                const prevented = this._startNavigation(e, coords, ZOOM_START);
                 if (!prevented) {
                     state = this._navState;
                 }
             }
 
             if (state) {
-                var totalDelta = state.totalDelta || delta;
+                const totalDelta = state.totalDelta || delta;
                 state.totalDelta = totalDelta + delta;
 
-                var axes = this._navState.axes;
-                var ranges = {};
+                const axes = this._navState.axes;
+                const ranges = {};
 
-                for (var i = 0; i < axes.length; i++) {
-                    var currentAxis = axes[i];
-                    var axisName = currentAxis.options.name;
+                for (let i = 0; i < axes.length; i++) {
+                    const currentAxis = axes[i];
+                    const axisName = currentAxis.options.name;
                     if (axisName) {
-                        ranges[axisName] = currentAxis.scaleRange(-totalDelta * this$1._mousewheelZoomRate(), coords);
+                        ranges[axisName] = currentAxis.scaleRange(-totalDelta * this._mousewheelZoomRate(), coords);
                     }
                 }
 
@@ -1049,25 +1031,25 @@ var Chart = (function (Class) {
                     clearTimeout(this._mwTimeout);
                 }
 
-                this._mwTimeout = setTimeout(function () {
-                    this$1._endNavigation(e, ZOOM_END);
+                this._mwTimeout = setTimeout(() => {
+                    this._endNavigation(e, ZOOM_END);
                 }, MOUSEWHEEL_DELAY);
             }
         }
-    };
+    }
 
-    Chart.prototype._startNavigation = function _startNavigation (e, coords, chartEvent) {
-        var plotArea = this._model._plotArea;
-        var pane = plotArea.findPointPane(coords);
-        var axes = plotArea.axes.slice(0);
+    _startNavigation(e, coords, chartEvent) {
+        const plotArea = this._model._plotArea;
+        const pane = plotArea.findPointPane(coords);
+        const axes = plotArea.axes.slice(0);
 
         if (!pane) {
             return;
         }
 
-        var ranges = axisRanges(axes);
+        const ranges = axisRanges(axes);
 
-        var prevented = this.trigger(chartEvent, {
+        const prevented = this.trigger(chartEvent, {
             axisRanges: ranges,
             originalEvent: e
         });
@@ -1084,9 +1066,9 @@ var Chart = (function (Class) {
                 axes: axes
             };
         }
-    };
+    }
 
-    Chart.prototype._endNavigation = function _endNavigation (e, chartEvent) {
+    _endNavigation(e, chartEvent) {
         if (this._navState) {
             this.trigger(chartEvent, {
                 axisRanges: this._navState.axisRanges,
@@ -1095,18 +1077,18 @@ var Chart = (function (Class) {
             this._suppressHover = false;
             this._navState = null;
         }
-    };
+    }
 
-    Chart.prototype._getChartElement = function _getChartElement (e, match) {
-        var element = this.surface.eventTarget(e);
+    _getChartElement(e, match) {
+        const element = this.surface.eventTarget(e);
         if (element) {
             return this._drawingChartElement(element, e, match);
         }
-    };
+    }
 
-    Chart.prototype._drawingChartElement = function _drawingChartElement (element, e, match) {
-        var current = element;
-        var chartElement;
+    _drawingChartElement(element, e, match) {
+        let current = element;
+        let chartElement;
         while (current && !chartElement) {
             chartElement = current.chartElement;
             current = current.parent;
@@ -1126,18 +1108,16 @@ var Chart = (function (Class) {
 
             return chartElement;
         }
-    };
+    }
 
-    Chart.prototype._eventCoordinates = function _eventCoordinates (e) {
-        var coordinates = eventCoordinates(e);
+    _eventCoordinates(e) {
+        const coordinates = eventCoordinates(e);
         return this._toModelCoordinates(coordinates.x, coordinates.y);
-    };
+    }
 
-    Chart.prototype._elementPadding = function _elementPadding () {
+    _elementPadding() {
         if (!this._padding) {
-            var ref = elementStyles(this.element, [ "paddingLeft", "paddingTop" ]);
-            var paddingLeft = ref.paddingLeft;
-            var paddingTop = ref.paddingTop;
+            const { paddingLeft, paddingTop } = elementStyles(this.element, [ "paddingLeft", "paddingTop" ]);
             this._padding = {
                 top: paddingTop,
                 left: paddingLeft
@@ -1145,39 +1125,37 @@ var Chart = (function (Class) {
         }
 
         return this._padding;
-    };
+    }
 
-    Chart.prototype._toDocumentCoordinates = function _toDocumentCoordinates (point) {
-        var padding = this._elementPadding();
-        var offset = elementOffset(this.element);
+    _toDocumentCoordinates(point) {
+        const padding = this._elementPadding();
+        const offset = elementOffset(this.element);
 
         return {
             left: round(point.x + padding.left + offset.left),
             top: round(point.y + padding.top + offset.top)
         };
-    };
+    }
 
     // TODO: Breaking change due to peer version change
     // Reuse by exposing _surfacePoint on Surface
-    Chart.prototype._toModelCoordinates = function _toModelCoordinates (clientX, clientY) {
-        var element = this.element;
-        var offset = elementOffset(element);
-        var padding = this._elementPadding();
-        var inverseTransform = elementScale(element).invert();
-        var point = new geometry.Point(
+    _toModelCoordinates(clientX, clientY) {
+        const element = this.element;
+        const offset = elementOffset(element);
+        const padding = this._elementPadding();
+        const inverseTransform = elementScale(element).invert();
+        const point = new geometry.Point(
             clientX - offset.left - padding.left,
             clientY - offset.top - padding.top
         ).transform(inverseTransform);
 
         return new Point(point.x, point.y);
-    };
-
-    Chart.prototype._tap = function _tap (e) {
-        var this$1 = this;
+    }
 
-        var drawingElement = this.surface.eventTarget(e);
-        var element = this._drawingChartElement(drawingElement, e);
-        var sharedTooltip = this._sharedTooltip();
+    _tap(e) {
+        const drawingElement = this.surface.eventTarget(e);
+        const element = this._drawingChartElement(drawingElement, e);
+        const sharedTooltip = this._sharedTooltip();
 
         if (!this._startHover(drawingElement, e) && !sharedTooltip) {
             this._unsetActivePoint();
@@ -1191,38 +1169,34 @@ var Chart = (function (Class) {
 
         //part of fix for hover issue on windows touch
         this.handlingTap = true;
-        setTimeout(function () {
-            this$1.handlingTap = false;
+        setTimeout(() => {
+            this.handlingTap = false;
         }, 0);
-    };
+    }
 
-    Chart.prototype._click = function _click (e) {
-        var element = this._getChartElement(e);
+    _click(e) {
+        const element = this._getChartElement(e);
         this._propagateClick(element, e);
-    };
-
-    Chart.prototype._propagateClick = function _propagateClick (element, e) {
-        var this$1 = this;
+    }
 
-        var current = element;
+    _propagateClick(element, e) {
+        let current = element;
         while (current) {
             if (current.click) {
-                current.click(this$1, e);
+                current.click(this, e);
             }
 
             current = current.parent;
         }
-    };
+    }
 
-    Chart.prototype._isLegendBeforeChart = function _isLegendBeforeChart () {
-        var ref = this;
-        var legendPosition = ref.options.legend.position;
-        var legend = ref._legend;
+    _isLegendBeforeChart() {
+        const { options: { legend: { position: legendPosition } }, _legend: legend } = this;
 
         return legend && legend.hasItems() && (legendPosition === TOP || legendPosition === LEFT);
-    };
+    }
 
-    Chart.prototype._focus = function _focus () {
+    _focus() {
         if (!this._preventInitialPointFocus) {
             if (this._isLegendBeforeChart()) {
                 this._focusFirstLegendItem();
@@ -1232,18 +1206,14 @@ var Chart = (function (Class) {
         }
 
         this._preventInitialPointFocus = false;
-    };
+    }
 
-    Chart.prototype._keydown = function _keydown (e) {
-        var ref = this;
-        var ref_focusState = ref._focusState;
-        var legendInFocus = ref_focusState.legendInFocus;
-        var focusedElement = ref_focusState.focusedElement;
-        var legend = ref._legend;
+    _keydown(e) {
+        const { _focusState: { legendInFocus, focusedElement }, _legend: legend } = this;
 
         if (e.key === TAB) {
             this._clearFocusedElement();
-            var isLegendBeforeChart = this._isLegendBeforeChart();
+            const isLegendBeforeChart = this._isLegendBeforeChart();
 
             if (legendInFocus && isLegendBeforeChart !== e.shiftKey) {
                 this._navigatePoints(e);
@@ -1271,14 +1241,10 @@ var Chart = (function (Class) {
         } else {
             this._navigateLegend(e);
         }
-    };
-
-    Chart.prototype._navigatePoints = function _navigatePoints (e) {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var focusState = ref._focusState;
-        var plotArea = ref._plotArea;
+    _navigatePoints(e) {
+        const { _focusState: focusState, _plotArea: plotArea } = this;
 
         focusState.legendInFocus = false;
 
@@ -1288,11 +1254,11 @@ var Chart = (function (Class) {
             return;
         }
 
-        var moveFocus = function (point) {
+        const moveFocus = (point) => {
             focusState.focusedPoint = point;
 
-            this$1._focusElement(focusState.focusedPoint);
-            this$1._displayTooltip(point);
+            this._focusElement(focusState.focusedPoint);
+            this._displayTooltip(point);
             e.preventDefault();
         };
 
@@ -1312,15 +1278,10 @@ var Chart = (function (Class) {
             default:
                 break;
         }
-    };
-
-    Chart.prototype._navigateLegend = function _navigateLegend (e) {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var focusState = ref._focusState;
-        var legend = ref._legend;
-        var rtl = ref.chartService.rtl;
+    _navigateLegend(e) {
+        const { _focusState: focusState, _legend: legend, chartService: { rtl: rtl } } = this;
 
         focusState.legendInFocus = true;
 
@@ -1330,13 +1291,13 @@ var Chart = (function (Class) {
             return;
         }
 
-        var itemsLength = legend.getItems().length;
-        var moveFocus = function (cycleFunc) {
+        const itemsLength = legend.getItems().length;
+        const moveFocus = (cycleFunc) => {
             focusState.focusedLegendItemIndex = cycleFunc(
                 focusState.focusedLegendItemIndex,
                 itemsLength
             );
-            this$1._focusElement(this$1._getFocusedLegendItem());
+            this._focusElement(this._getFocusedLegendItem());
             e.preventDefault();
         };
 
@@ -1352,80 +1313,75 @@ var Chart = (function (Class) {
             default:
                 break;
         }
-    };
+    }
 
-    Chart.prototype._focusFirstPoint = function _focusFirstPoint () {
-        var point = this._focusState.focusedPoint = this._plotArea.getFirstPoint();
+    _focusFirstPoint() {
+        const point = this._focusState.focusedPoint = this._plotArea.getFirstPoint();
 
         if (point) {
             this._focusElement(point);
             this._displayTooltip(point);
         }
-    };
+    }
 
-    Chart.prototype._hasFocus = function _hasFocus () {
+    _hasFocus() {
         return this.element.ownerDocument.activeElement === this.element;
-    };
+    }
 
-    Chart.prototype._mousedown = function _mousedown () {
+    _mousedown() {
         if (!this._hasFocus()) {
             this._preventInitialPointFocus = true;
         }
-    };
+    }
 
-    Chart.prototype._focusChart = function _focusChart () {
+    _focusChart() {
         if (!this._hasFocus()) {
             this._preventInitialPointFocus = true;
             this.element.focus();
         }
-    };
+    }
 
-    Chart.prototype._focusPoint = function _focusPoint (point) {
+    _focusPoint(point) {
         this._focusState.focusedPoint = point;
 
         this._focusChart();
 
         this._focusElement(point, true);
-    };
+    }
 
-    Chart.prototype._focusFirstLegendItem = function _focusFirstLegendItem () {
-        var ref = this;
-        var focusState = ref._focusState;
+    _focusFirstLegendItem() {
+        const { _focusState: focusState } = this;
 
         focusState.focusedLegendItemIndex = 0;
         this._focusElement(this._getFocusedLegendItem());
         focusState.legendInFocus = true;
 
         this._hideTooltip();
-    };
+    }
 
-    Chart.prototype._focusLegendItem = function _focusLegendItem (args) {
-        var ref = this;
-        var focusState = ref._focusState;
+    _focusLegendItem(args) {
+        const { _focusState: focusState } = this;
 
         focusState.focusedLegendItemIndex = this._legend
             .getItems()
-            .findIndex(function (x) { return x.options.series.index === args.seriesIndex
-                && x.options.pointIndex === args.pointIndex; });
+            .findIndex(x => x.options.series.index === args.seriesIndex
+                && x.options.pointIndex === args.pointIndex);
 
         focusState.legendInFocus = true;
 
         this._focusChart();
 
         this._focusElement(this._getFocusedLegendItem(), true);
-    };
+    }
 
-    Chart.prototype._getFocusedLegendItem = function _getFocusedLegendItem () {
-        var ref = this;
-        var focusState = ref._focusState;
-        var legend = ref._legend;
+    _getFocusedLegendItem() {
+        const { _focusState: focusState, _legend: legend } = this;
 
         return legend.getItems()[focusState.focusedLegendItemIndex];
-    };
+    }
 
-    Chart.prototype._focusElement = function _focusElement (element, omitHighlight) {
-        var ref = this;
-        var focusState = ref._focusState;
+    _focusElement(element, omitHighlight) {
+        const { _focusState: focusState } = this;
 
         this._clearFocusedElement();
 
@@ -1441,18 +1397,17 @@ var Chart = (function (Class) {
             element.focusVisual();
 
             if (focusState.legendInFocus) {
-                var options = element.options;
+                const options = element.options;
 
                 this._showSeriesInactiveOpacity(options.series.index, options.pointIndex);
             } else {
                 this._showInactiveOpacity(element);
             }
         }
-    };
+    }
 
-    Chart.prototype._clearFocusedElement = function _clearFocusedElement () {
-        var ref = this;
-        var focusState = ref._focusState;
+    _clearFocusedElement() {
+        const { _focusState: focusState } = this;
 
         if (!focusState) {
             return;
@@ -1464,59 +1419,59 @@ var Chart = (function (Class) {
         }
 
         focusState.focusedElement = null;
-    };
+    }
 
-    Chart.prototype._setElementActiveDescendant = function _setElementActiveDescendant (element) {
+    _setElementActiveDescendant(element) {
         if (this.options.renderAs === "canvas") {
             this._pseudoFocusedElement = this._createPseudoFocusedElement(element);
             this.element.append(this._pseudoFocusedElement);
         }
 
         this.element.setAttribute(ARIA_ACTIVE_DESCENDANT, element._id);
-    };
+    }
 
-    Chart.prototype._clearElementActiveDescendant = function _clearElementActiveDescendant () {
+    _clearElementActiveDescendant() {
         if (this._pseudoFocusedElement) {
             this._pseudoFocusedElement.remove();
             this._pseudoFocusedElement = null;
         }
 
         this.element.removeAttribute(ARIA_ACTIVE_DESCENDANT);
-    };
+    }
 
-    Chart.prototype._createPseudoFocusedElement = function _createPseudoFocusedElement (element) {
-        var pseudoElement = document.createElement("div");
-        var accessibilityOptions = element.options.accessibility;
+    _createPseudoFocusedElement(element) {
+        const pseudoElement = document.createElement("div");
+        const accessibilityOptions = element.options.accessibility;
 
         pseudoElement.id = element._id;
         pseudoElement.setAttribute("aria-label", element.getAriaLabelText());
         pseudoElement.setAttribute("role", accessibilityOptions.role);
         pseudoElement.setAttribute("aria-roledescription", accessibilityOptions.ariaRoleDescription);
 
-        var checked = accessibilityOptions.ariaChecked;
+        const checked = accessibilityOptions.ariaChecked;
         if (defined(checked)) {
             pseudoElement.setAttribute("aria-checked", checked);
         }
 
         return pseudoElement;
-    };
+    }
 
-    Chart.prototype._blur = function _blur () {
+    _blur() {
         this._focusState.legendInFocus = false;
         this._clearFocusedElement();
         this._hideInactiveOpacity();
-    };
+    }
 
-    Chart.prototype._startHover = function _startHover (element, e) {
+    _startHover(element, e) {
         if (this._suppressHover) {
             return false;
         }
 
-        var point = this._drawingChartElement(element, e, function(element) {
+        let point = this._drawingChartElement(element, e, function(element) {
             return (element.hover || element.over) && !(element instanceof PlotAreaBase);
         });
 
-        var activePoint = this._activePoint;
+        const activePoint = this._activePoint;
 
         this._updateHoveredPoint(point, e);
 
@@ -1531,10 +1486,10 @@ var Chart = (function (Class) {
         }
 
         return point;
-    };
+    }
 
-    Chart.prototype._displayTooltip = function _displayTooltip (point) {
-        var tooltipOptions = deepExtend({}, this.options.tooltip, point.options.tooltip);
+    _displayTooltip(point) {
+        const tooltipOptions = deepExtend({}, this.options.tooltip, point.options.tooltip);
         if (tooltipOptions.visible) {
             if (this._sharedTooltip() && point.box) {
                 this._trackSharedTooltip(point.box.center(), {});
@@ -1542,16 +1497,16 @@ var Chart = (function (Class) {
                 this._tooltip.show(point);
             }
         }
-    };
+    }
 
-    Chart.prototype._hideTooltip = function _hideTooltip () {
+    _hideTooltip() {
         if (this._tooltip) {
             this._tooltip.hide();
         }
-    };
+    }
 
-    Chart.prototype._displayInactiveOpacity = function _displayInactiveOpacity (activePoint, multipleSeries, highlightPoints) {
-        var chartInstance = this._activeChartInstance = this._chartInstanceFromPoint(activePoint);
+    _displayInactiveOpacity(activePoint, multipleSeries, highlightPoints) {
+        const chartInstance = this._activeChartInstance = this._chartInstanceFromPoint(activePoint);
         if (!chartInstance) {
             return;
         }
@@ -1562,7 +1517,7 @@ var Chart = (function (Class) {
             this._applySeriesOpacity(chartInstance.children, activePoint.series);
             this._highlight.show(highlightPoints || activePoint);
         } else {
-            var inactivePoints;
+            let inactivePoints;
 
             if (!chartInstance.supportsPointInactiveOpacity()) {
                 this._highlight.show(activePoint);
@@ -1575,34 +1530,32 @@ var Chart = (function (Class) {
                 this._highlight.show(inactivePoints, 1 - this._getInactiveOpacityForSeries(activePoint.series));
             }
         }
-    };
-
-    Chart.prototype._getInactivePoints = function _getInactivePoints (activePoint, chartInstance) {
-        var allPoints = this._getAllPointsOfType(chartInstance, activePoint.constructor);
+    }
 
-        return allPoints.filter(function (point) { return point !== activePoint; });
-    };
+    _getInactivePoints(activePoint, chartInstance) {
+        let allPoints = this._getAllPointsOfType(chartInstance, activePoint.constructor);
 
-    Chart.prototype._getAllPointsOfType = function _getAllPointsOfType (container, type) {
-        var this$1 = this;
+        return allPoints.filter(point => point !== activePoint);
+    }
 
-        var points = [];
+    _getAllPointsOfType(container, type) {
+        let points = [];
 
-        for (var i = 0; i < container.children.length; i++) {
-            var element = container.children[i];
+        for (let i = 0; i < container.children.length; i++) {
+            const element = container.children[i];
 
             if (element.constructor === type) {
                 points.push(element);
             } else if (element.children && element.children.length) {
-                points = points.concat(this$1._getAllPointsOfType(element, type));
+                points = points.concat(this._getAllPointsOfType(element, type));
             }
         }
 
         return points;
-    };
+    }
 
-    Chart.prototype._updateHoveredPoint = function _updateHoveredPoint (point, e) {
-        var hoveredPoint = this._hoveredPoint;
+    _updateHoveredPoint(point, e) {
+        const hoveredPoint = this._hoveredPoint;
 
         if (hoveredPoint && hoveredPoint !== point) {
             hoveredPoint.out(this, e);
@@ -1613,53 +1566,49 @@ var Chart = (function (Class) {
             this._hoveredPoint = point;
             point.over(this, e);
         }
-    };
+    }
 
-    Chart.prototype._updateDrilldownPoint = function _updateDrilldownPoint (point) {
+    _updateDrilldownPoint(point) {
         if (!point || !point.series) {
             return;
         }
 
-        var ref = SeriesBinder.current.bindPoint(point.series, null, point.dataItem);
-        var fields = ref.fields;
+        const { fields } = SeriesBinder.current.bindPoint(point.series, null, point.dataItem);
         if (fields.drilldown) {
             this._drilldownState = { cursor: this.element.style.cursor };
             this.element.style.cursor = 'pointer';
         }
-    };
+    }
 
-    Chart.prototype._resetDrilldownPoint = function _resetDrilldownPoint () {
+    _resetDrilldownPoint() {
         if (this._drilldownState) {
             this.element.style.cursor = this._drilldownState.cursor;
             this._drilldownState = null;
         }
-    };
+    }
 
-    Chart.prototype._startDrilldown = function _startDrilldown (point) {
+    _startDrilldown(point) {
         if (!point || !point.series) {
             return;
         }
 
-        var series = point.series;
-        var ref = SeriesBinder.current.bindPoint(series, null, point.dataItem);
-        var fields = ref.fields;
-        var value = fields.drilldown;
+        const series = point.series;
+        const { fields } = SeriesBinder.current.bindPoint(series, null, point.dataItem);
+        const value = fields.drilldown;
         if (value) {
-            var args = { series: series, point: point, value: value, sender: this };
+            const args = { series, point, value, sender: this };
             this.trigger(DRILLDOWN, args);
         }
-    };
-
-    Chart.prototype._updateSeriesOpacity = function _updateSeriesOpacity (point, resetOpacity) {
-        var this$1 = this;
+    }
 
-        var plotArea = this._plotArea;
-        var length = plotArea.series.length;
+    _updateSeriesOpacity(point, resetOpacity) {
+        const plotArea = this._plotArea;
+        const length = plotArea.series.length;
 
-        for (var i = 0; i < length; i++) {
-            var currSeries = plotArea.series[i];
-            var defaultOpacity = this$1._getDefaultOpacityForSeries(currSeries);
-            var inactiveOpacity = this$1._getInactiveOpacityForSeries(currSeries);
+        for (let i = 0; i < length; i++) {
+            const currSeries = plotArea.series[i];
+            const defaultOpacity = this._getDefaultOpacityForSeries(currSeries);
+            const inactiveOpacity = this._getInactiveOpacityForSeries(currSeries);
 
             if (!resetOpacity && currSeries !== point.series) {
                 currSeries.defaultOpacity = defaultOpacity;
@@ -1676,53 +1625,51 @@ var Chart = (function (Class) {
                 }
             }
         }
-    };
-
-    Chart.prototype._applySeriesOpacity = function _applySeriesOpacity (elements, activeSeries, reset, series) {
-        var this$1 = this;
+    }
 
-        for (var i = 0; i < elements.length; i++) {
-            var element = elements[i];
-            var currSeries = element.series || series;
-            var shouldHighlight = currSeries && (currSeries.highlight || {}).visible;
+    _applySeriesOpacity(elements, activeSeries, reset, series) {
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            const currSeries = element.series || series;
+            const shouldHighlight = currSeries && (currSeries.highlight || {}).visible;
 
             if (shouldHighlight && element.visual) {
-                var opacity = series ? series.opacity : element.series.opacity;
+                const opacity = series ? series.opacity : element.series.opacity;
                 if (currSeries !== activeSeries || reset) {
                     element.visual.opacity(reset ? 1 : opacity);
                 }
             }
 
             if (element.children && element.children.length) {
-                this$1._applySeriesOpacity(element.children, activeSeries, reset, element.series);
+                this._applySeriesOpacity(element.children, activeSeries, reset, element.series);
             }
         }
-    };
+    }
 
-    Chart.prototype._chartInstanceFromPoint = function _chartInstanceFromPoint (point) {
-        var chartInstance = point.parent;
+    _chartInstanceFromPoint(point) {
+        let chartInstance = point.parent;
 
         while (chartInstance && !chartInstance.plotArea) {
             chartInstance = chartInstance.parent;
         }
 
         return chartInstance;
-    };
+    }
 
-    Chart.prototype._showInactiveOpacity = function _showInactiveOpacity (point) {
-        var multipleSeries = this._plotArea.series.length > 1;
-        var hasInactiveOpacity = this._hasInactiveOpacity();
+    _showInactiveOpacity(point) {
+        const multipleSeries = this._plotArea.series.length > 1;
+        const hasInactiveOpacity = this._hasInactiveOpacity();
 
         if (hasInactiveOpacity) {
             this._displayInactiveOpacity(point, multipleSeries);
         } else {
             this._highlight.show(point);
         }
-    };
+    }
 
-    Chart.prototype._hideInactiveOpacity = function _hideInactiveOpacity (point) {
-        var multipleSeries = this._plotArea.series.length > 1;
-        var hasInactiveOpacity = this._hasInactiveOpacity();
+    _hideInactiveOpacity(point) {
+        const multipleSeries = this._plotArea.series.length > 1;
+        const hasInactiveOpacity = this._hasInactiveOpacity();
         if (hasInactiveOpacity) {
             if (multipleSeries && this._activeChartInstance) {
                 this._updateSeriesOpacity(point, true);
@@ -1732,53 +1679,47 @@ var Chart = (function (Class) {
             this._highlight && this._highlight.hide();
             this._activePoint = null;
         }
-    };
+    }
 
-    Chart.prototype._hasInactiveOpacity = function _hasInactiveOpacity () {
-        var hasDefaultInactiveOpacity = this.options.seriesDefaults.highlight.inactiveOpacity !== undefined;
-        var hasInactiveOpacity = this.options.series.filter(function (s) { return s.highlight.inactiveOpacity !== undefined; } ).length > 0;
+    _hasInactiveOpacity() {
+        let hasDefaultInactiveOpacity = this.options.seriesDefaults.highlight.inactiveOpacity !== undefined;
+        let hasInactiveOpacity = this.options.series.filter(s => s.highlight.inactiveOpacity !== undefined ).length > 0;
         return hasDefaultInactiveOpacity || hasInactiveOpacity;
-    };
+    }
 
-    Chart.prototype._getInactiveOpacityForSeries = function _getInactiveOpacityForSeries (series) {
-        var defaultInactiveOpacity = this.options.seriesDefaults.highlight.inactiveOpacity;
-        var seriesInactiveOpacity = series.highlight.inactiveOpacity;
+    _getInactiveOpacityForSeries(series) {
+        let defaultInactiveOpacity = this.options.seriesDefaults.highlight.inactiveOpacity;
+        let seriesInactiveOpacity = series.highlight.inactiveOpacity;
         return seriesInactiveOpacity || defaultInactiveOpacity || series.opacity || DEFAULT_SERIES_OPACITY;
-    };
+    }
 
-    Chart.prototype._getDefaultOpacityForSeries = function _getDefaultOpacityForSeries (series) {
+    _getDefaultOpacityForSeries(series) {
         return series.defaultOpacity || series.opacity || DEFAULT_SERIES_OPACITY;
-    };
-
-    Chart.prototype._mouseover = function _mouseover (e) {
-        var obj;
+    }
 
-        var point = this._startHover(e.element, e.originalEvent);
+    _mouseover(e) {
+        const point = this._startHover(e.element, e.originalEvent);
 
         if (point && point.tooltipTracking && !this._mouseMoveTrackHandler && !this._sharedTooltip()) {
             this._mouseMoveTrackHandler = this._mouseMoveTracking.bind(this);
-            bindEvents(document, ( obj = {}, obj[ MOUSEMOVE ] = this._mouseMoveTrackHandler, obj ));
+            bindEvents(document, {
+                [ MOUSEMOVE ]: this._mouseMoveTrackHandler
+            });
         }
-    };
-
-    Chart.prototype._mouseMoveTracking = function _mouseMoveTracking (e) {
-        var obj;
+    }
 
-        var ref = this;
-        var options = ref.options;
-        var tooltip = ref._tooltip;
-        var highlight = ref._highlight;
-        var point = ref._activePoint;
-        var coords = this._eventCoordinates(e);
+    _mouseMoveTracking(e) {
+        const { options, _tooltip: tooltip, _highlight: highlight, _activePoint: point } = this;
+        const coords = this._eventCoordinates(e);
 
         if (this._plotArea.box.containsPoint(coords)) {
             if (point && point.tooltipTracking && point.series && point.parent.getNearestPoint) {
-                var seriesPoint = point.parent.getNearestPoint(coords.x, coords.y, point.seriesIx);
+                const seriesPoint = point.parent.getNearestPoint(coords.x, coords.y, point.seriesIx);
                 if (seriesPoint && seriesPoint !== point) {
                     this._activePoint = seriesPoint;
 
                     if (!seriesPoint.hover(this, e)) {
-                        var tooltipOptions = deepExtend({}, options.tooltip, seriesPoint.options.tooltip);
+                        const tooltipOptions = deepExtend({}, options.tooltip, seriesPoint.options.tooltip);
                         if (tooltipOptions.visible) {
                             tooltip.show(seriesPoint);
                         }
@@ -1788,23 +1729,25 @@ var Chart = (function (Class) {
                 }
             }
         } else {
-            unbindEvents(document, ( obj = {}, obj[ MOUSEMOVE ] = this._mouseMoveTrackHandler, obj ));
+            unbindEvents(document, {
+                [ MOUSEMOVE ]: this._mouseMoveTrackHandler
+            });
             this._unsetActivePoint();
             this._clearFocusedElement();
             this._mouseMoveTrackHandler = null;
 
             this._hideInactiveOpacity(point);
         }
-    };
+    }
 
-    Chart.prototype._mousemove = function _mousemove (e) {
-        var coords = this._eventCoordinates(e);
-        var plotArea = this._plotArea;
+    _mousemove(e) {
+        const coords = this._eventCoordinates(e);
+        const plotArea = this._plotArea;
 
         this._trackCrosshairs(coords);
 
         if (plotArea.hover) {
-            var overPlotArea = plotArea.backgroundContainsPoint(coords);
+            const overPlotArea = plotArea.backgroundContainsPoint(coords);
             if (overPlotArea) {
                 this._plotAreaHovered = true;
                 this._plotArea.hover(this, e);
@@ -1817,13 +1760,13 @@ var Chart = (function (Class) {
         if (this._sharedTooltip()) {
             this._trackSharedTooltip(coords, e);
         }
-    };
+    }
 
-    Chart.prototype._trackCrosshairs = function _trackCrosshairs (coords) {
-        var crosshairs = this._plotArea.crosshairs;
+    _trackCrosshairs(coords) {
+        const crosshairs = this._plotArea.crosshairs;
 
-        for (var i = 0; i < crosshairs.length; i++) {
-            var current = crosshairs[i];
+        for (let i = 0; i < crosshairs.length; i++) {
+            const current = crosshairs[i];
 
             if (current.box.containsPoint(coords)) {
                 current.showAt(coords);
@@ -1831,28 +1774,23 @@ var Chart = (function (Class) {
                 current.hide();
             }
         }
-    };
+    }
 
-    Chart.prototype._trackSharedTooltip = function _trackSharedTooltip (coords, e, toggle) {
+    _trackSharedTooltip(coords, e, toggle) {
         if (this._suppressHover) {
             return;
         }
 
-        var ref = this;
-        var tooltipOptions = ref.options.tooltip;
-        var plotArea = ref._plotArea;
-        var categoryAxis = ref._plotArea.categoryAxis;
-        var tooltip = ref._tooltip;
-        var highlight = ref._highlight;
+        const { options: { tooltip: tooltipOptions }, _plotArea: plotArea, _plotArea: { categoryAxis }, _tooltip: tooltip, _highlight: highlight } = this;
 
         if (plotArea.backgroundContainsPoint(coords)) {
-            var index = categoryAxis.pointCategoryIndex(coords);
+            const index = categoryAxis.pointCategoryIndex(coords);
             if (index !== this._tooltipCategoryIx || (!this._sharedHighlight && toggle)) {
-                var points = plotArea.pointsByCategoryIndex(index);
-                var pointArgs = points.map(function(point) {
+                const points = plotArea.pointsByCategoryIndex(index);
+                const pointArgs = points.map(function(point) {
                     return point.eventArgs(e);
                 });
-                var hoverArgs = pointArgs[0] || {};
+                const hoverArgs = pointArgs[0] || {};
                 hoverArgs.categoryPoints = pointArgs;
 
                 if (points.length > 0 && !this.trigger(SERIES_HOVER, hoverArgs)) {
@@ -1879,20 +1817,19 @@ var Chart = (function (Class) {
             this._tooltipCategoryIx = null;
             this._sharedHighlight = false;
         }
-    };
+    }
 
-    Chart.prototype.hideElements = function hideElements (options) {
-        var plotArea = this._plotArea;
+    hideElements(options) {
+        const plotArea = this._plotArea;
         this._mousemoveThrottled.cancel();
 
         plotArea.hideCrosshairs();
 
         this._unsetActivePoint(options);
-    };
+    }
 
-    Chart.prototype._unsetActivePoint = function _unsetActivePoint (options) {
-        var ref = this;
-        var highlight = ref._highlight;
+    _unsetActivePoint(options) {
+        const { _highlight: highlight } = this;
 
         this._activePoint = null;
         this._hoveredPoint = null;
@@ -1907,72 +1844,68 @@ var Chart = (function (Class) {
         if (highlight) {
             highlight.hide();
         }
-    };
+    }
 
-    Chart.prototype._deferRedraw = function _deferRedraw () {
+    _deferRedraw() {
         this._redraw();
-    };
+    }
 
-    Chart.prototype._clearRedrawTimeout = function _clearRedrawTimeout () {
+    _clearRedrawTimeout() {
         if (this._redrawTimeout) {
             clearInterval(this._redrawTimeout);
             this._redrawTimeout = null;
         }
-    };
-
-    Chart.prototype.bindCategories = function bindCategories () {
-        var this$1 = this;
+    }
 
-        var options = this.options;
-        var definitions = [].concat(options.categoryAxis);
+    bindCategories() {
+        const options = this.options;
+        const definitions = [].concat(options.categoryAxis);
 
-        for (var axisIx = 0; axisIx < definitions.length; axisIx++) {
-            var axis = definitions[axisIx];
+        for (let axisIx = 0; axisIx < definitions.length; axisIx++) {
+            const axis = definitions[axisIx];
             if (axis.autoBind !== false) {
-                this$1.bindCategoryAxisFromSeries(axis, axisIx);
+                this.bindCategoryAxisFromSeries(axis, axisIx);
             }
         }
-    };
-
-    Chart.prototype.bindCategoryAxisFromSeries = function bindCategoryAxisFromSeries (axis, axisIx) {
-        var this$1 = this;
-
-        var uniqueCategories = new Set();
-        var seriesOnAxis = this.options.series.filter(function (series) { return series.categoryAxis === axis.name || (!series.categoryAxis && axisIx === 0); });
-        var hasCategoryBinding = seriesOnAxis.some(function (series) { return Boolean(series.categoryField); });
-        var seriesWithData = seriesOnAxis.filter(function (series) { return series.data && series.data.length > 0; });
-        var categorySamples = seriesWithData.map(function (series) { return SeriesBinder.current.bindPoint(series, 0).fields.category; });
-        var dateAxis = categorySamples.reduce(function (result, firstCategory) { return result || isDateAxis(axis, firstCategory); }, false);
-        var seriesWithBinding = seriesWithData.filter(function (series, seriesIx) { return series.categoryField || defined(categorySamples[seriesIx]); });
+    }
 
-        seriesWithBinding.forEach(function (series) { return series.data.forEach(function (row, index) {
-            var category = SeriesBinder.current.bindPoint(series, index).fields.category;
+    bindCategoryAxisFromSeries(axis, axisIx) {
+        const uniqueCategories = new Set();
+        const seriesOnAxis = this.options.series.filter(series => series.categoryAxis === axis.name || (!series.categoryAxis && axisIx === 0));
+        const hasCategoryBinding = seriesOnAxis.some(series => Boolean(series.categoryField));
+        const seriesWithData = seriesOnAxis.filter(series => series.data && series.data.length > 0);
+        const categorySamples = seriesWithData.map(series => SeriesBinder.current.bindPoint(series, 0).fields.category);
+        const dateAxis = categorySamples.reduce((result, firstCategory) => result || isDateAxis(axis, firstCategory), false);
+        const seriesWithBinding = seriesWithData.filter((series, seriesIx) => series.categoryField || defined(categorySamples[seriesIx]));
+
+        seriesWithBinding.forEach((series) => series.data.forEach((row, index) => {
+            let category = SeriesBinder.current.bindPoint(series, index).fields.category;
             if (dateAxis) {
-                var date = parseDateCategory(category, row, this$1.chartService.intl);
+                const date = parseDateCategory(category, row, this.chartService.intl);
                 category = date ? date.getTime() : undefined;
             }
 
             uniqueCategories.add(category);
-        }); });
+        }));
 
         if (uniqueCategories.size > 0) {
-            var categories = Array.from(uniqueCategories.values());
+            let categories = Array.from(uniqueCategories.values());
             if (dateAxis) {
-                categories = categories.sort().map(function (time) { return time && new Date(time); });
+                categories = categories.sort().map(time => time && new Date(time));
             }
 
             axis.categories = categories;
         } else if (hasCategoryBinding) {
             axis.categories = [];
         }
-    };
+    }
 
-    Chart.prototype._isBindable = function _isBindable (series) {
-        var valueFields = SeriesBinder.current.valueFields(series);
-        var result = true;
+    _isBindable(series) {
+        const valueFields = SeriesBinder.current.valueFields(series);
+        let result = true;
 
-        for (var i = 0; i < valueFields.length; i++) {
-            var field = valueFields[i];
+        for (let i = 0; i < valueFields.length; i++) {
+            let field = valueFields[i];
             if (field === VALUE) {
                 field = "field";
             } else {
@@ -1986,11 +1919,11 @@ var Chart = (function (Class) {
         }
 
         return result;
-    };
+    }
 
-    Chart.prototype._noTransitionsRedraw = function _noTransitionsRedraw () {
-        var options = this.options;
-        var transitionsState;
+    _noTransitionsRedraw() {
+        const options = this.options;
+        let transitionsState;
 
         if (options.transitions !== false) {
             options.transitions = false;
@@ -2002,18 +1935,16 @@ var Chart = (function (Class) {
         if (transitionsState) {
             options.transitions = true;
         }
-    };
+    }
 
-    Chart.prototype._legendItemHover = function _legendItemHover (seriesIndex, pointIndex) {
+    _legendItemHover(seriesIndex, pointIndex) {
         this._showSeriesInactiveOpacity(seriesIndex, pointIndex);
-    };
+    }
 
-    Chart.prototype._showSeriesInactiveOpacity = function _showSeriesInactiveOpacity (seriesIndex, pointIndex) {
-        var ref = this;
-        var plotArea = ref._plotArea;
-        var highlight = ref._highlight;
-        var currentSeries = (plotArea.srcSeries || plotArea.series)[seriesIndex];
-        var items;
+    _showSeriesInactiveOpacity(seriesIndex, pointIndex) {
+        const { _plotArea: plotArea, _highlight: highlight } = this;
+        const currentSeries = (plotArea.srcSeries || plotArea.series)[seriesIndex];
+        let items;
 
         if (inArray(currentSeries.type, [ PIE, DONUT, FUNNEL, PYRAMID ])) {
             items = plotArea.findPoint(function(point) {
@@ -2024,30 +1955,32 @@ var Chart = (function (Class) {
         }
 
         if (this._hasInactiveOpacity() && currentSeries.visible && items) {
-            var multipleSeries = plotArea.series.length > 1;
-            var point = items.length ? items[0] : items;
+            const multipleSeries = plotArea.series.length > 1;
+            const point = items.length ? items[0] : items;
 
             this._displayInactiveOpacity(point, multipleSeries, items);
         } else {
             highlight.show(items);
         }
-    };
+    }
 
-    Chart.prototype._shouldAttachMouseMove = function _shouldAttachMouseMove () {
+    _shouldAttachMouseMove() {
         return this._plotArea.crosshairs.length || (this._tooltip && this._sharedTooltip()) || this.requiresHandlers([ PLOT_AREA_HOVER, PLOT_AREA_LEAVE ]);
-    };
-
-    Chart.prototype.updateMouseMoveHandler = function updateMouseMoveHandler () {
-        var obj, obj$1;
+    }
 
-        unbindEvents(this.element, ( obj = {}, obj[ MOUSEMOVE ] = this._mousemoveThrottled, obj ));
+    updateMouseMoveHandler() {
+        unbindEvents(this.element, {
+            [ MOUSEMOVE ]: this._mousemoveThrottled
+        });
 
         if (this._shouldAttachMouseMove()) {
-            bindEvents(this.element, ( obj$1 = {}, obj$1[ MOUSEMOVE ] = this._mousemoveThrottled, obj$1 ));
+            bindEvents(this.element, {
+                [ MOUSEMOVE ]: this._mousemoveThrottled
+            });
         }
-    };
+    }
 
-    Chart.prototype.applyOptions = function applyOptions (options, theme) {
+    applyOptions(options, theme) {
         clearMissingValues(this._originalOptions, options);
         this._originalOptions = deepExtend(this._originalOptions, options);
         this.options = deepExtend({}, this._originalOptions);
@@ -2059,37 +1992,44 @@ var Chart = (function (Class) {
         this._initTheme(this.options, this._theme);
 
         this._toggleDragZoomEvents();
-    };
+    }
 
-    Chart.prototype.setOptions = function setOptions (options, theme) {
+    setOptions(options, theme) {
         this.applyOptions(options, theme);
         this.bindCategories();
         this.redraw();
         this.updateMouseMoveHandler();
         this._restoreOverlayElement();
-    };
+    }
 
-    Chart.prototype.setDirection = function setDirection (rtl) {
+    setDirection(rtl) {
         this.chartService.rtl = Boolean(rtl);
         if (this.surface && this.surface.type === 'svg') {
             this._destroySurface();
         }
-    };
+    }
 
-    Chart.prototype.setIntlService = function setIntlService (intl) {
+    setIntlService(intl) {
         this.chartService.intl = intl;
-    };
+    }
 
-    Chart.prototype.noTransitionsRedraw = function noTransitionsRedraw () {
+    noTransitionsRedraw() {
         this._noTransitionsRedraw();
-    };
-
-    Chart.prototype.destroy = function destroy () {
-        var obj, obj$1;
+    }
 
+    destroy() {
         this._destroyed = true;
 
-        unbindEvents(this.element, ( obj = {}, obj[ CONTEXTMENU ] = this._clickHandler, obj[ MOUSEWHEEL ] = this._mousewheelHandler, obj[ MOUSEMOVE ] = this._mousemoveThrottled, obj[ MOUSELEAVE ] = this._mouseleaveHandler, obj[ MOUSEDOWN ] = this._mousedownHandler, obj[ KEYDOWN ] = this._keydownHandler, obj[ FOCUS ] = this._focusHandler, obj[ BLUR] = this._blurHandler, obj ));
+        unbindEvents(this.element, {
+            [ CONTEXTMENU ]: this._clickHandler,
+            [ MOUSEWHEEL ]: this._mousewheelHandler,
+            [ MOUSEMOVE ]: this._mousemoveThrottled,
+            [ MOUSELEAVE ]: this._mouseleaveHandler,
+            [ MOUSEDOWN ]: this._mousedownHandler,
+            [ KEYDOWN ]: this._keydownHandler,
+            [ FOCUS ]: this._focusHandler,
+            [ BLUR]: this._blurHandler
+        });
 
         if (this.domEvents) {
             this.domEvents.destroy();
@@ -2097,7 +2037,9 @@ var Chart = (function (Class) {
         }
 
         if (this._mouseMoveTrackHandler) {
-            unbindEvents(document, ( obj$1 = {}, obj$1[ MOUSEMOVE ] = this._mouseMoveTrackHandler, obj$1 ));
+            unbindEvents(document, {
+                [ MOUSEMOVE ]: this._mouseMoveTrackHandler
+            });
         }
 
         this._focusState = null;
@@ -2108,10 +2050,10 @@ var Chart = (function (Class) {
         this._destroySurface();
 
         this._clearRedrawTimeout();
-    };
+    }
 
-    Chart.prototype._destroySurface = function _destroySurface () {
-        var surface = this.surface;
+    _destroySurface() {
+        const surface = this.surface;
         if (surface) {
             surface.unbind("mouseenter", this._surfaceMouseenterHandler);
             surface.unbind("mouseleave", this._surfaceMouseleaveHandler);
@@ -2119,20 +2061,20 @@ var Chart = (function (Class) {
 
             this.surface = null;
         }
-    };
+    }
 
-    Chart.prototype._destroySelections = function _destroySelections () {
-        var selections = this._selections;
+    _destroySelections() {
+        const selections = this._selections;
 
         if (selections) {
             while (selections.length > 0) {
                 selections.shift().destroy();
             }
         }
-    };
+    }
 
-    Chart.prototype._destroyView = function _destroyView () {
-        var model = this._model;
+    _destroyView() {
+        const model = this._model;
 
         if (model) {
             model.destroy();
@@ -2166,16 +2108,14 @@ var Chart = (function (Class) {
             this._mousewheelZoom.destroy();
             delete this._mousewheelZoom;
         }
-    };
-
-    return Chart;
-}(Class));
+    }
+}
 
 function resolveAxisAliases(options) {
-    var aliases = AXIS_NAMES;
+    const aliases = AXIS_NAMES;
 
-    for (var idx = 0; idx < aliases.length; idx++) {
-        var alias = aliases[idx] + "Axes";
+    for (let idx = 0; idx < aliases.length; idx++) {
+        const alias = aliases[idx] + "Axes";
         if (options[alias]) {
             options[aliases[idx] + "Axis"] = options[alias];
             delete options[alias];
@@ -2185,7 +2125,7 @@ function resolveAxisAliases(options) {
 
 function pointByCategoryName(points, name) {
     if (points) {
-        for (var idx = 0; idx < points.length; idx++) {
+        for (let idx = 0; idx < points.length; idx++) {
             if (points[idx].category === name) {
                 return [ points[idx] ];
             }
@@ -2194,12 +2134,12 @@ function pointByCategoryName(points, name) {
 }
 
 function applyAxisDefaults(options, themeOptions) {
-    var themeAxisDefaults = ((themeOptions || {}).axisDefaults) || {};
-    var axisName, axisDefaults, axes;
+    const themeAxisDefaults = ((themeOptions || {}).axisDefaults) || {};
+    let axisName, axisDefaults, axes;
 
     function mapAxisOptions(axisOptions) {
-        var axisColor = (axisOptions || {}).color || axisDefaults.color;
-        var result = deepExtend({},
+        const axisColor = (axisOptions || {}).color || axisDefaults.color;
+        const result = deepExtend({},
             themeAxisDefaults,
             themeAxisDefaults[axisName],
             axisDefaults,
@@ -2216,7 +2156,7 @@ function applyAxisDefaults(options, themeOptions) {
         return result;
     }
 
-    for (var idx = 0; idx < AXIS_NAMES.length; idx++) {
+    for (let idx = 0; idx < AXIS_NAMES.length; idx++) {
         axisName = AXIS_NAMES[idx] + "Axis";
         axisDefaults = options.axisDefaults || {};
         axes = [].concat(options[axisName]);
@@ -2228,20 +2168,20 @@ function applyAxisDefaults(options, themeOptions) {
 }
 
 function applySeriesDefaults(options, themeOptions) {
-    var series = options.series;
-    var seriesLength = series.length;
-    var seriesDefaults = options.seriesDefaults;
-    var commonDefaults = deepExtend({}, options.seriesDefaults);
-    var themeSeriesDefaults = themeOptions ? deepExtend({}, themeOptions.seriesDefaults) : {};
-    var commonThemeDefaults = deepExtend({}, themeSeriesDefaults);
+    const series = options.series;
+    const seriesLength = series.length;
+    const seriesDefaults = options.seriesDefaults;
+    const commonDefaults = deepExtend({}, options.seriesDefaults);
+    const themeSeriesDefaults = themeOptions ? deepExtend({}, themeOptions.seriesDefaults) : {};
+    const commonThemeDefaults = deepExtend({}, themeSeriesDefaults);
 
     cleanupNestedSeriesDefaults(commonDefaults);
     cleanupNestedSeriesDefaults(commonThemeDefaults);
 
-    for (var i = 0; i < seriesLength; i++) {
-        var seriesType = series[i].type || options.seriesDefaults.type;
+    for (let i = 0; i < seriesLength; i++) {
+        const seriesType = series[i].type || options.seriesDefaults.type;
 
-        var baseOptions = deepExtend(
+        const baseOptions = deepExtend(
             { data: [] },
             commonThemeDefaults,
             themeSeriesDefaults[seriesType],
@@ -2283,11 +2223,11 @@ function cleanupNestedSeriesDefaults(seriesDefaults) {
 
 
 function axisRanges(axes) {
-    var ranges = {};
+    const ranges = {};
 
-    for (var i = 0; i < axes.length; i++) {
-        var axis = axes[i];
-        var axisName = axis.options.name;
+    for (let i = 0; i < axes.length; i++) {
+        const axis = axes[i];
+        const axisName = axis.options.name;
         if (axisName) {
             ranges[axisName] = axis.range();
         }
@@ -2296,15 +2236,15 @@ function axisRanges(axes) {
     return ranges;
 }
 
-var DATA_FIELDS = [ 'data', 'categories' ];
+const DATA_FIELDS = [ 'data', 'categories' ];
 
 function clearMissingValues(originalOptions, options) {
-    for (var field in options) {
+    for (let field in options) {
         if (!inArray(field, DATA_FIELDS) && hasOwnProperty(options, field)) {
-            var fieldValue = options[field];
-            var originalValue = originalOptions[field];
+            const fieldValue = options[field];
+            const originalValue = originalOptions[field];
             if (defined(originalValue)) {
-                var nullValue = fieldValue === null;
+                const nullValue = fieldValue === null;
                 if ((nullValue || !defined(fieldValue))) {
                     delete originalOptions[field];
                     if (nullValue) {
@@ -2321,7 +2261,7 @@ function clearMissingValues(originalOptions, options) {
 }
 
 function triggerPaneRender(panes) {
-    for (var idx = 0; idx < panes.length; idx++) {
+    for (let idx = 0; idx < panes.length; idx++) {
         panes[idx].notifyRender();
     }
 }