@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/playerglobal/flash/display/DisplayObjectContainer.js

@@ -0,0 +1,224 @@
+// flash.display.DisplayObjectContainer: children by index, as AS3 sees
+// them, over the player's render-ordered list.
+import { avm2 } from "../../../../runtime/index.js";
+import { hitsOwnPoint } from "../../../display/bounds.js";
+import { Container, MovieClip, pickWork } from "../../../display/display.js";
+export function containerNatives(s) {
+    const natives = {};
+    // s.rt at call time: the natives are made before the runtime that holds them is.
+    const childOf = (v) => {
+        const d = v?.$display;
+        if (!d) {
+            throw s.rt.error("TypeError", 2007, "child");
+        }
+        return d;
+    };
+    const ownChild = (c, v) => {
+        const d = childOf(v);
+        if (d.parent !== c) {
+            throw s.rt.error("ArgumentError", 2025);
+        }
+        return d;
+    };
+    /**
+     * Where `d` is in `c`'s list, or -1. One the timeline is taking out is
+     * out of the list while its removal is told of, its parent still `c`.
+     */
+    const indexOf = (c, d) => d.parent === c ? c.children.indexOf(d) : -1;
+    const ownIndex = (c, d) => {
+        const i = indexOf(c, d);
+        if (i < 0) {
+            throw s.rt.error("ArgumentError", 2025);
+        }
+        return i;
+    };
+    const indexIn = (c, v, max = c.children.length - 1) => {
+        const i = s.rt.toInt(v);
+        if (i < 0 || i > max) {
+            throw s.rt.error("RangeError", 2006);
+        }
+        return i;
+    };
+    /** `d` put at `index` of `c`; `moved` if it is in `c`'s list already. */
+    const add = (c, v, d, index, moved) => {
+        // Adding an ancestor, or itself, would make a cycle.
+        for (let o = c; o; o = o.parent) {
+            if (o === d) {
+                throw s.rt.error("ArgumentError", 2150);
+            }
+        }
+        // Out of another parent first, with its events; within the same one, a move only. One the
+        // timeline is taking out of `c` is told of already.
+        if (d.parent && d.parent !== c) {
+            s.lifecycle.removing(d);
+        }
+        c.addChildAt(d, index);
+        if (!moved) {
+            s.lifecycle.added(d);
+        }
+        return v;
+    };
+    class DisplayObjectContainerNatives {
+        get numChildren() {
+            return this.$display.children.length;
+        }
+        /** Itself, if a clip, and every clip in it stopped, those not yet made alive too. */
+        stopAllMovieClips() {
+            const stop = (d) => {
+                if (d instanceof MovieClip) {
+                    d.playing = false;
+                }
+                if (d instanceof Container) {
+                    for (const child of d.children) {
+                        stop(child);
+                    }
+                }
+            };
+            stop(this.$display);
+        }
+        addChild(child) {
+            const c = this.$display;
+            const d = childOf(child);
+            // Already a child: moved to the top.
+            const moved = indexOf(c, d) >= 0;
+            return add(c, child, d, c.children.length - (moved ? 1 : 0), moved);
+        }
+        addChildAt(child, index) {
+            const c = this.$display;
+            const d = childOf(child);
+            const moved = indexOf(c, d) >= 0;
+            return add(c, child, d, indexIn(c, index, c.children.length - (moved ? 1 : 0)), moved);
+        }
+        removeChild(child) {
+            const c = this.$display;
+            s.lifecycle.remove(ownChild(c, child));
+            return child;
+        }
+        removeChildAt(index) {
+            const c = this.$display;
+            const d = c.children[indexIn(c, index)];
+            s.lifecycle.remove(d);
+            return d.object;
+        }
+        removeChildren(begin, end) {
+            const c = this.$display;
+            const n = c.children.length;
+            const from = begin === undefined ? 0 : s.rt.toInt(begin);
+            const to = end === undefined ? 0x7fffffff : s.rt.toInt(end);
+            // `end` is the last one removed. Its default, 0x7fffffff, stands for the last child, and
+            // with it a `begin` past the end removes nothing where Flash would otherwise throw.
+            const all = to === 0x7fffffff;
+            if (from < 0 || (!all && (to >= n || from > to))) {
+                throw s.rt.error("RangeError", 2006);
+            }
+            // Those there when it began, each from wherever a listener put it meanwhile, as Flash's
+            // are; one a listener took off already is left be.
+            for (const d of c.children.slice(from, all ? n : to + 1)) {
+                if (d.parent) {
+                    s.lifecycle.remove(d);
+                }
+            }
+        }
+        /**
+         * What draws under a point of the stage, of this container's
+         * descendants: each visible one whose own drawing is there, within
+         * its masks, parents before their children, as the corpus's
+         * `displayobjectcontainer_getobjectsunderpoint` has Flash's; masks and
+         * objects without a face to a script are left out.
+         */
+        getObjectsUnderPoint(point) {
+            if (point === null || point === undefined) {
+                throw s.rt.error("TypeError", 2007, "point");
+            }
+            const x = s.rt.toNumber(s.rt.getProperty(point, s.rt.publicName("x")));
+            const y = s.rt.toNumber(s.rt.getProperty(point, s.rt.publicName("y")));
+            const found = [];
+            const stage = s.stage;
+            if (!stage) {
+                return s.rt.array(found);
+            }
+            const visit = (c) => {
+                for (const d of c.children) {
+                    if (!d.visible || d.clipDepth > 0 || d.maskOf) {
+                        continue;
+                    }
+                    if (d.object && hitsOwnPoint(d, x, y, stage)) {
+                        found.push(d.object);
+                    }
+                    if (d instanceof Container) {
+                        visit(d);
+                    }
+                }
+            };
+            visit(this.$display);
+            return s.rt.array(found);
+        }
+        /** Whether a security sandbox hides any of them: the player has none. */
+        areInaccessibleObjectsUnderPoint(point) {
+            if (point === null || point === undefined) {
+                throw s.rt.error("TypeError", 2007, "point");
+            }
+            return false;
+        }
+        getChildAt(index) {
+            const c = this.$display;
+            return c.children[indexIn(c, index)].object;
+        }
+        getChildIndex(child) {
+            const c = this.$display;
+            return ownIndex(c, childOf(child));
+        }
+        setChildIndex(child, index) {
+            const c = this.$display;
+            const d = childOf(child);
+            ownIndex(c, d);
+            c.addChildAt(d, indexIn(c, index));
+        }
+        getChildByName(name) {
+            if (name === null || name === undefined) {
+                throw s.rt.error("TypeError", 2007, "name");
+            }
+            return this.$display.children.find((d) => d.name === name)?.object ?? null;
+        }
+        contains(child) {
+            const c = this.$display;
+            for (let o = child?.$display ?? null; o; o = o.parent) {
+                if (o === c) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        swapChildren(a, b) {
+            const c = this.$display;
+            const x = childOf(a);
+            ownIndex(c, x);
+            const y = childOf(b);
+            ownIndex(c, y);
+            c.swapChildren(x, y);
+        }
+        swapChildrenAt(a, b) {
+            const c = this.$display;
+            c.swapChildren(c.children[indexIn(c, a)], c.children[indexIn(c, b)]);
+        }
+        get mouseChildren() {
+            return this.$mouseChildren ?? true;
+        }
+        set mouseChildren(v) {
+            this.$mouseChildren = !!v;
+            pickWork.changes++;
+        }
+        // The stage's is always true: setting it sets the root's, removed or not, as Ruffle has it.
+        get tabChildren() {
+            return this === s.stage?.object ? true : (this.$tabChildren ?? true);
+        }
+        set tabChildren(v) {
+            const target = this === s.stage?.object ? s.root?.object : this;
+            if (target) {
+                target.$tabChildren = !!v;
+            }
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::DisplayObjectContainer", DisplayObjectContainerNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/Graphics.js

@@ -0,0 +1,345 @@
+import { avm2 } from "../../../../runtime/index.js";
+import { BitmapStore } from "../../../bitmap/bitmap.js";
+import { CONTENT, Container, ShapeObject } from "../../../display/display.js";
+import { Drawing } from "../../../display/drawing.js";
+import { concat } from "../../../display/geometry.js";
+import { graphicsData } from "../../../display/graphicsdata.js";
+import { CHECK, COPY, kernelOfShader, shaderUse } from "./shaders.js";
+const TWIPS = 20;
+const CAPS = { round: 0, none: 1, square: 2 };
+const JOINTS = { round: 0, bevel: 1, miter: 2 };
+/** Which way round a triangle drawTriangles drops: 1 clockwise on a y-down screen, -1 the other. */
+const CULLING = { none: 0, positive: 1, negative: -1 };
+const IDENTITY = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+// Made once: a drawing may begin a bitmap fill for each triangle it draws on every frame.
+const MATRIX_NAMES = ["a", "b", "c", "d", "tx", "ty"].map((k) => avm2.qname(avm2.publicNs, k));
+/** The gradients begun with no matrix, which read back with Flash's default for one. */
+const unplaced = new WeakSet();
+/** A Graphics object for `display`, made once. */
+export function graphicsOf(s, o) {
+    if (!o.$graphics) {
+        const g = s.rt.construct(s.rt.classNamed("flash.display::Graphics"));
+        g.$display = o.$display;
+        o.$graphics = g;
+    }
+    return o.$graphics;
+}
+/** 0xAARRGGBB of a color and an alpha in [0, 1], the alpha a byte floored as Flash stores it (0.5 is 127). */
+function argb(color, alpha) {
+    const a = Math.floor(Math.max(0, Math.min(1, Number(alpha))) * 255);
+    return ((a << 24) | (Number(color) & 0xffffff)) >>> 0;
+}
+export function graphicsNatives(s) {
+    const natives = {};
+    const drawing = (o) => {
+        o.$display.drawing ??= new Drawing();
+        o.$display.invalidate(CONTENT);
+        return o.$display.drawing;
+    };
+    const num = (v, fallback = 0) => {
+        const n = Number(v);
+        return Number.isNaN(n) ? fallback : n;
+    };
+    /** A shader as a fill takes it: TypeError 2007 for null, 2171 for no kernel, its inputs set (2164). */
+    const shaderOf = (shader, how = COPY) => {
+        if (shader === null || shader === undefined) {
+            throw s.rt.error("TypeError", 2007, "shader");
+        }
+        if (!kernelOfShader(shader)) {
+            throw s.rt.error("ArgumentError", 2171);
+        }
+        return shaderUse(s, shader, 0, how);
+    };
+    /** A fill's matrix from an AS3 Matrix, or the identity for none. */
+    const matrixFrom = (matrix) => {
+        if (matrix === null || matrix === undefined) {
+            return { ...IDENTITY };
+        }
+        const rt = s.rt;
+        const m = matrix;
+        return {
+            a: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[0])),
+            b: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[1])),
+            c: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[2])),
+            d: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[3])),
+            tx: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[4])),
+            ty: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[5])),
+        };
+    };
+    /** The data of `display`'s drawing, a timeline shape's too, and with `recurse` its children's, each through `m`. */
+    const gather = (display, m, recurse, out) => {
+        if (display instanceof ShapeObject) {
+            graphicsData(display.drawn()?.layers ?? [], m, unplaced, out);
+        }
+        graphicsData(display.drawing?.layers ?? [], m, unplaced, out);
+        if (recurse && display instanceof Container) {
+            for (const child of display.children) {
+                gather(child, concat(child.matrix, m), true, out);
+            }
+        }
+    };
+    const matrixOf = (m) => s.rt.construct(s.rt.classNamed("flash.geom::Matrix"), m.a, m.b, m.c, m.d, m.tx, m.ty);
+    const vectorOf = (type, values) => {
+        const o = s.rt.resolve(s.rt.vector(type)).$it.instance();
+        o.$a = values;
+        return o;
+    };
+    const objectOf = (datum) => {
+        const make = (name, ...args) => s.rt.construct(s.rt.classNamed(`flash.display::${name}`), ...args);
+        switch (datum.type) {
+            case "solid":
+                return make("GraphicsSolidFill", datum.color, datum.alpha);
+            case "gradient":
+                return make("GraphicsGradientFill", datum.radial ? "radial" : "linear", s.rt.array(datum.colors), s.rt.array(datum.alphas), s.rt.array(datum.ratios), matrixOf(datum.matrix), datum.spread, datum.linearRgb ? "linearRGB" : "rgb", datum.focal);
+            case "bitmap": {
+                // A copy of its pixels, not the BitmapData it was begun with, as adl gives.
+                const store = datum.image instanceof BitmapStore ? datum.image : null;
+                let bitmap = null;
+                if (store) {
+                    bitmap = s.rt.construct(s.rt.classNamed("flash.display::BitmapData"), store.width, store.height, store.transparent, 0);
+                    bitmap.$store = store.clone();
+                }
+                return make("GraphicsBitmapFill", bitmap, matrixOf(datum.matrix), true, false);
+            }
+            case "path":
+                return make("GraphicsPath", vectorOf("int", datum.commands), vectorOf("Number", datum.data), datum.winding);
+            default:
+                return make("GraphicsEndFill");
+        }
+    };
+    class GraphicsNatives {
+        /** readGraphicsData's: what the drawing holds, in Flash's form, onto `target`. */
+        "flash.display:Graphics::nativeGetGraphicsData"(target, recurse) {
+            const out = [];
+            gather(this.$display, IDENTITY, !!recurse, out);
+            const list = target.$a;
+            for (const datum of out) {
+                list.push(objectOf(datum));
+            }
+        }
+        clear() {
+            drawing(this).clear();
+        }
+        beginFill(color, alpha = 1) {
+            drawing(this).beginFill({ type: "solid", color: argb(color, alpha) });
+        }
+        /** Recorded as a shape's gradient is drawn: its first stop's color, until gradients draw. */
+        /**
+         * As adl draws one: arrays of different lengths, or a ratio outside 0
+         * to 255, draw nothing; no stops draw black; past 16 stops are left
+         * out; an unknown spread or interpolation is pad or RGB; null alphas
+         * and ratios are opaque and even, null colours TypeError 2007.
+         */
+        beginGradientFill(type, colors, alphas, ratios, matrix = null, spreadMethod = "pad", interpolationMethod = "rgb", focalPointRatio = 0) {
+            const kind = s.rt.toString(type);
+            if (kind !== "linear" && kind !== "radial") {
+                throw s.rt.error("ArgumentError", 2008, "type");
+            }
+            if (colors === null || colors === undefined) {
+                throw s.rt.error("TypeError", 2007, "colors");
+            }
+            // Null alphas are opaque, and null ratios spread evenly, floor(255 k / (n - 1)), as adl draws them.
+            const array = (v) => v.$a ?? [];
+            const c = array(colors);
+            const a = alphas === null || alphas === undefined ? c.map(() => 1) : array(alphas);
+            const r = ratios === null || ratios === undefined
+                ? c.map((_, k) => (c.length > 1 ? Math.floor((255 * k) / (c.length - 1)) : 0))
+                : array(ratios).map((v) => Math.trunc(s.rt.toNumber(v)));
+            if (a.length !== c.length || r.length !== c.length || r.some((v) => !(v >= 0 && v <= 255))) {
+                drawing(this).beginFill({ type: "solid", color: 0 });
+                return;
+            }
+            const spread = s.rt.toString(spreadMethod);
+            const fill = {
+                type: "gradient",
+                radial: kind === "radial",
+                focal: kind === "radial" ? num(focalPointRatio) : 0,
+                stops: c.slice(0, 16).map((color, i) => ({ ratio: r[i], color: argb(color, a[i]) })),
+                spread: spread === "reflect" ? 1 : spread === "repeat" ? 2 : 0,
+                linearRgb: s.rt.toString(interpolationMethod) === "linearRGB",
+                matrix: matrixFrom(matrix),
+            };
+            if (matrix === null || matrix === undefined) {
+                unplaced.add(fill);
+            }
+            drawing(this).beginFill(fill);
+        }
+        /** The BitmapData itself, not a copy: the fill shows its later changes, the shape a view of its store. */
+        beginBitmapFill(bitmap, matrix = null, repeat = true, smooth = false) {
+            if (bitmap === null || bitmap === undefined) {
+                throw s.rt.error("TypeError", 2007, "bitmap");
+            }
+            const store = bitmap.$store;
+            if (!store) {
+                throw s.rt.error("ArgumentError", 2015);
+            }
+            store.views.add(this.$display.ref);
+            drawing(this).beginFill({
+                type: "image",
+                image: store,
+                matrix: matrixFrom(matrix),
+                repeat: !!repeat,
+                smooth: !!smooth,
+            });
+        }
+        /**
+         * A fill of the kernel's pixels, its parameters and images taken as they
+         * are now: the shape's points through the matrix's inverse are its
+         * coordinates, a pixel's centre each, as adl draws it.
+         */
+        beginShaderFill(shader, matrix = null) {
+            drawing(this).beginFill({
+                type: "shader",
+                use: shaderOf(shader),
+                matrix: matrixFrom(matrix),
+            });
+        }
+        endFill() {
+            drawing(this).endFill();
+        }
+        lineStyle(thickness = Number.NaN, color = 0, alpha = 1, pixelHinting = false, scaleMode = "normal", caps = null, joints = null, miterLimit = 3) {
+            const t = Number(thickness);
+            if (Number.isNaN(t)) {
+                drawing(this).lineStyle(null);
+                return;
+            }
+            const cap = CAPS[String(caps ?? "round")] ?? 0;
+            const line = {
+                width: Math.round(Math.max(0, Math.min(255, t)) * TWIPS),
+                color: argb(color, alpha),
+                startCap: cap,
+                endCap: cap,
+                join: JOINTS[String(joints ?? "round")] ?? 0,
+                miterLimit: num(miterLimit, 3),
+                noHScale: scaleMode === "none" || scaleMode === "vertical",
+                noVScale: scaleMode === "none" || scaleMode === "horizontal",
+                pixelHinting: !!pixelHinting,
+                noClose: false,
+                fill: null,
+            };
+            drawing(this).lineStyle(line);
+        }
+        lineGradientStyle() {
+            // The line keeps the color lineStyle gave it, as a shape's gradient line does.
+        }
+        lineBitmapStyle() {
+            // As lineGradientStyle.
+        }
+        /** Checked as adl checks it; the line keeps its colour, as a gradient's does. */
+        lineShaderStyle(shader) {
+            shaderOf(shader, CHECK);
+        }
+        drawRect(x, y, w, h) {
+            drawing(this).drawRect(num(x), num(y), num(w), num(h));
+        }
+        drawRoundRect(x, y, w, h, ew, eh = Number.NaN) {
+            const e = num(ew);
+            drawing(this).drawRoundRect(num(x), num(y), num(w), num(h), e, num(eh, e));
+        }
+        drawRoundRectComplex(x, y, w, h, tl, tr, bl, br) {
+            const r = (v) => {
+                const c = Math.min(Math.abs(num(v)), Math.abs(num(w)) / 2, Math.abs(num(h)) / 2);
+                return [c, c];
+            };
+            drawing(this).drawRoundRectComplex(num(x), num(y), num(w), num(h), r(tl), r(tr), r(bl), r(br));
+        }
+        moveTo(x, y) {
+            drawing(this).moveTo(num(x), num(y));
+        }
+        lineTo(x, y) {
+            drawing(this).lineTo(num(x), num(y));
+        }
+        curveTo(cx, cy, x, y) {
+            drawing(this).curveTo(num(cx), num(cy), num(x), num(y));
+        }
+        cubicCurveTo(c1x, c1y, c2x, c2y, x, y) {
+            drawing(this).cubicCurveTo(num(c1x), num(c1y), num(c2x), num(c2y), num(x), num(y));
+        }
+        /** As Flash checks: the winding one of its two, and the data's count even when there are commands (ArgumentError #2008, #2004). */
+        drawPath(commands, data, winding = "evenOdd") {
+            if (winding !== "evenOdd" && winding !== "nonZero") {
+                throw s.rt.error("ArgumentError", 2008, "winding");
+            }
+            const c = (commands?.$a ?? []).map((v) => Number(v));
+            const d = (data?.$a ?? []).map((v) => Number(v));
+            if (c.length && d.length % 2) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            drawing(this).drawPath(c, d, winding);
+        }
+        /**
+         * As Flash checks: the vertices in pairs, three of them a triangle
+         * without indices, indices in threes, and uvtData two or three a vertex,
+         * each ArgumentError #2004; then the culling one of its three, #2008.
+         * Null vertices draw nothing, and an index past the vertices ends the
+         * triangles there, without an error.
+         */
+        drawTriangles(vertices, indices = null, uvtData = null, culling = "none") {
+            if (vertices === null || vertices === undefined) {
+                return;
+            }
+            // The vectors' own storage, read, not copied: a Vector.<Number>'s and a Vector.<int>'s hold
+            // numbers alone, and a 3D engine passes thousands of them every frame.
+            const numbers = (v) => v.$a;
+            const given = numbers(vertices);
+            let coordinates = given;
+            // Flash keeps a point in twips as an int: NaN, or one past an int's range, is its least.
+            for (let i = 0; i < coordinates.length; i++) {
+                const x = coordinates[i] * TWIPS;
+                if (!(x >= -2147483648 && x <= 2147483647)) {
+                    if (coordinates === given) {
+                        coordinates = given.slice();
+                    }
+                    coordinates[i] = -2147483648 / TWIPS;
+                }
+            }
+            const n = coordinates.length / 2;
+            const order = indices === null || indices === undefined ? null : numbers(indices);
+            const uvt = uvtData === null || uvtData === undefined ? null : numbers(uvtData);
+            if (coordinates.length % 2 ||
+                (order ? order.length % 3 : n % 3) ||
+                (uvt && uvt.length !== n * 2 && uvt.length !== n * 3)) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            const cull = typeof culling === "string" && Object.hasOwn(CULLING, culling)
+                ? CULLING[culling]
+                : undefined;
+            if (cull === undefined) {
+                throw s.rt.error("ArgumentError", 2008, "culling");
+            }
+            // Three a vertex, t 1 where Flash was given none.
+            let full = uvt;
+            if (uvt && uvt.length !== n * 3) {
+                full = new Array(n * 3);
+                for (let v = 0; v < n; v++) {
+                    full[3 * v] = uvt[2 * v];
+                    full[3 * v + 1] = uvt[2 * v + 1];
+                    full[3 * v + 2] = 1;
+                }
+            }
+            drawing(this).drawTriangles(coordinates, order, full, cull);
+        }
+        copyFrom(other) {
+            const source = other?.$display?.drawing;
+            if (source) {
+                drawing(this).copyFrom(source);
+                // Its BitmapData fills watched as the other's are.
+                for (const layer of source.layers) {
+                    for (const { fill } of layer.fills) {
+                        if (fill.type === "image" && fill.image instanceof BitmapStore) {
+                            fill.image.views.add(this.$display.ref);
+                        }
+                    }
+                    for (const mesh of layer.meshes ?? []) {
+                        mesh.image.views.add(this.$display.ref);
+                    }
+                }
+            }
+            else {
+                drawing(this).clear();
+            }
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::Graphics", GraphicsNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/InteractiveObject.js

@@ -0,0 +1,87 @@
+// flash.display.InteractiveObject: what it keeps about input, kept as
+// fields with Flash's defaults until input reaches the player.
+import { avm2 } from "../../../../runtime/index.js";
+import { pickWork } from "../../../display/display.js";
+import { tabEnabledDefault } from "../../../input/keyboard.js";
+import { displayOf } from "./DisplayObject.js";
+/**
+ * `v` as an instance of the class `qualified` names, as Flash coerces a
+ * native's argument to its declared type: null for null and undefined,
+ * TypeError #1034 for anything else that is not one.
+ */
+export function coerceArgument(s, v, qualified) {
+    if (v === null || v === undefined) {
+        return null;
+    }
+    const cls = s.rt.classNamed(qualified);
+    if (s.rt.isInstance(v, cls)) {
+        return v;
+    }
+    throw s.rt.error("TypeError", 1034, s.rt.describe(v), cls.$it.name);
+}
+export function interactiveObjectNatives(s) {
+    const natives = {};
+    class InteractiveObjectNatives {
+        get tabEnabled() {
+            return this.$tabEnabled ?? tabEnabledDefault(displayOf(this));
+        }
+        set tabEnabled(v) {
+            this.$tabEnabled = !!v;
+        }
+        get tabIndex() {
+            return this.$tabIndex ?? -1;
+        }
+        set tabIndex(v) {
+            this.$tabIndex = Number(v) | 0;
+        }
+        get focusRect() {
+            return this.$focusRect ?? null;
+        }
+        set focusRect(v) {
+            this.$focusRect = v;
+        }
+        get mouseEnabled() {
+            return this.$mouseEnabled ?? true;
+        }
+        set mouseEnabled(v) {
+            this.$mouseEnabled = !!v;
+            pickWork.changes++;
+        }
+        get doubleClickEnabled() {
+            return this.$doubleClickEnabled ?? false;
+        }
+        set doubleClickEnabled(v) {
+            this.$doubleClickEnabled = !!v;
+        }
+        get accessibilityImplementation() {
+            return this.$accessibility ?? null;
+        }
+        set accessibilityImplementation(v) {
+            this.$accessibility = v;
+        }
+        get softKeyboardInputAreaOfInterest() {
+            return this.$softKeyboardArea ?? null;
+        }
+        set softKeyboardInputAreaOfInterest(v) {
+            this.$softKeyboardArea = v;
+        }
+        get needsSoftKeyboard() {
+            return this.$needsSoftKeyboard ?? false;
+        }
+        set needsSoftKeyboard(v) {
+            this.$needsSoftKeyboard = !!v;
+        }
+        /** Read when the host opens the SWF's context menu. */
+        get contextMenu() {
+            return this.$contextMenu ?? null;
+        }
+        set contextMenu(v) {
+            this.$contextMenu = coerceArgument(s, v, "flash.display::NativeMenu");
+        }
+        requestSoftKeyboard() {
+            return false;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::InteractiveObject", InteractiveObjectNatives);
+    return natives;
+}