litecanvas 0.103.5 → 0.103.7

package/dist/dist.dev.js

@@ -1,7 +1,7 @@
-;(() => {
+(() => {
   var setupZzFX = (global) => {
-    const zzfxX = new AudioContext()
-    global.zzfxV = 1
+    const zzfxX = new AudioContext();
+    global.zzfxV = 1;
     return (
       i = 1,
       d = 0.05,
@@ -51,7 +51,7 @@
         U = 0,
         W = 0,
         Y = 0,
-        Z = 0
+        Z = 0;
       for (
         e = a * e + 9,
           X *= a,
@@ -102,20 +102,20 @@
           (u = (z += T += H) * n.cos(K * _++)),
           (x += u + u * j * C(f ** 5)),
           g && ++g > J && ((z += V), (O += V), (g = 0)),
-          !h || ++$ % h || ((z = O), (T = F), (g = g || 1)))
-      ;((i = zzfxX.createBuffer(1, s, a)),
+          !h || ++$ % h || ((z = O), (T = F), (g = g || 1)));
+      ((i = zzfxX.createBuffer(1, s, a)),
         i.getChannelData(0).set(d),
         (z = zzfxX.createBufferSource()),
         (z.buffer = i),
         z.connect(zzfxX.destination),
-        z.start())
-    }
-  }
-  var defaultPalette = ["#211e20", "#555568", "#a0a08b", "#e9efec"]
+        z.start());
+    };
+  };
+  var defaultPalette = ["#211e20", "#555568", "#a0a08b", "#e9efec"];
   var assert = (condition, message = "Assertion failed") => {
-    if (!condition) throw new Error("[litecanvas] " + message)
-  }
-  var version = "0.103.5"
+    if (!condition) throw new Error("[litecanvas] " + message);
+  };
+  var version = "0.103.7";
   function litecanvas(settings = {}) {
     const root = window,
       math = Math,
@@ -125,10 +125,10 @@
       raf = requestAnimationFrame,
       _browserEventListeners = [],
       on = (elem, evt, callback) => {
-        elem.addEventListener(evt, callback, false)
+        elem.addEventListener(evt, callback, false);
         _browserEventListeners.push(() =>
           elem.removeEventListener(evt, callback, false),
-        )
+        );
       },
       lowerCase = (str) => str.toLowerCase(),
       preventDefault = (ev) => ev.preventDefault(),
@@ -144,8 +144,8 @@
         loop: null,
         tapEvents: true,
         keyboardEvents: true,
-      }
-    settings = Object.assign(defaults, settings)
+      };
+    settings = Object.assign(defaults, settings);
     let _initialized = false,
       _paused = true,
       _canvas,
@@ -168,7 +168,7 @@
       _coreEvents = "init,update,draw,tap,untap,tapping,tapped,resized",
       _mathFunctions =
         "PI,sin,cos,atan2,hypot,tan,abs,ceil,floor,trunc,min,max,pow,sqrt,sign,exp",
-      _eventListeners = {}
+      _eventListeners = {};
     const instance = {
       W: 0,
       H: 0,
@@ -181,483 +181,487 @@
         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",
-        )
-        return start + t * (end - start)
+        );
+        return start + t * (end - start);
       },
       deg2rad: (degs) => {
-        DEV: assert(isNumber(degs), "deg2rad: 1st param must be a number")
-        return (math.PI / 180) * degs
+        DEV: assert(isNumber(degs), "deg2rad: 1st param must be a number");
+        return (math.PI / 180) * degs;
       },
       rad2deg: (rads) => {
-        DEV: assert(isNumber(rads), "rad2deg: 1st param must be a number")
-        return (180 / math.PI) * rads
+        DEV: assert(isNumber(rads), "rad2deg: 1st param must be a number");
+        return (180 / math.PI) * rads;
       },
       round: (n, precision = 0) => {
         DEV: assert(
           isNumber(n),
           loggerPrefix + "round() 1st param must be a number",
-        )
+        );
         DEV: assert(
           isNumber(precision) && precision >= 0,
           loggerPrefix + "round() 2nd param must be a positive number or zero",
-        )
+        );
         if (!precision) {
-          return math.round(n)
+          return math.round(n);
         }
-        const multiplier = 10 ** precision
-        return math.round(n * multiplier) / multiplier
+        const multiplier = 10 ** precision;
+        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(
-          max > min,
+          max >= min,
           loggerPrefix +
             "clamp() the 2nd param must be less than the 3rd param",
-        )
-        if (value < min) return min
-        if (value > max) return max
-        return value
+        );
+        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",
-        )
-        return math.hypot(x2 - x1, y2 - y1)
+        );
+        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(
           max > min,
           loggerPrefix + "wrap() the 2nd param must be less than the 3rd param",
-        )
-        return value - (max - min) * math.floor((value - min) / (max - min))
+        );
+        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(
           stop1 !== start1,
           loggerPrefix +
             "map() the 2nd param must be different than the 3rd param",
-        )
+        );
         const result =
-          ((value - start1) / (stop1 - start1)) * (stop2 - start2) + start2
-        return withinBounds ? instance.clamp(result, start2, stop2) : 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(
           start !== stop,
           loggerPrefix +
             "norm() the 2nd param must be different than the 3rd param",
-        )
-        return instance.map(value, start, stop, 0, 1)
+        );
+        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(
-          max > min,
+          max >= min,
           loggerPrefix + "rand() the 1st param must be less than the 2nd param",
-        )
-        const a = 1664525
-        const c = 1013904223
-        const m = 4294967296
-        _rngSeed = (a * _rngSeed + c) % m
-        return (_rngSeed / m) * (max - min) + min
+        );
+        const a = 1664525;
+        const c = 1013904223;
+        const m = 4294967296;
+        _rngSeed = (a * _rngSeed + c) % m;
+        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(
-          min <= max,
+          max >= min,
           loggerPrefix +
             "randi() the 1st param must be less than the 2nd param",
-        )
-        return ~~instance.rand(min, max + 1)
+        );
+        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",
-        )
-        _rngSeed = ~~value
+        );
+        _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",
-        )
+        );
         if (null == color) {
-          _ctx.clearRect(0, 0, instance.W, instance.H)
+          _ctx.clearRect(0, 0, instance.W, instance.H);
         } else {
-          instance.rectfill(0, 0, instance.W, instance.H, color)
+          instance.rectfill(0, 0, instance.W, instance.H, color);
         }
       },
       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(width) && width > 0,
           loggerPrefix + "rect() 3rd param must be a positive number",
-        )
+        );
         DEV: assert(
           isNumber(height) && height >= 0,
           loggerPrefix + "rect() 4th param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           null == color || (isNumber(color) && color >= 0),
           loggerPrefix + "rect() 5th param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           null == radii ||
             isNumber(radii) ||
             (Array.isArray(radii) && radii.length >= 1),
           loggerPrefix +
             "rect() 6th param must be a number or array of numbers",
-        )
-        beginPath(_ctx)
+        );
+        beginPath(_ctx);
         _ctx[radii ? "roundRect" : "rect"](
           ~~x - _outline_fix,
           ~~y - _outline_fix,
           ~~width + _outline_fix * 2,
           ~~height + _outline_fix * 2,
           radii,
-        )
-        instance.stroke(color)
+        );
+        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(width) && width >= 0,
           loggerPrefix +
             "rectfill() 3rd param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           isNumber(height) && height >= 0,
           loggerPrefix +
             "rectfill() 4th param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           null == color || (isNumber(color) && color >= 0),
           loggerPrefix +
             "rectfill() 5th param must be a positive number or zero",
-        )
+        );
         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",
-        )
-        beginPath(_ctx)
-        _ctx[radii ? "roundRect" : "rect"](~~x, ~~y, ~~width, ~~height, radii)
-        instance.fill(color)
+        );
+        beginPath(_ctx);
+        _ctx[radii ? "roundRect" : "rect"](~~x, ~~y, ~~width, ~~height, radii);
+        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(radius) && radius >= 0,
           loggerPrefix + "circ() 3rd param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           null == color || (isNumber(color) && color >= 0),
           loggerPrefix + "circ() 4th param must be a positive number or zero",
-        )
-        beginPath(_ctx)
-        _ctx.arc(~~x, ~~y, ~~radius, 0, TWO_PI)
-        instance.stroke(color)
+        );
+        beginPath(_ctx);
+        _ctx.arc(~~x, ~~y, ~~radius, 0, TWO_PI);
+        instance.stroke(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(radius) && radius >= 0,
           loggerPrefix +
             "circfill() 3rd param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           null == color || (isNumber(color) && color >= 0),
           loggerPrefix +
             "circfill() 4th param must be a positive number or zero",
-        )
-        beginPath(_ctx)
-        _ctx.arc(~~x, ~~y, ~~radius, 0, TWO_PI)
-        instance.fill(color)
+        );
+        beginPath(_ctx);
+        _ctx.arc(~~x, ~~y, ~~radius, 0, TWO_PI);
+        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(radiusX) && radiusX >= 0,
           loggerPrefix + "oval() 3rd param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           isNumber(radiusY) && radiusY >= 0,
           loggerPrefix + "oval() 4th param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           null == color || (isNumber(color) && color >= 0),
           loggerPrefix + "oval() 5th param must be a positive number or zero",
-        )
-        beginPath(_ctx)
-        _ctx.ellipse(~~x, ~~y, ~~radiusX, ~~radiusY, 0, 0, TWO_PI)
-        instance.stroke(color)
+        );
+        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(radiusX) && radiusX >= 0,
           loggerPrefix +
             "ovalfill() 3rd param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           isNumber(radiusY) && radiusY >= 0,
           loggerPrefix +
             "ovalfill() 4th param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           null == color || (isNumber(color) && color >= 0),
           loggerPrefix +
             "ovalfill() 5th param must be a positive number or zero",
-        )
-        beginPath(_ctx)
-        _ctx.ellipse(~~x, ~~y, ~~radiusX, ~~radiusY, 0, 0, TWO_PI)
-        instance.fill(color)
+        );
+        beginPath(_ctx);
+        _ctx.ellipse(~~x, ~~y, ~~radiusX, ~~radiusY, 0, 0, TWO_PI);
+        instance.fill(color);
       },
       shape(points) {
         DEV: assert(
           Array.isArray(points),
           loggerPrefix + "shape() 1st param 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)",
-        )
-        beginPath(_ctx)
+        );
+        beginPath(_ctx);
         for (let i = 0; i < points.length; i += 2) {
           if (0 === i) {
-            _ctx.moveTo(~~points[i], ~~points[i + 1])
+            _ctx.moveTo(~~points[i], ~~points[i + 1]);
           } else {
-            _ctx.lineTo(~~points[i], ~~points[i + 1])
+            _ctx.lineTo(~~points[i], ~~points[i + 1]);
           }
         }
-        _ctx.lineTo(~~points[0], ~~points[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(x2),
           loggerPrefix + "line() 3rd param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           isNumber(y2),
           loggerPrefix + "line() 4th param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           null == color || (isNumber(color) && color >= 0),
           loggerPrefix + "line() 5th param must be a positive number or zero",
-        )
-        beginPath(_ctx)
-        let xfix = _outline_fix !== 0 && ~~x1 === ~~x2 ? 0.5 : 0
-        let yfix = _outline_fix !== 0 && ~~y1 === ~~y2 ? 0.5 : 0
-        _ctx.moveTo(~~x1 + xfix, ~~y1 + yfix)
-        _ctx.lineTo(~~x2 + xfix, ~~y2 + yfix)
-        instance.stroke(color)
+        );
+        beginPath(_ctx);
+        let xfix = _outline_fix !== 0 && ~~x1 === ~~x2 ? 0.5 : 0;
+        let yfix = _outline_fix !== 0 && ~~y1 === ~~y2 ? 0.5 : 0;
+        _ctx.moveTo(~~x1 + xfix, ~~y1 + yfix);
+        _ctx.lineTo(~~x2 + xfix, ~~y2 + yfix);
+        instance.stroke(color);
       },
       linewidth(value) {
         DEV: assert(
           isNumber(value) && value >= 0,
           loggerPrefix +
             "linewidth() 1st param must be a positive number or zero",
-        )
-        _ctx.lineWidth = ~~value
-        _outline_fix = 0 === ~~value % 2 ? 0 : 0.5
+        );
+        _ctx.lineWidth = ~~value;
+        _outline_fix = 0 === ~~value % 2 ? 0 : 0.5;
       },
       linedash(segments, offset = 0) {
         DEV: assert(
           Array.isArray(segments) && segments.length > 0,
           loggerPrefix + "linedash() 1st param must be an array of numbers",
-        )
+        );
         DEV: assert(
           isNumber(offset),
           loggerPrefix + "linedash() 2nd param must be a number",
-        )
-        _ctx.setLineDash(segments)
-        _ctx.lineDashOffset = offset
+        );
+        _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(
           null == color || (isNumber(color) && color >= 0),
           loggerPrefix + "text() 4th param must be a positive number or zero",
-        )
+        );
         DEV: assert(
           "string" === typeof fontStyle,
           loggerPrefix + "text() 5th param must be a string",
-        )
-        _ctx.font = `${fontStyle} ${_fontSize}px ${_fontFamily}`
-        _ctx.fillStyle = getColor(color)
-        const messages = ("" + message).split("\n")
+        );
+        _ctx.font = `${fontStyle} ${_fontSize}px ${_fontFamily}`;
+        _ctx.fillStyle = getColor(color);
+        const messages = ("" + message).split("\n");
         for (let i = 0; i < messages.length; i++) {
-          _ctx.fillText(messages[i], ~~x, ~~y + _fontSize * _fontLineHeight * i)
+          _ctx.fillText(
+            messages[i],
+            ~~x,
+            ~~y + _fontSize * _fontLineHeight * i,
+          );
         }
       },
       textgap(value) {
-        _fontLineHeight = value
+        _fontLineHeight = value;
       },
       textfont(family) {
         DEV: assert(
           "string" === typeof family,
           loggerPrefix + "textfont() 1st param must be a string",
-        )
-        _fontFamily = family
+        );
+        _fontFamily = family;
       },
       textsize(size) {
         DEV: assert(
           isNumber(size),
           loggerPrefix + "textsize() 1st param must be a number",
-        )
-        _fontSize = size
+        );
+        _fontSize = size;
       },
       textalign(align, baseline) {
         DEV: assert(
@@ -665,7 +669,7 @@
             ["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.",
-        )
+        );
         DEV: assert(
           null == baseline ||
             [
@@ -678,41 +682,47 @@
             ].includes(baseline),
           loggerPrefix +
             "textalign() 2nd param 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
+        );
+        if (align) _ctx.textAlign = align;
+        if (baseline) _ctx.textBaseline = baseline;
       },
       image(x, y, source2) {
         DEV: assert(
           isNumber(x),
           loggerPrefix + "image() 1st param must be a number",
-        )
+        );
         DEV: assert(
           isNumber(y),
           loggerPrefix + "image() 2nd param must be a number",
-        )
-        _ctx.drawImage(source2, ~~x, ~~y)
+        );
+        _ctx.drawImage(source2, ~~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(
           "string" === typeof pixels,
           loggerPrefix + "spr() 3rd param must be a string",
-        )
-        const rows = pixels.trim().split("\n")
+        );
+        const rows = pixels.trim().split("\n");
         for (let row = 0; row < rows.length; row++) {
-          const chars = rows[row].trim()
+          const chars = rows[row].trim();
           for (let col = 0; col < chars.length; col++) {
-            const char = chars[col]
+            const char = chars[col];
             if (char !== "." && char !== " ") {
-              instance.rectfill(x + col, y + row, 1, 1, parseInt(char, 36) || 0)
+              instance.rectfill(
+                x + col,
+                y + row,
+                1,
+                1,
+                parseInt(char, 36) || 0,
+              );
             }
           }
         }
@@ -721,224 +731,224 @@
         DEV: assert(
           isNumber(width) && width >= 1,
           loggerPrefix + "paint() 1st param must be a positive number",
-        )
+        );
         DEV: assert(
           isNumber(height) && height >= 1,
           loggerPrefix + "paint() 2nd param must be a positive number",
-        )
+        );
         DEV: assert(
           "function" === typeof callback,
           loggerPrefix + "paint() 3rd param must be a function",
-        )
+        );
         DEV: assert(
           (options && null == options.scale) || isNumber(options.scale),
           loggerPrefix + "paint() 4th param (options.scale) must be a number",
-        )
+        );
         DEV: assert(
           (options && null == options.canvas) ||
             options.canvas instanceof OffscreenCanvas,
           loggerPrefix +
             "paint() 4th param (options.canvas) must be an OffscreenCanvas",
-        )
+        );
         const canvas = options.canvas || new OffscreenCanvas(1, 1),
           scale = options.scale || 1,
-          currentContext = _ctx
-        canvas.width = width * scale
-        canvas.height = height * scale
-        _ctx = canvas.getContext("2d")
-        _ctx.scale(scale, scale)
-        callback(_ctx)
-        _ctx = currentContext
-        return canvas.transferToImageBitmap()
+          currentContext = _ctx;
+        canvas.width = width * scale;
+        canvas.height = height * scale;
+        _ctx = canvas.getContext("2d");
+        _ctx.scale(scale, scale);
+        callback(_ctx);
+        _ctx = currentContext;
+        return canvas.transferToImageBitmap();
       },
       ctx(context) {
         if (context) {
-          _ctx = context
+          _ctx = context;
         }
-        return _ctx
+        return _ctx;
       },
       push() {
-        _ctx.save()
+        _ctx.save();
       },
       pop() {
-        _ctx.restore()
+        _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",
-        )
-        _ctx.translate(~~x, ~~y)
+        );
+        _ctx.translate(~~x, ~~y);
       },
       scale(x, y) {
         DEV: assert(
           isNumber(x),
           loggerPrefix + "scale() 1st param must be a number",
-        )
+        );
         DEV: assert(
           null == y || isNumber(y),
           loggerPrefix + "scale() 2nd param must be a number",
-        )
-        _ctx.scale(x, y || x)
+        );
+        _ctx.scale(x, y || x);
       },
       rotate(radians) {
         DEV: assert(
           isNumber(radians),
           loggerPrefix + "rotate() 1st param must be a number",
-        )
-        _ctx.rotate(radians)
+        );
+        _ctx.rotate(radians);
       },
       alpha(value) {
         DEV: assert(
           isNumber(value),
           loggerPrefix + "alpha() 1st param must be a number",
-        )
-        _ctx.globalAlpha = instance.clamp(value, 0, 1)
+        );
+        _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",
-        )
-        _ctx.fillStyle = getColor(color)
-        _ctx.fill()
+        );
+        _ctx.fillStyle = getColor(color);
+        _ctx.fill();
       },
       stroke(color) {
         DEV: assert(
           null == color || (isNumber(color) && color >= 0),
           loggerPrefix + "stroke() 1st param must be a positive number or zero",
-        )
-        _ctx.strokeStyle = getColor(color)
-        _ctx.stroke()
+        );
+        _ctx.strokeStyle = getColor(color);
+        _ctx.stroke();
       },
       clip(callback) {
         DEV: assert(
           "function" === typeof callback,
           loggerPrefix + "clip() 1st param must be a function",
-        )
-        beginPath(_ctx)
-        callback(_ctx)
-        _ctx.clip()
+        );
+        beginPath(_ctx);
+        callback(_ctx);
+        _ctx.clip();
       },
       sfx(zzfxParams, pitchSlide = 0, volumeFactor = 1) {
         DEV: assert(
           null == zzfxParams || Array.isArray(zzfxParams),
           loggerPrefix + "sfx() 1st param must be an array",
-        )
+        );
         DEV: assert(
           isNumber(pitchSlide),
           loggerPrefix + "sfx() 2nd param must be a number",
-        )
+        );
         DEV: assert(
           isNumber(volumeFactor),
           loggerPrefix + "sfx() 3rd param must be a number",
-        )
+        );
         if (
           !root.zzfxV ||
           (navigator.userActivation && !navigator.userActivation.hasBeenActive)
         ) {
-          return false
+          return false;
         }
-        zzfxParams = zzfxParams || _defaultSound
+        zzfxParams = zzfxParams || _defaultSound;
         if (pitchSlide !== 0 || volumeFactor !== 1) {
-          zzfxParams = zzfxParams.slice()
-          zzfxParams[0] = volumeFactor * (zzfxParams[0] || 1)
-          zzfxParams[10] = ~~zzfxParams[10] + pitchSlide
+          zzfxParams = zzfxParams.slice();
+          zzfxParams[0] = volumeFactor * (zzfxParams[0] || 1);
+          zzfxParams[10] = ~~zzfxParams[10] + pitchSlide;
         }
-        zzfx.apply(0, zzfxParams)
-        return zzfxParams
+        zzfx.apply(0, zzfxParams);
+        return zzfxParams;
       },
       volume(value) {
         DEV: assert(
           isNumber(value) && value >= 0,
           loggerPrefix + "volume() 1st param must be a positive number or zero",
-        )
-        root.zzfxV = value
+        );
+        root.zzfxV = value;
       },
       canvas: () => _canvas,
       use(callback, config = {}) {
         DEV: assert(
           "function" === typeof callback,
           loggerPrefix + "use() 1st param must be a function",
-        )
+        );
         DEV: assert(
           "object" === typeof config,
           loggerPrefix + "use() 2nd param must be an object",
-        )
-        loadPlugin(callback, config)
+        );
+        loadPlugin(callback, config);
       },
       listen(eventName, callback) {
         DEV: assert(
           "string" === typeof eventName,
           loggerPrefix + "listen() 1st param must be a string",
-        )
+        );
         DEV: assert(
           "function" === typeof callback,
           loggerPrefix + "listen() 2nd param must be a function",
-        )
-        eventName = lowerCase(eventName)
-        _eventListeners[eventName] = _eventListeners[eventName] || new Set()
-        _eventListeners[eventName].add(callback)
-        return () => _eventListeners[eventName]?.delete(callback)
+        );
+        eventName = lowerCase(eventName);
+        _eventListeners[eventName] = _eventListeners[eventName] || new Set();
+        _eventListeners[eventName].add(callback);
+        return () => _eventListeners[eventName]?.delete(callback);
       },
       emit(eventName, arg1, arg2, arg3, arg4) {
         DEV: assert(
           "string" === typeof eventName,
           loggerPrefix + "emit() 1st param must be a string",
-        )
+        );
         if (_initialized) {
-          eventName = lowerCase(eventName)
-          triggerEvent("before:" + eventName, arg1, arg2, arg3, arg4)
-          triggerEvent(eventName, arg1, arg2, arg3, arg4)
-          triggerEvent("after:" + eventName, arg1, arg2, arg3, arg4)
+          eventName = lowerCase(eventName);
+          triggerEvent("before:" + eventName, arg1, arg2, arg3, arg4);
+          triggerEvent(eventName, arg1, arg2, arg3, arg4);
+          triggerEvent("after:" + eventName, arg1, arg2, arg3, arg4);
         }
       },
       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",
-        )
+        );
         DEV: assert(
           isNumber(textColor) && textColor >= 0,
           loggerPrefix + "pal() 2nd param must be a positive number or zero",
-        )
-        _colorPalette = colors || defaultPalette
-        _colorPaletteState = []
-        _defaultTextColor = textColor
+        );
+        _colorPalette = colors || defaultPalette;
+        _colorPaletteState = [];
+        _defaultTextColor = textColor;
       },
       palc(a, b) {
         DEV: assert(
           null == a || (isNumber(a) && a >= 0),
           loggerPrefix + "palc() 1st param must be a positive number",
-        )
+        );
         DEV: assert(
           isNumber(a) ? isNumber(b) && b >= 0 : null == b,
           loggerPrefix + "palc() 2nd param must be a positive number",
-        )
+        );
         if (a == null) {
-          _colorPaletteState = []
+          _colorPaletteState = [];
         } else {
-          _colorPaletteState[a] = b
+          _colorPaletteState[a] = b;
         }
       },
       def(key, value) {
         DEV: assert(
           "string" === typeof key,
           loggerPrefix + "def() 1st param must be a string",
-        )
+        );
         DEV: if (null == value) {
           console.warn(
             loggerPrefix +
               `def() changed the key "${key}" to null (previous value was ${instance[key]})`,
-          )
+          );
         }
-        instance[key] = value
+        instance[key] = value;
         if (settings.global) {
-          root[key] = value
+          root[key] = value;
         }
       },
       timescale(value) {
@@ -946,21 +956,21 @@
           isNumber(value) && value >= 0,
           loggerPrefix +
             "timescale() 1st param must be a positive number or zero",
-        )
-        _timeScale = value
+        );
+        _timeScale = value;
       },
       framerate(value) {
         DEV: assert(
           isNumber(value) && value >= 1,
           loggerPrefix + "framerate() 1st param must be a positive number",
-        )
-        _fpsInterval = 1e3 / ~~value
+        );
+        _fpsInterval = 1e3 / ~~value;
       },
       stat(index) {
         DEV: assert(
           isNumber(index) || "string" === typeof index,
           loggerPrefix + "stat() 1st param must be a number or string",
-        )
+        );
         const internals = [
           settings,
           _initialized,
@@ -976,56 +986,56 @@
           _fontFamily,
           _colorPaletteState,
           _fontLineHeight,
-        ]
-        const data = { index, value: internals[index] }
-        instance.emit("stat", data)
-        return data.value
+        ];
+        const data = { index, value: internals[index] };
+        instance.emit("stat", data);
+        return data.value;
       },
       pause() {
-        _paused = true
-        cancelAnimationFrame(_rafid)
+        _paused = true;
+        cancelAnimationFrame(_rafid);
       },
       resume() {
         DEV: assert(
           _initialized,
           loggerPrefix +
             'resume() cannot be called before the "init" event and neither after the quit() function',
-        )
+        );
         if (_initialized && _paused) {
-          _paused = false
-          _accumulated = _fpsInterval
-          _lastFrameTime = perf.now()
-          _rafid = raf(drawFrame)
+          _paused = false;
+          _accumulated = _fpsInterval;
+          _lastFrameTime = perf.now();
+          _rafid = raf(drawFrame);
         }
       },
       paused() {
-        return _paused
+        return _paused;
       },
       quit() {
-        instance.emit("quit")
-        instance.pause()
-        _initialized = false
-        _eventListeners = {}
+        instance.emit("quit");
+        instance.pause();
+        _initialized = false;
+        _eventListeners = {};
         for (const removeListener of _browserEventListeners) {
-          removeListener()
+          removeListener();
         }
         if (settings.global) {
           for (const key in instance) {
-            delete root[key]
+            delete root[key];
           }
-          delete root.ENGINE
+          delete root.ENGINE;
         }
         DEV: console.warn(
           loggerPrefix + "quit() terminated a Litecanvas instance.",
-        )
+        );
       },
-    }
+    };
     for (const k of _mathFunctions.split(",")) {
-      instance[k] = math[k]
+      instance[k] = math[k];
     }
     function init() {
       if (settings.autoscale) {
-        on(root, "resize", resizeCanvas)
+        on(root, "resize", resizeCanvas);
       }
       if (settings.tapEvents) {
         const _getXY = (ev) => [
@@ -1034,190 +1044,190 @@
           ],
           _taps = new Map(),
           _registerTap = (id, x, y) => {
-            const tap = { x, y, xi: x, yi: y, t: perf.now() }
-            _taps.set(id, tap)
-            return tap
+            const tap = { x, y, xi: x, yi: y, t: perf.now() };
+            _taps.set(id, tap);
+            return tap;
           },
           _updateTap = (id, x, y) => {
-            const tap = _taps.get(id) || _registerTap(id)
-            tap.x = x
-            tap.y = y
+            const tap = _taps.get(id) || _registerTap(id);
+            tap.x = x;
+            tap.y = y;
           },
-          _checkTapped = (tap) => tap && perf.now() - tap.t <= 300
-        let _pressingMouse = false
+          _checkTapped = (tap) => tap && perf.now() - tap.t <= 300;
+        let _pressingMouse = false;
         on(_canvas, "mousedown", (ev) => {
           if (ev.button === 0) {
-            preventDefault(ev)
-            const [x, y] = _getXY(ev)
-            instance.emit("tap", x, y, 0)
-            _registerTap(0, x, y)
-            _pressingMouse = true
+            preventDefault(ev);
+            const [x, y] = _getXY(ev);
+            instance.emit("tap", x, y, 0);
+            _registerTap(0, x, y);
+            _pressingMouse = true;
           }
-        })
+        });
         on(_canvas, "mouseup", (ev) => {
           if (ev.button === 0) {
-            preventDefault(ev)
-            const tap = _taps.get(0)
-            const [x, y] = _getXY(ev)
+            preventDefault(ev);
+            const tap = _taps.get(0);
+            const [x, y] = _getXY(ev);
             if (_checkTapped(tap)) {
-              instance.emit("tapped", tap.xi, tap.yi, 0)
+              instance.emit("tapped", tap.xi, tap.yi, 0);
             }
-            instance.emit("untap", x, y, 0)
-            _taps.delete(0)
-            _pressingMouse = false
+            instance.emit("untap", x, y, 0);
+            _taps.delete(0);
+            _pressingMouse = false;
           }
-        })
+        });
         on(root, "mousemove", (ev) => {
-          preventDefault(ev)
-          const [x, y] = _getXY(ev)
-          instance.def("MX", x)
-          instance.def("MY", y)
-          if (!_pressingMouse) return
-          instance.emit("tapping", x, y, 0)
-          _updateTap(0, x, y)
-        })
+          preventDefault(ev);
+          const [x, y] = _getXY(ev);
+          instance.def("MX", x);
+          instance.def("MY", y);
+          if (!_pressingMouse) return;
+          instance.emit("tapping", x, y, 0);
+          _updateTap(0, x, y);
+        });
         on(_canvas, "touchstart", (ev) => {
-          preventDefault(ev)
-          const touches = ev.changedTouches
+          preventDefault(ev);
+          const touches = ev.changedTouches;
           for (const touch of touches) {
-            const [x, y] = _getXY(touch)
-            instance.emit("tap", x, y, touch.identifier + 1)
-            _registerTap(touch.identifier + 1, x, y)
+            const [x, y] = _getXY(touch);
+            instance.emit("tap", x, y, touch.identifier + 1);
+            _registerTap(touch.identifier + 1, x, y);
           }
-        })
+        });
         on(_canvas, "touchmove", (ev) => {
-          preventDefault(ev)
-          const touches = ev.changedTouches
+          preventDefault(ev);
+          const touches = ev.changedTouches;
           for (const touch of touches) {
-            const [x, y] = _getXY(touch)
-            instance.emit("tapping", x, y, touch.identifier + 1)
-            _updateTap(touch.identifier + 1, x, y)
+            const [x, y] = _getXY(touch);
+            instance.emit("tapping", x, y, touch.identifier + 1);
+            _updateTap(touch.identifier + 1, x, y);
           }
-        })
+        });
         const _touchEndHandler = (ev) => {
-          preventDefault(ev)
-          const existing = []
+          preventDefault(ev);
+          const existing = [];
           if (ev.targetTouches.length > 0) {
             for (const touch of ev.targetTouches) {
-              existing.push(touch.identifier + 1)
+              existing.push(touch.identifier + 1);
             }
           }
           for (const [id, tap] of _taps) {
-            if (existing.includes(id)) continue
+            if (existing.includes(id)) continue;
             if (_checkTapped(tap)) {
-              instance.emit("tapped", tap.xi, tap.yi, id)
+              instance.emit("tapped", tap.xi, tap.yi, id);
             }
-            instance.emit("untap", tap.x, tap.y, id)
-            _taps.delete(id)
+            instance.emit("untap", tap.x, tap.y, id);
+            _taps.delete(id);
           }
-        }
-        on(_canvas, "touchend", _touchEndHandler)
-        on(_canvas, "touchcancel", _touchEndHandler)
+        };
+        on(_canvas, "touchend", _touchEndHandler);
+        on(_canvas, "touchcancel", _touchEndHandler);
         on(root, "blur", () => {
-          _pressingMouse = false
+          _pressingMouse = false;
           for (const [id, tap] of _taps) {
-            instance.emit("untap", tap.x, tap.y, id)
-            _taps.delete(id)
+            instance.emit("untap", tap.x, tap.y, id);
+            _taps.delete(id);
           }
-        })
+        });
       }
       if (settings.keyboardEvents) {
-        const _keysDown = new Set()
-        const _keysPress = new Set()
+        const _keysDown = new Set();
+        const _keysPress = new Set();
         const keyCheck = (keySet, key = "") => {
-          key = lowerCase(key)
+          key = lowerCase(key);
           return !key
             ? keySet.size > 0
-            : keySet.has("space" === key ? " " : key)
-        }
-        let _lastKey = ""
+            : keySet.has("space" === key ? " " : key);
+        };
+        let _lastKey = "";
         on(root, "keydown", (event) => {
-          const key = lowerCase(event.key)
+          const key = lowerCase(event.key);
           if (!_keysDown.has(key)) {
-            _keysDown.add(key)
-            _keysPress.add(key)
-            _lastKey = key === " " ? "space" : key
+            _keysDown.add(key);
+            _keysPress.add(key);
+            _lastKey = key === " " ? "space" : key;
           }
-        })
+        });
         on(root, "keyup", (event) => {
-          _keysDown.delete(lowerCase(event.key))
-        })
-        on(root, "blur", () => _keysDown.clear())
-        instance.listen("after:update", () => _keysPress.clear())
+          _keysDown.delete(lowerCase(event.key));
+        });
+        on(root, "blur", () => _keysDown.clear());
+        instance.listen("after:update", () => _keysPress.clear());
         instance.def("iskeydown", (key) => {
           DEV: assert(
             null == key || "string" === typeof key,
             loggerPrefix +
               "iskeydown() 1st param must be a string or undefined",
-          )
-          return keyCheck(_keysDown, key)
-        })
+          );
+          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",
-          )
-          return keyCheck(_keysPress, key)
-        })
-        instance.def("lastkey", () => _lastKey)
+          );
+          return keyCheck(_keysPress, key);
+        });
+        instance.def("lastkey", () => _lastKey);
       }
-      _initialized = true
-      instance.resume()
-      instance.emit("init", instance)
+      _initialized = true;
+      instance.resume();
+      instance.emit("init", instance);
     }
     function drawFrame() {
-      _rafid = raf(drawFrame)
-      let now = perf.now()
-      let updated = 0
-      let frameTime = now - _lastFrameTime
-      _lastFrameTime = now
-      _accumulated += frameTime < 100 ? frameTime : _fpsInterval
+      _rafid = raf(drawFrame);
+      let now = perf.now();
+      let updated = 0;
+      let frameTime = now - _lastFrameTime;
+      _lastFrameTime = now;
+      _accumulated += frameTime < 100 ? frameTime : _fpsInterval;
       while (_accumulated >= _fpsInterval) {
-        updated++
-        _accumulated -= _fpsInterval
-        let dt = (_fpsInterval / 1e3) * _timeScale
-        instance.emit("update", dt, updated)
-        instance.def("T", instance.T + dt)
+        updated++;
+        _accumulated -= _fpsInterval;
+        let dt = (_fpsInterval / 1e3) * _timeScale;
+        instance.emit("update", dt, updated);
+        instance.def("T", instance.T + dt);
       }
       if (updated) {
-        instance.emit("draw", _ctx)
+        instance.emit("draw", _ctx);
         if (updated > 1) {
-          _accumulated = 0
+          _accumulated = 0;
           DEV: console.warn(
             loggerPrefix +
               "the last frame updated " +
               updated +
               " times. This can drop the FPS if it keeps happening.",
-          )
+          );
         }
       }
     }
     function setupCanvas() {
       if ("string" === typeof settings.canvas) {
-        _canvas = document.querySelector(settings.canvas)
+        _canvas = document.querySelector(settings.canvas);
         DEV: assert(
           null != _canvas,
           loggerPrefix +
             'litecanvas() option "canvas" is an invalid CSS selector',
-        )
+        );
       } else {
-        _canvas = settings.canvas
+        _canvas = settings.canvas;
       }
-      _canvas = _canvas || document.createElement("canvas")
+      _canvas = _canvas || document.createElement("canvas");
       DEV: assert(
         "CANVAS" === _canvas.tagName,
         loggerPrefix +
           'litecanvas() option "canvas" should be a canvas element or string (CSS selector)',
-      )
-      _ctx = _canvas.getContext("2d")
-      on(_canvas, "click", () => focus())
-      resizeCanvas()
+      );
+      _ctx = _canvas.getContext("2d");
+      on(_canvas, "click", () => focus());
+      resizeCanvas();
       if (!_canvas.parentNode) {
-        document.body.appendChild(_canvas)
+        document.body.appendChild(_canvas);
       }
-      _canvas.style.imageRendering = "pixelated"
-      _canvas.oncontextmenu = () => false
+      _canvas.style.imageRendering = "pixelated";
+      _canvas.oncontextmenu = () => false;
     }
     function resizeCanvas() {
       DEV: assert(
@@ -1225,85 +1235,85 @@
           (isNumber(settings.width) && settings.width > 0),
         loggerPrefix +
           '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',
-      )
+      );
       DEV: assert(
         null == settings.height || (settings.width > 0 && settings.height > 0),
         loggerPrefix +
           'litecanvas() option "width" is required when the option "height" is defined',
-      )
+      );
       const width = settings.width > 0 ? settings.width : innerWidth,
         height =
-          settings.width > 0 ? settings.height || settings.width : innerHeight
-      instance.def("W", width)
-      instance.def("H", height)
-      _canvas.width = width
-      _canvas.height = height
+          settings.width > 0 ? settings.height || settings.width : innerHeight;
+      instance.def("W", width);
+      instance.def("H", height);
+      _canvas.width = width;
+      _canvas.height = height;
       if (settings.autoscale) {
-        let maxScale = +settings.autoscale
+        let maxScale = +settings.autoscale;
         if (!_canvas.style.display) {
-          _canvas.style.display = "block"
-          _canvas.style.margin = "auto"
+          _canvas.style.display = "block";
+          _canvas.style.margin = "auto";
         }
-        _canvasScale = math.min(innerWidth / width, innerHeight / height)
+        _canvasScale = math.min(innerWidth / width, innerHeight / height);
         _canvasScale =
-          maxScale > 1 && _canvasScale > maxScale ? maxScale : _canvasScale
-        _canvas.style.width = width * _canvasScale + "px"
-        _canvas.style.height = height * _canvasScale + "px"
+          maxScale > 1 && _canvasScale > maxScale ? maxScale : _canvasScale;
+        _canvas.style.width = width * _canvasScale + "px";
+        _canvas.style.height = height * _canvasScale + "px";
       }
-      _ctx.imageSmoothingEnabled = false
-      instance.textalign("start", "top")
-      instance.emit("resized", _canvasScale)
+      _ctx.imageSmoothingEnabled = false;
+      instance.textalign("start", "top");
+      instance.emit("resized", _canvasScale);
     }
     function triggerEvent(eventName, arg1, arg2, arg3, arg4) {
-      if (!_eventListeners[eventName]) return
+      if (!_eventListeners[eventName]) return;
       for (const callback of _eventListeners[eventName]) {
-        callback(arg1, arg2, arg3, arg4)
+        callback(arg1, arg2, arg3, arg4);
       }
     }
     function loadPlugin(callback, config) {
-      const pluginData = callback(instance, config)
+      const pluginData = callback(instance, config);
       DEV: assert(
         null == pluginData || "object" === typeof pluginData,
         loggerPrefix +
           "litecanvas() plugins should return an object or nothing",
-      )
+      );
       for (const key in pluginData) {
-        instance.def(key, pluginData[key])
+        instance.def(key, pluginData[key]);
       }
     }
     function getColor(index) {
-      const i = _colorPaletteState[index] ?? index
-      return _colorPalette[~~i % _colorPalette.length]
+      const i = _colorPaletteState[index] ?? index;
+      return _colorPalette[~~i % _colorPalette.length];
     }
     if (settings.global) {
       if (root.ENGINE) {
-        throw new Error("only one global litecanvas is allowed")
+        throw new Error("only one global litecanvas is allowed");
       }
-      Object.assign(root, instance)
-      root.ENGINE = instance
+      Object.assign(root, instance);
+      root.ENGINE = instance;
     }
-    DEV: console.info(loggerPrefix + `version ${version} started`)
-    DEV: console.debug(loggerPrefix + `litecanvas() options =`, settings)
-    setupCanvas()
-    const source = settings.loop ? settings.loop : root
+    DEV: console.info(loggerPrefix + `version ${version} started`);
+    DEV: console.debug(loggerPrefix + `litecanvas() options =`, settings);
+    setupCanvas();
+    const source = settings.loop ? settings.loop : root;
     for (const event of _coreEvents.split(",")) {
       DEV: if (root === source && source[event]) {
-        console.info(loggerPrefix + `using window.${event}()`)
+        console.info(loggerPrefix + `using window.${event}()`);
       }
-      if (source[event]) instance.listen(event, source[event])
+      if (source[event]) instance.listen(event, source[event]);
     }
     if ("loading" === document.readyState) {
-      on(root, "DOMContentLoaded", () => raf(init))
+      on(root, "DOMContentLoaded", () => raf(init));
     } else {
-      _rafid = raf(init)
+      _rafid = raf(init);
     }
-    return instance
+    return instance;
   }
-  window.litecanvas = litecanvas
-})()
+  window.litecanvas = litecanvas;
+})();