@pirireis/webglobeplugins 0.9.11 → 0.9.12

package/util/account/single-attribute-buffer-management/buffer-manager.js

@@ -19,10 +19,13 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BufferManager = void 0;
-var BufferManager = /** @class */ (function () {
-    function BufferManager(gl, itemSize, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.bufferType, bufferType = _c === void 0 ? "STATIC_DRAW" : _c, _d = _b.buffer, buffer = _d === void 0 ? null : _d, _e = _b.initialCapacity, initialCapacity = _e === void 0 ? null : _e;
-        this.isFreed = false;
+class BufferManager {
+    gl;
+    buffer;
+    itemSize;
+    bufferType;
+    isFreed = false;
+    constructor(gl, itemSize, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = null } = {}) {
         this.gl = gl;
         this.itemSize = itemSize;
         this.bufferType = bufferType;
@@ -30,47 +33,45 @@ var BufferManager = /** @class */ (function () {
         if (initialCapacity !== null)
             this.resetWithCapacity(initialCapacity);
     }
-    BufferManager.prototype.resetWithCapacity = function (capacity) {
-        var _a = this, gl = _a.gl, buffer = _a.buffer, bufferType = _a.bufferType, itemSize = _a.itemSize;
+    resetWithCapacity(capacity) {
+        const { gl, buffer, bufferType, itemSize } = this;
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
         // @ts-ignore
         gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    };
-    BufferManager.prototype.deleteBulk = function (offsets) {
-        var _a = this, gl = _a.gl, buffer = _a.buffer, itemSize = _a.itemSize;
-        var emptyBlock = new Float32Array(this.itemSize).fill(NaN);
-        var offsetMultiplier = itemSize * 4;
+    }
+    deleteBulk(offsets) {
+        const { gl, buffer, itemSize } = this;
+        const emptyBlock = new Float32Array(this.itemSize).fill(NaN);
+        const offsetMultiplier = itemSize * 4;
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        for (var _i = 0, offsets_1 = offsets; _i < offsets_1.length; _i++) {
-            var offset = offsets_1[_i];
+        for (let offset of offsets) {
             if (offset !== undefined) {
                 gl.bufferSubData(gl.ARRAY_BUFFER, offset * offsetMultiplier, emptyBlock);
             }
         }
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    };
-    BufferManager.prototype.insertBulk = function (blocks, offsets) {
-        var _a = this, gl = _a.gl, buffer = _a.buffer, itemSize = _a.itemSize;
+    }
+    insertBulk(blocks, offsets) {
+        const { gl, buffer, itemSize } = this;
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        var offsetMultiplier = itemSize * 4;
-        for (var i = 0; i < blocks.length; i++) {
-            var block = blocks[i];
-            var offset = offsets[i] * offsetMultiplier;
+        const offsetMultiplier = itemSize * 4;
+        for (let i = 0; i < blocks.length; i++) {
+            const block = blocks[i];
+            const offset = offsets[i] * offsetMultiplier;
             if (offset !== undefined)
                 gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
         }
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    };
+    }
     // TODO: this is broken
-    BufferManager.prototype.defrag = function (offsetValues, occupiedCapacity, newCapacity) {
-        var _a = this, gl = _a.gl, buffer = _a.buffer, bufferType = _a.bufferType, itemSize = _a.itemSize;
-        var newArray = new Float32Array(newCapacity * itemSize);
-        var bufferData = this._getBufferData(occupiedCapacity);
-        var newOffset = 0;
-        for (var _i = 0, offsetValues_1 = offsetValues; _i < offsetValues_1.length; _i++) {
-            var offset = offsetValues_1[_i];
-            var itemOffset = offset * itemSize;
+    defrag(offsetValues, occupiedCapacity, newCapacity) {
+        const { gl, buffer, bufferType, itemSize } = this;
+        const newArray = new Float32Array(newCapacity * itemSize);
+        const bufferData = this._getBufferData(occupiedCapacity);
+        let newOffset = 0;
+        for (const offset of offsetValues) {
+            const itemOffset = offset * itemSize;
             newArray.set(bufferData.slice(itemOffset, itemOffset + itemSize), newOffset);
             newOffset += itemSize;
         }
@@ -79,34 +80,33 @@ var BufferManager = /** @class */ (function () {
         gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
         gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    };
-    BufferManager.prototype.extendBuffer = function (occupiedCapacity, newCapacity) {
-        var _a = this, gl = _a.gl, buffer = _a.buffer, bufferType = _a.bufferType;
-        var itemSize = this.itemSize;
-        var bufferData = this._getBufferData(occupiedCapacity);
+    }
+    extendBuffer(occupiedCapacity, newCapacity) {
+        const { gl, buffer, bufferType } = this;
+        const itemSize = this.itemSize;
+        const bufferData = this._getBufferData(occupiedCapacity);
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
         // @ts-ignore
         gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
         gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    };
-    BufferManager.prototype._getBufferData = function (occupiedCapacity) {
-        var _a = this, gl = _a.gl, buffer = _a.buffer;
-        var size = occupiedCapacity * this.itemSize;
-        var bufferData = new Float32Array(size);
+    }
+    _getBufferData(occupiedCapacity) {
+        const { gl, buffer } = this;
+        const size = occupiedCapacity * this.itemSize;
+        const bufferData = new Float32Array(size);
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
         gl.getBufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
         return bufferData;
-    };
-    BufferManager.prototype.free = function () {
+    }
+    free() {
         if (this.isFreed)
             return;
         this.gl.deleteBuffer(this.buffer);
         // this.buffer = null;
         // this.gl = null;
         this.isFreed = true;
-    };
-    return BufferManager;
-}());
+    }
+}
 exports.BufferManager = BufferManager;

package/util/account/single-attribute-buffer-management/buffer-orchestrator.js

@@ -1,50 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BufferOrchestrator = void 0;
-var EXTRA_SIZE = 10;
-var BufferOrchestrator = /** @class */ (function () {
-    function BufferOrchestrator(_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.capacity, capacity = _c === void 0 ? 10 : _c;
+const EXTRA_SIZE = 10;
+class BufferOrchestrator {
+    _capacity;
+    offsetMap;
+    tombstoneOffsets;
+    _length;
+    constructor({ capacity = 10 } = {}) {
         this._capacity = capacity;
         this.offsetMap = new Map();
         this.tombstoneOffsets = [];
         this._length = 0;
     }
-    BufferOrchestrator.prototype.resetWithCapacity = function (bufferManagersMap, capacity) {
-        if (capacity === void 0) { capacity = null; }
+    resetWithCapacity(bufferManagersMap, capacity = null) {
         this._capacity = capacity !== null ? capacity : this._capacity;
-        for (var _i = 0, bufferManagersMap_1 = bufferManagersMap; _i < bufferManagersMap_1.length; _i++) {
-            var _a = bufferManagersMap_1[_i], key = _a[0], bufferManager = _a[1].bufferManager;
+        for (const [key, { bufferManager }] of bufferManagersMap) {
             bufferManager.resetWithCapacity(this._capacity);
         }
         this.offsetMap.clear();
         this.tombstoneOffsets = [];
         this._length = 0;
-    };
-    BufferOrchestrator.prototype.insertBulk = function (items, bufferManagersMap) {
+    }
+    insertBulk(items, bufferManagersMap) {
         this.autoExtendBuffers(items.length, bufferManagersMap);
-        var offsetMap = this.offsetMap;
-        var offsets = [];
-        for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
-            var item = items_1[_i];
-            var o = offsetMap.get(item.key);
-            var offset = o !== undefined ? o : this.nextOffset();
+        const { offsetMap } = this;
+        const offsets = [];
+        for (const item of items) {
+            let o = offsetMap.get(item.key);
+            const offset = o !== undefined ? o : this.nextOffset();
             offsetMap.set(item.key, offset);
             offsets.push(offset);
         }
-        for (var _a = 0, bufferManagersMap_2 = bufferManagersMap; _a < bufferManagersMap_2.length; _a++) {
-            var _b = bufferManagersMap_2[_a], key = _b[0], _c = _b[1], bufferManager = _c.bufferManager, adaptor = _c.adaptor;
+        for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
             bufferManager.insertBulk(items.map(adaptor), offsets);
         }
-    };
+    }
     // does not assign offset to the new items.
-    BufferOrchestrator.prototype.updateBulk = function (items, bufferManagersMap, bufferKeys) {
-        if (bufferKeys === void 0) { bufferKeys = null; }
-        var offsetMap = this.offsetMap;
-        var offsets = [];
-        for (var _i = 0, items_2 = items; _i < items_2.length; _i++) {
-            var item = items_2[_i];
-            var offset = offsetMap.get(item.key);
+    updateBulk(items, bufferManagersMap, bufferKeys = null) {
+        const { offsetMap } = this;
+        const offsets = [];
+        for (const item of items) {
+            const offset = offsetMap.get(item.key);
             if (offset !== undefined) {
                 offsets.push(offset);
             }
@@ -53,79 +50,71 @@ var BufferOrchestrator = /** @class */ (function () {
             }
         }
         if (bufferKeys) {
-            for (var _a = 0, bufferKeys_1 = bufferKeys; _a < bufferKeys_1.length; _a++) {
-                var key = bufferKeys_1[_a];
-                var bufferManagerComp = bufferManagersMap.get(key);
+            for (const key of bufferKeys) {
+                const bufferManagerComp = bufferManagersMap.get(key);
                 if (bufferManagerComp === undefined)
                     throw new Error("updateBulk bufferKey does not exist");
-                var bufferManager = bufferManagerComp.bufferManager, adaptor = bufferManagerComp.adaptor;
+                const { bufferManager, adaptor } = bufferManagerComp;
                 bufferManager.insertBulk(items.map(adaptor), offsets);
             }
         }
         else {
-            for (var _b = 0, bufferManagersMap_3 = bufferManagersMap; _b < bufferManagersMap_3.length; _b++) {
-                var _c = bufferManagersMap_3[_b], key = _c[0], _d = _c[1], bufferManager = _d.bufferManager, adaptor = _d.adaptor;
+            for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
                 bufferManager.insertBulk(items.map(adaptor), offsets);
             }
         }
-    };
-    BufferOrchestrator.prototype.deleteBulk = function (keys, bufferManagersMap) {
-        var offsets = [];
-        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-            var key = keys_1[_i];
-            var offset = this.getOffset(key);
+    }
+    deleteBulk(keys, bufferManagersMap) {
+        const offsets = [];
+        for (const key of keys) {
+            const offset = this.getOffset(key);
             if (offset !== undefined) {
                 offsets.push(offset);
                 this.offsetMap.delete(key);
                 this.tombstoneOffsets.push(offset);
             }
         }
-        for (var _a = 0, bufferManagersMap_4 = bufferManagersMap; _a < bufferManagersMap_4.length; _a++) {
-            var _b = bufferManagersMap_4[_a], key = _b[0], bufferManager = _b[1].bufferManager;
+        for (const [key, { bufferManager }] of bufferManagersMap) {
             bufferManager.deleteBulk(offsets);
         }
-    };
-    BufferOrchestrator.prototype.getOffset = function (key) {
+    }
+    getOffset(key) {
         return this.offsetMap.get(key);
-    };
-    BufferOrchestrator.prototype.nextOffset = function () {
+    }
+    nextOffset() {
         if (this.tombstoneOffsets.length > 0) {
-            var offset = this.tombstoneOffsets.pop();
+            const offset = this.tombstoneOffsets.pop();
             return offset;
         }
         if (this._length < this._capacity) {
             return this._length++;
         }
         return false;
-    };
-    BufferOrchestrator.prototype.autoExtendBuffers = function (itemsLength, bufferManagersMap) {
+    }
+    autoExtendBuffers(itemsLength, bufferManagersMap) {
         if (itemsLength <= this.emptySpace)
             return;
-        var newCapacity = this.length + itemsLength;
-        for (var _i = 0, bufferManagersMap_5 = bufferManagersMap; _i < bufferManagersMap_5.length; _i++) {
-            var _a = bufferManagersMap_5[_i], key = _a[0], bufferManager = _a[1].bufferManager;
+        const newCapacity = this.length + itemsLength;
+        for (const [key, { bufferManager }] of bufferManagersMap) {
             bufferManager.extendBuffer(this.length, newCapacity);
         }
         this._capacity = newCapacity;
-    };
-    BufferOrchestrator.prototype.defrag = function (bufferManagers, bufferKeys) {
-        var offsetMap = this.offsetMap;
-        var newCapacity = offsetMap.size + EXTRA_SIZE;
+    }
+    defrag(bufferManagers, bufferKeys) {
+        const offsetMap = this.offsetMap;
+        const newCapacity = offsetMap.size + EXTRA_SIZE;
         if (bufferKeys) {
-            for (var _i = 0, bufferKeys_2 = bufferKeys; _i < bufferKeys_2.length; _i++) {
-                var key = bufferKeys_2[_i];
-                var offset = offsetMap.get(key);
+            for (const key of bufferKeys) {
+                const offset = offsetMap.get(key);
                 if (offset !== undefined) {
-                    for (var _a = 0, bufferManagers_1 = bufferManagers; _a < bufferManagers_1.length; _a++) {
-                        var _b = bufferManagers_1[_a], key_1 = _b[0], bufferManager = _b[1].bufferManager;
+                    for (const [key, { bufferManager }] of bufferManagers) {
                         bufferManager.defrag([offset], this.length, newCapacity);
                     }
                 }
             }
         }
         else {
-            for (var _c = 0, bufferManagers_2 = bufferManagers; _c < bufferManagers_2.length; _c++) {
-                var _d = bufferManagers_2[_c], key = _d[0], bufferManager = _d[1].bufferManager;
+            for (const [key, { bufferManager }] of bufferManagers) {
                 bufferManager.defrag(offsetMap.values(), this.length, newCapacity);
             }
         }
@@ -133,48 +122,33 @@ var BufferOrchestrator = /** @class */ (function () {
         this._length = offsetMap.size;
         this._capacity = newCapacity;
         this.tombstoneOffsets = [];
-    };
+    }
     /**
      * Flushes metadata and sets length to 0 without actualize change on buffers
      * This method created for cases in which data is loaded on each frame
      */
-    BufferOrchestrator.prototype.flush = function (_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.capacity, capacity = _c === void 0 ? 10 : _c;
+    flush({ capacity = 10 } = {}) {
         this._length = 0;
         this._capacity = capacity;
         this.tombstoneOffsets = [];
         this.offsetMap.clear();
-    };
-    BufferOrchestrator.prototype._defrag = function () {
-        var newOffsetMap = new Map();
-        var newOffset = 0;
-        for (var _i = 0, _a = this.offsetMap; _i < _a.length; _i++) {
-            var _b = _a[_i], key = _b[0], offset = _b[1];
+    }
+    _defrag() {
+        const newOffsetMap = new Map();
+        let newOffset = 0;
+        for (const [key, offset] of this.offsetMap) {
             newOffsetMap.set(key, newOffset++);
         }
         this.offsetMap = newOffsetMap;
-    };
-    Object.defineProperty(BufferOrchestrator.prototype, "length", {
-        get: function () {
-            return this._length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(BufferOrchestrator.prototype, "emptySpace", {
-        get: function () {
-            return this._capacity - this.offsetMap.size;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(BufferOrchestrator.prototype, "capacity", {
-        get: function () {
-            return this._capacity;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return BufferOrchestrator;
-}());
+    }
+    get length() {
+        return this._length;
+    }
+    get emptySpace() {
+        return this._capacity - this.offsetMap.size;
+    }
+    get capacity() {
+        return this._capacity;
+    }
+}
 exports.BufferOrchestrator = BufferOrchestrator;

package/util/account/single-attribute-buffer-management/index.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectStore = exports.BufferManager = exports.BufferOrchestrator = void 0;
-var buffer_orchestrator_1 = require("./buffer-orchestrator");
+const buffer_orchestrator_1 = require("./buffer-orchestrator");
 Object.defineProperty(exports, "BufferOrchestrator", { enumerable: true, get: function () { return buffer_orchestrator_1.BufferOrchestrator; } });
-var buffer_manager_1 = require("./buffer-manager");
+const buffer_manager_1 = require("./buffer-manager");
 Object.defineProperty(exports, "BufferManager", { enumerable: true, get: function () { return buffer_manager_1.BufferManager; } });
-var object_store_1 = require("./object-store");
+const object_store_1 = require("./object-store");
 Object.defineProperty(exports, "ObjectStore", { enumerable: true, get: function () { return object_store_1.ObjectStore; } });

package/util/account/single-attribute-buffer-management/object-store.js

@@ -1,53 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectStore = void 0;
-var ObjectStore = /** @class */ (function () {
-    function ObjectStore(_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.initialCapcity, initialCapcity = _c === void 0 ? 10 : _c;
+class ObjectStore {
+    _container;
+    constructor({ initialCapcity = 10 } = {}) {
         this._container = this._createEmptyList(initialCapcity);
     }
-    ObjectStore.prototype.resetWithCapacity = function (capacity) {
+    resetWithCapacity(capacity) {
         this._container = this._createEmptyList(capacity);
-    };
-    ObjectStore.prototype.deleteBulk = function (offsets) {
-        for (var i = 0; i < offsets.length; i++) {
-            var offset = offsets[i];
+    }
+    deleteBulk(offsets) {
+        for (let i = 0; i < offsets.length; i++) {
+            const offset = offsets[i];
             if (offset !== undefined) {
                 this._container[offset] = null;
             }
         }
-    };
-    ObjectStore.prototype.insertBulk = function (objects, offsets) {
-        for (var i = 0; i < objects.length; i++) {
-            var object = objects[i];
-            var offset = offsets[i];
+    }
+    insertBulk(objects, offsets) {
+        for (let i = 0; i < objects.length; i++) {
+            const object = objects[i];
+            const offset = offsets[i];
             if (offset !== undefined) {
                 this._container[offset] = object;
             }
         }
-    };
-    ObjectStore.prototype.defrag = function (offsetValues, occupiedCapacity, newCapacity) {
-        var hold = this._createEmptyList(newCapacity);
-        for (var i = 0; i < offsetValues.length; i++) {
-            var offset = offsetValues[i];
+    }
+    defrag(offsetValues, occupiedCapacity, newCapacity) {
+        const hold = this._createEmptyList(newCapacity);
+        for (let i = 0; i < offsetValues.length; i++) {
+            const offset = offsetValues[i];
             if (offset !== undefined) {
                 hold[i] = this._container[offset];
             }
         }
         this._container = hold;
-    };
-    ObjectStore.prototype.extendBuffer = function (occupiedCapacity, newCapacity) {
-        var oldCapacity = this._container.length;
+    }
+    extendBuffer(occupiedCapacity, newCapacity) {
+        const oldCapacity = this._container.length;
         this._container = this._container.concat(this._createEmptyList(newCapacity - oldCapacity));
-    };
-    ObjectStore.prototype._createEmptyList = function (size) {
+    }
+    _createEmptyList(size) {
         return new Array(size).fill(null);
-    };
-    ObjectStore.prototype.get = function (index) {
+    }
+    get(index) {
         return this._container[index];
-    };
-    ObjectStore.prototype.free = function () {
-    };
-    return ObjectStore;
-}());
+    }
+    free() {
+    }
+}
 exports.ObjectStore = ObjectStore;

package/util/account/util.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.vaoAttributeLoader = void 0;
-var vaoAttributeLoader = function (gl, buffer, index, size, stride, offset, divisor, type) {
-    if (divisor === void 0) { divisor = null; }
-    if (type === void 0) { type = null; }
+const vaoAttributeLoader = (gl, buffer, index, size, stride, offset, divisor = null, type = null) => {
     if (!gl || !buffer) {
         throw new Error("Invalid WebGL context or buffer");
     }
@@ -13,7 +11,7 @@ var vaoAttributeLoader = function (gl, buffer, index, size, stride, offset, divi
     if (stride < 0 || offset < 0) {
         throw new Error("Stride and offset must be non-negative");
     }
-    var attribType = type === null ? gl.FLOAT : type;
+    const attribType = type === null ? gl.FLOAT : type;
     gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
     gl.enableVertexAttribArray(index);
     gl.vertexAttribPointer(index, size, attribType, false, stride, offset);

package/util/algorithms/search-binary.js

@@ -10,10 +10,10 @@ exports.findFirstIndexInRange = void 0;
  * @param {number} value
  * @returns {Index}
  */
-var findFirstIndexInRange = function (container, value) {
-    var start = 0;
-    var end = container.length - 1;
-    var mid = 0;
+const findFirstIndexInRange = (container, value) => {
+    let start = 0;
+    let end = container.length - 1;
+    let mid = 0;
     while (start <= end) {
         mid = Math.floor((start + end) / 2);
         if (container[mid] <= value && value <= container[mid + 1])

package/util/check/get.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapGetOrThrow = void 0;
-var mapGetOrThrow = function (errorNote) {
-    return function (mapInstance, ids) {
+const mapGetOrThrow = (errorNote) => {
+    return (mapInstance, ids) => {
         if (!ids)
             throw new Error("There is no map keys to get");
-        var result = [];
-        for (var i = 0; i < ids.length; i++) {
-            var e = mapInstance.get(ids[i]);
+        const result = [];
+        for (let i = 0; i < ids.length; i++) {
+            const e = mapInstance.get(ids[i]);
             if (e === undefined)
                 throw new Error(errorNote + " " + ids[i]);
             result.push(e);

package/util/check/typecheck.js

@@ -2,19 +2,19 @@
 // Generic
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBoolean = exports.constraintFloat = exports.isTextFont = exports.opacityCheck = exports.isHexColorWithOpacity = exports.isHexColor = void 0;
-var doesOwnProperties = function (properties, errorMessage) {
-    return function (object) {
-        properties.forEach(function (element) {
+const doesOwnProperties = (properties, errorMessage) => {
+    return (object) => {
+        properties.forEach(element => {
             if (!Object.hasOwn(object, element))
                 throw new TypeError(errorMessage + ':' + element);
         });
     };
 };
-var isHexColor = function (hexColor) { return /^#[0-9A-F]{6}$/i.test(hexColor); };
+const isHexColor = (hexColor) => /^#[0-9A-F]{6}$/i.test(hexColor);
 exports.isHexColor = isHexColor;
-var isHexColorWithOpacity = function (hexColor) { return /^#[0-9A-F]{6}[0-9a-f]{0,2}$/i.test(hexColor); };
+const isHexColorWithOpacity = (hexColor) => /^#[0-9A-F]{6}[0-9a-f]{0,2}$/i.test(hexColor);
 exports.isHexColorWithOpacity = isHexColorWithOpacity;
-var opacityCheck = function (opacity) {
+const opacityCheck = (opacity) => {
     if (typeof opacity !== "number")
         throw new TypeError("style.opacity must a number");
     if (opacity < 0 || 1 < opacity)
@@ -22,29 +22,27 @@ var opacityCheck = function (opacity) {
 };
 exports.opacityCheck = opacityCheck;
 // Text Related 
-var fontCheckTypes = doesOwnProperties(["name", "textColor", "hollowColor", "size", "bold", "italic"], "font does not have");
-var fontCheckColors = function (textColor, hollowColor) { return (0, exports.isHexColor)(textColor) && (0, exports.isHexColor)(hollowColor); };
-var isTextFont = function (textFont) {
+const fontCheckTypes = doesOwnProperties(["name", "textColor", "hollowColor", "size", "bold", "italic"], "font does not have");
+const fontCheckColors = (textColor, hollowColor) => (0, exports.isHexColor)(textColor) && (0, exports.isHexColor)(hollowColor);
+const isTextFont = (textFont) => {
     fontCheckTypes(textFont);
     fontCheckColors(textFont.textColor, textFont.hollowColor);
     if (typeof textFont.size !== "number")
         throw new TypeError("textFont size is not a number");
 };
 exports.isTextFont = isTextFont;
-var constraintFloat = function (x, lowerBound, upperBound) {
-    if (lowerBound === void 0) { lowerBound = null; }
-    if (upperBound === void 0) { upperBound = null; }
+const constraintFloat = (x, lowerBound = null, upperBound = null) => {
     if (typeof x !== "number")
         throw new Error("type must be numberic");
     if (lowerBound === null && upperBound === null)
         return;
     if (lowerBound !== null && lowerBound > x)
-        throw new Error("input must be greater than ".concat(lowerBound));
+        throw new Error(`input must be greater than ${lowerBound}`);
     if (upperBound !== null && x > upperBound)
-        throw new Error("input must be less than ".concat(upperBound));
+        throw new Error(`input must be less than ${upperBound}`);
 };
 exports.constraintFloat = constraintFloat;
-var isBoolean = function (x) {
+const isBoolean = (x) => {
     if (typeof x !== "boolean")
         throw new TypeError("type must be boolean");
 };

package/util/geometry/index.js

@@ -25,8 +25,8 @@ function createBBoxMatrix(minX, maxX, minY, maxY) {
     ]);
 }
 function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
-    var minXY = latLongToPixelXY(minY, minX);
-    var maxXY = latLongToPixelXY(maxY, maxX);
+    const minXY = latLongToPixelXY(minY, minX);
+    const maxXY = latLongToPixelXY(maxY, maxX);
     return createBBoxMatrix(minXY.x, maxXY.x, minXY.y, maxXY.y);
 }
 /**
@@ -34,20 +34,18 @@ function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
  * @param {Float32List} array
  * @returns {Float32Array}
  */
-function normalize(array, newLength) {
-    if (newLength === void 0) { newLength = 1; }
-    var total = 0;
-    for (var i = 0; i < array.length; i++) {
+function normalize(array, newLength = 1) {
+    let total = 0;
+    for (let i = 0; i < array.length; i++) {
         total += array[i] * array[i];
     }
-    var len = newLength / Math.sqrt(total);
-    var result = new Float32Array(array.length);
-    for (var i = 0; i < array.length; i++) {
+    const len = newLength / Math.sqrt(total);
+    const result = new Float32Array(array.length);
+    for (let i = 0; i < array.length; i++) {
         result[i] = array[i] * len;
     }
     return result;
 }
-function sphereCoord(long, lat, globe, height) {
-    if (height === void 0) { height = 0; }
+function sphereCoord(long, lat, globe, height = 0) {
     return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, 0), 6378.137 + height);
 }