@swf2es/player-hosts 0.1.3 → 0.1.5

package/dist/thread/player/bitmap/ops.js

@@ -1,10 +1,5 @@
-// 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 "../../native/render/index.js";
-import { BitmapStore, over, premultiply, unmultiply } from "./bitmap.js";
-import { bitmapKernel, drawKernel } from "./kernel.js";
+import { premultiply, unmultiply } from "./bitmap.js";
+import { bitmapKernel } from "./kernel.js";
 import { perlinSetup } from "./turbulence.js";
 const M = 2147483647;
 /**
@@ -478,762 +473,3 @@ export function pixelDissolve(store, source, rect, dx, dy, seed, count, fill) {
     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))));
-}