@amcharts/amcharts5 5.2.49 → 5.3.0

package/.internal/charts/xy/axes/DateAxis.js

@@ -1,4 +1,3 @@
-import { __assign, __extends } from "tslib";
 import { DataItem } from "../../../core/render/Component";
 import { ValueAxis } from "./ValueAxis";
 import * as $type from "../../../core/util/Type";
@@ -13,319 +12,280 @@ import * as $time from "../../../core/util/Time";
  * @see {@link https://www.amcharts.com/docs/v5/charts/xy-chart/axes/date-axis/} for more info
  * @important
  */
-var DateAxis = /** @class */ (function (_super) {
-    __extends(DateAxis, _super);
-    function DateAxis() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        Object.defineProperty(_this, "_dataGrouped", {
+export class DateAxis extends ValueAxis {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "_dataGrouped", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
-        Object.defineProperty(_this, "_seriesDataGrouped", {
+        Object.defineProperty(this, "_seriesDataGrouped", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
-        Object.defineProperty(_this, "_groupingCalculated", {
+        Object.defineProperty(this, "_groupingCalculated", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
-        Object.defineProperty(_this, "_intervalDuration", {
+        Object.defineProperty(this, "_intervalDuration", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: 1
         });
-        Object.defineProperty(_this, "_baseDuration", {
+        Object.defineProperty(this, "_baseDuration", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: 1
         });
-        Object.defineProperty(_this, "_intervalMax", {
+        Object.defineProperty(this, "_intervalMax", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: {}
         });
-        Object.defineProperty(_this, "_intervalMin", {
+        Object.defineProperty(this, "_intervalMin", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: {}
         });
-        return _this;
-    }
-    Object.defineProperty(DateAxis.prototype, "_afterNew", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            var _this = this;
-            this._settings.themeTags = $utils.mergeTags(this._settings.themeTags, ["axis"]);
-            _super.prototype._afterNew.call(this);
+    }
+    _afterNew() {
+        this._settings.themeTags = $utils.mergeTags(this._settings.themeTags, ["axis"]);
+        super._afterNew();
+        this._setBaseInterval(this.get("baseInterval"));
+        this.on("baseInterval", () => {
             this._setBaseInterval(this.get("baseInterval"));
-            this.on("baseInterval", function () {
-                _this._setBaseInterval(_this.get("baseInterval"));
-            });
+        });
+    }
+    _setBaseInterval(interval) {
+        this.setPrivateRaw("baseInterval", interval);
+        this._baseDuration = $time.getIntervalDuration(interval);
+    }
+    _fixZoomFactor() {
+        var maxZoomFactor = this.get("maxZoomFactor");
+        if (maxZoomFactor != null && maxZoomFactor != Infinity) {
+            this.setPrivateRaw("maxZoomFactor", maxZoomFactor);
         }
-    });
-    Object.defineProperty(DateAxis.prototype, "_setBaseInterval", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (interval) {
-            this.setPrivateRaw("baseInterval", interval);
-            this._baseDuration = $time.getIntervalDuration(interval);
+        else {
+            this.setPrivateRaw("maxZoomFactor", Math.round((this.getPrivate("max", 0) - this.getPrivate("min", 0)) / this.baseMainDuration()));
         }
-    });
-    Object.defineProperty(DateAxis.prototype, "_fixZoomFactor", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            var maxZoomFactor = this.get("maxZoomFactor");
-            if (maxZoomFactor != null && maxZoomFactor != Infinity) {
-                this.setPrivateRaw("maxZoomFactor", maxZoomFactor);
+    }
+    _groupData() {
+        const min = this.getPrivate("min");
+        const max = this.getPrivate("max");
+        if (($type.isNumber(min) && $type.isNumber(max))) {
+            this._fixZoomFactor();
+            const groupInterval = this.getPrivate("groupInterval");
+            if (groupInterval) {
+                this._setBaseInterval(groupInterval);
             }
             else {
-                this.setPrivateRaw("maxZoomFactor", Math.round((this.getPrivate("max", 0) - this.getPrivate("min", 0)) / this.baseMainDuration()));
+                this._setBaseInterval(this.get("baseInterval"));
             }
-        }
-    });
-    Object.defineProperty(DateAxis.prototype, "_groupData", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            var _this = this;
-            var min = this.getPrivate("min");
-            var max = this.getPrivate("max");
-            if (($type.isNumber(min) && $type.isNumber(max))) {
-                this._fixZoomFactor();
-                var groupInterval = this.getPrivate("groupInterval");
+            if (this.isDirty("groupInterval")) {
+                let groupInterval = this.get("groupInterval");
                 if (groupInterval) {
-                    this._setBaseInterval(groupInterval);
+                    this.setRaw("groupIntervals", [groupInterval]);
                 }
-                else {
-                    this._setBaseInterval(this.get("baseInterval"));
-                }
-                if (this.isDirty("groupInterval")) {
-                    var groupInterval_1 = this.get("groupInterval");
-                    if (groupInterval_1) {
-                        this.setRaw("groupIntervals", [groupInterval_1]);
+            }
+            if (this.isDirty("groupData")) {
+                if (!this._dataGrouped) {
+                    if (this.get("groupData")) {
+                        $array.each(this.series, (series) => {
+                            this._groupSeriesData(series);
+                        });
+                        this._handleRangeChange();
                     }
-                }
-                if (this.isDirty("groupData")) {
-                    if (!this._dataGrouped) {
-                        if (this.get("groupData")) {
-                            $array.each(this.series, function (series) {
-                                _this._groupSeriesData(series);
-                            });
-                            this._handleRangeChange();
-                        }
-                        else {
-                            var baseInterval = this.get("baseInterval");
-                            var mainDataSetId_1 = baseInterval.timeUnit + baseInterval.count;
-                            $array.each(this.series, function (series) {
-                                series.setDataSet(mainDataSetId_1);
-                            });
-                            this._setBaseInterval(baseInterval);
-                            this.setPrivateRaw("groupInterval", undefined);
-                            this.markDirtyExtremes();
-                        }
-                        this._dataGrouped = true;
+                    else {
+                        let baseInterval = this.get("baseInterval");
+                        let mainDataSetId = baseInterval.timeUnit + baseInterval.count;
+                        $array.each(this.series, (series) => {
+                            series.setDataSet(mainDataSetId);
+                        });
+                        this._setBaseInterval(baseInterval);
+                        this.setPrivateRaw("groupInterval", undefined);
+                        this.markDirtyExtremes();
                     }
+                    this._dataGrouped = true;
                 }
             }
         }
-    });
-    Object.defineProperty(DateAxis.prototype, "_groupSeriesData", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (series) {
-            if (this.get("groupData") && !series.get("groupDataDisabled")) {
-                this._dataGrouped = true; // helps to avoid double grouping
-                this._seriesDataGrouped = true;
-                // make array of intervals which will be used;
-                var intervals_1 = [];
-                var baseDuration_1 = this.baseMainDuration();
-                var groupIntervals = this.get("groupIntervals");
-                if (groupIntervals) { }
-                $array.each(groupIntervals, function (interval) {
-                    var intervalDuration = $time.getIntervalDuration(interval);
-                    if (intervalDuration > baseDuration_1) {
-                        intervals_1.push(interval);
-                    }
-                });
-                series._dataSets = {};
-                var key_1 = this.getPrivate("name") + this.get("renderer").getPrivate("letter");
-                var fields_1;
-                var baseAxis = series.get("baseAxis");
-                if (series.get("xAxis") === baseAxis) {
-                    fields_1 = series._valueYFields;
-                }
-                else if (series.get("yAxis") === baseAxis) {
-                    fields_1 = series._valueXFields;
+    }
+    _groupSeriesData(series) {
+        if (this.get("groupData") && !series.get("groupDataDisabled")) {
+            this._dataGrouped = true; // helps to avoid double grouping
+            this._seriesDataGrouped = true;
+            // make array of intervals which will be used;
+            let intervals = [];
+            let baseDuration = this.baseMainDuration();
+            let groupIntervals = this.get("groupIntervals");
+            if (groupIntervals) { }
+            $array.each(groupIntervals, (interval) => {
+                let intervalDuration = $time.getIntervalDuration(interval);
+                if (intervalDuration > baseDuration) {
+                    intervals.push(interval);
                 }
-                var dataItems_1 = series._mainDataItems;
-                var baseInterval = this.get("baseInterval");
-                var mainDataSetId = baseInterval.timeUnit + baseInterval.count;
-                series._dataSets[mainDataSetId] = dataItems_1;
-                var groupCallback_1 = series.get("groupDataCallback");
-                var groupOriginals_1 = series.get("groupDataWithOriginals", false);
-                if (groupCallback_1) {
-                    groupOriginals_1 = true;
+            });
+            series._dataSets = {};
+            const key = this.getPrivate("name") + this.get("renderer").getPrivate("letter");
+            let fields;
+            const baseAxis = series.get("baseAxis");
+            if (series.get("xAxis") === baseAxis) {
+                fields = series._valueYFields;
+            }
+            else if (series.get("yAxis") === baseAxis) {
+                fields = series._valueXFields;
+            }
+            let dataItems = series._mainDataItems;
+            let baseInterval = this.get("baseInterval");
+            let mainDataSetId = baseInterval.timeUnit + baseInterval.count;
+            series._dataSets[mainDataSetId] = dataItems;
+            const groupCallback = series.get("groupDataCallback");
+            let groupOriginals = series.get("groupDataWithOriginals", false);
+            if (groupCallback) {
+                groupOriginals = true;
+            }
+            const firstDay = this._root.locale.firstDayOfWeek;
+            const utc = this._root.utc;
+            const timezone = this._root.timezone;
+            $array.each(intervals, (interval) => {
+                let previousTime = -Infinity;
+                let dataSetId = interval.timeUnit + interval.count;
+                series._dataSets[dataSetId] = [];
+                let newDataItem;
+                let sum = {};
+                let count = {};
+                let groupFieldValues = {};
+                let workingFields = {};
+                $array.each(fields, (field) => {
+                    sum[field] = 0;
+                    count[field] = 0;
+                    groupFieldValues[field] = series.get((field + "Grouped"));
+                    workingFields[field] = field + "Working";
+                });
+                let intervalDuration = $time.getDuration(interval.timeUnit);
+                let firstItem = dataItems[0];
+                let firstDate;
+                if (firstItem) {
+                    firstDate = new Date(dataItems[0].get(key));
                 }
-                var firstDay_1 = this._root.locale.firstDayOfWeek;
-                var utc_1 = this._root.utc;
-                var timezone_1 = this._root.timezone;
-                $array.each(intervals_1, function (interval) {
-                    var previousTime = -Infinity;
-                    var dataSetId = interval.timeUnit + interval.count;
-                    series._dataSets[dataSetId] = [];
-                    var newDataItem;
-                    var sum = {};
-                    var count = {};
-                    var groupFieldValues = {};
-                    var workingFields = {};
-                    $array.each(fields_1, function (field) {
-                        sum[field] = 0;
-                        count[field] = 0;
-                        groupFieldValues[field] = series.get((field + "Grouped"));
-                        workingFields[field] = field + "Working";
-                    });
-                    var intervalDuration = $time.getDuration(interval.timeUnit);
-                    var firstItem = dataItems_1[0];
-                    var firstDate;
-                    if (firstItem) {
-                        firstDate = new Date(dataItems_1[0].get(key_1));
-                    }
-                    var prevNewDataItem;
-                    $array.each(dataItems_1, function (dataItem) {
-                        var time = dataItem.get(key_1);
-                        var roundedTime = $time.round(new Date(time), interval.timeUnit, interval.count, firstDay_1, utc_1, firstDate, timezone_1).getTime();
-                        var dataContext;
-                        if (previousTime < roundedTime - intervalDuration / 24) {
-                            dataContext = $object.copy(dataItem.dataContext);
-                            newDataItem = new DataItem(series, dataContext, series._makeDataItem(dataContext));
-                            newDataItem.setRaw(key_1, roundedTime);
-                            series._dataSets[dataSetId].push(newDataItem);
-                            $array.each(fields_1, function (field) {
-                                var value = dataItem.get(field);
-                                if ($type.isNumber(value)) {
-                                    newDataItem.setRaw(field, value);
-                                    newDataItem.setRaw(workingFields[field], value);
-                                    count[field] = 1;
-                                    sum[field] = value;
-                                }
-                                else {
-                                    sum[field] = 0;
-                                    count[field] = 0;
-                                }
-                            });
-                            if (groupOriginals_1) {
-                                newDataItem.set("originals", [dataItem]);
+                let prevNewDataItem;
+                $array.each(dataItems, (dataItem) => {
+                    let time = dataItem.get(key);
+                    let roundedTime = $time.round(new Date(time), interval.timeUnit, interval.count, firstDay, utc, firstDate, timezone).getTime();
+                    let dataContext;
+                    if (previousTime < roundedTime - intervalDuration / 24) {
+                        dataContext = $object.copy(dataItem.dataContext);
+                        newDataItem = new DataItem(series, dataContext, series._makeDataItem(dataContext));
+                        newDataItem.setRaw(key, roundedTime);
+                        series._dataSets[dataSetId].push(newDataItem);
+                        $array.each(fields, (field) => {
+                            let value = dataItem.get(field);
+                            if ($type.isNumber(value)) {
+                                newDataItem.setRaw(field, value);
+                                newDataItem.setRaw(workingFields[field], value);
+                                count[field] = 1;
+                                sum[field] = value;
                             }
-                            if (groupCallback_1 && prevNewDataItem) {
-                                groupCallback_1(prevNewDataItem, interval);
+                            else {
+                                sum[field] = 0;
+                                count[field] = 0;
                             }
-                            prevNewDataItem = newDataItem;
+                        });
+                        if (groupOriginals) {
+                            newDataItem.set("originals", [dataItem]);
                         }
-                        else {
-                            $array.each(fields_1, function (field) {
-                                var groupKey = groupFieldValues[field];
-                                var value = dataItem.get(field);
-                                if (value !== undefined) {
-                                    var currentValue = newDataItem.get(field);
-                                    switch (groupKey) {
-                                        case "close":
+                        if (groupCallback && prevNewDataItem) {
+                            groupCallback(prevNewDataItem, interval);
+                        }
+                        prevNewDataItem = newDataItem;
+                    }
+                    else {
+                        $array.each(fields, (field) => {
+                            let groupKey = groupFieldValues[field];
+                            let value = dataItem.get(field);
+                            if (value !== undefined) {
+                                let currentValue = newDataItem.get(field);
+                                switch (groupKey) {
+                                    case "close":
+                                        newDataItem.setRaw(field, value);
+                                        break;
+                                    case "sum":
+                                        newDataItem.setRaw(field, currentValue + value);
+                                        break;
+                                    case "open":
+                                        break;
+                                    case "low":
+                                        if (value < currentValue) {
+                                            newDataItem.setRaw(field, value);
+                                        }
+                                        break;
+                                    case "high":
+                                        if (value > currentValue) {
+                                            newDataItem.setRaw(field, value);
+                                        }
+                                        break;
+                                    case "average":
+                                        count[field]++;
+                                        sum[field] += value;
+                                        let average = sum[field] / count[field];
+                                        newDataItem.setRaw(field, average);
+                                        break;
+                                    case "extreme":
+                                        if (Math.abs(value) > Math.abs(currentValue)) {
                                             newDataItem.setRaw(field, value);
-                                            break;
-                                        case "sum":
-                                            newDataItem.setRaw(field, currentValue + value);
-                                            break;
-                                        case "open":
-                                            break;
-                                        case "low":
-                                            if (value < currentValue) {
-                                                newDataItem.setRaw(field, value);
-                                            }
-                                            break;
-                                        case "high":
-                                            if (value > currentValue) {
-                                                newDataItem.setRaw(field, value);
-                                            }
-                                            break;
-                                        case "average":
-                                            count[field]++;
-                                            sum[field] += value;
-                                            var average = sum[field] / count[field];
-                                            newDataItem.setRaw(field, average);
-                                            break;
-                                        case "extreme":
-                                            if (Math.abs(value) > Math.abs(currentValue)) {
-                                                newDataItem.setRaw(field, value);
-                                            }
-                                            break;
-                                    }
-                                    newDataItem.setRaw(workingFields[field], newDataItem.get(field));
-                                    var dataContext_1 = $object.copy(dataItem.dataContext);
-                                    dataContext_1[key_1] = roundedTime;
-                                    newDataItem.dataContext = dataContext_1;
+                                        }
+                                        break;
                                 }
-                            });
-                            if (groupOriginals_1) {
-                                newDataItem.get("originals").push(dataItem);
+                                newDataItem.setRaw(workingFields[field], newDataItem.get(field));
+                                let dataContext = $object.copy(dataItem.dataContext);
+                                dataContext[key] = roundedTime;
+                                newDataItem.dataContext = dataContext;
                             }
+                        });
+                        if (groupOriginals) {
+                            newDataItem.get("originals").push(dataItem);
                         }
-                        previousTime = roundedTime;
-                    });
-                    if (groupCallback_1 && prevNewDataItem) {
-                        groupCallback_1(prevNewDataItem, interval);
                     }
+                    previousTime = roundedTime;
                 });
-                if (series._dataSetId) {
-                    series.setDataSet(series._dataSetId);
+                if (groupCallback && prevNewDataItem) {
+                    groupCallback(prevNewDataItem, interval);
                 }
-                this.markDirtySize();
+            });
+            if (series._dataSetId) {
+                series.setDataSet(series._dataSetId);
             }
+            this.markDirtySize();
         }
-    });
-    Object.defineProperty(DateAxis.prototype, "_clearDirty", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            _super.prototype._clearDirty.call(this);
-            this._groupingCalculated = false;
-            this._dataGrouped = false;
-        }
-    });
+    }
+    _clearDirty() {
+        super._clearDirty();
+        this._groupingCalculated = false;
+        this._dataGrouped = false;
+    }
     /**
      * Returns a time interval axis would group data to for a specified duration.
      *
      * @since 5.2.1
      */
-    Object.defineProperty(DateAxis.prototype, "getGroupInterval", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (duration) {
-            var baseInterval = this.get("baseInterval");
-            var groupInterval = $time.chooseInterval(0, duration, this.get("groupCount", Infinity), this.get("groupIntervals"));
-            if ($time.getIntervalDuration(groupInterval) < $time.getIntervalDuration(baseInterval)) {
-                groupInterval = __assign({}, baseInterval);
-            }
-            return groupInterval;
+    getGroupInterval(duration) {
+        let baseInterval = this.get("baseInterval");
+        let groupInterval = $time.chooseInterval(0, duration, this.get("groupCount", Infinity), this.get("groupIntervals"));
+        if ($time.getIntervalDuration(groupInterval) < $time.getIntervalDuration(baseInterval)) {
+            groupInterval = Object.assign({}, baseInterval);
         }
-    });
+        return groupInterval;
+    }
     /**
      * Return `max` of a specified time interval.
      *
@@ -335,14 +295,9 @@ var DateAxis = /** @class */ (function (_super) {
      * @param   interval  Interval
      * @return            Max
      */
-    Object.defineProperty(DateAxis.prototype, "getIntervalMax", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (interval) {
-            return this._intervalMax[interval.timeUnit + interval.count];
-        }
-    });
+    getIntervalMax(interval) {
+        return this._intervalMax[interval.timeUnit + interval.count];
+    }
     /**
      * Return `min` of a specified time interval.
      *
@@ -352,459 +307,357 @@ var DateAxis = /** @class */ (function (_super) {
      * @param   interval  Interval
      * @return            Min
      */
-    Object.defineProperty(DateAxis.prototype, "getIntervalMin", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (interval) {
-            return this._intervalMin[interval.timeUnit + interval.count];
-        }
-    });
-    Object.defineProperty(DateAxis.prototype, "_handleRangeChange", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            var _this = this;
-            _super.prototype._handleRangeChange.call(this);
-            var selectionMin = Math.round(this.getPrivate("selectionMin"));
-            var selectionMax = Math.round(this.getPrivate("selectionMax"));
-            if ($type.isNumber(selectionMin) && $type.isNumber(selectionMax)) {
-                if (this.get("endLocation") == 0) {
-                    selectionMax += 1;
+    getIntervalMin(interval) {
+        return this._intervalMin[interval.timeUnit + interval.count];
+    }
+    _handleRangeChange() {
+        super._handleRangeChange();
+        let selectionMin = Math.round(this.getPrivate("selectionMin"));
+        let selectionMax = Math.round(this.getPrivate("selectionMax"));
+        if ($type.isNumber(selectionMin) && $type.isNumber(selectionMax)) {
+            if (this.get("endLocation") == 0) {
+                selectionMax += 1;
+            }
+            if (this.get("groupData") && !this._groupingCalculated) {
+                this._groupingCalculated = true;
+                let modifiedDifference = (selectionMax - selectionMin) + (this.get("startLocation", 0) + (1 - this.get("endLocation", 1)) * this.baseDuration());
+                let groupInterval = this.get("groupInterval");
+                if (!groupInterval) {
+                    groupInterval = this.getGroupInterval(modifiedDifference);
                 }
-                if (this.get("groupData") && !this._groupingCalculated) {
-                    this._groupingCalculated = true;
-                    var modifiedDifference = (selectionMax - selectionMin) + (this.get("startLocation", 0) + (1 - this.get("endLocation", 1)) * this.baseDuration());
-                    var groupInterval = this.get("groupInterval");
-                    if (!groupInterval) {
-                        groupInterval = this.getGroupInterval(modifiedDifference);
-                    }
-                    var current = this.getPrivate("groupInterval");
-                    if (groupInterval && (!current || (current.timeUnit !== groupInterval.timeUnit || current.count !== groupInterval.count) || this._seriesDataGrouped)) {
-                        this._seriesDataGrouped = false;
-                        this.setPrivateRaw("groupInterval", groupInterval);
-                        this._setBaseInterval(groupInterval);
-                        var newId_1 = groupInterval.timeUnit + groupInterval.count;
-                        $array.each(this.series, function (series) {
-                            if (series.get("baseAxis") === _this) {
-                                series.setDataSet(newId_1);
+                let current = this.getPrivate("groupInterval");
+                if (groupInterval && (!current || (current.timeUnit !== groupInterval.timeUnit || current.count !== groupInterval.count) || this._seriesDataGrouped)) {
+                    this._seriesDataGrouped = false;
+                    this.setPrivateRaw("groupInterval", groupInterval);
+                    this._setBaseInterval(groupInterval);
+                    let newId = groupInterval.timeUnit + groupInterval.count;
+                    $array.each(this.series, (series) => {
+                        if (series.get("baseAxis") === this) {
+                            series.setDataSet(newId);
+                        }
+                    });
+                    this.markDirtyExtremes();
+                    this._root.events.once("frameended", () => {
+                        this._root.events.once("frameended", () => {
+                            const type = "groupintervalchanged";
+                            if (this.events.isEnabled(type)) {
+                                this.events.dispatch(type, { type: type, target: this });
                             }
                         });
-                        this.markDirtyExtremes();
-                        this._root.events.once("frameended", function () {
-                            _this._root.events.once("frameended", function () {
-                                var type = "groupintervalchanged";
-                                if (_this.events.isEnabled(type)) {
-                                    _this.events.dispatch(type, { type: type, target: _this });
-                                }
-                            });
-                        });
-                    }
+                    });
                 }
-                $array.each(this.series, function (series) {
-                    if (series.get("baseAxis") === _this) {
-                        var fieldName_1 = (_this.getPrivate("name") + _this.get("renderer").getPrivate("letter"));
-                        var start = $array.getSortedIndex(series.dataItems, function (dataItem) {
-                            return $order.compare(dataItem.get(fieldName_1), selectionMin);
-                        });
-                        var startIndex = start.index;
-                        if (startIndex > 0) {
-                            startIndex -= 1;
-                        }
-                        selectionMax += _this.baseDuration() * (1 - _this.get("endLocation", 1));
-                        var end = $array.getSortedIndex(series.dataItems, function (dataItem) {
-                            return $order.compare(dataItem.get(fieldName_1), selectionMax);
-                        });
-                        var endIndex = end.index;
-                        var endIndex2 = endIndex;
-                        if (endIndex2 > 0) {
-                            endIndex2--;
-                        }
-                        var firstDataItem = series.dataItems[startIndex];
-                        var lastDataItem = series.dataItems[endIndex2];
-                        var lastDate = void 0;
-                        var firstDate = void 0;
-                        if (firstDataItem) {
-                            firstDate = firstDataItem.get(fieldName_1);
-                        }
-                        if (lastDataItem) {
-                            lastDate = lastDataItem.get(fieldName_1);
-                        }
-                        var outOfSelection = false;
-                        if (lastDate != null && firstDate != null) {
-                            if (lastDate < selectionMin || firstDate > selectionMax) {
-                                outOfSelection = true;
-                            }
+            }
+            $array.each(this.series, (series) => {
+                if (series.get("baseAxis") === this) {
+                    let fieldName = (this.getPrivate("name") + this.get("renderer").getPrivate("letter"));
+                    const start = $array.getSortedIndex(series.dataItems, (dataItem) => {
+                        return $order.compare(dataItem.get(fieldName), selectionMin);
+                    });
+                    let startIndex = start.index;
+                    if (startIndex > 0) {
+                        startIndex -= 1;
+                    }
+                    selectionMax += this.baseDuration() * (1 - this.get("endLocation", 1));
+                    const end = $array.getSortedIndex(series.dataItems, (dataItem) => {
+                        return $order.compare(dataItem.get(fieldName), selectionMax);
+                    });
+                    let endIndex = end.index;
+                    let endIndex2 = endIndex;
+                    if (endIndex2 > 0) {
+                        endIndex2--;
+                    }
+                    const firstDataItem = series.dataItems[startIndex];
+                    const lastDataItem = series.dataItems[endIndex2];
+                    let lastDate;
+                    let firstDate;
+                    if (firstDataItem) {
+                        firstDate = firstDataItem.get(fieldName);
+                    }
+                    if (lastDataItem) {
+                        lastDate = lastDataItem.get(fieldName);
+                    }
+                    let outOfSelection = false;
+                    if (lastDate != null && firstDate != null) {
+                        if (lastDate < selectionMin || firstDate > selectionMax) {
+                            outOfSelection = true;
                         }
-                        series.setPrivate("outOfSelection", outOfSelection);
-                        series.setPrivate("startIndex", startIndex);
-                        series.setPrivate("endIndex", endIndex);
                     }
-                });
-            }
-        }
-    });
-    Object.defineProperty(DateAxis.prototype, "_adjustMinMax", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (min, max, gridCount, _strictMode) {
-            return { min: min, max: max, step: (max - min) / gridCount };
+                    series.setPrivate("outOfSelection", outOfSelection);
+                    series.setPrivate("startIndex", startIndex);
+                    series.setPrivate("endIndex", endIndex);
+                }
+            });
         }
-    });
+    }
+    _adjustMinMax(min, max, gridCount, _strictMode) {
+        return { min: min, max: max, step: (max - min) / gridCount };
+    }
     /**
      * @ignore
      */
-    Object.defineProperty(DateAxis.prototype, "intervalDuration", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            return this._intervalDuration;
-        }
-    });
-    Object.defineProperty(DateAxis.prototype, "_saveMinMax", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (min, max) {
-            var groupInterval = this.getPrivate("groupInterval");
-            if (!groupInterval) {
-                groupInterval = this.get("baseInterval");
-            }
-            var id = groupInterval.timeUnit + groupInterval.count;
-            this._intervalMin[id] = min;
-            this._intervalMax[id] = max;
+    intervalDuration() {
+        return this._intervalDuration;
+    }
+    _saveMinMax(min, max) {
+        let groupInterval = this.getPrivate("groupInterval");
+        if (!groupInterval) {
+            groupInterval = this.get("baseInterval");
+        }
+        let id = groupInterval.timeUnit + groupInterval.count;
+        this._intervalMin[id] = min;
+        this._intervalMax[id] = max;
+    }
+    _getM(timeUnit) {
+        if (timeUnit == "month" || timeUnit == "year" || timeUnit == "day") {
+            return 1.05;
         }
-    });
-    Object.defineProperty(DateAxis.prototype, "_getM", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (timeUnit) {
-            if (timeUnit == "month" || timeUnit == "year") {
-                return 1.05;
+        return 1.01;
+    }
+    _prepareAxisItems() {
+        const min = this.getPrivate("min");
+        const max = this.getPrivate("max");
+        if ($type.isNumber(min) && $type.isNumber(max)) {
+            const selectionMin = Math.round(this.getPrivate("selectionMin"));
+            const selectionMax = Math.round(this.getPrivate("selectionMax"));
+            const renderer = this.get("renderer");
+            const baseInterval = this.getPrivate("baseInterval");
+            let value = selectionMin;
+            let i = 0;
+            const intervals = this.get("gridIntervals");
+            let gridInterval = $time.chooseInterval(0, selectionMax - selectionMin, renderer.gridCount(), intervals);
+            if ($time.getIntervalDuration(gridInterval) < this.baseDuration()) {
+                gridInterval = Object.assign({}, baseInterval);
             }
-            return 1.01;
-        }
-    });
-    Object.defineProperty(DateAxis.prototype, "_prepareAxisItems", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            var min = this.getPrivate("min");
-            var max = this.getPrivate("max");
-            if ($type.isNumber(min) && $type.isNumber(max)) {
-                var selectionMin = Math.round(this.getPrivate("selectionMin"));
-                var selectionMax = Math.round(this.getPrivate("selectionMax"));
-                var renderer = this.get("renderer");
-                var baseInterval = this.getPrivate("baseInterval");
-                var value = selectionMin;
-                var i = 0;
-                var intervals = this.get("gridIntervals");
-                var gridInterval = $time.chooseInterval(0, selectionMax - selectionMin, renderer.gridCount(), intervals);
-                if ($time.getIntervalDuration(gridInterval) < this.baseDuration()) {
-                    gridInterval = __assign({}, baseInterval);
+            const intervalDuration = $time.getIntervalDuration(gridInterval);
+            this._intervalDuration = intervalDuration;
+            const nextGridUnit = $time.getNextUnit(gridInterval.timeUnit);
+            const firstDay = this._root.locale.firstDayOfWeek;
+            const utc = this._root.utc;
+            const timezone = this._root.timezone;
+            value = $time.round(new Date(selectionMin - intervalDuration), gridInterval.timeUnit, gridInterval.count, firstDay, utc, new Date(min), timezone).getTime();
+            let previousValue = value - intervalDuration;
+            let format;
+            const formats = this.get("dateFormats");
+            this.setPrivateRaw("gridInterval", gridInterval);
+            while (value < selectionMax + intervalDuration) {
+                let dataItem;
+                if (this.dataItems.length < i + 1) {
+                    dataItem = new DataItem(this, undefined, {});
+                    this._dataItems.push(dataItem);
+                    this.processDataItem(dataItem);
                 }
-                var intervalDuration = $time.getIntervalDuration(gridInterval);
-                this._intervalDuration = intervalDuration;
-                var nextGridUnit = $time.getNextUnit(gridInterval.timeUnit);
-                var firstDay = this._root.locale.firstDayOfWeek;
-                var utc = this._root.utc;
-                var timezone = this._root.timezone;
-                value = $time.round(new Date(selectionMin - intervalDuration), gridInterval.timeUnit, gridInterval.count, firstDay, utc, new Date(min), timezone).getTime();
-                var previousValue = value - intervalDuration;
-                var format = void 0;
-                var formats = this.get("dateFormats");
-                this.setPrivateRaw("gridInterval", gridInterval);
-                while (value < selectionMax + intervalDuration) {
-                    var dataItem = void 0;
-                    if (this.dataItems.length < i + 1) {
-                        dataItem = new DataItem(this, undefined, {});
-                        this._dataItems.push(dataItem);
-                        this.processDataItem(dataItem);
-                    }
-                    else {
-                        dataItem = this.dataItems[i];
-                    }
-                    this._createAssets(dataItem, []);
-                    if (dataItem.isHidden()) {
-                        dataItem.show();
-                    }
-                    dataItem.setRaw("value", value);
-                    var endValue = value + $time.getDuration(gridInterval.timeUnit, gridInterval.count * this._getM(gridInterval.timeUnit));
-                    endValue = $time.round(new Date(endValue), gridInterval.timeUnit, 1, firstDay, utc, undefined, timezone).getTime();
-                    dataItem.setRaw("endValue", endValue);
-                    var date = new Date(value);
-                    format = formats[gridInterval.timeUnit];
-                    if (nextGridUnit && this.get("markUnitChange") && $type.isNumber(previousValue)) {
-                        if (gridInterval.timeUnit != "year") {
-                            if ($time.checkChange(value, previousValue, nextGridUnit, utc, timezone)) {
-                                format = this.get("periodChangeDateFormats")[gridInterval.timeUnit];
-                            }
+                else {
+                    dataItem = this.dataItems[i];
+                }
+                this._createAssets(dataItem, []);
+                if (dataItem.isHidden()) {
+                    dataItem.show();
+                }
+                dataItem.setRaw("value", value);
+                let endValue = value + $time.getDuration(gridInterval.timeUnit, gridInterval.count * this._getM(gridInterval.timeUnit));
+                endValue = $time.round(new Date(endValue), gridInterval.timeUnit, 1, firstDay, utc, undefined, timezone).getTime();
+                dataItem.setRaw("endValue", endValue);
+                let date = new Date(value);
+                format = formats[gridInterval.timeUnit];
+                if (nextGridUnit && this.get("markUnitChange") && $type.isNumber(previousValue)) {
+                    if (gridInterval.timeUnit != "year") {
+                        if ($time.checkChange(value, previousValue, nextGridUnit, utc, timezone)) {
+                            format = this.get("periodChangeDateFormats")[gridInterval.timeUnit];
                         }
                     }
-                    var label = dataItem.get("label");
-                    if (label) {
-                        label.set("text", this._root.dateFormatter.format(date, format));
-                    }
-                    this._prepareDataItem(dataItem, gridInterval.count);
-                    previousValue = value;
-                    value = endValue;
-                    if (value == previousValue) {
-                        break;
-                    }
-                    i++;
                 }
-                for (var j = i; j < this.dataItems.length; j++) {
-                    this.dataItems[j].hide();
+                const label = dataItem.get("label");
+                if (label) {
+                    label.set("text", this._root.dateFormatter.format(date, format));
                 }
-                $array.each(this.series, function (series) {
-                    if (series.inited) {
-                        series._markDirtyAxes();
-                    }
-                });
+                this._prepareDataItem(dataItem, gridInterval.count);
+                previousValue = value;
+                value = endValue;
+                if (value == previousValue) {
+                    break;
+                }
+                i++;
             }
-            this._updateGhost();
-        }
-    });
-    Object.defineProperty(DateAxis.prototype, "_getDelta", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            this._deltaMinMax = this.baseDuration() / 2;
-        }
-    });
-    Object.defineProperty(DateAxis.prototype, "_fixMin", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (min) {
-            var baseInterval = this.getPrivate("baseInterval");
-            var firstDay = this._root.locale.firstDayOfWeek;
-            var timezone = this._root.timezone;
-            var utc = this._root.utc;
-            var timeUnit = baseInterval.timeUnit;
-            var startTime = $time.round(new Date(min), timeUnit, baseInterval.count, firstDay, utc, undefined, timezone).getTime();
-            var endTime = startTime + $time.getDuration(timeUnit, baseInterval.count * this._getM(timeUnit));
-            endTime = $time.round(new Date(endTime), timeUnit, 1, firstDay, utc, undefined, timezone).getTime();
-            return startTime + (endTime - startTime) * this.get("startLocation", 0);
-        }
-    });
-    Object.defineProperty(DateAxis.prototype, "_fixMax", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (max) {
-            var baseInterval = this.getPrivate("baseInterval");
-            var firstDay = this._root.locale.firstDayOfWeek;
-            var timezone = this._root.timezone;
-            var utc = this._root.utc;
-            var timeUnit = baseInterval.timeUnit;
-            var startTime = $time.round(new Date(max), timeUnit, baseInterval.count, firstDay, utc, undefined, timezone).getTime();
-            var endTime = startTime + $time.getDuration(timeUnit, baseInterval.count * this._getM(timeUnit));
-            endTime = $time.round(new Date(endTime), timeUnit, 1, firstDay, utc, undefined, timezone).getTime();
-            return startTime + (endTime - startTime) * this.get("endLocation", 1);
-        }
-    });
-    Object.defineProperty(DateAxis.prototype, "_updateDates", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (_date) {
+            for (let j = i; j < this.dataItems.length; j++) {
+                this.dataItems[j].hide();
+            }
+            $array.each(this.series, (series) => {
+                if (series.inited) {
+                    series._markDirtyAxes();
+                }
+            });
         }
-    });
+        this._updateGhost();
+    }
+    _getDelta() {
+        this._deltaMinMax = this.baseDuration() / 2;
+    }
+    _fixMin(min) {
+        const baseInterval = this.getPrivate("baseInterval");
+        const firstDay = this._root.locale.firstDayOfWeek;
+        const timezone = this._root.timezone;
+        const utc = this._root.utc;
+        const timeUnit = baseInterval.timeUnit;
+        let startTime = $time.round(new Date(min), timeUnit, baseInterval.count, firstDay, utc, undefined, timezone).getTime();
+        let endTime = startTime + $time.getDuration(timeUnit, baseInterval.count * this._getM(timeUnit));
+        endTime = $time.round(new Date(endTime), timeUnit, 1, firstDay, utc, undefined, timezone).getTime();
+        return startTime + (endTime - startTime) * this.get("startLocation", 0);
+    }
+    _fixMax(max) {
+        const baseInterval = this.getPrivate("baseInterval");
+        const firstDay = this._root.locale.firstDayOfWeek;
+        const timezone = this._root.timezone;
+        const utc = this._root.utc;
+        const timeUnit = baseInterval.timeUnit;
+        let startTime = $time.round(new Date(max), timeUnit, baseInterval.count, firstDay, utc, undefined, timezone).getTime();
+        let endTime = startTime + $time.getDuration(timeUnit, baseInterval.count * this._getM(timeUnit));
+        endTime = $time.round(new Date(endTime), timeUnit, 1, firstDay, utc, undefined, timezone).getTime();
+        return startTime + (endTime - startTime) * this.get("endLocation", 1);
+    }
+    _updateDates(_date) {
+    }
     /**
      * Returns a duration of currently active `baseInterval` in milliseconds.
      *
      * @return Duration
      */
-    Object.defineProperty(DateAxis.prototype, "baseDuration", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            return this._baseDuration;
-            //return $time.getIntervalDuration(this.getPrivate("baseInterval"));
-        }
-    });
+    baseDuration() {
+        return this._baseDuration;
+        //return $time.getIntervalDuration(this.getPrivate("baseInterval"));
+    }
     /**
      * Returns a duration of user-defined `baseInterval` in milliseconds.
      *
      * @return Duration
      */
-    Object.defineProperty(DateAxis.prototype, "baseMainDuration", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            return $time.getIntervalDuration(this.get("baseInterval"));
-        }
-    });
+    baseMainDuration() {
+        return $time.getIntervalDuration(this.get("baseInterval"));
+    }
     /**
      * @ignore
      */
-    Object.defineProperty(DateAxis.prototype, "processSeriesDataItem", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (dataItem, fields) {
-            var _this = this;
-            var baseInterval = this.getPrivate("baseInterval");
-            if (!dataItem.open) {
-                dataItem.open = {};
-            }
-            if (!dataItem.close) {
-                dataItem.close = {};
-            }
-            $array.each(fields, function (field) {
-                var value = dataItem.get(field);
-                if ($type.isNumber(value)) {
-                    var startTime = dataItem.open[field];
-                    var endTime = dataItem.close[field];
-                    // this is done to save cpu, as rounding is quite expensive, especially with timezone set. 
-                    // if value is between prev start and end, it means it didn't change, all is fine.
-                    if (value >= startTime && value <= endTime) {
-                    }
-                    else {
-                        var firstDay = _this._root.locale.firstDayOfWeek;
-                        var utc = _this._root.utc;
-                        var timezone = _this._root.timezone;
-                        var timeUnit = baseInterval.timeUnit;
-                        var count = baseInterval.count;
-                        startTime = $time.round(new Date(value), timeUnit, count, firstDay, utc, undefined, timezone).getTime();
-                        endTime = startTime + $time.getDuration(timeUnit, count * _this._getM(timeUnit));
-                        endTime = $time.round(new Date(endTime), timeUnit, 1, firstDay, utc, undefined, timezone).getTime();
-                        dataItem.open[field] = startTime;
-                        dataItem.close[field] = endTime;
-                    }
-                    _this._updateDates(startTime);
+    processSeriesDataItem(dataItem, fields) {
+        const baseInterval = this.getPrivate("baseInterval");
+        if (!dataItem.open) {
+            dataItem.open = {};
+        }
+        if (!dataItem.close) {
+            dataItem.close = {};
+        }
+        $array.each(fields, (field) => {
+            let value = dataItem.get(field);
+            if ($type.isNumber(value)) {
+                let startTime = dataItem.open[field];
+                let endTime = dataItem.close[field];
+                // this is done to save cpu, as rounding is quite expensive, especially with timezone set. 
+                // if value is between prev start and end, it means it didn't change, all is fine.
+                if (value >= startTime && value <= endTime) {
                 }
-            });
-        }
-    });
+                else {
+                    const firstDay = this._root.locale.firstDayOfWeek;
+                    const utc = this._root.utc;
+                    const timezone = this._root.timezone;
+                    const timeUnit = baseInterval.timeUnit;
+                    const count = baseInterval.count;
+                    startTime = $time.round(new Date(value), timeUnit, count, firstDay, utc, undefined, timezone).getTime();
+                    endTime = startTime + $time.getDuration(timeUnit, count * this._getM(timeUnit));
+                    endTime = $time.round(new Date(endTime), timeUnit, 1, firstDay, utc, undefined, timezone).getTime();
+                    dataItem.open[field] = startTime;
+                    dataItem.close[field] = endTime;
+                }
+                this._updateDates(startTime);
+            }
+        });
+    }
     /**
      * @ignore
      */
-    Object.defineProperty(DateAxis.prototype, "getDataItemPositionX", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (dataItem, field, cellLocation, axisLocation) {
-            var openValue;
-            var closeValue;
-            if (dataItem.open && dataItem.close) {
-                openValue = dataItem.open[field];
-                closeValue = dataItem.close[field];
-            }
-            else {
-                openValue = dataItem.get(field);
-                closeValue = openValue;
-            }
-            var value = openValue + (closeValue - openValue) * cellLocation;
-            value = this._baseValue + (value - this._baseValue) * axisLocation;
-            return this.valueToPosition(value);
-        }
-    });
+    getDataItemPositionX(dataItem, field, cellLocation, axisLocation) {
+        let openValue;
+        let closeValue;
+        if (dataItem.open && dataItem.close) {
+            openValue = dataItem.open[field];
+            closeValue = dataItem.close[field];
+        }
+        else {
+            openValue = dataItem.get(field);
+            closeValue = openValue;
+        }
+        let value = openValue + (closeValue - openValue) * cellLocation;
+        value = this._baseValue + (value - this._baseValue) * axisLocation;
+        return this.valueToPosition(value);
+    }
     /**
      * @ignore
      */
-    Object.defineProperty(DateAxis.prototype, "getDataItemCoordinateX", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (dataItem, field, cellLocation, axisLocation) {
-            return this._settings.renderer.positionToCoordinate(this.getDataItemPositionX(dataItem, field, cellLocation, axisLocation));
-        }
-    });
+    getDataItemCoordinateX(dataItem, field, cellLocation, axisLocation) {
+        return this._settings.renderer.positionToCoordinate(this.getDataItemPositionX(dataItem, field, cellLocation, axisLocation));
+    }
     /**
      * @ignore
      */
-    Object.defineProperty(DateAxis.prototype, "getDataItemPositionY", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (dataItem, field, cellLocation, axisLocation) {
-            var openValue;
-            var closeValue;
-            if (dataItem.open && dataItem.close) {
-                openValue = dataItem.open[field];
-                closeValue = dataItem.close[field];
-            }
-            else {
-                openValue = dataItem.get(field);
-                closeValue = openValue;
-            }
-            var value = openValue + (closeValue - openValue) * cellLocation;
-            value = this._baseValue + (value - this._baseValue) * axisLocation;
-            return this.valueToPosition(value);
-        }
-    });
+    getDataItemPositionY(dataItem, field, cellLocation, axisLocation) {
+        let openValue;
+        let closeValue;
+        if (dataItem.open && dataItem.close) {
+            openValue = dataItem.open[field];
+            closeValue = dataItem.close[field];
+        }
+        else {
+            openValue = dataItem.get(field);
+            closeValue = openValue;
+        }
+        let value = openValue + (closeValue - openValue) * cellLocation;
+        value = this._baseValue + (value - this._baseValue) * axisLocation;
+        return this.valueToPosition(value);
+    }
     /**
      * @ignore
      */
-    Object.defineProperty(DateAxis.prototype, "getDataItemCoordinateY", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (dataItem, field, cellLocation, axisLocation) {
-            return this._settings.renderer.positionToCoordinate(this.getDataItemPositionY(dataItem, field, cellLocation, axisLocation));
-        }
-    });
+    getDataItemCoordinateY(dataItem, field, cellLocation, axisLocation) {
+        return this._settings.renderer.positionToCoordinate(this.getDataItemPositionY(dataItem, field, cellLocation, axisLocation));
+    }
     /**
      * @ignore
      */
-    Object.defineProperty(DateAxis.prototype, "roundAxisPosition", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (position, location) {
-            var value = this.positionToValue(position);
-            value = value - (location - 0.5) * this.baseDuration();
-            var baseInterval = this.getPrivate("baseInterval");
-            if (!$type.isNaN(value)) {
-                var firstDay = this._root.locale.firstDayOfWeek;
-                var timeUnit = baseInterval.timeUnit;
-                var utc = this._root.utc;
-                var timezone = this._root.timezone;
-                var count = baseInterval.count;
-                value = $time.round(new Date(value), timeUnit, count, firstDay, utc, new Date(this.getPrivate("min", 0)), timezone).getTime();
-                var duration = $time.getDateIntervalDuration(baseInterval, new Date(value), firstDay, utc, timezone);
-                if (timezone) {
-                    value = $time.round(new Date(value + this.baseDuration() * 0.05), timeUnit, count, firstDay, utc, new Date(this.getPrivate("min", 0)), timezone).getTime();
-                    duration = $time.getDateIntervalDuration(baseInterval, new Date(value + duration * location), firstDay, utc, timezone);
-                }
-                return this.valueToPosition(value + duration * location);
+    roundAxisPosition(position, location) {
+        let value = this.positionToValue(position);
+        value = value - (location - 0.5) * this.baseDuration();
+        let baseInterval = this.getPrivate("baseInterval");
+        if (!$type.isNaN(value)) {
+            const firstDay = this._root.locale.firstDayOfWeek;
+            const timeUnit = baseInterval.timeUnit;
+            const utc = this._root.utc;
+            const timezone = this._root.timezone;
+            const count = baseInterval.count;
+            value = $time.round(new Date(value), timeUnit, count, firstDay, utc, new Date(this.getPrivate("min", 0)), timezone).getTime();
+            let duration = $time.getDateIntervalDuration(baseInterval, new Date(value), firstDay, utc, timezone);
+            if (timezone) {
+                value = $time.round(new Date(value + this.baseDuration() * 0.05), timeUnit, count, firstDay, utc, new Date(this.getPrivate("min", 0)), timezone).getTime();
+                duration = $time.getDateIntervalDuration(baseInterval, new Date(value + duration * location), firstDay, utc, timezone);
             }
-            return NaN;
+            return this.valueToPosition(value + duration * location);
         }
-    });
+        return NaN;
+    }
     /**
      * Returns text to be used in an axis tooltip for specific relative position.
      *
      * @param   position  Position
      * @return            Tooltip text
      */
-    Object.defineProperty(DateAxis.prototype, "getTooltipText", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (position) {
-            //@todo number formatter + tag
-            if (this.getPrivate("min") != null) {
-                var format = this.get("tooltipDateFormats")[this.getPrivate("baseInterval").timeUnit];
-                var value = this.positionToValue(position);
-                var date = new Date(value);
-                var baseInterval = this.getPrivate("baseInterval");
-                var duration = $time.getDateIntervalDuration(baseInterval, date, this._root.locale.firstDayOfWeek, this._root.utc, this._root.timezone);
-                return this._root.dateFormatter.format(new Date(value + this.get("tooltipIntervalOffset", -this.get("tooltipLocation", 0.5)) * duration), this.get("tooltipDateFormat", format));
-            }
-            return "";
-        }
-    });
+    getTooltipText(position) {
+        //@todo number formatter + tag
+        if (this.getPrivate("min") != null) {
+            let format = this.get("tooltipDateFormats")[this.getPrivate("baseInterval").timeUnit];
+            let value = this.positionToValue(position);
+            let date = new Date(value);
+            let baseInterval = this.getPrivate("baseInterval");
+            let duration = $time.getDateIntervalDuration(baseInterval, date, this._root.locale.firstDayOfWeek, this._root.utc, this._root.timezone);
+            return this._root.dateFormatter.format(new Date(value + this.get("tooltipIntervalOffset", -this.get("tooltipLocation", 0.5)) * duration), this.get("tooltipDateFormat", format));
+        }
+        return "";
+    }
     /**
      * Returns a data item from series that is closest to the `position`.
      *
@@ -812,74 +665,64 @@ var DateAxis = /** @class */ (function (_super) {
      * @param   position  Relative position
      * @return            Data item
      */
-    Object.defineProperty(DateAxis.prototype, "getSeriesItem", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (series, position, location) {
-            var fieldName = (this.getPrivate("name") + this.get("renderer").getPrivate("letter"));
-            var value = this.positionToValue(position);
-            if (location == null) {
-                location = 0.5;
+    getSeriesItem(series, position, location) {
+        let fieldName = (this.getPrivate("name") + this.get("renderer").getPrivate("letter"));
+        let value = this.positionToValue(position);
+        if (location == null) {
+            location = 0.5;
+        }
+        value = value - (location - 0.5) * this.baseDuration();
+        const result = $array.getSortedIndex(series.dataItems, (dataItem) => {
+            var diValue = 0;
+            if (dataItem.open) {
+                diValue = dataItem.open[fieldName];
             }
-            value = value - (location - 0.5) * this.baseDuration();
-            var result = $array.getSortedIndex(series.dataItems, function (dataItem) {
-                var diValue = 0;
-                if (dataItem.open) {
-                    diValue = dataItem.open[fieldName];
-                }
-                return $order.compare(diValue, value);
-            });
-            if (series.get("snapTooltip")) {
-                var first = series.dataItems[result.index - 1];
-                var second = series.dataItems[result.index];
-                if (first && second) {
-                    if (first.open && second.close) {
-                        var open_1 = first.open[fieldName];
-                        var close_1 = second.close[fieldName];
-                        if (Math.abs(value - open_1) > Math.abs(value - close_1)) {
-                            return second;
-                        }
+            return $order.compare(diValue, value);
+        });
+        if (series.get("snapTooltip")) {
+            let first = series.dataItems[result.index - 1];
+            let second = series.dataItems[result.index];
+            if (first && second) {
+                if (first.open && second.close) {
+                    let open = first.open[fieldName];
+                    let close = second.close[fieldName];
+                    if (Math.abs(value - open) > Math.abs(value - close)) {
+                        return second;
                     }
                 }
-                if (first) {
-                    return first;
-                }
-                if (second) {
-                    return second;
-                }
             }
-            else {
-                // @todo check if is in range
-                var dataItem = series.dataItems[result.index - 1];
-                if (dataItem) {
-                    if (dataItem.open && dataItem.close) {
-                        var open_2 = dataItem.open[fieldName];
-                        var close_2 = dataItem.close[fieldName];
-                        if (value >= open_2 && value <= close_2) {
-                            return dataItem;
-                        }
+            if (first) {
+                return first;
+            }
+            if (second) {
+                return second;
+            }
+        }
+        else {
+            // @todo check if is in range
+            const dataItem = series.dataItems[result.index - 1];
+            if (dataItem) {
+                if (dataItem.open && dataItem.close) {
+                    let open = dataItem.open[fieldName];
+                    let close = dataItem.close[fieldName];
+                    if (value >= open && value <= close) {
+                        return dataItem;
                     }
                 }
             }
         }
-    });
+    }
     /**
      * @ignore
      */
-    Object.defineProperty(DateAxis.prototype, "shouldGap", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (dataItem, nextItem, autoGapCount, fieldName) {
-            var value1 = dataItem.get(fieldName);
-            var value2 = nextItem.get(fieldName);
-            if (value2 - value1 > this.baseDuration() * autoGapCount) {
-                return true;
-            }
-            return false;
+    shouldGap(dataItem, nextItem, autoGapCount, fieldName) {
+        const value1 = dataItem.get(fieldName);
+        const value2 = nextItem.get(fieldName);
+        if (value2 - value1 > this.baseDuration() * autoGapCount) {
+            return true;
         }
-    });
+        return false;
+    }
     /**
      * Zooms the axis to specific `start` and `end` dates.
      *
@@ -889,14 +732,9 @@ var DateAxis = /** @class */ (function (_super) {
      * @param  end       End Date
      * @param  duration  Duration in milliseconds
      */
-    Object.defineProperty(DateAxis.prototype, "zoomToDates", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (start, end, duration) {
-            this.zoomToValues(start.getTime(), end.getTime(), duration);
-        }
-    });
+    zoomToDates(start, end, duration) {
+        this.zoomToValues(start.getTime(), end.getTime(), duration);
+    }
     /**
      * Returns a `Date` object corresponding to specific position within plot
      * area.
@@ -904,14 +742,9 @@ var DateAxis = /** @class */ (function (_super) {
      * @param   position  Pposition
      * @return            Date
      */
-    Object.defineProperty(DateAxis.prototype, "positionToDate", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (position) {
-            return new Date(this.positionToValue(position));
-        }
-    });
+    positionToDate(position) {
+        return new Date(this.positionToValue(position));
+    }
     /**
      * Returns a relative position within plot area that corresponds to specific
      * date.
@@ -919,14 +752,9 @@ var DateAxis = /** @class */ (function (_super) {
      * @param   date  Date
      * @return        Position
      */
-    Object.defineProperty(DateAxis.prototype, "dateToPosition", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function (date) {
-            return this.valueToPosition(date.getTime());
-        }
-    });
+    dateToPosition(date) {
+        return this.valueToPosition(date.getTime());
+    }
     /**
      * Returns position span between start and end of a single cell in axis.
      *
@@ -934,32 +762,25 @@ var DateAxis = /** @class */ (function (_super) {
      * @return Position
      * @ignore
      */
-    Object.defineProperty(DateAxis.prototype, "getCellWidthPosition", {
-        enumerable: false,
-        configurable: true,
-        writable: true,
-        value: function () {
-            var max = this.getPrivate("selectionMax", this.getPrivate("max"));
-            var min = this.getPrivate("selectionMin", this.getPrivate("min"));
-            if ($type.isNumber(max) && $type.isNumber(min)) {
-                return this.baseDuration() / (max - min);
-            }
-            return 0.05;
+    getCellWidthPosition() {
+        let max = this.getPrivate("selectionMax", this.getPrivate("max"));
+        let min = this.getPrivate("selectionMin", this.getPrivate("min"));
+        if ($type.isNumber(max) && $type.isNumber(min)) {
+            return this.baseDuration() / (max - min);
         }
-    });
-    Object.defineProperty(DateAxis, "className", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "DateAxis"
-    });
-    Object.defineProperty(DateAxis, "classNames", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: ValueAxis.classNames.concat([DateAxis.className])
-    });
-    return DateAxis;
-}(ValueAxis));
-export { DateAxis };
+        return 0.05;
+    }
+}
+Object.defineProperty(DateAxis, "className", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "DateAxis"
+});
+Object.defineProperty(DateAxis, "classNames", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: ValueAxis.classNames.concat([DateAxis.className])
+});
 //# sourceMappingURL=DateAxis.js.map