litecanvas 0.207.1 → 0.208.0

package/src/index.js

@@ -15,7 +15,6 @@ export default function litecanvas(settings = {}) {
         math = Math,
         perf = performance,
         TWO_PI = math.PI * 2,
-        loggerPrefix = '[Litecanvas] ',
         raf = requestAnimationFrame,
         isNumber = Number.isFinite,
         /** @type {Function[]} */
@@ -44,6 +43,11 @@ export default function litecanvas(settings = {}) {
             keyboardEvents: true,
         }
 
+    DEV: assert(
+        null == settings || 'object' === typeof settings,
+        'litecanvas() 1st parameter must be a object'
+    )
+
     // setup the settings default values
     settings = Object.assign(defaults, settings)
 
@@ -138,9 +142,9 @@ export default function litecanvas(settings = {}) {
          * @tutorial https://gamedev.net/tutorials/programming/general-and-gameplay-programming/a-brief-introduction-to-lerp-r4954/
          */
         lerp: (start, end, t) => {
-            DEV: assert(isNumber(start), loggerPrefix + 'lerp() 1st param must be a number')
-            DEV: assert(isNumber(end), loggerPrefix + 'lerp() 2nd param must be a number')
-            DEV: assert(isNumber(t), loggerPrefix + 'lerp() 3rd param must be a number')
+            DEV: assert(isNumber(start), 'lerp() 1st parameter must be a number')
+            DEV: assert(isNumber(end), 'lerp() 2nd parameter must be a number')
+            DEV: assert(isNumber(t), 'lerp() 3rd parameter must be a number')
 
             return start + t * (end - start)
         },
@@ -152,7 +156,7 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the value in radians
          */
         deg2rad: (degs) => {
-            DEV: assert(isNumber(degs), 'deg2rad() 1st param must be a number')
+            DEV: assert(isNumber(degs), 'deg2rad() 1st parameter must be a number')
 
             return (math.PI / 180) * degs
         },
@@ -164,11 +168,30 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the value in degrees
          */
         rad2deg: (rads) => {
-            DEV: assert(isNumber(rads), 'rad2deg() 1st param must be a number')
+            DEV: assert(isNumber(rads), 'rad2deg() 1st parameter must be a number')
 
             return (180 / math.PI) * rads
         },
 
+        /**
+         * Modulus (Euclidean division).
+         *
+         * Note: When `b == 0` returns `0`, rather than `NaN`.
+         *
+         * @param {number} a dividend
+         * @param {number} b divisor
+         * @returns {number} the remainder
+         * @example
+         *      mod(-1, 5) // => 4
+         *      -1 % 5 // => -1
+         */
+        mod(a, b) {
+            DEV: assert(isNumber(a), 'mod() 1st parameter must be a number')
+            DEV: assert(isNumber(b) && b >= 0, 'mod() 2nd parameter must be a non-negative number')
+
+            return ((a % b) + b) % b || 0
+        },
+
         /**
          * Returns the rounded value of an number to optional precision (number of digits after the decimal point).
          *
@@ -179,10 +202,10 @@ export default function litecanvas(settings = {}) {
          * @returns {number} rounded number.
          */
         round: (n, precision = 0) => {
-            DEV: assert(isNumber(n), loggerPrefix + 'round() 1st param must be a number')
+            DEV: assert(isNumber(n), 'round() 1st parameter must be a number')
             DEV: assert(
                 isNumber(precision) && precision >= 0,
-                loggerPrefix + 'round() 2nd param must be a positive number or zero'
+                'round() 2nd parameter must be a non-negative number'
             )
 
             if (!precision) {
@@ -201,13 +224,10 @@ export default function litecanvas(settings = {}) {
          * @returns {number}
          */
         clamp: (value, min, max) => {
-            DEV: assert(isNumber(value), loggerPrefix + 'clamp() 1st param must be a number')
-            DEV: assert(isNumber(min), loggerPrefix + 'clamp() 2nd param must be a number')
-            DEV: assert(isNumber(max), loggerPrefix + 'clamp() 3rd param must be a number')
-            DEV: assert(
-                max >= min,
-                loggerPrefix + 'clamp() the 2nd param must be less than the 3rd param'
-            )
+            DEV: assert(isNumber(value), 'clamp() 1st parameter must be a number')
+            DEV: assert(isNumber(min), 'clamp() 2nd parameter must be a number')
+            DEV: assert(isNumber(max), 'clamp() 3rd parameter must be a number')
+            DEV: assert(max >= min, 'clamp() the 2nd parameter must be less than the 3rd parameter')
 
             if (value < min) return min
             if (value > max) return max
@@ -224,10 +244,10 @@ export default function litecanvas(settings = {}) {
          * @returns {number}
          */
         dist: (x1, y1, x2, y2) => {
-            DEV: assert(isNumber(x1), loggerPrefix + 'dist() 1st param must be a number')
-            DEV: assert(isNumber(y1), loggerPrefix + 'dist() 2nd param must be a number')
-            DEV: assert(isNumber(x2), loggerPrefix + 'dist() 3rd param must be a number')
-            DEV: assert(isNumber(y2), loggerPrefix + 'dist() 4th param must be a number')
+            DEV: assert(isNumber(x1), 'dist() 1st parameter must be a number')
+            DEV: assert(isNumber(y1), 'dist() 2nd parameter must be a number')
+            DEV: assert(isNumber(x2), 'dist() 3rd parameter must be a number')
+            DEV: assert(isNumber(y2), 'dist() 4th parameter must be a number')
 
             return math.hypot(x2 - x1, y2 - y1)
         },
@@ -241,13 +261,10 @@ export default function litecanvas(settings = {}) {
          * @returns {number}
          */
         wrap: (value, min, max) => {
-            DEV: assert(isNumber(value), loggerPrefix + 'wrap() 1st param must be a number')
-            DEV: assert(isNumber(min), loggerPrefix + 'wrap() 2nd param must be a number')
-            DEV: assert(isNumber(max), loggerPrefix + 'wrap() 3rd param must be a number')
-            DEV: assert(
-                max > min,
-                loggerPrefix + 'wrap() the 2nd param must be less than the 3rd param'
-            )
+            DEV: assert(isNumber(value), 'wrap() 1st parameter must be a number')
+            DEV: assert(isNumber(min), 'wrap() 2nd parameter must be a number')
+            DEV: assert(isNumber(max), 'wrap() 3rd parameter must be a number')
+            DEV: assert(max > min, 'wrap() the 2nd parameter must be less than the 3rd parameter')
 
             return value - (max - min) * math.floor((value - min) / (max - min))
         },
@@ -264,14 +281,14 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the remapped number
          */
         map(value, start1, stop1, start2, stop2, withinBounds) {
-            DEV: assert(isNumber(value), loggerPrefix + 'map() 1st param must be a number')
-            DEV: assert(isNumber(start1), loggerPrefix + 'map() 2nd param must be a number')
-            DEV: assert(isNumber(stop1), loggerPrefix + 'map() 3rd param must be a number')
-            DEV: assert(isNumber(start2), loggerPrefix + 'map() 4th param must be a number')
-            DEV: assert(isNumber(stop2), loggerPrefix + 'map() 5th param must be a number')
+            DEV: assert(isNumber(value), 'map() 1st parameter must be a number')
+            DEV: assert(isNumber(start1), 'map() 2nd parameter must be a number')
+            DEV: assert(isNumber(stop1), 'map() 3rd parameter must be a number')
+            DEV: assert(isNumber(start2), 'map() 4th parameter must be a number')
+            DEV: assert(isNumber(stop2), 'map() 5th parameter must be a number')
             DEV: assert(
                 stop1 !== start1,
-                loggerPrefix + 'map() the 2nd param must be different than the 3rd param'
+                'map() the 2nd parameter must be different than the 3rd parameter'
             )
 
             // prettier-ignore
@@ -290,12 +307,12 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the normalized number.
          */
         norm: (value, start, stop) => {
-            DEV: assert(isNumber(value), loggerPrefix + 'norm() 1st param must be a number')
-            DEV: assert(isNumber(start), loggerPrefix + 'norm() 2nd param must be a number')
-            DEV: assert(isNumber(stop), loggerPrefix + 'norm() 3rd param must be a number')
+            DEV: assert(isNumber(value), 'norm() 1st parameter must be a number')
+            DEV: assert(isNumber(start), 'norm() 2nd parameter must be a number')
+            DEV: assert(isNumber(stop), 'norm() 3rd parameter must be a number')
             DEV: assert(
                 start !== stop,
-                loggerPrefix + 'norm() the 2nd param must be different than the 3rd param'
+                'norm() the 2nd parameter must be different than the 3rd parameter'
             )
 
             return instance.map(value, start, stop, 0, 1)
@@ -311,12 +328,9 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the random number
          */
         rand: (min = 0.0, max = 1.0) => {
-            DEV: assert(isNumber(min), loggerPrefix + 'rand() 1st param must be a number')
-            DEV: assert(isNumber(max), loggerPrefix + 'rand() 2nd param must be a number')
-            DEV: assert(
-                max >= min,
-                loggerPrefix + 'rand() the 1st param must be less than the 2nd param'
-            )
+            DEV: assert(isNumber(min), 'rand() 1st parameter must be a number')
+            DEV: assert(isNumber(max), 'rand() 2nd parameter must be a number')
+            DEV: assert(max >= min, 'rand() the 1st parameter must be less than the 2nd parameter')
 
             const a = 1664525
             const c = 1013904223
@@ -335,12 +349,9 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the random number
          */
         randi: (min = 0, max = 1) => {
-            DEV: assert(isNumber(min), loggerPrefix + 'randi() 1st param must be a number')
-            DEV: assert(isNumber(max), loggerPrefix + 'randi() 2nd param must be a number')
-            DEV: assert(
-                max >= min,
-                loggerPrefix + 'randi() the 1st param must be less than the 2nd param'
-            )
+            DEV: assert(isNumber(min), 'randi() 1st parameter must be a number')
+            DEV: assert(isNumber(max), 'randi() 2nd parameter must be a number')
+            DEV: assert(max >= min, 'randi() the 1st parameter must be less than the 2nd parameter')
 
             return ~~instance.rand(min, max + 1)
         },
@@ -355,7 +366,7 @@ export default function litecanvas(settings = {}) {
         rseed(value) {
             DEV: assert(
                 isNumber(value) && value >= 0,
-                loggerPrefix + 'rseed() 1st param must be a positive integer or zero'
+                'rseed() 1st parameter must be a non-negative integer'
             )
 
             _rngSeed = ~~value
@@ -363,14 +374,14 @@ export default function litecanvas(settings = {}) {
 
         /** BASIC GRAPHICS API */
         /**
-         * Clear the game screen with an optional color
+         * Clear the game screen with an optional color.
          *
          * @param {number} [color] The background color (index) or null/undefined (for transparent)
          */
         cls(color) {
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'cls() 1st param must be a positive number or zero or undefined'
+                'cls() 1st parameter must be a non-negative number'
             )
 
             if (null == color) {
@@ -393,26 +404,27 @@ export default function litecanvas(settings = {}) {
          * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/roundRect
          */
         rect(x, y, width, height, color, radii) {
-            DEV: assert(isNumber(x), loggerPrefix + 'rect() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'rect() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'rect() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'rect() 2nd parameter must be a number')
             DEV: assert(
                 isNumber(width) && width > 0,
-                loggerPrefix + 'rect() 3rd param must be a positive number'
+                'rect() 3rd parameter must be a positive number'
             )
             DEV: assert(
                 isNumber(height) && height >= 0,
-                loggerPrefix + 'rect() 4th param must be a positive number or zero'
+                'rect() 4th parameter must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'rect() 5th param must be a positive number or zero'
+                'rect() 5th parameter must be a non-negative number'
             )
             DEV: assert(
                 null == radii || isNumber(radii) || (Array.isArray(radii) && radii.length >= 1),
-                loggerPrefix + 'rect() 6th param must be a number or array of numbers'
+                'rect() 6th parameter must be a number or array of numbers'
             )
 
             beginPath(_ctx)
+
             _ctx[radii ? 'roundRect' : 'rect'](
                 ~~x - _outline_fix,
                 ~~y - _outline_fix,
@@ -434,27 +446,28 @@ export default function litecanvas(settings = {}) {
          * @param {number|number[]} [radii] A number or list specifying the radii used to draw a rounded-borders rectangle
          */
         rectfill(x, y, width, height, color, radii) {
-            DEV: assert(isNumber(x), loggerPrefix + 'rectfill() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'rectfill() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'rectfill() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'rectfill() 2nd parameter must be a number')
             DEV: assert(
                 isNumber(width) && width >= 0,
-                loggerPrefix + 'rectfill() 3rd param must be a positive number or zero'
+                'rectfill() 3rd parameter must be a non-negative number'
             )
             DEV: assert(
                 isNumber(height) && height >= 0,
-                loggerPrefix + 'rectfill() 4th param must be a positive number or zero'
+                'rectfill() 4th parameter must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'rectfill() 5th param must be a positive number or zero'
+                'rectfill() 5th parameter must be a non-negative number'
             )
             DEV: assert(
                 null == radii || isNumber(radii) || (Array.isArray(radii) && radii.length >= 1),
-                loggerPrefix +
-                    'rectfill() 6th param must be a number or array of at least 2 numbers'
+
+                'rectfill() 6th parameter must be a number or array of at least 2 numbers'
             )
 
             beginPath(_ctx)
+
             _ctx[radii ? 'roundRect' : 'rect'](~~x, ~~y, ~~width, ~~height, radii)
             instance.fill(color)
         },
@@ -469,22 +482,23 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         oval(x, y, radiusX, radiusY, color) {
-            DEV: assert(isNumber(x), loggerPrefix + 'oval() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'oval() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'oval() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'oval() 2nd parameter must be a number')
             DEV: assert(
                 isNumber(radiusX) && radiusX >= 0,
-                loggerPrefix + 'oval() 3rd param must be a positive number or zero'
+                'oval() 3rd parameter must be a non-negative number'
             )
             DEV: assert(
                 isNumber(radiusY) && radiusY >= 0,
-                loggerPrefix + 'oval() 4th param must be a positive number or zero'
+                'oval() 4th parameter must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'oval() 5th param must be a positive number or zero'
+                'oval() 5th parameter must be a non-negative number'
             )
 
             beginPath(_ctx)
+
             _ctx.ellipse(~~x, ~~y, ~~radiusX, ~~radiusY, 0, 0, TWO_PI)
             instance.stroke(color)
         },
@@ -499,22 +513,23 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         ovalfill(x, y, radiusX, radiusY, color) {
-            DEV: assert(isNumber(x), loggerPrefix + 'ovalfill() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'ovalfill() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'ovalfill() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'ovalfill() 2nd parameter must be a number')
             DEV: assert(
                 isNumber(radiusX) && radiusX >= 0,
-                loggerPrefix + 'ovalfill() 3rd param must be a positive number or zero'
+                'ovalfill() 3rd parameter must be a non-negative number'
             )
             DEV: assert(
                 isNumber(radiusY) && radiusY >= 0,
-                loggerPrefix + 'ovalfill() 4th param must be a positive number or zero'
+                'ovalfill() 4th parameter must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'ovalfill() 5th param must be a positive number or zero'
+                'ovalfill() 5th parameter must be a non-negative number'
             )
 
             beginPath(_ctx)
+
             _ctx.ellipse(~~x, ~~y, ~~radiusX, ~~radiusY, 0, 0, TWO_PI)
             instance.fill(color)
         },
@@ -528,15 +543,15 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         circ(x, y, radius, color) {
-            DEV: assert(isNumber(x), loggerPrefix + 'circ() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'circ() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'circ() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'circ() 2nd parameter must be a number')
             DEV: assert(
                 isNumber(radius) && radius >= 0,
-                loggerPrefix + 'circ() 3rd param must be a positive number or zero'
+                'circ() 3rd parameter must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'circ() 4th param must be a positive number or zero'
+                'circ() 4th parameter must be a non-negative number'
             )
 
             instance.oval(x, y, radius, radius, color)
@@ -551,15 +566,15 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         circfill(x, y, radius, color) {
-            DEV: assert(isNumber(x), loggerPrefix + 'circfill() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'circfill() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'circfill() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'circfill() 2nd parameter must be a number')
             DEV: assert(
                 isNumber(radius) && radius >= 0,
-                loggerPrefix + 'circfill() 3rd param must be a positive number or zero'
+                'circfill() 3rd parameter must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'circfill() 4th param must be a positive number or zero'
+                'circfill() 4th parameter must be a non-negative number'
             )
 
             instance.ovalfill(x, y, radius, radius, color)
@@ -572,21 +587,19 @@ export default function litecanvas(settings = {}) {
          * @param {number[]} points an array of Xs and Ys coordinates
          */
         shape(points) {
-            DEV: assert(
-                Array.isArray(points),
-                loggerPrefix + 'shape() 1st param must be an array of numbers'
-            )
+            DEV: assert(Array.isArray(points), 'shape() 1st parameter must be an array of numbers')
             DEV: assert(
                 points.length >= 6,
-                loggerPrefix +
-                    'shape() 1st param must be an array with at least 6 numbers (3 points)'
+                'shape() 1st parameter must be an array with at least 6 numbers (3 points)'
             )
+
             beginPath(_ctx)
+
             for (let i = 0; i < points.length; i += 2) {
-                if (0 === i) {
-                    _ctx.moveTo(~~points[i], ~~points[i + 1])
-                } else {
+                if (i) {
                     _ctx.lineTo(~~points[i], ~~points[i + 1])
+                } else {
+                    _ctx.moveTo(~~points[i], ~~points[i + 1])
                 }
             }
             _ctx.lineTo(~~points[0], ~~points[1])
@@ -602,25 +615,19 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         line(x1, y1, x2, y2, color) {
-            DEV: assert(isNumber(x1), loggerPrefix + 'line() 1st param must be a number')
-            DEV: assert(isNumber(y1), loggerPrefix + 'line() 2nd param must be a number')
-            DEV: assert(
-                isNumber(x2),
-                loggerPrefix + 'line() 3rd param must be a positive number or zero'
-            )
-            DEV: assert(
-                isNumber(y2),
-                loggerPrefix + 'line() 4th param must be a positive number or zero'
-            )
+            DEV: assert(isNumber(x1), 'line() 1st parameter must be a number')
+            DEV: assert(isNumber(y1), 'line() 2nd parameter must be a number')
+            DEV: assert(isNumber(x2), 'line() 3rd parameter must be a non-negative number')
+            DEV: assert(isNumber(y2), 'line() 4th parameter must be a non-negative number')
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'line() 5th param must be a positive number or zero'
+                'line() 5th parameter must be a non-negative number'
             )
 
             beginPath(_ctx)
 
-            let xfix = _outline_fix !== 0 && ~~x1 === ~~x2 ? 0.5 : 0
-            let yfix = _outline_fix !== 0 && ~~y1 === ~~y2 ? 0.5 : 0
+            let xfix = _outline_fix && ~~x1 === ~~x2 ? 0.5 : 0
+            let yfix = _outline_fix && ~~y1 === ~~y2 ? 0.5 : 0
 
             _ctx.moveTo(~~x1 + xfix, ~~y1 + yfix)
             _ctx.lineTo(~~x2 + xfix, ~~y2 + yfix)
@@ -637,11 +644,11 @@ export default function litecanvas(settings = {}) {
         linewidth(value) {
             DEV: assert(
                 isNumber(value) && value >= 0,
-                loggerPrefix + 'linewidth() 1st param must be a positive number or zero'
+                'linewidth() 1st parameter must be a non-negative integer'
             )
 
             _ctx.lineWidth = ~~value
-            _outline_fix = 0 === ~~value % 2 ? 0 : 0.5
+            _outline_fix = ~~value % 2 ? 0.5 : 0
         },
 
         /**
@@ -655,9 +662,9 @@ export default function litecanvas(settings = {}) {
         linedash(segments, offset = 0) {
             DEV: assert(
                 Array.isArray(segments) && segments.length > 0,
-                loggerPrefix + 'linedash() 1st param must be an array of numbers'
+                'linedash() 1st parameter must be an array of numbers'
             )
-            DEV: assert(isNumber(offset), loggerPrefix + 'linedash() 2nd param must be a number')
+            DEV: assert(isNumber(offset), 'linedash() 2nd parameter must be a number')
 
             _ctx.setLineDash(segments)
             _ctx.lineDashOffset = offset
@@ -674,16 +681,13 @@ export default function litecanvas(settings = {}) {
          * @param {string} [fontStyle] can be "normal" (default), "italic" and/or "bold".
          */
         text(x, y, message, color = _defaultTextColor, fontStyle = 'normal') {
-            DEV: assert(isNumber(x), loggerPrefix + 'text() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'text() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'text() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'text() 2nd parameter must be a number')
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'text() 4th param must be a positive number or zero'
-            )
-            DEV: assert(
-                'string' === typeof fontStyle,
-                loggerPrefix + 'text() 5th param must be a string'
+                'text() 4th parameter must be a non-negative number'
             )
+            DEV: assert('string' === typeof fontStyle, 'text() 5th parameter must be a string')
 
             _ctx.font = `${fontStyle} ${_fontSize}px ${_fontFamily}`
             _ctx.fillStyle = getColor(color)
@@ -702,7 +706,7 @@ export default function litecanvas(settings = {}) {
          * @param {number} value
          */
         textgap(value) {
-            DEV: assert(isNumber(value), loggerPrefix + 'textgap() 1st param must be a number')
+            DEV: assert(isNumber(value), 'textgap() 1st parameter must be a number')
 
             _fontLineHeight = value
         },
@@ -713,10 +717,7 @@ export default function litecanvas(settings = {}) {
          * @param {string} family
          */
         textfont(family) {
-            DEV: assert(
-                'string' === typeof family,
-                loggerPrefix + 'textfont() 1st param must be a string'
-            )
+            DEV: assert('string' === typeof family, 'textfont() 1st parameter must be a string')
 
             _fontFamily = family
         },
@@ -727,7 +728,7 @@ export default function litecanvas(settings = {}) {
          * @param {number} size
          */
         textsize(size) {
-            DEV: assert(isNumber(size), loggerPrefix + 'textsize() 1st param must be a number')
+            DEV: assert(isNumber(size), 'textsize() 1st parameter must be a number')
 
             _fontSize = size
         },
@@ -743,16 +744,16 @@ export default function litecanvas(settings = {}) {
         textalign(align, baseline) {
             DEV: assert(
                 null == align || ['left', 'right', 'center', 'start', 'end'].includes(align),
-                loggerPrefix +
-                    'textalign() 1st param must be null or one of the following strings: center, left, right, start or end.'
+
+                'textalign() 1st parameter must be null or one of the following strings: center, left, right, start or end.'
             )
             DEV: assert(
                 null == baseline ||
                     ['top', 'bottom', 'middle', 'hanging', 'alphabetic', 'ideographic'].includes(
                         baseline
                     ),
-                loggerPrefix +
-                    'textalign() 2nd param must be null or one of the following strings: middle, top, bottom, hanging, alphabetic or ideographic.'
+
+                'textalign() 2nd parameter must be null or one of the following strings: middle, top, bottom, hanging, alphabetic or ideographic.'
             )
 
             if (align) _ctx.textAlign = align
@@ -768,8 +769,8 @@ export default function litecanvas(settings = {}) {
          * @param {CanvasImageSource} source
          */
         image(x, y, source) {
-            DEV: assert(isNumber(x), loggerPrefix + 'image() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'image() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'image() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'image() 2nd parameter must be a number')
 
             _ctx.drawImage(source, ~~x, ~~y)
         },
@@ -782,12 +783,9 @@ export default function litecanvas(settings = {}) {
          * @param {string} pixels
          */
         spr(x, y, pixels) {
-            DEV: assert(isNumber(x), loggerPrefix + 'spr() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'spr() 2nd param must be a number')
-            DEV: assert(
-                'string' === typeof pixels,
-                loggerPrefix + 'spr() 3rd param must be a string'
-            )
+            DEV: assert(isNumber(x), 'spr() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'spr() 2nd parameter must be a number')
+            DEV: assert('string' === typeof pixels, 'spr() 3rd parameter must be a string')
 
             const rows = pixels.trim().split('\n')
 
@@ -817,24 +815,21 @@ export default function litecanvas(settings = {}) {
         paint(width, height, callback, options = {}) {
             DEV: assert(
                 isNumber(width) && width >= 1,
-                loggerPrefix + 'paint() 1st param must be a positive number'
+                'paint() 1st parameter must be a positive number'
             )
             DEV: assert(
                 isNumber(height) && height >= 1,
-                loggerPrefix + 'paint() 2nd param must be a positive number'
-            )
-            DEV: assert(
-                'function' === typeof callback,
-                loggerPrefix + 'paint() 3rd param must be a function'
+                'paint() 2nd parameter must be a positive number'
             )
+            DEV: assert('function' === typeof callback, 'paint() 3rd parameter must be a function')
             DEV: assert(
                 (options && null == options.scale) ||
                     (isNumber(options.scale) && options.scale > 0),
-                loggerPrefix + 'paint() 4th param (options.scale) must be a positive number'
+                'paint() 4th parameter (options.scale) must be a positive number'
             )
             DEV: assert(
                 (options && null == options.canvas) || options.canvas instanceof OffscreenCanvas,
-                loggerPrefix + 'paint() 4th param (options.canvas) must be an OffscreenCanvas'
+                'paint() 4th parameter (options.canvas) must be an OffscreenCanvas'
             )
 
             const /** @type {OffscreenCanvas} */
@@ -867,22 +862,38 @@ export default function litecanvas(settings = {}) {
                 null == context ||
                     context instanceof CanvasRenderingContext2D ||
                     context instanceof OffscreenCanvasRenderingContext2D,
-                loggerPrefix + 'ctx() 1st param must be an [Offscreen]CanvasRenderingContext2D'
+                'ctx() 1st parameter must be an [Offscreen]CanvasRenderingContext2D'
             )
 
             if (context) {
                 _ctx = context
             }
+
             return _ctx
         },
 
         /**
-         * saves the current drawing style settings and transformations
+         * Saves the current drawing style settings and, optionally, transforms (translate/rotate/scale) the canvas.
+         *
+         * @param {number} [translateX]
+         * @param {number} [translateY]
+         * @param {number} [rotation] in radians
+         * @param {number} [scaleX]
+         * @param {number} [scaleY]
          *
          * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/save
          */
-        push() {
+        push(translateX = 0, translateY = translateX, rotation = 0, scaleX = 1, scaleY = scaleX) {
+            DEV: assert(isNumber(translateX), 'push() 1st parameter must be a number')
+            DEV: assert(isNumber(translateY), 'push() 2nd parameter must be a number')
+            DEV: assert(isNumber(rotation), 'push() 3rd parameter must be a number')
+            DEV: assert(isNumber(scaleX), 'push() 4th parameter must be a number')
+            DEV: assert(isNumber(scaleY), 'push() 5th parameter must be a number')
+
             _ctx.save()
+            instance.translate(translateX, translateY)
+            instance.rotate(rotation)
+            instance.scale(scaleX, scaleY)
         },
 
         /**
@@ -901,8 +912,8 @@ export default function litecanvas(settings = {}) {
          * @param {number} y
          */
         translate(x, y) {
-            DEV: assert(isNumber(x), loggerPrefix + 'translate() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'translate() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'translate() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'translate() 2nd parameter must be a number')
 
             _ctx.translate(~~x, ~~y)
         },
@@ -914,8 +925,8 @@ export default function litecanvas(settings = {}) {
          * @param {number} [y]
          */
         scale(x, y = x) {
-            DEV: assert(isNumber(x), loggerPrefix + 'scale() 1st param must be a number')
-            DEV: assert(isNumber(y), loggerPrefix + 'scale() 2nd param must be a number')
+            DEV: assert(isNumber(x), 'scale() 1st parameter must be a number')
+            DEV: assert(isNumber(y), 'scale() 2nd parameter must be a number')
 
             _ctx.scale(x, y)
         },
@@ -926,7 +937,7 @@ export default function litecanvas(settings = {}) {
          * @param {number} radians
          */
         rotate(radians) {
-            DEV: assert(isNumber(radians), loggerPrefix + 'rotate() 1st param must be a number')
+            DEV: assert(isNumber(radians), 'rotate() 1st parameter must be a number')
 
             _ctx.rotate(radians)
         },
@@ -938,7 +949,7 @@ export default function litecanvas(settings = {}) {
          * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalAlpha
          */
         alpha(value) {
-            DEV: assert(isNumber(value), loggerPrefix + 'alpha() 1st param must be a number')
+            DEV: assert(isNumber(value), 'alpha() 1st parameter must be a number')
 
             _ctx.globalAlpha = instance.clamp(value, 0, 1)
         },
@@ -951,7 +962,7 @@ export default function litecanvas(settings = {}) {
         fill(color) {
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'fill() 1st param must be a positive number or zero'
+                'fill() 1st parameter must be a non-negative number'
             )
 
             _ctx.fillStyle = getColor(color)
@@ -966,7 +977,7 @@ export default function litecanvas(settings = {}) {
         stroke(color) {
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                loggerPrefix + 'stroke() 1st param must be a positive number or zero'
+                'stroke() 1st parameter must be a non-negative number'
             )
 
             _ctx.strokeStyle = getColor(color)
@@ -982,7 +993,7 @@ export default function litecanvas(settings = {}) {
         clip(callback) {
             DEV: assert(
                 'function' === typeof callback,
-                loggerPrefix + 'clip() 1st param must be a function (ctx) => void'
+                'clip() 1st parameter must be a function (ctx) => void'
             )
 
             beginPath(_ctx)
@@ -995,7 +1006,7 @@ export default function litecanvas(settings = {}) {
          * Play a sound effects using ZzFX library.
          * If the first argument is omitted, plays an default sound.
          *
-         * @param {number[]} [zzfxParams] a ZzFX array of params
+         * @param {number[]} [zzfxParams] a ZzFX array of parameters
          * @param {number} [pitchSlide] a value to increment/decrement the pitch
          * @param {number} [volumeFactor] the volume factor
          * @returns {number[] | boolean} The sound that was played or `false`
@@ -1005,15 +1016,15 @@ export default function litecanvas(settings = {}) {
         sfx(zzfxParams, pitchSlide, volumeFactor) {
             DEV: assert(
                 null == zzfxParams || Array.isArray(zzfxParams),
-                loggerPrefix + 'sfx() 1st param must be an array'
+                'sfx() 1st parameter must be an array'
             )
             DEV: assert(
                 null == pitchSlide || isNumber(pitchSlide),
-                loggerPrefix + 'sfx() 2nd param must be a number'
+                'sfx() 2nd parameter must be a number'
             )
             DEV: assert(
                 null == volumeFactor || isNumber(volumeFactor),
-                loggerPrefix + 'sfx() 3rd param must be a number'
+                'sfx() 3rd parameter must be a number'
             )
 
             if (
@@ -1030,7 +1041,6 @@ export default function litecanvas(settings = {}) {
                 zzfxParams = zzfxParams.slice()
                 zzfxParams[0] = volumeFactor * (zzfxParams[0] || 1)
                 zzfxParams[10] = ~~zzfxParams[10] + pitchSlide
-                console.log(zzfxParams)
             }
 
             zzfx.apply(0, zzfxParams)
@@ -1047,7 +1057,7 @@ export default function litecanvas(settings = {}) {
         volume(value) {
             DEV: assert(
                 isNumber(value) && value >= 0,
-                loggerPrefix + 'volume() 1st param must be a positive number or zero'
+                'volume() 1st parameter must be a non-negative number'
             )
 
             root.zzfxV = value
@@ -1070,12 +1080,9 @@ export default function litecanvas(settings = {}) {
         use(callback, config = {}) {
             DEV: assert(
                 'function' === typeof callback,
-                loggerPrefix + 'use() 1st param must be a function (instance, config) => any'
-            )
-            DEV: assert(
-                'object' === typeof config,
-                loggerPrefix + 'use() 2nd param must be an object'
+                'use() 1st parameter must be a function (instance, config) => any'
             )
+            DEV: assert('object' === typeof config, 'use() 2nd parameter must be an object')
 
             loadPlugin(callback, config)
         },
@@ -1087,14 +1094,8 @@ export default function litecanvas(settings = {}) {
          * @param {Function} callback the function that is called when the event occurs
          */
         listen: (eventName, callback) => {
-            DEV: assert(
-                'string' === typeof eventName,
-                loggerPrefix + 'listen() 1st param must be a string'
-            )
-            DEV: assert(
-                'function' === typeof callback,
-                loggerPrefix + 'listen() 2nd param must be a function'
-            )
+            DEV: assert('string' === typeof eventName, 'listen() 1st parameter must be a string')
+            DEV: assert('function' === typeof callback, 'listen() 2nd parameter must be a function')
 
             eventName = lowerCase(eventName)
 
@@ -1109,13 +1110,10 @@ export default function litecanvas(settings = {}) {
          * @param {Function} callback the function that is called when the event occurs
          */
         unlisten: (eventName, callback) => {
-            DEV: assert(
-                'string' === typeof eventName,
-                loggerPrefix + 'unlisten() 1st param must be a string'
-            )
+            DEV: assert('string' === typeof eventName, 'unlisten() 1st parameter must be a string')
             DEV: assert(
                 'function' === typeof callback,
-                loggerPrefix + 'unlisten() 2nd param must be a function'
+                'unlisten() 2nd parameter must be a function'
             )
 
             eventName = lowerCase(eventName)
@@ -1140,10 +1138,7 @@ export default function litecanvas(settings = {}) {
          * @returns {any} always returns the second argument
          */
         emit(eventName, arg1, arg2, arg3, arg4) {
-            DEV: assert(
-                'string' === typeof eventName,
-                loggerPrefix + 'emit() 1st param must be a string'
-            )
+            DEV: assert('string' === typeof eventName, 'emit() 1st parameter must be a string')
 
             if (_initialized) {
                 eventName = lowerCase(eventName)
@@ -1178,11 +1173,11 @@ export default function litecanvas(settings = {}) {
         pal(colors, textColor = 3) {
             DEV: assert(
                 null == colors || (Array.isArray(colors) && colors.length > 0),
-                loggerPrefix + 'pal() 1st param must be a array of color strings'
+                'pal() 1st parameter must be null or an array of colors'
             )
             DEV: assert(
                 isNumber(textColor) && textColor >= 0,
-                loggerPrefix + 'pal() 2nd param must be a positive number or zero'
+                'pal() 2nd parameter must be a non-negative number'
             )
 
             _colorPalette = colors || defaultPalette
@@ -1205,14 +1200,14 @@ export default function litecanvas(settings = {}) {
         palc(a, b) {
             DEV: assert(
                 null == a || (isNumber(a) && a >= 0),
-                loggerPrefix + 'palc() 1st param must be a positive number'
+                'palc() 1st parameter must be a positive number'
             )
             DEV: assert(
                 isNumber(a) ? isNumber(b) && b >= 0 : null == b,
-                loggerPrefix + 'palc() 2nd param must be a positive number'
+                'palc() 2nd parameter must be a positive number'
             )
 
-            if (a == null) {
+            if (null == a) {
                 _colorPaletteState = []
             } else {
                 _colorPaletteState[a] = b
@@ -1231,11 +1226,10 @@ export default function litecanvas(settings = {}) {
          * @param {any} value the property value
          */
         def(key, value) {
-            DEV: assert('string' === typeof key, loggerPrefix + 'def() 1st param must be a string')
+            DEV: assert('string' === typeof key, 'def() 1st parameter must be a string')
             DEV: if (null == value) {
                 console.warn(
-                    loggerPrefix +
-                        `def() changed the key "${key}" to null (previous value was ${instance[key]})`
+                    `[litecanvas] def() changed the key "${key}" to null (previous value was ${instance[key]})`
                 )
             }
 
@@ -1255,7 +1249,7 @@ export default function litecanvas(settings = {}) {
         timescale(value) {
             DEV: assert(
                 isNumber(value) && value >= 0,
-                loggerPrefix + 'timescale() 1st param must be a positive number or zero'
+                'timescale() 1st parameter must be a non-negative number'
             )
 
             _timeScale = value
@@ -1269,7 +1263,7 @@ export default function litecanvas(settings = {}) {
         framerate(value) {
             DEV: assert(
                 isNumber(value) && value >= 1,
-                loggerPrefix + 'framerate() 1st param must be a positive number'
+                'framerate() 1st parameter must be a positive number'
             )
 
             _fpsInterval = 1000 / ~~value
@@ -1282,7 +1276,7 @@ export default function litecanvas(settings = {}) {
          * @returns {any}
          */
         stat(index) {
-            DEV: assert(isNumber(index), loggerPrefix + 'stat() 1st param must be a number')
+            DEV: assert(isNumber(index), 'stat() 1st parameter must be a number')
 
             const internals = [
                 // 0
@@ -1330,9 +1324,8 @@ export default function litecanvas(settings = {}) {
 
             DEV: assert(
                 index >= 0 && index < internals.length,
-                loggerPrefix +
-                    'stat() 1st param must be a number between 0 and ' +
-                    (internals.length - 1)
+
+                'stat() 1st parameter must be a number between 0 and ' + (internals.length - 1)
             )
 
             return internals[index]
@@ -1355,8 +1348,8 @@ export default function litecanvas(settings = {}) {
         resume() {
             DEV: assert(
                 _initialized,
-                loggerPrefix +
-                    'resume() cannot be called before the "init" event and neither after the quit() function'
+
+                'resume() cannot be called before the "init" event and neither after the quit() function'
             )
             if (_initialized && _paused) {
                 startGameLoop()
@@ -1403,7 +1396,7 @@ export default function litecanvas(settings = {}) {
                 delete root.ENGINE
             }
 
-            DEV: console.warn(loggerPrefix + 'quit() terminated a Litecanvas instance.')
+            DEV: console.warn('[litecanvas] quit() terminated a Litecanvas instance.')
         },
     }
 
@@ -1438,6 +1431,9 @@ export default function litecanvas(settings = {}) {
                         (ev.pageX - _canvas.offsetLeft) / _canvasScale,
                         (ev.pageY - _canvas.offsetTop) / _canvasScale,
                     ],
+                /**
+                 * @type {Map<number,{x:number, y:number, xi: number, yi: number, t:number}>}
+                 */
                 _taps = new Map(),
                 _registerTap =
                     /**
@@ -1487,7 +1483,7 @@ export default function litecanvas(settings = {}) {
                  * @param {MouseEvent} ev
                  */
                 (ev) => {
-                    if (ev.button === 0) {
+                    if (!ev.button) {
                         preventDefault(ev)
                         const [x, y] = _getXY(ev)
                         instance.emit('tap', x, y, 0)
@@ -1504,7 +1500,7 @@ export default function litecanvas(settings = {}) {
                  * @param {MouseEvent} ev
                  */
                 (ev) => {
-                    if (ev.button === 0) {
+                    if (!ev.button) {
                         preventDefault(ev)
                         const tap = _taps.get(0)
                         const [x, y] = _getXY(ev)
@@ -1580,10 +1576,8 @@ export default function litecanvas(settings = {}) {
                 preventDefault(ev)
                 const existing = []
 
-                if (ev.targetTouches.length > 0) {
-                    for (const touch of ev.targetTouches) {
-                        existing.push(touch.identifier + 1)
-                    }
+                for (const touch of ev.targetTouches) {
+                    existing.push(touch.identifier + 1)
                 }
 
                 for (const [id, tap] of _taps) {
@@ -1654,7 +1648,7 @@ export default function litecanvas(settings = {}) {
                 (key) => {
                     DEV: assert(
                         null == key || 'string' === typeof key,
-                        loggerPrefix + 'iskeydown() 1st param must be a string or undefined'
+                        'iskeydown() 1st parameter must be a string or undefined'
                     )
                     return keyCheck(_keysDown, key)
                 }
@@ -1669,7 +1663,7 @@ export default function litecanvas(settings = {}) {
                 (key) => {
                     DEV: assert(
                         null == key || 'string' === typeof key,
-                        loggerPrefix + 'iskeypressed() 1st param must be a string or undefined'
+                        'iskeypressed() 1st parameter must be a string or undefined'
                     )
                     return keyCheck(_keysPress, key)
                 }
@@ -1732,10 +1726,7 @@ export default function litecanvas(settings = {}) {
 
         if ('string' === typeof settings.canvas) {
             _canvas = d.querySelector(settings.canvas)
-            DEV: assert(
-                null != _canvas,
-                loggerPrefix + 'litecanvas() option "canvas" is an invalid CSS selector'
-            )
+            DEV: assert(null != _canvas, 'litecanvas() option "canvas" is an invalid CSS selector')
         } else {
             _canvas = settings.canvas
         }
@@ -1744,8 +1735,8 @@ export default function litecanvas(settings = {}) {
 
         DEV: assert(
             _canvas instanceof HTMLElement && 'CANVAS' === _canvas.tagName,
-            loggerPrefix +
-                'litecanvas() option "canvas" should be a canvas element or string (CSS selector of a canvas)'
+
+            'litecanvas() option "canvas" should be a canvas element or string (CSS selector of a canvas)'
         )
 
         _ctx = _canvas.getContext('2d')
@@ -1767,16 +1758,16 @@ export default function litecanvas(settings = {}) {
     function resizeCanvas() {
         DEV: assert(
             null == settings.width || (isNumber(settings.width) && settings.width > 0),
-            loggerPrefix + 'litecanvas() option "width" should be a positive number when defined'
+            'litecanvas() option "width" should be a positive number when defined'
         )
         DEV: assert(
             null == settings.height || (isNumber(settings.height) && settings.height > 0),
-            loggerPrefix + 'litecanvas() option "height" should be a positive number when defined'
+            'litecanvas() option "height" should be a positive number when defined'
         )
         DEV: assert(
             null == settings.height || (settings.width > 0 && settings.height > 0),
-            loggerPrefix +
-                'litecanvas() option "width" is required when the option "height" is defined'
+
+            'litecanvas() option "width" is required when the option "height" is defined'
         )
 
         const width = settings.width > 0 ? settings.width : innerWidth,
@@ -1837,7 +1828,7 @@ export default function litecanvas(settings = {}) {
 
         DEV: assert(
             null == pluginData || 'object' === typeof pluginData,
-            loggerPrefix + 'litecanvas() plugins should return an object or nothing'
+            'litecanvas() plugins should return an object or nothing'
         )
 
         for (const key in pluginData) {
@@ -1862,8 +1853,8 @@ export default function litecanvas(settings = {}) {
         root.ENGINE = instance
     }
 
-    DEV: console.info(loggerPrefix + `version ${version} started`)
-    DEV: console.debug(loggerPrefix + `litecanvas() options =`, settings)
+    DEV: console.info(`[litecanvas] version ${version} started`)
+    DEV: console.debug(`[litecanvas] litecanvas() options =`, settings)
 
     // setup the canvas
     setupCanvas()