litecanvas 0.83.0 → 0.83.2

package/src/index.js

@@ -20,9 +20,7 @@ export default function litecanvas(settings = {}) {
         /** @type {(elem:HTMLElement, evt:string, callback:(event:Event)=>void)=>void} */
         on = (elem, evt, callback) => {
             elem.addEventListener(evt, callback, false)
-            _browserEventListeners.push(() =>
-                elem.removeEventListener(evt, callback, false)
-            )
+            _browserEventListeners.push(() => elem.removeEventListener(evt, callback, false))
         },
         isNumber = Number.isFinite,
         /** @type {LitecanvasOptions} */
@@ -135,7 +133,7 @@ export default function litecanvas(settings = {}) {
          *
          * @type {number}
          */
-        HALF_PI: math.PI / 2,
+        HALF_PI: TWO_PI / 4,
 
         /**
          * Calculates a linear (interpolation) value over t%.
@@ -212,10 +210,7 @@ export default function litecanvas(settings = {}) {
             DEV: assert(isNumber(value), 'clamp: 1st param must be a number')
             DEV: assert(isNumber(min), 'clamp: 2nd param must be a number')
             DEV: assert(isNumber(max), 'clamp: 3rd param must be a number')
-            DEV: assert(
-                max > min,
-                'randi: the 2nd param must be less than the 3rd param'
-            )
+            DEV: assert(max > min, 'clamp: the 2nd param must be less than the 3rd param')
 
             if (value < min) return min
             if (value > max) return max
@@ -234,14 +229,7 @@ export default function litecanvas(settings = {}) {
             DEV: assert(isNumber(value), 'wrap: 1st param must be a number')
             DEV: assert(isNumber(min), 'wrap: 2nd param must be a number')
             DEV: assert(isNumber(max), 'wrap: 3rd param must be a number')
-            DEV: assert(
-                max > min,
-                'randi: the 2nd param must be less than the 3rd param'
-            )
-            DEV: assert(
-                max !== min,
-                'randi: the 2nd param must be not equal to the 3rd param'
-            )
+            DEV: assert(max > min, 'wrap: the 2nd param must be less than the 3rd param')
 
             return value - (max - min) * math.floor((value - min) / (max - min))
         },
@@ -263,6 +251,7 @@ export default function litecanvas(settings = {}) {
             DEV: assert(isNumber(stop1), 'map: 3rd param must be a number')
             DEV: assert(isNumber(start2), 'map: 4th param must be a number')
             DEV: assert(isNumber(stop2), 'map: 5th param must be a number')
+            DEV: assert(max !== min, 'map: the 3rd param must be different than the 2nd param')
 
             // prettier-ignore
             const result = ((value - start1) / (stop1 - start1)) * (stop2 - start2) + start2
@@ -292,11 +281,19 @@ export default function litecanvas(settings = {}) {
          *
          * @param {number} from - the lower bound
          * @param {number} to - the higher bound
-         * @param {number} t - the amount
-         * @param {(n: number) => number} fn - the periodic function (which default to `Math.sin`)
+         * @param {number} t - value passed to the periodic function
+         * @param {(n: number) => number} [fn] - the periodic function (which default to `Math.sin`)
          */
-        wave: (from, to, t, fn = Math.sin) =>
-            from + ((fn(t) + 1) / 2) * (to - from),
+        wave: (from, to, t, fn = Math.sin) => {
+            DEV: assert(isNumber(from), 'wave: 1st param must be a number')
+            DEV: assert(isNumber(to), 'wave: 2nd param must be a number')
+            DEV: assert(isNumber(t), 'wave: 3rd param must be a number')
+            DEV: assert(
+                'function' === typeof fn,
+                'wave: 4rd param must be a function (n: number) => number'
+            )
+            return from + ((fn(t) + 1) / 2) * (to - from)
+        },
 
         /** RNG API */
         /**
@@ -310,10 +307,7 @@ export default function litecanvas(settings = {}) {
         rand: (min = 0.0, max = 1.0) => {
             DEV: assert(isNumber(min), 'rand: 1st param must be a number')
             DEV: assert(isNumber(max), 'rand: 2nd param must be a number')
-            DEV: assert(
-                max > min,
-                'rand: the 1st param must be less than the 2nd param'
-            )
+            DEV: assert(max > min, 'rand: the 1st param must be less than the 2nd param')
 
             const a = 1664525
             const c = 1013904223
@@ -334,10 +328,7 @@ export default function litecanvas(settings = {}) {
         randi: (min = 0, max = 1) => {
             DEV: assert(isNumber(min), 'randi: 1st param must be a number')
             DEV: assert(isNumber(max), 'randi: 2nd param must be a number')
-            DEV: assert(
-                max > min,
-                'randi: the 1st param must be less than the 2nd param'
-            )
+            DEV: assert(max > min, 'randi: the 1st param must be less than the 2nd param')
 
             return math.floor(instance.rand(min, max + 1))
         },
@@ -373,13 +364,7 @@ export default function litecanvas(settings = {}) {
             if (null == color) {
                 _ctx.clearRect(0, 0, _ctx.canvas.width, _ctx.canvas.height)
             } else {
-                instance.rectfill(
-                    0,
-                    0,
-                    _ctx.canvas.width,
-                    _ctx.canvas.height,
-                    color
-                )
+                instance.rectfill(0, 0, _ctx.canvas.width, _ctx.canvas.height, color)
             }
         },
 
@@ -392,14 +377,13 @@ export default function litecanvas(settings = {}) {
          * @param {number} height
          * @param {number} [color=0] the color index
          * @param {number|number[]} [radii] A number or list specifying the radii used to draw a rounded-borders rectangle
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/roundRect
          */
         rect(x, y, width, height, color, radii) {
             DEV: assert(isNumber(x), 'rect: 1st param must be a number')
             DEV: assert(isNumber(y), 'rect: 2nd param must be a number')
-            DEV: assert(
-                isNumber(width) && width > 0,
-                'rect: 3rd param must be a positive number'
-            )
+            DEV: assert(isNumber(width) && width > 0, 'rect: 3rd param must be a positive number')
             DEV: assert(
                 isNumber(height) && height >= 0,
                 'rect: 4th param must be a positive number or zero'
@@ -409,9 +393,7 @@ export default function litecanvas(settings = {}) {
                 'rect: 5th param must be a positive number or zero'
             )
             DEV: assert(
-                null == radii ||
-                    isNumber(radii) ||
-                    (Array.isArray(radii) && radii.length >= 1),
+                null == radii || isNumber(radii) || (Array.isArray(radii) && radii.length >= 1),
                 'rect: 6th param must be a number or array of numbers'
             )
 
@@ -452,20 +434,12 @@ export default function litecanvas(settings = {}) {
                 'rectfill: 5th param must be a positive number or zero'
             )
             DEV: assert(
-                null == radii ||
-                    isNumber(radii) ||
-                    (Array.isArray(radii) && radii.length >= 1),
+                null == radii || isNumber(radii) || (Array.isArray(radii) && radii.length >= 1),
                 'rectfill: 6th param must be a number or array of at least 2 numbers'
             )
 
             _ctx.beginPath()
-            _ctx[radii ? 'roundRect' : 'rect'](
-                ~~x,
-                ~~y,
-                ~~width,
-                ~~height,
-                radii
-            )
+            _ctx[radii ? 'roundRect' : 'rect'](~~x, ~~y, ~~width, ~~height, radii)
             instance.fill(color)
         },
 
@@ -531,14 +505,8 @@ export default function litecanvas(settings = {}) {
         line(x1, y1, x2, y2, color) {
             DEV: assert(isNumber(x1), 'line: 1st param must be a number')
             DEV: assert(isNumber(y1), 'line: 2nd param must be a number')
-            DEV: assert(
-                isNumber(x2),
-                'line: 3rd param must be a positive number or zero'
-            )
-            DEV: assert(
-                isNumber(y2),
-                'line: 4th param must be a positive number or zero'
-            )
+            DEV: assert(isNumber(x2), 'line: 3rd param must be a positive number or zero')
+            DEV: assert(isNumber(y2), 'line: 4th param must be a positive number or zero')
             DEV: assert(
                 null == color || (isNumber(color) && color >= 0),
                 'line: 5th param must be a positive number or zero'
@@ -584,10 +552,7 @@ export default function litecanvas(settings = {}) {
                 Array.isArray(segments) && segments.length > 0,
                 'linedash: 1st param must be an array of numbers'
             )
-            DEV: assert(
-                isNumber(offset),
-                'linedash: 2nd param must be a number'
-            )
+            DEV: assert(isNumber(offset), 'linedash: 2nd param must be a number')
 
             _ctx.setLineDash(segments)
             _ctx.lineDashOffset = offset
@@ -610,10 +575,7 @@ export default function litecanvas(settings = {}) {
                 null == color || (isNumber(color) && color >= 0),
                 'text: 4th param must be a positive number or zero'
             )
-            DEV: assert(
-                'string' === typeof fontStyle,
-                'text: 5th param must be a string'
-            )
+            DEV: assert('string' === typeof fontStyle, 'text: 5th param must be a string')
 
             _ctx.font = `${fontStyle} ${_fontSize}px ${_fontFamily}`
             _ctx.fillStyle = _colors[~~color % _colors.length]
@@ -626,10 +588,7 @@ export default function litecanvas(settings = {}) {
          * @param {string} family
          */
         textfont(family) {
-            DEV: assert(
-                'string' === typeof family,
-                'textfont: 1st param must be a string'
-            )
+            DEV: assert('string' === typeof family, 'textfont: 1st param must be a string')
 
             _fontFamily = family
         },
@@ -655,20 +614,14 @@ export default function litecanvas(settings = {}) {
          */
         textalign(align, baseline) {
             DEV: assert(
-                null == align ||
-                    ['left', 'right', 'center', 'start', 'end'].includes(align),
+                null == align || ['left', 'right', 'center', 'start', 'end'].includes(align),
                 'textalign: 1st param must be null or one of the following strings: center, left, right, start or end.'
             )
             DEV: assert(
                 null == baseline ||
-                    [
-                        'top',
-                        'bottom',
-                        'middle',
-                        'hanging',
-                        'alphabetic',
-                        'ideographic',
-                    ].includes(baseline),
+                    ['top', 'bottom', 'middle', 'hanging', 'alphabetic', 'ideographic'].includes(
+                        baseline
+                    ),
                 'textalign: 2nd param must be null or one of the following strings: middle, top, bottom, hanging, alphabetic or ideographic.'
             )
 
@@ -806,10 +759,7 @@ export default function litecanvas(settings = {}) {
          */
         scale: (x, y) => {
             DEV: assert(isNumber(x), 'scale: 1st param must be a number')
-            DEV: assert(
-                null == y || isNumber(y),
-                'scale: 2nd param must be a number'
-            )
+            DEV: assert(null == y || isNumber(y), 'scale: 2nd param must be a number')
 
             return _ctx.scale(x, y || x)
         },
@@ -906,14 +856,13 @@ export default function litecanvas(settings = {}) {
         /**
          * Turn given path into a clipping region.
          *
+         * Note: always call `push()` before and `pop()` after.
+         *
          * @param {Path2D} path
          * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/clip
          */
         clip(path) {
-            DEV: assert(
-                path instanceof Path2D,
-                'clip: 1st param must be a Path2D instance'
-            )
+            DEV: assert(path instanceof Path2D, 'clip: 1st param must be a Path2D instance')
 
             _ctx.clip(path)
         },
@@ -936,15 +885,11 @@ export default function litecanvas(settings = {}) {
                 'sfx: 1st param must be an array'
             )
             DEV: assert(isNumber(pitchSlide), 'sfx: 2nd param must be a number')
-            DEV: assert(
-                isNumber(volumeFactor),
-                'sfx: 3rd param must be a number'
-            )
+            DEV: assert(isNumber(volumeFactor), 'sfx: 3rd param must be a number')
 
             if (
                 root.zzfxV <= 0 ||
-                (navigator.userActivation &&
-                    !navigator.userActivation.hasBeenActive)
+                (navigator.userActivation && !navigator.userActivation.hasBeenActive)
             ) {
                 return false
             }
@@ -982,18 +927,16 @@ export default function litecanvas(settings = {}) {
          * @param {pluginCallback} callback
          */
         use(callback, config = {}) {
-            DEV: assert(
-                'function' === typeof callback,
-                'use: 1st param must be a function'
-            )
-            DEV: assert(
-                'object' === typeof config,
-                'use: 2nd param must be an object'
-            )
+            DEV: assert('function' === typeof callback, 'use: 1st param must be a function')
+            DEV: assert('object' === typeof config, 'use: 2nd param must be an object')
 
-            _initialized
-                ? loadPlugin(callback, config)
-                : _plugins.push([callback, config])
+            if (_initialized) {
+                // load the plugin now
+                loadPlugin(callback, config)
+            } else {
+                // schedule to load the plugin right before the "init" event
+                _plugins.push([callback, config])
+            }
         },
 
         /**
@@ -1004,14 +947,8 @@ export default function litecanvas(settings = {}) {
          * @returns {Function} a function to remove the listener
          */
         listen(eventName, callback) {
-            DEV: assert(
-                'string' === typeof eventName,
-                'listen: 1st param must be a string'
-            )
-            DEV: assert(
-                'function' === typeof callback,
-                'listen: 2nd param must be a function'
-            )
+            DEV: assert('string' === typeof eventName, 'listen: 1st param must be a string')
+            DEV: assert('function' === typeof callback, 'listen: 2nd param must be a function')
 
             eventName = eventName.toLowerCase()
 
@@ -1032,10 +969,7 @@ export default function litecanvas(settings = {}) {
          * @param {*} [arg4] any data to be passed over the listeners
          */
         emit(eventName, arg1, arg2, arg3, arg4) {
-            DEV: assert(
-                'string' === typeof eventName,
-                'emit: 1st param must be a string'
-            )
+            DEV: assert('string' === typeof eventName, 'emit: 1st param must be a string')
             if (_initialized) {
                 eventName = eventName.toLowerCase()
 
@@ -1065,14 +999,9 @@ export default function litecanvas(settings = {}) {
          * @param {*} value
          */
         def(key, value) {
-            DEV: assert(
-                'string' === typeof key,
-                'def: 1st param must be a string'
-            )
+            DEV: assert('string' === typeof key, 'def: 1st param must be a string')
             DEV: if (null == value) {
-                console.warn(
-                    `def: key "${key}" was defined as ${value} but now is null`
-                )
+                console.warn(`def: key "${key}" was defined as ${value} but now is null`)
             }
 
             instance[key] = value
@@ -1118,10 +1047,7 @@ export default function litecanvas(settings = {}) {
          * @returns {any}
          */
         stat(n) {
-            DEV: assert(
-                isNumber(n) && n >= 0,
-                'stat: 1st param must be a positive number'
-            )
+            DEV: assert(isNumber(n) && n >= 0, 'stat: 1st param must be a positive number')
 
             const list = [
                 // 0
@@ -1213,30 +1139,50 @@ export default function litecanvas(settings = {}) {
 
         // default mouse/touch handlers
         if (settings.tapEvents) {
-            const _getXY = (pageX, pageY) => [
-                    (pageX - _canvas.offsetLeft) / _scale,
-                    (pageY - _canvas.offsetTop) / _scale,
-                ],
+            const _getXY =
+                    /**
+                     * @param {number} pageX
+                     * @param {number} pageY
+                     */
+                    (pageX, pageY) => [
+                        (pageX - _canvas.offsetLeft) / _scale,
+                        (pageY - _canvas.offsetTop) / _scale,
+                    ],
                 _taps = new Map(),
-                _registerTap = (id, x, y) => {
-                    const tap = {
-                        x,
-                        y,
-                        startX: x,
-                        startY: y,
-                        // timestamp
-                        ts: performance.now(),
-                    }
-                    _taps.set(id, tap)
-                    return tap
-                },
-                _updateTap = (id, x, y) => {
-                    const tap = _taps.get(id) || _registerTap(id)
-                    tap.x = x
-                    tap.y = y
-                },
-                _checkTapped = (tap) =>
-                    tap && performance.now() - tap.ts <= 300,
+                _registerTap =
+                    /**
+                     * @param {number} id
+                     * @param {number} [x]
+                     * @param {number} [y]
+                     */
+                    (id, x, y) => {
+                        const tap = {
+                            x,
+                            y,
+                            startX: x,
+                            startY: y,
+                            // timestamp
+                            ts: performance.now(),
+                        }
+                        _taps.set(id, tap)
+                        return tap
+                    },
+                _updateTap =
+                    /**
+                     * @param {number} id
+                     * @param {number} x
+                     * @param {number} y
+                     */
+                    (id, x, y) => {
+                        const tap = _taps.get(id) || _registerTap(id)
+                        tap.x = x
+                        tap.y = y
+                    },
+                _checkTapped =
+                    /**
+                     * @param {{ts: number}} tap
+                     */
+                    (tap) => tap && performance.now() - tap.ts <= 300,
                 preventDefault = (ev) => ev.preventDefault()
 
             let _pressingMouse = false
@@ -1384,9 +1330,7 @@ export default function litecanvas(settings = {}) {
              */
             const keyCheck = (keySet, key = '') => {
                 key = key.toLowerCase()
-                return !key
-                    ? keySet.size > 0
-                    : keySet.has('space' === key ? ' ' : key)
+                return !key ? keySet.size > 0 : keySet.has('space' === key ? ' ' : key)
             }
 
             // @ts-ignore
@@ -1505,10 +1449,7 @@ export default function litecanvas(settings = {}) {
 
         _canvas = _canvas || document.createElement('canvas')
 
-        DEV: assert(
-            _canvas && _canvas.tagName === 'CANVAS',
-            'Invalid canvas element'
-        )
+        DEV: assert(_canvas && _canvas.tagName === 'CANVAS', 'Invalid canvas element')
 
         instance.def('CANVAS', _canvas)
         _ctx = _canvas.getContext('2d')
@@ -1527,18 +1468,15 @@ export default function litecanvas(settings = {}) {
 
     function resizeCanvas() {
         DEV: assert(
-            null == settings.width ||
-                (isNumber(settings.width) && settings.width > 0),
+            null == settings.width || (isNumber(settings.width) && settings.width > 0),
             'Litecanvas\' option "width" should be a positive number when defined'
         )
         DEV: assert(
-            null == settings.height ||
-                (isNumber(settings.height) && settings.height > 0),
+            null == settings.height || (isNumber(settings.height) && settings.height > 0),
             'Litecanvas\' option "height" should be a positive number when defined'
         )
         DEV: assert(
-            null == settings.height ||
-                (settings.width > 0 && settings.height > 0),
+            null == settings.height || (settings.width > 0 && settings.height > 0),
             'Litecanvas\' option "width" is required when the option "height" is defined'
         )
 
@@ -1557,10 +1495,7 @@ export default function litecanvas(settings = {}) {
                 _canvas.style.margin = 'auto'
             }
 
-            _scale = math.min(
-                root.innerWidth / instance.W,
-                root.innerHeight / instance.H
-            )
+            _scale = math.min(root.innerWidth / instance.W, root.innerHeight / instance.H)
             _scale = (settings.pixelart ? ~~_scale : _scale) || 1
 
             _canvas.style.width = instance.W * _scale + 'px'

package/types/index.d.ts

@@ -3,9 +3,7 @@ import './types.d.ts'
 /**
  * The litecanvas constructor
  */
-export default function litecanvas(
-    settings?: LitecanvasOptions
-): LitecanvasInstance
+export default function litecanvas(settings?: LitecanvasOptions): LitecanvasInstance
 
 declare global {
     function litecanvas(settings?: LitecanvasOptions): LitecanvasInstance
@@ -131,15 +129,10 @@ declare global {
      *
      * @param from - the lower bound
      * @param to - the higher bound
-     * @param t - the amount
-     * @param fn - the periodic function (which default to `Math.sin`)
-     */
-    function wave(
-        from: number,
-        to: number,
-        t: number,
-        fn?: (n: number) => number
-    ): number
+     * @param t - the value passed to the periodic function
+     * @param fn= - the periodic function (which default to `Math.sin`)
+     */
+    function wave(from: number, to: number, t: number, fn?: (n: number) => number): number
     /**
      * Returns the sine of a number in radians
      */
@@ -249,6 +242,8 @@ declare global {
      * @param height
      * @param [color=0] the color index
      * @param [radii] A number or list specifying the radii used to draw a rounded-borders rectangle
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/roundRect
      */
     function rect(
         x: number,
@@ -293,12 +288,7 @@ declare global {
      * @param radius
      * @param [color=0] the color index
      */
-    function circfill(
-        x: number,
-        y: number,
-        radius: number,
-        color?: number
-    ): void
+    function circfill(x: number, y: number, radius: number, color?: number): void
     /**
      * Draw a line
      *
@@ -308,13 +298,7 @@ declare global {
      * @param y2
      * @param [color=0] the color index
      */
-    function line(
-        x1: number,
-        y1: number,
-        x2: number,
-        y2: number,
-        color?: number
-    ): void
+    function line(x1: number, y1: number, x2: number, y2: number, color?: number): void
     /**
      * Sets the thickness of lines
      *
@@ -342,13 +326,7 @@ declare global {
      * @param [color=3] the color index
      * @param [fontStyle="normal"] can be "normal" (default), "italic" and/or "bold"
      */
-    function text(
-        x: number,
-        y: number,
-        message: string,
-        color?: number,
-        fontStyle?: string
-    ): void
+    function text(x: number, y: number, message: string, color?: number, fontStyle?: string): void
     /**
      * Set the font family
      *
@@ -369,10 +347,7 @@ declare global {
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/textBaseline
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/textAlign
      */
-    function textalign(
-        align: CanvasTextAlign,
-        baseline: CanvasTextBaseline
-    ): void
+    function textalign(align: CanvasTextAlign, baseline: CanvasTextBaseline): void
 
     /** IMAGE GRAPHICS API */
     /**
@@ -552,13 +527,7 @@ declare global {
      * @param [arg3] any data to be passed over the listeners
      * @param [arg4] any data to be passed over the listeners
      */
-    function emit(
-        event: string,
-        arg1?: any,
-        arg2?: any,
-        arg3?: any,
-        arg4?: any
-    ): void
+    function emit(event: string, arg1?: any, arg2?: any, arg3?: any, arg4?: any): void
     /**
      * Set or reset the color palette
      *

package/types/types.d.ts

@@ -120,15 +120,10 @@ type LitecanvasInstance = {
      *
      * @param from - the lower bound
      * @param to - the higher bound
-     * @param t - the amount
+     * @param t - the value passed to the periodic function
      * @param fn - the periodic function (which default to `Math.sin`)
      */
-    wave(
-        from: number,
-        to: number,
-        t: number,
-        fn?: (n: number) => number
-    ): number
+    wave(from: number, to: number, t: number, fn?: (n: number) => number): number
     /**
      * Returns the sine of a number in radians
      */
@@ -238,6 +233,8 @@ type LitecanvasInstance = {
      * @param height
      * @param [color=0] the color index
      * @param [radii] A number or list specifying the radii used to draw a rounded-borders rectangle
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/roundRect
      */
     rect(
         x: number,
@@ -320,13 +317,7 @@ type LitecanvasInstance = {
      * @param [color=3] the color index
      * @param [fontStyle="normal"] can be "normal" (default), "italic" and/or "bold"
      */
-    text(
-        x: number,
-        y: number,
-        message: string,
-        color?: number,
-        fontStyle?: string
-    ): void
+    text(x: number, y: number, message: string, color?: number, fontStyle?: string): void
     /**
      * Set the font family
      *
@@ -472,11 +463,7 @@ type LitecanvasInstance = {
      *
      * @see https://github.com/KilledByAPixel/ZzFX
      */
-    sfx(
-        zzfxParams?: number[],
-        pitchSlide?: number,
-        volumeFactor?: number
-    ): number[] | boolean
+    sfx(zzfxParams?: number[], pitchSlide?: number, volumeFactor?: number): number[] | boolean
     /**
      * Set the ZzFX's global volume factor.
      * Note: use 0 to mute all sound effects.
@@ -660,8 +647,6 @@ type LitecanvasGameLoop = {
     tapping?: (tapX: number, tapY: number, tapId: number) => void
 }
 
-type drawCallback = (
-    context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D
-) => void
+type drawCallback = (context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D) => void
 
 type pluginCallback = (instance: LitecanvasInstance, config?: any) => any