litecanvas 0.207.1 → 0.208.0

package/dist/dist.dev.js

@@ -113,15 +113,14 @@
   };
   var defaultPalette = ["#211e20", "#555568", "#a0a08b", "#e9efec"];
   var assert = (condition, message = "Assertion failed") => {
-    if (!condition) throw new Error("[litecanvas] " + message);
+    if (!condition) throw new Error("[Litecanvas] " + message);
   };
-  var version = "0.207.1";
+  var version = "0.208.0";
   function litecanvas(settings = {}) {
     const root = window,
       math = Math,
       perf = performance,
       TWO_PI = math.PI * 2,
-      loggerPrefix = "[Litecanvas] ",
       raf = requestAnimationFrame,
       isNumber = Number.isFinite,
       _browserEventListeners = [],
@@ -145,6 +144,10 @@
         tapEvents: true,
         keyboardEvents: true,
       };
+    DEV: assert(
+      null == settings || "object" === typeof settings,
+      "litecanvas() 1st parameter must be a object",
+    );
     settings = Object.assign(defaults, settings);
     let _loop = settings.loop,
       _initialized = false,
@@ -176,36 +179,32 @@
       TWO_PI,
       HALF_PI: TWO_PI / 4,
       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);
       },
       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;
       },
       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;
       },
-      round: (n, precision = 0) => {
+      mod(a, b) {
+        DEV: assert(isNumber(a), "mod() 1st parameter must be a number");
         DEV: assert(
-          isNumber(n),
-          loggerPrefix + "round() 1st param must be a number",
+          isNumber(b) && b >= 0,
+          "mod() 2nd parameter 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(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) {
           return math.round(n);
@@ -214,127 +213,64 @@
         return math.round(n * multiplier) / multiplier;
       },
       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(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,
-          loggerPrefix +
-            "clamp() the 2nd param must be less than the 3rd param",
+          "clamp() the 2nd parameter must be less than the 3rd parameter",
         );
         if (value < min) return min;
         if (value > max) return max;
         return value;
       },
       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);
       },
       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(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,
-          loggerPrefix + "wrap() the 2nd param must be less than the 3rd param",
+          "wrap() the 2nd parameter must be less than the 3rd parameter",
         );
         return value - (max - min) * math.floor((value - min) / (max - min));
       },
       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",
         );
         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),
-          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);
       },
       rand: (min = 0, max = 1) => {
-        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(isNumber(min), "rand() 1st parameter must be a number");
+        DEV: assert(isNumber(max), "rand() 2nd parameter must be a number");
         DEV: assert(
           max >= min,
-          loggerPrefix + "rand() the 1st param must be less than the 2nd param",
+          "rand() the 1st parameter must be less than the 2nd parameter",
         );
         const a = 1664525;
         const c = 1013904223;
@@ -343,33 +279,25 @@
         return (_rngSeed / m) * (max - min) + min;
       },
       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(isNumber(min), "randi() 1st parameter must be a number");
+        DEV: assert(isNumber(max), "randi() 2nd parameter must be a number");
         DEV: assert(
           max >= min,
-          loggerPrefix +
-            "randi() the 1st param must be less than the 2nd param",
+          "randi() the 1st parameter must be less than the 2nd parameter",
         );
         return ~~instance.rand(min, max + 1);
       },
       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;
       },
       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) {
           _ctx.clearRect(0, 0, instance.W, instance.H);
@@ -378,32 +306,25 @@
         }
       },
       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"](
@@ -416,177 +337,131 @@
         instance.stroke(color);
       },
       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);
       },
       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);
       },
       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);
       },
       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);
       },
       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);
       },
       shape(points) {
         DEV: assert(
           Array.isArray(points),
-          loggerPrefix + "shape() 1st param must be an array of numbers",
+          "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]);
       },
       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(x1), "line() 1st parameter must be a number");
+        DEV: assert(isNumber(y1), "line() 2nd parameter must be a number");
         DEV: assert(
           isNumber(x2),
-          loggerPrefix + "line() 3rd param must be a positive number or zero",
+          "line() 3rd parameter must be a non-negative number",
         );
         DEV: assert(
           isNumber(y2),
-          loggerPrefix + "line() 4th param must be a positive number or zero",
+          "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);
         instance.stroke(color);
@@ -594,40 +469,33 @@
       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;
       },
       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",
+          "linedash() 2nd parameter must be a number",
         );
         _ctx.setLineDash(segments);
         _ctx.lineDashOffset = offset;
       },
       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",
+          "text() 4th parameter must be a non-negative number",
         );
         DEV: assert(
           "string" === typeof fontStyle,
-          loggerPrefix + "text() 5th param must be a string",
+          "text() 5th parameter must be a string",
         );
         _ctx.font = `${fontStyle} ${_fontSize}px ${_fontFamily}`;
         _ctx.fillStyle = getColor(color);
@@ -643,21 +511,21 @@
       textgap(value) {
         DEV: assert(
           isNumber(value),
-          loggerPrefix + "textgap() 1st param must be a number",
+          "textgap() 1st parameter must be a number",
         );
         _fontLineHeight = value;
       },
       textfont(family) {
         DEV: assert(
           "string" === typeof family,
-          loggerPrefix + "textfont() 1st param must be a string",
+          "textfont() 1st parameter must be a string",
         );
         _fontFamily = family;
       },
       textsize(size) {
         DEV: assert(
           isNumber(size),
-          loggerPrefix + "textsize() 1st param must be a number",
+          "textsize() 1st parameter must be a number",
         );
         _fontSize = size;
       },
@@ -665,8 +533,7 @@
         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 ||
@@ -678,35 +545,22 @@
               "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;
         if (baseline) _ctx.textBaseline = baseline;
       },
       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);
       },
       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(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,
-          loggerPrefix + "spr() 3rd param must be a string",
+          "spr() 3rd parameter must be a string",
         );
         const rows = pixels.trim().split("\n");
         for (let row = 0; row < rows.length; row++) {
@@ -728,27 +582,25 @@
       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",
+          "paint() 2nd parameter must be a positive number",
         );
         DEV: assert(
           "function" === typeof callback,
-          loggerPrefix + "paint() 3rd param must be a function",
+          "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 canvas = options.canvas || new OffscreenCanvas(1, 1),
           scale = options.scale || 1,
@@ -766,60 +618,67 @@
           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;
       },
-      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);
       },
       pop() {
         _ctx.restore();
       },
       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);
       },
       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);
       },
       rotate(radians) {
         DEV: assert(
           isNumber(radians),
-          loggerPrefix + "rotate() 1st param must be a number",
+          "rotate() 1st parameter must be a number",
         );
         _ctx.rotate(radians);
       },
       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);
       },
       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);
         _ctx.fill();
@@ -827,7 +686,7 @@
       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);
         _ctx.stroke();
@@ -835,7 +694,7 @@
       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);
         callback(_ctx);
@@ -844,15 +703,15 @@
       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 (
           !root.zzfxV ||
@@ -865,7 +724,6 @@
           zzfxParams = zzfxParams.slice();
           zzfxParams[0] = volumeFactor * (zzfxParams[0] || 1);
           zzfxParams[10] = ~~zzfxParams[10] + pitchSlide;
-          console.log(zzfxParams);
         }
         zzfx.apply(0, zzfxParams);
         return zzfxParams;
@@ -873,7 +731,7 @@
       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;
       },
@@ -881,23 +739,22 @@
       use(callback, config = {}) {
         DEV: assert(
           "function" === typeof callback,
-          loggerPrefix +
-            "use() 1st param must be a function (instance, config) => any",
+          "use() 1st parameter must be a function (instance, config) => any",
         );
         DEV: assert(
           "object" === typeof config,
-          loggerPrefix + "use() 2nd param must be an object",
+          "use() 2nd parameter must be an object",
         );
         loadPlugin(callback, config);
       },
       listen: (eventName, callback) => {
         DEV: assert(
           "string" === typeof eventName,
-          loggerPrefix + "listen() 1st param must be a string",
+          "listen() 1st parameter must be a string",
         );
         DEV: assert(
           "function" === typeof callback,
-          loggerPrefix + "listen() 2nd param must be a function",
+          "listen() 2nd parameter must be a function",
         );
         eventName = lowerCase(eventName);
         _eventListeners[eventName] = _eventListeners[eventName] || new Set();
@@ -906,11 +763,11 @@
       unlisten: (eventName, callback) => {
         DEV: assert(
           "string" === typeof eventName,
-          loggerPrefix + "unlisten() 1st param must be a string",
+          "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);
         if (_eventListeners[eventName]) {
@@ -920,7 +777,7 @@
       emit(eventName, arg1, arg2, arg3, arg4) {
         DEV: assert(
           "string" === typeof eventName,
-          loggerPrefix + "emit() 1st param must be a string",
+          "emit() 1st parameter must be a string",
         );
         if (_initialized) {
           eventName = lowerCase(eventName);
@@ -940,11 +797,11 @@
       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;
         _colorPaletteState = [];
@@ -954,13 +811,13 @@
       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;
@@ -969,12 +826,11 @@
       def(key, value) {
         DEV: assert(
           "string" === typeof key,
-          loggerPrefix + "def() 1st param must be a string",
+          "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]})`,
           );
         }
         instance[key] = value;
@@ -985,23 +841,19 @@
       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;
       },
       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 = 1e3 / ~~value;
       },
       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 = [
           settings,
           _initialized,
@@ -1020,8 +872,7 @@
         ];
         DEV: assert(
           index >= 0 && index < internals.length,
-          loggerPrefix +
-            "stat() 1st param must be a number between 0 and " +
+          "stat() 1st parameter must be a number between 0 and " +
             (internals.length - 1),
         );
         return internals[index];
@@ -1036,8 +887,7 @@
       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();
@@ -1063,7 +913,7 @@
           delete root.ENGINE;
         }
         DEV: console.warn(
-          loggerPrefix + "quit() terminated a Litecanvas instance.",
+          "[litecanvas] quit() terminated a Litecanvas instance.",
         );
       },
     };
@@ -1102,7 +952,7 @@
           _checkTapped = (tap) => tap && perf.now() - tap.t <= 300;
         let _pressingMouse = false;
         on(_canvas, "mousedown", (ev) => {
-          if (ev.button === 0) {
+          if (!ev.button) {
             preventDefault(ev);
             const [x, y] = _getXY(ev);
             instance.emit("tap", x, y, 0);
@@ -1111,7 +961,7 @@
           }
         });
         on(_canvas, "mouseup", (ev) => {
-          if (ev.button === 0) {
+          if (!ev.button) {
             preventDefault(ev);
             const tap = _taps.get(0);
             const [x, y] = _getXY(ev);
@@ -1153,10 +1003,8 @@
         const _touchEndHandler = (ev) => {
           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) {
             if (existing.includes(id)) continue;
@@ -1203,16 +1051,14 @@
         instance.def("iskeydown", (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);
         });
         instance.def("iskeypressed", (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);
         });
@@ -1251,8 +1097,7 @@
         _canvas = d.querySelector(settings.canvas);
         DEV: assert(
           null != _canvas,
-          loggerPrefix +
-            'litecanvas() option "canvas" is an invalid CSS selector',
+          'litecanvas() option "canvas" is an invalid CSS selector',
         );
       } else {
         _canvas = settings.canvas;
@@ -1260,8 +1105,7 @@
       _canvas = _canvas || d.createElement("canvas");
       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");
       on(_canvas, "click", () => focus());
@@ -1276,19 +1120,16 @@
       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,
         height =
@@ -1324,8 +1165,7 @@
       const pluginData = callback(instance, config);
       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) {
         instance.def(key, pluginData[key]);
@@ -1342,8 +1182,8 @@
       Object.assign(root, instance);
       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);
     setupCanvas();
     if (_loop) {
       for (const eventName in _loop) {