@swf2es/player 0.0.0-stage → 0.1.1

package/dist/playerglobal/flash/display/BitmapData.js

@@ -0,0 +1,634 @@
+// flash.display.BitmapData: a pixel store (bitmap/bitmap.ts) behind the AS3
+// object, as $store; the natives read and write it. Flash's limits and its
+// ArgumentError 2015 for a size it refuses and for a store disposed.
+import { avm2 } from "@swf2es/runtime";
+import { BitmapStore, pixelRect, spanRect } from "../../../bitmap/bitmap.js";
+import { drawDisplayObject } from "../../../bitmap/draw.js";
+import { applyFilter, filterRefusal, filtersDrawn, GLOWS, generatedRect, } from "../../../bitmap/filters.js";
+import { alphaAt, colorBounds, colorTransform, comparePixels, copyChannel, drawBitmap, floodFill, histogram, isThresholdOperation, merge, noise, paletteMap, perlinNoise, pixelDissolve, scroll, threshold, } from "../../../bitmap/ops.js";
+import { shaderFilter } from "../../../bitmap/pixel-bender.js";
+import { encodePng } from "../../../bitmap/png.js";
+import { INVALID_PIXELS } from "../../../display/timeline.js";
+import { filterKindOf, recordOf } from "../filters/BitmapFilter.js";
+import { colorOf } from "../geom/Transform.js";
+import { programOf } from "./ShaderData.js";
+import { kernelOfShader, READ, shaderUse } from "./shaders.js";
+/** The longest side adl makes a BitmapData of: 2^31 / 20, whole. */
+const MAX_SIDE = 107374182;
+/** The most pixels adl makes a BitmapData of, whatever its shape: 2146500576 bytes. */
+const MAX_PIXELS = 536625144;
+/** The store of a BitmapData object, or ArgumentError 2015 where it was disposed or never made. */
+export function storeOf(s, o) {
+    const store = sizeOf(s, o);
+    // A bitmap of 0 by 0 is one Flash could not read from the SWF: it has a size and nothing else.
+    if (store.width === 0) {
+        throw s.rt.error("ArgumentError", 2015);
+    }
+    return store;
+}
+/** The store for reading its size: one Flash could not read has it, a disposed one not. */
+function sizeOf(s, o) {
+    const store = o.$store;
+    if (!store || store.disposed) {
+        throw s.rt.error("ArgumentError", 2015);
+    }
+    return store;
+}
+/**
+ * A flash.geom.Rectangle as pixels (bitmap.ts pixelRect), NaN and Infinity
+ * as adl takes them; with `span`, a negative size spanning back, as merge,
+ * copyChannel, paletteMap, threshold and pixelDissolve take it (spanRect).
+ * TypeError 2007 for null.
+ */
+function rectOf(s, v, span = false) {
+    if (v === null || v === undefined) {
+        throw s.rt.error("TypeError", 2007, "rect");
+    }
+    const r = v;
+    const read = (k) => s.rt.toNumber(s.rt.getProperty(r, s.rt.publicName(k)));
+    return (span ? spanRect : pixelRect)(read("x"), read("y"), read("width"), read("height"));
+}
+/**
+ * A flash.geom.Point's values as pixels, truncated toward 0 as Flash's
+ * destination, alpha and hit-test points are, unlike a rect's rounded
+ * edges; NaN, and anything past int's range, int's least, which lies off
+ * every bitmap, as adl takes them; TypeError 2007 for null.
+ */
+function pointOf(s, v, name) {
+    if (v === null || v === undefined) {
+        throw s.rt.error("TypeError", 2007, name);
+    }
+    const p = v;
+    const read = (k) => {
+        const t = Math.trunc(s.rt.toNumber(s.rt.getProperty(p, s.rt.publicName(k))));
+        return t >= -0x80000000 && t <= 0x7fffffff ? t + 0 : -0x80000000;
+    };
+    return [read("x"), read("y")];
+}
+/** A source BitmapData's store; TypeError 2007 for null. */
+function sourceOf(s, v) {
+    if (v === null || v === undefined) {
+        throw s.rt.error("TypeError", 2007, "sourceBitmapData");
+    }
+    return storeOf(s, v);
+}
+/**
+ * draw: a BitmapData, or a Bitmap as its data, its own transform ignored,
+ * composited on the CPU (bitmap/ops.ts drawBitmap); any other display
+ * object rendered by the Scripting's drawer at `samples` a side, over its
+ * own bounds alone, then composited the same way. A null source is
+ * ArgumentError 2005, as Flash words it.
+ */
+function drawInto(s, store, source, matrix, ct, mode, clip, smoothing, samples = 4) {
+    if (source === null || source === undefined) {
+        throw s.rt.error("ArgumentError", 2005, 0);
+    }
+    const o = source;
+    const data = o.$store !== undefined ? o : o.$display?.store !== undefined ? (o.$bitmapData ?? null) : null;
+    if (data === null && o.$display === undefined) {
+        throw s.rt.error("ArgumentError", 2005, 0);
+    }
+    const m = matrix === null || matrix === undefined
+        ? { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 }
+        : matrixOf(s, matrix);
+    const c = ct === null || ct === undefined ? null : colorOf(s, ct);
+    const blend = mode === null || mode === undefined ? "normal" : s.rt.toString(mode);
+    const r = clip === null || clip === undefined ? null : rectOf(s, clip);
+    if (data === null) {
+        // Any other display object, through the renderer, then composited as a bitmap is.
+        if (!s.drawer) {
+            throw s.rt.unsupported("BitmapData#draw of a display object without a renderer");
+        }
+        drawDisplayObject(s.drawer, store, o.$display, m, c, blend, r, samples);
+        return;
+    }
+    if (data.$bitmapData === null && data.$store === undefined) {
+        return;
+    }
+    // A BitmapData drawn into itself goes a row at a time; through a Bitmap, in scan order. A
+    // Bitmap is a display object, whose erase and alpha blends a BitmapData's are not.
+    const bitmap = o.$store === undefined;
+    drawBitmap(store, storeOf(s, data), m, c, blend, r, !!smoothing, !bitmap, bitmap ? "bitmap" : null);
+}
+/**
+ * A flash.geom.Matrix's six values, its translation as draw takes it under
+ * adl, in twips in an int: NaN is int's least, and so is anything past
+ * the int's range, Infinity too, which a matrix that only moves draws at
+ * 0 (and any other off every bitmap); and a move within 2^30 twips of
+ * the range's ends wraps round to near 0, 107374180 drawing at -2.4.
+ */
+function matrixOf(s, o) {
+    const read = (k) => s.rt.toNumber(s.rt.getProperty(o, s.rt.publicName(k)));
+    const m = {
+        a: read("a"),
+        b: read("b"),
+        c: read("c"),
+        d: read("d"),
+        tx: read("tx"),
+        ty: read("ty"),
+    };
+    const moves = m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1;
+    const twips = (t) => {
+        const v = t * 20;
+        if (Number.isNaN(v) || (moves && Math.abs(v) >= 2 ** 31)) {
+            return 0;
+        }
+        return moves && Math.abs(v) >= 2 ** 30 ? (v - Math.sign(v) * 2 ** 31) / 20 : t;
+    };
+    m.tx = twips(m.tx);
+    m.ty = twips(m.ty);
+    return m;
+}
+/** Samples a side of each pixel a display object is rendered at, by drawWithQuality's quality: Flash's 1, 2 and 4. */
+function samplesOf(s, quality) {
+    if (quality === null || quality === undefined) {
+        return 4;
+    }
+    switch (s.rt.toString(quality).toLowerCase()) {
+        case "low":
+            return 1;
+        case "medium":
+            return 2;
+        default:
+            return 4;
+    }
+}
+export function bitmapDataNatives(s) {
+    const natives = {};
+    /** A filter object's record; TypeError 2007 for null, as for anything that is no filter. */
+    const filterOf = (v) => {
+        const kind = v && typeof v === "object" ? filterKindOf(s.rt, v) : null;
+        if (!kind) {
+            throw s.rt.error("TypeError", 2007, "filter");
+        }
+        return recordOf(v, kind);
+    };
+    class BitmapDataNatives {
+        "flash.display:BitmapData::ctor"(width, height, transparent, fill) {
+            // A class SymbolClass binds to a bitmap has its pixels, whatever size it asks for.
+            const symbol = this.$symbol;
+            if (symbol) {
+                this.$store = BitmapStore.of(symbol.pixels ?? INVALID_PIXELS);
+                return;
+            }
+            // A side under 1 is refused, and as adl refuses them, a side past 2^31 / 20
+            // (107374183 by 1) and more than MAX_PIXELS (32753 by 16384, 65514 by 8191).
+            const w = s.rt.toInt(width);
+            const h = s.rt.toInt(height);
+            if (w < 1 || h < 1 || w > MAX_SIDE || h > MAX_SIDE || w * h > MAX_PIXELS) {
+                throw s.rt.error("ArgumentError", 2015);
+            }
+            // One the browser cannot allocate is refused, as adl refuses what its memory
+            // cannot hold, rather than ending the player with a RangeError.
+            try {
+                this.$store = new BitmapStore(w, h, transparent === undefined ? true : !!transparent, s.rt.toUint(fill === undefined ? 0xffffffff : fill));
+            }
+            catch (e) {
+                if (e instanceof RangeError) {
+                    throw s.rt.error("ArgumentError", 2015);
+                }
+                throw e;
+            }
+        }
+        // Disposed, every read throws, the size included, as Flash has it.
+        get width() {
+            return sizeOf(s, this).width;
+        }
+        get height() {
+            return sizeOf(s, this).height;
+        }
+        get transparent() {
+            return sizeOf(s, this).transparent;
+        }
+        get rect() {
+            const store = sizeOf(s, this);
+            return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), 0, 0, store.width, store.height);
+        }
+        getPixel(x, y) {
+            return storeOf(s, this).getPixel(s.rt.toInt(x), s.rt.toInt(y));
+        }
+        getPixel32(x, y) {
+            return storeOf(s, this).getPixel32(s.rt.toInt(x), s.rt.toInt(y));
+        }
+        setPixel(x, y, color) {
+            storeOf(s, this).setPixel(s.rt.toInt(x), s.rt.toInt(y), s.rt.toUint(color));
+        }
+        setPixel32(x, y, color) {
+            storeOf(s, this).setPixel32(s.rt.toInt(x), s.rt.toInt(y), s.rt.toUint(color));
+        }
+        fillRect(rect, color) {
+            const store = storeOf(s, this);
+            store.fillRect(rectOf(s, rect), s.rt.toUint(color));
+        }
+        clone() {
+            const store = storeOf(s, this);
+            const o = s.rt.construct(s.rt.classNamed("flash.display::BitmapData"), store.width, store.height, store.transparent, 0);
+            o.$store = store.clone();
+            return o;
+        }
+        dispose() {
+            const store = this.$store;
+            if (store && !store.disposed) {
+                store.dispose();
+            }
+        }
+        copyPixels(source, rect, dest, alphaBitmap, alphaPoint, mergeAlpha) {
+            const store = storeOf(s, this);
+            if (source === null || source === undefined) {
+                throw s.rt.error("TypeError", 2007, "sourceBitmapData");
+            }
+            const from = storeOf(s, source);
+            const r = rectOf(s, rect);
+            const [dx, dy] = pointOf(s, dest, "destPoint");
+            const alpha = alphaBitmap === null || alphaBitmap === undefined
+                ? null
+                : storeOf(s, alphaBitmap);
+            const [ax, ay] = alphaPoint === null || alphaPoint === undefined
+                ? [0, 0]
+                : pointOf(s, alphaPoint, "alphaPoint");
+            store.copyPixels(from, r, dx, dy, !!mergeAlpha, alpha, ax, ay);
+        }
+        /** `sourceRect` of the source filtered into this at `destPoint`, its filter's rect written whole (bitmap/filters.ts). */
+        applyFilter(source, sourceRect, destPoint, filter) {
+            const store = storeOf(s, this);
+            const from = sourceOf(s, source);
+            const r = rectOf(s, sourceRect);
+            const [dx, dy] = pointOf(s, destPoint, "destPoint");
+            const f = filterOf(filter);
+            if (f.kind === "shader") {
+                if (!kernelOfShader(f.shader)) {
+                    throw s.rt.error("ArgumentError", 2171);
+                }
+                // Its inputs read as they are, as a job reads them: run now, not drawn later.
+                const use = shaderUse(s, f.shader, 1, READ);
+                shaderFilter(store, from, r, dx, dy, f.extensions, use, programOf(use.kernel));
+                return;
+            }
+            // adl draws none of the filters with a glow into an opaque destination.
+            if (!store.transparent && GLOWS.has(f.kind)) {
+                throw s.rt.error("flash.errors::IllegalOperationError", 2077);
+            }
+            switch (filterRefusal(r, f, { x: 0, y: 0, width: from.width, height: from.height })) {
+                case 2015:
+                    throw s.rt.error("ArgumentError", 2015);
+                case 2077:
+                    throw s.rt.error("flash.errors::IllegalOperationError", 2077);
+            }
+            // A displacement map's map as it is now, not as it was when set.
+            const map = f.kind === "displacementMap" && f.mapBitmap ? storeOf(s, f.mapBitmap) : null;
+            if (!applyFilter(store, from, r, dx, dy, f, map)) {
+                throw s.rt.unsupported(`BitmapData.applyFilter with a ${f.kind} filter`);
+            }
+        }
+        generateFilterRect(sourceRect, filter) {
+            const store = storeOf(s, this);
+            const f = filterOf(filter);
+            if (f.kind === "shader") {
+                // This bitmap's rect grown by the extensions, whatever the rect given, as adl gives it.
+                rectOf(s, sourceRect);
+                const [left, top, right, bottom] = f.extensions;
+                return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), -left, -top, store.width + left + right, store.height + top + bottom);
+            }
+            if (!filtersDrawn.has(f.kind)) {
+                throw s.rt.unsupported(`BitmapData.generateFilterRect with a ${f.kind} filter`);
+            }
+            const r = generatedRect(store.width, store.height, rectOf(s, sourceRect), f);
+            return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), r.x, r.y, r.width, r.height);
+        }
+        getPixels(rect) {
+            const store = storeOf(s, this);
+            const o = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray"));
+            o.$bytes.write(store.argbBytes(rectOf(s, rect)));
+            return o;
+        }
+        copyPixelsToByteArray(rect, target) {
+            const store = storeOf(s, this);
+            if (target === null || target === undefined) {
+                throw s.rt.error("TypeError", 2007, "data");
+            }
+            const bytes = target.$bytes;
+            bytes.write(store.argbBytes(rectOf(s, rect), bytes.littleEndian));
+        }
+        /**
+         * The rect as an image file, written into `byteArray` from its position
+         * or into a new one, which is returned: PNG; JPEG and JPEG XR, which
+         * Flash also writes, are not supported yet.
+         */
+        encode(rect, compressor, byteArray) {
+            const store = storeOf(s, this);
+            if (rect === null || rect === undefined) {
+                throw s.rt.error("TypeError", 2007, "rectangle");
+            }
+            if (compressor === null || compressor === undefined) {
+                throw s.rt.error("TypeError", 2007, "compressor");
+            }
+            const options = compressor;
+            const is = (name) => s.rt.isInstance(options, s.rt.classNamed(name));
+            if (!is("flash.display::PNGEncoderOptions")) {
+                if (is("flash.display::JPEGEncoderOptions") || is("flash.display::JPEGXREncoderOptions")) {
+                    throw s.rt.unsupported("BitmapData#encode as JPEG");
+                }
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            const area = store.clip(rectOf(s, rect));
+            if (!area) {
+                throw s.rt.error("ArgumentError", 2006);
+            }
+            const fast = !!s.rt.getProperty(options, s.rt.publicName("fastCompression"));
+            const out = byteArray === null || byteArray === undefined
+                ? s.rt.construct(s.rt.classNamed("flash.utils::ByteArray"))
+                : byteArray;
+            out.$bytes.write(encodePng(store, area, fast));
+            return out;
+        }
+        setPixels(rect, input) {
+            const store = storeOf(s, this);
+            // The parameters checked in order: the rect's null before the input's.
+            const r = rectOf(s, rect);
+            if (input === null || input === undefined) {
+                throw s.rt.error("TypeError", 2007, "inputByteArray");
+            }
+            const c = store.clip(r);
+            if (!c) {
+                return;
+            }
+            // A pixel at a time, as Flash reads them: those read before the end are set, then EOFError 2030.
+            const bytes = input.$bytes;
+            const values = [];
+            try {
+                for (let i = 0; i < c.width * c.height; i++) {
+                    bytes.checkEOF(4);
+                    values.push(bytes.view.getUint32(bytes.position, bytes.littleEndian));
+                    bytes.position = (bytes.position + 4) >>> 0;
+                }
+            }
+            finally {
+                store.setVector(c, values);
+            }
+        }
+        getVector(rect) {
+            const store = storeOf(s, this);
+            const cls = s.rt.resolve(s.rt.vector("uint"));
+            const o = cls.$it.instance();
+            o.$a = store.getVector(rectOf(s, rect));
+            return o;
+        }
+        setVector(rect, input) {
+            const store = storeOf(s, this);
+            const r = rectOf(s, rect);
+            if (input === null || input === undefined) {
+                throw s.rt.error("TypeError", 2007, "imputVector");
+            }
+            const c = store.clip(r);
+            if (!c) {
+                return;
+            }
+            const values = input.$a;
+            if (values.length < c.width * c.height) {
+                throw s.rt.error("RangeError", 2006);
+            }
+            store.setVector(c, values);
+        }
+        noise(seed, low, high, channels, gray) {
+            noise(storeOf(s, this), s.rt.toInt(seed), low === undefined ? 0 : s.rt.toUint(low), high === undefined ? 255 : s.rt.toUint(high), channels === undefined ? 7 : s.rt.toUint(channels), !!gray);
+        }
+        copyChannel(source, rect, dest, from, to) {
+            const store = storeOf(s, this);
+            const src = sourceOf(s, source);
+            const r = rectOf(s, rect, true);
+            const [dx, dy] = pointOf(s, dest, "destPoint");
+            copyChannel(store, src, r, dx, dy, s.rt.toUint(from), s.rt.toUint(to));
+        }
+        /** Offsets past those given, or not Points, are (0, 0). */
+        perlinNoise(baseX, baseY, octaves, seed, stitch, fractal, channels = 7, gray = false, offsets = null) {
+            const store = storeOf(s, this);
+            const given = offsets?.$a;
+            const point = s.rt.classNamed("flash.geom::Point");
+            const read = (p, k) => s.rt.toNumber(s.rt.getProperty(p, s.rt.publicName(k)));
+            // Past 1024 octaves the doubles' ratio would be infinite, where Flash's sum stays as it was from
+            // some 40 on, for any count up to 2^32 - 1, a negative one too (the `perlin-noise` case).
+            const count = Math.min(s.rt.toUint(octaves), 1024);
+            const shifts = Array.from({ length: count }, (_, i) => {
+                const p = given?.[i];
+                return p && s.rt.isInstanceOf(p, point.$it)
+                    ? [read(p, "x"), read(p, "y")]
+                    : [0, 0];
+            });
+            perlinNoise(store, [s.rt.toNumber(baseX), s.rt.toNumber(baseY)], shifts, s.rt.toInt(seed), !!stitch, !!fractal, s.rt.toUint(channels), !!gray);
+        }
+        paletteMap(source, rect, dest, red = null, green = null, blue = null, alpha = null) {
+            const store = storeOf(s, this);
+            const src = sourceOf(s, source);
+            if (rect === null || rect === undefined) {
+                throw s.rt.error("TypeError", 2007, "sourceRect");
+            }
+            const r = rectOf(s, rect, true);
+            const [dx, dy] = pointOf(s, dest, "destPoint");
+            // A channel's table, or itself where none is given.
+            const table = (v, shift) => Uint32Array.from({ length: 256 }, (_, i) => v === null || v === undefined
+                ? i << shift
+                : s.rt.toUint(s.rt.getProperty(v, s.rt.publicName(i))));
+            paletteMap(store, src, r, dx, dy, [
+                table(red, 16),
+                table(green, 8),
+                table(blue, 0),
+                table(alpha, 24),
+            ]);
+        }
+        /**
+         * 0 for the same pixels, a BitmapData of their differences, or -3 and
+         * -4 for another width and height, as Flash's; -1 for this one disposed.
+         */
+        compare(other) {
+            if (other === null || other === undefined) {
+                throw s.rt.error("TypeError", 2007, "otherBitmapData");
+            }
+            const own = this.$store;
+            if (!own || own.disposed) {
+                return -1;
+            }
+            const theirs = storeOf(s, other);
+            if (theirs.width !== own.width) {
+                return -3;
+            }
+            if (theirs.height !== own.height) {
+                return -4;
+            }
+            const pixels = comparePixels(own, theirs);
+            if (!pixels) {
+                return 0;
+            }
+            const o = s.rt.construct(s.rt.classNamed("flash.display::BitmapData"), own.width, own.height, true, 0);
+            o.$store.pixels.set(pixels);
+            o.$store.changed();
+            return o;
+        }
+        colorTransform(rect, ct) {
+            const store = storeOf(s, this);
+            const r = rectOf(s, rect);
+            if (ct === null || ct === undefined) {
+                throw s.rt.error("TypeError", 2007, "colorTransform");
+            }
+            // A foot of NaN, int's least, less a top past 0 wraps round in int
+            // arithmetic to a height reaching the bitmap's foot, as adl has it; a
+            // width of NaN covers nothing.
+            r.height |= 0;
+            colorTransform(store, r, colorOf(s, ct));
+        }
+        merge(source, rect, dest, rMul, gMul, bMul, aMul) {
+            const store = storeOf(s, this);
+            const src = sourceOf(s, source);
+            const r = rectOf(s, rect, true);
+            const [dx, dy] = pointOf(s, dest, "destPoint");
+            merge(store, src, r, dx, dy, [rMul, gMul, bMul, aMul].map((m) => s.rt.toUint(m)));
+        }
+        scroll(x, y) {
+            scroll(storeOf(s, this), s.rt.toInt(x), s.rt.toInt(y));
+        }
+        threshold(source, rect, dest, op, value, color, mask, copySource) {
+            const store = storeOf(s, this);
+            const src = sourceOf(s, source);
+            const r = rectOf(s, rect, true);
+            const [dx, dy] = pointOf(s, dest, "destPoint");
+            // A String parameter: undefined is null, refused with 2007 before the value is looked at.
+            if (op === null || op === undefined) {
+                throw s.rt.error("TypeError", 2007, "operation");
+            }
+            const operation = s.rt.toString(op);
+            if (!isThresholdOperation(operation)) {
+                throw s.rt.error("ArgumentError", 2005, 3);
+            }
+            return threshold(store, src, r, dx, dy, operation, s.rt.toUint(value), s.rt.toUint(color), mask === undefined ? 0xffffffff : s.rt.toUint(mask), !!copySource);
+        }
+        getColorBoundsRect(mask, color, find) {
+            const r = colorBounds(storeOf(s, this), s.rt.toUint(mask), s.rt.toUint(color), find === undefined ? true : !!find);
+            return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), r.x, r.y, r.width, r.height);
+        }
+        floodFill(x, y, color) {
+            floodFill(storeOf(s, this), s.rt.toInt(x), s.rt.toInt(y), s.rt.toUint(color));
+        }
+        histogram(rect) {
+            const store = storeOf(s, this);
+            const counts = histogram(store, rect === null || rect === undefined
+                ? { x: 0, y: 0, width: store.width, height: store.height }
+                : rectOf(s, rect));
+            const inner = s.rt.resolve(s.rt.vector("Number"));
+            const outer = s.rt.applyType(s.rt.classNamed("__AS3__.vec::Vector"), [inner]);
+            const o = outer.$it.instance();
+            o.$a = counts.map((c) => {
+                const v = inner.$it.instance();
+                v.$a = c;
+                return v;
+            });
+            return o;
+        }
+        hitTest(firstPoint, firstAlpha, second, secondPoint, secondAlpha) {
+            const store = storeOf(s, this);
+            const [fx, fy] = pointOf(s, firstPoint, "firstPoint");
+            // adl refuses a point the bitmap, put there, would reach past int's range from.
+            if (fx + store.width > 0x7fffffff || fy + store.height > 0x7fffffff) {
+                throw s.rt.error("ArgumentError", 1508, "firstPoint");
+            }
+            const a1 = s.rt.toUint(firstAlpha);
+            const other = second;
+            if (other === null || other === undefined) {
+                throw s.rt.error("ArgumentError", 2005, 2);
+            }
+            const name = s.rt.traitsOf(other).name;
+            // A Bitmap tests as its BitmapData.
+            const data = other.$store !== undefined
+                ? other
+                : other.$display?.store !== undefined
+                    ? (other.$bitmapData ?? null)
+                    : null;
+            const isPoint = name === "flash.geom::Point";
+            const isRect = name === "flash.geom::Rectangle";
+            if (isPoint || isRect) {
+                // A point truncated, a rect's edges rounded, as everywhere else.
+                const area = isRect ? rectOf(s, other) : null;
+                const [px, py] = isPoint ? pointOf(s, other, "secondObject") : [0, 0];
+                const x0 = (area ? area.x : px) - fx;
+                const y0 = (area ? area.y : py) - fy;
+                const w = area ? area.width : 1;
+                const h = area ? area.height : 1;
+                for (let y = Math.max(0, y0); y < Math.min(store.height, y0 + h); y++) {
+                    for (let x = Math.max(0, x0); x < Math.min(store.width, x0 + w); x++) {
+                        // A point or rect hits no pixel of alpha 0, at threshold 0 too (bitmapdata_hittest_threshold).
+                        const a = alphaAt(store, x, y);
+                        if (a > 0 && a >= a1) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            if (data) {
+                const second = storeOf(s, data);
+                // Against a bitmap, its point is required.
+                const [sx, sy] = pointOf(s, secondPoint, "secondBitmapDataPoint");
+                if (sx + second.width > 0x7fffffff || sy + second.height > 0x7fffffff) {
+                    throw s.rt.error("ArgumentError", 1508, "secondBitmapDataPoint");
+                }
+                const a2 = secondAlpha === undefined ? 1 : s.rt.toUint(secondAlpha);
+                const ox = sx - fx;
+                const oy = sy - fy;
+                for (let y = Math.max(0, oy); y < Math.min(store.height, oy + second.height); y++) {
+                    for (let x = Math.max(0, ox); x < Math.min(store.width, ox + second.width); x++) {
+                        if (alphaAt(store, x, y) >= a1 && alphaAt(second, x - ox, y - oy) >= a2) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            throw s.rt.error("ArgumentError", 2005, 2);
+        }
+        pixelDissolve(source, rect, dest, seed, count, fill) {
+            const store = storeOf(s, this);
+            // Anything but a BitmapData is refused as null, as Flash words it.
+            if (source === null || source === undefined || source.$store === undefined) {
+                throw s.rt.error("TypeError", 2007, "sourceBitmapData");
+            }
+            const src = storeOf(s, source);
+            if (rect === null || rect === undefined) {
+                throw s.rt.error("TypeError", 2007, "sourceRect");
+            }
+            const r = rectOf(s, rect, true);
+            const [dx, dy] = pointOf(s, dest, "destPoint");
+            const n = count === undefined ? 0 : s.rt.toInt(count);
+            if (n < 0) {
+                throw s.rt.error("RangeError", 2027, "numPixels", n);
+            }
+            return pixelDissolve(store, src, r, dx, dy, 
+            // An int, as declared: NaN is 0, where it would never reach a state.
+            seed === undefined ? 0 : s.rt.toInt(seed), n, fill === undefined ? 0 : s.rt.toUint(fill));
+        }
+        draw(source, matrix, ct, mode, clip, smoothing) {
+            drawInto(s, storeOf(s, this), source, matrix, ct, mode, clip, smoothing);
+        }
+        drawWithQuality(source, matrix, ct, mode, clip, smoothing, quality) {
+            drawInto(s, storeOf(s, this), source, matrix, ct, mode, clip, smoothing, samplesOf(s, quality));
+        }
+        lock() {
+            storeOf(s, this);
+        }
+        unlock() {
+            storeOf(s, this);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::BitmapData", BitmapDataNatives);
+    return natives;
+}
+export function bitmapDataHooks(s) {
+    return {
+        "flash.display::BitmapData": {
+            create: (traits) => {
+                const o = Object.create(traits.proto);
+                o.$store = null;
+                o.$symbol = s.symbols.bitmapSymbol(traits);
+                return o;
+            },
+        },
+    };
+}
+//# sourceMappingURL=BitmapData.js.map