melonjs 14.5.0 → 15.1.0

package/dist/melonjs.mjs/text/bitmaptext.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.1.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -39,7 +39,7 @@ import TextMetrics from './textmetrics.js';
      *     { name: "arial", type: "image" src: "data/font/arial.png" },
      * ])
      * // Then create an instance of your bitmap font:
-     * var myFont = new me.BitmapText(x, y, {font:"arial", text:"Hello"});
+     * let myFont = new me.BitmapText(x, y, {font:"arial", text:"Hello"});
      * // two possibilities for using "myFont"
      * // either call the draw function from your Renderable draw function
      * myFont.draw(renderer, "Hello!", 0, 0);
@@ -194,12 +194,12 @@ import TextMetrics from './textmetrics.js';
      * @returns {Bounds} this Bitmap Text bounding box Rectangle object
      */
     updateBounds(absolute = true) {
-        var bounds = this.getBounds();
+        let bounds = this.getBounds();
 
         bounds.clear();
 
         if (typeof this.metrics !== "undefined") {
-            var ax, ay;
+            let ax, ay;
 
             bounds.addBounds(this.metrics.measureText(this._text));
 
@@ -298,7 +298,7 @@ import TextMetrics from './textmetrics.js';
      */
     draw(renderer, text, x, y) {
         // save the previous global alpha value
-        var _alpha = renderer.globalAlpha();
+        let _alpha = renderer.globalAlpha();
 
         // allows to provide backward compatibility when
         // adding Bitmap Font to an object container
@@ -312,15 +312,15 @@ import TextMetrics from './textmetrics.js';
             y = this.pos.y;
         }
 
-        var lX = x;
-        var stringHeight = this.metrics.lineHeight();
-        var maxWidth = 0;
+        let lX = x;
+        let stringHeight = this.metrics.lineHeight();
+        let maxWidth = 0;
 
-        for (var i = 0; i < this._text.length; i++) {
+        for (let i = 0; i < this._text.length; i++) {
             x = lX;
-            var string = this._text[i].trimEnd();
+            let string = this._text[i].trimEnd();
             // adjust x pos based on alignment value
-            var stringWidth = this.metrics.lineWidth(string);
+            let stringWidth = this.metrics.lineWidth(string);
             switch (this.textAlign) {
                 case "right":
                     x -= stringWidth;
@@ -356,18 +356,18 @@ import TextMetrics from './textmetrics.js';
             }
 
             // draw the string
-            var lastGlyph = null;
-            for (var c = 0, len = string.length; c < len; c++) {
+            let lastGlyph = null;
+            for (let c = 0, len = string.length; c < len; c++) {
                 // calculate the char index
-                var ch = string.charCodeAt(c);
-                var glyph = this.fontData.glyphs[ch];
+                let ch = string.charCodeAt(c);
+                let glyph = this.fontData.glyphs[ch];
 
                 if (typeof glyph !== "undefined") {
-                    var glyphWidth = glyph.width;
-                    var glyphHeight = glyph.height;
-                    var kerning = (lastGlyph && lastGlyph.kerning) ? lastGlyph.getKerning(ch) : 0;
-                    var scaleX = this.fontScale.x;
-                    var scaleY = this.fontScale.y;
+                    let glyphWidth = glyph.width;
+                    let glyphHeight = glyph.height;
+                    let kerning = (lastGlyph && lastGlyph.kerning) ? lastGlyph.getKerning(ch) : 0;
+                    let scaleX = this.fontScale.x;
+                    let scaleY = this.fontScale.y;
 
                     // draw it
                     if (glyphWidth !== 0 && glyphHeight !== 0) {

package/dist/melonjs.mjs/text/bitmaptextdata.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.1.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -15,7 +15,7 @@ const capChars = ["M", "N", "B", "D", "C", "E", "F", "K", "A", "G", "H", "I", "J
  * @ignore
  */
 function getValueFromPair(string, pattern) {
-    var value = string.match(pattern);
+    let value = string.match(pattern);
     if (!value) {
         throw new Error("Could not find pattern " + pattern + " in string: " + string);
     }
@@ -32,8 +32,8 @@ function getValueFromPair(string, pattern) {
  * @returns {Glyph}
  */
 function getFirstGlyph(glyphs) {
-    var keys = Object.keys(glyphs);
-    for (var i = 0; i < keys.length; i++) {
+    let keys = Object.keys(glyphs);
+    for (let i = 0; i < keys.length; i++) {
         if (keys[i] > 32) {
             return glyphs[keys[i]];
         }
@@ -49,8 +49,8 @@ function getFirstGlyph(glyphs) {
  * @param {object} glyphs - the map of glyphs, each key is a char code
  */
 function createSpaceGlyph(glyphs) {
-    var spaceCharCode = " ".charCodeAt(0);
-    var glyph = glyphs[spaceCharCode];
+    let spaceCharCode = " ".charCodeAt(0);
+    let glyph = glyphs[spaceCharCode];
     if (!glyph) {
         glyph = new Glyph();
         glyph.id = spaceCharCode;
@@ -109,12 +109,12 @@ function createSpaceGlyph(glyphs) {
         if (!fontData) {
             throw new Error("File containing font data was empty, cannot load the bitmap font.");
         }
-        var lines = fontData.split(/\r\n|\n/);
-        var padding = fontData.match(/padding\=\d+,\d+,\d+,\d+/g);
+        let lines = fontData.split(/\r\n|\n/);
+        let padding = fontData.match(/padding\=\d+,\d+,\d+,\d+/g);
         if (!padding) {
             throw new Error("Padding not found in first line");
         }
-        var paddingValues = padding[0].split("=")[1].split(",");
+        let paddingValues = padding[0].split("=")[1].split(",");
         this.padTop = parseFloat(paddingValues[0]);
         this.padLeft = parseFloat(paddingValues[1]);
         this.padBottom = parseFloat(paddingValues[2]);
@@ -122,24 +122,24 @@ function createSpaceGlyph(glyphs) {
 
         this.lineHeight = parseFloat(getValueFromPair(lines[1], /lineHeight\=\d+/g));
 
-        var baseLine = parseFloat(getValueFromPair(lines[1], /base\=\d+/g));
+        let baseLine = parseFloat(getValueFromPair(lines[1], /base\=\d+/g));
 
-        var padY = this.padTop + this.padBottom;
+        let padY = this.padTop + this.padBottom;
 
-        var glyph = null;
+        let glyph = null;
 
-        var i;
+        let i;
 
         for (i = 4; i < lines.length; i++) {
-            var line = lines[i];
-            var characterValues = line.split(/=|\s+/);
+            let line = lines[i];
+            let characterValues = line.split(/=|\s+/);
             if (!line || /^kernings/.test(line)) {
                 continue;
             }
             if (/^kerning\s/.test(line)) {
-                var first = parseFloat(characterValues[2]);
-                var second = parseFloat(characterValues[4]);
-                var amount = parseFloat(characterValues[6]);
+                let first = parseFloat(characterValues[2]);
+                let second = parseFloat(characterValues[4]);
+                let amount = parseFloat(characterValues[6]);
 
                 glyph = this.glyphs[first];
                 if (glyph !== null && typeof glyph !== "undefined") {
@@ -148,7 +148,7 @@ function createSpaceGlyph(glyphs) {
             } else {
                 glyph = new Glyph();
 
-                var ch = parseFloat(characterValues[2]);
+                let ch = parseFloat(characterValues[2]);
                 glyph.id = ch;
                 glyph.x = parseFloat(characterValues[4]);
                 glyph.y = parseFloat(characterValues[6]);
@@ -170,16 +170,16 @@ function createSpaceGlyph(glyphs) {
 
         createSpaceGlyph(this.glyphs);
 
-        var capGlyph = null;
+        let capGlyph = null;
         for (i = 0; i < capChars.length; i++) {
-            var capChar = capChars[i];
+            let capChar = capChars[i];
             capGlyph = this.glyphs[capChar.charCodeAt(0)];
             if (capGlyph) {
                 break;
             }
         }
         if (!capGlyph) {
-            for (var charCode in this.glyphs) {
+            for (let charCode in this.glyphs) {
                 if (this.glyphs.hasOwnProperty(charCode)) {
                     glyph = this.glyphs[charCode];
                     if (glyph.height === 0 || glyph.width === 0) {

package/dist/melonjs.mjs/text/glyph.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.1.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -38,7 +38,7 @@ const PAGE_SIZE = 1 << LOG2_PAGE_SIZE;
      */
     getKerning(ch) {
         if (this.kerning) {
-            var page = this.kerning[ch >>> LOG2_PAGE_SIZE];
+            let page = this.kerning[ch >>> LOG2_PAGE_SIZE];
             if (page) {
                 return page[ch & PAGE_SIZE - 1] || 0;
             }
@@ -53,7 +53,7 @@ const PAGE_SIZE = 1 << LOG2_PAGE_SIZE;
         if (!this.kerning) {
             this.kerning = {};
         }
-        var page = this.kerning[ch >>> LOG2_PAGE_SIZE];
+        let page = this.kerning[ch >>> LOG2_PAGE_SIZE];
         if (typeof page === "undefined") {
             this.kerning[ch >>> LOG2_PAGE_SIZE] = {};
             page = this.kerning[ch >>> LOG2_PAGE_SIZE];

package/dist/melonjs.mjs/text/text.js

@@ -1,12 +1,11 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.1.0
  * 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 Color from '../math/color.js';
-import WebGLRenderer from '../video/webgl/webgl_renderer.js';
 import { renderer } from '../video/video.js';
 import pool from '../system/pooling.js';
 import Renderable from '../renderable/renderable.js';
@@ -26,18 +25,6 @@ import TextMetrics from './textmetrics.js';
 const runits = ["ex", "em", "pt", "px"];
 const toPX = [12, 24, 0.75, 1];
 
-// return a valid 2d context for Text rendering/styling
-var getContext2d = function (renderer$1, text) {
-    if (text.offScreenCanvas === true) {
-        return text.canvasTexture.context;
-    } else {
-        if (typeof renderer$1 === "undefined") {
-            renderer$1 = renderer;
-        }
-        return renderer$1.getFontContext();
-    }
-};
-
 /**
  * @classdesc
  * a generic system font object.
@@ -52,16 +39,15 @@ var getContext2d = function (renderer$1, text) {
      * @param {number|string} settings.size - size, or size + suffix (px, em, pt)
      * @param {Color|string} [settings.fillStyle="#000000"] - a CSS color value
      * @param {Color|string} [settings.strokeStyle="#000000"] - a CSS color value
-     * @param {number} [settings.lineWidth=1] - line width, in pixels, when drawing stroke
+     * @param {number} [settings.lineWidth=0] - line width, in pixels, when drawing stroke
      * @param {string} [settings.textAlign="left"] - horizontal text alignment
      * @param {string} [settings.textBaseline="top"] - the text baseline
      * @param {number} [settings.lineHeight=1.0] - line spacing height
      * @param {Vector2d} [settings.anchorPoint={x:0.0, y:0.0}] - anchor point to draw the text at
-     * @param {boolean} [settings.offScreenCanvas=false] - whether to draw the font to an individual "cache" texture first
      * @param {number} [settings.wordWrapWidth] - the maximum length in CSS pixel for a single segment of text
      * @param {(string|string[])} [settings.text=""] - a string, or an array of strings
      * @example
-     * var font = new me.Text(0, 0, {font: "Arial", size: 8, fillStyle: this.color});
+     * let font = new me.Text(0, 0, {font: "Arial", size: 8, fillStyle: this.color});
      */
     constructor(x, y, settings) {
         // call the parent constructor
@@ -112,9 +98,9 @@ var getContext2d = function (renderer$1, text) {
          * sets the current line width, in pixels, when drawing stroke
          * @public
          * @type {number}
-         * @default 1
+         * @default 0
          */
-        this.lineWidth = settings.lineWidth || 1;
+        this.lineWidth = settings.lineWidth || 0;
 
         /**
          * Set the default text alignment (or justification),<br>
@@ -143,16 +129,6 @@ var getContext2d = function (renderer$1, text) {
          */
         this.lineHeight = settings.lineHeight || 1.0;
 
-        /**
-         * whether to draw the font to a indidividual offscreen canvas texture first <br>
-         * Note: this will improve performances when using WebGL, but will impact
-         * memory consumption as every text element will have its own canvas texture
-         * @public
-         * @type {boolean}
-         * @default false
-         */
-        this.offScreenCanvas = false;
-
         /**
          * the maximum length in CSS pixel for a single segment of text.
          * (use -1 to disable word wrapping)
@@ -199,10 +175,9 @@ var getContext2d = function (renderer$1, text) {
             this.italic();
         }
 
-        if (settings.offScreenCanvas === true) {
-            this.offScreenCanvas = true;
-            this.canvasTexture = pool.pull("CanvasTexture", 2, 2, { offscreenCanvas: true });
-        }
+        // the canvas Texture used to render this text
+        // XXX: offscreenCanvas is currently disabled for text rendering due to issue in WebGL mode
+        this.canvasTexture = pool.pull("CanvasTexture", 2, 2, { offscreenCanvas: false });
 
         // instance to text metrics functions
         this.metrics = new TextMetrics(this);
@@ -242,7 +217,7 @@ var getContext2d = function (renderer$1, text) {
      */
     setFont(font, size = 10) {
         // font name and type
-        var font_names = font.split(",").map((value) => {
+        let font_names = font.split(",").map((value) => {
             value = value.trim();
             return (
                 !/(^".*"$)|(^'.*'$)/.test(value)
@@ -255,7 +230,7 @@ var getContext2d = function (renderer$1, text) {
             size += "px";
         } else /* string */ {
             // extract the units and convert if necessary
-            var CSSval = size.match(/([-+]?[\d.]*)(.*)/);
+            let CSSval = size.match(/([-+]?[\d.]*)(.*)/);
             this.fontSize = parseFloat(CSSval[1]);
             if (CSSval[2]) {
                 this.fontSize *= toPX[runits.indexOf(CSSval[2])];
@@ -278,7 +253,7 @@ var getContext2d = function (renderer$1, text) {
      * @returns {Text} this object for chaining
      */
     setText(value = "") {
-        var bounds = this.getBounds();
+        let bounds = this.getBounds();
 
         // set the next text
         if (this._text.toString() !== value.toString()) {
@@ -291,38 +266,38 @@ var getContext2d = function (renderer$1, text) {
 
         // word wrap if necessary
         if (this._text.length > 0 && this.wordWrapWidth > 0) {
-            this._text = this.metrics.wordWrap(this._text, this.wordWrapWidth, getContext2d(renderer, this));
+            this._text = this.metrics.wordWrap(this._text, this.wordWrapWidth, this.canvasTexture.context);
         }
 
         // calculcate the text size and update the bounds accordingly
-        bounds.addBounds(this.metrics.measureText(this._text, getContext2d(renderer, this)), true);
+        bounds.addBounds(this.metrics.measureText(this._text, this.canvasTexture.context), true);
 
         // update the offScreenCanvas texture if required
-        if (this.offScreenCanvas === true) {
-            var width = Math.ceil(this.metrics.width),
-                height = Math.ceil(this.metrics.height);
-
-            if (renderer instanceof WebGLRenderer) {
-                // invalidate the previous corresponding texture so that it can reuploaded once changed
-                this.glTextureUnit = renderer.cache.getUnit(renderer.cache.get(this.canvasTexture.canvas));
-                renderer.currentCompositor.unbindTexture2D(null, this.glTextureUnit);
-
-                if (renderer.WebGLVersion === 1) {
-                    // round size to next Pow2
-                    width = nextPowerOfTwo(this.metrics.width);
-                    height = nextPowerOfTwo(this.metrics.height);
-                }
-            }
-
-            // resize the cache canvas if necessary
-            if (this.canvasTexture.width < width || this.canvasTexture.height < height) {
-                this.canvasTexture.resize(width, height);
+        let width = Math.ceil(this.metrics.width),
+            height = Math.ceil(this.metrics.height);
+
+        if (typeof renderer.gl !== "undefined") {
+            // make sure the right compositor is active
+            renderer.setCompositor("quad");
+            // invalidate the previous corresponding texture so that it can reuploaded once changed
+            this.glTextureUnit = renderer.cache.getUnit(renderer.cache.get(this.canvasTexture.canvas));
+            renderer.currentCompositor.unbindTexture2D(null, this.glTextureUnit);
+
+            if (renderer.WebGLVersion === 1) {
+                // round size to next Pow2
+                width = nextPowerOfTwo(this.metrics.width);
+                height = nextPowerOfTwo(this.metrics.height);
             }
+        }
 
-            this.canvasTexture.clear();
-            this._drawFont(this.canvasTexture.context, this._text,  this.pos.x - this.metrics.x, this.pos.y - this.metrics.y, false);
+        // resize the cache canvas if necessary
+        if (this.canvasTexture.width < width || this.canvasTexture.height < height) {
+            this.canvasTexture.resize(width, height);
         }
 
+        this.canvasTexture.clear();
+        this._drawFont(this.canvasTexture.context, this._text,  this.pos.x - this.metrics.x, this.pos.y - this.metrics.y);
+
         this.isDirty = true;
 
         return this;
@@ -335,7 +310,7 @@ var getContext2d = function (renderer$1, text) {
      * @returns {TextMetrics} a TextMetrics object defining the dimensions of the given piece of text
      */
     measureText(renderer, text = this._text) {
-        return this.metrics.measureText(text, getContext2d(renderer, this));
+        return this.metrics.measureText(text, this.canvasTexture.context);
     }
 
 
@@ -345,9 +320,8 @@ var getContext2d = function (renderer$1, text) {
      * @param {string} [text]
      * @param {number} [x]
      * @param {number} [y]
-     * @param {boolean} [stroke=false] - draw stroke the the text if true
      */
-    draw(renderer, text, x = this.pos.x, y = this.pos.y, stroke = false) {
+    draw(renderer, text, x = this.pos.x, y = this.pos.y) {
         // "hacky patch" for backward compatibilty
         if (typeof this.ancestor === "undefined") {
 
@@ -361,21 +335,18 @@ var getContext2d = function (renderer$1, text) {
             // update text cache
             this.setText(text);
 
-            x = this.metrics.x;
-            y = this.metrics.y;
-
             // save the previous context
             renderer.save();
 
             // apply the defined alpha value
             renderer.setGlobalAlpha(renderer.globalAlpha() * this.getOpacity());
 
-        } else {
-             // added directly to an object container
-            x = this.pos.x;
-            y = this.pos.y;
         }
 
+        // adjust x,y position based on the bounding box
+        x = this.metrics.x;
+        y = this.metrics.y;
+
         // clamp to pixel grid if required
         if (renderer.settings.subPixel === false) {
             x = ~~x;
@@ -383,12 +354,7 @@ var getContext2d = function (renderer$1, text) {
         }
 
         // draw the text
-        if (this.offScreenCanvas === true) {
-            renderer.drawImage(this.canvasTexture.canvas, x, y);
-        } else {
-            renderer.drawFont(this._drawFont(renderer.getFontContext(), this._text, x, y, stroke));
-        }
-
+        renderer.drawImage(this.canvasTexture.canvas, x, y);
 
         // for backward compatibilty
         if (typeof this.ancestor === "undefined") {
@@ -398,28 +364,33 @@ var getContext2d = function (renderer$1, text) {
     }
 
     /**
-     * draw a stroke text at the specified coord, as defined <br>
-     * by the `lineWidth` and `fillStroke` properties. <br>
-     * Note : using drawStroke is not recommended for performance reasons
+     * draw a stroke text at the specified coord, as defined by the `lineWidth` and `fillStroke` properties.
+     * @deprecated since 15.0.0
      * @param {CanvasRenderer|WebGLRenderer} renderer - Reference to the destination renderer instance
      * @param {string} text
      * @param {number} x
      * @param {number} y
      */
     drawStroke(renderer, text, x, y) {
-        this.draw(renderer, text, x, y, true);
+        this.draw(renderer, text, x, y);
     }
 
     /**
      * @ignore
      */
-    _drawFont(context, text, x, y, stroke = false) {
-        setContextStyle(context, this, stroke);
+    _drawFont(context, text, x, y) {
+        setContextStyle(context, this);
 
-        for (var i = 0; i < text.length; i++) {
-            var string = text[i].trimEnd();
+        for (let i = 0; i < text.length; i++) {
+            let string = text[i].trimEnd();
             // draw the string
-            context[stroke ? "strokeText" : "fillText"](string, x, y);
+            if (this.fillStyle.alpha > 0) {
+                context.fillText(string, x, y);
+            }
+            // stroke the text
+            if (this.lineWidth > 0 && this.strokeStyle.alpha > 0) {
+                context.strokeText(string, x, y);
+            }
             // add leading space
             y += this.metrics.lineHeight();
         }
@@ -431,15 +402,15 @@ var getContext2d = function (renderer$1, text) {
      * @ignore
      */
     destroy() {
-        if (this.offScreenCanvas === true) {
-            if (renderer instanceof WebGLRenderer) {
-                renderer.currentCompositor.deleteTexture2D(renderer.currentCompositor.getTexture2D(this.glTextureUnit));
-                this.glTextureUnit = undefined;
-            }
-            renderer.cache.delete(this.canvasTexture.canvas);
-            pool.push(this.canvasTexture);
-            this.canvasTexture = undefined;
+        if (typeof renderer.gl !== "undefined") {
+            // make sure the right compositor is active
+            renderer.setCompositor("quad");
+            renderer.currentCompositor.deleteTexture2D(renderer.currentCompositor.getTexture2D(this.glTextureUnit));
+            this.glTextureUnit = undefined;
         }
+        renderer.cache.delete(this.canvasTexture.canvas);
+        pool.push(this.canvasTexture);
+        this.canvasTexture = undefined;
         pool.push(this.fillStyle);
         pool.push(this.strokeStyle);
         this.fillStyle = this.strokeStyle = undefined;

package/dist/melonjs.mjs/text/textmetrics.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.1.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -57,14 +57,14 @@ import setContextStyle from './textstyle.js';
         if (this.ancestor instanceof Text) {
             return context.measureText(text).width;
         } else { // it's a BitmapText
-            var characters = text.split("");
-            var width = 0;
-            var lastGlyph = null;
-            for (var i = 0; i < characters.length; i++) {
-                var ch = characters[i].charCodeAt(0);
-                var glyph = this.ancestor.fontData.glyphs[ch];
+            let characters = text.split("");
+            let width = 0;
+            let lastGlyph = null;
+            for (let i = 0; i < characters.length; i++) {
+                let ch = characters[i].charCodeAt(0);
+                let glyph = this.ancestor.fontData.glyphs[ch];
                 if (typeof glyph !== "undefined") {
-                    var kerning = (lastGlyph && lastGlyph.kerning) ? lastGlyph.getKerning(ch) : 0;
+                    let kerning = (lastGlyph && lastGlyph.kerning) ? lastGlyph.getKerning(ch) : 0;
                     width += (glyph.xadvance + kerning) * this.ancestor.fontScale.x;
                     lastGlyph = glyph;
                 }
@@ -80,7 +80,7 @@ import setContextStyle from './textstyle.js';
      * @returns {TextMetrics} this
      */
     measureText(text, context) {
-        var strings;
+        let strings;
 
         if (!Array.isArray(text)) {
             strings = ("" + text).split("\n");
@@ -99,7 +99,7 @@ import setContextStyle from './textstyle.js';
         // compute the bounding box size
         this.width = this.height = 0;
 
-        for (var i = 0; i < strings.length; i++) {
+        for (let i = 0; i < strings.length; i++) {
             this.width = Math.max(this.lineWidth(strings[i].trimEnd(), context), this.width);
             this.height += this.lineHeight();
         }
@@ -130,9 +130,9 @@ import setContextStyle from './textstyle.js';
      * @returns {string[]} an array of string representing wrapped text
      */
     wordWrap(text, width, context) {
-        var words;
-        var currentLine = "";
-        var output = [];
+        let words;
+        let currentLine = "";
+        let output = [];
 
         if (Array.isArray(text)) {
             // join into a single string
@@ -150,8 +150,8 @@ import setContextStyle from './textstyle.js';
         }
 
         for (let i = 0; i < words.length; i++) {
-            var word = words[i];
-            var lineWidth = this.lineWidth(currentLine + word + " ", context);
+            let word = words[i];
+            let lineWidth = this.lineWidth(currentLine + word + " ", context);
             if (lineWidth < width) {
                 // add the word to the current line
                 currentLine += word + " ";

package/dist/melonjs.mjs/text/textstyle.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.1.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -9,13 +9,11 @@
  * apply the current text style to the given context
  * @ignore
  */
-function setContextStyle(context, style, stroke = false) {
+function setContextStyle(context, style) {
     context.font = style.font;
     context.fillStyle = style.fillStyle.toRGBA();
-    if (stroke === true) {
-        context.strokeStyle = style.strokeStyle.toRGBA();
-        context.lineWidth = style.lineWidth;
-    }
+    context.strokeStyle = style.strokeStyle.toRGBA();
+    context.lineWidth = style.lineWidth;
     context.textAlign = style.textAlign;
     context.textBaseline = style.textBaseline;
 }

package/dist/melonjs.mjs/tweens/easing.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.1.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -270,21 +270,21 @@ let Easing = {
         /** @ignore */
         In: function ( k ) {
 
-            var s = 1.70158;
+            const s = 1.70158;
             return k * k * ( ( s + 1 ) * k - s );
 
         },
         /** @ignore */
         Out: function ( k ) {
 
-            var s = 1.70158;
+            const s = 1.70158;
             return --k * k * ( ( s + 1 ) * k + s ) + 1;
 
         },
         /** @ignore */
         InOut: function ( k ) {
 
-            var s = 1.70158 * 1.525;
+            const s = 1.70158 * 1.525;
             if ( ( k *= 2 ) < 1 ) return 0.5 * ( k * k * ( ( s + 1 ) * k - s ) );
             return 0.5 * ( ( k -= 2 ) * k * ( ( s + 1 ) * k + s ) + 2 );