@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/avm1/globals/MovieClip.js

@@ -0,0 +1,1070 @@
+// MovieClip's AS2 face over the player's display objects (docs/avm1.md,
+// "Hosting AVM1 objects"): a clip's, a button's or a text field's AVM1
+// object finds its children by name, `_root`, `_parent` and `_levelN`, and
+// the display properties `_x` to `_ymouse`, after its own properties; and
+// MovieClip's methods, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/object/stage_object.rs and globals/movie_clip.rs have them:
+// MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle
+// contributors. Where adl parts from Ruffle, adl decides (docs/avm1.md,
+// "Clips and paths").
+import { avm1 } from "../../../runtime/index.js";
+import { bounds, hitsObject, hitsPoint, toStage } from "../../display/bounds.js";
+import { ButtonObject, MovieClip, TextObject, TRANSFORM, } from "../../display/display.js";
+import { apply, contains, invert, transformRect } from "../../display/geometry.js";
+import { cached } from "../../display/shapeobject.js";
+import { asciiLower, childByName, pathOf, slashPathOf } from "../paths.js";
+import { blendModeOf, storeOf } from "./BitmapData.js";
+import { drawingMethods } from "./drawing.js";
+import { filtersProperty } from "./filters.js";
+import { assignTransform, transformOf } from "./geom.js";
+import { formVars } from "./LoadVars.js";
+/** AVM1's depths are the timeline's less this, as Flash gives them to scripts. */
+export const DEPTH_BIAS = 16384;
+/** A number cast to an int as x86 casts one: cut toward zero, NaN and what does not fit -2^31. */
+const castInt = (n) => n > -2147483649 && n < 2147483648 ? Math.trunc(n) : -2147483648;
+/** A pixel value in whole twips, as Flash keeps positions. */
+const twips = (px) => castInt(px * 20);
+/** A value as a property set takes it: a number, or none for undefined, null or NaN, which leave the property be. */
+function numberOf(value, version) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const n = avm1.toNumber(value, version);
+    return Number.isNaN(n) ? null : n;
+}
+/** An object's width and height in its parent's space, in twips as Flash reports them. */
+function size(d) {
+    const r = twipsBounds(d, twipsMatrix(d.placed));
+    return r === null ? [0, 0] : [(r.xMax - r.xMin) / 20, (r.yMax - r.yMin) / 20];
+}
+/** Move a display object, by a copy of its matrix, and have it drawn again. */
+function moveTo(d, x, y) {
+    d.touch();
+    d.matrix = { ...d.matrix, tx: x ?? d.matrix.tx, ty: y ?? d.matrix.ty };
+    d.invalidate(TRANSFORM);
+}
+/** An alpha as Flash keeps it, an 8.8 multiplier: the percentage's 256ths cut toward zero, in 16 bits. */
+function alphaOf(percent) {
+    const n = castInt(percent * 2.56);
+    return (n << 16) >> 16;
+}
+/**
+ * The display properties, in GetProperty's and SetProperty's order: `_x`
+ * is 0, `_ymouse` 21.
+ */
+const PROPERTIES = [
+    [
+        "_x",
+        {
+            get: (f) => f.target.matrix.tx,
+            set(f, value, version) {
+                const n = numberOf(value, version);
+                if (n !== null) {
+                    moveTo(f.target, twips(n) / 20, null);
+                }
+            },
+        },
+    ],
+    [
+        "_y",
+        {
+            get: (f) => f.target.matrix.ty,
+            set(f, value, version) {
+                const n = numberOf(value, version);
+                if (n !== null) {
+                    moveTo(f.target, null, twips(n) / 20);
+                }
+            },
+        },
+    ],
+    [
+        "_xscale",
+        {
+            get: (f) => f.xscale !== null && f.target.scaleX === clampScale(f.xscale / 100)
+                ? f.xscale
+                : f.target.scaleX * 100,
+            set(f, value, version) {
+                const n = numberOf(value, version);
+                if (n !== null) {
+                    f.target.touch();
+                    setScaleX(f, n / 100, n);
+                }
+            },
+        },
+    ],
+    [
+        "_yscale",
+        {
+            get: (f) => f.yscale !== null && f.target.scaleY === clampScale(f.yscale / 100)
+                ? f.yscale
+                : f.target.scaleY * 100,
+            set(f, value, version) {
+                const n = numberOf(value, version);
+                if (n !== null) {
+                    f.target.touch();
+                    setScaleY(f, n / 100, n);
+                }
+            },
+        },
+    ],
+    [
+        "_currentframe",
+        { get: (f) => (f.target instanceof MovieClip ? f.target.currentFrame : undefined), set: null },
+    ],
+    [
+        "_totalframes",
+        { get: (f) => (f.target instanceof MovieClip ? f.target.totalFrames : undefined), set: null },
+    ],
+    [
+        "_alpha",
+        {
+            get: (f) => (f.target.colorTransform?.aMul ?? 1) * 100,
+            set(f, value, version) {
+                const n = numberOf(value, version);
+                if (n !== null) {
+                    const d = f.target;
+                    d.touch();
+                    const aMul = Number.isFinite(n) ? alphaOf(n) / 256 : 0;
+                    d.colorTransform = { ...(d.colorTransform ?? IDENTITY_COLOR), aMul };
+                    d.invalidate(TRANSFORM);
+                }
+            },
+        },
+    ],
+    [
+        "_visible",
+        {
+            get: (f) => f.target.visible,
+            set(f, value, version) {
+                // A number, as in Flash 4: "false" is NaN, which leaves it be.
+                const n = numberOf(value, version);
+                if (n !== null) {
+                    f.target.visible = n !== 0;
+                    f.target.invalidate(TRANSFORM);
+                    if (n === 0) {
+                        f.movie.hidden(f.target);
+                    }
+                }
+            },
+        },
+    ],
+    [
+        "_width",
+        {
+            get: (f) => size(f.target)[0],
+            set(f, value, version) {
+                const n = numberOf(value, version);
+                if (n !== null) {
+                    setSize(f, n, true);
+                }
+            },
+        },
+    ],
+    [
+        "_height",
+        {
+            get: (f) => size(f.target)[1],
+            set(f, value, version) {
+                const n = numberOf(value, version);
+                if (n !== null) {
+                    setSize(f, n, false);
+                }
+            },
+        },
+    ],
+    [
+        "_rotation",
+        {
+            get: (f) => f.target.rotation,
+            set(f, value, version) {
+                const n = numberOf(value, version);
+                if (n !== null) {
+                    f.target.touch();
+                    f.target.setRotation(n);
+                }
+            },
+        },
+    ],
+    ["_target", { get: (f) => slashPathOf(f.target, (d) => f.movie.levelOf(d)), set: null }],
+    [
+        "_framesloaded",
+        {
+            // -1 for a load's root in error, which has -1 bytes.
+            get: (f) => {
+                if (!(f.target instanceof MovieClip)) {
+                    return undefined;
+                }
+                const swf = f.movie.swfOf(f.target);
+                return swf.root === f.target && swf.length < 0 ? -1 : f.target.totalFrames;
+            },
+            set: null,
+        },
+    ],
+    [
+        "_name",
+        {
+            get: (f) => f.target.name,
+            set(f, value, version) {
+                f.target.name = avm1.stringOf(version >= 7 && typeof value === "number" && Number.isNaN(value) ? 0 : value, version);
+            },
+        },
+    ],
+    [
+        "_droptarget",
+        {
+            // The slash path of what it was last dragged over; "" for nothing, in every version (adl;
+            // Ruffle: undefined up to SWF 5).
+            get: (f) => {
+                const over = f.movie.dropTargetOf(f.target);
+                return over === null ? "" : slashPathOf(over, (d) => f.movie.levelOf(d));
+            },
+            set: null,
+        },
+    ],
+    ["_url", { get: (f) => f.movie.swfOf(f.target).url, set: null }],
+    [
+        "_highquality",
+        {
+            get: (f) => (f.movie.quality === "BEST" ? 2 : f.movie.quality === "LOW" ? 0 : 1),
+            set(f, value, version) {
+                if (value === undefined || value === null) {
+                    return;
+                }
+                const n = avm1.toNumber(value, version);
+                if (!Number.isNaN(n)) {
+                    f.movie.quality = n > 1.5 ? "BEST" : n === 0 ? "LOW" : "HIGH";
+                }
+            },
+        },
+    ],
+    [
+        "_focusrect",
+        {
+            get(f, version) {
+                if (version <= 5) {
+                    return f.movie.focusRect ? 1 : 0;
+                }
+                return f.target === f.movie.root ? f.movie.focusRect : (f.focusRect ?? null);
+            },
+            set(f, value, version) {
+                if (version <= 5 || f.target === f.movie.root) {
+                    if (value === undefined || value === null) {
+                        return;
+                    }
+                    const n = value instanceof avm1.Avm1Object ? 0 : avm1.toNumber(value, version);
+                    if (!Number.isNaN(n)) {
+                        f.movie.focusRect = n !== 0;
+                    }
+                }
+                else {
+                    f.focusRect =
+                        value === undefined || value === null ? null : avm1.toBoolean(value, version);
+                }
+            },
+        },
+    ],
+    [
+        "_soundbuftime",
+        {
+            get: (f) => f.movie.soundBufferTime,
+            set(f, value, version) {
+                if (value === undefined || value === null) {
+                    return;
+                }
+                const n = avm1.toNumber(value, version);
+                if (!Number.isNaN(n)) {
+                    f.movie.soundBufferTime = castInt(n);
+                }
+            },
+        },
+    ],
+    [
+        "_quality",
+        {
+            get: (f) => f.movie.quality,
+            set(f, value, version) {
+                const quality = avm1.stringOf(value, version).toUpperCase();
+                if (QUALITIES.includes(quality)) {
+                    f.movie.quality = quality;
+                }
+            },
+        },
+    ],
+    ["_xmouse", { get: (f) => mouse(f.target, f.movie)[0], set: null }],
+    ["_ymouse", { get: (f) => mouse(f.target, f.movie)[1], set: null }],
+];
+const QUALITIES = ["LOW", "MEDIUM", "HIGH", "BEST"];
+/** A clip's colour transform where it has none. */
+export const IDENTITY_COLOR = {
+    rMul: 1,
+    gMul: 1,
+    bMul: 1,
+    aMul: 1,
+    rAdd: 0,
+    gAdd: 0,
+    bAdd: 0,
+    aAdd: 0,
+};
+/** The display properties by name in lower case, which they are found by in any case. */
+const BY_NAME = new Map(PROPERTIES.map(([name, p]) => [name, p]));
+/**
+ * The pointer in `d`'s space, as Flash gives it (Ruffle's
+ * local_mouse_position): through the matrix from `d`'s twips to the
+ * screen's pixels (`pixelRatio` of them a stage pixel), whose translation
+ * a matrix keeps whole, so a whole pixel, and back to whole twips, each
+ * rounded half to even; where that matrix cannot be inverted, as for a
+ * clip scaled to nothing, the pointer's pixels are taken as twips (the
+ * corpus's `mouse_pos`).
+ */
+function mouse(d, movie) {
+    const m = toStage(d, movie.root.parent);
+    const ratio = movie.pixelRatio;
+    const px = movie.mouseX * ratio;
+    const py = movie.mouseY * ratio;
+    const device = {
+        a: (m.a * ratio) / 20,
+        b: (m.b * ratio) / 20,
+        c: (m.c * ratio) / 20,
+        d: (m.d * ratio) / 20,
+        tx: roundEven(m.tx * ratio),
+        ty: roundEven(m.ty * ratio),
+    };
+    const back = invert(device);
+    if (back === null) {
+        return [roundEven(px) / 20, roundEven(py) / 20];
+    }
+    const x = back.a * px + back.c * py + roundEven(back.tx);
+    const y = back.b * px + back.d * py + roundEven(back.ty);
+    return [roundEven(x) / 20, roundEven(y) / 20];
+}
+/**
+ * The largest scale Flash's matrix holds, either way: a larger `_xscale`
+ * or `_yscale` is given back as set but draws at this (adl).
+ */
+const MAX_SCALE = 32768;
+const clampScale = (s) => Math.max(-MAX_SCALE, Math.min(MAX_SCALE, s));
+/** Preserve explicit percentages without a divide/multiply round trip; size setters supply factors. */
+function setScaleX(f, s, percent = s * 100) {
+    f.target.setScaleX(clampScale(s));
+    f.xscale = percent;
+}
+function setScaleY(f, s, percent = s * 100) {
+    f.target.setScaleY(clampScale(s));
+    f.yscale = percent;
+}
+/**
+ * `_width` or `_height` set, as adl sets them: the bounds of the object's
+ * own content turned by its rotation, unscaled, in whole twips, are the
+ * base; the side set scales to the value over its base, the other to its
+ * size now over its base, both positive. A negative value changes nothing.
+ */
+function setSize(f, value, horizontal) {
+    if (value < 0) {
+        return;
+    }
+    const d = f.target;
+    d.touch();
+    // A field's own size is the value, in whole twips, whatever its scale (the corpus's
+    // `movieclip_create_text_field` and `edittext_width_height`).
+    if (d instanceof TextObject) {
+        if (horizontal) {
+            d.width = twips(value) / 20;
+        }
+        else {
+            d.height = twips(value) / 20;
+        }
+        d.fit();
+        return;
+    }
+    const r = twipsBounds(d, null);
+    const width = r === null ? 0 : r.xMax - r.xMin;
+    const height = r === null ? 0 : r.yMax - r.yMin;
+    const radians = ((d.rotation || 0) * Math.PI) / 180;
+    const cos = Math.abs(Math.cos(radians));
+    const sin = Math.abs(Math.sin(radians));
+    const baseWidth = Math.round(cos * width + sin * height) / 20;
+    const baseHeight = Math.round(sin * width + cos * height) / 20;
+    const [w, h] = size(d);
+    const sx = baseWidth !== 0 ? (horizontal ? value : w) / baseWidth : 0;
+    const sy = baseHeight !== 0 ? (horizontal ? h : value) / baseHeight : 0;
+    setScaleX(f, sx);
+    setScaleY(f, sy);
+}
+/** A number rounded to the nearest whole one, a half to the even one, as Rust's round_ties_even. */
+function roundEven(n) {
+    const r = Math.round(n);
+    return Math.abs(n % 1) === 0.5 && r % 2 !== 0 ? r - 1 : r;
+}
+const f32 = Math.fround;
+/** `m`, in pixels, as Flash keeps it. */
+const twipsMatrix = (m) => ({
+    a: f32(m.a),
+    b: f32(m.b),
+    c: f32(m.c),
+    d: f32(m.d),
+    tx: Math.round(m.tx * 20),
+    ty: Math.round(m.ty * 20),
+});
+/** A single float rounded to an int, a half to the even one, out of range -2^31, NaN 0 (Ruffle's round_to_i32). */
+function roundInt(n) {
+    if (!Number.isFinite(n)) {
+        return 0;
+    }
+    return n < 2147483648 ? roundEven(n) | 0 : -2147483648;
+}
+/** `m` then `n`, a child's matrix then its parent's, as Flash concatenates them. */
+function concatTwips(n, m) {
+    return {
+        a: f32(f32(n.a * m.a) + f32(n.c * m.b)),
+        b: f32(f32(n.b * m.a) + f32(n.d * m.b)),
+        c: f32(f32(n.a * m.c) + f32(n.c * m.d)),
+        d: f32(f32(n.b * m.c) + f32(n.d * m.d)),
+        tx: roundInt(f32(f32(n.a * m.tx) + f32(n.c * m.ty))) + n.tx,
+        ty: roundInt(f32(f32(n.b * m.tx) + f32(n.d * m.ty))) + n.ty,
+    };
+}
+/** `d`'s matrix to the stage's space, as Flash's local_to_global_matrix. */
+function toStageTwips(d, stage) {
+    let m = twipsMatrix(d.placed);
+    for (let p = d.parent; p !== null && p !== stage; p = p.parent) {
+        m = concatTwips(twipsMatrix(p.placed), m);
+    }
+    return m;
+}
+/** The inverse of `m`, null for a singular one (Ruffle's Matrix::inverse). */
+function invertTwips(m) {
+    const det = f32(f32(m.a * m.d) - f32(m.b * m.c));
+    if (!(Math.abs(det) > 1.1920929e-7)) {
+        return null;
+    }
+    return {
+        a: f32(m.d / det),
+        b: f32(m.b / -det),
+        c: f32(m.c / -det),
+        d: f32(m.a / det),
+        tx: roundInt(f32(f32(f32(m.d * m.tx) - f32(m.c * m.ty)) / -det)),
+        ty: roundInt(f32(f32(f32(m.b * m.tx) - f32(m.a * m.ty)) / det)),
+    };
+}
+/** A point in twips through `m`, rounded to twips as Flash's matrices do. */
+function transformTwips(m, x, y) {
+    return [
+        roundInt(f32(f32(m.a * x) + f32(m.c * y))) + m.tx,
+        roundInt(f32(f32(m.b * x) + f32(m.d * y))) + m.ty,
+    ];
+}
+/**
+ * `d`'s bounds in twips, its own (`m` null) or through matrix `m`, each
+ * corner rounded to twips; null for an object with nothing in it.
+ */
+function twipsBounds(d, m, lines = true) {
+    const r = bounds(d, lines);
+    if (r === null) {
+        return null;
+    }
+    const xMin = Math.round(r.xMin * 20);
+    const yMin = Math.round(r.yMin * 20);
+    const xMax = Math.round(r.xMax * 20);
+    const yMax = Math.round(r.yMax * 20);
+    if (m === null) {
+        return { xMin, yMin, xMax, yMax };
+    }
+    const corners = [
+        transformTwips(m, xMin, yMin),
+        transformTwips(m, xMin, yMax),
+        transformTwips(m, xMax, yMin),
+        transformTwips(m, xMax, yMax),
+    ];
+    const xs = corners.map((c) => c[0]);
+    const ys = corners.map((c) => c[1]);
+    return {
+        xMin: Math.min(...xs),
+        yMin: Math.min(...ys),
+        xMax: Math.max(...xs),
+        yMax: Math.max(...ys),
+    };
+}
+/** `name` among the path properties: `_root`, `_parent`, `_global` from SWF 6, `_levelN` and `_flashN`. */
+function pathProperty(face, name, version) {
+    if (version < 5) {
+        return avm1.ABSENT;
+    }
+    const key = version > 6 ? name : asciiLower(name);
+    const movie = face.movie;
+    switch (key) {
+        case "_root":
+            return movie.faceOf(movie.rootOf(face.target)) ?? undefined;
+        case "_parent": {
+            const parent = movie.levelOf(face.target) !== null ? null : face.target.parent;
+            return parent === null ? undefined : (movie.faceOf(parent) ?? undefined);
+        }
+        case "_global":
+            return version >= 6 ? movie.realm.global : avm1.ABSENT;
+    }
+    if (!key.startsWith("_level") && !key.startsWith("_flash")) {
+        return avm1.ABSENT;
+    }
+    const level = movie.level(levelOf(key.slice(6)));
+    return level === null ? undefined : (movie.faceOf(level) ?? undefined);
+}
+/** `_levelN`'s N as Flash reads it: a sign and the digits up to anything else, wrapping. */
+function levelOf(digits) {
+    const negative = digits.charCodeAt(0) === 0x2d;
+    let n = 0;
+    for (let i = negative ? 1 : 0; i < digits.length; i++) {
+        const d = digits.charCodeAt(i) - 0x30;
+        if (d < 0 || d > 9) {
+            break;
+        }
+        n = (Math.imul(n, 10) + d) | 0;
+    }
+    return negative ? -n | 0 : n;
+}
+/** `d`'s AVM1 side, null for one without. */
+export function nativeOf(d) {
+    const native = d.avm1?.display;
+    return native instanceof ClipNative ? native : null;
+}
+/** A display object's side of its AVM1 object (runtime's DisplayNative). */
+export class ClipNative {
+    movie;
+    target;
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return `ClipNative(${this.target.name})`;
+    }
+    type;
+    /** `_xscale` and `_yscale` as last set, given back as set while the scale is still theirs. */
+    xscale = null;
+    yscale = null;
+    /** A clip's own `_focusrect` from SWF 6, null for the stage's. */
+    focusRect = null;
+    /** Where it was as it was removed, the path its references find a clip at from then on. */
+    removedAt = null;
+    /** A clip's clip actions, from its place or the clip it duplicates; null for none. */
+    handlers = null;
+    /** The events of clip actions Flash could not read, which stop the SWF as one comes. */
+    corrupt = 0;
+    /** Whether a clip's load came, on its first frame. */
+    loaded = false;
+    /** Whether its unload came. */
+    unloaded = false;
+    /** Whether it was removed with an unload handler, and stays until the next frame. */
+    pending = false;
+    /** The SWF whose blocks its clip actions are, its place's. */
+    swf = null;
+    /** `_lockroot`: whether it is `_root` for the code in it, as a SWF loaded into it has it. */
+    lockroot = false;
+    constructor(movie, target) {
+        this.movie = movie;
+        this.target = target;
+        this.type = target instanceof MovieClip ? "movieclip" : "object";
+    }
+    get(name, version) {
+        // Ruffle's stage_object.rs: the path properties, then children, then the display properties.
+        const magic = name.charCodeAt(0) === 0x5f;
+        if (magic) {
+            const p = pathProperty(this, name, version);
+            if (p !== avm1.ABSENT) {
+                return p;
+            }
+        }
+        const child = childByName(this.target, name, version > 6);
+        if (child !== null) {
+            // An object without an AVM1 object of its own, a shape's, is its parent's.
+            return this.movie.faceOf(child) ?? this.movie.faceOf(this.target) ?? undefined;
+        }
+        if (magic) {
+            const property = BY_NAME.get(asciiLower(name));
+            if (property !== undefined) {
+                return property.get(this, version);
+            }
+        }
+        return avm1.ABSENT;
+    }
+    set(name, value, version) {
+        if (name.charCodeAt(0) !== 0x5f) {
+            return false;
+        }
+        const property = BY_NAME.get(asciiLower(name));
+        if (property === undefined) {
+            return false;
+        }
+        property.set?.(this, value, version);
+        return true;
+    }
+    changed(name, value, version) {
+        this.movie.propertyChanged(this.target, name, value, version);
+    }
+    keys(out) {
+        const d = this.target;
+        if (d instanceof MovieClip || d instanceof ButtonObject) {
+            const children = d.children;
+            for (let i = children.length - 1; i >= 0; i--) {
+                if (children[i].name !== "") {
+                    out.push(children[i].name);
+                }
+            }
+        }
+    }
+    path() {
+        return pathOf(this.target, (d) => this.movie.levelOf(d));
+    }
+    live() {
+        if (!this.movie.removed(this.target)) {
+            return this.movie.faceOf(this.target);
+        }
+        const path = this.removedAt;
+        const d = path === null ? null : this.movie.atPath(path);
+        return d === null || d === this.target ? null : this.movie.faceOf(d);
+    }
+    property(index, version) {
+        const p = PROPERTIES[index];
+        return p === undefined ? undefined : p[1].get(this, version);
+    }
+    setProperty(index, value, version) {
+        const p = PROPERTIES[index];
+        if (p === undefined) {
+            return false;
+        }
+        if (p[1].set === null) {
+            avm1Coerce(index, value, version);
+        }
+        else {
+            p[1].set(this, value, version);
+        }
+        return true;
+    }
+}
+/** A read-only property's value converted all the same, as SetProperty converts it. */
+function avm1Coerce(index, value, version) {
+    if (index <= 12 && value !== undefined && value !== null) {
+        avm1.toNumber(value, version);
+    }
+    else if (index === 20 || index === 21) {
+        avm1.toNumber(value, version);
+    }
+}
+/** The display object of `self`, a clip's AVM1 object, where it is one's. */
+function clipOf(self) {
+    if (!(self instanceof avm1.Avm1Object) || self.display === null) {
+        return null;
+    }
+    const live = self.display.live();
+    const d = live?.display?.target;
+    return d instanceof MovieClip ? d : null;
+}
+/** The bounds of `d` in `target`'s space, or the invalid ones of nothing, as an Object of xMin, xMax, yMin, yMax. */
+function boundsObject(movie, d, target, lines, version) {
+    let r;
+    if (target === d) {
+        r = twipsBounds(d, null, lines);
+    }
+    else {
+        const stage = movie.root.parent;
+        const up = toStageTwips(d, stage);
+        const down = invertTwips(toStageTwips(target, stage));
+        r = twipsBounds(d, down ? concatTwips(down, up) : up, lines);
+    }
+    if (!movie.newInvalidBounds && (version >= 8 || movie.version >= 8)) {
+        movie.newInvalidBounds = true;
+    }
+    // Twips of nothing: one more in another clip's space once switched, as Flash.
+    const none = target !== d && movie.newInvalidBounds ? 0x8000000 : 0x7ffffff;
+    const o = movie.realm.newObject(version);
+    avm1.set(o, "xMin", (r?.xMin ?? none) / 20, version);
+    avm1.set(o, "xMax", (r?.xMax ?? none) / 20, version);
+    avm1.set(o, "yMin", (r?.yMin ?? none) / 20, version);
+    avm1.set(o, "yMax", (r?.yMax ?? none) / 20, version);
+    return o;
+}
+/**
+ * A display object's `blendMode` on its class's prototype, of `flags`: its
+ * mode's name; one set that is none leaves it as it was (the corpus's
+ * movieclip_blend_mode_property, adl for a button's).
+ */
+export function blendModeProperty(realm, proto, flags, targetOf) {
+    const p = proto.add("blendMode", undefined, flags);
+    p.get = realm.method((self) => targetOf(self)?.blendMode);
+    p.set = realm.method((self, args) => {
+        const d = targetOf(self);
+        const mode = blendModeOf(args[0]);
+        if (d !== null && mode !== null) {
+            d.touch();
+            d.setBlendMode(mode);
+        }
+        return undefined;
+    });
+}
+/**
+ * A display object's `cacheAsBitmap` on its class's prototype, of `flags`:
+ * whether Flash draws it from a bitmap it keeps, as it does any filtered
+ * one whatever was set (as AS3's reads it); one set is what the script asks
+ * for, as Ruffle has it.
+ */
+export function cacheAsBitmapProperty(realm, proto, flags, targetOf) {
+    const p = proto.add("cacheAsBitmap", undefined, flags);
+    p.get = realm.method((self) => {
+        const d = targetOf(self);
+        return d === null ? undefined : cached(d);
+    });
+    p.set = realm.method((self, args, version) => {
+        targetOf(self)?.setCachedAsBitmap(avm1.toBoolean(args[0], version));
+        return undefined;
+    });
+}
+/** The display object a method's argument names from `start`: a clip's AVM1 object, or a path. */
+export function targetOf(movie, start, value, version) {
+    if (value instanceof avm1.Avm1Object && value.display !== null) {
+        return value.display.target;
+    }
+    const path = avm1.stringOf(value, version);
+    const from = movie.faceOf(start);
+    const cx = movie.realm.current;
+    if (path === "" || from === null || cx === null) {
+        return null;
+    }
+    const object = avm1.targetPath(cx, from, path, true, false, version);
+    const d = object?.display?.target;
+    return d === undefined ? null : d;
+}
+/** A point's own stored x and y, numbers both, as localToGlobal reads them, null for anything else. */
+function pointOf(value) {
+    if (!(value instanceof avm1.Avm1Object)) {
+        return null;
+    }
+    const x = value.exact("x");
+    const y = value.exact("y");
+    if (x === undefined ||
+        y === undefined ||
+        typeof x.value !== "number" ||
+        typeof y.value !== "number") {
+        return null;
+    }
+    return [value, x.value, y.value];
+}
+/** MovieClip: its constructor and its prototype's methods, as `_global.MovieClip`. */
+export function movieClipClass(movie) {
+    const realm = movie.realm;
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self) => self, () => undefined);
+    const method = (name, flags, fn) => {
+        proto.define(name, realm.method((self, args, version) => {
+            const clip = clipOf(self);
+            return clip === null ? undefined : fn(clip, args, version);
+        }), avm1.DONT_ENUM | avm1.DONT_DELETE | flags);
+    };
+    proto.define("useHandCursor", true, avm1.DONT_ENUM);
+    proto.define("enabled", true, avm1.DONT_ENUM);
+    drawingMethods(method, (clip) => movie.swfOf(clip).version);
+    method("attachMovie", 0, (clip, args, version) => {
+        if (args.length < 3) {
+            return undefined;
+        }
+        const name = avm1.stringOf(args[0], version);
+        const instance = avm1.stringOf(args[1], version);
+        const depth = avm1.toNumber(args[2], version) | 0;
+        const init = args.length > 3 && args[3] instanceof avm1.Avm1Object ? args[3] : null;
+        const child = movie.attachMovie(clip, name, instance, depth, init);
+        // A SWF 5 gets nothing back, as from duplicateMovieClip (adl).
+        return version < 6 || child === null ? undefined : (movie.faceOf(child) ?? undefined);
+    });
+    method("swapDepths", 0, (clip, args, version) => {
+        swapDepths(movie, clip, args[0], version);
+        return undefined;
+    });
+    method("localToGlobal", 0, (clip, args, version) => {
+        const p = pointOf(args[0]);
+        if (p !== null) {
+            const m = toStageTwips(clip, movie.root.parent);
+            const [x, y] = transformTwips(m, twips(p[1]), twips(p[2]));
+            avm1.set(p[0], "x", x / 20, version);
+            avm1.set(p[0], "y", y / 20, version);
+        }
+        return undefined;
+    });
+    method("globalToLocal", 0, (clip, args, version) => {
+        const p = pointOf(args[0]);
+        if (p !== null) {
+            const m = invertTwips(toStageTwips(clip, movie.root.parent));
+            const [x, y] = m ? transformTwips(m, twips(p[1]), twips(p[2])) : [twips(p[1]), twips(p[2])];
+            avm1.set(p[0], "x", x / 20, version);
+            avm1.set(p[0], "y", y / 20, version);
+        }
+        return undefined;
+    });
+    method("hitTest", 0, (clip, args, version) => {
+        if (args.length > 1) {
+            const x = avm1.toNumber(args[0], version);
+            const y = avm1.toNumber(args[1], version);
+            const shape = args.length > 2 && avm1.toBoolean(args[2], version);
+            if (Number.isFinite(x) && Number.isFinite(y)) {
+                // In the root's space, which may have moved; without the shape, in the
+                // box around the clip on the stage (Ruffle's hit_test_bounds).
+                const stage = movie.root.parent;
+                const [sx, sy] = apply(toStage(movie.root, stage), x, y);
+                if (shape) {
+                    return hitsPoint(clip, sx, sy, true, stage);
+                }
+                const r = bounds(clip, true);
+                return r !== null && contains(transformRect(r, toStage(clip, stage)), sx, sy);
+            }
+            return false;
+        }
+        if (args.length === 1) {
+            const other = targetOf(movie, clip, args[0], version);
+            return other !== null && hitsObject(clip, other, movie.root.parent);
+        }
+        return false;
+    });
+    // A snapshot of this clip by whatever TextSnapshot is on _global now.
+    method("getTextSnapshot", 0, (clip, _, version) => realm.construct(avm1.get(realm.global, "TextSnapshot", version), [movie.faceOf(clip) ?? undefined], version));
+    method("getBounds", 0, (clip, args, version) => {
+        const target = args.length > 0 ? targetOf(movie, clip, args[0], version) : clip;
+        return target === null ? undefined : boundsObject(movie, clip, target, true, version);
+    });
+    // A sprite's are its tags', a SWF's root's the SWF's.
+    const bytes = (clip) => {
+        const swf = movie.swfOf(clip);
+        return clip === swf.root ? swf.length : (clip.timeline.length ?? 0);
+    };
+    method("getBytesTotal", 0, bytes);
+    // A load in error has -1 bytes in all, none loaded (the corpus's movieclip_state_values).
+    method("getBytesLoaded", 0, (clip) => Math.max(0, bytes(clip)));
+    // The root is level 0's, at depth 0 (the corpus's movieclip_get_instance_at_depth).
+    method("getDepth", avm1.READ_ONLY | avm1.VERSION_6, (clip) => clip.depth !== null ? clip.depth - DEPTH_BIAS : clip === movie.root ? -DEPTH_BIAS : undefined);
+    // The SWF at the URL in place of what the clip shows, the clip's own variables sent where
+    // a method is "GET" or "POST", in any case (Ruffle's load_movie).
+    method("loadMovie", 0, (clip, args, version) => {
+        const face = clip.avm1;
+        if (face === null) {
+            return undefined;
+        }
+        const url = avm1.stringOf(args[0], version);
+        const method = args.length > 1 ? avm1.stringOf(args[1], version).toUpperCase() : "";
+        const form = method === "GET" || method === "POST" ? { method, vars: formVars(face, version) } : null;
+        movie.loadMovie(clip, url, form);
+        return undefined;
+    });
+    method("unloadMovie", 0, (clip) => {
+        movie.unloadMovie(clip);
+        return undefined;
+    });
+    method("play", 0, (clip) => {
+        clip.playing = true;
+        return undefined;
+    });
+    // As GetURL, from the code that called it, whose variables a method sends.
+    method("getURL", 0, (_, args, version) => {
+        const cx = movie.realm.current;
+        if (cx !== null) {
+            avm1.getUrlMethod(cx, args, version);
+        }
+        return undefined;
+    });
+    // The clip's own variables sent where a method is "GET" or "POST", in any case.
+    method("loadVariables", 0, (clip, args, version) => {
+        const face = clip.avm1;
+        if (args.length === 0 || face === null) {
+            return undefined;
+        }
+        const method = args.length > 1 ? avm1.stringOf(args[1], version).toUpperCase() : "";
+        const form = method === "GET" || method === "POST" ? { method, vars: formVars(face, version) } : null;
+        movie.loadVariables(clip, avm1.stringOf(args[0], version), form);
+        return undefined;
+    });
+    method("stop", 0, (clip) => {
+        clip.playing = false;
+        return undefined;
+    });
+    method("nextFrame", 0, (clip) => {
+        if (clip.currentFrame < clip.totalFrames) {
+            movie.timeline(clip).goto(clip.currentFrame + 1, false);
+        }
+        return undefined;
+    });
+    method("prevFrame", 0, (clip) => {
+        if (clip.currentFrame > 1) {
+            movie.timeline(clip).goto(clip.currentFrame - 1, false);
+        }
+        return undefined;
+    });
+    // Whether the clip is `_root` for the code in it; any value set as a boolean (the corpus's
+    // movieclip_lockroot).
+    const lockroot = proto.add("_lockroot", undefined, avm1.DONT_ENUM | avm1.DONT_DELETE);
+    lockroot.get = realm.method((self) => {
+        const clip = clipOf(self);
+        const native = clip?.avm1?.display;
+        return native instanceof ClipNative ? native.lockroot : undefined;
+    });
+    lockroot.set = realm.method((self, args, version) => {
+        const clip = clipOf(self);
+        const native = clip?.avm1?.display;
+        if (native instanceof ClipNative) {
+            native.lockroot = avm1.toBoolean(args[0], version);
+        }
+        return undefined;
+    });
+    // A new Transform of it each read; one given takes the matrix and colour transform of its clip.
+    const transform = proto.add("transform", undefined, avm1.DONT_ENUM | avm1.VERSION_8);
+    transform.get = realm.method((self, _, version) => {
+        const clip = clipOf(self);
+        const face = clip === null ? null : movie.faceOf(clip);
+        return face === null ? undefined : transformOf(movie, face, version);
+    });
+    transform.set = realm.method((self, args) => {
+        const clip = clipOf(self);
+        if (clip !== null) {
+            assignTransform(clip, args[0]);
+        }
+        return undefined;
+    });
+    filtersProperty(realm, proto, avm1.DONT_DELETE | avm1.DONT_ENUM | avm1.VERSION_8, clipOf, () => movie.filterFaces);
+    blendModeProperty(realm, proto, avm1.DONT_DELETE | avm1.DONT_ENUM | avm1.VERSION_8, clipOf);
+    cacheAsBitmapProperty(realm, proto, avm1.DONT_DELETE | avm1.DONT_ENUM | avm1.VERSION_8, clipOf);
+    // A BitmapData, disposed or not, at a depth; anything else does nothing. pixelSnapping is
+    // not read (Ruffle).
+    method("attachBitmap", avm1.VERSION_8, (clip, args, version) => {
+        const store = storeOf(args[0]);
+        if (store !== null && args.length > 1) {
+            const depth = avm1.toNumber(args[1], version) | 0;
+            movie.attachBitmap(clip, store, depth, args.length > 3 && avm1.toBoolean(args[3], version));
+        }
+        return undefined;
+    });
+    method("startDrag", 0, (clip, args, version) => {
+        const lockCenter = args.length > 0 && avm1.toBoolean(args[0], version);
+        const bounds = args.length > 4 ? args.slice(1, 5).map((a) => avm1.toNumber(a, version)) : null;
+        movie.startDrag(clip, lockCenter, bounds);
+        return undefined;
+    });
+    method("stopDrag", 0, () => {
+        movie.stopDrag();
+        return undefined;
+    });
+    method("setMask", avm1.VERSION_6, (clip, args, version) => {
+        if (args.length === 0) {
+            return undefined;
+        }
+        const value = args[0];
+        const mask = value == null ? null : movie.resolve(value, version);
+        if (value != null && mask === null) {
+            return false;
+        }
+        clip.setMask(mask);
+        return true;
+    });
+    method("gotoAndPlay", 0, (clip, args, version) => {
+        const cx = realm.current;
+        if (cx !== null) {
+            avm1.goto(cx, clip, args[0], true, 0, version);
+        }
+        return undefined;
+    });
+    method("gotoAndStop", 0, (clip, args, version) => {
+        const cx = realm.current;
+        if (cx !== null) {
+            avm1.goto(cx, clip, args[0], false, 0, version);
+        }
+        return undefined;
+    });
+    method("duplicateMovieClip", 0, (clip, args, version) => {
+        if (args.length === 0) {
+            return undefined;
+        }
+        // Any init object, as Flash takes it, an object made of a primitive (Ruffle: not version-gated).
+        const name = avm1.stringOf(args[0], version);
+        const depth = args.length > 1 ? avm1.toNumber(args[1], version) | 0 : 0;
+        const init = args.length > 2 ? realm.box(args[2], version) : null;
+        const child = movie.duplicate(clip, name, (depth + DEPTH_BIAS) | 0, init);
+        // A SWF 5 gets nothing back.
+        return version < 6 || child === null ? undefined : (movie.faceOf(child) ?? undefined);
+    });
+    proto.define("removeMovieClip", realm.method((self) => {
+        // Any display object's, as removeMovieClip.call(field) takes a text field.
+        const d = self instanceof avm1.Avm1Object ? self.display?.live()?.display?.target : undefined;
+        if (d !== undefined) {
+            movie.remove(d);
+        }
+        return undefined;
+    }), avm1.DONT_ENUM | avm1.DONT_DELETE);
+    method("getNextHighestDepth", avm1.VERSION_7, (clip) => {
+        let highest = -1;
+        for (const depth of clip.depths.keys()) {
+            highest = Math.max(highest, depth);
+        }
+        return Math.max(0, highest - (DEPTH_BIAS - 1));
+    });
+    method("getInstanceAtDepth", avm1.VERSION_7, (clip, args, version) => {
+        if (args.length === 0) {
+            return undefined;
+        }
+        const child = clip.depths.get((avm1.toNumber(args[0], version) | 0) + DEPTH_BIAS);
+        return child === undefined
+            ? undefined
+            : (movie.faceOf(child) ?? movie.faceOf(clip) ?? undefined);
+    });
+    method("getSWFVersion", 0, (clip) => {
+        const version = movie.swfOf(clip).version;
+        return version > 0 ? version : -1;
+    });
+    method("getRect", avm1.VERSION_8, (clip, args, version) => {
+        const target = args.length > 0 ? targetOf(movie, clip, args[0], version) : clip;
+        return target === null ? undefined : boundsObject(movie, clip, target, false, version);
+    });
+    method("createEmptyMovieClip", avm1.VERSION_6, (clip, args, version) => {
+        if (args.length < 2) {
+            return undefined;
+        }
+        const instance = avm1.stringOf(args[0], version);
+        const depth = avm1.toNumber(args[1], version) | 0;
+        return movie.faceOf(movie.createEmptyMovieClip(clip, instance, depth)) ?? undefined;
+    });
+    // Its place in whole pixels; a SWF 8 gets the field back, an earlier one nothing. The
+    // depth is cast as Rust casts it, saturating (Ruffle).
+    method("createTextField", avm1.VERSION_6, (clip, args, version) => {
+        const instance = avm1.stringOf(args[0], version);
+        const d = avm1.toNumber(args[1], version);
+        const depth = Number.isNaN(d) ? 0 : Math.trunc(Math.max(-0x80000000, Math.min(0x7fffffff, d)));
+        const [x, y, width, height] = args.slice(2, 6).map((a) => avm1.toNumber(a, version) | 0);
+        const field = movie.createTextField(clip, instance, depth, [x, y, width, height]);
+        return version < 8 ? undefined : (movie.faceOf(field) ?? undefined);
+    });
+    return { constr, proto };
+}
+/** swapDepths: to a depth, or to where a sibling is, swapping with what is there. */
+function swapDepths(movie, clip, arg, version) {
+    const parent = clip === movie.root ? null : clip.parent;
+    if (movie.removed(clip) || !(parent instanceof MovieClip)) {
+        return;
+    }
+    let depth = null;
+    if (typeof arg === "number") {
+        depth = ((avm1.toNumber(arg, version) | 0) + DEPTH_BIAS) | 0;
+    }
+    else {
+        const target = targetOf(movie, clip, arg, version);
+        if (target !== null && target.parent === parent && !movie.removed(target)) {
+            depth = target.depth;
+        }
+    }
+    if (depth === null || depth < 0 || depth > 2130706428 || depth === clip.depth) {
+        return;
+    }
+    const other = parent.depths.get(depth);
+    const from = clip.depth;
+    if (other !== undefined) {
+        parent.swapChildren(clip, other);
+        parent.depths.set(from, other);
+        other.depth = from;
+        // The clip swapped away is the script's too: the timeline no longer
+        // moves it, nor makes it anew on a rewind (`avm1-rewind-swapped-other`).
+        other.touch();
+    }
+    else {
+        parent.removeChild(clip);
+        parent.placeAtDepth(clip, depth);
+    }
+    parent.depths.set(depth, clip);
+    clip.depth = depth;
+    clip.touch();
+}