melonjs 17.1.0 → 17.2.0

package/dist/types/audio/audio.d.ts

@@ -113,11 +113,12 @@ export function rate(sound_name: string, ...args: any[]): number;
  * @memberof audio
  * @param {string} sound_name - audio clip name - case sensitive
  * @param {number} [pan] - the panning value - A value of -1.0 is all the way left and 1.0 is all the way right.
+ * @param {number} [id] - the sound instance ID. If none is passed, all sounds in group will be changed.
  * @return {number} the current panning value
  * @example
  * me.audio.stereo("cling", -1);
  */
-export function stereo(sound_name: string, pan?: number | undefined): number;
+export function stereo(sound_name: string, pan?: number | undefined, id?: number | undefined): number;
 /**
  * get or set the 3D spatial position for the specified sound.
  * @memberof audio
@@ -125,9 +126,10 @@ export function stereo(sound_name: string, pan?: number | undefined): number;
  * @param  {Number} x - the x-position of the audio source.
  * @param  {Number} y - the y-position of the audio source.
  * @param  {Number} z - the z-position of the audio source.
+ * @param {number} [id] - the sound instance ID. If none is passed, all sounds in group will be changed.
  * @return {Array} the current 3D spatial position: [x, y, z]
  */
-export function position(sound_name: string, x: number, y: number, z: number): any[];
+export function position(sound_name: string, x: number, y: number, z: number, id?: number | undefined): any[];
 /**
  * Get/set the direction the audio source is pointing in the 3D cartesian coordinate space.
  * Depending on how direction the sound is, based on the `cone` attributes, a sound pointing away from the listener can be quiet or silent.
@@ -136,9 +138,10 @@ export function position(sound_name: string, x: number, y: number, z: number): a
  * @param  {Number} x - the x-orientation of the audio source.
  * @param  {Number} y - the y-orientation of the audio source.
  * @param  {Number} z - the z-orientation of the audio source.
+ * @param {number} [id] - the sound instance ID. If none is passed, all sounds in group will be changed.
  * @return {Array} the current 3D spatial orientation: [x, y, z]
  */
-export function orientation(sound_name: string, x: number, y: number, z: number): any[];
+export function orientation(sound_name: string, x: number, y: number, z: number, id?: number | undefined): any[];
 /**
  * get or set the panner node's attributes for a sound or group of sounds.
  * See {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Web_audio_spatialization_basics#creating_a_panner_node}
@@ -153,6 +156,7 @@ export function orientation(sound_name: string, x: number, y: number, z: number)
  * @param {string} [settings.refDistance=1] - A reference distance for reducing volume as source moves further from the listener. This is simply a variable of the distance model and has a different effect depending on which model is used and the scale of your coordinates. Generally, volume will be equal to 1 at this distance.
  * @param {string} [settings.rolloffFactor=1] - How quickly the volume reduces as source moves from listener. This is simply a variable of the distance model and can be in the range of `[0, 1]` with `linear` and `[0, ∞]` with `inverse` and `exponential`.
  * @param {string} [settings.panningModel="HRTF"] - Determines which spatialization algorithm is used to position audio. Can be `HRTF` or `equalpower`.
+ * @param {number} [id] - the sound instance ID. If none is passed, all sounds in group will be changed.
  * @return {Object} current panner attributes.
  * @example
  * me.audio.panner("cling", {
@@ -162,7 +166,7 @@ export function orientation(sound_name: string, x: number, y: number, z: number)
  *    distanceModel: 'exponential'
  * });
  */
-export function panner(sound_name: string, attributes: any): Object;
+export function panner(sound_name: string, attributes: any, id?: number | undefined): Object;
 /**
  * stop the specified sound on all channels
  * @memberof audio

package/dist/types/loader/cache.d.ts

@@ -6,3 +6,4 @@ export let tmxList: {};
 export let binList: {};
 export let jsonList: {};
 export let videoList: {};
+export let fontList: {};

package/dist/types/loader/loader.d.ts

@@ -242,6 +242,13 @@ export function getJSON(elt: string): JSON;
  * @returns {HTMLVideoElement}
  */
 export function getVideo(elt: string): HTMLVideoElement;
+/**
+ * return the specified FontFace Object
+ * @memberof loader
+ * @param {string} elt - name of the font file
+ * @returns {FontFace}
+ */
+export function getFont(elt: string): FontFace;
 /**
  * a small class to manage loading of stuff and manage resources
  * @namespace loader

package/dist/types/system/platform.d.ts

@@ -15,6 +15,7 @@
 * @property {boolean} isWeixin `true` if running under Wechat
 * @property {boolean} nodeJS `true` if running under node.js
 * @property {boolean} isMobile `true` if a mobile device
+* @property {boolean} webApp `true` if running as a standalone web app
 */
 export const ua: string;
 export const iOS: boolean;
@@ -29,3 +30,4 @@ export const ejecta: boolean;
 export const isWeixin: boolean;
 export const nodeJS: boolean;
 export const isMobile: boolean;
+export const webApp: boolean;

package/dist/types/video/renderer.d.ts

@@ -66,7 +66,6 @@ export default class Renderer {
      * @ignore
      */
     currentBlendMode: string;
-    canvas: any;
     currentColor: Color;
     currentTint: Color;
     projectionMatrix: Matrix3d;
@@ -96,12 +95,12 @@ export default class Renderer {
      */
     reset(): void;
     /**
-     * return a reference to the canvas which this renderer draws to
+     * return a reference to the current render target corresponding canvas which this renderer draws to
      * @returns {HTMLCanvasElement}
      */
     getCanvas(): HTMLCanvasElement;
     /**
-     * return a reference to this renderer canvas corresponding Context
+     * return a reference to the current render target corresponding Context
      * @returns {CanvasRenderingContext2D|WebGLRenderingContext}
      */
     getContext(): CanvasRenderingContext2D | WebGLRenderingContext;
@@ -110,14 +109,6 @@ export default class Renderer {
      * @returns {string} blend mode
      */
     getBlendMode(): string;
-    /**
-     * Returns the 2D Context object of the given Canvas<br>
-     * Also configures anti-aliasing and blend modes based on constructor options.
-     * @param {HTMLCanvasElement} canvas
-     * @param {boolean} [transparent=true] - use false to disable transparency
-     * @returns {CanvasRenderingContext2D}
-     */
-    getContext2d(canvas: HTMLCanvasElement, transparent?: boolean | undefined): CanvasRenderingContext2D;
     /**
      * get the current fill & stroke style color.
      * @returns {Color} current global color
@@ -141,11 +132,10 @@ export default class Renderer {
      */
     resize(width: number, height: number): void;
     /**
-     * enable/disable image smoothing (scaling interpolation) for the given context
-     * @param {CanvasRenderingContext2D} context
+     * enable/disable image smoothing (scaling interpolation) for the current render target
      * @param {boolean} [enable=false]
      */
-    setAntiAlias(context: CanvasRenderingContext2D, enable?: boolean | undefined): void;
+    setAntiAlias(enable?: boolean | undefined): void;
     /**
      * set/change the current projection matrix (WebGL only)
      * @param {Matrix3d} matrix
@@ -167,7 +157,7 @@ export default class Renderer {
      * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas} src - the source image to be tinted
      * @param {Color|string} color - the color that will be used to tint the image
      * @param {string} [mode="multiply"] - the composition mode used to tint the image
-     * @returns {HTMLCanvasElement|OffscreenCanvas} a new canvas element representing the tinted image
+     * @returns {HTMLCanvasElement|OffscreenCanvas} a new canvas or offscreencanvas (if supported) element representing the tinted image
      */
     tint(src: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, color: Color | string, mode?: string | undefined): HTMLCanvasElement | OffscreenCanvas;
     /**

package/dist/types/video/rendertarget/canvasrendertarget.d.ts

@@ -6,18 +6,15 @@ declare class CanvasRenderTarget {
     /**
      * @param {number} width - the desired width of the canvas
      * @param {number} height - the desired height of the canvas
-     * @param {object} attributes - The attributes to create both the canvas and context
-     * @param {boolean} [attributes.context="2d"] - the context type to be created ("2d", "webgl", "webgl2")
+     * @param {Settings} attributes - The attributes to create both the canvas and context
+     * @param {boolean} [attributes.context="2d"] - the context type to be created ("2d", "webgl")
+     * @param {boolean} [attributes.preferWebGL1=false] - set to true for force using WebGL1 instead of WebGL2 (if supported)
+     * @param {boolean} [attributes.transparent=false] - specify if the canvas contains an alpha channel
      * @param {boolean} [attributes.offscreenCanvas=false] - will create an offscreenCanvas if true instead of a standard canvas
      * @param {boolean} [attributes.willReadFrequently=false] - Indicates whether or not a lot of read-back operations are planned
      * @param {boolean} [attributes.antiAlias=false] - Whether to enable anti-aliasing, use false (default) for a pixelated effect.
      */
-    constructor(width: number, height: number, attributes?: {
-        context?: boolean | undefined;
-        offscreenCanvas?: boolean | undefined;
-        willReadFrequently?: boolean | undefined;
-        antiAlias?: boolean | undefined;
-    });
+    constructor(width: number, height: number, attributes?: Settings);
     /**
      * the canvas created for this CanvasRenderTarget
      * @type {HTMLCanvasElement|OffscreenCanvas}
@@ -28,7 +25,7 @@ declare class CanvasRenderTarget {
      * @type {CanvasRenderingContext2D|WebGLRenderingContext}
      */
     context: CanvasRenderingContext2D | WebGLRenderingContext;
-    attributes: never;
+    attributes: any;
     WebGLVersion: any;
     /**
      * @ignore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melonjs",
-  "version": "17.1.0",
+  "version": "17.2.0",
   "description": "melonJS Game Engine",
   "homepage": "http://www.melonjs.org/",
   "type": "module",
@@ -53,45 +53,45 @@
   ],
   "dependencies": {
     "@teppeis/multimaps": "^3.0.0",
-    "core-js": "^3.36.1",
+    "core-js": "^3.37.0",
     "earcut": "2.2.4",
     "eventemitter3": "^5.0.1",
     "howler": "2.2.4",
+    "save-dev": "^0.0.1-security",
     "semver": "^7.6.0",
     "whatwg-fetch": "^3.6.20"
   },
   "devDependencies": {
-    "@babel/eslint-parser": "^7.24.1",
-    "@babel/plugin-syntax-import-assertions": "^7.24.1",
-    "@fastify/static": "^7.0.1",
+    "@fastify/static": "^7.0.3",
     "@melonjs/webdoc-theme": "^1.1.1",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-image": "^3.0.3",
+    "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-replace": "^5.0.5",
     "@webdoc/cli": "^2.2.0",
-    "chromedriver": "^123.0.1",
+    "chromedriver": "^123.0.4",
     "cross-env": "^7.0.3",
     "del-cli": "^5.1.0",
-    "eslint": "^8.57.0",
-    "eslint-plugin-jsdoc": "^48.2.2",
+    "eslint": "^9.1.0",
+    "eslint-plugin-jsdoc": "^48.2.3",
     "expect": "^29.7.0",
     "expect-mocha-image-snapshot": "^3.0.16",
     "fastify": "^4.26.2",
     "mocha": "^10.4.0",
     "npm-self-link": "^1.1.7",
-    "puppeteer": "^22.6.1",
-    "rollup": "^4.13.2",
+    "puppeteer": "^22.6.5",
+    "rollup": "^4.16.1",
     "rollup-plugin-bundle-size": "^1.0.3",
     "rollup-plugin-string": "^3.0.0",
-    "terser": "^5.30.0",
-    "typescript": "^5.4.3"
+    "terser": "^5.30.3",
+    "typescript": "^5.4.5"
   },
   "scripts": {
     "build": "npm run lint && rollup -c --silent",
     "build:cd": "npm run lint && rollup -c --failAfterWarnings",
     "dist": " npm run clean && npm run build && mkdirp dist && cp -fR build/*.* dist/ && npm run types && npm run doc",
-    "lint": "eslint src/** rollup.config.mjs",
+    "lint": "eslint",
     "pretest": "mkdirp tests/browser/public/lib && cp -f build/melonjs.module.js tests/browser/public/lib",
     "test": "npm run test-node && mocha ./tests/browser/spec/*.js --reporter spec --bail --timeout 10000",
     "test-node": "node build/melonjs.module.js",

package/src/application/application.js

@@ -180,7 +180,7 @@ export default class Application {
 
         // identify parent element and/or the html target for resizing
         this.parentElement = device.getElement(this.settings.parent);
-        if (typeof this.settings.scaleTarget !== "undefined" ) {
+        if (typeof this.settings.scaleTarget !== "undefined") {
             this.settings.scaleTarget = device.getElement(this.settings.scaleTarget);
         }
 

package/src/application/header.js

@@ -20,7 +20,7 @@ export function consoleHeader(app) {
         device.language
     );
 
-    console.log( "resolution: " + "requested " + app.settings.width + "x" + app.settings.height +
+    console.log("resolution: " + "requested " + app.settings.width + "x" + app.settings.height +
         ", got " + app.renderer.width + "x" + app.renderer.height
     );
 }

package/src/audio/audio.js

@@ -284,14 +284,15 @@ export function rate(sound_name, ...args) {
  * @memberof audio
  * @param {string} sound_name - audio clip name - case sensitive
  * @param {number} [pan] - the panning value - A value of -1.0 is all the way left and 1.0 is all the way right.
+ * @param {number} [id] - the sound instance ID. If none is passed, all sounds in group will be changed.
  * @return {number} the current panning value
  * @example
  * me.audio.stereo("cling", -1);
  */
-export function stereo(sound_name, pan) {
+export function stereo(sound_name, pan, id) {
     let sound = audioTracks[sound_name];
     if (sound && typeof sound !== "undefined") {
-        return sound.stereo(pan);
+        return sound.stereo(pan, id);
     } else {
         throw new Error("audio clip " + sound_name + " does not exist");
     }
@@ -304,12 +305,13 @@ export function stereo(sound_name, pan) {
  * @param  {Number} x - the x-position of the audio source.
  * @param  {Number} y - the y-position of the audio source.
  * @param  {Number} z - the z-position of the audio source.
+ * @param {number} [id] - the sound instance ID. If none is passed, all sounds in group will be changed.
  * @return {Array} the current 3D spatial position: [x, y, z]
  */
-export function position(sound_name, x, y, z) {
+export function position(sound_name, x, y, z, id) {
     let sound = audioTracks[sound_name];
     if (sound && typeof sound !== "undefined") {
-        return sound.pos(x, y, z);
+        return sound.pos(x, y, z, id);
     } else {
         throw new Error("audio clip " + sound_name + " does not exist");
     }
@@ -323,12 +325,13 @@ export function position(sound_name, x, y, z) {
  * @param  {Number} x - the x-orientation of the audio source.
  * @param  {Number} y - the y-orientation of the audio source.
  * @param  {Number} z - the z-orientation of the audio source.
+ * @param {number} [id] - the sound instance ID. If none is passed, all sounds in group will be changed.
  * @return {Array} the current 3D spatial orientation: [x, y, z]
  */
-export function orientation(sound_name, x, y, z) {
+export function orientation(sound_name, x, y, z, id) {
     let sound = audioTracks[sound_name];
     if (sound && typeof sound !== "undefined") {
-        return sound.orientation(x, y, z);
+        return sound.orientation(x, y, z, id);
     } else {
         throw new Error("audio clip " + sound_name + " does not exist");
     }
@@ -348,6 +351,7 @@ export function orientation(sound_name, x, y, z) {
  * @param {string} [settings.refDistance=1] - A reference distance for reducing volume as source moves further from the listener. This is simply a variable of the distance model and has a different effect depending on which model is used and the scale of your coordinates. Generally, volume will be equal to 1 at this distance.
  * @param {string} [settings.rolloffFactor=1] - How quickly the volume reduces as source moves from listener. This is simply a variable of the distance model and can be in the range of `[0, 1]` with `linear` and `[0, ∞]` with `inverse` and `exponential`.
  * @param {string} [settings.panningModel="HRTF"] - Determines which spatialization algorithm is used to position audio. Can be `HRTF` or `equalpower`.
+ * @param {number} [id] - the sound instance ID. If none is passed, all sounds in group will be changed.
  * @return {Object} current panner attributes.
  * @example
  * me.audio.panner("cling", {
@@ -357,10 +361,10 @@ export function orientation(sound_name, x, y, z) {
  *    distanceModel: 'exponential'
  * });
  */
-export function panner(sound_name, attributes) {
+export function panner(sound_name, attributes, id) {
     let sound = audioTracks[sound_name];
     if (sound && typeof sound !== "undefined") {
-        return sound.pannerAttr(attributes);
+        return sound.pannerAttr(attributes, id);
     } else {
         throw new Error("audio clip " + sound_name + " does not exist");
     }

package/src/geometries/path2d.js

@@ -63,12 +63,12 @@ export default class Path2D {
                     break;
                 case "H":
                     // H take 1 coordinate
-                    lastPoint = points.length === 0 ? startPoint : points[points.length-1];
+                    lastPoint = points.length === 0 ? startPoint : points[points.length - 1];
                     this.lineTo(lastPoint.x + coordinates[0], lastPoint.y);
                     break;
                 case "V":
                     // V take 1 coordinate
-                    lastPoint = points.length === 0 ? startPoint : points[points.length-1];
+                    lastPoint = points.length === 0 ? startPoint : points[points.length - 1];
                     this.lineTo(lastPoint.x, lastPoint.y + coordinates[0]);
                     break;
                 case "M":
@@ -120,7 +120,7 @@ export default class Path2D {
         let points = this.points;
         if (points.length > 0) {
             let firstPoint = points[0];
-            if (!firstPoint.equals(points[points.length-1])) {
+            if (!firstPoint.equals(points[points.length - 1])) {
                 this.lineTo(firstPoint.x, firstPoint.y);
             }
             this.isDirty = true;
@@ -145,14 +145,14 @@ export default class Path2D {
             }
 
             // calculate all vertices
-            for (let i = 0; i < indicesLength; i++ ) {
+            for (let i = 0; i < indicesLength; i++) {
                 let point = points[indices[i]];
                 vertices[i].set(point.x, point.y);
             }
 
             // recycle overhead from a previous triangulation
             while (vertices.length > indicesLength) {
-                pool.push(vertices[vertices.length-1]);
+                pool.push(vertices[vertices.length - 1]);
                 vertices.length -= 1;
             }
             this.isDirty = false;
@@ -179,7 +179,7 @@ export default class Path2D {
     lineTo(x, y) {
         let points = this.points;
         let startPoint = this.startPoint;
-        let lastPoint = points.length === 0 ? startPoint : points[points.length-1];
+        let lastPoint = points.length === 0 ? startPoint : points[points.length - 1];
 
         if (!startPoint.equals(lastPoint)) {
             points.push(pool.pull("Point", startPoint.x, startPoint.y));
@@ -208,7 +208,7 @@ export default class Path2D {
         // based on from https://github.com/karellodewijk/canvas-webgl/blob/master/canvas-webgl.js
         //bring angles all in [0, 2*PI] range
         if (startAngle === endAngle) return;
-        const fullCircle = anticlockwise ? Math.abs(startAngle-endAngle) >= (TAU) : Math.abs(endAngle-startAngle) >= (TAU);
+        const fullCircle = anticlockwise ? Math.abs(startAngle - endAngle) >= (TAU) : Math.abs(endAngle - startAngle) >= (TAU);
 
         startAngle = startAngle % (TAU);
         endAngle = endAngle % (TAU);
@@ -217,7 +217,7 @@ export default class Path2D {
         if (endAngle < 0) endAngle += TAU;
 
         if (startAngle >= endAngle) {
-            endAngle+= TAU;
+            endAngle += TAU;
         }
 
         let diff = endAngle - startAngle;
@@ -258,7 +258,7 @@ export default class Path2D {
     arcTo(x1, y1, x2, y2, radius) {
         let points = this.points;
         let startPoint = this.startPoint;
-        let lastPoint = points.length === 0 ? startPoint : points[points.length-1];
+        let lastPoint = points.length === 0 ? startPoint : points[points.length - 1];
 
         // based on from https://github.com/karellodewijk/canvas-webgl/blob/master/canvas-webgl.js
         let x0 = lastPoint.x, y0 = lastPoint.y;
@@ -273,8 +273,8 @@ export default class Path2D {
         let angle = Math.atan2(a1, a0) - Math.atan2(b1, b0);
 
         //work out tangent points using tan(θ) = opposite / adjacent; angle/2 because hypotenuse is the bisection of a,b
-        let tan_angle_div2 = Math.tan(angle/2);
-        let adj_l = (radius/tan_angle_div2);
+        let tan_angle_div2 = Math.tan(angle / 2);
+        let adj_l = (radius / tan_angle_div2);
 
         let tangent1_pointx = x1 + a0 * adj_l, tangent1_pointy = y1 + a1 * adj_l;
         let tangent2_pointx = x1 + b0 * adj_l, tangent2_pointy = y1 + b1 * adj_l;
@@ -309,7 +309,7 @@ export default class Path2D {
     ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise = false) {
         // based on from https://github.com/karellodewijk/canvas-webgl/blob/master/canvas-webgl.js
         if (startAngle === endAngle) return;
-        let fullCircle = anticlockwise ? Math.abs(startAngle-endAngle) >= (TAU) : Math.abs(endAngle-startAngle) >= (TAU);
+        let fullCircle = anticlockwise ? Math.abs(startAngle - endAngle) >= (TAU) : Math.abs(endAngle - startAngle) >= (TAU);
 
         //bring angles all in [0, 2*PI] range
         startAngle = startAngle % (TAU);
@@ -317,7 +317,7 @@ export default class Path2D {
         if (startAngle < 0) startAngle += TAU;
         if (endAngle < 0) endAngle += TAU;
 
-        if (startAngle>=endAngle) {
+        if (startAngle >= endAngle) {
             endAngle += TAU;
         }
 
@@ -347,7 +347,7 @@ export default class Path2D {
             const _y1 = radiusY * Math.sin(angle);
             const _x2 = x + _x1 * cos_rotation - _y1 * sin_rotation;
             const _y2 = y + _x1 * sin_rotation + _y1 * cos_rotation;
-            this.lineTo( _x2, _y2);
+            this.lineTo(_x2, _y2);
             angle += angleStep;
         }
         // close the ellipse
@@ -365,7 +365,7 @@ export default class Path2D {
     quadraticCurveTo(cpX, cpY, x, y) {
         const points = this.points;
         const startPoint = this.startPoint;
-        const lastPoint = points.length === 0 ? startPoint : points[points.length-1];
+        const lastPoint = points.length === 0 ? startPoint : points[points.length - 1];
         const endPoint = pool.pull("Point").set(x, y);
         const controlPoint = pool.pull("Point").set(cpX, cpY);
         const resolution = this.arcResolution;
@@ -393,7 +393,7 @@ export default class Path2D {
     bezierCurveTo(cp1X, cp1Y, cp2X, cp2Y, x, y) {
         const points = this.points;
         const startPoint = this.startPoint;
-        const lastPoint = points.length === 0 ? startPoint : points[points.length-1];
+        const lastPoint = points.length === 0 ? startPoint : points[points.length - 1];
         const endPoint = pool.pull("Point").set(x, y);
         const controlPoint1 = pool.pull("Point").set(cp1X, cp1Y);
         const controlPoint2 = pool.pull("Point").set(cp2X, cp2Y);

package/src/index.js

@@ -226,7 +226,7 @@ export function boot() {
     }
 
     // output melonJS version in the console
-    console.log("melonJS 2 (v" + version + ") | http://melonjs.org" );
+    console.log("melonJS 2 (v" + version + ") | http://melonjs.org");
 
     // register all built-ins objects into the object pool
     pool.register("me.Entity", Entity);
@@ -293,7 +293,7 @@ export function boot() {
     event.emit(event.BOOT);
 
     // enable/disable the cache
-    loader.setNocache( utils.getUriFragment().nocache || false );
+    loader.setNocache(utils.getUriFragment().nocache || false);
 
     // automatically enable keyboard events
     input.initKeyboardEvent();

package/src/level/tiled/TMXObject.js

@@ -228,7 +228,7 @@ export default class TMXObject {
                 let _polygon = pool.pull("Polygon", 0, 0, this.points);
                 let isConvex = _polygon.isConvex();
                 // make sure it's a convex polygon
-                if (isConvex === false ) {
+                if (isConvex === false) {
                     throw new Error("collision polygones in Tiled should be defined as Convex");
                 } else if (isConvex === null) {
                     throw new Error("invalid polygone");

package/src/level/tiled/TMXTileMap.js

@@ -199,7 +199,7 @@ export default class TMXTileMap {
         if (this.version !== "undefined" && this.version !== "") {
             // deprecation warning if map tiled version is older than 1.5
             if (checkVersion(this.version, "1.5") < 0) {
-                warning("("+this.name+") Tiled Map format version 1.4 and below", "format 1.5 or higher", "10.4.4");
+                warning("(" + this.name + ") Tiled Map format version 1.4 and below", "format 1.5 or higher", "10.4.4");
             }
         }
 

package/src/level/tiled/TMXUtils.js

@@ -45,7 +45,7 @@ function setTMXValue(name, type, value) {
                 try {
                     value = JSON.parse(match);
                 }
-                catch (e) {
+                catch {
                     throw new Error("Unable to parse JSON: " + match);
                 }
             }
@@ -56,7 +56,7 @@ function setTMXValue(name, type, value) {
                     // eslint-disable-next-line
                     value = Function("'use strict';return (" + match + ")")();
                 }
-                catch (e) {
+                catch {
                     throw new Error("Unable to evaluate: " + match);
                 }
             }

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

@@ -185,10 +185,10 @@ export default class TMXHexagonalRenderer extends TMXRenderer {
             }
         } else {
             if ((x & 1) ^ this.staggerEven) {
-                ret.set(x -1, y + 1);
+                ret.set(x - 1, y + 1);
             }
             else {
-                ret.set(x -1, y);
+                ret.set(x - 1, y);
             }
         }
         return ret;
@@ -422,11 +422,11 @@ export default class TMXHexagonalRenderer extends TMXRenderer {
             let staggeredRow = this.doStaggerX(startTile.x + layer.pos.x);
 
             // main drawing loop
-            for (; startPos.y < rect.bottom && startTile.y < endY; ) {
+            for (; startPos.y < rect.bottom && startTile.y < endY;) {
                 rowTile.setV(startTile);
                 rowPos.setV(startPos);
 
-                for (; rowPos.x < rect.right && rowTile.x < endX; rowTile.x+=2) {
+                for (; rowPos.x < rect.right && rowTile.x < endX; rowTile.x += 2) {
                     tile = layer.cellAt(rowTile.x, rowTile.y, false);
                     if (tile) {
                         // draw the tile

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

@@ -133,8 +133,8 @@ export default class TMXOrthogonalRenderer extends TMXRenderer {
         }
 
         // main drawing loop
-        for (let y = start.y; y !== end.y; y+= incY) {
-            for (let x = start.x; x !== end.x; x+= incX) {
+        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/loader/cache.js

@@ -17,3 +17,6 @@ export let jsonList = {};
 
 // contains all the video files
 export let videoList = {};
+
+// contains all the font files
+export let fontList = {};

package/src/loader/loader.js

@@ -2,7 +2,7 @@ import * as fileUtil from "./../utils/file.js";
 import * as event from "./../system/event.js";
 import * as audio from "./../audio/audio.js";
 import state from "./../state/state.js";
-import { imgList, tmxList, binList, jsonList, videoList } from "./cache.js";
+import { imgList, tmxList, binList, jsonList, videoList, fontList } from "./cache.js";
 import { preloadImage } from "./parsers/image.js";
 import { preloadFontFace } from "./parsers/fontface.js";
 import { preloadTMX } from "./parsers/tmx.js";
@@ -529,8 +529,12 @@ export function unload(asset) {
             return true;
 
         case "fontface":
-            // ??
-            return true;
+            if (typeof typeof globalThis.document !== "undefined" && typeof globalThis.document.fonts !== "undefined") {
+                globalThis.document.fonts.delete(fontList[asset.name]);
+                delete fontList[asset.name];
+                return true;
+            }
+            return false;
 
         case "tmx":
         case "tsx":
@@ -615,6 +619,16 @@ export function unloadAll() {
         }
     }
 
+    // unload all video resources
+    for (name in fontList) {
+        if (fontList.hasOwnProperty(name)) {
+            unload({
+                "name" : name,
+                "type" : "font"
+            });
+        }
+    }
+
     // unload all audio resources
     audio.unloadAll();
 }
@@ -695,3 +709,19 @@ export function getVideo(elt) {
     return null;
 }
 
+/**
+ * return the specified FontFace Object
+ * @memberof loader
+ * @param {string} elt - name of the font file
+ * @returns {FontFace}
+ */
+export function getFont(elt) {
+    // force as string
+    elt = "" + elt;
+    if (elt in fontList) {
+        return fontList[elt];
+    }
+    return null;
+}
+
+