@swf2es/player 0.0.0-stage → 0.1.0

package/dist/bitmap/ops.js

@@ -0,0 +1,1240 @@
+// The pixel operations of BitmapData that read and write its store alone
+// (bitmap.ts): each on unmultiplied ARGB as Flash's results show it works,
+// the store premultiplying again as it writes. The rules are the ones
+// Flash traces under adl and records in Ruffle's corpus.
+import { DRAW_OPAQUE, DRAW_SKIP_ZERO_ALPHA, DRAW_SMOOTH, DRAW_TRANSFORM, DrawKernel, } from "@swf2es/native/render";
+import { BitmapStore, over, premultiply, unmultiply } from "./bitmap.js";
+import { bitmapKernel, drawKernel } from "./kernel.js";
+import { perlinSetup } from "./turbulence.js";
+const M = 2147483647;
+/**
+ * Flash's noise generator's first state: Park-Miller's minimal standard,
+ * x * 16807 mod 2^31 - 1, a seed of 0 taken as 1 and one under 0 as
+ * -seed + 1 (all 25 pixels Ruffle's bitmapdata_getvector records of
+ * noise(0) match). The render module draws from it (pixels.zig).
+ */
+function noiseState(seed) {
+    let s = seed | 0;
+    if (s <= 0) {
+        s = -s + 1;
+    }
+    return s % M || 1;
+}
+/**
+ * noise: each pixel's channels drawn in R, G, B order, then alpha, which
+ * only a transparent bitmap draws; a grayscale draw is one for all three
+ * colours, then alpha. A value is low + r % (high - low + 1), high capped
+ * at 255 and a range upside down giving low. A colour left out is 0, an
+ * alpha left out 255.
+ */
+export function noise(store, seed, low, high, channels, gray) {
+    const lo = Math.max(0, Math.min(255, low));
+    const hi = Math.max(0, Math.min(255, high));
+    bitmapKernel()?.noise(store.pixels, noiseState(seed), lo, hi - lo + 1, channels & 15, gray, store.transparent);
+    store.changed();
+}
+/** The channel's shift in ARGB: 1 red, 2 green, 4 blue, 8 alpha; -1 for another value. */
+function shiftOf(channel) {
+    switch (channel) {
+        case 1:
+            return 16;
+        case 2:
+            return 8;
+        case 4:
+            return 0;
+        case 8:
+            return 24;
+        default:
+            return -1;
+    }
+}
+/** Each destination pixel's channel set from the source pixel's channel, both unmultiplied. */
+export function copyChannel(store, source, rect, dx, dy, from, to) {
+    const fromShift = shiftOf(from);
+    const toShift = shiftOf(to);
+    if (toShift < 0 || (toShift === 24 && !store.transparent)) {
+        return;
+    }
+    // A source of more than one channel, or none, copies 0, as Flash does.
+    copied(store, source, rect, dx, dy, { op: "channel", from: fromShift, to: toShift });
+}
+/**
+ * colorTransform as Flash computes it, fitted under adl: each channel read
+ * back as p * 255 / a, floored; then (c * floor(mul * 256) >> 8) +
+ * trunc(offset), clamped to 0..255, the alpha alike; and written
+ * premultiplied as c * (a + 1) >> 8, not as setPixel32 rounds. A pixel
+ * of alpha 0 is left as it is; an opaque bitmap's alpha is transformed
+ * like a transparent one's.
+ */
+export function colorTransform(store, rect, ct) {
+    const c = store.clip(rect);
+    if (!c) {
+        return;
+    }
+    const fixed = (m) => Math.trunc(m * 256);
+    const muls = [ct.rMul, ct.gMul, ct.bMul, ct.aMul].map(fixed);
+    const adds = [ct.rAdd, ct.gAdd, ct.bAdd, ct.aAdd].map(Math.trunc);
+    bitmapKernel()?.transform(store.pixels, store.width, c, muls, adds);
+    store.changed();
+}
+/**
+ * merge: each channel ((s * m + d * (256 - m)) >> 8) & 0xFF, unmultiplied,
+ * the multiplier a uint and nothing clamped, as 18 multipliers from -257
+ * to 2^32 - 1 show Flash computing it under adl; a double holds the
+ * product, so the shift is a division.
+ */
+export function merge(store, source, rect, dx, dy, muls) {
+    copied(store, source, rect, dx, dy, { op: "merge", muls });
+}
+/**
+ * The source rect's pixels against the destination's at the point, both
+ * clipped and unmultiplied, each destination pixel made by `op` of the
+ * pair (pixel-ops.ts). In place, rows down and pixels along, each read as
+ * the ones before it left it, as Flash does: a move down or right repeats
+ * what it wrote.
+ */
+function copied(store, source, rect, dx, dy, op) {
+    const s = source.clip(rect);
+    if (!s) {
+        return;
+    }
+    dx += s.x - rect.x;
+    dy += s.y - rect.y;
+    const d = store.clip({ x: dx, y: dy, width: s.width, height: s.height });
+    if (!d) {
+        return;
+    }
+    // The store written first: if it is the source, both are then its own array.
+    const into = store.pixels;
+    const from = source.readable;
+    const sx = s.x + (d.x - dx);
+    const sy = s.y + (d.y - dy);
+    bitmapKernel()?.copy(into, store.width, from, source.width, d, sx, sy, store.transparent, op);
+    store.changed();
+}
+/**
+ * paletteMap: each copied pixel the sum of its channels' entries in the
+ * four tables, red, green, blue and alpha, wrapping at 32 bits, as Flash
+ * makes it (Ruffle's operations.rs); a table not given maps its channel
+ * to itself.
+ */
+export function paletteMap(store, source, rect, dx, dy, tables) {
+    copied(store, source, rect, dx, dy, { op: "palette", tables });
+}
+/**
+ * compare's differing pixels, null where none differ: 0 for a pixel the
+ * same in both, the colours' differences, opaque, where they differ, else
+ * the alphas' difference in every channel (Ruffle's operations.rs).
+ */
+export function comparePixels(left, right) {
+    const out = new Uint32Array(left.width * left.height);
+    let different = false;
+    for (let i = 0; i < out.length; i++) {
+        const p = left.unmultiplied(left.readable[i]);
+        const q = right.unmultiplied(right.readable[i]);
+        if (p === q) {
+            continue;
+        }
+        different = true;
+        if ((p & 0xffffff) !== (q & 0xffffff)) {
+            out[i] =
+                (0xff000000 |
+                    ((((p >>> 16) - (q >>> 16)) & 0xff) << 16) |
+                    ((((p >>> 8) - (q >>> 8)) & 0xff) << 8) |
+                    ((p - q) & 0xff)) >>>
+                    0;
+        }
+        else {
+            const alpha = ((p >>> 24) - (q >>> 24)) & 0xff;
+            out[i] = ((alpha << 24) | (alpha << 16) | (alpha << 8) | alpha) >>> 0;
+        }
+    }
+    return different ? out : null;
+}
+/**
+ * perlinNoise: each pixel's channels from turbulence.ts, a channel left
+ * out its least, alpha left out opaque, written as they come, not
+ * premultiplied, as Flash writes them (Ruffle's operations.rs, whose
+ * conversion to a byte is Flash's). A channel's noise is drawn from the
+ * next of the generator's four only for the channels asked for.
+ */
+export function perlinNoise(store, base, offsets, seed, stitch, fractal, channels, gray) {
+    const { width, height } = store;
+    // A base's sign is dropped (adl).
+    const frequency = [
+        base[0] === 0 ? 0 : 1 / Math.abs(base[0]),
+        base[1] === 0 ? 0 : 1 / Math.abs(base[1]),
+    ];
+    bitmapKernel()?.perlin(store.pixels, width, {
+        ...perlinSetup(seed, frequency, stitch, width, height),
+        offsets,
+        fractal,
+        channels: channels & 15,
+        gray,
+        transparent: store.transparent,
+    });
+    store.changed();
+}
+/** scroll: the pixels moved by (x, y); what nothing moved onto keeps its old pixels. */
+export function scroll(store, x, y) {
+    const { width, height } = store;
+    // Nothing moves: the pixels are left where they are, on the GPU or not, and
+    // a GPU copy that holds the newest stays current, or the next move on it
+    // would bring the store back and leave the CPU's copy behind.
+    if (x === 0 && y === 0) {
+        if (!store.onGpu(() => true)) {
+            store.changed();
+        }
+        return;
+    }
+    // The pixels that stay within the store, moved on the GPU where it holds the newest.
+    const moved = store.clip({ x: -x, y: -y, width, height });
+    if (store.onGpu((copy) => !moved || copy.copy(store, moved, moved.x + x, moved.y + y))) {
+        return;
+    }
+    const old = store.pixels.slice();
+    for (let row = 0; row < height; row++) {
+        const sy = row - y;
+        if (sy < 0 || sy >= height) {
+            continue;
+        }
+        for (let col = 0; col < width; col++) {
+            const sx = col - x;
+            if (sx >= 0 && sx < width) {
+                store.pixels[row * width + col] = old[sy * width + sx];
+            }
+        }
+    }
+    store.changed();
+}
+const OPERATIONS = {
+    "<": (a, b) => a < b,
+    "<=": (a, b) => a <= b,
+    ">": (a, b) => a > b,
+    ">=": (a, b) => a >= b,
+    "==": (a, b) => a === b,
+    "!=": (a, b) => a !== b,
+};
+/** Whether `op` is one threshold takes. */
+export function isThresholdOperation(op) {
+    // Its own keys only: "constructor" and the rest of Object's are not operations.
+    return Object.hasOwn(OPERATIONS, op);
+}
+/**
+ * threshold: each source pixel, unmultiplied and masked, compared with the
+ * masked threshold as unsigned numbers; where the test holds the
+ * destination pixel becomes `color`, elsewhere the source pixel if
+ * `copySource`; how many held. With `premultiplied`, as AVM1's
+ * BitmapData has it (Ruffle's operations.rs), the pixel is compared as it
+ * is kept, premultiplied, and `color` and the source pixel are written as
+ * a transparent bitmap keeps them, the colour's channels premultiplied by
+ * its alpha. Flash leaves an opaque bitmap's alpha as written there too,
+ * which its getPixel32 then reads; here an opaque store keeps every alpha
+ * at 255, which its drawing, copies and filters take it to have, so its
+ * getPixel32 alone differs from Flash's (its getPixel does not).
+ */
+export function threshold(store, source, rect, dx, dy, op, value, color, mask, copySource, premultiplied = false) {
+    const test = OPERATIONS[op];
+    const target = (value & mask) >>> 0;
+    let count = 0;
+    const s = source.clip(rect);
+    if (!s) {
+        return 0;
+    }
+    dx += s.x - rect.x;
+    dy += s.y - rect.y;
+    const d = store.clip({ x: dx, y: dy, width: s.width, height: s.height });
+    if (!d) {
+        return 0;
+    }
+    const sx = s.x + (d.x - dx);
+    const sy = s.y + (d.y - dy);
+    // In place, each pixel read as the ones before it left it (copied).
+    const into = store.pixels;
+    const pixels = source.readable;
+    const opaque = store.transparent ? 0 : 0xff000000;
+    const fill = premultiplied
+        ? (premultiply(color >>> 0) | opaque) >>> 0
+        : store.premultiplied(color >>> 0);
+    for (let row = 0; row < d.height; row++) {
+        for (let i = 0; i < d.width; i++) {
+            const to = (d.y + row) * store.width + d.x + i;
+            const raw = pixels[(sy + row) * source.width + sx + i];
+            if (test(((premultiplied ? raw : unmultiply(raw)) & mask) >>> 0, target)) {
+                into[to] = fill;
+                count++;
+            }
+            else if (copySource) {
+                into[to] = (raw | opaque) >>> 0;
+            }
+        }
+    }
+    store.changed();
+    return count;
+}
+/**
+ * getColorBoundsRect: the smallest rect holding every pixel whose
+ * unmultiplied value, masked, is `color` (or is not, without findColor);
+ * empty where none is, and where the one found is the pixel at the
+ * origin alone, as Flash has it (Ruffle's bitmap_data). With
+ * `premultiplied`, as AVM1's BitmapData has it (Ruffle's operations.rs),
+ * the pixel is compared as it is kept, premultiplied, masked, with the
+ * colour premultiplied and not masked, and an opaque bitmap's alpha is
+ * in the mask.
+ */
+export function colorBounds(store, mask, color, find, premultiplied = false) {
+    let x0 = store.width;
+    let y0 = store.height;
+    let x1 = -1;
+    let y1 = -1;
+    if (premultiplied && !store.transparent) {
+        mask = (mask | 0xff000000) >>> 0;
+    }
+    const target = premultiplied ? store.premultiplied(color >>> 0) : (color & mask) >>> 0;
+    for (let y = 0; y < store.height; y++) {
+        for (let x = 0; x < store.width; x++) {
+            const pixel = store.pixels[y * store.width + x];
+            const hit = ((premultiplied ? pixel : unmultiply(pixel)) & mask) >>> 0 === target;
+            if (hit === find) {
+                x0 = Math.min(x0, x);
+                y0 = Math.min(y0, y);
+                x1 = Math.max(x1, x);
+                y1 = Math.max(y1, y);
+            }
+        }
+    }
+    // Flash takes extents that end at the origin for none found: a lone hit at (0, 0) gives an empty rect.
+    return x1 <= 0 && y1 <= 0
+        ? { x: 0, y: 0, width: 0, height: 0 }
+        : { x: x0, y: y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+}
+/** floodFill: the 4-connected region of the start pixel's exact value set to `color`. */
+export function floodFill(store, x, y, color) {
+    const { width, height } = store;
+    if (x < 0 || y < 0 || x >= width || y >= height) {
+        return;
+    }
+    const from = store.pixels[y * width + x];
+    const to = store.premultiplied(color >>> 0);
+    if (from === to) {
+        return;
+    }
+    const stack = [y * width + x];
+    while (stack.length) {
+        const i = stack.pop();
+        if (store.pixels[i] !== from) {
+            continue;
+        }
+        store.pixels[i] = to;
+        const px = i % width;
+        if (px > 0) {
+            stack.push(i - 1);
+        }
+        if (px < width - 1) {
+            stack.push(i + 1);
+        }
+        if (i >= width) {
+            stack.push(i - width);
+        }
+        if (i + width < width * height) {
+            stack.push(i + width);
+        }
+    }
+    store.changed();
+}
+/** histogram: four arrays of 256 counts, red, green, blue and alpha, of the rect's unmultiplied pixels. */
+export function histogram(store, rect) {
+    const counts = [0, 1, 2, 3].map(() => new Array(256).fill(0));
+    const c = store.clip(rect);
+    if (!c) {
+        return counts;
+    }
+    for (let y = c.y; y < c.y + c.height; y++) {
+        for (let x = c.x; x < c.x + c.width; x++) {
+            const p = unmultiply(store.pixels[y * store.width + x]);
+            counts[0][(p >>> 16) & 0xff]++;
+            counts[1][(p >>> 8) & 0xff]++;
+            counts[2][p & 0xff]++;
+            counts[3][p >>> 24]++;
+        }
+    }
+    return counts;
+}
+/** The unmultiplied alpha at (x, y), as a hit test reads it: an opaque bitmap's 255; -1 outside. */
+export function alphaAt(store, x, y) {
+    if (x < 0 || y < 0 || x >= store.width || y >= store.height) {
+        return -1;
+    }
+    return store.transparent ? store.readable[y * store.width + x] >>> 24 : 255;
+}
+/**
+ * Flash's pixelDissolve taps, by the state's width in bits: a Galois LFSR,
+ * s >> 1, xor the tap where s was odd, read off adl for every width a
+ * BitmapData can have (2 to 26 bits).
+ */
+const DISSOLVE_TAPS = [
+    0, 0, 3, 6, 12, 20, 48, 96, 184, 272, 576, 1280, 3232, 6912, 13568, 24576, 46080, 73728, 132096,
+    466944, 589824, 1310720, 3145728, 4325376, 14155776, 18874368, 59244544,
+];
+/** Bits to number 0..n - 1: ceil(log2(n)). */
+function bitsFor(n) {
+    return n <= 1 ? 0 : 32 - Math.clz32(n - 1);
+}
+/**
+ * pixelDissolve as Flash does it, fitted under adl: a state of
+ * ceil(log2 w) + ceil(log2 h) bits stands for the pixel (s & (2^bw - 1),
+ * s >> bw) of the rect, a state outside it skipped; each call writes
+ * numPixels pixels, from the seed on, and returns the state after the
+ * last, raw, so the next call goes on from there. Every call writes the
+ * pixel at the origin too, which no state stands for, and so n calls of
+ * 1 write n + 1 (Ruffle's bitmapdata_pixeldissolve); 0 starts at the tap,
+ * and a seed past the generator's states steps down to them as any state
+ * does, its bits shifted out, or to 0, which writes the origin for good. A
+ * pixel takes the fill colour where the source is the destination, and
+ * there it is the source rect that dissolves, the point aside, though
+ * clipped as a copy's; else the source's pixel. A rect a pixel high or
+ * wide dissolves nothing and gives the seed back as it came; a count of 0
+ * writes the origin alone and gives the seed back, the tap for 0. AS3's
+ * answers are AVM1's (the dissolve-noise case).
+ */
+export function pixelDissolve(store, source, rect, dx, dy, seed, count, fill) {
+    // Over the rect clipped to the source and then to the destination, as the copies are.
+    const sc = source.clip(rect);
+    if (!sc) {
+        return seed;
+    }
+    const ox = dx + (sc.x - rect.x);
+    const oy = dy + (sc.y - rect.y);
+    const dc = store.clip({ x: ox, y: oy, width: sc.width, height: sc.height });
+    if (!dc) {
+        return seed;
+    }
+    const rx = sc.x + (dc.x - ox);
+    const ry = sc.y + (dc.y - oy);
+    dx = dc.x;
+    dy = dc.y;
+    const { width: w, height: h } = dc;
+    if (w <= 1 || h <= 1) {
+        return seed;
+    }
+    const bw = bitsFor(w);
+    const bits = bw + bitsFor(h);
+    const tap = DISSOLVE_TAPS[bits] ?? 0;
+    const xMask = (1 << bw) - 1;
+    const color = store.premultiplied(fill >>> 0);
+    // An opaque store keeps every alpha at 255, as threshold's copies have it.
+    const opaque = store.transparent ? 0 : 0xff000000;
+    const next = (s) => (s & 1 ? (s >>> 1) ^ tap : s >>> 1);
+    // A position of the rect, written where it lies in both bitmaps.
+    const write = (state) => {
+        const px = state & xMask;
+        const py = Math.floor(state / 2 ** bw);
+        const sx = rx + px;
+        const sy = ry + py;
+        // In place, Flash fills the source rect's pixels, wherever the point is.
+        const tx = source === store ? sx : dx + px;
+        const ty = source === store ? sy : dy + py;
+        if (sx < 0 ||
+            sy < 0 ||
+            sx >= source.width ||
+            sy >= source.height ||
+            tx < 0 ||
+            ty < 0 ||
+            tx >= store.width ||
+            ty >= store.height) {
+            return;
+        }
+        store.pixels[ty * store.width + tx] =
+            source === store ? color : (source.pixels[sy * source.width + sx] | opaque) >>> 0;
+    };
+    const inside = (state) => (state & xMask) < w && Math.floor(state / 2 ** bw) < h;
+    // The origin is written on every call; 0, which no state within the
+    // generator's steps to (a seed past them may), starts at the tap.
+    write(0);
+    if (seed === 0) {
+        seed = tap;
+    }
+    if (count === 0) {
+        store.changed();
+        return seed;
+    }
+    let s = seed >>> 0;
+    // The states inside the rect come round every w * h - 1 writes (state 0
+    // is the origin's, which only a seed past the states steps down to, and
+    // stays at), so a count past that is one full round, which writes every
+    // pixel, and the remainder: the same pixels and the seed Flash returns,
+    // without its seconds-long loop.
+    const round = w * h - 1;
+    const steps = count > round ? round + (count % round) : count;
+    for (let k = 0; k < steps; k++) {
+        // A seed's bits past the states shift out, and every state then comes
+        // round within 2^bits steps, so this ends.
+        while (!inside(s)) {
+            s = next(s);
+        }
+        write(s);
+        s = next(s);
+    }
+    store.changed();
+    return s;
+}
+// The blend modes draw composites with, as the numbers the pixel loops take,
+// worked out once a draw.
+const NORMAL = 0;
+const MULTIPLY = 1;
+const SCREEN = 2;
+const LIGHTEN = 3;
+const DARKEN = 4;
+const DIFFERENCE = 5;
+const ADD = 6;
+const SUBTRACT = 7;
+const INVERT = 8;
+const OVERLAY = 9;
+const HARDLIGHT = 10;
+const ERASE = 11;
+const ALPHA = 12;
+/**
+ * Each blend mode draw takes, by its name; any other draws nothing. Alpha
+ * and erase need a layer: a display object drawn has one, and they then
+ * scale the destination's alpha where it covers; a BitmapData drawn has
+ * not, and they do nothing.
+ */
+const MODES = new Map([
+    ["normal", NORMAL],
+    ["layer", NORMAL],
+    ["multiply", MULTIPLY],
+    ["screen", SCREEN],
+    ["lighten", LIGHTEN],
+    ["darken", DARKEN],
+    ["difference", DIFFERENCE],
+    ["add", ADD],
+    ["subtract", SUBTRACT],
+    ["invert", INVERT],
+    ["overlay", OVERLAY],
+    ["hardlight", HARDLIGHT],
+    ["erase", ERASE],
+    ["alpha", ALPHA],
+]);
+/**
+ * draw of a bitmap source: each destination pixel in the clip takes the
+ * source pixel under its centre, through the matrix's inverse, clamped to
+ * the source's edges (bilinear when smoothing), scaled by how much of the
+ * pixel the transformed source covers (a 4 x 4 sample grid), passed
+ * through the colour transform as colorTransform does, and composited by
+ * the blend mode. Flash's own pixels, under adl: nearest at the centre,
+ * normal as the store's source-over, alpha and erase as nothing unless the
+ * source is a display object's `layer`: a Bitmap's, every pixel of which it
+ * covers, or a drawing's snapshot, which covers only where it drew.
+ */
+export function drawBitmap(store, source, m, ct, mode, clip, smooth, rows = false, layer = null) {
+    const code = MODES.get(mode);
+    const whole = code === ERASE || code === ALPHA;
+    if (code === undefined || (whole && layer === null)) {
+        return;
+    }
+    // A drawing's alpha blend leaves the destination where it drew nothing, or drew clear (adl).
+    const keepClear = code === ALPHA && layer === "drawing";
+    // Flash rasterises the translation snapped down to quarter pixels, which
+    // its 4 x 4 coverage then reads exactly (a move of 0.49 covers 3/4 and
+    // 1/4 of the edge pixels under adl).
+    m = { ...m, tx: Math.floor(m.tx * 4) / 4, ty: Math.floor(m.ty * 4) / 4 };
+    const det = m.a * m.d - m.b * m.c;
+    if (det === 0) {
+        return;
+    }
+    // The destination pixels the source can reach: its corners through the matrix.
+    const corners = [
+        [0, 0],
+        [source.width, 0],
+        [0, source.height],
+        [source.width, source.height],
+    ].map(([x, y]) => [m.a * x + m.c * y + m.tx, m.b * x + m.d * y + m.ty]);
+    const xs = corners.map((p) => p[0]);
+    const ys = corners.map((p) => p[1]);
+    let area = store.clip({
+        x: Math.floor(Math.min(...xs)),
+        y: Math.floor(Math.min(...ys)),
+        width: Math.ceil(Math.max(...xs)) - Math.floor(Math.min(...xs)),
+        height: Math.ceil(Math.max(...ys)) - Math.floor(Math.min(...ys)),
+    });
+    if (area && clip) {
+        area = store.clip({
+            x: Math.max(area.x, clip.x),
+            y: Math.max(area.y, clip.y),
+            width: Math.min(area.x + area.width, clip.x + clip.width) - Math.max(area.x, clip.x),
+            height: Math.min(area.y + area.height, clip.y + clip.height) - Math.max(area.y, clip.y),
+        });
+    }
+    if (!area) {
+        return;
+    }
+    // A layer's blend reads the source as it was: of a Bitmap of the bitmap itself, the part
+    // that can reach the area is copied first.
+    if (whole && source === store) {
+        [source, m] = reachable(store, m, area);
+    }
+    const transform = ct ? prepareColorTransform(ct) : null;
+    // Unscaled at a whole pixel, as every snapshot of a display object is
+    // composited: each covered pixel is covered whole and is the source's
+    // own, so it is copied straight, as the general path below would.
+    const moved = m.a === 1 &&
+        m.b === 0 &&
+        m.c === 0 &&
+        m.d === 1 &&
+        Number.isInteger(m.tx) &&
+        Number.isInteger(m.ty) &&
+        source !== store;
+    // The inverse: from a destination point to the source's.
+    const ia = m.d / det;
+    const ib = -m.b / det;
+    const ic = -m.c / det;
+    const id = m.a / det;
+    const itx = -(ia * m.tx + ic * m.ty);
+    const ity = -(ib * m.tx + id * m.ty);
+    if (code === NORMAL && source !== store) {
+        const inverse = job.inverse;
+        inverse[0] = ia;
+        inverse[1] = ib;
+        inverse[2] = ic;
+        inverse[3] = id;
+        inverse[4] = itx;
+        inverse[5] = ity;
+        if (drawnNatively(store, source, m, moved, area, transform, smooth)) {
+            return;
+        }
+    }
+    if (moved) {
+        if (composite(store, source, area, m.tx, m.ty, transform, code, keepClear)) {
+            store.changed();
+        }
+        return;
+    }
+    // How many of the pixel's 4 x 4 samples fall inside the source.
+    const coverage = (x, y) => {
+        let hits = 0;
+        for (let k = 0; k < 16; k++) {
+            const px = x + ((k & 3) + 0.5) / 4;
+            const py = y + ((k >> 2) + 0.5) / 4;
+            const sx = ia * px + ic * py + itx;
+            const sy = ib * px + id * py + ity;
+            if (sx >= 0 && sy >= 0 && sx < source.width && sy < source.height) {
+                hits++;
+            }
+        }
+        return hits;
+    };
+    // The arrays taken once. What the source reads as: its own pixels drawn into itself, else as
+    // a draw reads them. The store's, which bring back what the GPU drew last or copy a library
+    // bitmap's, are taken at the first pixel put, but first when the source is the store, which
+    // reads them as written.
+    let into = source === store ? store.pixels : null;
+    const pixels = source === store ? source.readable : source.drawable;
+    // Whether a pixel was put, for the store to count a change: a draw that puts none is none.
+    let wrote = false;
+    // Through a Bitmap of itself, a BitmapData is drawn in plain scan order,
+    // each pixel reading what the ones before it wrote, which smears both
+    // ways (adl): pixel by pixel. A layer's blend has a copy of it by now.
+    if (source === store && !rows) {
+        for (let y = area.y; y < area.y + area.height; y++) {
+            for (let x = area.x; x < area.x + area.width; x++) {
+                const hits = coverage(x, y);
+                if (hits === 0) {
+                    continue;
+                }
+                const cx = x + 0.5;
+                const cy = y + 0.5;
+                const sx = ia * cx + ic * cy + itx;
+                const sy = ib * cx + id * cy + ity;
+                let p = smooth
+                    ? bilinear(pixels, source.width, source.height, sx - 0.5, sy - 0.5)
+                    : nearest(pixels, source.width, source.height, sx, sy);
+                if (transform) {
+                    p = transformed(p, transform);
+                }
+                if (hits < 16) {
+                    p = scaleBy(p, hits / 16);
+                }
+                into ??= store.pixels;
+                put(store, into, y * store.width + x, code, p);
+                wrote = true;
+            }
+        }
+        if (wrote) {
+            store.changed();
+        }
+        return;
+    }
+    // Otherwise a row at a time, each pass over it in a loop of its own, so
+    // that no pixel crosses a call: a pixel past 2^30 a call returns is a
+    // number V8 allocates. Every pixel of a row is read before one is
+    // written, which is how Flash draws a BitmapData into itself: a move
+    // right keeps the pixels, a move down smears rows.
+    const n = area.width;
+    const buffers = takeRows(n);
+    try {
+        const { pixels: row, hits, us, vs } = buffers;
+        const w = source.width;
+        const h = source.height;
+        for (let y = area.y; y < area.y + area.height; y++) {
+            // Where all 16 samples of a pixel surely fall inside the source, and
+            // where none can: only the pixels between are tested sample by sample.
+            spanFrom = Number.NEGATIVE_INFINITY;
+            spanTo = Number.POSITIVE_INFINITY;
+            const spans = !whole && coveredSpan(ia, ic, itx, w, y) && coveredSpan(ib, id, ity, h, y);
+            const fullFrom = spans ? Math.max(area.x, spanFrom) : 0;
+            const fullTo = spans ? Math.min(area.x + n, spanTo) : 0;
+            let any = 0;
+            for (let x = area.x, k = 0; k < n; x++, k++) {
+                const cx = x + 0.5;
+                const cy = y + 0.5;
+                const sx = ia * cx + ic * cy + itx;
+                const sy = ib * cx + id * cy + ity;
+                let hit = 16;
+                if (whole) {
+                    // Erase and alpha take a pixel whole where the source is at its centre, as adl
+                    // draws a shape's edge for them, an edge through the centre counted on its right
+                    // and below.
+                    hit = sx > 0 && sy > 0 && sx <= w && sy <= h ? 16 : 0;
+                }
+                else if (x < fullFrom || x >= fullTo) {
+                    hit = coverage(x, y);
+                }
+                hits[k] = hit;
+                if (hit === 0) {
+                    continue;
+                }
+                any++;
+                us[k] = sx;
+                vs[k] = sy;
+            }
+            if (any === 0) {
+                continue;
+            }
+            sampleRow(pixels, w, h, us, vs, hits, row, n, smooth);
+            if (transform) {
+                transformRow(row, hits, n, transform);
+            }
+            coverRow(row, hits, n);
+            into ??= store.pixels;
+            blendRow(store, into, y * store.width + area.x, row, hits, n, code, keepClear);
+            wrote = true;
+        }
+    }
+    finally {
+        giveRowsBack(buffers);
+    }
+    if (wrote) {
+        store.changed();
+    }
+}
+/** The draw kernel's job, filled for each draw: drawBitmap allocates nothing for it. */
+const job = DrawKernel.job();
+/** How far a source point may lie for the draw kernel, whose numbers are then exact as drawBitmap's. */
+const REACH = 2 ** 30;
+/**
+ * A draw in the normal blend mode of another store, by the draw kernel
+ * (draw.zig), whose pixels are those of the paths below, to the bit, the
+ * matrix's inverse in `job.inverse` already: whether it drew it, which it
+ * does not for numbers it cannot take as they are, nor where the realm has
+ * no kernel.
+ */
+function drawnNatively(store, source, m, moved, area, ct, smooth) {
+    // A store the GPU drew last is read back only by a draw that puts a pixel, as below.
+    if (store.newerOnGpu) {
+        return false;
+    }
+    // The source rows the draw reads: the area's, moved; else those its corners reach, and one
+    // more each way for smoothing and rounding. A point far out, or not finite, is drawn below.
+    const inverse = job.inverse;
+    let top;
+    let bottom;
+    if (moved) {
+        if (Math.abs(m.tx) >= 2 ** 31 || Math.abs(m.ty) >= 2 ** 31) {
+            return false;
+        }
+        top = area.y - m.ty;
+        bottom = top + area.height;
+    }
+    else {
+        const x0 = area.x;
+        const x1 = area.x + area.width;
+        const y0 = area.y;
+        const y1 = area.y + area.height;
+        const ia = inverse[0];
+        const ib = inverse[1];
+        const ic = inverse[2];
+        const id = inverse[3];
+        const itx = inverse[4];
+        const ity = inverse[5];
+        const ya = ib * x0 + id * y0 + ity;
+        const yb = ib * x1 + id * y0 + ity;
+        const yc = ib * x0 + id * y1 + ity;
+        const yd = ib * x1 + id * y1 + ity;
+        const xa = ia * x0 + ic * y0 + itx;
+        const xb = ia * x1 + ic * y0 + itx;
+        const xc = ia * x0 + ic * y1 + itx;
+        const xd = ia * x1 + ic * y1 + itx;
+        const low = Math.min(ya, yb, yc, yd);
+        const high = Math.max(ya, yb, yc, yd);
+        const far = Math.max(Math.abs(xa), Math.abs(xb), Math.abs(xc), Math.abs(xd));
+        if (!(Math.abs(low) < REACH && Math.abs(high) < REACH && far < REACH)) {
+            return false;
+        }
+        top = Math.max(0, Math.min(source.height - 1, Math.floor(low) - 1));
+        bottom = Math.max(top + 1, Math.min(source.height, Math.ceil(high) + 1));
+    }
+    if (ct) {
+        const t = job.transform;
+        t[0] = ct.rMul;
+        t[1] = ct.gMul;
+        t[2] = ct.bMul;
+        t[3] = ct.aMul;
+        t[4] = ct.rAdd;
+        t[5] = ct.gAdd;
+        t[6] = ct.bAdd;
+        t[7] = ct.aAdd;
+        if (!t.every(Number.isFinite)) {
+            return false;
+        }
+    }
+    // Copying wide source rows for a small clip can cost more than the draw.
+    // Whole-pixel moves do less work per destination pixel, so their limit is lower.
+    const sourcePixels = source.width * (bottom - top);
+    const copiedPerPixel = moved ? 32 : 128;
+    if (sourcePixels > Math.max(1024, area.width * area.height * copiedPerPixel)) {
+        return false;
+    }
+    const kernel = drawKernel();
+    if (!kernel) {
+        return false;
+    }
+    job.source = source.drawable;
+    job.sourceWidth = source.width;
+    job.sourceHeight = source.height;
+    job.sourceTop = top;
+    job.sourceRows = bottom - top;
+    job.into = store.readable;
+    job.intoWidth = store.width;
+    job.x = area.x;
+    job.y = area.y;
+    job.width = area.width;
+    job.height = area.height;
+    job.moved = moved;
+    job.tx = moved ? m.tx : 0;
+    job.ty = moved ? m.ty : 0;
+    job.flags =
+        (smooth ? DRAW_SMOOTH : 0) |
+            (ct ? DRAW_TRANSFORM : 0) |
+            (store.transparent ? 0 : DRAW_OPAQUE) |
+            (ct?.skipZeroAlpha ? DRAW_SKIP_ZERO_ALPHA : 0);
+    const result = kernel.draw(job);
+    // The job holds no store's pixels past the draw.
+    job.source = EMPTY;
+    job.into = EMPTY;
+    if (result === "refused") {
+        return false;
+    }
+    if (result === "written") {
+        kernel.writeBack(job, store.pixels);
+        store.changed();
+    }
+    return true;
+}
+const EMPTY = new Uint32Array(0);
+/**
+ * The row buffers kept between draws, which drawBitmap and composite take
+ * for a draw and give back after it. A draw runs to its end without
+ * calling out, so no other draw can take them in the middle of one:
+ * `scratchTaken` holds that, and a draw that finds them taken throws
+ * rather than overwrite a row another is working on.
+ */
+let scratch = {
+    pixels: new Uint32Array(0),
+    hits: new Uint8Array(0),
+    us: new Float64Array(0),
+    vs: new Float64Array(0),
+};
+let scratchTaken = false;
+/** The widest row whose buffers are kept for the next draw: a wider one's go with its draw. */
+const ROW_KEPT = 8192;
+/** Buffers for rows of `n` pixels: the kept ones where they are wide enough, until given back. */
+function takeRows(n) {
+    if (scratch.pixels.length >= n) {
+        if (scratchTaken) {
+            throw new Error("drawBitmap's row buffers are taken by a draw already under way");
+        }
+        scratchTaken = true;
+        return scratch;
+    }
+    const buffers = {
+        pixels: new Uint32Array(n),
+        hits: new Uint8Array(n),
+        us: new Float64Array(n),
+        vs: new Float64Array(n),
+    };
+    if (n <= ROW_KEPT && !scratchTaken) {
+        scratch = buffers;
+        scratchTaken = true;
+    }
+    return buffers;
+}
+function giveRowsBack(buffers) {
+    if (buffers === scratch) {
+        scratchTaken = false;
+    }
+}
+/** coveredSpan's answer: the first pixel of a row covered whole and the one past the last. */
+let spanFrom = 0;
+let spanTo = 0;
+/**
+ * Narrows spanFrom to spanTo, the destination pixels in row y whose 16 samples
+ * all have u = a x + c y' + t within [0, size), y' each of the row's four
+ * sample rows; false where u barely moves along x without being still,
+ * which leaves every pixel to be tested. The span keeps a margin of a
+ * thousandth of a pixel, and more where the numbers are large, from where
+ * the samples' own arithmetic decides, so a pixel in it is one the tests
+ * find whole.
+ */
+function coveredSpan(a, c, t, size, y) {
+    if (a === 0) {
+        // u is the same all along a sample row, worked out as the tests do.
+        for (let k = 0; k < 4; k++) {
+            const u = c * (y + (k + 0.5) / 4) + t;
+            if (!(u >= 0 && u < size)) {
+                spanFrom = Number.POSITIVE_INFINITY;
+            }
+        }
+        return true;
+    }
+    if (Math.abs(a) < 1e-6) {
+        return false;
+    }
+    for (let k = 0; k < 4; k++) {
+        const offset = c * (y + (k + 0.5) / 4) + t;
+        // The x where u is 0 and where it is size, in either order.
+        const at0 = -offset / a;
+        const atSize = (size - offset) / a;
+        const margin = 0.001 +
+            (1e-12 * (Math.abs(offset) + size + Math.abs(a) * (Math.abs(at0) + Math.abs(atSize)))) /
+                Math.abs(a);
+        const low = Math.min(at0, atSize) + margin;
+        const high = Math.max(at0, atSize) - margin;
+        if (!Number.isFinite(low) || !Number.isFinite(high)) {
+            return false;
+        }
+        // Samples lie at x + 1/8 to x + 7/8.
+        spanFrom = Math.max(spanFrom, Math.ceil(low - 0.125));
+        spanTo = Math.min(spanTo, Math.floor(high - 0.875) + 1);
+    }
+    return true;
+}
+/** The source's pixel under each covered pixel's point of the row, nearest or bilinear. */
+function sampleRow(from, width, height, us, vs, hits, row, n, smooth) {
+    for (let k = 0; k < n; k++) {
+        if (hits[k] === 0) {
+            continue;
+        }
+        row[k] = smooth
+            ? bilinear(from, width, height, us[k] - 0.5, vs[k] - 0.5)
+            : nearest(from, width, height, us[k], vs[k]);
+    }
+}
+/** The row's covered pixels through the colour transform, a run of one pixel transformed once. */
+function transformRow(row, hits, n, ct) {
+    let last = -1;
+    let out = 0;
+    for (let k = 0; k < n; k++) {
+        if (hits[k] === 0) {
+            continue;
+        }
+        const p = row[k];
+        if (p !== last) {
+            last = p;
+            out = transformed(p, ct);
+        }
+        row[k] = out;
+    }
+}
+/** The row's partly covered pixels scaled by their coverage. */
+function coverRow(row, hits, n) {
+    for (let k = 0; k < n; k++) {
+        const hit = hits[k];
+        if (hit !== 0 && hit < 16) {
+            row[k] = scaleBy(row[k], hit / 16);
+        }
+    }
+}
+/**
+ * The row's covered pixels composited into the store's pixels from `at` by
+ * the blend mode; with `keepClear`, a clear one leaves the destination be.
+ */
+function blendRow(store, into, at, row, hits, n, mode, keepClear) {
+    if (mode === NORMAL) {
+        const opaque = store.transparent ? 0 : 0xff000000;
+        for (let k = 0; k < n; k++) {
+            if (hits[k] === 0) {
+                continue;
+            }
+            const p = row[k];
+            const sa = p >>> 24;
+            into[at + k] = sa === 255 ? p : (over(p, into[at + k]) | opaque) >>> 0;
+        }
+        return;
+    }
+    for (let k = 0; k < n; k++) {
+        if (hits[k] !== 0 && !(keepClear && row[k] >>> 24 === 0)) {
+            put(store, into, at + k, mode, row[k]);
+        }
+    }
+}
+/** `source` at (tx, ty) composited into `area` of the store, a pixel each; whether it put one. */
+function composite(store, source, area, tx, ty, ct, mode, keepClear) {
+    const from = source.drawable;
+    const opaque = store.transparent ? 0 : 0xff000000;
+    // The store's pixels, taken as drawBitmap takes them: at the first pixel put.
+    let into = null;
+    if (!ct && mode === NORMAL) {
+        for (let y = area.y; y < area.y + area.height; y++) {
+            let i = y * store.width + area.x;
+            let j = (y - ty) * source.width + (area.x - tx);
+            for (let x = 0; x < area.width; x++, i++, j++) {
+                // Source over, inline: what blend("normal") computes.
+                const p = from[j];
+                const sa = p >>> 24;
+                if (sa === 0) {
+                    continue;
+                }
+                into ??= store.pixels;
+                into[i] = sa === 255 ? p : (over(p, into[i]) | opaque) >>> 0;
+            }
+        }
+        return into !== null;
+    }
+    // A row at a time through the passes drawBitmap's rows take, every pixel covered.
+    const n = area.width;
+    const buffers = takeRows(n);
+    try {
+        const { pixels: row, hits } = buffers;
+        hits.fill(16, 0, n);
+        into = store.pixels;
+        for (let y = area.y; y < area.y + area.height; y++) {
+            const j = (y - ty) * source.width + (area.x - tx);
+            // A view and a copy: a loop copying it was slower, for all a view allocates.
+            row.set(from.subarray(j, j + n));
+            if (ct) {
+                transformRow(row, hits, n, ct);
+            }
+            blendRow(store, into, y * store.width + area.x, row, hits, n, mode, keepClear);
+        }
+    }
+    finally {
+        giveRowsBack(buffers);
+    }
+    return true;
+}
+/**
+ * A drawn pixel composited into the store by the blend mode, opaque where
+ * the store is, but for erase and alpha: an opaque bitmap holds the alpha
+ * they leave, as Flash's memory does, and reads it back (getPixel32).
+ */
+function put(store, into, i, mode, p) {
+    const out = blend(mode, p, into[i]);
+    if (store.transparent) {
+        into[i] = out;
+    }
+    else if (mode === ERASE || mode === ALPHA) {
+        into[i] = out;
+        store.holdsAlpha ||= out >>> 24 !== 255;
+    }
+    else {
+        into[i] = (out | 0xff000000) >>> 0;
+    }
+}
+/**
+ * The part of `store` a draw of itself through `m` into `area` can read,
+ * copied, as a layer reads it before the draw writes, and the matrix that
+ * draws the copy where the store would be drawn: the area's corners taken
+ * back through the matrix, a pixel wider for smoothing, within the store.
+ */
+function reachable(store, m, area) {
+    const det = m.a * m.d - m.b * m.c;
+    const back = [
+        [area.x, area.y],
+        [area.x + area.width, area.y],
+        [area.x, area.y + area.height],
+        [area.x + area.width, area.y + area.height],
+    ].map(([x, y]) => [
+        (m.d * (x - m.tx) - m.c * (y - m.ty)) / det,
+        (m.a * (y - m.ty) - m.b * (x - m.tx)) / det,
+    ]);
+    const x0 = Math.max(0, Math.floor(Math.min(...back.map((p) => p[0]))) - 1);
+    const y0 = Math.max(0, Math.floor(Math.min(...back.map((p) => p[1]))) - 1);
+    const x1 = Math.min(store.width, Math.ceil(Math.max(...back.map((p) => p[0]))) + 1);
+    const y1 = Math.min(store.height, Math.ceil(Math.max(...back.map((p) => p[1]))) + 1);
+    const width = Math.max(0, x1 - x0);
+    const height = Math.max(0, y1 - y0);
+    const copy = new BitmapStore(width, height, store.transparent, 0);
+    const from = store.readable;
+    const into = copy.pixels;
+    for (let y = 0; y < height; y++) {
+        into.set(from.subarray((y0 + y) * store.width + x0, (y0 + y) * store.width + x0 + width), y * width);
+    }
+    copy.holdsAlpha = store.holdsAlpha;
+    return [copy, { ...m, tx: m.tx + m.a * x0 + m.c * y0, ty: m.ty + m.b * x0 + m.d * y0 }];
+}
+function nearest(from, width, height, x, y) {
+    const px = Math.min(width - 1, Math.max(0, Math.floor(x)));
+    const py = Math.min(height - 1, Math.max(0, Math.floor(y)));
+    return from[py * width + px];
+}
+/** Bilinear between the four premultiplied pixels round (x, y), clamped to the edges. */
+function bilinear(from, width, height, x, y) {
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const fx = x - x0;
+    const fy = y - y0;
+    const left = Math.min(width - 1, Math.max(0, x0));
+    const right = Math.min(width - 1, Math.max(0, x0 + 1));
+    const top = Math.min(height - 1, Math.max(0, y0)) * width;
+    const bottom = Math.min(height - 1, Math.max(0, y0 + 1)) * width;
+    const p00 = from[top + left];
+    const p10 = from[top + right];
+    const p01 = from[bottom + left];
+    const p11 = from[bottom + right];
+    const gx = 1 - fx;
+    const gy = 1 - fy;
+    return (((lerp4(p00, p10, p01, p11, 24, fx, fy, gx, gy) << 24) |
+        (lerp4(p00, p10, p01, p11, 16, fx, fy, gx, gy) << 16) |
+        (lerp4(p00, p10, p01, p11, 8, fx, fy, gx, gy) << 8) |
+        lerp4(p00, p10, p01, p11, 0, fx, fy, gx, gy)) >>>
+        0);
+}
+/** One channel of bilinear's four pixels, weighed by fx and fy and by gx and gy, their complements. */
+function lerp4(p00, p10, p01, p11, shift, fx, fy, gx, gy) {
+    const top = ((p00 >>> shift) & 0xff) * gx + ((p10 >>> shift) & 0xff) * fx;
+    const bottom = ((p01 >>> shift) & 0xff) * gx + ((p11 >>> shift) & 0xff) * fx;
+    return Math.round(top * gy + bottom * fy);
+}
+/** A premultiplied pixel through a colour transform, as colorTransform computes it. */
+function transformed(p, ct) {
+    const a0 = p >>> 24;
+    if (a0 === 0 && ct.skipZeroAlpha) {
+        return 0;
+    }
+    const a = colorChannel(a0, ct.aMul, ct.aAdd);
+    return (((a << 24) |
+        (drawColorChannel(p, a0, 16, ct.rMul, ct.rAdd, a) << 16) |
+        (drawColorChannel(p, a0, 8, ct.gMul, ct.gAdd, a) << 8) |
+        drawColorChannel(p, a0, 0, ct.bMul, ct.bAdd, a)) >>>
+        0);
+}
+function prepareColorTransform(ct) {
+    return {
+        rMul: Math.trunc(ct.rMul * 256),
+        gMul: Math.trunc(ct.gMul * 256),
+        bMul: Math.trunc(ct.bMul * 256),
+        aMul: Math.trunc(ct.aMul * 256),
+        rAdd: Math.trunc(ct.rAdd),
+        gAdd: Math.trunc(ct.gAdd),
+        bAdd: Math.trunc(ct.bAdd),
+        aAdd: Math.trunc(ct.aAdd),
+        // The alpha-zero guard tests the original offset before truncation.
+        skipZeroAlpha: ct.aAdd <= 0,
+    };
+}
+// These stay outside the pixel loops so a transform creates no per-pixel closures.
+function colorChannel(v, mul, add) {
+    return Math.max(0, Math.min(255, Math.floor((v * mul) / 256) + add));
+}
+function straightChannel(p, alpha, shift) {
+    return alpha === 0 ? 0 : Math.min(255, Math.floor((((p >>> shift) & 0xff) * 255) / alpha));
+}
+function premultipliedChannel(v, alpha) {
+    return alpha === 255 ? v : (v * (alpha + 1)) >> 8;
+}
+function drawColorChannel(p, alpha, shift, mul, add, outAlpha) {
+    const v = colorChannel(straightChannel(p, alpha, shift), mul, add);
+    return premultipliedChannel(v, outAlpha);
+}
+/** A premultiplied pixel with all four channels scaled by a coverage. */
+function scaleBy(p, f) {
+    return (((Math.round((p >>> 24) * f) << 24) |
+        (Math.round(((p >>> 16) & 0xff) * f) << 16) |
+        (Math.round(((p >>> 8) & 0xff) * f) << 8) |
+        Math.round((p & 0xff) * f)) >>>
+        0);
+}
+/**
+ * The destination alone, as erase and alpha leave it: each channel scaled
+ * by k / 255, what the source's alpha leaves or is, floored, as adl's are.
+ */
+function scaleFloored(d, k) {
+    const a = Math.floor(((d >>> 24) * k) / 255);
+    const r = Math.floor((((d >>> 16) & 0xff) * k) / 255);
+    const g = Math.floor((((d >>> 8) & 0xff) * k) / 255);
+    const b = Math.floor(((d & 0xff) * k) / 255);
+    return ((a << 24) | (r << 16) | (g << 8) | b) >>> 0;
+}
+/** x * y / 255, rounded as the blend modes' arithmetic has it. */
+function mul(x, y) {
+    return (x * y + 127) / 255;
+}
+/**
+ * Premultiplied s over d by a blend mode, the W3C's compositing with each
+ * mode's mix. Every helper takes its operands as arguments, so a pixel
+ * allocates nothing: a closure over them would take a context each call.
+ */
+function blend(mode, s, d) {
+    if (mode === NORMAL) {
+        return over(s, d);
+    }
+    const sa = s >>> 24;
+    if (mode === ERASE || mode === ALPHA) {
+        return scaleFloored(d, mode === ERASE ? 255 - sa : sa);
+    }
+    const da = d >>> 24;
+    const a = mode === ADD || mode === SUBTRACT
+        ? Math.min(255, sa + da)
+        : Math.min(255, Math.round(sa + da - mul(sa, da)));
+    return (((a << 24) |
+        (blendChannel(mode, (s >>> 16) & 0xff, (d >>> 16) & 0xff, sa, da) << 16) |
+        (blendChannel(mode, (s >>> 8) & 0xff, (d >>> 8) & 0xff, sa, da) << 8) |
+        blendChannel(mode, s & 0xff, d & 0xff, sa, da)) >>>
+        0);
+}
+/** A colour channel of blend: source cs and destination cd under alphas sa and da. */
+function blendChannel(mode, cs, cd, sa, da) {
+    let b;
+    switch (mode) {
+        case MULTIPLY:
+            b = mul(cs, cd);
+            break;
+        case SCREEN:
+            b = (cs * da) / 255 + (cd * sa) / 255 - mul(cs, cd);
+            break;
+        case LIGHTEN:
+            b = Math.max(mul(cs, da), mul(cd, sa));
+            break;
+        case DARKEN:
+            b = Math.min(mul(cs, da), mul(cd, sa));
+            break;
+        case DIFFERENCE:
+            b = Math.abs(mul(cs, da) - mul(cd, sa));
+            break;
+        case ADD:
+            return Math.min(255, cs + cd);
+        case SUBTRACT:
+            return Math.max(0, cd - cs);
+        case INVERT:
+            // The destination inverted, the source's colour unused.
+            return Math.max(0, Math.min(255, Math.floor(mul(255 - cd, sa) + mul(cd, 255 - sa))));
+        case OVERLAY:
+            b = 2 * cd <= da ? 2 * mul(cs, cd) : mul(sa, da) - 2 * mul(da - cd, sa - cs);
+            break;
+        default:
+            b = 2 * cs <= sa ? 2 * mul(cs, cd) : mul(sa, da) - 2 * mul(da - cd, sa - cs);
+            break;
+    }
+    return Math.max(0, Math.min(255, Math.floor(b + mul(cs, 255 - da) + mul(cd, 255 - sa))));
+}
+//# sourceMappingURL=ops.js.map