@swf2es/player 0.1.0 → 0.1.1

package/dist/bitmap-ops.js

@@ -1,725 +0,0 @@
-// 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 { unmultiply } from "./bitmap.js";
-const M = 2147483647;
-/**
- * Flash's noise generator: 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).
- */
-export class ParkMiller {
-    x;
-    constructor(seed) {
-        let s = seed | 0;
-        if (s <= 0) {
-            s = -s + 1;
-        }
-        this.x = s % M || 1;
-    }
-    next() {
-        // 16807 * x stays below 2^46: exact in a double.
-        this.x = (this.x * 16807) % M;
-        return this.x;
-    }
-}
-/**
- * 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 rng = new ParkMiller(seed);
-    const lo = Math.max(0, Math.min(255, low));
-    const hi = Math.max(0, Math.min(255, high));
-    const span = hi - lo + 1;
-    const draw = () => (span <= 0 ? lo : lo + (rng.next() % span));
-    const alpha = (channels & 8) !== 0 && store.transparent;
-    for (let i = 0; i < store.pixels.length; i++) {
-        let r = 0;
-        let g = 0;
-        let b = 0;
-        if (gray) {
-            r = g = b = draw();
-        }
-        else {
-            if (channels & 1) {
-                r = draw();
-            }
-            if (channels & 2) {
-                g = draw();
-            }
-            if (channels & 4) {
-                b = draw();
-            }
-        }
-        const a = alpha ? draw() : 255;
-        store.pixels[i] = store.premultiplied(((a << 24) | (r << 16) | (g << 8) | b) >>> 0);
-    }
-    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.
-    forEachCopied(store, source, rect, dx, dy, (s, d) => {
-        const v = fromShift < 0 ? 0 : (s >>> fromShift) & 0xff;
-        return ((d & ~(0xff << toShift)) | (v << toShift)) >>> 0;
-    });
-}
-/**
- * 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 [rm, gm, bm, am] = [ct.rMul, ct.gMul, ct.bMul, ct.aMul].map(fixed);
-    const [ro, go, bo, ao] = [ct.rAdd, ct.gAdd, ct.bAdd, ct.aAdd].map(Math.trunc);
-    const ch = (v, m, o) => Math.max(0, Math.min(255, Math.floor((v * m) / 256) + o));
-    for (let y = c.y; y < c.y + c.height; y++) {
-        for (let x = c.x; x < c.x + c.width; x++) {
-            const i = y * store.width + x;
-            const p = store.pixels[i];
-            const a0 = p >>> 24;
-            // A pixel of alpha 0 is left as it is, offsets and all.
-            if (a0 === 0) {
-                continue;
-            }
-            const straight = (shift) => a0 === 0 ? 0 : Math.min(255, Math.floor((((p >>> shift) & 0xff) * 255) / a0));
-            // An opaque bitmap's alpha is transformed too: down to 0, the pixel reads 0.
-            const a = ch(a0, am, ao);
-            const r = ch(straight(16), rm, ro);
-            const g = ch(straight(8), gm, go);
-            const b = ch(straight(0), bm, bo);
-            const out = (v) => (a === 255 ? v : (v * (a + 1)) >> 8);
-            store.pixels[i] = ((a << 24) | (out(r) << 16) | (out(g) << 8) | out(b)) >>> 0;
-        }
-    }
-    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) {
-    const [rm, gm, bm, am] = muls;
-    const mix = (s, d, shift, m) => Math.floor((((s >>> shift) & 0xff) * m + ((d >>> shift) & 0xff) * (256 - m)) / 256) & 0xff;
-    forEachCopied(store, source, rect, dx, dy, (s, d) => ((mix(s, d, 24, am) << 24) |
-        (mix(s, d, 16, rm) << 16) |
-        (mix(s, d, 8, gm) << 8) |
-        mix(s, d, 0, bm)) >>>
-        0);
-}
-/**
- * The source rect's pixels against the destination's at the point, both
- * clipped and unmultiplied, each destination pixel set to what `f` makes
- * of the pair; from a copy where the source is the destination.
- */
-function forEachCopied(store, source, rect, dx, dy, f) {
-    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;
-    }
-    const sx = s.x + (d.x - dx);
-    const sy = s.y + (d.y - dy);
-    const [pixels, pw, ox, oy] = readFrom(source, store, sx, sy, d.width, d.height);
-    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 p = unmultiply(pixels[(sy - oy + row) * pw + sx - ox + i]);
-            store.pixels[to] = store.premultiplied(f(p, unmultiply(store.pixels[to])));
-        }
-    }
-    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;
-    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.
- */
-export function threshold(store, source, rect, dx, dy, op, value, color, mask, copySource) {
-    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);
-    const [pixels, pw, ox, oy] = readFrom(source, store, sx, sy, d.width, d.height);
-    const fill = 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 - oy + row) * pw + sx - ox + i];
-            if (test((unmultiply(raw) & mask) >>> 0, target)) {
-                store.pixels[to] = fill;
-                count++;
-            }
-            else if (copySource) {
-                store.pixels[to] = store.transparent ? raw : (raw | 0xff000000) >>> 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).
- */
-export function colorBounds(store, mask, color, find) {
-    let x0 = store.width;
-    let y0 = store.height;
-    let x1 = -1;
-    let y1 = -1;
-    const target = (color & mask) >>> 0;
-    for (let y = 0; y < store.height; y++) {
-        for (let x = 0; x < store.width; x++) {
-            const hit = (unmultiply(store.pixels[y * store.width + x]) & 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), or -1 outside. */
-export function alphaAt(store, x, y) {
-    if (x < 0 || y < 0 || x >= store.width || y >= store.height) {
-        return -1;
-    }
-    return store.pixels[y * store.width + x] >>> 24;
-}
-/**
- * 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); a seed past the
- * generator's states is taken modulo 2^bits - 1, and 0 starts at the tap. A
- * pixel takes the fill colour where the source is the destination, else
- * the source's; a rect a pixel high or wide dissolves nothing.
- */
-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 0;
-    }
-    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 0;
-    }
-    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 0;
-    }
-    const bw = bitsFor(w);
-    const bits = bw + bitsFor(h);
-    const tap = DISSOLVE_TAPS[bits] ?? 0;
-    const mask = 2 ** bits - 1;
-    const xMask = (1 << bw) - 1;
-    const color = store.premultiplied(fill >>> 0);
-    const next = (s) => (s & 1 ? Math.floor(s / 2) ^ tap : Math.floor(s / 2));
-    // 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;
-        const tx = dx + px;
-        const ty = 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];
-    };
-    const inside = (state) => (state & xMask) < w && Math.floor(state / 2 ** bw) < h;
-    // The origin is written on every call; the seed is reduced to the
-    // generator's period, and 0, which it never reaches, starts at the tap.
-    write(0);
-    const start = Math.abs(Math.trunc(seed));
-    let s = start > mask ? start % mask : start;
-    if (s === 0) {
-        s = tap;
-    }
-    // The states inside the rect come round every w * h - 1 writes (state 0
-    // is the origin's, reached from seed 0 alone), 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++) {
-        // Every state but 0 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 pixels a copy reads, with their row width and origin: the source's
- * own, or where the source is the destination, a copy of the rect alone,
- * so a one-pixel operation does not copy the whole store.
- */
-function readFrom(source, store, x, y, w, h) {
-    if (source !== store) {
-        return [source.pixels, source.width, 0, 0];
-    }
-    const copy = new Uint32Array(w * h);
-    for (let row = 0; row < h; row++) {
-        const from = (y + row) * source.width + x;
-        copy.set(source.pixels.subarray(from, from + w), row * w);
-    }
-    return [copy, w, x, y];
-}
-/** The blend modes draw composites with; alpha and erase need a layer, which a bitmap drawn has not, and do nothing. */
-const BLENDS = new Set([
-    "normal",
-    "layer",
-    "multiply",
-    "screen",
-    "lighten",
-    "darken",
-    "difference",
-    "add",
-    "subtract",
-    "invert",
-    "overlay",
-    "hardlight",
-]);
-/**
- * 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.
- */
-export function drawBitmap(store, source, m, ct, mode, clip, smooth, rows = false) {
-    if (!BLENDS.has(mode)) {
-        return;
-    }
-    // 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;
-    }
-    // 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.
-    if (m.a === 1 &&
-        m.b === 0 &&
-        m.c === 0 &&
-        m.d === 1 &&
-        Number.isInteger(m.tx) &&
-        Number.isInteger(m.ty) &&
-        source !== store) {
-        composite(store, source, area, m.tx, m.ty, ct, mode);
-        store.changed();
-        return;
-    }
-    // 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);
-    const inside = (x, y) => {
-        const sx = ia * x + ic * y + itx;
-        const sy = ib * x + id * y + ity;
-        return sx >= 0 && sy >= 0 && sx < source.width && sy < source.height;
-    };
-    // Drawn into itself, a BitmapData goes a row at a time, top down, every
-    // pixel of the row read before one is written, as Flash does: a move
-    // right keeps the pixels, a move down smears rows. Through a Bitmap of
-    // itself it is plain scan order, which smears both ways (adl).
-    const row = rows && source === store ? new Uint32Array(area.width) : null;
-    const written = row ? new Uint8Array(area.width) : null;
-    for (let y = area.y; y < area.y + area.height; y++) {
-        if (row && written) {
-            written.fill(0);
-        }
-        for (let x = area.x; x < area.x + area.width; x++) {
-            let hits = 0;
-            for (let k = 0; k < 16; k++) {
-                if (inside(x + ((k & 3) + 0.5) / 4, y + ((k >> 2) + 0.5) / 4)) {
-                    hits++;
-                }
-            }
-            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(source, sx - 0.5, sy - 0.5) : nearest(source, sx, sy);
-            if (ct) {
-                p = transformed(p, ct);
-            }
-            if (hits < 16) {
-                p = scaleBy(p, hits / 16);
-            }
-            if (row && written) {
-                row[x - area.x] = p;
-                written[x - area.x] = 1;
-                continue;
-            }
-            put(store, y * store.width + x, mode, p);
-        }
-        if (row && written) {
-            for (let k = 0; k < area.width; k++) {
-                if (written[k]) {
-                    put(store, y * store.width + area.x + k, mode, row[k]);
-                }
-            }
-        }
-    }
-    store.changed();
-}
-/** `source` at (tx, ty) composited into `area` of the store, a pixel each. */
-function composite(store, source, area, tx, ty, ct, mode) {
-    const into = store.pixels;
-    const from = source.pixels;
-    const opaque = store.transparent ? 0 : 0xff000000;
-    const plain = !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++) {
-            const p = from[j];
-            if (plain) {
-                // Source over, inline: what blend("normal") computes.
-                const sa = p >>> 24;
-                if (sa === 0) {
-                    continue;
-                }
-                if (sa === 255) {
-                    into[i] = p;
-                    continue;
-                }
-                into[i] = (sourceOver(p, into[i]) | opaque) >>> 0;
-                continue;
-            }
-            put(store, i, mode, ct ? transformed(p, ct) : p);
-        }
-    }
-}
-/** A drawn pixel composited into the store by the blend mode, opaque where the store is. */
-function put(store, i, mode, p) {
-    const out = blend(mode, p, store.pixels[i]);
-    store.pixels[i] = store.transparent ? out : (out | 0xff000000) >>> 0;
-}
-function nearest(source, x, y) {
-    const px = Math.min(source.width - 1, Math.max(0, Math.floor(x)));
-    const py = Math.min(source.height - 1, Math.max(0, Math.floor(y)));
-    return source.pixels[py * source.width + px];
-}
-/** Bilinear between the four premultiplied pixels round (x, y), clamped to the edges. */
-function bilinear(source, x, y) {
-    const x0 = Math.floor(x);
-    const y0 = Math.floor(y);
-    const fx = x - x0;
-    const fy = y - y0;
-    const at = (px, py) => source.pixels[Math.min(source.height - 1, Math.max(0, py)) * source.width +
-        Math.min(source.width - 1, Math.max(0, px))];
-    const p00 = at(x0, y0);
-    const p10 = at(x0 + 1, y0);
-    const p01 = at(x0, y0 + 1);
-    const p11 = at(x0 + 1, y0 + 1);
-    let out = 0;
-    for (const shift of [24, 16, 8, 0]) {
-        const v = (p) => (p >>> shift) & 0xff;
-        const top = v(p00) * (1 - fx) + v(p10) * fx;
-        const bottom = v(p01) * (1 - fx) + v(p11) * fx;
-        out |= Math.round(top * (1 - fy) + bottom * fy) << shift;
-    }
-    return out >>> 0;
-}
-/** A premultiplied pixel through a colour transform, as colorTransform computes it. */
-function transformed(p, ct) {
-    const a0 = p >>> 24;
-    if (a0 === 0 && ct.aAdd <= 0) {
-        return 0;
-    }
-    const fixed = (v) => Math.trunc(v * 256);
-    const ch = (v, mul, add) => Math.max(0, Math.min(255, Math.floor((v * fixed(mul)) / 256) + Math.trunc(add)));
-    const straight = (shift) => a0 === 0 ? 0 : Math.min(255, Math.floor((((p >>> shift) & 0xff) * 255) / a0));
-    const a = ch(a0, ct.aMul, ct.aAdd);
-    const out = (v) => (a === 255 ? v : (v * (a + 1)) >> 8);
-    return (((a << 24) |
-        (out(ch(straight(16), ct.rMul, ct.rAdd)) << 16) |
-        (out(ch(straight(8), ct.gMul, ct.gAdd)) << 8) |
-        out(ch(straight(0), ct.bMul, ct.bAdd))) >>>
-        0);
-}
-/** A premultiplied pixel with all four channels scaled by a coverage. */
-function scaleBy(p, f) {
-    let out = 0;
-    for (const shift of [24, 16, 8, 0]) {
-        out |= Math.round(((p >>> shift) & 0xff) * f) << shift;
-    }
-    return out >>> 0;
-}
-/** Premultiplied s over d by a blend mode, the W3C's compositing with each mode's mix. */
-function blend(mode, s, d) {
-    const sa = s >>> 24;
-    if (mode === "normal" || mode === "layer") {
-        return sourceOver(s, d);
-    }
-    const da = d >>> 24;
-    const mul = (x, y) => (x * y + 127) / 255;
-    const channel = (shift) => {
-        const cs = (s >>> shift) & 0xff;
-        const cd = (d >>> shift) & 0xff;
-        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))));
-    };
-    const a = mode === "add" || mode === "subtract"
-        ? Math.min(255, sa + da)
-        : Math.min(255, Math.round(sa + da - mul(sa, da)));
-    return ((a << 24) | (channel(16) << 16) | (channel(8) << 8) | channel(0)) >>> 0;
-}
-/** Source over destination, both premultiplied, as Flash composites: s + ((d * (256 - sa)) >> 8). */
-function sourceOver(s, d) {
-    const sa = s >>> 24;
-    if (sa === 255) {
-        return s >>> 0;
-    }
-    const k = 256 - sa;
-    const ch = (shift) => Math.min(255, ((s >>> shift) & 0xff) + ((((d >>> shift) & 0xff) * k) >> 8));
-    return ((ch(24) << 24) | (ch(16) << 16) | (ch(8) << 8) | ch(0)) >>> 0;
-}
-//# sourceMappingURL=bitmap-ops.js.map