litecanvas 0.209.0 → 0.301.0

package/dist/dist.dev.js

@@ -115,12 +115,12 @@
   var assert = (condition, message = "Assertion failed") => {
     if (!condition) throw new Error("[Litecanvas] " + message);
   };
-  var version = "0.209.0";
+  var version = "0.301.0";
   function litecanvas(settings = {}) {
     const root = window,
       math = Math,
       perf = performance,
-      TWO_PI = math.PI * 2,
+      TAU = math.PI * 2,
       raf = requestAnimationFrame,
       isNumber = Number.isFinite,
       _browserEventListeners = [],
@@ -146,11 +146,11 @@
       };
     DEV: assert(
       null == settings || "object" === typeof settings,
-      "litecanvas() 1st parameter must be a object",
+      "litecanvas() 1st argument must be a object",
     );
     settings = Object.assign(defaults, settings);
     let _loop = settings.loop,
-      _initialized = false,
+      _initialized,
       _paused,
       _canvas,
       _canvasScale = 1,
@@ -176,35 +176,34 @@
       T: 0,
       MX: -1,
       MY: -1,
-      TWO_PI,
-      HALF_PI: TWO_PI / 4,
+      TAU,
       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);
       },
       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;
       },
       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;
       },
       mod(a, b) {
-        DEV: assert(isNumber(a), "mod() 1st parameter must be a number");
+        DEV: assert(isNumber(a), "mod() 1st argument must be a number");
         DEV: assert(
           isNumber(b) && b >= 0,
-          "mod() 2nd parameter must be a non-negative number",
+          "mod() 2nd argument must be a non-negative number",
         );
         return ((a % b) + b) % b || 0;
       },
       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) {
           return math.round(n);
@@ -213,64 +212,64 @@
         return math.round(n * multiplier) / multiplier;
       },
       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(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 parameter must be less than the 3rd parameter",
+          "clamp() the 2nd argument must be less than the 3rd argument",
         );
         if (value < min) return min;
         if (value > max) return max;
         return value;
       },
       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);
       },
       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(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 parameter must be less than the 3rd parameter",
+          "wrap() the 2nd argument must be less than the 3rd argument",
         );
         return value - (max - min) * math.floor((value - min) / (max - min));
       },
       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",
         );
         const result =
           ((value - start1) / (stop1 - start1)) * (stop2 - start2) + start2;
         return withinBounds ? instance.clamp(result, start2, stop2) : result;
       },
       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);
       },
       rand: (min = 0, max = 1) => {
-        DEV: assert(isNumber(min), "rand() 1st parameter must be a number");
-        DEV: assert(isNumber(max), "rand() 2nd parameter must be a number");
+        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 parameter must be less than the 2nd parameter",
+          "rand() the 1st argument must be less than the 2nd argument",
         );
         const a = 1664525;
         const c = 1013904223;
@@ -279,25 +278,25 @@
         return (_rngSeed / m) * (max - min) + min;
       },
       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(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 parameter must be less than the 2nd parameter",
+          "randi() the 1st argument must be less than the 2nd argument",
         );
         return ~~instance.rand(min, max + 1);
       },
       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;
       },
       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) {
           _ctx.clearRect(0, 0, instance.W, instance.H);
@@ -306,25 +305,25 @@
         }
       },
       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);
         _ctx[radii ? "roundRect" : "rect"](
@@ -337,102 +336,102 @@
         instance.stroke(color);
       },
       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);
         _ctx[radii ? "roundRect" : "rect"](~~x, ~~y, ~~width, ~~height, radii);
         instance.fill(color);
       },
       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);
       },
       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);
       },
       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);
       },
       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);
       },
       shape(points) {
         DEV: assert(
           Array.isArray(points),
-          "shape() 1st parameter must be an array of numbers",
+          "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);
         for (let i = 0; i < points.length; i += 2) {
@@ -445,19 +444,19 @@
         _ctx.lineTo(~~points[0], ~~points[1]);
       },
       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(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 parameter must be a non-negative number",
+          "line() 3rd argument must be a non-negative number",
         );
         DEV: assert(
           isNumber(y2),
-          "line() 4th parameter must be a non-negative number",
+          "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);
         let xfix = _outline_fix && ~~x1 === ~~x2 ? 0.5 : 0;
@@ -469,7 +468,7 @@
       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;
         _outline_fix = ~~value % 2 ? 0.5 : 0;
@@ -477,25 +476,25 @@
       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",
+          "linedash() 2nd argument must be a number",
         );
         _ctx.setLineDash(segments);
         _ctx.lineDashOffset = offset;
       },
       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",
+          "text() 5th argument must be a string",
         );
         _ctx.font = `${fontStyle} ${_fontSize}px ${_fontFamily}`;
         _ctx.fillStyle = getColor(color);
@@ -509,31 +508,25 @@
         }
       },
       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;
       },
       textfont(family) {
         DEV: assert(
           "string" === typeof family,
-          "textfont() 1st parameter must be a string",
+          "textfont() 1st argument must be a string",
         );
         _fontFamily = family;
       },
       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;
       },
       textalign(align, baseline) {
         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 ||
@@ -545,22 +538,22 @@
               "alphabetic",
               "ideographic",
             ].includes(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;
         if (baseline) _ctx.textBaseline = baseline;
       },
       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);
       },
       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(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 parameter must be a string",
+          "spr() 3rd argument must be a string",
         );
         const rows = pixels
           .replace(/[^\w.\n]/g, "")
@@ -583,25 +576,25 @@
       paint(width, height, callback, options = {}) {
         DEV: assert(
           isNumber(width) && width >= 1,
-          "paint() 1st parameter must be a positive number",
+          "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",
+          "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 canvas = options.canvas || new OffscreenCanvas(1, 1),
           scale = options.scale || 1,
@@ -619,7 +612,7 @@
           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) {
           _ctx = context;
@@ -635,18 +628,15 @@
       ) {
         DEV: assert(
           isNumber(translateX),
-          "push() 1st parameter must be a number",
+          "push() 1st argument 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",
+          "push() 2nd argument 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(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);
         instance.rotate(rotation);
@@ -656,30 +646,30 @@
         _ctx.restore();
       },
       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);
       },
       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);
       },
       rotate(radians) {
         DEV: assert(
           isNumber(radians),
-          "rotate() 1st parameter must be a number",
+          "rotate() 1st argument must be a number",
         );
         _ctx.rotate(radians);
       },
       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);
       },
       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);
         _ctx.fill();
@@ -687,7 +677,7 @@
       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);
         _ctx.stroke();
@@ -695,7 +685,7 @@
       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);
         callback(_ctx);
@@ -704,15 +694,15 @@
       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 (
           !root.zzfxV ||
@@ -732,7 +722,7 @@
       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;
       },
@@ -740,22 +730,41 @@
       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",
+          "use() 2nd argument must be an object",
         );
         loadPlugin(callback, config);
       },
+      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();
+      },
       listen: (eventName, callback) => {
         DEV: assert(
           "string" === typeof eventName,
-          "listen() 1st parameter must be a string",
+          "listen() 1st argument must be a string",
         );
         DEV: assert(
           "function" === typeof callback,
-          "listen() 2nd parameter must be a function",
+          "listen() 2nd argument must be a function",
         );
         eventName = lowerCase(eventName);
         _eventListeners[eventName] = _eventListeners[eventName] || new Set();
@@ -764,11 +773,11 @@
       unlisten: (eventName, callback) => {
         DEV: assert(
           "string" === typeof eventName,
-          "unlisten() 1st parameter must be a string",
+          "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);
         if (_eventListeners[eventName]) {
@@ -778,7 +787,7 @@
       emit(eventName, arg1, arg2, arg3, arg4) {
         DEV: assert(
           "string" === typeof eventName,
-          "emit() 1st parameter must be a string",
+          "emit() 1st argument must be a string",
         );
         if (_initialized) {
           eventName = lowerCase(eventName);
@@ -798,11 +807,11 @@
       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;
         _colorPaletteState = [];
@@ -812,11 +821,11 @@
       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) {
           _colorPaletteState = [];
@@ -827,7 +836,7 @@
       def(key, value) {
         DEV: assert(
           "string" === typeof key,
-          "def() 1st parameter must be a string",
+          "def() 1st argument must be a string",
         );
         DEV: if (null == value) {
           console.warn(
@@ -842,19 +851,19 @@
       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;
       },
       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 = 1e3 / ~~value;
       },
       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 = [
           settings,
           _initialized,
@@ -873,11 +882,14 @@
         ];
         DEV: assert(
           index >= 0 && index < internals.length,
-          "stat() 1st parameter must be a number between 0 and " +
+          "stat() 1st argument must be a number between 0 and " +
             (internals.length - 1),
         );
         return internals[index];
       },
+      ispaused() {
+        return _paused;
+      },
       pause() {
         if (!_paused) {
           _paused = true;
@@ -896,9 +908,6 @@
           instance.emit("resumed");
         }
       },
-      ispaused() {
-        return _paused;
-      },
       quit() {
         instance.emit("quit");
         instance.pause();
@@ -1031,9 +1040,9 @@
         const _keysPress = new Set();
         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;
         };
         let _lastKey = "";
         on(root, "keydown", (event) => {
@@ -1052,14 +1061,14 @@
         instance.def("iskeydown", (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);
         });
         instance.def("iskeypressed", (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);
         });
@@ -1110,11 +1119,9 @@
       );
       _ctx = _canvas.getContext("2d");
       on(_canvas, "click", () => focus());
-      resizeCanvas();
       if (!_canvas.parentNode) {
         d.body.appendChild(_canvas);
       }
-      _canvas.style.imageRendering = "pixelated";
       _canvas.oncontextmenu = () => false;
     }
     function resizeCanvas() {
@@ -1132,6 +1139,11 @@
         null == settings.height || (settings.width > 0 && settings.height > 0),
         '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;
@@ -1139,6 +1151,7 @@
       instance.def("H", height);
       _canvas.width = width;
       _canvas.height = height;
+      _canvas.style = "image-rendering:pixelated";
       if (settings.autoscale) {
         let maxScale = +settings.autoscale;
         if (!_canvas.style.display) {
@@ -1186,6 +1199,7 @@
     DEV: console.info(`[litecanvas] version ${version} started`);
     DEV: console.debug(`[litecanvas] litecanvas() options =`, settings);
     setupCanvas();
+    resizeCanvas();
     if (_loop) {
       for (const eventName in _loop) {
         if (_loop[eventName]) instance.listen(eventName, _loop[eventName]);