@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/native/render/bitmap-kernel.js

@@ -0,0 +1,591 @@
+import { renderInstance, renderModule } from "./module.js";
+import { copyRows, noiseRows, perlinRows, transformRows, } from "./pixel-ops.js";
+// blur.zig's Kind and Flags.
+const KINDS = ["glow", "dropShadow", "bevel", "gradientGlow", "gradientBevel"];
+const LAYER_INNER = 1;
+const LAYER_KNOCKOUT = 2;
+const LAYER_HIDE_OBJECT = 4;
+const LAYER_TYPE_INNER = 8;
+const LAYER_TYPE_OUTER = 16;
+const LAYER_INVERT = 32;
+/** blur.zig's LayerParams, and a gradient's table after it. */
+const LAYER_PARAMS = 192;
+const TABLE_BYTES = 1024;
+/**
+ * What a tile's input and scratch take at most, so that a filter over a
+ * large bitmap keeps its instance under retainMemory's default; a tile
+ * whose filter reaches far is four times its reach a side, whatever that
+ * takes, its blocks cut to the bitmap and the reach round it.
+ */
+const TILE_BYTES = 4 << 20;
+/** The arena's header an allocation, its alignment and the stack's room, with some to spare. */
+const SLACK = 64 << 10;
+/**
+ * Whether `area` is a rect blur.zig takes: whole, of some size. It never
+ * sees where the rect lies, which the blocks copied in hold.
+ */
+function sized(area) {
+    const { x, y, width: w, height: h } = area;
+    return (Number.isSafeInteger(x) &&
+        Number.isSafeInteger(y) &&
+        Number.isInteger(w) &&
+        Number.isInteger(h) &&
+        w > 0 &&
+        h > 0 &&
+        w <= 0x100000 &&
+        h <= 0x100000);
+}
+/** A blur as the player keeps it: 0 to 255, or NaN, which blurs nothing. */
+function blurry(v) {
+    return Number.isNaN(v) || (v >= 0 && v <= 255);
+}
+const unit = (v) => v >= 0 && v <= 1;
+const rgb = (v) => Number.isInteger(v) && v >= 0 && v <= 0xffffff;
+/** How far `quality` runs of a blur reach, each way: each half its box, whole taps. */
+function reach(blur, quality) {
+    return quality * Math.ceil((blur || 0) / 2);
+}
+/** The bytes a run's line buffer and sums take over a plane `w` wide (blur.zig's blur). */
+function runBytes(w, blurX, blurY) {
+    const line = blurX > 1 ? (w + 2 * Math.ceil(blurX / 2) + 3) * 4 : 0;
+    return line + (blurY > 1 ? w * 4 : 0);
+}
+/**
+ * `rect`, where it lies wholly past the bitmap on one side, moved to lie just
+ * past it: as far out as the player lets a rect lie, past the convolution's
+ * bounds, every tap reads there what it reads here, the nearest edge or the
+ * filter's colour.
+ */
+function inward(source, rect) {
+    const along = (at, size, length) => at + size <= 0 ? -size : at >= length ? length : at;
+    return {
+        ...rect,
+        x: along(rect.x, rect.width, source.width),
+        y: along(rect.y, rect.height, source.height),
+    };
+}
+/**
+ * `block` within the bitmap grown by a blur's reach (hx, hy), past which
+ * every pass of it holds nothing: null where it lies wholly past. A block
+ * whose reads past the bitmap are not nothing (an inner glow's, of 255 less
+ * the alpha) is not to be cut.
+ */
+function within(block, source, hx, hy) {
+    const x0 = Math.max(block.x, -hx);
+    const y0 = Math.max(block.y, -hy);
+    const x1 = Math.min(block.x + block.width, source.width + hx);
+    const y1 = Math.min(block.y + block.height, source.height + hy);
+    return x1 > x0 && y1 > y0 ? { x: x0, y: y0, width: x1 - x0, height: y1 - y0 } : null;
+}
+/**
+ * `area` in tiles, `bytes` of a tile `w` by `h` within TILE_BYTES where its
+ * reach (`far`) lets it: tiles four times the reach a side at least. Null
+ * where they do not fit the module.
+ */
+function tiles(area, far, bytes) {
+    const of = (side) => bytes(Math.min(side, area.width), Math.min(side, area.height));
+    let side = Math.max(area.width, area.height);
+    // Smaller, a tile would be mostly the reach round it, read again for each.
+    while (side > 16 && of(side) > TILE_BYTES && side > 4 * far) {
+        side = Math.ceil(side / 2);
+    }
+    if (!(of(side) + SLACK <= MOST_BYTES)) {
+        return null;
+    }
+    const out = [];
+    for (let y = 0; y < area.height; y += side) {
+        for (let x = 0; x < area.width; x += side) {
+            out.push({
+                x: area.x + x,
+                y: area.y + y,
+                width: Math.min(side, area.width - x),
+                height: Math.min(side, area.height - y),
+            });
+        }
+    }
+    return out;
+}
+/** What a call's input and scratch may take of the module's 128 MiB, the stack's and statics' room left. */
+const MOST_BYTES = 120 * 1024 * 1024;
+/** `area` of the source into `into`, row by row; 0 past the bitmap. */
+function copy(source, area, into) {
+    const { width: sw, height: sh, pixels } = source;
+    const x0 = Math.max(0, area.x);
+    const y0 = Math.max(0, area.y);
+    const x1 = Math.min(sw, area.x + area.width);
+    const y1 = Math.min(sh, area.y + area.height);
+    if (x0 > area.x || y0 > area.y || x1 < area.x + area.width || y1 < area.y + area.height) {
+        into.fill(0);
+    }
+    for (let sy = y0; sy < y1 && x1 > x0; sy++) {
+        into.set(pixels.subarray(sy * sw + x0, sy * sw + x1), (sy - area.y) * area.width + x0 - area.x);
+    }
+}
+/** The alpha of `area` of the source into `into`, a byte a pixel; 0 past the bitmap. */
+function copyAlpha(source, area, into) {
+    const { width: sw, height: sh, pixels } = source;
+    const x0 = Math.max(0, area.x);
+    const y0 = Math.max(0, area.y);
+    const x1 = Math.min(sw, area.x + area.width);
+    const y1 = Math.min(sh, area.y + area.height);
+    if (x0 > area.x || y0 > area.y || x1 < area.x + area.width || y1 < area.y + area.height) {
+        into.fill(0);
+    }
+    for (let sy = y0; sy < y1 && x1 > x0; sy++) {
+        let o = (sy - area.y) * area.width + x0 - area.x;
+        const end = sy * sw + x1;
+        for (let i = sy * sw + x0; i < end; i++) {
+            into[o++] = pixels[i] >>> 24;
+        }
+    }
+}
+/**
+ * The blocks of the source a layer over `area` blurs the alpha of, and its
+ * reads of them, moved by each of `offsets`: blurred once over where they
+ * all read and as far round it as the blur reaches (hx, hy), as a bevel
+ * reads on and back; reads further apart than `area` is wide or high, each
+ * over its own, so that a block is `area`'s size wherever the offset takes
+ * it. As the player's JS read them.
+ */
+function alphaReads(area, hx, hy, offsets) {
+    const kxs = offsets.map(([dx]) => Math.floor(dx));
+    const kys = offsets.map(([, dy]) => Math.floor(dy));
+    const x0 = Math.min(...kxs);
+    const y0 = Math.min(...kys);
+    const spanX = Math.max(...kxs) - x0;
+    const spanY = Math.max(...kys) - y0;
+    if (offsets.length > 1 && (spanX > area.width || spanY > area.height)) {
+        const each = offsets.map((offset) => alphaReads(area, hx, hy, [offset]));
+        return {
+            reads: each.map(({ reads }) => reads[0]),
+            moves: each.map(({ moves }, k) => ({ ...moves[0], read: k })),
+        };
+    }
+    return {
+        reads: [
+            {
+                x: area.x + x0 - hx,
+                y: area.y + y0 - hy,
+                width: area.width + 1 + spanX + 2 * hx,
+                height: area.height + 1 + spanY + 2 * hy,
+            },
+        ],
+        moves: offsets.map(([dx, dy], i) => ({
+            read: 0,
+            x: hx + (kxs[i] - x0) + (dx - kxs[i]),
+            y: hy + (kys[i] - y0) + (dy - kys[i]),
+        })),
+    };
+}
+// Params.flags in convolve.zig.
+const FLAG_CLAMP = 1;
+const FLAG_SOURCE_TRANSPARENT = 2;
+const FLAG_PRESERVE_ALPHA = 4;
+const FLAG_PREMULTIPLY = 8;
+// About what one call's input block and output hold: a large rect is
+// convolved a band of rows at a time, so that its scratch stays far under
+// retainMemory's default and the instance is kept rather than regrown.
+const BAND_BYTES = 1 << 20;
+/**
+ * BitmapData's CPU filters in the render module: a convolution
+ * (convolve.zig), and a blur, a glow, a drop shadow, a bevel and a gradient
+ * glow or bevel (blur.zig), on one instance, its scratch bounded. It
+ * compiles the render module as it is made, and throws where the host
+ * refuses it. Results own their buffers; rejection leaves the source
+ * untouched.
+ */
+export class BitmapKernel {
+    instance = null;
+    keep;
+    constructor(options = {}) {
+        this.keep = options.retainMemory ?? 8 << 20;
+        if (!Number.isInteger(this.keep) || this.keep < 0 || this.keep > 128 << 20) {
+            throw new RangeError("invalid bitmap kernel memory limit");
+        }
+        renderModule();
+    }
+    get capacity() {
+        return this.instance?.memory.buffer.byteLength ?? 0;
+    }
+    dispose() {
+        this.instance = null;
+    }
+    /**
+     * The convolved pixels, owned by the caller, or null where they would not
+     * fit; where the instance traps, the call is made again in a new one
+     * once. Never writes to the source.
+     */
+    convolve = (source, area, filter, transparent) => {
+        const { width: sw, height: sh } = source;
+        const cols = filter.matrixX;
+        const rows = filter.matrixY;
+        // Wholly past the kernel's reach of the bitmap, every tap reads alike, the nearest edge's or
+        // the filter's colour, wherever the rect is.
+        const grown = inward(source, {
+            x: area.x - cols,
+            y: area.y - rows,
+            width: area.width + 2 * cols,
+            height: area.height + 2 * rows,
+        });
+        const x = grown.x + cols;
+        const y = grown.y + rows;
+        const { width: w, height: h } = area;
+        if (![sw, sh, x, y, w, h, cols, rows].every(Number.isInteger) ||
+            sw <= 0 ||
+            sh <= 0 ||
+            sw > 0x3fffffff ||
+            sh > 0x3fffffff ||
+            source.pixels.length !== sw * sh ||
+            Math.abs(x) > 0x3fffffff ||
+            Math.abs(y) > 0x3fffffff ||
+            w <= 0 ||
+            h <= 0 ||
+            w > 0x100000 ||
+            h > 0x100000 ||
+            cols <= 0 ||
+            rows <= 0 ||
+            cols > 15 ||
+            rows > 15) {
+            return null;
+        }
+        const clampX = (v) => Math.max(0, Math.min(sw - 1, v));
+        const clampY = (v) => Math.max(0, Math.min(sh - 1, v));
+        const x0 = clampX(x - (cols >> 1));
+        const nw = clampX(x + w + cols - (cols >> 1) - 2) - x0 + 1;
+        // Each band's output rows read its rows of the source and the kernel's
+        // reach above and below them, which the next band copies again.
+        const band = Math.max(1, Math.min(h, Math.floor(BAND_BYTES / ((nw + w) * 4))));
+        const nhMax = Math.min(band + rows - 1, sh);
+        const matrixOffset = Math.ceil((96 + nw * nhMax * 4) / 8) * 8;
+        const inputMax = matrixOffset + cols * rows * 8;
+        // Leave room for the stack and alignment before reserving any native input;
+        // the kernel's planes hold at most 16 lines.
+        if (!Number.isSafeInteger(inputMax) ||
+            inputMax + (16 * nw + 1) * 16 + w * 32 + w * band * 4 > 127 * 1024 * 1024) {
+            return null;
+        }
+        let result;
+        try {
+            result = new Uint32Array(w * h);
+        }
+        catch {
+            return null;
+        }
+        return this.call((wasm) => {
+            const flags = (filter.clamp ? FLAG_CLAMP : 0) |
+                (source.transparent ? FLAG_SOURCE_TRANSPARENT : 0) |
+                (filter.preserveAlpha ? FLAG_PRESERVE_ALPHA : 0) |
+                (transparent ? FLAG_PREMULTIPLY : 0);
+            for (let top = 0; top < h; top += band) {
+                const bandY = y + top;
+                const bandH = Math.min(band, h - top);
+                const y0 = clampY(bandY - (rows >> 1));
+                const nh = clampY(bandY + bandH + rows - (rows >> 1) - 2) - y0 + 1;
+                const offset = Math.ceil((96 + nw * nh * 4) / 8) * 8;
+                const pointer = wasm.resetArena(offset + cols * rows * 8);
+                if (!pointer) {
+                    return null;
+                }
+                const pixelPointer = pointer + 96;
+                const matrixPointer = pointer + offset;
+                new Int32Array(wasm.memory.buffer, pointer, 16).set([
+                    sw,
+                    sh,
+                    x,
+                    bandY,
+                    w,
+                    bandH,
+                    x0,
+                    y0,
+                    nw,
+                    nh,
+                    cols,
+                    rows,
+                    flags,
+                    pixelPointer,
+                    matrixPointer,
+                    0,
+                ]);
+                new Float64Array(wasm.memory.buffer, pointer + 64, 2).set([
+                    filter.divisor || 1,
+                    filter.bias,
+                ]);
+                new Int32Array(wasm.memory.buffer, pointer + 80, 2).set([
+                    Math.floor(filter.alpha * 255) | 0,
+                    filter.color | 0,
+                ]);
+                const into = new Uint32Array(wasm.memory.buffer, pixelPointer, nw * nh);
+                for (let row = 0; row < nh; row++) {
+                    into.set(source.pixels.subarray((y0 + row) * sw + x0, (y0 + row) * sw + x0 + nw), row * nw);
+                }
+                const matrix = new Float64Array(wasm.memory.buffer, matrixPointer, cols * rows);
+                for (let k = 0; k < matrix.length; k++) {
+                    matrix[k] = filter.matrix[k] || 0;
+                }
+                const out = wasm.convolve(pointer);
+                if (!out) {
+                    // An ordinary allocation rejection can reuse its arena on a later call.
+                    return null;
+                }
+                // The kernel can grow memory; construct this view afterwards and copy before scratch reuse.
+                result.set(new Uint32Array(wasm.memory.buffer, out, w * bandH), top * w);
+            }
+            return result;
+        }, true);
+    };
+    /**
+     * The blur filter over `area` of the source, 0 past the bitmap: its
+     * premultiplied channels blurred apart (blur.zig), owned by the caller;
+     * null where the values are not the player's or the pixels would not fit.
+     * Large rects are filtered in tiles, each read as far round as the blur
+     * reaches. A trap is made again in a new instance once. Never writes to
+     * the source.
+     */
+    blur = (source, area, blurX, blurY, quality) => {
+        if (!sized(area) ||
+            !blurry(blurX) ||
+            !blurry(blurY) ||
+            !(Number.isInteger(quality) && quality >= 0 && quality <= 15)) {
+            return null;
+        }
+        const hx = reach(blurX, quality);
+        const hy = reach(blurY, quality);
+        // A block is cut to the bitmap and the reach round it.
+        const blockBytes = (w, h) => {
+            const bw = Math.min(w, source.width) + 2 * hx;
+            const n = bw * (Math.min(h, source.height) + 2 * hy);
+            return 32 + n * 6 + runBytes(bw, blurX, blurY);
+        };
+        const parts = tiles(area, Math.max(hx, hy), blockBytes);
+        if (!parts) {
+            return null;
+        }
+        const result = new Uint32Array(area.width * area.height);
+        return this.call((wasm) => {
+            for (const t of parts) {
+                const block = within({ x: t.x - hx, y: t.y - hy, width: t.width + 2 * hx, height: t.height + 2 * hy }, source, hx, hy);
+                // Past the blur's reach of the bitmap: nothing.
+                if (!block) {
+                    continue;
+                }
+                const n = block.width * block.height;
+                const pointer = wasm.resetArena(32 + n * 4);
+                if (!pointer) {
+                    return null;
+                }
+                new Int32Array(wasm.memory.buffer, pointer, 4).set([
+                    block.width,
+                    block.height,
+                    quality,
+                    pointer + 32,
+                ]);
+                new Float64Array(wasm.memory.buffer, pointer + 16, 2).set([blurX, blurY]);
+                copy(source, block, new Uint32Array(wasm.memory.buffer, pointer + 32, n));
+                const out = wasm.blurFilter(pointer);
+                if (!out) {
+                    return null;
+                }
+                // What the block holds of the tile, past the reach round it; nothing past the block.
+                const blurred = new Uint32Array(wasm.memory.buffer, out, n);
+                const x0 = Math.max(t.x, block.x);
+                const x1 = Math.min(t.x + t.width, block.x + block.width);
+                const y0 = Math.max(t.y, block.y);
+                const y1 = Math.min(t.y + t.height, block.y + block.height);
+                for (let y = y0; y < y1 && x1 > x0; y++) {
+                    const from = (y - block.y) * block.width + x0 - block.x;
+                    result.set(blurred.subarray(from, from + x1 - x0), (y - area.y) * area.width + x0 - area.x);
+                }
+            }
+            return result;
+        }, true);
+    };
+    /**
+     * A glow's, a shadow's, a bevel's or a gradient one's result over `area`
+     * of the source (blur.zig), read from the source moved by each of
+     * `offsets` (one, or two for a bevel, on and back): the alpha of blocks of
+     * the source blurred, read there, and the layer placed on the source's
+     * pixels; owned by the caller, null where the values are not the player's
+     * or the pixels would not fit. Large rects are filtered in tiles. A trap
+     * is made again in a new instance once. Never writes to the source.
+     */
+    layer = (source, area, f, offsets) => {
+        const kind = KINDS.indexOf(f.kind);
+        const bevel = f.kind === "bevel" || f.kind === "gradientBevel";
+        if (kind < 0 ||
+            !sized(area) ||
+            offsets.length !== (bevel ? 2 : 1) ||
+            !offsets.every(([x, y]) => Math.abs(x) < 2 ** 31 && Math.abs(y) < 2 ** 31) ||
+            !(Number.isInteger(f.quality) && f.quality >= 0 && f.quality <= 15) ||
+            !blurry(f.blurX) ||
+            !blurry(f.blurY) ||
+            !(f.strength >= 0 && f.strength <= 255) ||
+            !unit(f.alpha) ||
+            !unit(f.highlightAlpha) ||
+            !unit(f.shadowAlpha) ||
+            !rgb(f.color) ||
+            !rgb(f.highlightColor) ||
+            !rgb(f.shadowColor) ||
+            (f.table !== null && f.table.length !== 256)) {
+            return null;
+        }
+        const hx = reach(f.blurX, f.quality);
+        const hy = reach(f.blurY, f.quality);
+        // A tile's pixels, its blocks' alpha and their scratch, and its reads' planes and columns;
+        // a block cut to the bitmap and the reach round it, unless it reads 255 past it.
+        const cut = (r) => f.invert
+            ? r
+            : {
+                ...r,
+                width: Math.min(r.width, source.width + 2 * hx),
+                height: Math.min(r.height, source.height + 2 * hy),
+            };
+        const tileBytes = (w, h) => {
+            const { reads } = alphaReads({ x: 0, y: 0, width: w, height: h }, hx, hy, offsets);
+            const read = reads
+                .map(cut)
+                .reduce((sum, r) => sum + r.width * r.height * 2 + runBytes(r.width, f.blurX, f.blurY), 0);
+            return LAYER_PARAMS + TABLE_BYTES + w * h * 4 + read + offsets.length * (w * h + w * 16);
+        };
+        const parts = tiles(area, Math.max(hx, hy), tileBytes);
+        if (!parts) {
+            return null;
+        }
+        const flags = (f.inner ? LAYER_INNER : 0) |
+            (f.knockout ? LAYER_KNOCKOUT : 0) |
+            (f.hideObject ? LAYER_HIDE_OBJECT : 0) |
+            (f.type === "inner" ? LAYER_TYPE_INNER : 0) |
+            (f.type === "outer" ? LAYER_TYPE_OUTER : 0) |
+            (f.invert ? LAYER_INVERT : 0);
+        const result = new Uint32Array(area.width * area.height);
+        return this.call((wasm) => {
+            for (const t of parts) {
+                const whole = alphaReads(t, hx, hy, offsets);
+                // Past the bitmap and the blur's reach round it, the alpha blurred is nothing, as the
+                // block's reads past it are: a block cut there, a pixel past it kept of one wholly so,
+                // its moves still the whole block's, which blur.zig reads the cut by.
+                const reads = f.invert
+                    ? whole.reads
+                    : whole.reads.map((r) => within(r, source, hx, hy) ?? { ...r, width: 1, height: 1 });
+                const moves = whole.moves;
+                const n = t.width * t.height;
+                const alpha = reads.reduce((sum, r) => sum + r.width * r.height, 0);
+                const pointer = wasm.resetArena(LAYER_PARAMS + TABLE_BYTES + n * 4 + alpha);
+                if (!pointer) {
+                    return null;
+                }
+                const buffer = wasm.memory.buffer;
+                const table = pointer + LAYER_PARAMS;
+                const pixels = table + TABLE_BYTES;
+                const ints = new Int32Array(buffer, pointer, LAYER_PARAMS / 4);
+                ints.fill(0);
+                ints.set([kind, flags, t.width, t.height, pixels, f.quality, reads.length, moves.length]);
+                let at = pixels + n * 4;
+                for (const [k, r] of reads.entries()) {
+                    const from = whole.reads[k];
+                    ints.set([at, r.width, r.height, r.x - from.x, r.y - from.y], 8 + k * 6);
+                    copyAlpha(source, r, new Uint8Array(buffer, at, r.width * r.height));
+                    at += r.width * r.height;
+                }
+                const floats = new Float64Array(buffer, pointer, LAYER_PARAMS / 8);
+                for (const [k, m] of moves.entries()) {
+                    ints[20 + k * 6] = m.read;
+                    floats[11 + k * 3] = m.x;
+                    floats[12 + k * 3] = m.y;
+                }
+                floats.set([f.blurX, f.blurY, f.strength, f.alpha, f.highlightAlpha, f.shadowAlpha], 16);
+                ints.set([f.color, f.highlightColor, f.shadowColor, table], 44);
+                if (f.table) {
+                    new Uint32Array(buffer, table, 256).set(f.table);
+                }
+                copy(source, t, new Uint32Array(buffer, pixels, n));
+                const out = wasm.layerFilter(pointer);
+                if (!out) {
+                    return null;
+                }
+                const placed = new Uint32Array(wasm.memory.buffer, out, n);
+                for (let row = 0; row < t.height; row++) {
+                    result.set(placed.subarray(row * t.width, (row + 1) * t.width), (t.y - area.y + row) * area.width + t.x - area.x);
+                }
+            }
+            return result;
+        }, true);
+    };
+    /**
+     * `region` of `into` (`intoWidth` wide) made by the copy `op` of `from`'s
+     * pixels from (sx, sy) on: copyChannel, merge, paletteMap or a colour
+     * matrix filter (pixel-ops.ts), each pixel reading what the pixels before
+     * it wrote where `from` is `into`. False where the module refused it,
+     * which may leave the rows done before it done.
+     */
+    copy(into, intoWidth, from, fromWidth, region, sx, sy, transparent, op) {
+        if (!whole(region) || !Number.isInteger(sx) || !Number.isInteger(sy)) {
+            return false;
+        }
+        const progress = { row: 0, state: 0 };
+        return (this.call((wasm) => copyRows(wasm, into, intoWidth, from, fromWidth, region, sx, sy, transparent, op, progress)
+            ? true
+            : null, true) ?? false);
+    }
+    /** colorTransform over `region` of `pixels` (`width` wide), in place: false where the module refused it. */
+    transform(pixels, width, region, muls, adds) {
+        if (!whole(region)) {
+            return false;
+        }
+        const progress = { row: 0, state: 0 };
+        return (this.call((wasm) => (transformRows(wasm, pixels, width, region, muls, adds, progress) ? true : null), true) ?? false);
+    }
+    /**
+     * noise over every pixel, Park-Miller's generator from `state` (1 to
+     * 2^31 - 2), values lo + r % span: false where the module refused it.
+     */
+    noise(pixels, state, lo, span, channels, gray, transparent) {
+        if (!(Number.isInteger(state) && state >= 1 && state < 2147483647) || pixels.length === 0) {
+            return false;
+        }
+        const progress = { row: 0, state };
+        return (this.call((wasm) => noiseRows(wasm, pixels, lo, span, channels, gray, transparent, progress) ? true : null, true) ?? false);
+    }
+    /** perlinNoise over every pixel of a `width`-wide store: false where the module refused it. */
+    perlin(pixels, width, setup) {
+        if (!(width > 0) || pixels.length % width !== 0 || pixels.length === 0) {
+            return false;
+        }
+        const progress = { row: 0, state: 0 };
+        return (this.call((wasm) => (perlinRows(wasm, pixels, width, setup, progress) ? true : null), true) ??
+            false);
+    }
+    /** `body` on the instance, made where there is none: made again in a new one where it traps if `again`. */
+    call(body, again) {
+        try {
+            if (!this.instance) {
+                try {
+                    this.instance = renderInstance(() => {
+                        throw new Error("the bitmap kernel takes no tessellator");
+                    });
+                }
+                catch {
+                    return null;
+                }
+            }
+            return body(this.instance);
+        }
+        catch {
+            // A trap: never resume that instance.
+            this.dispose();
+            return again ? this.call(body, false) : null;
+        }
+        finally {
+            if (this.capacity > this.keep) {
+                this.dispose();
+            }
+        }
+    }
+}
+/** Whether `r` is a rect of whole pixels with an area, within a store. */
+function whole(r) {
+    return ([r.x, r.y, r.width, r.height].every(Number.isInteger) &&
+        r.x >= 0 &&
+        r.y >= 0 &&
+        r.width > 0 &&
+        r.height > 0);
+}