melonjs 14.0.2 → 14.1.0

package/src/particles/emitter.js

@@ -23,9 +23,9 @@ function createDefaultParticleTexture(w = 8, h = 8) {
  */
 class ParticleEmitter extends Container {
     /**
-     * @param {number} x x position of the particle emitter
-     * @param {number} y y position of the particle emitter
-     * @param {ParticleEmitterSettings} [settings=ParticleEmitterSettings] the settings for the particle emitter.
+     * @param {number} x - x position of the particle emitter
+     * @param {number} y - y position of the particle emitter
+     * @param {ParticleEmitterSettings} [settings=ParticleEmitterSettings] - the settings for the particle emitter.
      * @example
      * // Create a particle emitter at position 100, 100
      * var emitter = new ParticleEmitter(100, 100, {
@@ -110,7 +110,7 @@ class ParticleEmitter extends Container {
 
     /**
      * Reset the emitter with particle emitter settings.
-     * @param {ParticleEmitterSettings} settings [optional] object with emitter settings. See {@link ParticleEmitterSettings}
+     * @param {ParticleEmitterSettings} settings - [optional] object with emitter settings. See {@link ParticleEmitterSettings}
      */
     reset(settings = {}) {
         Object.assign(this.settings, ParticleEmitterSettings, settings);
@@ -161,7 +161,7 @@ class ParticleEmitter extends Container {
 
     /**
      * Launch particles from emitter constantly (e.g. for stream)
-     * @param {number} duration [optional] time that the emitter releases particles in ms
+     * @param {number} duration - [optional] time that the emitter releases particles in ms
      */
     streamParticles(duration) {
         this._enabled = true;
@@ -179,7 +179,7 @@ class ParticleEmitter extends Container {
 
     /**
      * Launch all particles from emitter and stop (e.g. for explosion)
-     * @param {number} total [optional] number of particles to launch
+     * @param {number} total - [optional] number of particles to launch
      */
     burstParticles(total) {
         this._enabled = true;

package/src/particles/particle.js

@@ -10,7 +10,7 @@ import Renderable from "./../renderable/renderable.js";
  */
 class Particle extends Renderable {
     /**
-     * @param {ParticleEmitter} emitter the particle emitter
+     * @param {ParticleEmitter} emitter - the particle emitter
      */
     constructor(emitter) {
         // Call the super constructor
@@ -107,7 +107,7 @@ class Particle extends Renderable {
      * Update the Particle <br>
      * This is automatically called by the game manager {@link game}
      * @ignore
-     * @param {number} dt time since the last update in milliseconds
+     * @param {number} dt - time since the last update in milliseconds
      */
     update(dt) {
         // move things forward independent of the current frame rate

package/src/physics/body.js

@@ -16,9 +16,9 @@ import Point from "../geometries/point.js";
  */
 class Body {
     /**
-     * @param {Renderable} ancestor the parent object this body is attached to
-     * @param {Rect|Rect[]|Polygon|Polygon[]|Line|Line[]|Ellipse|Ellipse[]|Point|Point[]|Bounds|Bounds[]|object} [shapes] a initial shape, list of shapes, or JSON object defining the body
-     * @param {Function} [onBodyUpdate] callback for when the body is updated (e.g. add/remove shapes)
+     * @param {Renderable} ancestor - the parent object this body is attached to
+     * @param {Rect|Rect[]|Polygon|Polygon[]|Line|Line[]|Ellipse|Ellipse[]|Point|Point[]|Bounds|Bounds[]|object} [shapes] - a initial shape, list of shapes, or JSON object defining the body
+     * @param {Function} [onBodyUpdate] - callback for when the body is updated (e.g. add/remove shapes)
      */
     constructor(ancestor, shapes, onBodyUpdate) {
 
@@ -236,7 +236,7 @@ class Body {
     /**
      * add a collision shape to this body <br>
      * (note: me.Rect objects will be converted to me.Polygon before being added)
-     * @param {Rect|Polygon|Line|Ellipse|Point|Point[]|Bounds|object} shape a shape or JSON object
+     * @param {Rect|Polygon|Line|Ellipse|Point|Point[]|Bounds|object} shape - a shape or JSON object
      * @returns {number} the shape array length
      * @example
      * // add a rectangle shape
@@ -292,9 +292,9 @@ class Body {
 
     /**
      * set the body vertices to the given one
-     * @param {Vector2d[]} vertices an array of me.Vector2d points defining a convex hull
-     * @param {number} [index=0] the shape object for which to set the vertices
-     * @param {boolean} [clear=true] either to reset the body definition before adding the new vertices
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
+     * @param {number} [index=0] - the shape object for which to set the vertices
+     * @param {boolean} [clear=true] - either to reset the body definition before adding the new vertices
      */
     setVertices(vertices, index = 0, clear = true) {
         var polygon = this.getShape(index);
@@ -315,8 +315,8 @@ class Body {
 
     /**
      * add the given vertices to the body shape
-     * @param {Vector2d[]} vertices an array of me.Vector2d points defining a convex hull
-     * @param {number} [index=0] the shape object for which to set the vertices
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
+     * @param {number} [index=0] - the shape object for which to set the vertices
      */
     addVertices(vertices, index = 0) {
         this.setVertices(vertices, index, false);
@@ -325,8 +325,8 @@ class Body {
     /**
      * add collision mesh based on a JSON object
      * (this will also apply any physic properties defined in the given JSON file)
-     * @param {object} json a JSON object as exported from a Physics Editor tool
-     * @param {string} [id] an optional shape identifier within the given the json object
+     * @param {object} json - a JSON object as exported from a Physics Editor tool
+     * @param {string} [id] - an optional shape identifier within the given the json object
      * @see https://www.codeandweb.com/physicseditor
      * @returns {number} how many shapes were added to the body
      * @example
@@ -365,7 +365,7 @@ class Body {
 
     /**
      * return the collision shape at the given index
-     * @param {number} [index=0] the shape object at the specified index
+     * @param {number} [index=0] - the shape object at the specified index
      * @returns {Polygon|Line|Ellipse} shape a shape object if defined
      */
     getShape(index) {
@@ -382,7 +382,7 @@ class Body {
 
     /**
      * remove the specified shape from the body shape list
-     * @param {Polygon|Line|Ellipse} shape a shape object
+     * @param {Polygon|Line|Ellipse} shape - a shape object
      * @returns {number} the shape array length
      */
     removeShape(shape) {
@@ -400,7 +400,7 @@ class Body {
 
     /**
      * remove the shape at the given index from the body shape list
-     * @param {number} index the shape object at the specified index
+     * @param {number} index - the shape object at the specified index
      * @returns {number} the shape array length
      */
     removeShapeAt(index) {
@@ -412,7 +412,7 @@ class Body {
      * but it's also possible to specify 'collision filters' to provide a finer <br>
      * control over which body can collide with each other.
      * @see collision.types
-     * @param {number} [bitmask = collision.types.ALL_OBJECT] the collision mask
+     * @param {number} [bitmask = collision.types.ALL_OBJECT] - the collision mask
      * @example
      * // filter collision detection with collision shapes, enemies and collectables
      * body.setCollisionMask(me.collision.types.WORLD_SHAPE | me.collision.types.ENEMY_OBJECT | me.collision.types.COLLECTABLE_OBJECT);
@@ -427,7 +427,7 @@ class Body {
     /**
      * define the collision type of the body for collision filtering
      * @see collision.types
-     * @param {number} type the collision type
+     * @param {number} type - the collision type
      * @example
      * // set the body collision type
      * body.collisionType = me.collision.types.PLAYER_OBJECT;
@@ -444,7 +444,7 @@ class Body {
 
     /**
      * the built-in function to solve the collision response
-     * @param {object} response the collision response object (see {@link ResponseObject})
+     * @param {object} response - the collision response object (see {@link ResponseObject})
      */
     respondToCollision(response) {
         // the overlap vector
@@ -483,8 +483,8 @@ class Body {
      *    - The current element being processed in the array <br>
      *    - The index of element in the array. <br>
      *    - The array forEach() was called upon. <br>
-     * @param {Function} callback fnction to execute on each element
-     * @param {object} [thisArg] value to use as this(i.e reference Object) when executing callback.
+     * @param {Function} callback - fnction to execute on each element
+     * @param {object} [thisArg] - value to use as this(i.e reference Object) when executing callback.
      * @example
      * // iterate through all shapes of the physic body
      * mySprite.body.forEach((shape) => {
@@ -522,8 +522,8 @@ class Body {
      */
     /**
      * Returns true if the any of the shape composing the body contains the given point.
-     * @param  {number} x x coordinate
-     * @param  {number} y y coordinate
+     * @param  {number} x -  x coordinate
+     * @param  {number} y -  y coordinate
      * @returns {boolean} true if contains
      */
     contains() {
@@ -553,8 +553,8 @@ class Body {
     /**
      * Rotate this body (counter-clockwise) by the specified angle (in radians).
      * Unless specified the body will be rotated around its center point
-     * @param {number} angle The angle to rotate (in radians)
-     * @param {Vector2d|ObservableVector2d} [v=Body.getBounds().center] an optional point to rotate around
+     * @param {number} angle - The angle to rotate (in radians)
+     * @param {Vector2d|ObservableVector2d} [v=Body.getBounds().center] - an optional point to rotate around
      * @returns {Body} Reference to this object for method chaining
      */
     rotate(angle, v = this.getBounds().center) {
@@ -577,8 +577,8 @@ class Body {
 
     /**
      * cap the body velocity (body.maxVel property) to the specified value<br>
-     * @param {number} x max velocity on x axis
-     * @param {number} y max velocity on y axis
+     * @param {number} x - max velocity on x axis
+     * @param {number} y - max velocity on y axis
      */
     setMaxVelocity(x, y) {
         this.maxVel.x = x;
@@ -587,8 +587,8 @@ class Body {
 
     /**
      * set the body default friction
-     * @param {number} x horizontal friction
-     * @param {number} y vertical friction
+     * @param {number} x - horizontal friction
+     * @param {number} y - vertical friction
      */
     setFriction(x = 0, y = 0) {
         this.friction.x = x;
@@ -605,7 +605,7 @@ class Body {
      * Updates to Body.vel are bounded by maxVel (which defaults to viewport size if not set) <br>
      * At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the constructor arguments.
      * @protected
-     * @param {number} dt time since the last update in milliseconds.
+     * @param {number} dt - time since the last update in milliseconds.
      * @returns {boolean} true if resulting velocity is different than 0
      */
     update(dt) { // eslint-disable-line no-unused-vars

package/src/physics/bounds.js

@@ -7,7 +7,7 @@ import Vector2d from "./../math/vector2.js";
  */
 class Bounds {
     /**
-     * @param {Vector2d[]} [vertices] an array of me.Vector2d points
+     * @param {Vector2d[]} [vertices] - an array of me.Vector2d points
      */
     constructor(vertices) {
         // @ignore
@@ -203,7 +203,7 @@ class Bounds {
      * Updates bounds using the given vertices
      * @name update
      * @memberof Bounds
-     * @param {Vector2d[]} vertices an array of me.Vector2d points
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points
      */
     update(vertices) {
         this.add(vertices, true);
@@ -213,8 +213,8 @@ class Bounds {
      * add the given vertices to the bounds definition.
      * @name add
      * @memberof Bounds
-     * @param {Vector2d[]} vertices an array of me.Vector2d points
-     * @param {boolean} [clear=false] either to reset the bounds before adding the new vertices
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
      */
     add(vertices, clear = false) {
         if (clear === true) {
@@ -234,7 +234,7 @@ class Bounds {
      * @name addBounds
      * @memberof Bounds
      * @param {Bounds} bounds
-     * @param {boolean} [clear=false] either to reset the bounds before adding the new vertices
+     * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
      */
     addBounds(bounds, clear = false) {
         if (clear === true) {
@@ -254,8 +254,8 @@ class Bounds {
      * add the given point to the bounds definition.
      * @name addPoint
      * @memberof Bounds
-     * @param {Vector2d|Point} point the point to be added to the bounds
-     * @param {Matrix2d} [m] an optional transform to apply to the given point (only if the given point is a vector)
+     * @param {Vector2d|Point} point - the point to be added to the bounds
+     * @param {Matrix2d} [m] - an optional transform to apply to the given point (only if the given point is a vector)
      */
     addPoint(point, m) {
         if ((typeof m !== "undefined") && (typeof point.rotate === "function")) {
@@ -276,7 +276,7 @@ class Bounds {
      * @param {number} y0 - top Y coordinates of the quad
      * @param {number} x1 - right X coordinates of the quad
      * @param {number} y1 - bottom y coordinates of the quad
-     * @param {Matrix2d} [m] an optional transform to apply to the given frame coordinates
+     * @param {Matrix2d} [m] - an optional transform to apply to the given frame coordinates
      */
     addFrame(x0, y0, x1, y1, m) {
         var v = pool.pull("Vector2d");

package/src/physics/collision.js

@@ -96,8 +96,8 @@ var collision = {
      * @name rayCast
      * @memberof collision
      * @public
-     * @param {Line} line line to be tested for collision
-     * @param {Array.<Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
+     * @param {Line} line - line to be tested for collision
+     * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.
      * @returns {Array.<Renderable>} an array of intersecting physic objects
      * @example
      *    // define a line accross the viewport

package/src/physics/detector.js

@@ -28,8 +28,8 @@ let globalResponse = new ResponseObject();
  * @name shouldCollide
  * @memberof collision
  * @ignore
- * @param {Renderable} a a reference to the object A.
- * @param {Renderable} b a reference to the object B.
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Renderable} b - a reference to the object B.
  * @returns {boolean} true if they should collide, false otherwise
  */
 function shouldCollide(a, b) {
@@ -52,8 +52,8 @@ function shouldCollide(a, b) {
  * find all the collisions for the specified object
  * @name collisionCheck
  * @ignore
- * @param {Renderable} objA object to be tested for collision
- * @param {ResponseObject} [response] a user defined response object that will be populated if they intersect.
+ * @param {Renderable} objA - object to be tested for collision
+ * @param {ResponseObject} [response] - a user defined response object that will be populated if they intersect.
  * @returns {boolean} in case of collision, false otherwise
  */
 export function collisionCheck(objA, response = globalResponse) {
@@ -115,8 +115,8 @@ export function collisionCheck(objA, response = globalResponse) {
  * Checks for object colliding with the given line
  * @name rayCast
  * @ignore
- * @param {Line} line line to be tested for collision
- * @param {Array.<Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
+ * @param {Line} line - line to be tested for collision
+ * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.
  * @returns {Array.<Renderable>} an array of intersecting physic objects
  * @example
  *    // define a line accross the viewport

package/src/physics/quadtree.js

@@ -55,11 +55,11 @@ var QT_VECTOR = new Vector2d();
  */
 class QuadTree {
     /**
-     * @param {World} world the physic world this QuadTree belongs to
-     * @param {Bounds} bounds bounds of the node
-     * @param {number} [max_objects=4] max objects a node can hold before splitting into 4 subnodes
-     * @param {number} [max_levels=4] total max levels inside root Quadtree
-     * @param {number} [level] deepth level, required for subnodes
+     * @param {World} world - the physic world this QuadTree belongs to
+     * @param {Bounds} bounds - bounds of the node
+     * @param {number} [max_objects=4] - max objects a node can hold before splitting into 4 subnodes
+     * @param {number} [max_levels=4] - total max levels inside root Quadtree
+     * @param {number} [level] - deepth level, required for subnodes
      */
     constructor(world, bounds, max_objects = 4, max_levels = 4, level = 0) {
 
@@ -194,7 +194,7 @@ class QuadTree {
      * Insert the given object container into the node.
      * @name insertContainer
      * @memberof QuadTree
-     * @param {Container} container group of objects to be added
+     * @param {Container} container - group of objects to be added
      */
     insertContainer(container) {
         for (var i = container.children.length, child; i--, (child = container.children[i]);) {
@@ -222,7 +222,7 @@ class QuadTree {
      * objects to their corresponding subnodes.
      * @name insert
      * @memberof QuadTree
-     * @param {object} item object to be added
+     * @param {object} item - object to be added
      */
     insert(item) {
         var index = -1;
@@ -266,8 +266,8 @@ class QuadTree {
      * Return all objects that could collide with the given object
      * @name retrieve
      * @memberof QuadTree
-     * @param {object} item object to be checked against
-     * @param {object} [fn] a sorting function for the returned array
+     * @param {object} item - object to be checked against
+     * @param {object} [fn] - a sorting function for the returned array
      * @returns {object[]} array with all detected objects
      */
     retrieve(item, fn) {
@@ -301,7 +301,7 @@ class QuadTree {
      * (this function won't recalculate the impacted node)
      * @name remove
      * @memberof QuadTree
-     * @param {object} item object to be removed
+     * @param {object} item - object to be removed
      * @returns {boolean} true if the item was found and removed.
      */
      remove(item) {
@@ -367,7 +367,7 @@ class QuadTree {
      * clear the quadtree
      * @name clear
      * @memberof QuadTree
-     * @param {Bounds} [bounds=this.bounds] the bounds to be cleared
+     * @param {Bounds} [bounds=this.bounds] - the bounds to be cleared
      */
     clear(bounds) {
         this.objects.length = 0;

package/src/physics/sat.js

@@ -46,9 +46,9 @@ for (var a = 0; a < 5; a++) { T_ARRAYS.push([]); }
  * resulting in a one dimensional range of the minimum and
  * maximum value on that axis.
  * @ignore
- * @param {Array.<Vector2d>} points The points to flatten.
- * @param {Vector2d} normal The unit vector axis to flatten on.
- * @param {Array.<number>} result An array.  After calling this function,
+ * @param {Array.<Vector2d>} points - The points to flatten.
+ * @param {Vector2d} normal - The unit vector axis to flatten on.
+ * @param {Array.<number>} result - An array.  After calling this function,
  *   result[0] will be the minimum value,
  *   result[1] will be the maximum value.
  */
@@ -70,13 +70,13 @@ function flattenPointsOn(points, normal, result) {
  * Check whether two convex polygons are separated by the specified
  * axis (must be a unit vector).
  * @ignore
- * @param {Vector2d} aPos The position of the first polygon.
- * @param {Vector2d} bPos The position of the second polygon.
- * @param {Array.<Vector2d>} aPoints The points in the first polygon.
- * @param {Array.<Vector2d>} bPoints The points in the second polygon.
- * @param {Vector2d} axis The axis (unit sized) to test against.  The points of both polygons
+ * @param {Vector2d} aPos - The position of the first polygon.
+ * @param {Vector2d} bPos - The position of the second polygon.
+ * @param {Array.<Vector2d>} aPoints - The points in the first polygon.
+ * @param {Array.<Vector2d>} bPoints - The points in the second polygon.
+ * @param {Vector2d} axis - The axis (unit sized) to test against.  The points of both polygons
  *   will be projected onto this axis.
- * @param {Response=} response A Response object (optional) which will be populated
+ * @param {Response=} response - A Response object (optional) which will be populated
  *   if the axis is not a separating axis.
  * @returns {boolean} true if it is a separating axis, false otherwise.  If false,
  *   and a response is passed in, information about how much overlap and
@@ -161,8 +161,8 @@ function isSeparatingAxis(aPos, bPos, aPoints, bPoints, axis, response) {
  * </pre>
  *
  * @ignore
- * @param {Vector2d} line The line segment.
- * @param {Vector2d} point The point.
+ * @param {Vector2d} line - The line segment.
+ * @param {Vector2d} point - The point.
  * @returns  {number} LEFT_VORNOI_REGION (-1) if it is the left region,
  *          MIDDLE_VORNOI_REGION (0) if it is the middle region,
  *          RIGHT_VORNOI_REGION (1) if it is the right region.
@@ -187,11 +187,11 @@ function vornoiRegion(line, point) {
 /**
  * Checks whether polygons collide.
  * @ignore
- * @param {Renderable} a a reference to the object A.
- * @param {Polygon} polyA a reference to the object A Polygon to be tested
- * @param {Renderable} b a reference to the object B.
- * @param {Polygon} polyB a reference to the object B Polygon to be tested
- * @param {Response=} response Response object (optional) that will be populated if they intersect.
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Polygon} polyA - a reference to the object A Polygon to be tested
+ * @param {Renderable} b - a reference to the object B.
+ * @param {Polygon} polyB - a reference to the object B Polygon to be tested
+ * @param {Response=} response - Response object (optional) that will be populated if they intersect.
  * @returns {boolean} true if they intersect, false if they don't.
  */
 export function testPolygonPolygon(a, polyA, b, polyB, response) {
@@ -241,11 +241,11 @@ export function testPolygonPolygon(a, polyA, b, polyB, response) {
 /**
  * Check if two Ellipse collide.
  * @ignore
- * @param {Renderable} a a reference to the object A.
- * @param {Ellipse} ellipseA a reference to the object A Ellipse to be tested
- * @param {Renderable} b a reference to the object B.
- * @param {Ellipse} ellipseB a reference to the object B Ellipse to be tested
- * @param {Response=} response Response object (optional) that will be populated if
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
+ * @param {Renderable} b - a reference to the object B.
+ * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
+ * @param {Response=} response - Response object (optional) that will be populated if
  *   the circles intersect.
  * @returns {boolean} true if the circles intersect, false if they don't.
  */
@@ -282,11 +282,11 @@ export function testEllipseEllipse(a, ellipseA, b, ellipseB, response) {
 /**
  * Check if a polygon and an ellipse collide.
  * @ignore
- * @param {Renderable} a a reference to the object A.
- * @param {Polygon} polyA a reference to the object A Polygon to be tested
- * @param {Renderable} b a reference to the object B.
- * @param {Ellipse} ellipseB a reference to the object B Ellipse to be tested
- * @param {Response=} response Response object (optional) that will be populated if they intersect.
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Polygon} polyA - a reference to the object A Polygon to be tested
+ * @param {Renderable} b - a reference to the object B.
+ * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
+ * @param {Response=} response - Response object (optional) that will be populated if they intersect.
  * @returns {boolean} true if they intersect, false if they don't.
  */
 export function testPolygonEllipse(a, polyA, b, ellipseB, response) {
@@ -448,11 +448,11 @@ export function testPolygonEllipse(a, polyA, b, ellipseB, response) {
  * **NOTE:** This is slightly less efficient than testPolygonEllipse as it just
  * runs testPolygonEllipse and reverses the response at the end.
  * @ignore
- * @param {Renderable} a a reference to the object A.
- * @param {Ellipse} ellipseA a reference to the object A Ellipse to be tested
- * @param {Renderable} b a reference to the object B.
- * @param {Polygon} polyB a reference to the object B Polygon to be tested
- * @param {Response=} response Response object (optional) that will be populated if
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
+ * @param {Renderable} b - a reference to the object B.
+ * @param {Polygon} polyB - a reference to the object B Polygon to be tested
+ * @param {Response=} response - Response object (optional) that will be populated if
  *   they intersect.
  * @returns {boolean} true if they intersect, false if they don't.
  */

package/src/physics/world.js

@@ -13,10 +13,10 @@ import state from "./../state/state.js";
  */
 class World extends Container {
     /**
-     * @param {number} [x=0] position of the container (accessible via the inherited pos.x property)
-     * @param {number} [y=0] position of the container (accessible via the inherited pos.y property)
-     * @param {number} [width=game.viewport.width] width of the container
-     * @param {number} [height=game.viewport.height] height of the container
+     * @param {number} [x=0] - position of the container (accessible via the inherited pos.x property)
+     * @param {number} [y=0] - position of the container (accessible via the inherited pos.y property)
+     * @param {number} [width=game.viewport.width] - width of the container
+     * @param {number} [height=game.viewport.height] - height of the container
      */
     constructor(x = 0, y = 0, width = Infinity, height = Infinity) {
         // call the super constructor
@@ -169,7 +169,7 @@ class World extends Container {
      * update the game world
      * @name reset
      * @memberof World
-     * @param {number} dt the time passed since the last frame update
+     * @param {number} dt - the time passed since the last frame update
      * @returns {boolean} true if the word is dirty
      */
     update(dt) {

package/src/plugin/plugin.js

@@ -44,9 +44,9 @@ export var plugin = {
      * @name patch
      * @memberof plugin
      * @public
-     * @param {object} proto target object
-     * @param {string} name target function
-     * @param {Function} fn replacement function
+     * @param {object} proto - target object
+     * @param {string} name - target function
+     * @param {Function} fn - replacement function
      * @example
      * // redefine the me.game.update function with a new one
      * me.plugin.patch(me.game, "update", function () {
@@ -89,9 +89,9 @@ export var plugin = {
      * @memberof plugin
      * @see Base
      * @public
-     * @param {plugin.Base} pluginObj Plugin object to instantiate and register
+     * @param {plugin.Base} pluginObj - Plugin object to instantiate and register
      * @param {string} name
-     * @param {object} [...arguments] all extra parameters will be passed to the plugin constructor
+     * @param {object} [...arguments] - all extra parameters will be passed to the plugin constructor
      * @example
      * // register a new plugin
      * me.plugin.register(TestPlugin, "testPlugin");

package/src/renderable/collectable.js

@@ -10,9 +10,9 @@ import pool from "./../system/pooling.js";
  */
 class Collectable extends Sprite {
     /**
-     * @param {number} x the x coordinates of the collectable
-     * @param {number} y the y coordinates of the collectable
-     * @param {object} settings See {@link Sprite}
+     * @param {number} x - the x coordinates of the collectable
+     * @param {number} y - the y coordinates of the collectable
+     * @param {object} settings - See {@link Sprite}
      */
     constructor(x, y, settings) {
 

package/src/renderable/colorlayer.js

@@ -9,9 +9,9 @@ import Renderable from "./renderable.js";
  */
 class ColorLayer extends Renderable {
     /**
-     * @param {string} name Layer name
-     * @param {Color|string} color CSS color
-     * @param {number} [z = 0] z-index position
+     * @param {string} name - Layer name
+     * @param {Color|string} color - CSS color
+     * @param {number} [z = 0] - z-index position
      */
     constructor(name, color, z) {
         // parent constructor
@@ -44,8 +44,8 @@ class ColorLayer extends Renderable {
      * @name draw
      * @memberof ColorLayer
      * @protected
-     * @param {CanvasRenderer|WebGLRenderer} renderer a renderer instance
-     * @param {Camera2d} [viewport] the viewport to (re)draw
+     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
+     * @param {Camera2d} [viewport] - the viewport to (re)draw
      */
     draw(renderer, viewport) {
         renderer.save();