litecanvas 0.209.0 → 0.301.0

package/src/index.js

@@ -14,7 +14,7 @@ export default function litecanvas(settings = {}) {
     const root = window,
         math = Math,
         perf = performance,
-        TWO_PI = math.PI * 2,
+        TAU = math.PI * 2,
         raf = requestAnimationFrame,
         isNumber = Number.isFinite,
         /** @type {Function[]} */
@@ -45,7 +45,7 @@ export default function litecanvas(settings = {}) {
 
     DEV: assert(
         null == settings || 'object' === typeof settings,
-        'litecanvas() 1st parameter must be a object'
+        'litecanvas() 1st argument must be a object'
     )
 
     // setup the settings default values
@@ -53,7 +53,7 @@ export default function litecanvas(settings = {}) {
 
     let _loop = settings.loop,
         /** @type {boolean} */
-        _initialized = false,
+        _initialized,
         /** @type {boolean} */
         _paused,
         /** @type {HTMLCanvasElement} */
@@ -117,20 +117,9 @@ export default function litecanvas(settings = {}) {
          * Twice the value of the mathematical constant PI (π).
          * Approximately 6.28318
          *
-         * Note: TWO_PI radians equals 360°, PI radians equals 180°,
-         * HALF_PI radians equals 90°, and HALF_PI/2 radians equals 45°.
-         *
-         * @type {number}
-         */
-        TWO_PI,
-
-        /**
-         * Half the value of the mathematical constant PI (π).
-         * Approximately 1.57079
-         *
          * @type {number}
          */
-        HALF_PI: TWO_PI / 4,
+        TAU,
 
         /**
          * Calculates a linear (interpolation) value over t%.
@@ -142,9 +131,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), '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')
+            DEV: assert(isNumber(start), 'lerp() 1st argument must be a number')
+            DEV: assert(isNumber(end), 'lerp() 2nd argument must be a number')
+            DEV: assert(isNumber(t), 'lerp() 3rd argument must be a number')
 
             return start + t * (end - start)
         },
@@ -156,7 +145,7 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the value in radians
          */
         deg2rad: (degs) => {
-            DEV: assert(isNumber(degs), 'deg2rad() 1st parameter must be a number')
+            DEV: assert(isNumber(degs), 'deg2rad() 1st argument must be a number')
 
             return (math.PI / 180) * degs
         },
@@ -168,7 +157,7 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the value in degrees
          */
         rad2deg: (rads) => {
-            DEV: assert(isNumber(rads), 'rad2deg() 1st parameter must be a number')
+            DEV: assert(isNumber(rads), 'rad2deg() 1st argument must be a number')
 
             return (180 / math.PI) * rads
         },
@@ -181,13 +170,10 @@ export default function litecanvas(settings = {}) {
          * @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')
+            DEV: assert(isNumber(a), 'mod() 1st argument must be a number')
+            DEV: assert(isNumber(b) && b >= 0, 'mod() 2nd argument must be a non-negative number')
 
             return ((a % b) + b) % b || 0
         },
@@ -202,10 +188,10 @@ export default function litecanvas(settings = {}) {
          * @returns {number} rounded number.
          */
         round: (n, precision = 0) => {
-            DEV: assert(isNumber(n), 'round() 1st parameter must be a number')
+            DEV: assert(isNumber(n), 'round() 1st argument must be a number')
             DEV: assert(
                 isNumber(precision) && precision >= 0,
-                'round() 2nd parameter must be a non-negative number'
+                'round() 2nd argument must be a non-negative number'
             )
 
             if (!precision) {
@@ -224,10 +210,10 @@ export default function litecanvas(settings = {}) {
          * @returns {number}
          */
         clamp: (value, min, max) => {
-            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')
+            DEV: assert(isNumber(value), 'clamp() 1st argument must be a number')
+            DEV: assert(isNumber(min), 'clamp() 2nd argument must be a number')
+            DEV: assert(isNumber(max), 'clamp() 3rd argument must be a number')
+            DEV: assert(max >= min, 'clamp() the 2nd argument must be less than the 3rd argument')
 
             if (value < min) return min
             if (value > max) return max
@@ -244,10 +230,10 @@ export default function litecanvas(settings = {}) {
          * @returns {number}
          */
         dist: (x1, y1, x2, y2) => {
-            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')
+            DEV: assert(isNumber(x1), 'dist() 1st argument must be a number')
+            DEV: assert(isNumber(y1), 'dist() 2nd argument must be a number')
+            DEV: assert(isNumber(x2), 'dist() 3rd argument must be a number')
+            DEV: assert(isNumber(y2), 'dist() 4th argument must be a number')
 
             return math.hypot(x2 - x1, y2 - y1)
         },
@@ -261,10 +247,10 @@ export default function litecanvas(settings = {}) {
          * @returns {number}
          */
         wrap: (value, min, max) => {
-            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')
+            DEV: assert(isNumber(value), 'wrap() 1st argument must be a number')
+            DEV: assert(isNumber(min), 'wrap() 2nd argument must be a number')
+            DEV: assert(isNumber(max), 'wrap() 3rd argument must be a number')
+            DEV: assert(max > min, 'wrap() the 2nd argument must be less than the 3rd argument')
 
             return value - (max - min) * math.floor((value - min) / (max - min))
         },
@@ -281,14 +267,14 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the remapped number
          */
         map(value, start1, stop1, start2, stop2, withinBounds) {
-            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(isNumber(value), 'map() 1st argument must be a number')
+            DEV: assert(isNumber(start1), 'map() 2nd argument must be a number')
+            DEV: assert(isNumber(stop1), 'map() 3rd argument must be a number')
+            DEV: assert(isNumber(start2), 'map() 4th argument must be a number')
+            DEV: assert(isNumber(stop2), 'map() 5th argument must be a number')
             DEV: assert(
                 stop1 !== start1,
-                'map() the 2nd parameter must be different than the 3rd parameter'
+                'map() the 2nd argument must be different than the 3rd argument'
             )
 
             // prettier-ignore
@@ -307,12 +293,12 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the normalized number.
          */
         norm: (value, start, stop) => {
-            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(isNumber(value), 'norm() 1st argument must be a number')
+            DEV: assert(isNumber(start), 'norm() 2nd argument must be a number')
+            DEV: assert(isNumber(stop), 'norm() 3rd argument must be a number')
             DEV: assert(
                 start !== stop,
-                'norm() the 2nd parameter must be different than the 3rd parameter'
+                'norm() the 2nd argument must be different than the 3rd argument'
             )
 
             return instance.map(value, start, stop, 0, 1)
@@ -328,9 +314,9 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the random number
          */
         rand: (min = 0.0, max = 1.0) => {
-            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')
+            DEV: assert(isNumber(min), 'rand() 1st argument must be a number')
+            DEV: assert(isNumber(max), 'rand() 2nd argument must be a number')
+            DEV: assert(max >= min, 'rand() the 1st argument must be less than the 2nd argument')
 
             const a = 1664525
             const c = 1013904223
@@ -349,9 +335,9 @@ export default function litecanvas(settings = {}) {
          * @returns {number} the random number
          */
         randi: (min = 0, max = 1) => {
-            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')
+            DEV: assert(isNumber(min), 'randi() 1st argument must be a number')
+            DEV: assert(isNumber(max), 'randi() 2nd argument must be a number')
+            DEV: assert(max >= min, 'randi() the 1st argument must be less than the 2nd argument')
 
             return ~~instance.rand(min, max + 1)
         },
@@ -366,7 +352,7 @@ export default function litecanvas(settings = {}) {
         rseed(value) {
             DEV: assert(
                 isNumber(value) && value >= 0,
-                'rseed() 1st parameter must be a non-negative integer'
+                'rseed() 1st argument must be a non-negative integer'
             )
 
             _rngSeed = ~~value
@@ -381,7 +367,7 @@ export default function litecanvas(settings = {}) {
         cls(color) {
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'cls() 1st parameter must be a non-negative number'
+                'cls() 1st argument must be a non-negative number'
             )
 
             if (null == color) {
@@ -404,23 +390,23 @@ 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), 'rect() 1st parameter must be a number')
-            DEV: assert(isNumber(y), 'rect() 2nd parameter must be a number')
+            DEV: assert(isNumber(x), 'rect() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'rect() 2nd argument must be a number')
             DEV: assert(
                 isNumber(width) && width > 0,
-                'rect() 3rd parameter must be a positive number'
+                'rect() 3rd argument must be a positive number'
             )
             DEV: assert(
                 isNumber(height) && height >= 0,
-                'rect() 4th parameter must be a non-negative number'
+                'rect() 4th argument must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'rect() 5th parameter must be a non-negative number'
+                'rect() 5th argument must be a non-negative number'
             )
             DEV: assert(
                 null == radii || isNumber(radii) || (Array.isArray(radii) && radii.length >= 1),
-                'rect() 6th parameter must be a number or array of numbers'
+                'rect() 6th argument must be a number or array of numbers'
             )
 
             beginPath(_ctx)
@@ -446,24 +432,24 @@ 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), 'rectfill() 1st parameter must be a number')
-            DEV: assert(isNumber(y), 'rectfill() 2nd parameter must be a number')
+            DEV: assert(isNumber(x), 'rectfill() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'rectfill() 2nd argument must be a number')
             DEV: assert(
                 isNumber(width) && width >= 0,
-                'rectfill() 3rd parameter must be a non-negative number'
+                'rectfill() 3rd argument must be a non-negative number'
             )
             DEV: assert(
                 isNumber(height) && height >= 0,
-                'rectfill() 4th parameter must be a non-negative number'
+                'rectfill() 4th argument must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'rectfill() 5th parameter must be a non-negative number'
+                'rectfill() 5th argument must be a non-negative number'
             )
             DEV: assert(
                 null == radii || isNumber(radii) || (Array.isArray(radii) && radii.length >= 1),
 
-                'rectfill() 6th parameter must be a number or array of at least 2 numbers'
+                'rectfill() 6th argument must be a number or array of at least 2 numbers'
             )
 
             beginPath(_ctx)
@@ -482,24 +468,24 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         oval(x, y, radiusX, radiusY, color) {
-            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(x), 'oval() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'oval() 2nd argument must be a number')
             DEV: assert(
                 isNumber(radiusX) && radiusX >= 0,
-                'oval() 3rd parameter must be a non-negative number'
+                'oval() 3rd argument must be a non-negative number'
             )
             DEV: assert(
                 isNumber(radiusY) && radiusY >= 0,
-                'oval() 4th parameter must be a non-negative number'
+                'oval() 4th argument must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'oval() 5th parameter must be a non-negative number'
+                'oval() 5th argument must be a non-negative number'
             )
 
             beginPath(_ctx)
 
-            _ctx.ellipse(~~x, ~~y, ~~radiusX, ~~radiusY, 0, 0, TWO_PI)
+            _ctx.ellipse(~~x, ~~y, ~~radiusX, ~~radiusY, 0, 0, TAU)
             instance.stroke(color)
         },
 
@@ -513,24 +499,24 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         ovalfill(x, y, radiusX, radiusY, color) {
-            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(x), 'ovalfill() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'ovalfill() 2nd argument must be a number')
             DEV: assert(
                 isNumber(radiusX) && radiusX >= 0,
-                'ovalfill() 3rd parameter must be a non-negative number'
+                'ovalfill() 3rd argument must be a non-negative number'
             )
             DEV: assert(
                 isNumber(radiusY) && radiusY >= 0,
-                'ovalfill() 4th parameter must be a non-negative number'
+                'ovalfill() 4th argument must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'ovalfill() 5th parameter must be a non-negative number'
+                'ovalfill() 5th argument must be a non-negative number'
             )
 
             beginPath(_ctx)
 
-            _ctx.ellipse(~~x, ~~y, ~~radiusX, ~~radiusY, 0, 0, TWO_PI)
+            _ctx.ellipse(~~x, ~~y, ~~radiusX, ~~radiusY, 0, 0, TAU)
             instance.fill(color)
         },
 
@@ -543,15 +529,15 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         circ(x, y, radius, color) {
-            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(x), 'circ() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'circ() 2nd argument must be a number')
             DEV: assert(
                 isNumber(radius) && radius >= 0,
-                'circ() 3rd parameter must be a non-negative number'
+                'circ() 3rd argument must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'circ() 4th parameter must be a non-negative number'
+                'circ() 4th argument must be a non-negative number'
             )
 
             instance.oval(x, y, radius, radius, color)
@@ -566,15 +552,15 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         circfill(x, y, radius, color) {
-            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(x), 'circfill() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'circfill() 2nd argument must be a number')
             DEV: assert(
                 isNumber(radius) && radius >= 0,
-                'circfill() 3rd parameter must be a non-negative number'
+                'circfill() 3rd argument must be a non-negative number'
             )
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'circfill() 4th parameter must be a non-negative number'
+                'circfill() 4th argument must be a non-negative number'
             )
 
             instance.ovalfill(x, y, radius, radius, color)
@@ -587,10 +573,10 @@ export default function litecanvas(settings = {}) {
          * @param {number[]} points an array of Xs and Ys coordinates
          */
         shape(points) {
-            DEV: assert(Array.isArray(points), 'shape() 1st parameter must be an array of numbers')
+            DEV: assert(Array.isArray(points), 'shape() 1st argument must be an array of numbers')
             DEV: assert(
                 points.length >= 6,
-                'shape() 1st parameter must be an array with at least 6 numbers (3 points)'
+                'shape() 1st argument must be an array with at least 6 numbers (3 points)'
             )
 
             beginPath(_ctx)
@@ -615,13 +601,13 @@ export default function litecanvas(settings = {}) {
          * @param {number} [color=0] the color index
          */
         line(x1, y1, x2, y2, color) {
-            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(isNumber(x1), 'line() 1st argument must be a number')
+            DEV: assert(isNumber(y1), 'line() 2nd argument must be a number')
+            DEV: assert(isNumber(x2), 'line() 3rd argument must be a non-negative number')
+            DEV: assert(isNumber(y2), 'line() 4th argument must be a non-negative number')
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'line() 5th parameter must be a non-negative number'
+                'line() 5th argument must be a non-negative number'
             )
 
             beginPath(_ctx)
@@ -644,7 +630,7 @@ export default function litecanvas(settings = {}) {
         linewidth(value) {
             DEV: assert(
                 isNumber(value) && value >= 0,
-                'linewidth() 1st parameter must be a non-negative integer'
+                'linewidth() 1st argument must be a non-negative integer'
             )
 
             _ctx.lineWidth = ~~value
@@ -662,9 +648,9 @@ export default function litecanvas(settings = {}) {
         linedash(segments, offset = 0) {
             DEV: assert(
                 Array.isArray(segments) && segments.length > 0,
-                'linedash() 1st parameter must be an array of numbers'
+                'linedash() 1st argument must be an array of numbers'
             )
-            DEV: assert(isNumber(offset), 'linedash() 2nd parameter must be a number')
+            DEV: assert(isNumber(offset), 'linedash() 2nd argument must be a number')
 
             _ctx.setLineDash(segments)
             _ctx.lineDashOffset = offset
@@ -681,13 +667,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), 'text() 1st parameter must be a number')
-            DEV: assert(isNumber(y), 'text() 2nd parameter must be a number')
+            DEV: assert(isNumber(x), 'text() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'text() 2nd argument must be a number')
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'text() 4th parameter must be a non-negative number'
+                'text() 4th argument must be a non-negative number'
             )
-            DEV: assert('string' === typeof fontStyle, 'text() 5th parameter must be a string')
+            DEV: assert('string' === typeof fontStyle, 'text() 5th argument must be a string')
 
             _ctx.font = `${fontStyle} ${_fontSize}px ${_fontFamily}`
             _ctx.fillStyle = getColor(color)
@@ -706,7 +692,7 @@ export default function litecanvas(settings = {}) {
          * @param {number} value
          */
         textgap(value) {
-            DEV: assert(isNumber(value), 'textgap() 1st parameter must be a number')
+            DEV: assert(isNumber(value), 'textgap() 1st argument must be a number')
 
             _fontLineHeight = value
         },
@@ -717,7 +703,7 @@ export default function litecanvas(settings = {}) {
          * @param {string} family
          */
         textfont(family) {
-            DEV: assert('string' === typeof family, 'textfont() 1st parameter must be a string')
+            DEV: assert('string' === typeof family, 'textfont() 1st argument must be a string')
 
             _fontFamily = family
         },
@@ -728,7 +714,7 @@ export default function litecanvas(settings = {}) {
          * @param {number} size
          */
         textsize(size) {
-            DEV: assert(isNumber(size), 'textsize() 1st parameter must be a number')
+            DEV: assert(isNumber(size), 'textsize() 1st argument must be a number')
 
             _fontSize = size
         },
@@ -745,7 +731,7 @@ export default function litecanvas(settings = {}) {
             DEV: assert(
                 null == align || ['left', 'right', 'center', 'start', 'end'].includes(align),
 
-                'textalign() 1st parameter must be null or one of the following strings: center, left, right, start or end.'
+                'textalign() 1st argument must be null or one of the following strings: center, left, right, start or end.'
             )
             DEV: assert(
                 null == baseline ||
@@ -753,7 +739,7 @@ export default function litecanvas(settings = {}) {
                         baseline
                     ),
 
-                'textalign() 2nd parameter must be null or one of the following strings: middle, top, bottom, hanging, alphabetic or ideographic.'
+                'textalign() 2nd argument must be null or one of the following strings: middle, top, bottom, hanging, alphabetic or ideographic.'
             )
 
             if (align) _ctx.textAlign = align
@@ -769,8 +755,8 @@ export default function litecanvas(settings = {}) {
          * @param {CanvasImageSource} source
          */
         image(x, y, source) {
-            DEV: assert(isNumber(x), 'image() 1st parameter must be a number')
-            DEV: assert(isNumber(y), 'image() 2nd parameter must be a number')
+            DEV: assert(isNumber(x), 'image() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'image() 2nd argument must be a number')
 
             _ctx.drawImage(source, ~~x, ~~y)
         },
@@ -787,9 +773,9 @@ export default function litecanvas(settings = {}) {
          * @param {string} pixels
          */
         spr(x, y, pixels) {
-            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')
+            DEV: assert(isNumber(x), 'spr() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'spr() 2nd argument must be a number')
+            DEV: assert('string' === typeof pixels, 'spr() 3rd argument must be a string')
 
             const rows = pixels
                 .replace(/[^\w.\n]/g, '')
@@ -818,23 +804,20 @@ export default function litecanvas(settings = {}) {
          * @see https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas
          */
         paint(width, height, callback, options = {}) {
-            DEV: assert(
-                isNumber(width) && width >= 1,
-                'paint() 1st parameter must be a positive number'
-            )
+            DEV: assert(isNumber(width) && width >= 1, 'paint() 1st argument must be a number >= 1')
             DEV: assert(
                 isNumber(height) && height >= 1,
-                'paint() 2nd parameter must be a positive number'
+                'paint() 2nd argument must be a number >= 1'
             )
-            DEV: assert('function' === typeof callback, 'paint() 3rd parameter must be a function')
+            DEV: assert('function' === typeof callback, 'paint() 3rd argument must be a function')
             DEV: assert(
                 (options && null == options.scale) ||
                     (isNumber(options.scale) && options.scale > 0),
-                'paint() 4th parameter (options.scale) must be a positive number'
+                'paint() 4th argument (options.scale) must be a positive number'
             )
             DEV: assert(
                 (options && null == options.canvas) || options.canvas instanceof OffscreenCanvas,
-                'paint() 4th parameter (options.canvas) must be an OffscreenCanvas'
+                'paint() 4th argument (options.canvas) must be an OffscreenCanvas'
             )
 
             const /** @type {OffscreenCanvas} */
@@ -867,7 +850,7 @@ export default function litecanvas(settings = {}) {
                 null == context ||
                     context instanceof CanvasRenderingContext2D ||
                     context instanceof OffscreenCanvasRenderingContext2D,
-                'ctx() 1st parameter must be an [Offscreen]CanvasRenderingContext2D'
+                'ctx() 1st argument must be an [Offscreen]CanvasRenderingContext2D'
             )
 
             if (context) {
@@ -889,11 +872,11 @@ export default function litecanvas(settings = {}) {
          * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/save
          */
         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')
+            DEV: assert(isNumber(translateX), 'push() 1st argument must be a number')
+            DEV: assert(isNumber(translateY), 'push() 2nd argument must be a number')
+            DEV: assert(isNumber(rotation), 'push() 3rd argument must be a number')
+            DEV: assert(isNumber(scaleX), 'push() 4th argument must be a number')
+            DEV: assert(isNumber(scaleY), 'push() 5th argument must be a number')
 
             _ctx.save()
             instance.translate(translateX, translateY)
@@ -917,8 +900,8 @@ export default function litecanvas(settings = {}) {
          * @param {number} y
          */
         translate(x, y) {
-            DEV: assert(isNumber(x), 'translate() 1st parameter must be a number')
-            DEV: assert(isNumber(y), 'translate() 2nd parameter must be a number')
+            DEV: assert(isNumber(x), 'translate() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'translate() 2nd argument must be a number')
 
             _ctx.translate(~~x, ~~y)
         },
@@ -930,8 +913,8 @@ export default function litecanvas(settings = {}) {
          * @param {number} [y]
          */
         scale(x, y = x) {
-            DEV: assert(isNumber(x), 'scale() 1st parameter must be a number')
-            DEV: assert(isNumber(y), 'scale() 2nd parameter must be a number')
+            DEV: assert(isNumber(x), 'scale() 1st argument must be a number')
+            DEV: assert(isNumber(y), 'scale() 2nd argument must be a number')
 
             _ctx.scale(x, y)
         },
@@ -942,7 +925,7 @@ export default function litecanvas(settings = {}) {
          * @param {number} radians
          */
         rotate(radians) {
-            DEV: assert(isNumber(radians), 'rotate() 1st parameter must be a number')
+            DEV: assert(isNumber(radians), 'rotate() 1st argument must be a number')
 
             _ctx.rotate(radians)
         },
@@ -954,7 +937,7 @@ export default function litecanvas(settings = {}) {
          * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalAlpha
          */
         alpha(value) {
-            DEV: assert(isNumber(value), 'alpha() 1st parameter must be a number')
+            DEV: assert(isNumber(value), 'alpha() 1st argument must be a number')
 
             _ctx.globalAlpha = instance.clamp(value, 0, 1)
         },
@@ -967,7 +950,7 @@ export default function litecanvas(settings = {}) {
         fill(color) {
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'fill() 1st parameter must be a non-negative number'
+                'fill() 1st argument must be a non-negative number'
             )
 
             _ctx.fillStyle = getColor(color)
@@ -982,7 +965,7 @@ export default function litecanvas(settings = {}) {
         stroke(color) {
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
-                'stroke() 1st parameter must be a non-negative number'
+                'stroke() 1st argument must be a non-negative number'
             )
 
             _ctx.strokeStyle = getColor(color)
@@ -998,7 +981,7 @@ export default function litecanvas(settings = {}) {
         clip(callback) {
             DEV: assert(
                 'function' === typeof callback,
-                'clip() 1st parameter must be a function (ctx) => void'
+                'clip() 1st argument must be a function (ctx) => void'
             )
 
             beginPath(_ctx)
@@ -1021,15 +1004,15 @@ export default function litecanvas(settings = {}) {
         sfx(zzfxParams, pitchSlide, volumeFactor) {
             DEV: assert(
                 null == zzfxParams || Array.isArray(zzfxParams),
-                'sfx() 1st parameter must be an array'
+                'sfx() 1st argument must be an array'
             )
             DEV: assert(
                 null == pitchSlide || isNumber(pitchSlide),
-                'sfx() 2nd parameter must be a number'
+                'sfx() 2nd argument must be a number'
             )
             DEV: assert(
                 null == volumeFactor || isNumber(volumeFactor),
-                'sfx() 3rd parameter must be a number'
+                'sfx() 3rd argument must be a number'
             )
 
             if (
@@ -1062,7 +1045,7 @@ export default function litecanvas(settings = {}) {
         volume(value) {
             DEV: assert(
                 isNumber(value) && value >= 0,
-                'volume() 1st parameter must be a non-negative number'
+                'volume() 1st argument must be a non-negative number'
             )
 
             root.zzfxV = value
@@ -1085,13 +1068,42 @@ export default function litecanvas(settings = {}) {
         use(callback, config = {}) {
             DEV: assert(
                 'function' === typeof callback,
-                'use() 1st parameter must be a function (instance, config) => any'
+                'use() 1st argument must be a function (instance, config) => any'
             )
-            DEV: assert('object' === typeof config, 'use() 2nd parameter must be an object')
+            DEV: assert('object' === typeof config, 'use() 2nd argument must be an object')
 
             loadPlugin(callback, config)
         },
 
+        /**
+         * Resizes the canvas
+         *
+         * @param {number} width
+         * @param {number} [height]
+         * @param {boolean|number} [autoscale]
+         */
+        resize(width, height = width, autoscale) {
+            DEV: assert(
+                isNumber(width) && width >= 1,
+                'resize() 1st argument must be a number >= 1'
+            )
+            DEV: assert(
+                isNumber(height) && height >= 1,
+                'resize() 2nd argument must be a number >= 1'
+            )
+            DEV: assert(
+                null == autoscale ||
+                    'boolean' === typeof autoscale ||
+                    (isNumber(autoscale) && autoscale > 1),
+                'resize() 3rd argument must be a boolean or a number > 1'
+            )
+
+            settings.height = height
+            settings.autoscale = null == autoscale ? settings.autoscale : autoscale
+
+            resizeCanvas()
+        },
+
         /**
          * Add a game event listener.
          *
@@ -1099,8 +1111,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, 'listen() 1st parameter must be a string')
-            DEV: assert('function' === typeof callback, 'listen() 2nd parameter must be a function')
+            DEV: assert('string' === typeof eventName, 'listen() 1st argument must be a string')
+            DEV: assert('function' === typeof callback, 'listen() 2nd argument must be a function')
 
             eventName = lowerCase(eventName)
 
@@ -1115,10 +1127,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, 'unlisten() 1st parameter must be a string')
+            DEV: assert('string' === typeof eventName, 'unlisten() 1st argument must be a string')
             DEV: assert(
                 'function' === typeof callback,
-                'unlisten() 2nd parameter must be a function'
+                'unlisten() 2nd argument must be a function'
             )
 
             eventName = lowerCase(eventName)
@@ -1143,7 +1155,7 @@ export default function litecanvas(settings = {}) {
          * @returns {any} always returns the second argument
          */
         emit(eventName, arg1, arg2, arg3, arg4) {
-            DEV: assert('string' === typeof eventName, 'emit() 1st parameter must be a string')
+            DEV: assert('string' === typeof eventName, 'emit() 1st argument must be a string')
 
             if (_initialized) {
                 eventName = lowerCase(eventName)
@@ -1178,11 +1190,11 @@ export default function litecanvas(settings = {}) {
         pal(colors, textColor = 3) {
             DEV: assert(
                 null == colors || (Array.isArray(colors) && colors.length > 0),
-                'pal() 1st parameter must be null or an array of colors'
+                'pal() 1st argument must be null or an array of colors'
             )
             DEV: assert(
                 isNumber(textColor) && textColor >= 0,
-                'pal() 2nd parameter must be a non-negative number'
+                'pal() 2nd argument must be a non-negative number'
             )
 
             _colorPalette = colors || defaultPalette
@@ -1205,11 +1217,11 @@ export default function litecanvas(settings = {}) {
         palc(a, b) {
             DEV: assert(
                 null == a || (isNumber(a) && a >= 0),
-                'palc() 1st parameter must be a positive number'
+                'palc() 1st argument must be a positive number'
             )
             DEV: assert(
                 isNumber(a) ? isNumber(b) && b >= 0 : null == b,
-                'palc() 2nd parameter must be a positive number'
+                'palc() 2nd argument must be a positive number'
             )
 
             if (null == a) {
@@ -1231,7 +1243,7 @@ export default function litecanvas(settings = {}) {
          * @param {any} value the property value
          */
         def(key, value) {
-            DEV: assert('string' === typeof key, 'def() 1st parameter must be a string')
+            DEV: assert('string' === typeof key, 'def() 1st argument must be a string')
             DEV: if (null == value) {
                 console.warn(
                     `[litecanvas] def() changed the key "${key}" to null (previous value was ${instance[key]})`
@@ -1254,7 +1266,7 @@ export default function litecanvas(settings = {}) {
         timescale(value) {
             DEV: assert(
                 isNumber(value) && value >= 0,
-                'timescale() 1st parameter must be a non-negative number'
+                'timescale() 1st argument must be a non-negative number'
             )
 
             _timeScale = value
@@ -1268,7 +1280,7 @@ export default function litecanvas(settings = {}) {
         framerate(value) {
             DEV: assert(
                 isNumber(value) && value >= 1,
-                'framerate() 1st parameter must be a positive number'
+                'framerate() 1st argument must be a number >= 1'
             )
 
             _fpsInterval = 1000 / ~~value
@@ -1281,7 +1293,7 @@ export default function litecanvas(settings = {}) {
          * @returns {any}
          */
         stat(index) {
-            DEV: assert(isNumber(index), 'stat() 1st parameter must be a number')
+            DEV: assert(isNumber(index), 'stat() 1st argument must be a number')
 
             const internals = [
                 // 0
@@ -1330,12 +1342,21 @@ export default function litecanvas(settings = {}) {
             DEV: assert(
                 index >= 0 && index < internals.length,
 
-                'stat() 1st parameter must be a number between 0 and ' + (internals.length - 1)
+                'stat() 1st argument must be a number between 0 and ' + (internals.length - 1)
             )
 
             return internals[index]
         },
 
+        /**
+         * Returns `true` if the engine loop is paused.
+         *
+         * @returns {boolean}
+         */
+        ispaused() {
+            return _paused
+        },
+
         /**
          * Pauses the engine loop (update & draw).
          */
@@ -1363,15 +1384,6 @@ export default function litecanvas(settings = {}) {
             }
         },
 
-        /**
-         * Returns `true` if the engine loop is paused.
-         *
-         * @returns {boolean}
-         */
-        ispaused() {
-            return _paused
-        },
-
         /**
          * Shutdown the litecanvas instance and remove all event listeners.
          */
@@ -1622,7 +1634,7 @@ export default function litecanvas(settings = {}) {
              */
             const keyCheck = (keySet, key = '') => {
                 key = lowerCase(key)
-                return !key ? keySet.size > 0 : keySet.has('space' === key ? ' ' : key)
+                return key ? keySet.has('space' === key ? ' ' : key) : keySet.size > 0
             }
 
             /** @type {string} */
@@ -1653,7 +1665,7 @@ export default function litecanvas(settings = {}) {
                 (key) => {
                     DEV: assert(
                         null == key || 'string' === typeof key,
-                        'iskeydown() 1st parameter must be a string or undefined'
+                        'iskeydown() 1st argument must be a string'
                     )
                     return keyCheck(_keysDown, key)
                 }
@@ -1668,7 +1680,7 @@ export default function litecanvas(settings = {}) {
                 (key) => {
                     DEV: assert(
                         null == key || 'string' === typeof key,
-                        'iskeypressed() 1st parameter must be a string or undefined'
+                        'iskeypressed() 1st argument must be a string'
                     )
                     return keyCheck(_keysPress, key)
                 }
@@ -1748,14 +1760,10 @@ export default function litecanvas(settings = {}) {
 
         on(_canvas, 'click', () => focus())
 
-        resizeCanvas()
-
         if (!_canvas.parentNode) {
             d.body.appendChild(_canvas)
         }
 
-        _canvas.style.imageRendering = 'pixelated'
-
         // disable default browser's right click in canvas
         _canvas.oncontextmenu = () => false
     }
@@ -1774,6 +1782,11 @@ export default function litecanvas(settings = {}) {
 
             'litecanvas() option "width" is required when the option "height" is defined'
         )
+        DEV: assert(
+            'boolean' === typeof settings.autoscale ||
+                (isNumber(settings.autoscale) && settings.autoscale > 1),
+            'litecanvas() option "autoscale" must be boolean or a number > 1'
+        )
 
         const width = settings.width > 0 ? settings.width : innerWidth,
             height = settings.width > 0 ? settings.height || settings.width : innerHeight
@@ -1784,6 +1797,9 @@ export default function litecanvas(settings = {}) {
         _canvas.width = width
         _canvas.height = height
 
+        /** @ts-ignore */
+        _canvas.style = 'image-rendering:pixelated'
+
         if (settings.autoscale) {
             let maxScale = +settings.autoscale
             if (!_canvas.style.display) {
@@ -1863,8 +1879,10 @@ export default function litecanvas(settings = {}) {
 
     // setup the canvas
     setupCanvas()
+    resizeCanvas()
 
     // setup default event listeners
+    // they have high priority
     if (_loop) {
         for (const eventName in _loop) {
             if (_loop[eventName]) instance.listen(eventName, _loop[eventName])