@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,600 @@
+// flash.geom's AS2 classes, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/point.rs, rectangle.rs, matrix.rs,
+// color_transform.rs and transform.rs have them: MIT OR Apache-2.0,
+// Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors. Point,
+// Rectangle and Matrix are plain objects, as Flash writes them in
+// ActionScript: their methods read and write their properties by name, so
+// any object with them will do, and their values are kept as given.
+// ColorTransform and Transform hold native state. What a method makes, a
+// Point, a Rectangle, a Matrix, is made by the class `_global.flash.geom`
+// has then, a script's own among them, in doubles where Ruffle works in
+// floats and twips.
+import { avm1 } from "../../../runtime/index.js";
+import { bounds, toStage } from "../../display/bounds.js";
+import { TRANSFORM } from "../../display/display.js";
+const num = (v, version) => avm1.toNumber(v, version);
+const read = (o, name, version) => o instanceof avm1.Avm1Object ? avm1.get(o, name, version) : undefined;
+const field = (o, name, version) => num(read(o, name, version), version);
+/** `_global.flash.geom[name]`, as the realm has it now: undefined where there is none. */
+function geomClass(realm, name, version) {
+    const geom = read(read(realm.global, "flash", version), "geom", version);
+    return read(geom, name, version);
+}
+/** A new `name` of `args`, by the class `flash.geom` has now; -1 where it has none (Ruffle). */
+export function makeGeom(realm, name, args, version) {
+    const constr = geomClass(realm, name, version);
+    return constr instanceof avm1.Avm1Function ? realm.construct(constr, args, version) : -1;
+}
+/** `o.name(...args)`, a method found as code calls it; undefined where there is none. */
+function callMethod(o, name, args, version) {
+    const method = read(o, name, version);
+    return method instanceof avm1.Avm1Function && o instanceof avm1.Avm1Object
+        ? method.call(o, args, version, 1)
+        : undefined;
+}
+/** `(a=1, b=2)`: each value as AVM1 makes it a string. */
+function described(o, names, version, short) {
+    const parts = names.map((n, i) => `${short?.[i] ?? n}=${avm1.stringOf(avm1.get(o, n, version), version)}`);
+    return `(${parts.join(", ")})`;
+}
+/** A getter, and a setter if given, on `o` as `name`. */
+function accessor(realm, o, name, get, set, flags = 0) {
+    const p = o.add(name, undefined, flags);
+    p.get = realm.method(get);
+    if (set !== null) {
+        p.set = realm.method(set);
+    }
+}
+function pointClass(realm) {
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self, args, v) => {
+        avm1.set(self, "x", args.length === 0 ? 0 : args[0], v);
+        avm1.set(self, "y", args.length === 0 ? 0 : args[1], v);
+        return self;
+    }, () => undefined);
+    const point = (x, y, v) => makeGeom(realm, "Point", [x, y], v);
+    const method = (name, f) => proto.define(name, realm.method(f), 0);
+    accessor(realm, proto, "length", (self, _, v) => Math.hypot(field(self, "x", v), field(self, "y", v)), null);
+    method("add", (self, args, v) => point(field(self, "x", v) + field(args[0], "x", v), field(self, "y", v) + field(args[0], "y", v), v));
+    method("subtract", (self, args, v) => point(field(self, "x", v) - field(args[0], "x", v), field(self, "y", v) - field(args[0], "y", v), v));
+    method("equals", (self, args, v) => args[0] instanceof avm1.Avm1Object &&
+        read(self, "x", v) === read(args[0], "x", v) &&
+        read(self, "y", v) === read(args[0], "y", v));
+    method("normalize", (self, args, v) => {
+        // A point of no length stays as it is, as Flash's (the corpus's `point`).
+        const length = Math.hypot(field(self, "x", v), field(self, "y", v));
+        if (Number.isFinite(length) && length !== 0) {
+            const k = num(args[0], v) / length;
+            avm1.set(self, "x", field(self, "x", v) * k, v);
+            avm1.set(self, "y", field(self, "y", v) * k, v);
+        }
+        return undefined;
+    });
+    method("offset", (self, args, v) => {
+        avm1.set(self, "x", field(self, "x", v) + num(args[0], v), v);
+        avm1.set(self, "y", field(self, "y", v) + num(args[1], v), v);
+        return undefined;
+    });
+    method("clone", (self, _, v) => makeGeom(realm, "Point", [read(self, "x", v), read(self, "y", v)], v));
+    method("toString", (self, _, v) => described(self, ["x", "y"], v));
+    const statics = (name, f) => constr.define(name, realm.method(f), 0);
+    statics("distance", (_, args, v) => args.length < 2 ? Number.NaN : read(callMethod(args[0], "subtract", [args[1]], v), "length", v));
+    statics("interpolate", (_, args, v) => {
+        if (args.length < 3) {
+            return point(Number.NaN, Number.NaN, v);
+        }
+        const [a, b, f] = [args[0], args[1], num(args[2], v)];
+        const bx = field(b, "x", v);
+        const by = field(b, "y", v);
+        return point(bx - (bx - field(a, "x", v)) * f, by - (by - field(a, "y", v)) * f, v);
+    });
+    statics("polar", (_, args, v) => {
+        const length = num(args[0], v);
+        const angle = num(args[1], v);
+        return point(length * Math.cos(angle), length * Math.sin(angle), v);
+    });
+    return constr;
+}
+function rectangleClass(realm) {
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const NAMES = ["x", "y", "width", "height"];
+    const constr = realm.classOf(proto, (self, args, v) => {
+        for (const [i, n] of NAMES.entries()) {
+            avm1.set(self, n, args.length === 0 ? 0 : args[i], v);
+        }
+        return self;
+    }, () => undefined);
+    const f = (o, n, v) => field(o, n, v);
+    const put = (o, n, value, v) => avm1.set(o, n, value, v);
+    const make = (x, y, w, h, v) => makeGeom(realm, "Rectangle", [x, y, w, h], v);
+    const point = (x, y, v) => makeGeom(realm, "Point", [x, y], v);
+    const method = (name, fn) => proto.define(name, realm.method(fn), 0);
+    const empty = (o, v) => !(f(o, "width", v) > 0) || !(f(o, "height", v) > 0);
+    accessor(realm, proto, "left", (self, _, v) => read(self, "x", v), (self, args, v) => {
+        put(self, "width", f(self, "width", v) + f(self, "x", v) - num(args[0], v), v);
+        put(self, "x", args[0], v);
+        return undefined;
+    });
+    accessor(realm, proto, "top", (self, _, v) => read(self, "y", v), (self, args, v) => {
+        put(self, "height", f(self, "height", v) + f(self, "y", v) - num(args[0], v), v);
+        put(self, "y", args[0], v);
+        return undefined;
+    });
+    accessor(realm, proto, "right", (self, _, v) => f(self, "x", v) + f(self, "width", v), (self, args, v) => {
+        put(self, "width", num(args[0], v) - f(self, "x", v), v);
+        return undefined;
+    });
+    accessor(realm, proto, "bottom", (self, _, v) => f(self, "y", v) + f(self, "height", v), (self, args, v) => {
+        put(self, "height", num(args[0], v) - f(self, "y", v), v);
+        return undefined;
+    });
+    accessor(realm, proto, "topLeft", 
+    // Points of the values as they are, not numbers (the corpus's `rectangle`).
+    (self, _, v) => makeGeom(realm, "Point", [read(self, "x", v), read(self, "y", v)], v), (self, args, v) => {
+        put(self, "width", f(self, "width", v) + f(self, "x", v) - f(args[0], "x", v), v);
+        put(self, "height", f(self, "height", v) + f(self, "y", v) - f(args[0], "y", v), v);
+        put(self, "x", read(args[0], "x", v), v);
+        put(self, "y", read(args[0], "y", v), v);
+        return undefined;
+    });
+    accessor(realm, proto, "bottomRight", (self, _, v) => point(f(self, "x", v) + f(self, "width", v), f(self, "y", v) + f(self, "height", v), v), (self, args, v) => {
+        put(self, "width", f(args[0], "x", v) - f(self, "x", v), v);
+        put(self, "height", f(args[0], "y", v) - f(self, "y", v), v);
+        return undefined;
+    });
+    accessor(realm, proto, "size", (self, _, v) => makeGeom(realm, "Point", [read(self, "width", v), read(self, "height", v)], v), (self, args, v) => {
+        put(self, "width", read(args[0], "x", v), v);
+        put(self, "height", read(args[0], "y", v), v);
+        return undefined;
+    });
+    method("clone", (self, _, v) => make(read(self, "x", v), read(self, "y", v), read(self, "width", v), read(self, "height", v), v));
+    method("isEmpty", (self, _, v) => empty(self, v));
+    method("setEmpty", (self, _, v) => {
+        for (const n of NAMES) {
+            put(self, n, 0, v);
+        }
+        return undefined;
+    });
+    const inflate = (self, dx, dy, v) => {
+        put(self, "x", f(self, "x", v) - dx, v);
+        put(self, "width", f(self, "width", v) + 2 * dx, v);
+        put(self, "y", f(self, "y", v) - dy, v);
+        put(self, "height", f(self, "height", v) + 2 * dy, v);
+        return undefined;
+    };
+    method("inflate", (self, args, v) => inflate(self, num(args[0], v), num(args[1], v), v));
+    method("inflatePoint", (self, args, v) => inflate(self, f(args[0], "x", v), f(args[0], "y", v), v));
+    const offset = (self, dx, dy, v) => {
+        put(self, "x", f(self, "x", v) + dx, v);
+        put(self, "y", f(self, "y", v) + dy, v);
+        return undefined;
+    };
+    method("offset", (self, args, v) => offset(self, num(args[0], v), num(args[1], v), v));
+    method("offsetPoint", (self, args, v) => offset(self, f(args[0], "x", v), f(args[0], "y", v), v));
+    // A NaN anywhere makes it undefined, neither in nor out (Ruffle).
+    const contains = (self, x, y, v) => {
+        const [rx, ry, w, h] = NAMES.map((n) => f(self, n, v));
+        if ([x, y, rx, ry, w, h].some(Number.isNaN)) {
+            return undefined;
+        }
+        return x >= rx && x < rx + w && y >= ry && y < ry + h;
+    };
+    method("contains", (self, args, v) => contains(self, num(args[0], v), num(args[1], v), v));
+    method("containsPoint", (self, args, v) => contains(self, f(args[0], "x", v), f(args[0], "y", v), v));
+    method("containsRectangle", (self, args, v) => {
+        const [rx, ry, w, h] = NAMES.map((n) => f(self, n, v));
+        const [ox, oy, ow, oh] = NAMES.map((n) => f(args[0], n, v));
+        if ([rx, ry, w, h, ox, oy, ow, oh].some(Number.isNaN)) {
+            return undefined;
+        }
+        return ox >= rx && oy >= ry && ox + ow <= rx + w && oy + oh <= ry + h;
+    });
+    const overlap = (self, other, v) => {
+        const [ax, ay, aw, ah] = NAMES.map((n) => f(self, n, v));
+        const [bx, by, bw, bh] = NAMES.map((n) => f(other, n, v));
+        const left = Math.max(ax, bx);
+        const top = Math.max(ay, by);
+        const right = Math.min(ax + aw, bx + bw);
+        const bottom = Math.min(ay + ah, by + bh);
+        return { left, top, right, bottom };
+    };
+    method("intersects", (self, args, v) => {
+        const o = overlap(self, args[0], v);
+        return o.right > o.left && o.bottom > o.top;
+    });
+    method("intersection", (self, args, v) => {
+        const o = overlap(self, args[0], v);
+        return o.right > o.left && o.bottom > o.top
+            ? make(o.left, o.top, o.right - o.left, o.bottom - o.top, v)
+            : make(0, 0, 0, 0, v);
+    });
+    method("union", (self, args, v) => {
+        // Empty here by a size not above 0: one of NaNs is not, and its NaNs go into the union.
+        const other = args[0];
+        const none = (o) => f(o, "width", v) <= 0 || f(o, "height", v) <= 0;
+        if (none(self)) {
+            return callMethod(other, "clone", [], v);
+        }
+        if (none(other)) {
+            return callMethod(self, "clone", [], v);
+        }
+        const [ax, ay, aw, ah] = NAMES.map((n) => f(self, n, v));
+        const [bx, by, bw, bh] = NAMES.map((n) => f(other, n, v));
+        const left = Math.min(ax, bx);
+        const top = Math.min(ay, by);
+        return make(left, top, Math.max(ax + aw, bx + bw) - left, Math.max(ay + ah, by + bh) - top, v);
+    });
+    method("equals", (self, args, v) => {
+        const other = args[0];
+        const constr = geomClass(realm, "Rectangle", v);
+        const prototype = read(constr, "prototype", v);
+        let p = other instanceof avm1.Avm1Object ? read(other, "__proto__", v) : undefined;
+        let isRectangle = false;
+        for (let depth = 0; p instanceof avm1.Avm1Object && depth < 256; depth++) {
+            if (p === prototype) {
+                isRectangle = true;
+                break;
+            }
+            p = read(p, "__proto__", v);
+        }
+        return isRectangle && NAMES.every((n) => read(self, n, v) === read(other, n, v));
+    });
+    method("toString", (self, _, v) => described(self, NAMES, v, ["x", "y", "w", "h"]));
+    return constr;
+}
+/** A matrix's six fields by name, as numbers. */
+function matrixOf(o, v) {
+    return [
+        field(o, "a", v),
+        field(o, "b", v),
+        field(o, "c", v),
+        field(o, "d", v),
+        field(o, "tx", v),
+        field(o, "ty", v),
+    ];
+}
+const MATRIX_NAMES = ["a", "b", "c", "d", "tx", "ty"];
+function setMatrix(o, m, v) {
+    for (const [i, n] of MATRIX_NAMES.entries()) {
+        avm1.set(o, n, m[i], v);
+    }
+    return undefined;
+}
+function matrixClass(realm) {
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self, args, v) => {
+        if (args.length === 0) {
+            setMatrix(self, [1, 0, 0, 1, 0, 0], v);
+        }
+        else {
+            for (const [i, n] of MATRIX_NAMES.entries()) {
+                if (i < args.length) {
+                    avm1.set(self, n, args[i], v);
+                }
+            }
+        }
+        return self;
+    }, () => undefined);
+    const method = (name, fn) => proto.define(name, realm.method(fn), 0);
+    const point = (x, y, v) => makeGeom(realm, "Point", [x, y], v);
+    method("identity", (self, _, v) => setMatrix(self, [1, 0, 0, 1, 0, 0], v));
+    method("translate", (self, args, v) => {
+        const [a, b, c, d, tx, ty] = matrixOf(self, v);
+        return setMatrix(self, [a, b, c, d, tx + num(args[0], v), ty + num(args[1], v)], v);
+    });
+    method("scale", (self, args, v) => {
+        const [a, b, c, d, tx, ty] = matrixOf(self, v);
+        const sx = num(args[0], v);
+        const sy = num(args[1], v);
+        return setMatrix(self, [a * sx, b * sy, c * sx, d * sy, tx * sx, ty * sy], v);
+    });
+    method("rotate", (self, args, v) => {
+        const [a, b, c, d, tx, ty] = matrixOf(self, v);
+        const q = num(args[0], v);
+        const cos = Math.cos(q);
+        const sin = Math.sin(q);
+        return setMatrix(self, [
+            a * cos - b * sin,
+            a * sin + b * cos,
+            c * cos - d * sin,
+            c * sin + d * cos,
+            tx * cos - ty * sin,
+            tx * sin + ty * cos,
+        ], v);
+    });
+    method("concat", (self, args, v) => {
+        const [a, b, c, d, tx, ty] = matrixOf(self, v);
+        const [ma, mb, mc, md, mtx, mty] = matrixOf(args[0], v);
+        return setMatrix(self, [
+            a * ma + b * mc,
+            a * mb + b * md,
+            c * ma + d * mc,
+            c * mb + d * md,
+            tx * ma + ty * mc + mtx,
+            tx * mb + ty * md + mty,
+        ], v);
+    });
+    method("invert", (self, _, v) => {
+        const [a, b, c, d, tx, ty] = matrixOf(self, v);
+        const det = a * d - b * c;
+        if (det === 0) {
+            return setMatrix(self, [1, 0, 0, 1, 0, 0], v);
+        }
+        return setMatrix(self, [d / det, -b / det, -c / det, a / det, (c * ty - d * tx) / det, (b * tx - a * ty) / det], v);
+    });
+    // A rotation not given is NaN, as Flash's; a translation not given is 0.
+    const box = (sx, sy, q, tx, ty) => {
+        const cos = Math.cos(q);
+        const sin = Math.sin(q);
+        return [sx * cos, sy * sin, -sx * sin, sy * cos, tx, ty];
+    };
+    const arg = (args, i, fallback, v) => i < args.length ? num(args[i], v) : fallback;
+    method("createBox", (self, args, v) => setMatrix(self, box(num(args[0], v), num(args[1], v), arg(args, 2, Number.NaN, v), arg(args, 3, 0, v), arg(args, 4, 0, v)), v));
+    method("createGradientBox", (self, args, v) => {
+        const w = num(args[0], v);
+        const h = num(args[1], v);
+        const x = arg(args, 3, 0, v);
+        const y = arg(args, 4, 0, v);
+        return setMatrix(self, box(w / 1638.4, h / 1638.4, arg(args, 2, 0, v), x + w / 2, y + h / 2), v);
+    });
+    method("transformPoint", (self, args, v) => {
+        const [a, b, c, d, tx, ty] = matrixOf(self, v);
+        const x = field(args[0], "x", v);
+        const y = field(args[0], "y", v);
+        return point(a * x + c * y + tx, b * x + d * y + ty, v);
+    });
+    method("deltaTransformPoint", (self, args, v) => {
+        const [a, b, c, d] = matrixOf(self, v);
+        const x = field(args[0], "x", v);
+        const y = field(args[0], "y", v);
+        return point(a * x + c * y, b * x + d * y, v);
+    });
+    method("clone", (self, _, v) => makeGeom(realm, "Matrix", MATRIX_NAMES.map((n) => read(self, n, v)), v));
+    method("toString", (self, _, v) => described(self, MATRIX_NAMES, v));
+    return constr;
+}
+/** A ColorTransform's eight values: the multipliers, red, green, blue, alpha, then the offsets. */
+const colors = new WeakMap();
+const COLOR_NAMES = [
+    "redMultiplier",
+    "greenMultiplier",
+    "blueMultiplier",
+    "alphaMultiplier",
+    "redOffset",
+    "greenOffset",
+    "blueOffset",
+    "alphaOffset",
+];
+/** A native ColorTransform's values, or null for anything else. */
+export function colorValues(o) {
+    return o instanceof avm1.Avm1Object ? (colors.get(o) ?? null) : null;
+}
+function colorTransformClass(realm) {
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self, args, v) => {
+        const values = Float64Array.of(1, 1, 1, 1, 0, 0, 0, 0);
+        const copied = args.length === 1 ? colorValues(args[0]) : null;
+        if (copied) {
+            values.set(copied);
+        }
+        else if (args.length >= 8) {
+            for (let i = 0; i < 8; i++) {
+                values[i] = num(args[i], v);
+            }
+        }
+        colors.set(self, values);
+        return self;
+    }, () => undefined);
+    // Alpha first of each four, as Flash defines them: for..in lists them the other way.
+    for (const i of [3, 0, 1, 2, 7, 4, 5, 6]) {
+        const name = COLOR_NAMES[i];
+        accessor(realm, proto, name, (self) => colors.get(self)?.[i], (self, args, v) => {
+            const values = colors.get(self);
+            if (values) {
+                values[i] = num(args[0], v);
+            }
+            return undefined;
+        });
+    }
+    accessor(realm, proto, "rgb", (self) => {
+        const c = colors.get(self);
+        return c ? (((c[4] | 0) << 16) + ((c[5] | 0) << 8) + (c[6] | 0)) >>> 0 : undefined;
+    }, (self, args, v) => {
+        const c = colors.get(self);
+        if (c) {
+            const rgb = num(args[0], v) >>> 0;
+            c.set([0, 0, 0], 0);
+            c[4] = (rgb >>> 16) & 0xff;
+            c[5] = (rgb >>> 8) & 0xff;
+            c[6] = rgb & 0xff;
+        }
+        return undefined;
+    });
+    proto.define("concat", realm.method((self, args) => {
+        const c = colors.get(self);
+        const o = colorValues(args[0]);
+        if (c && o) {
+            for (let i = 0; i < 4; i++) {
+                c[4 + i] = o[4 + i] * c[i] + c[4 + i];
+                c[i] *= o[i];
+            }
+        }
+        return undefined;
+    }), 0);
+    proto.define("toString", realm.method((self, _, v) => described(self, COLOR_NAMES, v)), 0);
+    return constr;
+}
+/** A Transform's clip, by its AVM1 object, read again as it is used, as Ruffle's MovieClipReference is. */
+const transforms = new WeakMap();
+/** What a clip's AVM1 object, or a Transform's, is the face of; null for anything else. */
+function displayOf(o) {
+    const face = o instanceof avm1.Avm1Object ? (transforms.get(o) ?? o) : null;
+    const target = face?.display?.target;
+    return target === undefined ? null : target;
+}
+/** `d`'s matrix as a new Matrix, in pixels. */
+function matrixObject(host, m, v) {
+    return makeGeom(host.realm, "Matrix", [m.a, m.b, m.c, m.d, m.tx, m.ty], v);
+}
+function colorObject(host, c, v) {
+    return makeGeom(host.realm, "ColorTransform", c ?? [1, 1, 1, 1, 0, 0, 0, 0], v);
+}
+/** A 16-bit integer, wrapped, as a clip's colour transform keeps each value. */
+export const int16 = (n) => ((n | 0) << 16) >> 16;
+/** A multiplier as a clip keeps it, in 8.8 fixed point, 16 bits. */
+const fixed8 = (n) => int16(Math.trunc(n * 256)) / 256;
+/** An offset as a clip keeps it: whole, 16 bits (-66682.5 is -1147). */
+const offset16 = (n) => int16(Math.floor(n));
+/** A display object's colour transform as ColorTransform's eight values. */
+function colorArgs(d) {
+    const c = d.colorTransform;
+    return c
+        ? [c.rMul, c.gMul, c.bMul, c.aMul, c.rAdd, c.gAdd, c.bAdd, c.aAdd]
+        : [1, 1, 1, 1, 0, 0, 0, 0];
+}
+/** `matrix` set on `d` where it has all six fields of its own: whole twips, as Flash keeps the translation. */
+function setDisplayMatrix(d, matrix, v) {
+    if (!(matrix instanceof avm1.Avm1Object) ||
+        MATRIX_NAMES.some((n) => matrix.own(n, v) === undefined)) {
+        return;
+    }
+    const [a, b, c, dd, tx, ty] = matrixOf(matrix, v);
+    d.setMatrix({ a, b, c, d: dd, tx: Math.round(tx * 20) / 20, ty: Math.round(ty * 20) / 20 });
+    d.touch();
+    d.invalidate(TRANSFORM);
+}
+/**
+ * A native ColorTransform's values set as `d`'s colour transform, as a
+ * clip keeps them: the multipliers in 8.8 fixed point, the offsets whole,
+ * each 16 bits, wrapped (the corpus's `transform`: -66682.5 is -1147).
+ */
+function setDisplayColor(d, color) {
+    const c = colorValues(color);
+    if (c === null) {
+        return;
+    }
+    d.colorTransform = {
+        rMul: fixed8(c[0]),
+        gMul: fixed8(c[1]),
+        bMul: fixed8(c[2]),
+        aMul: fixed8(c[3]),
+        rAdd: offset16(c[4]),
+        gAdd: offset16(c[5]),
+        bAdd: offset16(c[6]),
+        aAdd: offset16(c[7]),
+    };
+    d.touch();
+    d.invalidate(TRANSFORM);
+}
+function transformClass(host) {
+    const realm = host.realm;
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self, args) => {
+        // Of exactly one clip; otherwise `new` gives undefined.
+        if (args.length !== 1 || displayOf(args[0]) === null || transforms.has(args[0])) {
+            return undefined;
+        }
+        transforms.set(self, args[0]);
+        return self;
+    }, () => undefined);
+    const clip = (self) => (transforms.has(self) ? displayOf(self) : null);
+    accessor(realm, proto, "matrix", (self, _, v) => {
+        const d = clip(self);
+        return d ? matrixObject(host, d.matrix, v) : undefined;
+    }, (self, args, v) => {
+        const d = clip(self);
+        if (d) {
+            setDisplayMatrix(d, args[0], v);
+        }
+        return undefined;
+    });
+    accessor(realm, proto, "colorTransform", (self, _, v) => {
+        const d = clip(self);
+        return d ? colorObject(host, colorArgs(d), v) : undefined;
+    }, (self, args) => {
+        const d = clip(self);
+        if (d) {
+            setDisplayColor(d, args[0]);
+        }
+        return undefined;
+    });
+    accessor(realm, proto, "concatenatedMatrix", (self, _, v) => {
+        const d = clip(self);
+        return d ? matrixObject(host, toStage(d, host.stageOf(d)), v) : undefined;
+    }, null);
+    accessor(realm, proto, "concatenatedColorTransform", (self, _, v) => {
+        const d = clip(self);
+        if (!d) {
+            return undefined;
+        }
+        // Each ancestor's applied after what is in it, each product kept as a clip keeps a
+        // colour transform (the corpus's `transform`).
+        let c = colorArgs(d);
+        for (let p = d.parent; p !== null; p = p.parent) {
+            const o = colorArgs(p);
+            c = [
+                fixed8(c[0] * o[0]),
+                fixed8(c[1] * o[1]),
+                fixed8(c[2] * o[2]),
+                fixed8(c[3] * o[3]),
+                offset16(c[4] * o[0] + o[4]),
+                offset16(c[5] * o[1] + o[5]),
+                offset16(c[6] * o[2] + o[6]),
+                offset16(c[7] * o[3] + o[7]),
+            ];
+        }
+        return colorObject(host, c, v);
+    }, null);
+    accessor(realm, proto, "pixelBounds", (self, _, v) => {
+        const d = clip(self);
+        if (!d) {
+            return undefined;
+        }
+        const r = bounds(d, true);
+        const m = toStage(d, host.stageOf(d));
+        if (r === null) {
+            return makeGeom(realm, "Rectangle", [0, 0, 0, 0], v);
+        }
+        const xs = [r.xMin, r.xMax].flatMap((x) => [r.yMin, r.yMax].map((y) => m.a * x + m.c * y + m.tx));
+        const ys = [r.xMin, r.xMax].flatMap((x) => [r.yMin, r.yMax].map((y) => m.b * x + m.d * y + m.ty));
+        const left = Math.min(...xs);
+        const top = Math.min(...ys);
+        return makeGeom(realm, "Rectangle", [left, top, Math.max(...xs) - left, Math.max(...ys) - top], v);
+    }, null);
+    return constr;
+}
+/** A clip's `transform`: a new Transform of it each read, as Flash gives one. */
+export function transformOf(host, face, v) {
+    return makeGeom(host.realm, "Transform", [face], v);
+}
+/** `clip.transform = t`: the matrix and colour transform of the clip `t` is a Transform of. */
+export function assignTransform(d, t) {
+    const from = t instanceof avm1.Avm1Object && transforms.has(t) ? displayOf(t) : null;
+    if (from === null) {
+        return;
+    }
+    const m = from.matrix;
+    d.setMatrix({ a: m.a, b: m.b, c: m.c, d: m.d, tx: m.tx, ty: m.ty });
+    d.colorTransform = from.colorTransform ? { ...from.colorTransform } : null;
+    d.touch();
+    d.invalidate(TRANSFORM);
+}
+/**
+ * `_global.flash`, from SWF 8, with `geom`'s classes; `display` waits for
+ * BitmapData. Its members are plain properties, as Flash's.
+ */
+export function flashPackage(host) {
+    const realm = host.realm;
+    const flash = new avm1.Avm1Object(realm.objectProto);
+    const geom = new avm1.Avm1Object(realm.objectProto);
+    const display = new avm1.Avm1Object(realm.objectProto);
+    flash.define("geom", geom, 0);
+    flash.define("display", display, 0);
+    geom.define("Point", pointClass(realm), 0);
+    geom.define("Rectangle", rectangleClass(realm), 0);
+    geom.define("Matrix", matrixClass(realm), 0);
+    geom.define("ColorTransform", colorTransformClass(realm), 0);
+    geom.define("Transform", transformClass(host), 0);
+    realm.global.define("flash", flash, avm1.DONT_ENUM | avm1.VERSION_8);
+    return flash;
+}