melonjs 15.0.0 → 15.1.0

package/src/level/tiled/renderer/TMXHexagonalRenderer.js

@@ -5,7 +5,7 @@ import TMXLayer from "./../TMXLayer.js";
 
 
 
-// scope global var & constants
+// scope global variables & constants
 const offsetsStaggerX = [
     {x:   0, y:   0},
     {x: + 1, y: - 1},
@@ -82,7 +82,7 @@ const offsetsStaggerY = [
      * @ignore
      */
     getBounds(layer) {
-        var bounds = layer instanceof TMXLayer ? pool.pull("Bounds") : this.bounds;
+        let bounds = layer instanceof TMXLayer ? pool.pull("Bounds") : this.bounds;
 
         // The map size is the same regardless of which indexes are shifted.
         if (this.staggerX) {
@@ -125,7 +125,7 @@ const offsetsStaggerY = [
      * @ignore
      */
     topLeft(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
 
         if (!this.staggerX) {
             if ((y & 1) ^ this.staggerEven) {
@@ -149,7 +149,7 @@ const offsetsStaggerY = [
      * @ignore
      */
     topRight(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
 
         if (!this.staggerX) {
             if ((y & 1) ^ this.staggerEven) {
@@ -174,7 +174,7 @@ const offsetsStaggerY = [
      * @ignore
      */
     bottomLeft(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
 
         if (!this.staggerX) {
             if ((y & 1) ^ this.staggerEven) {
@@ -198,7 +198,7 @@ const offsetsStaggerY = [
      * @ignore
      */
     bottomRight(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
 
         if (!this.staggerX) {
             if ((y & 1) ^ this.staggerEven) {
@@ -223,7 +223,7 @@ const offsetsStaggerY = [
      * @ignore
      */
     pixelToTileCoords(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
 
         if (this.staggerX) { //flat top
             x -= this.staggerEven ? this.tilewidth : this.sideoffsetx;
@@ -233,13 +233,13 @@ const offsetsStaggerY = [
         }
 
         // Start with the coordinates of a grid-aligned tile
-        var referencePoint = pool.pull("Vector2d",
+        let referencePoint = pool.pull("Vector2d",
             Math.floor(x / (this.columnwidth * 2)),
             Math.floor((y / (this.rowheight * 2)))
         );
 
         // Relative x and y position on the base square of the grid-aligned tile
-        var rel = pool.pull("Vector2d",
+        let rel = pool.pull("Vector2d",
             x - referencePoint.x * (this.columnwidth * 2),
             y - referencePoint.y * (this.rowheight * 2)
         );
@@ -259,7 +259,7 @@ const offsetsStaggerY = [
         }
 
         // Determine the nearest hexagon tile by the distance to the center
-        var left, top, centerX, centerY;
+        let left, top, centerX, centerY;
         if (this.staggerX) {
             left = this.sidelengthx / 2;
             centerX = left + this.columnwidth;
@@ -281,17 +281,17 @@ const offsetsStaggerY = [
             this.centers[3].set(centerX, centerY + this.rowheight);
         }
 
-        var nearest = 0;
-        var minDist = Number.MAX_VALUE;
-        for (var i = 0; i < 4; ++i) {
-            var dc = this.centers[i].sub(rel).length2();
+        let nearest = 0;
+        let minDist = Number.MAX_VALUE;
+        for (let i = 0; i < 4; ++i) {
+            let dc = this.centers[i].sub(rel).length2();
             if (dc < minDist) {
                 minDist = dc;
                 nearest = i;
             }
         }
 
-        var offsets = (this.staggerX) ? offsetsStaggerX : offsetsStaggerY;
+        let offsets = (this.staggerX) ? offsetsStaggerX : offsetsStaggerY;
 
         ret.set(
             referencePoint.x + offsets[nearest].x,
@@ -309,9 +309,9 @@ const offsetsStaggerY = [
      * @ignore
      */
     tileToPixelCoords(x, y, v) {
-        var tileX = Math.floor(x),
+        let tileX = Math.floor(x),
             tileY = Math.floor(y);
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
 
         if (this.staggerX) {
             ret.y = tileY * (this.tileheight + this.sidelengthy);
@@ -349,8 +349,8 @@ const offsetsStaggerY = [
      * @ignore
      */
     drawTile(renderer, x, y, tmxTile) {
-        var tileset = tmxTile.tileset;
-        var point = this.tileToPixelCoords(x, y, pool.pull("Vector2d"));
+        let tileset = tmxTile.tileset;
+        let point = this.tileToPixelCoords(x, y, pool.pull("Vector2d"));
 
         // draw the tile
         tileset.drawTile(
@@ -368,10 +368,10 @@ const offsetsStaggerY = [
      * @ignore
      */
     drawTileLayer(renderer, layer, rect) {
-        var tile;
+        let tile;
 
         // get top-left and bottom-right tile position
-        var startTile = this.pixelToTileCoords(
+        let startTile = this.pixelToTileCoords(
             rect.pos.x,
             rect.pos.y,
             pool.pull("Vector2d")
@@ -381,22 +381,22 @@ const offsetsStaggerY = [
         startTile.sub(layer.pos);
 
         // get top-left and bottom-right tile position
-        var startPos = this.tileToPixelCoords(
+        let startPos = this.tileToPixelCoords(
             startTile.x + layer.pos.x,
             startTile.y + layer.pos.y,
             pool.pull("Vector2d")
         );
 
-        var rowTile = startTile.clone();
-        var rowPos = startPos.clone();
+        let rowTile = startTile.clone();
+        let rowPos = startPos.clone();
 
        /* Determine in which half of the tile the top-left corner of the area we
         * need to draw is. If we're in the upper half, we need to start one row
         * up due to those tiles being visible as well. How we go up one row
         * depends on whether we're in the left or right half of the tile.
         */
-        var inUpperHalf = rect.pos.y - startPos.y < this.sideoffsety;
-        var inLeftHalf = rect.pos.x - startPos.x < this.sideoffsetx;
+        let inUpperHalf = rect.pos.y - startPos.y < this.sideoffsety;
+        let inLeftHalf = rect.pos.x - startPos.x < this.sideoffsetx;
 
         if (inUpperHalf) {
             startTile.y--;
@@ -405,8 +405,8 @@ const offsetsStaggerY = [
             startTile.x--;
         }
 
-        var endX = layer.cols;
-        var endY = layer.rows;
+        let endX = layer.cols;
+        let endY = layer.rows;
 
         if (this.staggerX) {
             //ensure we are in the valid tile range
@@ -419,7 +419,7 @@ const offsetsStaggerY = [
                 startPos
             );
 
-            var staggeredRow = this.doStaggerX(startTile.x + layer.pos.x);
+            let staggeredRow = this.doStaggerX(startTile.x + layer.pos.x);
 
             // main drawing loop
             for (; startPos.y < rect.bottom && startTile.y < endY; ) {

package/src/level/tiled/renderer/TMXIsometricRenderer.js

@@ -42,7 +42,7 @@ import TMXLayer from "./../TMXLayer.js";
      * @ignore
      */
     getBounds(layer) {
-        var bounds = layer instanceof TMXLayer ? pool.pull("Bounds") : this.bounds;
+        let bounds = layer instanceof TMXLayer ? pool.pull("Bounds") : this.bounds;
         bounds.setMinMax(
             0, 0,
             (this.cols + this.rows) * (this.tilewidth / 2),
@@ -56,7 +56,7 @@ import TMXLayer from "./../TMXLayer.js";
      * @ignore
      */
     pixelToTileCoords(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
         return ret.set(
             (y / this.tileheight) + ((x - this.originX) / this.tilewidth),
             (y / this.tileheight) - ((x - this.originX) / this.tilewidth)
@@ -68,7 +68,7 @@ import TMXLayer from "./../TMXLayer.js";
      * @ignore
      */
     tileToPixelCoords(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
         return ret.set(
             (x - y) * this.hTilewidth + this.originX,
             (x + y) * this.hTileheight
@@ -81,9 +81,9 @@ import TMXLayer from "./../TMXLayer.js";
      * @ignore
      */
     adjustPosition(obj) {
-        var tileX = obj.x / this.hTilewidth;
-        var tileY = obj.y / this.tileheight;
-        var isoPos = pool.pull("Vector2d");
+        let tileX = obj.x / this.hTilewidth;
+        let tileY = obj.y / this.tileheight;
+        let isoPos = pool.pull("Vector2d");
 
         this.tileToPixelCoords(tileX, tileY, isoPos);
 
@@ -98,7 +98,7 @@ import TMXLayer from "./../TMXLayer.js";
      * @ignore
      */
     drawTile(renderer, x, y, tmxTile) {
-        var tileset = tmxTile.tileset;
+        let tileset = tmxTile.tileset;
         // draw the tile
         tileset.drawTile(
             renderer,
@@ -114,24 +114,24 @@ import TMXLayer from "./../TMXLayer.js";
      */
     drawTileLayer(renderer, layer, rect) {
         // cache a couple of useful references
-        var tileset = layer.tileset;
+        let tileset = layer.tileset;
 
         // get top-left and bottom-right tile position
-        var rowItr = this.pixelToTileCoords(
+        let rowItr = this.pixelToTileCoords(
             rect.pos.x - tileset.tilewidth,
             rect.pos.y - tileset.tileheight,
             pool.pull("Vector2d")
         ).floorSelf();
-        var tileEnd = this.pixelToTileCoords(
+        let tileEnd = this.pixelToTileCoords(
             rect.pos.x + rect.width + tileset.tilewidth,
             rect.pos.y + rect.height + tileset.tileheight,
             pool.pull("Vector2d")
         ).ceilSelf();
 
-        var rectEnd = this.tileToPixelCoords(tileEnd.x, tileEnd.y, pool.pull("Vector2d"));
+        let rectEnd = this.tileToPixelCoords(tileEnd.x, tileEnd.y, pool.pull("Vector2d"));
 
         // Determine the tile and pixel coordinates to start at
-        var startPos = this.tileToPixelCoords(rowItr.x, rowItr.y, pool.pull("Vector2d"));
+        let startPos = this.tileToPixelCoords(rowItr.x, rowItr.y, pool.pull("Vector2d"));
         startPos.x -= this.hTilewidth;
         startPos.y += this.tileheight;
 
@@ -140,8 +140,8 @@ import TMXLayer from "./../TMXLayer.js";
          * up due to those tiles being visible as well. How we go up one row
          * depends on whether we're in the left or right half of the tile.
          */
-        var inUpperHalf = startPos.y - rect.pos.y > this.hTileheight;
-        var inLeftHalf  = rect.pos.x - startPos.x < this.hTilewidth;
+        let inUpperHalf = startPos.y - rect.pos.y > this.hTileheight;
+        let inLeftHalf  = rect.pos.x - startPos.x < this.hTilewidth;
 
         if (inUpperHalf) {
             if (inLeftHalf) {
@@ -156,21 +156,21 @@ import TMXLayer from "./../TMXLayer.js";
         }
 
         // Determine whether the current row is shifted half a tile to the right
-        var shifted = inUpperHalf ^ inLeftHalf;
+        let shifted = inUpperHalf ^ inLeftHalf;
 
         // initialize the columItr vector
-        var columnItr = rowItr.clone();
+        let columnItr = rowItr.clone();
 
         // main drawing loop
-        for (var y = startPos.y * 2; y - this.tileheight * 2 < rectEnd.y * 2; y += this.tileheight) {
+        for (let y = startPos.y * 2; y - this.tileheight * 2 < rectEnd.y * 2; y += this.tileheight) {
             columnItr.setV(rowItr);
-            for (var x = startPos.x; x < rectEnd.x; x += this.tilewidth) {
-                var tmxTile = layer.cellAt(columnItr.x, columnItr.y);
+            for (let x = startPos.x; x < rectEnd.x; x += this.tilewidth) {
+                let tmxTile = layer.cellAt(columnItr.x, columnItr.y);
                 // render if a valid tile position
                 if (tmxTile) {
                     tileset = tmxTile.tileset;
                     // offset could be different per tileset
-                    var offset  = tileset.tileoffset;
+                    let offset  = tileset.tileoffset;
                     // draw our tile
                     tileset.drawTile(
                         renderer,

package/src/level/tiled/renderer/TMXOrthogonalRenderer.js

@@ -36,7 +36,7 @@ import TMXRenderer from "./TMXRenderer.js";
      * @ignore
      */
     pixelToTileCoords(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
         return ret.set(
             x / this.tilewidth,
             y / this.tileheight
@@ -49,7 +49,7 @@ import TMXRenderer from "./TMXRenderer.js";
      * @ignore
      */
     tileToPixelCoords(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
         return ret.set(
             x * this.tilewidth,
             y * this.tileheight
@@ -75,7 +75,7 @@ import TMXRenderer from "./TMXRenderer.js";
      * @ignore
      */
     drawTile(renderer, x, y, tmxTile) {
-        var tileset = tmxTile.tileset;
+        let tileset = tmxTile.tileset;
         // draw the tile
         tileset.drawTile(
             renderer,
@@ -90,16 +90,16 @@ import TMXRenderer from "./TMXRenderer.js";
      * @ignore
      */
     drawTileLayer(renderer, layer, rect) {
-        var incX = 1, incY = 1;
+        let incX = 1, incY = 1;
 
         // get top-left and bottom-right tile position
-        var start = this.pixelToTileCoords(
+        let start = this.pixelToTileCoords(
             Math.max(rect.pos.x - (layer.maxTileSize.width - layer.tilewidth), 0),
             Math.max(rect.pos.y - (layer.maxTileSize.height - layer.tileheight), 0),
             pool.pull("Vector2d")
         ).floorSelf();
 
-        var end = this.pixelToTileCoords(
+        let end = this.pixelToTileCoords(
             rect.pos.x + rect.width + this.tilewidth,
             rect.pos.y + rect.height + this.tileheight,
             pool.pull("Vector2d")
@@ -133,9 +133,9 @@ import TMXRenderer from "./TMXRenderer.js";
         }
 
         // main drawing loop
-        for (var y = start.y; y !== end.y; y+= incY) {
-            for (var x = start.x; x !== end.x; x+= incX) {
-                var tmxTile = layer.cellAt(x, y, false);
+        for (let y = start.y; y !== end.y; y+= incY) {
+            for (let x = start.x; x !== end.x; x+= incX) {
+                let tmxTile = layer.cellAt(x, y, false);
                 if (tmxTile) {
                     this.drawTile(renderer, x, y, tmxTile);
                 }

package/src/level/tiled/renderer/TMXRenderer.js

@@ -47,7 +47,7 @@ import Bounds from "./../../../physics/bounds.js";
      * @returns {Bounds}
      */
     getBounds(layer) {
-        var bounds = layer instanceof TMXLayer ? pool.pull("Bounds") : this.bounds;
+        let bounds = layer instanceof TMXLayer ? pool.pull("Bounds") : this.bounds;
         bounds.setMinMax(
             0, 0,
             this.cols * this.tilewidth,

package/src/level/tiled/renderer/TMXStaggeredRenderer.js

@@ -27,9 +27,9 @@ import { degToRad } from "./../../../math/math.js";
      * @ignore
      */
     pixelToTileCoords(x, y, v) {
-        var ret = v || new Vector2d();
+        let ret = v || new Vector2d();
 
-        var alignedX = x,
+        let alignedX = x,
             alignedY = y;
 
         if (this.staggerX) {
@@ -39,7 +39,7 @@ import { degToRad } from "./../../../math/math.js";
         }
 
         // Start with the coordinates of a grid-aligned tile
-        var referencePoint = pool.pull("Vector2d",
+        let referencePoint = pool.pull("Vector2d",
             Math.floor(alignedX / this.tilewidth),
             Math.floor(alignedY / this.tileheight)
         );
@@ -58,13 +58,13 @@ import { degToRad } from "./../../../math/math.js";
         }
 
         // Relative x and y position on the base square of the grid-aligned tile
-        var rel = pool.pull("Vector2d",
+        let rel = pool.pull("Vector2d",
             alignedX - referencePoint.x * this.tilewidth,
             alignedY - referencePoint.y * this.tileheight
         );
 
         // Check whether the cursor is in any of the corners (neighboring tiles)
-        var y_pos = rel.x * (this.tileheight / this.tilewidth);
+        let y_pos = rel.x * (this.tileheight / this.tilewidth);
 
         if (this.sideoffsety - y_pos > rel.y) {
             referencePoint = this.topLeft(referencePoint.x, referencePoint.y, referencePoint);

package/src/loader/loader.js

@@ -56,7 +56,7 @@ function checkLoadStatus(onloadcb) {
             clearTimeout(timerId);
             // trigger the onload callback
             // we call either the supplied callback (which takes precedence) or the global one
-            var callback = onloadcb || onload;
+            let callback = onloadcb || onload;
             setTimeout(() => {
                 callback();
                 event.emit(event.LOADER_COMPLETE);
@@ -82,7 +82,7 @@ function onResourceLoaded(res) {
     loadCount++;
 
     // currrent progress
-    var progress = loadCount / resourceCount;
+    let progress = loadCount / resourceCount;
 
     // call callback if defined
     if (typeof onProgress === "function") {
@@ -143,11 +143,11 @@ function onLoadingError(res) {
  * ];
  * ...
  * // set all resources to be loaded
- * me.loader.preload(game.resources, this.loaded.bind(this));
+ * me.loader.preload(game.resources, () => this.loaded());
  */
 export function preload(res, onloadcb, switchToLoadState = true) {
     // parse the resources
-    for (var i = 0; i < res.length; i++) {
+    for (let i = 0; i < res.length; i++) {
         resourceCount += load(
             res[i],
             onResourceLoaded.bind(this, res[i]),
@@ -183,7 +183,7 @@ export function preload(res, onloadcb, switchToLoadState = true) {
  * @returns {number} the amount of corresponding resource to be preloaded
  * @example
  * // load an image asset
- * me.loader.load({name: "avatar",  type:"image",  src: "data/avatar.png"}, this.onload.bind(this), this.onerror.bind(this));
+ * me.loader.load({name: "avatar",  type:"image",  src: "data/avatar.png"}, () => this.onload(), () => this.onerror());
  * // load a base64 image asset
  *  me.loader.load({name: "avatar", type:"image", src: "data:image/png;base64,iVBORw0KAAAQAAAAEACA..."};
  * // start loading music
@@ -307,7 +307,7 @@ export function unload(res) {
  * @example me.loader.unloadAll();
  */
 export function unloadAll() {
-    var name;
+    let name;
 
     // unload all binary resources
     for (name in binList) {

package/src/loader/loadingscreen.js

@@ -72,7 +72,7 @@ class DefaultLoadingScreen extends Stage {
      * @ignore
      */
     onResetEvent() {
-        var barHeight = 8;
+        const barHeight = 8;
 
         // set a background color
         game.world.backgroundColor.parseCSS("#202020");

package/src/loader/parser.js

@@ -50,7 +50,7 @@ export function preloadFontFace(data, onload, onerror) {
         }
     }
 
-    var font = new FontFace(data.name, data.src);
+    let font = new FontFace(data.name, data.src);
 
     // loading promise
     font.load().then(() => {
@@ -97,9 +97,9 @@ export function preloadTMX(tmxData, onload, onerror) {
         return;
     }
 
-    var xmlhttp = new XMLHttpRequest();
+    let xmlhttp = new XMLHttpRequest();
     // check the data format ('tmx', 'json')
-    var format = fileUtil.getExtension(tmxData.src);
+    let format = fileUtil.getExtension(tmxData.src);
 
     if (xmlhttp.overrideMimeType) {
         if (format === "json") {
@@ -119,7 +119,7 @@ export function preloadTMX(tmxData, onload, onerror) {
             // status = 0 when file protocol is used, or cross-domain origin,
             // (With Chrome use "--allow-file-access-from-files --disable-web-security")
             if ((xmlhttp.status === 200) || ((xmlhttp.status === 0) && xmlhttp.responseText)) {
-                var result = null;
+                let result = null;
 
                 // parse response
                 switch (format) {
@@ -139,7 +139,7 @@ export function preloadTMX(tmxData, onload, onerror) {
                             result = xmlhttp.responseXML;
                         }
                         // converts to a JS object
-                        var data = TMXUtils.parse(result);
+                        var data = TMXUtils.parse(result); // <= "Unexpected lexical declaration in case block" if using let
                         switch (format) {
                             case "tmx":
                                 result = data.map;
@@ -184,7 +184,7 @@ export function preloadTMX(tmxData, onload, onerror) {
  * @ignore
  */
 export function preloadJSON(data, onload, onerror) {
-    var xmlhttp = new XMLHttpRequest();
+    let xmlhttp = new XMLHttpRequest();
 
     if (xmlhttp.overrideMimeType) {
         xmlhttp.overrideMimeType("application/json");
@@ -221,7 +221,7 @@ export function preloadJSON(data, onload, onerror) {
  * @ignore
  */
 export function preloadBinary(data, onload, onerror) {
-    var httpReq = new XMLHttpRequest();
+    let httpReq = new XMLHttpRequest();
 
     // load our file
     httpReq.open("GET", data.src + nocache, true);
@@ -229,11 +229,11 @@ export function preloadBinary(data, onload, onerror) {
     httpReq.responseType = "arraybuffer";
     httpReq.onerror = onerror;
     httpReq.onload = function () {
-        var arrayBuffer = httpReq.response;
+        let arrayBuffer = httpReq.response;
         if (arrayBuffer) {
-            var byteArray = new Uint8Array(arrayBuffer);
-            var buffer = [];
-            for (var i = 0; i < byteArray.byteLength; i++) {
+            let byteArray = new Uint8Array(arrayBuffer);
+            let buffer = [];
+            for (let i = 0; i < byteArray.byteLength; i++) {
                 buffer[i] = String.fromCharCode(byteArray[i]);
             }
             binList[data.name] = buffer.join("");
@@ -252,7 +252,7 @@ export function preloadBinary(data, onload, onerror) {
  * @ignore
  */
 export function preloadJavascript(data, onload, onerror) {
-    var script = document.createElement("script");
+    let script = document.createElement("script");
 
     script.src = data.src;
     script.type = "text/javascript";

package/src/loader/settings.js

@@ -21,7 +21,7 @@ export let baseURL = {};
  * me.loader.crossOrigin = "anonymous";
  *
  * // set all ressources to be loaded
- * me.loader.preload(game.resources, this.loaded.bind(this));
+ * me.loader.preload(game.resources, () => this.loaded());
  */
 export let crossOrigin;
 
@@ -39,7 +39,7 @@ export let crossOrigin;
  * me.loader.withCredentials = true;
  *
  * // set all ressources to be loaded
- * me.loader.preload(game.resources, this.loaded.bind(this));
+ * me.loader.preload(game.resources, () => this.loaded());
  */
 export let withCredentials = false;
 

package/src/math/color.js

@@ -21,7 +21,7 @@ const hex4Rx = /^#([\da-fA-F])([\da-fA-F])([\da-fA-F])([\da-fA-F])$/;
 const hex6Rx = /^#([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})$/;
 const hex8Rx = /^#([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})$/;
 
-var cssToRGB = new Map();
+let cssToRGB = new Map();
 
 [
     // CSS1
@@ -279,13 +279,13 @@ var cssToRGB = new Map();
      * @returns {Color} Reference to this object for method chaining
      */
     setHSV(h, s, v) {
-        var r, g, b;
+        let r, g, b;
 
-        var i = Math.floor(h * 6);
-        var f = h * 6 - i;
-        var p = v * (1 - s);
-        var q = v * (1 - f * s);
-        var t = v * (1 - (1 - f) * s);
+        let i = Math.floor(h * 6);
+        let f = h * 6 - i;
+        let p = v * (1 - s);
+        let q = v * (1 - f * s);
+        let t = v * (1 - (1 - f) * s);
 
         switch (i % 6) {
             case 0: r = v, g = t, b = p; break;
@@ -306,13 +306,13 @@ var cssToRGB = new Map();
      * @returns {Color} Reference to this object for method chaining
      */
     setHSL(h, s, l) {
-        var r, g, b;
+        let r, g, b;
 
         if (s === 0) {
             r = g = b = l; // achromatic
         } else {
-            var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-            var p = 2 * l - q;
+            let q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            let p = 2 * l - q;
 
             r = hue2rgb(p, q, h + 1/3);
             g = hue2rgb(p, q, h);
@@ -462,7 +462,7 @@ var cssToRGB = new Map();
     parseRGB(rgbColor) {
         // TODO : Memoize this function by caching its input
 
-        var match = rgbaRx.exec(rgbColor);
+        let match = rgbaRx.exec(rgbColor);
         if (match) {
             return this.setColor(+match[1], +match[2], +match[3], +match[5]);
         }
@@ -480,7 +480,7 @@ var cssToRGB = new Map();
     parseHex(hexColor, argb = false) {
         // TODO : Memoize this function by caching its input
 
-        var match;
+        let match;
         if ((match = hex8Rx.exec(hexColor))) {
             // #AARRGGBB or #RRGGBBAA
             return this.setColor(
@@ -502,10 +502,10 @@ var cssToRGB = new Map();
 
         if ((match = hex4Rx.exec(hexColor))) {
             // #ARGB or #RGBA
-            var r = match[argb === false ? 1 : 2];
-            var g = match[argb === false ? 2 : 3];
-            var b = match[argb === false ? 3 : 4];
-            var a = match[argb === false ? 4 : 1];
+            let r = match[argb === false ? 1 : 2];
+            let g = match[argb === false ? 2 : 3];
+            let b = match[argb === false ? 3 : 4];
+            let a = match[argb === false ? 4 : 1];
             return this.setColor(
                 parseInt(r + r, 16), // r
                 parseInt(g + g, 16), // g
@@ -534,11 +534,11 @@ var cssToRGB = new Map();
      * @returns {number}
      */
     toUint32(alpha = 1.0) {
-        var a = this.glArray;
+        let a = this.glArray;
 
-        var ur = (a[0] * 255) & 0xff;
-        var ug = (a[1] * 255) & 0xff;
-        var ub = (a[2] * 255) & 0xff;
+        let ur = (a[0] * 255) & 0xff;
+        let ug = (a[1] * 255) & 0xff;
+        let ub = (a[2] * 255) & 0xff;
 
         return (((alpha * 255) & 0xff) << 24) + (ur << 16) + (ug << 8) + ub;
     }

package/src/math/math.js

@@ -185,7 +185,7 @@ export function weightedRandom(min, max) {
  */
 export function round(num, dec = 0) {
     // if only one argument use the object value
-    var powres = Math.pow(10, dec);
+    const powres = Math.pow(10, dec);
     return (~~(0.5 + num * powres) / powres);
 }