melonjs 15.0.0 → 15.1.1

package/dist/melonjs.mjs/level/tiled/TMXUtils.js

@@ -1,18 +1,18 @@
 /*!
- * melonJS Game Engine - v15.0.0
+ * melonJS Game Engine - v15.1.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
  * @copyright (C) 2011 - 2023 Olivier Biot (AltByte Pte Ltd)
  */
-import { isBoolean, isNumeric } from '../../utils/string.js';
+import utils from '../../utils/utils.js';
 
 /**
  * set and interpret a TMX property value
  * @ignore
  */
 function setTMXValue(name, type, value) {
-    var match;
+    let match;
 
     if (typeof(value) !== "string") {
         // Value is already normalized (e.g. with JSON maps)
@@ -32,11 +32,11 @@ function setTMXValue(name, type, value) {
 
         default :
             // try to parse it anyway
-            if (!value || isBoolean(value)) {
+            if (!value || utils.string.isBoolean(value)) {
                 // if value not defined or boolean
                 value = value ? (value === "true") : true;
             }
-            else if (isNumeric(value)) {
+            else if (utils.string.isNumeric(value)) {
                 // check if numeric
                 value = Number(value);
             }
@@ -89,8 +89,8 @@ function setTMXValue(name, type, value) {
 function parseAttributes(obj, elt) {
     // do attributes
     if (elt.attributes && elt.attributes.length > 0) {
-        for (var j = 0; j < elt.attributes.length; j++) {
-            var attribute = elt.attributes.item(j);
+        for (let j = 0; j < elt.attributes.length; j++) {
+            let attribute = elt.attributes.item(j);
             if (typeof(attribute.name) !== "undefined") {
                 // DOM4 (Attr no longer inherit from Node)
                 obj[attribute.name] = attribute.value;
@@ -103,14 +103,19 @@ function parseAttributes(obj, elt) {
 }
 
 /**
- * decompress zlib/gzip data (NOT IMPLEMENTED)
+ * decompress and decode zlib/gzip data
  * @ignore
  * @name decompress
- * @param  {number[]} data- -  Array of bytes
- * @param  {string} format- -  compressed data format ("gzip","zlib")
+ * @param {string} input - Base64 encoded and compressed data
+ * @param {string} format - compressed data format ("gzip","zlib", "zstd")
+ * @returns {Uint32Array} Decoded and decompress data
  */
-function decompress() {
-    throw new Error("GZIP/ZLIB compressed TMX Tile Map not supported!");
+function decompress(data, format) {
+    if (typeof utils.inflateb64 === "function") {
+        return utils.inflateb64(data, format);
+    } else {
+        throw new Error("GZIP/ZLIB compressed TMX Tile Map not supported!");
+    }
 }
 
 /**
@@ -121,10 +126,10 @@ function decompress() {
  * @returns {number[]} Decoded data
  */
 function decodeCSV(input) {
-    var entries = input.replace("\n", "").trim().split(",");
+    let entries = input.replace("\n", "").trim().split(",");
 
-    var result = [];
-    for (var i = 0; i < entries.length; i++) {
+    let result = [];
+    for (let i = 0; i < entries.length; i++) {
         result.push(+entries[i]);
     }
     return result;
@@ -141,9 +146,9 @@ function decodeCSV(input) {
 function decodeBase64AsArray(input, bytes) {
     bytes = bytes || 1;
 
-    var i, j, len;
-    var dec = globalThis.atob(input.replace(/[^A-Za-z0-9\+\/\=]/g, ""));
-    var ar = new Uint32Array(dec.length / bytes);
+    let i, j, len;
+    let dec = globalThis.atob(input.replace(/[^A-Za-z0-9\+\/\=]/g, ""));
+    let ar = new Uint32Array(dec.length / bytes);
 
     for (i = 0, len = dec.length / bytes; i < len; i++) {
         ar[i] = 0;
@@ -167,12 +172,12 @@ function decode(data, encoding, compression) {
             return decodeCSV(data);
 
         case "base64":
-            var decoded = decodeBase64AsArray(data, 4);
-            return (
-                (compression === "none") ?
-                decoded :
-                decompress()
-            );
+            if (compression !== "none") {
+                data = decompress(data, compression);
+            } else {
+                data = decodeBase64AsArray(data, 4);
+            }
+            return data;
 
         case "none":
             return data;
@@ -190,11 +195,11 @@ function decode(data, encoding, compression) {
  * @ignore
  */
 function normalize(obj, item) {
-    var nodeName = item.nodeName;
+    let nodeName = item.nodeName;
 
     switch (nodeName) {
         case "data":
-            var data = parse(item);
+            var data = parse(item);  // <= "Unexpected lexical declaration in case block" if using let
 
             data.encoding = data.encoding || "xml";
 
@@ -232,7 +237,7 @@ function normalize(obj, item) {
         case "layer":
         case "objectgroup":
         case "group":
-            var layer = parse(item);
+            var layer = parse(item); //  // <= "Unexpected lexical declaration in case block" if using let
             layer.type = (nodeName === "layer" ? "tilelayer" : nodeName);
             if (layer.image) {
                 layer.image = layer.image.source;
@@ -248,13 +253,13 @@ function normalize(obj, item) {
 
         case "frame":
         case "object":
-            var name = nodeName + "s";
+            var name = nodeName + "s";  // <= "Unexpected lexical declaration in case block" if using let
             obj[name] = obj[name] || [];
             obj[name].push(parse(item));
             break;
 
         case "tile":
-            var tile = parse(item);
+            var tile = parse(item);  // <= "Unexpected lexical declaration in case block" if using let
             if (tile.image) {
                 tile.imagewidth = tile.image.width;
                 tile.imageheight = tile.image.height;
@@ -265,7 +270,7 @@ function normalize(obj, item) {
             break;
 
         case "tileset":
-            var tileset = parse(item);
+            var tileset = parse(item);  // <= "Unexpected lexical declaration in case block" if using let
             if (tileset.image) {
                 tileset.imagewidth = tileset.image.width;
                 tileset.imageheight = tileset.image.height;
@@ -281,10 +286,10 @@ function normalize(obj, item) {
             obj[nodeName] = [];
 
             // Get a point array
-            var points = parse(item).points.split(" ");
+            var points = parse(item).points.split(" ");  // <= "Unexpected lexical declaration in case block" if using let
 
             // And normalize them into an array of vectors
-            for (var i = 0, v; i < points.length; i++) {
+            for (let i = 0, v; i < points.length; i++) {
                 v = points[i].split(",");
                 obj[nodeName].push({
                     "x" : +v[0],
@@ -299,7 +304,7 @@ function normalize(obj, item) {
             break;
 
         case "property":
-            var property = parse(item);
+            var property = parse(item);  // <= "Unexpected lexical declaration in case block" if using let
             // for custom properties, text is used
             var value = (typeof property.value !== "undefined") ? property.value : property.text;
 
@@ -323,9 +328,9 @@ function normalize(obj, item) {
  */
 function parse(xml) {
     // Create the return object
-    var obj = {};
+    let obj = {};
 
-    var text = "";
+    let text = "";
 
     if (xml.nodeType === 1) {
         // do attributes
@@ -360,14 +365,14 @@ function parse(xml) {
  * @ignore
  */
 function applyTMXProperties(obj, data) {
-    var properties = data.properties;
-    var types = data.propertytypes;
+    let properties = data.properties;
+    let types = data.propertytypes;
     if (typeof(properties) !== "undefined") {
-        for (var property in properties) {
+        for (let property in properties) {
             if (properties.hasOwnProperty(property)) {
-                var type = "string";
-                var name = property;
-                var value = properties[property];
+                let type = "string";
+                let name = property;
+                let value = properties[property];
                 // proof-check for new and old JSON format
                 if (typeof properties[property].name !== "undefined") {
                     name = properties[property].name;

package/dist/melonjs.mjs/level/tiled/constants.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v15.0.0
+ * melonJS Game Engine - v15.1.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license

package/dist/melonjs.mjs/level/tiled/renderer/TMXHexagonalRenderer.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v15.0.0
+ * melonJS Game Engine - v15.1.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -10,7 +10,7 @@ import pool from '../../../system/pooling.js';
 import TMXRenderer from './TMXRenderer.js';
 import TMXLayer from '../TMXLayer.js';
 
-// scope global var & constants
+// scope global variables & constants
 const offsetsStaggerX = [
     {x:   0, y:   0},
     {x: + 1, y: - 1},
@@ -87,7 +87,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) {
@@ -130,7 +130,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) {
@@ -154,7 +154,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) {
@@ -179,7 +179,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) {
@@ -203,7 +203,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) {
@@ -228,7 +228,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;
@@ -238,13 +238,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)
         );
@@ -264,7 +264,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;
@@ -286,17 +286,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,
@@ -314,9 +314,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);
@@ -354,8 +354,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(
@@ -373,10 +373,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")
@@ -386,22 +386,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--;
@@ -410,8 +410,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
@@ -424,7 +424,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/dist/melonjs.mjs/level/tiled/renderer/TMXIsometricRenderer.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v15.0.0
+ * melonJS Game Engine - v15.1.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -48,7 +48,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),
@@ -62,7 +62,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)
@@ -74,7 +74,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
@@ -87,9 +87,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);
 
@@ -104,7 +104,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,
@@ -120,24 +120,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;
 
@@ -146,8 +146,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) {
@@ -162,21 +162,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/dist/melonjs.mjs/level/tiled/renderer/TMXOrthogonalRenderer.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v15.0.0
+ * melonJS Game Engine - v15.1.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -43,7 +43,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
@@ -56,7 +56,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
@@ -82,7 +82,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,
@@ -97,16 +97,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")
@@ -138,9 +138,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/dist/melonjs.mjs/level/tiled/renderer/TMXRenderer.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v15.0.0
+ * melonJS Game Engine - v15.1.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -54,7 +54,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/dist/melonjs.mjs/level/tiled/renderer/TMXStaggeredRenderer.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v15.0.0
+ * melonJS Game Engine - v15.1.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -33,9 +33,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) {
@@ -45,7 +45,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)
         );
@@ -64,13 +64,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);