@pirireis/webglobeplugins 0.9.11 → 0.9.13

package/util/heatwavedatamanager/datamanager.js

@@ -1,64 +1,16 @@
-"use strict";
 /**
  * todo:
  * data must be processed before being set to the cache
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var DataManager = /** @class */ (function () {
+export default class DataManager {
     /**
      *
      * @param {Array<number>} timeEpocs | array of time epocs
      * @param {Function} fetchMethod | fetchMethod(time) => Promise<data>
      * @param {boolean} autoDownload | auto download data or not
     */
-    function DataManager(timeEpocs, fetchMethod, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.autoDownload, autoDownload = _c === void 0 ? true : _c;
-        this._timeEpocs = timeEpocs.sort(function (a, b) { return a - b; });
+    constructor(timeEpocs, fetchMethod, { autoDownload = true } = {}) {
+        this._timeEpocs = timeEpocs.sort((a, b) => a - b);
         this._datas = [];
         this._datas.length = timeEpocs.length;
         // in construction
@@ -71,13 +23,12 @@ var DataManager = /** @class */ (function () {
         this._lastIndex = -1;
         this.autoDownload(autoDownload);
     }
-    DataManager.prototype.autoDownload = function (bool, time) {
-        var _this = this;
+    autoDownload(bool, time) {
         if (!bool) {
             this._autoDownload = false;
             return;
         }
-        var index = this._lastIndex === -1 ? 0 : this._lastIndex;
+        let index = this._lastIndex === -1 ? 0 : this._lastIndex;
         if (time !== undefined) {
             if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
                 this._autoDownload = bool;
@@ -89,11 +40,11 @@ var DataManager = /** @class */ (function () {
             return;
         this._downloadStartIndex = index;
         this._autoDownload = bool;
-        var recursion = function (startId, currentDownloadId) {
-            if (startId !== _this._downloadStartIndex)
+        const recursion = (startId, currentDownloadId) => {
+            if (startId !== this._downloadStartIndex)
                 return;
-            if (currentDownloadId < _this._timeEpocs.length && _this._autoDownload) {
-                _this._getData(currentDownloadId).then(function () {
+            if (currentDownloadId < this._timeEpocs.length && this._autoDownload) {
+                this._getData(currentDownloadId).then(() => {
                     recursion(startId, currentDownloadId + 1);
                 });
             }
@@ -102,29 +53,28 @@ var DataManager = /** @class */ (function () {
         // save index as start index
         //start recursive download
         // use started id as a flag to stop the download
-    };
+    }
     /**
      * @param {number} time
      * It looks like async function is not needed here. changes just overwrites the previous changes.
      */
-    DataManager.prototype.updateTime = function (time) {
-        var _this = this;
+    updateTime(time) {
         if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
             this._dontRender();
             return;
         }
         this._lastTime = time;
-        var index = this._findIndex(time);
-        var ratio = this._getRatio(time, index);
-        Promise.all([this._getData(index - 1), this._getData(index)]).then(function (datas) {
-            if (_this._lastTime === time) {
-                _this._lastIndex = index;
-                _this._ratio = ratio;
-                _this._pushCallback(ratio, datas);
+        const index = this._findIndex(time);
+        const ratio = this._getRatio(time, index);
+        Promise.all([this._getData(index - 1), this._getData(index)]).then((datas) => {
+            if (this._lastTime === time) {
+                this._lastIndex = index;
+                this._ratio = ratio;
+                this._pushCallback(ratio, datas);
             }
         });
-    };
-    DataManager.prototype.register = function (key, callback) {
+    }
+    register(key, callback) {
         if (this._callbackmethodOwners.indexOf(key) !== -1) {
             console.warn("key already registered, old one is unregistered");
             this.unregister(key);
@@ -133,12 +83,12 @@ var DataManager = /** @class */ (function () {
         this._callbackmethodOwners.push(key);
         if (this._lastIndex !== -1)
             callback(this._ratio, this._datas[this._lastIndex - 1], this._datas[this._lastIndex]);
-    };
+    }
     /**
      * @param {*} key | id of the owner of the callback
      */
-    DataManager.prototype.unregister = function (key) {
-        var index = this._callbackmethodOwners.indexOf(key);
+    unregister(key) {
+        let index = this._callbackmethodOwners.indexOf(key);
         if (index !== -1) {
             this._callbackmethods.splice(index, 1);
             this._callbackmethodOwners.splice(index, 1);
@@ -146,15 +96,15 @@ var DataManager = /** @class */ (function () {
         if (this._callbackmethods.length === 0) {
             this.free();
         }
-    };
-    DataManager.prototype.free = function () {
+    }
+    free() {
         this._callbackmethods = [];
         this._callbackmethodOwners = [];
         this._autoDownload = false;
-    };
-    DataManager.prototype._findIndex = function (time) {
-        var _timeEpocs = this._timeEpocs;
-        var index = this._lastIndex === -1 ? 1 : this._lastIndex;
+    }
+    _findIndex(time) {
+        const { _timeEpocs } = this;
+        let index = this._lastIndex === -1 ? 1 : this._lastIndex;
         if (this)
             if (time < _timeEpocs[index - 1]) {
                 while (index > 1 && time < _timeEpocs[index - 1]) {
@@ -167,46 +117,33 @@ var DataManager = /** @class */ (function () {
                 }
             }
         return index;
-    };
-    DataManager.prototype._getRatio = function (time, index) {
+    }
+    _getRatio(time, index) {
         return (time - this._timeEpocs[index - 1]) / (this._timeEpocs[index] - this._timeEpocs[index - 1]);
-    };
-    DataManager.prototype._pushCallback = function (ratio, datas) {
-        var _a;
-        for (var i = 0; i < this._callbackmethods.length; i++) {
-            (_a = this._callbackmethods)[i].apply(_a, __spreadArray([ratio], datas, false));
+    }
+    _pushCallback(ratio, datas) {
+        for (let i = 0; i < this._callbackmethods.length; i++) {
+            this._callbackmethods[i](ratio, ...datas);
         }
-    };
-    DataManager.prototype._getData = function (index) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (index < 0 || index >= this._timeEpocs.length) {
-                            throw new Error("Index out of range");
-                        }
-                        if (!this._datas[index]) {
-                            if (!this._dataPromises[index])
-                                this._dataPromises[index] = this._fetchMethod(this._timeEpocs[index]).then(function (data) {
-                                    _this._datas[index] = data;
-                                }, function (error) {
-                                    console.error("error", error);
-                                }).finally(function () {
-                                    _this._dataPromises[index] = null;
-                                });
-                        }
-                        return [4 /*yield*/, this._dataPromises[index]];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this._datas[index]];
-                }
-            });
-        });
-    };
-    DataManager.prototype._dontRender = function () {
+    }
+    async _getData(index) {
+        if (index < 0 || index >= this._timeEpocs.length) {
+            throw new Error("Index out of range");
+        }
+        if (!this._datas[index]) {
+            if (!this._dataPromises[index])
+                this._dataPromises[index] = this._fetchMethod(this._timeEpocs[index]).then((data) => {
+                    this._datas[index] = data;
+                }, (error) => {
+                    console.error("error", error);
+                }).finally(() => {
+                    this._dataPromises[index] = null;
+                });
+        }
+        await this._dataPromises[index];
+        return this._datas[index];
+    }
+    _dontRender() {
         this._pushCallback(0, [null, null]);
-    };
-    return DataManager;
-}());
-exports.default = DataManager;
+    }
+}

package/util/heatwavedatamanager/index.js

@@ -1,10 +1,3 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PointCoordinatesDataCalculator = exports.HeatWaveDataManager = void 0;
-var pointcoordinatesdatacalculator_1 = __importDefault(require("./pointcoordinatesdatacalculator"));
-exports.PointCoordinatesDataCalculator = pointcoordinatesdatacalculator_1.default;
-var datamanager_1 = __importDefault(require("./datamanager"));
-exports.HeatWaveDataManager = datamanager_1.default;
+import PointCoordinatesDataCalculator from "./pointcoordinatesdatacalculator";
+import HeatWaveDataManager from "./datamanager";
+export { HeatWaveDataManager, PointCoordinatesDataCalculator };

package/util/heatwavedatamanager/pointcoordinatesdatacalculator.js

@@ -1,20 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import PointCoordsMeta from "./pointcoordsmeta";
+const pointObject = (long, lat, posIndex, callback) => {
+    return { long, lat, posIndex, callback };
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-var pointcoordsmeta_1 = __importDefault(require("./pointcoordsmeta"));
-var pointObject = function (long, lat, posIndex, callback) {
-    return { long: long, lat: lat, posIndex: posIndex, callback: callback };
-};
-var PointCoordinatesDataCalculator = /** @class */ (function () {
-    function PointCoordinatesDataCalculator(bbox, width, height) {
+export default class PointCoordinatesDataCalculator {
+    constructor(bbox, width, height) {
         this._pointObjects = {};
         this._ratio = 0.0;
         this._bbox = bbox;
         this._width = width;
         this._height = height;
-        this._metaCalculater = new pointcoordsmeta_1.default(bbox, width, height);
+        this._metaCalculater = new PointCoordsMeta(bbox, width, height);
         this._texture0 = null;
         this._texture1 = null;
     }
@@ -25,51 +20,49 @@ var PointCoordinatesDataCalculator = /** @class */ (function () {
      * @param {*} long
      * @param {*} callback | callback(data0, data1, interpolated)
      */
-    PointCoordinatesDataCalculator.prototype.registerPoint = function (key, long, lat, callback) {
+    registerPoint(key, long, lat, callback) {
         if (key in this._pointObjects) {
             console.warn("key already registered, old one is unregistered");
             this.unregisterPoint(key);
         }
         if (!this._isInBBox(long, lat))
             return false;
-        var meta = this._metaCalculater.getFlooredMeta(long, lat);
+        const meta = this._metaCalculater.getFlooredMeta(long, lat);
         this._pointObjects[key] = pointObject(long, lat, meta.index, callback);
         if (this._texture0 && this._texture1) {
-            var _a = this._findAPoint(meta.index), data0 = _a.data0, data1 = _a.data1, interpolated = _a.interpolated;
+            const { data0, data1, interpolated } = this._findAPoint(meta.index);
             callback(data0, data1, interpolated);
         }
         return true;
-    };
-    PointCoordinatesDataCalculator.prototype._isInBBox = function (long, lat) {
+    }
+    _isInBBox(long, lat) {
         return lat >= this._bbox[1] && lat <= this._bbox[3] && long >= this._bbox[0] && long <= this._bbox[2];
-    };
-    PointCoordinatesDataCalculator.prototype.unregisterPoint = function (key) {
+    }
+    unregisterPoint(key) {
         if (!(key in this._pointObjects))
             return false;
         delete this._pointObjects[key];
         return true;
-    };
-    PointCoordinatesDataCalculator.prototype.updatePoint = function (key, long, lat) {
+    }
+    updatePoint(key, long, lat) {
         if (!(key in this._pointObjects))
             return false;
         if (!this._isInBBox(long, lat))
             return false;
         this._pointObjects[key].long = long;
         this._pointObjects[key].lat = lat;
-        var meta = this._metaCalculater.getFlooredMeta(long, lat);
+        const meta = this._metaCalculater.getFlooredMeta(long, lat);
         this._pointObjects[key].posIndex = meta.index;
-        var _a = this._findAPoint(meta.index), data0 = _a.data0, data1 = _a.data1, interpolated = _a.interpolated;
+        const { data0, data1, interpolated } = this._findAPoint(meta.index);
         this._pointObjects[key].callback(data0, data1, interpolated);
         return true;
-    };
+    }
     /**
      * @param {Number} ratio 0-1
      * @param {} textureData0
      * @param {*} textureData1
      */
-    PointCoordinatesDataCalculator.prototype.updateData = function (ratio, textureData0, textureData1) {
-        if (textureData0 === void 0) { textureData0 = null; }
-        if (textureData1 === void 0) { textureData1 = null; }
+    updateData(ratio, textureData0 = null, textureData1 = null) {
         if (!textureData0 && !textureData1) {
             this._pushPointCallBackEmpty();
             return;
@@ -80,32 +73,30 @@ var PointCoordinatesDataCalculator = /** @class */ (function () {
         }
         this._ratio = ratio;
         this._pushPointCallbackAll();
-    };
-    PointCoordinatesDataCalculator.prototype._findAPoint = function (posIndex) {
-        var data0 = this._texture0[posIndex];
-        var data1 = this._texture1[posIndex];
-        var interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
-        return { data0: data0, data1: data1, interpolated: interpolated };
-    };
-    PointCoordinatesDataCalculator.prototype._pushPointCallbackAll = function () {
-        for (var key in this._pointObjects) {
-            var _a = this._pointObjects[key], posIndex = _a.posIndex, callback = _a.callback;
-            var _b = this._findAPoint(posIndex), data0 = _b.data0, data1 = _b.data1, interpolated = _b.interpolated;
+    }
+    _findAPoint(posIndex) {
+        const data0 = this._texture0[posIndex];
+        const data1 = this._texture1[posIndex];
+        const interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
+        return { data0, data1, interpolated };
+    }
+    _pushPointCallbackAll() {
+        for (const key in this._pointObjects) {
+            const { posIndex, callback } = this._pointObjects[key];
+            const { data0, data1, interpolated } = this._findAPoint(posIndex);
             callback(data0, data1, interpolated);
         }
-    };
-    PointCoordinatesDataCalculator.prototype._pushPointCallBackEmpty = function () {
-        for (var key in this._pointObjects) {
-            var callback = this._pointObjects[key].callback;
+    }
+    _pushPointCallBackEmpty() {
+        for (const key in this._pointObjects) {
+            const { callback } = this._pointObjects[key];
             callback(null, null, null);
         }
-    };
-    PointCoordinatesDataCalculator.prototype.flush = function () {
+    }
+    flush() {
         this._pointObjects = {};
-    };
-    return PointCoordinatesDataCalculator;
-}());
-exports.default = PointCoordinatesDataCalculator;
+    }
+}
 // function test() {
 //     const cp = window.plugin.getPointCoordinatesDataCalculator();
 //     const bbox = [-15, 25, 70, 60];

package/util/heatwavedatamanager/pointcoordsmeta.js

@@ -1,21 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var PointCoordsMeta = /** @class */ (function () {
-    function PointCoordsMeta(bbox, width, height) {
+export default class PointCoordsMeta {
+    constructor(bbox, width, height) {
         this._bbox = bbox;
         this._width = width;
         this._height = height;
         this._xRatio = this._width / (this._bbox[2] - this._bbox[0]);
         this._yRatio = this._height / (this._bbox[3] - this._bbox[1]);
     }
-    PointCoordsMeta.prototype.getFlooredMeta = function (long, lat) {
-        var x = (long - this._bbox[0]) * this._xRatio;
-        var y = (this._bbox[3] - lat) * this._yRatio;
+    getFlooredMeta(long, lat) {
+        let x = (long - this._bbox[0]) * this._xRatio;
+        let y = (this._bbox[3] - lat) * this._yRatio;
         x = x > 0 ? x - 1 : 0;
         y = y > 0 ? y - 1 : 0;
-        var index = Math.floor(y) * this._width + Math.floor(x);
-        return { index: index };
-    };
-    return PointCoordsMeta;
-}());
-exports.default = PointCoordsMeta;
+        const index = Math.floor(y) * this._width + Math.floor(x);
+        return { index };
+    }
+}

package/util/index.js

@@ -1,57 +1,13 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.heatwavedatamanager = exports.programs = exports.webglobe = exports.geometry = exports.shaderfunctions = exports.webglobjectbuilders = void 0;
-var webglobjectbuilders = __importStar(require("./webglobjectbuilders"));
-exports.webglobjectbuilders = webglobjectbuilders;
-var shaderfunctions = __importStar(require("./shaderfunctions"));
-exports.shaderfunctions = shaderfunctions;
-var geometry = __importStar(require("./geometry"));
-exports.geometry = geometry;
-var webglobe = __importStar(require("./webglobe"));
-exports.webglobe = webglobe;
-var programs = __importStar(require("./programs"));
-exports.programs = programs;
-var heatwavedatamanager = __importStar(require("./heatwavedatamanager"));
-exports.heatwavedatamanager = heatwavedatamanager;
-__exportStar(require("./webglobe"), exports);
-__exportStar(require("./webglobjectbuilders"), exports);
-__exportStar(require("./shaderfunctions"), exports);
-__exportStar(require("./geometry"), exports);
-__exportStar(require("./programs"), exports);
-__exportStar(require("./heatwavedatamanager"), exports);
+import * as webglobjectbuilders from './webglobjectbuilders';
+import * as shaderfunctions from './shaderfunctions';
+import * as geometry from './geometry';
+import * as webglobe from './webglobe';
+import * as programs from './programs';
+import * as heatwavedatamanager from './heatwavedatamanager';
+export { webglobjectbuilders, shaderfunctions, geometry, webglobe, programs, heatwavedatamanager };
+export * from './webglobe';
+export * from './webglobjectbuilders';
+export * from './shaderfunctions';
+export * from './geometry';
+export * from './programs';
+export * from './heatwavedatamanager';

package/util/interpolation/timetrack/index.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWorker = void 0;
-var createWorker = function () { return new Worker(new URL('./web-worker.js', import.meta.url), { type: 'module' }); };
-exports.createWorker = createWorker;
+const createWorker = () => new Worker(new URL('./web-worker.js', import.meta.url), { type: 'module' });
+export { createWorker };

package/util/interpolation/timetrack/timetrack-interpolator.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GEOMETRY = exports.TimeTrackInterpolator = void 0;
-var search_binary_1 = require("../../algorithms/search-binary");
-var methods_1 = require("../../../Math/methods");
+import { findFirstIndexInRange } from '../../algorithms/search-binary';
+import { sphericalLinearInterpolation_Cartesian3d, sphericalLinearInterpolation_Mercator, } from '../../../Math/methods';
 /**
  * @typedef {Array<number>} vec3 [x, y, z]
  * @typedef {Array<number>} vec2 [x, y]
@@ -10,20 +7,18 @@ var methods_1 = require("../../../Math/methods");
  * @typedef {number} fraction a number between 0 and 1
  * @typedef {Array<number>} wgs84 [long, lat]
  */
-var GEOMETRY = Object.freeze({
+const GEOMETRY = Object.freeze({
     CARTESIAN3D: 0,
     MERCATOR: 1,
 });
-exports.GEOMETRY = GEOMETRY;
-var TimeTrackInterpolator = /** @class */ (function () {
+class TimeTrackInterpolator {
     /**
      * @typedef Timetrack
      * @property {Array<vec4>}} coordinates [x,y,z, length]
      * @property {Array<Number>} times
      * @param {Array<Timetrack>} timeTracks
      */
-    function TimeTrackInterpolator(_a) {
-        var _b = _a === void 0 ? {} : _a, timeTracks = _b.timeTracks, _c = _b.bbox, bbox = _c === void 0 ? null : _c, _d = _b.geometry, geometry = _d === void 0 ? GEOMETRY.CARTESIAN3D : _d;
+    constructor({ timeTracks, bbox = null, geometry = GEOMETRY.CARTESIAN3D } = {}) {
         this.timeTracks = null;
         this.timeTracksStartTimes = null;
         this.geometry = geometry;
@@ -32,50 +27,49 @@ var TimeTrackInterpolator = /** @class */ (function () {
         if (bbox)
             this.setBbox(bbox);
     }
-    TimeTrackInterpolator.prototype.setGeometry = function (geometry) {
+    setGeometry(geometry) {
         if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {
             throw new Error('Invalid geometry');
         }
         this.geometry = geometry;
-    };
-    TimeTrackInterpolator.prototype.setTimetracks = function (timeTracks) {
+    }
+    setTimetracks(timeTracks) {
         this.timeTracks = timeTracks;
-    };
-    TimeTrackInterpolator.prototype.interpolate = function (time) {
-        var _a = this, timeTracks = _a.timeTracks, geometry = _a.geometry;
+    }
+    interpolate(time) {
+        const { timeTracks, geometry } = this;
         if (!timeTracks) {
             return null;
         }
-        var resultArray = [];
-        var info = {
+        const resultArray = [];
+        const info = {
             outOfRange: 0,
             processed: 0,
         };
-        for (var i = 0; i < timeTracks.length; i++) {
-            var _b = timeTracks[i], times = _b.times, coordinates = _b.coordinates;
+        for (let i = 0; i < timeTracks.length; i++) {
+            const { times, coordinates } = timeTracks[i];
             if (times[times.length - 1] < time)
                 continue;
             info.processed++;
-            var timeIndex = (0, search_binary_1.findFirstIndexInRange)(times, time);
+            const timeIndex = findFirstIndexInRange(times, time);
             if (timeIndex === null) {
                 info.outOfRange++;
                 continue;
             }
-            var timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
-            var interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
-                (0, methods_1.sphericalLinearInterpolation_Cartesian3d)(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
-                (0, methods_1.sphericalLinearInterpolation_Mercator)(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
-            resultArray.push.apply(resultArray, interpolated);
+            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
+            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
+                sphericalLinearInterpolation_Cartesian3d(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
+                sphericalLinearInterpolation_Mercator(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            resultArray.push(...interpolated);
         }
         return new Float32Array(resultArray);
-    };
+    }
     // implicit methods
-    TimeTrackInterpolator.prototype._orderTimeTracks = function () {
-        this.timeTracks.sort(function (a, b) { return a.times[0] - b.times[0]; });
-    };
-    TimeTrackInterpolator.prototype._setStartTimes = function () {
-        this.timeTracksStartTimes = this.timeTracks.map(function (tt) { return tt.times[0]; });
-    };
-    return TimeTrackInterpolator;
-}());
-exports.TimeTrackInterpolator = TimeTrackInterpolator;
+    _orderTimeTracks() {
+        this.timeTracks.sort((a, b) => a.times[0] - b.times[0]);
+    }
+    _setStartTimes() {
+        this.timeTracksStartTimes = this.timeTracks.map(tt => tt.times[0]);
+    }
+}
+export { TimeTrackInterpolator, GEOMETRY };