@thi.ng/shader-ast-js 1.0.26 → 1.0.28

package/env.js

@@ -5,7 +5,14 @@ import { ZERO3, ZERO4 } from "@thi.ng/vectors/api";
 import { fromBVec2, fromBVec3, fromBVec4 } from "@thi.ng/vectors/convert";
 import { setVN3, setVN4 } from "@thi.ng/vectors/setvn";
 import { setVV4 } from "@thi.ng/vectors/setvv";
-import { setSwizzle2, setSwizzle3, setSwizzle4, swizzle2, swizzle3, swizzle4, } from "@thi.ng/vectors/swizzle";
+import {
+  setSwizzle2,
+  setSwizzle3,
+  setSwizzle4,
+  swizzle2,
+  swizzle3,
+  swizzle4
+} from "@thi.ng/vectors/swizzle";
 import { BVEC2, BVEC3, BVEC4 } from "./env/bvec.js";
 import { FLOAT } from "./env/float.js";
 import { INT } from "./env/int.js";
@@ -22,7 +29,17 @@ import { UVEC4 } from "./env/uvec4.js";
 import { VEC2 } from "./env/vec2.js";
 import { VEC3 } from "./env/vec3.js";
 import { VEC4 } from "./env/vec4.js";
-import { POOL_IVEC2, POOL_IVEC3, POOL_IVEC4, POOL_UVEC2, POOL_UVEC3, POOL_UVEC4, POOL_VEC2, POOL_VEC3, POOL_VEC4, } from "./pool.js";
+import {
+  POOL_IVEC2,
+  POOL_IVEC3,
+  POOL_IVEC4,
+  POOL_UVEC2,
+  POOL_UVEC3,
+  POOL_UVEC4,
+  POOL_VEC2,
+  POOL_VEC3,
+  POOL_VEC4
+} from "./pool.js";
 const { next: $2, uniform: $n2 } = POOL_VEC2;
 const { next: $3, uniform: $n3 } = POOL_VEC3;
 const { next: $4, uniform: $n4 } = POOL_VEC4;
@@ -32,100 +49,101 @@ const { next: $i4, uniform: $ni4 } = POOL_IVEC4;
 const { next: $u2, uniform: $nu2 } = POOL_UVEC2;
 const { next: $u3, uniform: $nu3 } = POOL_UVEC3;
 const { next: $u4, uniform: $nu4 } = POOL_UVEC4;
-// TODO texture lookups
-// all texture fns currently return [0,0,0,0] or 0
 const SAMPLER_TODO = {
-    texelFetch: () => ZERO4,
-    texelFetchOffset: () => ZERO4,
-    texture: () => ZERO4,
-    texturen: () => 0,
-    textureGrad: () => ZERO4,
-    textureGradn: () => 0,
-    textureLod: () => ZERO4,
-    textureLodn: () => 0,
-    textureOffset: () => ZERO4,
-    textureOffsetn: () => 0,
-    textureProj: () => ZERO4,
-    textureProjn: () => 0,
-    textureSize: () => ZERO3,
+  texelFetch: () => ZERO4,
+  texelFetchOffset: () => ZERO4,
+  texture: () => ZERO4,
+  texturen: () => 0,
+  textureGrad: () => ZERO4,
+  textureGradn: () => 0,
+  textureLod: () => ZERO4,
+  textureLodn: () => 0,
+  textureOffset: () => ZERO4,
+  textureOffsetn: () => 0,
+  textureProj: () => ZERO4,
+  textureProjn: () => 0,
+  textureSize: () => ZERO3
 };
-export const JS_DEFAULT_ENV = {
-    vec2: VEC2(POOL_VEC2),
-    vec2b: (v) => fromBVec2($2(), v),
-    vec2i: identity,
-    vec2n: $n2,
-    vec2u: identity,
-    vec3: VEC3(POOL_VEC3),
-    vec3b: (v) => fromBVec3($3(), v),
-    vec3i: identity,
-    vec3n: $n3,
-    vec3u: identity,
-    vec3vn: (a, n) => setVN3($3(), a, n),
-    vec4: VEC4(POOL_VEC4),
-    vec4b: (v) => fromBVec4($4(), v),
-    vec4i: identity,
-    vec4n: $n4,
-    vec4u: identity,
-    vec4vn: (a, n) => setVN4($4(), a, n),
-    vec4vnn: (a, z, w) => setVV4($4(), a, [z, w]),
-    vec4vv: (a, b) => setVV4($4(), a, b),
-    mat2n: (n) => mat22n($4(), n),
-    mat2vv: (a, b) => mat22v($4(), a, b),
-    mat3n: (n) => mat33n([], n),
-    mat3vvv: (a, b, c) => mat33v([], a, b, c),
-    mat4n: (n) => mat44n([], n),
-    mat4vvvv: (a, b, c, d) => mat44v([], a, b, c, d),
-    swizzle2: (a, b, c) => swizzle2($2(), a, b, c),
-    swizzle3: (a, b, c, d) => swizzle3($3(), a, b, c, d),
-    swizzle4: (a, b, c, d, e) => swizzle4($4(), a, b, c, d, e),
-    set_swizzle2: setSwizzle2,
-    set_swizzle3: setSwizzle3,
-    set_swizzle4: setSwizzle4,
-    float: FLOAT,
-    int: INT,
-    uint: UINT,
-    bvec2: BVEC2,
-    bvec2n: (n) => ((n = !!n), [n, n]),
-    bvec3: BVEC3,
-    bvec3n: (n) => ((n = !!n), [n, n, n]),
-    bvec4: BVEC4,
-    bvec4n: (n) => ((n = !!n), [n, n, n, n]),
-    ivec2: IVEC2,
-    ivec2b: (v) => fromBVec2($i2(), v),
-    ivec2n: $ni2,
-    ivec3: IVEC3,
-    ivec3b: (v) => fromBVec3($i3(), v),
-    ivec3n: $ni3,
-    ivec4: IVEC4,
-    ivec4b: (v) => fromBVec4($i4(), v),
-    ivec4n: $ni4,
-    uvec2: UVEC2,
-    uvec2b: (v) => fromBVec2($u2(), v),
-    uvec2n: $nu2,
-    uvec3: UVEC3,
-    uvec3b: (v) => fromBVec3($u3(), v),
-    uvec3n: $nu3,
-    uvec4: UVEC4,
-    uvec4b: (v) => fromBVec4($u4(), v),
-    uvec4n: $nu4,
-    mat2: MAT2,
-    mat3: MAT3,
-    mat4: MAT4,
-    sampler1D: SAMPLER_TODO,
-    sampler2D: SAMPLER_TODO,
-    sampler3D: SAMPLER_TODO,
-    samplerCube: SAMPLER_TODO,
-    sampler2DShadow: SAMPLER_TODO,
-    samplerCubeShadow: SAMPLER_TODO,
-    pools: {
-        vec2: POOL_VEC2,
-        vec3: POOL_VEC3,
-        vec4: POOL_VEC4,
-        ivec2: POOL_IVEC2,
-        ivec3: POOL_IVEC3,
-        ivec4: POOL_IVEC4,
-        uvec2: POOL_UVEC2,
-        uvec3: POOL_UVEC3,
-        uvec4: POOL_UVEC4,
-    },
+const JS_DEFAULT_ENV = {
+  vec2: VEC2(POOL_VEC2),
+  vec2b: (v) => fromBVec2($2(), v),
+  vec2i: identity,
+  vec2n: $n2,
+  vec2u: identity,
+  vec3: VEC3(POOL_VEC3),
+  vec3b: (v) => fromBVec3($3(), v),
+  vec3i: identity,
+  vec3n: $n3,
+  vec3u: identity,
+  vec3vn: (a, n) => setVN3($3(), a, n),
+  vec4: VEC4(POOL_VEC4),
+  vec4b: (v) => fromBVec4($4(), v),
+  vec4i: identity,
+  vec4n: $n4,
+  vec4u: identity,
+  vec4vn: (a, n) => setVN4($4(), a, n),
+  vec4vnn: (a, z, w) => setVV4($4(), a, [z, w]),
+  vec4vv: (a, b) => setVV4($4(), a, b),
+  mat2n: (n) => mat22n($4(), n),
+  mat2vv: (a, b) => mat22v($4(), a, b),
+  mat3n: (n) => mat33n([], n),
+  mat3vvv: (a, b, c) => mat33v([], a, b, c),
+  mat4n: (n) => mat44n([], n),
+  mat4vvvv: (a, b, c, d) => mat44v([], a, b, c, d),
+  swizzle2: (a, b, c) => swizzle2($2(), a, b, c),
+  swizzle3: (a, b, c, d) => swizzle3($3(), a, b, c, d),
+  swizzle4: (a, b, c, d, e) => swizzle4($4(), a, b, c, d, e),
+  set_swizzle2: setSwizzle2,
+  set_swizzle3: setSwizzle3,
+  set_swizzle4: setSwizzle4,
+  float: FLOAT,
+  int: INT,
+  uint: UINT,
+  bvec2: BVEC2,
+  bvec2n: (n) => (n = !!n, [n, n]),
+  bvec3: BVEC3,
+  bvec3n: (n) => (n = !!n, [n, n, n]),
+  bvec4: BVEC4,
+  bvec4n: (n) => (n = !!n, [n, n, n, n]),
+  ivec2: IVEC2,
+  ivec2b: (v) => fromBVec2($i2(), v),
+  ivec2n: $ni2,
+  ivec3: IVEC3,
+  ivec3b: (v) => fromBVec3($i3(), v),
+  ivec3n: $ni3,
+  ivec4: IVEC4,
+  ivec4b: (v) => fromBVec4($i4(), v),
+  ivec4n: $ni4,
+  uvec2: UVEC2,
+  uvec2b: (v) => fromBVec2($u2(), v),
+  uvec2n: $nu2,
+  uvec3: UVEC3,
+  uvec3b: (v) => fromBVec3($u3(), v),
+  uvec3n: $nu3,
+  uvec4: UVEC4,
+  uvec4b: (v) => fromBVec4($u4(), v),
+  uvec4n: $nu4,
+  mat2: MAT2,
+  mat3: MAT3,
+  mat4: MAT4,
+  sampler1D: SAMPLER_TODO,
+  sampler2D: SAMPLER_TODO,
+  sampler3D: SAMPLER_TODO,
+  samplerCube: SAMPLER_TODO,
+  sampler2DShadow: SAMPLER_TODO,
+  samplerCubeShadow: SAMPLER_TODO,
+  pools: {
+    vec2: POOL_VEC2,
+    vec3: POOL_VEC3,
+    vec4: POOL_VEC4,
+    ivec2: POOL_IVEC2,
+    ivec3: POOL_IVEC3,
+    ivec4: POOL_IVEC4,
+    uvec2: POOL_UVEC2,
+    uvec3: POOL_UVEC3,
+    uvec4: POOL_UVEC4
+  }
+};
+export {
+  JS_DEFAULT_ENV
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/shader-ast-js",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "Customizable JS codegen, compiler & runtime for @thi.ng/shader-ast",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc env",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,17 +35,18 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/math": "^5.7.6",
-    "@thi.ng/matrices": "^2.2.12",
-    "@thi.ng/pixel": "^5.0.3",
-    "@thi.ng/shader-ast": "^0.12.84",
-    "@thi.ng/vectors": "^7.8.8"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/math": "^5.7.7",
+    "@thi.ng/matrices": "^2.2.14",
+    "@thi.ng/pixel": "^5.0.5",
+    "@thi.ng/shader-ast": "^0.12.85",
+    "@thi.ng/vectors": "^7.8.10"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -160,5 +163,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "22e36fa838e5431d40165384918b395603bbd92f\n"
 }

package/pool.js

@@ -1,75 +1,74 @@
-import { typedArray, } from "@thi.ng/api";
+import {
+  typedArray
+} from "@thi.ng/api";
 import { outOfBounds } from "@thi.ng/errors/out-of-bounds";
 import { set } from "@thi.ng/vectors/set";
 import { setC2, setC3, setC4 } from "@thi.ng/vectors/setc";
 import { setN, setN2, setN3, setN4 } from "@thi.ng/vectors/setn";
-/**
- * Manager for re-using pre-allocated memory for various vector ops. If the
- * compiled shader program includes a `main()` function, the pools will be reset
- * automatically when that `main` function executes. Otherwise, users **MUST**
- * call the {@link CompileResult.__reset} manually each time before invoking a
- * compiled entry point function.
- *
- * @remarks
- * Currently, the default capacity for each vector type is fixed at 2048 items.
- * That means a shader program can create up to this number of temporary objects
- * (per fragment/invocation). Should this number be insufficient, please submit
- * an issue and explain your use case. Thanks!
- */
-export class Pool {
-    size;
-    cap;
-    mem;
-    items;
-    index = 0;
-    next;
-    from;
-    uniform;
-    constructor(type, size, cap) {
-        this.size = size;
-        this.cap = cap;
-        this.mem = typedArray(type, cap * size);
-        this.items = new Array(cap);
-        for (let i = 0; i < cap; i++) {
-            this.items[i] = this.mem.subarray(i * size, i * size + size);
-        }
-        const next = () => {
-            if (this.index > this.items.length)
-                outOfBounds(this.index);
-            return this.items[this.index++];
-        };
-        let from;
-        let uniform;
-        switch (this.size) {
-            case 2:
-                from = (x, y) => setC2(next(), x, y);
-                uniform = (n) => setN2(next(), n);
-            case 3:
-                from = (x, y, z) => setC3(next(), x, y, z);
-                uniform = (n) => setN3(next(), n);
-            case 4:
-                from = (x, y, z, w) => setC4(next(), x, y, z, w);
-                uniform = (n) => setN4(next(), n);
-            default:
-                from = (...args) => set(next(), args);
-                uniform = (n) => setN(next(), n);
-        }
-        this.next = next;
-        this.from = from;
-        this.uniform = uniform;
+class Pool {
+  constructor(type, size, cap) {
+    this.size = size;
+    this.cap = cap;
+    this.mem = typedArray(type, cap * size);
+    this.items = new Array(cap);
+    for (let i = 0; i < cap; i++) {
+      this.items[i] = this.mem.subarray(i * size, i * size + size);
     }
-    reset() {
-        this.index = 0;
-        return this;
+    const next = () => {
+      if (this.index > this.items.length)
+        outOfBounds(this.index);
+      return this.items[this.index++];
+    };
+    let from;
+    let uniform;
+    switch (this.size) {
+      case 2:
+        from = (x, y) => setC2(next(), x, y);
+        uniform = (n) => setN2(next(), n);
+      case 3:
+        from = (x, y, z) => setC3(next(), x, y, z);
+        uniform = (n) => setN3(next(), n);
+      case 4:
+        from = (x, y, z, w) => setC4(next(), x, y, z, w);
+        uniform = (n) => setN4(next(), n);
+      default:
+        from = (...args) => set(next(), args);
+        uniform = (n) => setN(next(), n);
     }
+    this.next = next;
+    this.from = from;
+    this.uniform = uniform;
+  }
+  mem;
+  items;
+  index = 0;
+  next;
+  from;
+  uniform;
+  reset() {
+    this.index = 0;
+    return this;
+  }
 }
 const CAP = 2048;
-export const POOL_VEC2 = new Pool("f32", 2, CAP);
-export const POOL_VEC3 = new Pool("f32", 3, CAP);
-export const POOL_VEC4 = new Pool("f32", 4, CAP);
-export const POOL_IVEC2 = new Pool("i32", 2, CAP);
-export const POOL_IVEC3 = new Pool("i32", 3, CAP);
-export const POOL_IVEC4 = new Pool("i32", 4, CAP);
-export const POOL_UVEC2 = new Pool("u32", 2, CAP);
-export const POOL_UVEC3 = new Pool("u32", 3, CAP);
-export const POOL_UVEC4 = new Pool("u32", 4, CAP);
+const POOL_VEC2 = new Pool("f32", 2, CAP);
+const POOL_VEC3 = new Pool("f32", 3, CAP);
+const POOL_VEC4 = new Pool("f32", 4, CAP);
+const POOL_IVEC2 = new Pool("i32", 2, CAP);
+const POOL_IVEC3 = new Pool("i32", 3, CAP);
+const POOL_IVEC4 = new Pool("i32", 4, CAP);
+const POOL_UVEC2 = new Pool("u32", 2, CAP);
+const POOL_UVEC3 = new Pool("u32", 3, CAP);
+const POOL_UVEC4 = new Pool("u32", 4, CAP);
+export {
+  POOL_IVEC2,
+  POOL_IVEC3,
+  POOL_IVEC4,
+  POOL_UVEC2,
+  POOL_UVEC3,
+  POOL_UVEC4,
+  POOL_VEC2,
+  POOL_VEC3,
+  POOL_VEC4,
+  Pool
+};

package/runtime.js

@@ -1,99 +1,50 @@
 import { clamp, clamp01 } from "@thi.ng/math/interval";
 import { intBufferFromCanvas } from "@thi.ng/pixel/int";
-export const rgbaBgra8888 = (rgba) => ((clamp01(rgba[0]) * 255.5) << 0) |
-    ((clamp01(rgba[1]) * 255.5) << 8) |
-    ((clamp01(rgba[2]) * 255.5) << 16) |
-    ((clamp01(rgba[3]) * 255.5) << 24);
-export const rgbaRgb565 = (rgba) => (((clamp01(rgba[0]) * 255.5) & 0xf8) << 8) |
-    (((clamp01(rgba[1]) * 255.5) & 0xfc) << 3) |
-    (((clamp01(rgba[2]) * 255.5) & 0xf8) >> 3);
-const clampCoord = (x, maxW, w) => w !== undefined ? Math.min(x + w, maxW) : maxW;
-/**
- * Low-level function used by {@link canvasRenderer} and {@link renderBuffer}.
- * Applies shader function `fn` to each pixel in the given region of the
- * `pixels` buffer (e.g. a `Uint32Array`). The render region is defined via
- * options. The top-left `x`, `y` coords and `w`, `h` dimensions. The remaining
- * parameters `bufW`, `bufH`, `bufOffsetX`, `bufOffsetY` and `imgH` are used to
- * define the actual location of the given buffer in the full image to be
- * computed and to support use cases where the target array only defines a
- * sub-region of the full image (e.g. when splitting rendering over multiple
- * workers, each with their own buffer).
- *
- * @param fn -
- * @param pixels -
- * @param opts
- */
-export const renderPixels = (fn, pixels, { x, y, w, h, bufW, bufH, offsetX, offsetY, imgH, fmt }) => {
-    offsetX = offsetX || 0;
-    offsetY = offsetY || 0;
-    imgH = (imgH || bufH) - 1 - offsetY;
-    x = clamp(x || 0, 0, bufW);
-    y = clamp(y || 0, 0, bufH);
-    const x2 = clampCoord(x, bufW, w);
-    const y2 = clampCoord(y, bufH, h);
-    const fragCoord = [];
-    for (let yy = y; yy < y2; yy++) {
-        fragCoord[1] = imgH - yy;
-        let i = yy * bufW + x;
-        for (let xx = x; xx < x2; xx++) {
-            fragCoord[0] = xx + offsetX;
-            pixels[i++] = fmt(fn(fragCoord));
-        }
+const rgbaBgra8888 = (rgba) => clamp01(rgba[0]) * 255.5 << 0 | clamp01(rgba[1]) * 255.5 << 8 | clamp01(rgba[2]) * 255.5 << 16 | clamp01(rgba[3]) * 255.5 << 24;
+const rgbaRgb565 = (rgba) => (clamp01(rgba[0]) * 255.5 & 248) << 8 | (clamp01(rgba[1]) * 255.5 & 252) << 3 | (clamp01(rgba[2]) * 255.5 & 248) >> 3;
+const clampCoord = (x, maxW, w) => w !== void 0 ? Math.min(x + w, maxW) : maxW;
+const renderPixels = (fn, pixels, { x, y, w, h, bufW, bufH, offsetX, offsetY, imgH, fmt }) => {
+  offsetX = offsetX || 0;
+  offsetY = offsetY || 0;
+  imgH = (imgH || bufH) - 1 - offsetY;
+  x = clamp(x || 0, 0, bufW);
+  y = clamp(y || 0, 0, bufH);
+  const x2 = clampCoord(x, bufW, w);
+  const y2 = clampCoord(y, bufH, h);
+  const fragCoord = [];
+  for (let yy = y; yy < y2; yy++) {
+    fragCoord[1] = imgH - yy;
+    let i = yy * bufW + x;
+    for (let xx = x; xx < x2; xx++) {
+      fragCoord[0] = xx + offsetX;
+      pixels[i++] = fmt(fn(fragCoord));
     }
-    return pixels;
+  }
+  return pixels;
 };
-/**
- * Takes a
- * [`IntBuffer`](https://docs.thi.ng/umbrella/pixel/classes/IntBuffer.html)
- * pixel buffer from thi.ng/pixel, and options to define a buffer-local render
- * region. Applies shader function `fn` to each pixel in that region (or the
- * full buffer by default).
- *
- * @remarks
- * In case the buffer only defines a sub-region of a larger image,
- * {@link RenderPixelOpts.offsetX}, {@link RenderPixelOpts.offsetY} and
- * {@link RenderPixelOpts.imgH} can be given to configure the location and full
- * image height.
- *
- * The default target pixel format is `ABGR8888` using {@link rgbaBgra8888} as
- * default {@link RenderPixelOpts.fmt} conversion.
- *
- * @param fn -
- * @param buf -
- * @param x -
- * @param y -
- * @param w -
- * @param h -
- * @param bufOffsetX -
- * @param bufOffsetY -
- * @param imgH -
- */
-export const renderBuffer = (fn, buf, opts) => {
-    renderPixels(fn, buf.data, {
-        fmt: rgbaBgra8888,
-        bufW: buf.width,
-        bufH: buf.height,
-        x: 0,
-        y: 0,
-        ...opts,
-    });
-    return buf;
+const renderBuffer = (fn, buf, opts) => {
+  renderPixels(fn, buf.data, {
+    fmt: rgbaBgra8888,
+    bufW: buf.width,
+    bufH: buf.height,
+    x: 0,
+    y: 0,
+    ...opts
+  });
+  return buf;
 };
-/**
- * Higher order function accepting an `HTMLCanvasElement` and returning a render
- * function which accepts the following parameters:
- *
- * - `fn` - shader function (compiled via `targetJS().compile(ast)`)
- * - `x`, `y`, `w`, `h` - optional args to define a sub-region to be updated
- *   (default to full image update)
- *
- * @param canvas -
- */
-export const canvasRenderer = (canvas) => {
-    const buf = intBufferFromCanvas(canvas);
-    const data = new ImageData(canvas.width, canvas.height);
-    return (fn, x = 0, y = 0, w = canvas.width, h = canvas.height) => {
-        renderBuffer(fn, buf, { x, y, w, h });
-        buf.blitCanvas(canvas, { data });
-    };
+const canvasRenderer = (canvas) => {
+  const buf = intBufferFromCanvas(canvas);
+  const data = new ImageData(canvas.width, canvas.height);
+  return (fn, x = 0, y = 0, w = canvas.width, h = canvas.height) => {
+    renderBuffer(fn, buf, { x, y, w, h });
+    buf.blitCanvas(canvas, { data });
+  };
+};
+export {
+  canvasRenderer,
+  renderBuffer,
+  renderPixels,
+  rgbaBgra8888,
+  rgbaRgb565
 };