@swf2es/player 0.0.0-stage → 0.1.0

package/dist/scripting.js

@@ -0,0 +1,1019 @@
+// A SWF's scripts: the runtime with playerglobal's natives, the link
+// between a display object and the AS3 object that is its other face
+// (docs/architecture/player.md, "Scripts and the display list"), and the frame
+// that runs them: its events, frame scripts, gotos' cycles and the
+// construction of what timelines placed. The runtime allocates every
+// DisplayObject through a hook that takes the display object the player
+// has pending, when the player constructs a timeline child's class, or
+// makes one for a `new`. The rest is in parts it holds, in scripting/:
+// the SWFs' code, what SymbolClass binds, display objects' comings and
+// goings, loads and timers.
+import { AIR_API_VERSION, API_VERSION } from "@swf2es/codegen";
+import { avm2 } from "@swf2es/runtime";
+import { decodeInBrowser } from "./bitmap/images.js";
+import { BitmapObject, BUTTON, ButtonObject, buttonStates, CLIP, Container, MovieClip, OTHER, scriptChildren, scriptWork, TRANSFORM, walkList, } from "./display/display.js";
+import { browserFileHost } from "./files.js";
+import { browserClipboard, browserNavigate, defaultStorage, globalWebSocketHost, hostTouchPoints, memoryStore, platformCapabilities, } from "./hosts.js";
+import { LocalConnections } from "./localconnection.js";
+import { browserAudioHost } from "./media/audio.js";
+import { finishSounds, soundHostOf, stopAllSounds, timelineSoundsOf } from "./media/sounds.js";
+import { airLibrary, builtinLibrary, playerglobalLibrary, playerHooks, playerNatives, } from "./playerglobal/index.js";
+import { Clipboard } from "./scripting/clipboard.js";
+import { Code } from "./scripting/code.js";
+import { dispatchTo, heard, WeakTargets } from "./scripting/events.js";
+import { ModuleHandover, ModuleRecorder } from "./scripting/handover.js";
+import { Lifecycle } from "./scripting/lifecycle.js";
+import { Loads } from "./scripting/loads.js";
+import { Symbols } from "./scripting/symbols.js";
+import { Timers } from "./scripting/timers.js";
+import { Workers } from "./scripting/workers.js";
+import { stageAlignment } from "./stage.js";
+// For index.ts, which reaches playerglobal only through here.
+export { airLibrary, builtinLibrary, playerglobalLibrary };
+/** AS3 classes placed children are instances of when SymbolClass binds none. */
+const DEFAULT_CLASS = {
+    shape: "flash.display::Shape",
+    morph: "flash.display::MorphShape",
+    sprite: "flash.display::MovieClip",
+    button: "flash.display::SimpleButton",
+    bitmap: "flash.display::Bitmap",
+    text: "flash.text::TextField",
+    static: "flash.text::StaticText",
+};
+export class Scripting {
+    codegen;
+    rt;
+    /**
+     * The main SWF's application domain, a child of the runtime's root, which
+     * holds the player's own classes as Flash's system domain does: a domain
+     * made without a parent is the main one's sibling, and sees none of it.
+     */
+    mainDomain;
+    /** The SWFs' code, linked into their application domains, and whose code runs. */
+    code = new Code(this);
+    /** What SymbolClass bound, the fonts registered and the sounds' shared decodes. */
+    symbols = new Symbols(this);
+    /** What happens to display objects as they come and go: their events, and the orphans. */
+    lifecycle = new Lifecycle(this);
+    /** What Loaders, URLStreams and host callbacks asked for, till the frame it comes in. */
+    loads;
+    /** The clocks, getTimer's, and the timers that fire by them. */
+    timers;
+    /** The system's clipboard as scripts see it, and when they may read or write it. */
+    clipboard;
+    /** flash.system's workers: this VM's own, and those it started on the host's threads. */
+    workers;
+    screenCapabilities;
+    externalInterface;
+    /** How many calls the page has made into the SWF's ExternalInterface callbacks, which run outside a frame. */
+    hostCalls = 0;
+    /** Calls to an event's updateAfterEvent, and Stage.color set: a redraw asked for before the next frame. */
+    updates = 0;
+    /** The requests already prepared by a frame or an intermediate render. */
+    renderedUpdates = 0;
+    /** How many goto cycles run inside one another now. */
+    cycles = 0;
+    /**
+     * Whether the frame's own frame scripts are running: a clip a script
+     * makes with `new` then, around a button whose early scripts run, loses
+     * its first frame's script to them, as in Flash; one made before keeps it.
+     */
+    scriptPhase = false;
+    /** The frames whose scripts rounds marked run, for checkRoundLeftOut. */
+    framesMarked = 0;
+    /**
+     * Whether a round of frame scripts left out as having nothing to do is
+     * run anyway and must find nothing: the checked build's tests set it
+     * (SWF2ES_CHECKED), to prove the rounds' count (scriptWork) complete.
+     */
+    static checkRounds = false;
+    /** Whether they nested too deep this frame, which stops them all till the next. */
+    overflowed = false;
+    /**
+     * The clips runFrameScripts visits, a list for each depth it runs inside
+     * itself at, kept: the whole display list's every frame, often more than
+     * once.
+     */
+    scriptQueues = [];
+    scriptDepth = 0;
+    /**
+     * Where an error nothing caught goes as it happens, so that the frame
+     * goes on, as in Flash and Ruffle; null to have the frame throw them when
+     * it ends.
+     */
+    onUncaught;
+    /** Errors kept for the frame's end: all, without onUncaught, else those it threw. */
+    uncaught = [];
+    /** Children frames played on placed, to be made alive in the frame's construct phase. */
+    toConstruct = [];
+    /** The children of the gotos under way placed and not yet made alive, each goto's in order. */
+    placing = [];
+    /** flash.net.Socket's TCP: the host's, each connection kept for destroy to close; null for none. */
+    socket;
+    /** air.net.WebSocket's client: the global WebSocket's by default, null for none. */
+    webSocket;
+    audio;
+    /** Opens the pages navigateToURL asks for: the browser's window by default, null for none. */
+    navigate;
+    fileHost;
+    fileLifetime = new AbortController();
+    /** Where the host keeps the compiler's modules across page loads, or nothing does. */
+    moduleCache;
+    /** Compile uncached AVM2 method bodies on first factory use; experimental and off by default. */
+    lazyCompilation;
+    /** The connections open, Sockets' and WebSockets', each closing its transport: what destroy closes. */
+    connections = new Set();
+    /** Aborts the fetches of the `fetch` option still under way, once destroyed. */
+    stopped = new AbortController();
+    /** Whether destroy has been called: the player plays, loads and connects no more. */
+    destroyed = false;
+    localConnections;
+    /** Whether sendToURL sends, as an embedding's allowNetworking "internal" or "none" has it not. */
+    sendToUrl;
+    /** Takes what fscommand sends, or nothing does. */
+    fsCommand;
+    /** What plays every library's timeline and button sounds. */
+    timelineSounds = timelineSoundsOf(soundHostOf(this));
+    /** The host's fetch of a URL's bytes, for Loader.load, aborted when the load is closed or replaced; null where there is none. */
+    fetch = null;
+    /** Decodes the images of a SWF's JPEG tags as it is linked; the browser's by default, null for none. */
+    decodeImage;
+    /**
+     * How BitmapData.draw renders a display object, set by the host once it
+     * has a renderer (a RenderView); null where there is none.
+     */
+    drawer = null;
+    /** The main SWF's URL, as its LoaderInfo reports it. */
+    url = "file:///";
+    /** Security.sandboxType, as the host placed the SWF: "remote" by default, a web page's; "application" in AIR. */
+    sandboxType;
+    /** Whether the SWFs see AIR's API, as in AIR, rather than Flash Player's plugin's. */
+    air;
+    /** The AIR application the SWFs are, in AIR: its launch and window (NativeApplication). */
+    application;
+    /** In AIR, the host's file system, which flash.filesystem.File reads. */
+    fileSystem;
+    /** In AIR, where EncryptedLocalStore keeps its items: the host's, or one of its own in memory. */
+    encryptedStore;
+    /**
+     * Takes the policy files Security.loadPolicyFile names, resolved, for a
+     * host that judges requests by them; nothing does by default, as a
+     * browser's fetch knows only CORS.
+     */
+    loadPolicyFile;
+    /** Where every relative URL the SWFs ask for resolves, where the host gives one; else against the SWF's. */
+    base;
+    /** Where local SharedObjects are kept (flash/net/SharedObject.ts). */
+    storage;
+    /** Writes every SharedObject a script opened, set by their natives; destroy calls it. */
+    flushSharedObjects = null;
+    /** What Capabilities reports of the system (flash/system/Capabilities.ts). */
+    platform;
+    /** How many touches the host's screen takes at once: none where it has no touch screen. */
+    maxTouchPoints;
+    /**
+     * Multitouch.inputMode: "gesture" where the host takes touches, as Flash
+     * starts on a touch screen; "none" where it does not, which Flash keeps
+     * there whatever a script sets (measured in adl and Flash Player 32).
+     */
+    inputMode;
+    /** Multitouch.mapTouchToMouse, AIR's: whether the primary touch moves the mouse in touchPoint mode too. */
+    mapTouchToMouse = true;
+    /** Where its events keep what dispatch reads and writes (scripting/events.ts's eventFields). */
+    eventFields = null;
+    /** The display object the next DisplayObject allocation is for, while the player constructs a timeline child's class. */
+    pending = null;
+    /** The stage, once the player has made it, and the root it holds. */
+    stage = null;
+    /** stage.focus: the object keys go to, a TextField that edits with them; null for the stage. */
+    focus = null;
+    root = null;
+    library = null;
+    /** Whether a script asked the stage to render (Stage.invalidate). */
+    invalidated = false;
+    /** The objects whose scrollRect was set since the last frame was drawn, which it takes effect at. */
+    scrolled = new Set();
+    /**
+     * What finishes once this frame's EXIT_FRAME has gone, the frame's ends
+     * after it: an asynchronous ShaderJob's result and its COMPLETE, as adl
+     * delivers them, before the timers that fall between frames.
+     */
+    afterExitFrame = [];
+    /** The clip whose frame script is running, while one is: a goto it asks for waits for it to return. */
+    inFrameScript = null;
+    /** The display objects listening for each frame event, in the order they first listened; a broadcast reaches these. */
+    broadcasts = new Map();
+    /** The dispatchers listening for ACTIVATE or DEACTIVATE, held weakly. */
+    activation = new Map();
+    /** What flash.display.Stage reports and sets; the player copies the frame rate back each frame. */
+    stageWidth = 0;
+    stageHeight = 0;
+    /** Live Stage layout is part of the opt-in Context3D installation. */
+    liveStageLayout = false;
+    stageScaleMode = "showAll";
+    stageAlign = "";
+    /** A script's setting takes precedence over the embedding's defaults. */
+    stageScaleModeSet = false;
+    stageAlignSet = false;
+    /** A host updates placement synchronously before the setter returns. */
+    onStageLayout = null;
+    /** Stage.color's 0xRRGGBB, the SWF's background until a script sets it; null before the stage is made. */
+    stageColor = null;
+    /**
+     * What the host shows, in stage coordinates: margins past the stage's
+     * edges take the pointer too, at negative coordinates or past its size.
+     * A size of 0 is the stage's.
+     */
+    stageViewportX = 0;
+    stageViewportY = 0;
+    stageViewportWidth = 0;
+    stageViewportHeight = 0;
+    /** The latest pointer position in stage coordinates. */
+    mouseStageX = 0;
+    mouseStageY = 0;
+    frameRate = 24;
+    /** Frames played since the start. */
+    frames = 0;
+    quality = "HIGH";
+    showDefaultContextMenu = true;
+    /** Display objects made with an AS3 object, which Flash numbers for their default names. */
+    instances = 0;
+    statusClass = null;
+    /** The system cursor is visible until flash.ui.Mouse hides it. */
+    mouseVisible = true;
+    /** Mouse.cursor: "auto" for the player's choice, a flash.ui.MouseCursor name or a registered one. */
+    mouseCursor = "auto";
+    /** The cursors Mouse.registerCursor registered, by name, as CSS cursor values. */
+    cursors = new Map();
+    pointer = null;
+    /** Created only when a Loader holds AVM1 content. */
+    avm1Input = null;
+    /** Whether an HTML assignment drops its final line break, as some players do. */
+    trimTrailingHtmlBreak;
+    constructor(codegen, 
+    // The API version follows `air`, the one switch for it, below.
+    options = {}) {
+        this.codegen = codegen;
+        this.localConnections = options.localConnections ?? new LocalConnections();
+        this.screenCapabilities = {
+            screenResolutionX: options.screenCapabilities?.screenResolutionX ??
+                (typeof screen === "undefined" ? 0 : screen.width),
+            screenResolutionY: options.screenCapabilities?.screenResolutionY ??
+                (typeof screen === "undefined" ? 0 : screen.height),
+            pixelAspectRatio: options.screenCapabilities?.pixelAspectRatio ?? 1,
+            screenDPI: options.screenCapabilities?.screenDPI ?? 72,
+        };
+        this.trimTrailingHtmlBreak = options.trimTrailingHtmlBreak ?? false;
+        this.timers = new Timers(this, options);
+        this.decodeImage = options.decodeImage === undefined ? decodeInBrowser : options.decodeImage;
+        this.externalInterface = options.externalInterface ?? null;
+        const socket = options.socket;
+        this.socket = socket
+            ? {
+                connect: (host, port, events) => this.track(events, (tracked) => socket.connect(host, port, tracked)),
+            }
+            : null;
+        const webSocket = options.webSocket === undefined ? globalWebSocketHost() : options.webSocket;
+        this.webSocket = webSocket
+            ? {
+                connect: (url, protocols, events) => this.track(events, (tracked) => webSocket.connect(url, protocols, tracked)),
+            }
+            : null;
+        this.onUncaught = options.onUncaught ?? null;
+        this.audio = options.audio === undefined ? browserAudioHost() : options.audio;
+        this.fileHost = options.fileHost === undefined ? browserFileHost() : options.fileHost;
+        this.navigate = options.navigate === undefined ? browserNavigate() : options.navigate;
+        this.clipboard = new Clipboard(options.clipboard === undefined ? browserClipboard() : options.clipboard);
+        this.fsCommand = options.fsCommand ?? null;
+        this.workers = new Workers(this, options);
+        if (options.handedModules) {
+            const handover = new ModuleHandover(options.handedModules);
+            this.code.handover = handover;
+            this.codegen = handover.guard(codegen);
+        }
+        else if (options.workerHost && !options.workerParent) {
+            this.code.recorder = new ModuleRecorder();
+        }
+        this.sendToUrl = options.sendToUrl ?? true;
+        this.moduleCache = options.moduleCache ?? null;
+        this.lazyCompilation = options.lazyCompilation ?? false;
+        const fetch = options.fetch;
+        this.fetch = fetch
+            ? (request, signal) => fetch(request, AbortSignal.any([signal, this.stopped.signal]))
+            : null;
+        this.url = options.url ?? this.url;
+        this.air = options.air ?? false;
+        this.application = this.air ? (options.application ?? null) : null;
+        this.fileSystem = this.air ? (options.fileSystem ?? null) : null;
+        this.encryptedStore = this.air ? (options.encryptedStore ?? memoryStore()) : null;
+        this.sandboxType = options.sandboxType ?? (this.air ? "application" : "remote");
+        this.loadPolicyFile = options.loadPolicyFile ?? null;
+        this.base = options.base ?? null;
+        this.loads = new Loads(this, options);
+        this.storage = options.storage ?? defaultStorage();
+        this.platform = { ...platformCapabilities(), ...options.platform };
+        this.maxTouchPoints = Math.max(0, Math.floor(options.maxTouchPoints ?? hostTouchPoints()) || 0);
+        this.inputMode = this.maxTouchPoints > 0 ? "gesture" : "none";
+        // One version for the compiler and the runtime, so that what code sees by name it sees by a string too.
+        this.rt = new avm2.Runtime((rt) => ({ ...avm2.builtinNatives(rt), ...playerNatives(this) }), { ...avm2.builtinHooks(), ...playerHooks(this) }, { ...options, apiVersion: this.air ? AIR_API_VERSION : API_VERSION });
+        this.mainDomain = this.rt.childDomain(this.rt.root);
+        this.codegen.reset(this.rt.apiVersion);
+    }
+    /** Load the libraries the SWF's code links against (builtin, playerglobal), whose scripts run on first use. */
+    loadLibraries(abcs) {
+        // A background worker's thread loads them too.
+        this.workers.libraries.push(...abcs);
+        return this.code.loadLibraries(abcs);
+    }
+    /** Resolves once every load and host request so far is ready or failed (Loads.settled). */
+    settled() {
+        return this.loads.settled();
+    }
+    /** Whether the time since the host's last call was a load from bytes' (Loads.heldTime). */
+    heldTime() {
+        return this.loads.heldTime();
+    }
+    /** Whether the next frame waits for a load from bytes still compiling (Loads.holdsFrame). */
+    holdsFrame() {
+        return this.loads.holdsFrame();
+    }
+    /**
+     * Stop for good, as a page that takes its player away needs: the open
+     * SharedObjects are written, as Flash wrote them as a SWF went, the sounds
+     * stop and the audio host closes, the open Sockets and WebSockets close,
+     * and the fetches under way are aborted. Left open, a connection kept
+     * receiving and queueing for a player no one plays, and its listeners
+     * kept the player alive. What arrives after is never delivered, as no
+     * frame plays again (Player.destroy).
+     */
+    destroy() {
+        this.onStageLayout = null;
+        this.fileLifetime.abort();
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        this.loads.destroyAvm1();
+        this.workers.stopAll();
+        this.code.recorder?.drop();
+        this.localConnections.destroy(this);
+        this.flushSharedObjects?.();
+        stopAllSounds(this);
+        this.audio?.close?.();
+        for (const connection of [...this.connections]) {
+            connection.close();
+        }
+        this.stopped.abort();
+        avm2.clearPropertyCaches();
+    }
+    /**
+     * A host's connection kept among `connections` from its connect till
+     * either end closes it: `connect` is given `events` with a close that
+     * forgets it, and the transport it returns is wrapped likewise.
+     */
+    track(events, connect) {
+        let open = true;
+        const entry = { close: () => { } };
+        const forget = () => {
+            open = false;
+            this.connections.delete(entry);
+        };
+        const transport = connect({
+            ...events,
+            close: (...args) => {
+                forget();
+                events.close(...args);
+            },
+            // Refused or failed: a host need not close it after, nor destroy.
+            error: (...args) => {
+                forget();
+                events.error(...args);
+            },
+        });
+        entry.close = () => {
+            forget();
+            transport.close();
+        };
+        if (open) {
+            this.connections.add(entry);
+        }
+        return {
+            send: (data) => transport.send(data),
+            close: (code) => {
+                forget();
+                transport.close(code);
+            },
+        };
+    }
+    /** SymbolClass: bind the SWF's characters to their classes, in its library, and the library to this. */
+    bind(swf, library) {
+        this.symbols.bind(swf, library);
+        library.construct = (display, character) => this.construct(display, character, library);
+        library.uncaught = this.reportUncaught;
+        library.constructLater = (display, character) => {
+            // Its class is ready as the frame plays, its script run, as the frame's
+            // tags have it in Flash; only the instance waits (`delayed_symbolclass`).
+            const name = library.classes.get(character.id);
+            if (name) {
+                this.rt.classNamed(name, library.domain ?? null);
+            }
+            this.toConstruct.push({ display, character, library });
+        };
+        library.constructPlaced = (placed) => {
+            const goto = { placed, library };
+            this.placing.push(goto);
+            try {
+                this.constructGoto(goto);
+            }
+            finally {
+                this.placing.splice(this.placing.indexOf(goto), 1);
+            }
+        };
+        library.removing = (display, byTimeline) => this.lifecycle.removing(display, byTimeline);
+        library.sounds = this.timelineSounds;
+    }
+    /**
+     * The AS3 object of a timeline child the player just made: an instance
+     * of the class SymbolClass binds its character to, else of MovieClip or
+     * Shape, constructed with `display` as its other face. A clip's first
+     * frame is entered by Sprite's constructChildren on the way.
+     */
+    construct(display, character, library) {
+        // Flash exposes placed metadata only after the child's constructor returns.
+        const bytes = display.metaData;
+        display.metaData = null;
+        const metaData = bytes === null ? null : this.readMetaData(bytes);
+        // Its first frame's children are there before its constructor runs, made alive in its super().
+        if (display instanceof MovieClip) {
+            display.timelineChild = true;
+            display.placeFirstFrame();
+        }
+        const name = library.classes.get(character.id) ?? DEFAULT_CLASS[character.type];
+        const domain = library.domain ?? null;
+        // Flash gives the parent a property of the child's instance name, which
+        // a sealed class without it refuses: ReferenceError #1056, as Flash.
+        const named = (object) => {
+            const parent = display.parent?.object;
+            if (parent && display.timelineNamed) {
+                this.rt.setProperty(parent, avm2.qname(avm2.publicNs, display.name), object);
+            }
+        };
+        // A button's states are made before its constructor runs, as Flash has
+        // them; in a SWF after 9, one whose up state has a clip has a frame run
+        // then too: the frame scripts due on the display list, the orphans and
+        // what scripts made, the button's states up, over, down, hit among them
+        // (`button-frame-order`, Ruffle's frame_script_button_order). Its parent
+        // has its property by then, as scripts there find it (`simplebutton_symbolclass`).
+        if (display instanceof ButtonObject && character.type === "button") {
+            // Named before its states, as Flash names an object when it is made.
+            if (display.name === "") {
+                display.name = `instance${++this.instances}`;
+            }
+            this.makeButtonStates(display, character, library);
+            if ((library.version ?? 10) > 9 && hasClip(display.upState)) {
+                const cls = this.rt.classNamed(name, domain);
+                this.pending = display;
+                let object;
+                try {
+                    object = this.rt.allocate(cls);
+                }
+                finally {
+                    this.pending = null;
+                }
+                // A name the parent refuses is thrown once the button is constructed, as another child's is.
+                let refused = null;
+                if (object) {
+                    try {
+                        named(object);
+                    }
+                    catch (error) {
+                        refused = { error };
+                    }
+                }
+                display.firstScripts = true;
+                // What is placed and not yet alive is made first, as a frame's
+                // construct phase makes it: the frame's other children, and those
+                // of the gotos under way, which their parents' listeners look for.
+                this.constructPending();
+                for (const goto of [...this.placing]) {
+                    this.constructGoto(goto);
+                }
+                this.broadcast("frameConstructed");
+                this.runFrameScripts(this.stage ?? display, display);
+                this.broadcast("exitFrame");
+                if (object) {
+                    this.rt.constructSuper(cls, object);
+                    if (bytes !== null) {
+                        object.$metaData = metaData;
+                    }
+                    if (refused) {
+                        throw refused.error;
+                    }
+                    this.lifecycle.added(display);
+                    return;
+                }
+            }
+        }
+        const object = character.type === "bitmap" && display instanceof BitmapObject
+            ? this.constructBitmap(display, name, domain)
+            : this.constructAs(display, this.rt.classNamed(name, domain));
+        if (bytes !== null) {
+            object.$metaData = metaData;
+        }
+        named(object);
+        this.lifecycle.added(display);
+    }
+    readMetaData(raw) {
+        const bytes = new avm2.Bytes(this.rt, {});
+        bytes.write(raw);
+        bytes.position = 0;
+        return new avm2.Amf3Reader(this.rt, bytes).value();
+    }
+    /**
+     * A bitmap a timeline placed: a Bitmap, or the Bitmap subclass bound to
+     * it. A class extending BitmapData bound to it is its data's, made with
+     * (1, 1) where PlaceObject3 has HasImage; without it Flash constructs
+     * the class as a display object's and refuses it, TypeError 2022.
+     */
+    constructBitmap(display, name, domain) {
+        const cls = this.rt.classNamed(name, domain);
+        if (!extendsClass(cls, "flash.display::BitmapData")) {
+            return this.constructAs(display, cls);
+        }
+        if (!display.hasImage) {
+            this.rt.construct(cls);
+            throw this.rt.error("TypeError", 2022, `${name.replace(/^.*::/, "")}$`);
+        }
+        const data = this.rt.construct(cls, 1, 1);
+        return this.constructAs(display, this.rt.classNamed("flash.display::Bitmap"), data);
+    }
+    /** Construct `cls` for `display`: the allocation hook takes it as the instance's other face. */
+    constructAs(display, cls, ...args) {
+        this.pending = display;
+        try {
+            return this.rt.construct(cls, ...args);
+        }
+        finally {
+            this.pending = null;
+        }
+    }
+    /** A button's states from its records, each a Sprite of its characters where it has other than one, all constructed. */
+    makeButtonStates(button, character, library) {
+        const sprite = this.rt.classNamed("flash.display::Sprite");
+        buttonStates(button, character, library, (display, c) => this.construct(display, c, library), (holder) => this.constructAs(holder, sprite));
+    }
+    /** A flash.events.Event of `type`. */
+    event(type, bubbles = false) {
+        return this.rt.construct(this.rt.classNamed("flash.events::Event"), type, bubbles, false);
+    }
+    /** Flash Player's status event; AIR-only response properties stay at their defaults. */
+    httpStatus(status) {
+        let cls = this.statusClass;
+        if (!cls) {
+            cls = this.rt.classNamed("flash.events::HTTPStatusEvent");
+            this.statusClass = cls;
+        }
+        return this.rt.construct(cls, "httpStatus", false, false, status);
+    }
+    /** The display objects a broadcast of `type` reaches, for EventDispatcher to keep. */
+    broadcastTargets(type) {
+        let targets = this.broadcasts.get(type);
+        if (!targets) {
+            targets = new Set();
+            this.broadcasts.set(type, targets);
+        }
+        return targets;
+    }
+    /** Embedding defaults apply until ActionScript sets the corresponding property. */
+    setStageDefaults(scaleMode, align) {
+        if (!this.liveStageLayout) {
+            return;
+        }
+        if (!this.stageScaleModeSet) {
+            this.stageScaleMode = scaleMode;
+        }
+        if (!this.stageAlignSet) {
+            this.stageAlign = stageAlignment(align);
+        }
+    }
+    /** The host's visible size in noScale, the authored size in other modes. */
+    resizeStage(width, height) {
+        if (!this.liveStageLayout || (width === this.stageWidth && height === this.stageHeight)) {
+            return;
+        }
+        this.stageWidth = width;
+        this.stageHeight = height;
+        const stage = this.stage?.object;
+        if (this.stageScaleMode === "noScale" && stage && heard(stage, "resize")) {
+            dispatchTo(this, stage, this.event("resize"));
+        }
+    }
+    /** The dispatchers a broadcast of ACTIVATE or DEACTIVATE reaches, for EventDispatcher to keep. */
+    activationTargets(type) {
+        let targets = this.activation.get(type);
+        if (!targets) {
+            targets = new WeakTargets();
+            this.activation.set(type, targets);
+        }
+        return targets;
+    }
+    /**
+     * Dispatch ACTIVATE or DEACTIVATE to every EventDispatcher that listens
+     * for it and is still alive, display object or not, in the order they
+     * first listened, each its own event and its own target only. Flash
+     * documents them on EventDispatcher itself, unlike a frame's events.
+     */
+    broadcastActivation(type) {
+        for (const target of this.activation.get(type)?.live() ?? []) {
+            dispatchTo(this, target, this.event(type));
+        }
+    }
+    /**
+     * Dispatch an event of `type` to every display object that listens for
+     * it, in the order they first listened, each its own event and target.
+     * RENDER reaches only objects on stage; the other frame events reach
+     * off-stage objects too. None has a capture or bubble phase.
+     */
+    broadcast(type) {
+        const targets = this.broadcasts.get(type);
+        if (!targets) {
+            return;
+        }
+        for (const target of [...targets]) {
+            if (type === "render" && !this.lifecycle.onStage(target.$display)) {
+                continue;
+            }
+            dispatchTo(this, target, this.event(type));
+        }
+    }
+    /** An error that no script caught: to the host's hook now, or kept for the frame's end. */
+    reportUncaught = (error) => {
+        if (!this.onUncaught) {
+            this.uncaught.push(error);
+            return;
+        }
+        // A hook that throws stops nothing here either: its error is thrown
+        // when the frame ends, after the listeners and scripts that follow.
+        try {
+            this.onUncaught(error);
+        }
+        catch (hookError) {
+            this.uncaught.push(hookError);
+        }
+    };
+    /**
+     * Run the frame scripts of the clips that entered a frame with one since
+     * they last ran: the orphans' first, newest first, then those under
+     * `root`, each in tree order: a clip's own, again for the frame a goto of
+     * its own lands it on, then its children's, as Flash runs a parent's
+     * landing script before a child the jump made. A clip a script removes
+     * still runs its own, as Flash queues them first. Rounds until none is
+     * left, bounded, as a script that jumps on every run would never settle.
+     * `also`, a button being made, is visited after them all, for one none
+     * of them has; a clip visited twice still runs a frame's script once.
+     */
+    runFrameScripts(root, also = null) {
+        // A script's error is reported apart: its goto still happens, and the
+        // scripts after it still run, as in Flash (the unit test "a frame
+        // script's goto happens though the script throws after it").
+        // Overflowed, cycles stop their script loops; the frame's own pass goes on.
+        const stopped = () => this.overflowed && this.cycles > 0;
+        const depth = this.scriptDepth++;
+        const queue = this.scriptQueues[depth] ?? [];
+        this.scriptQueues[depth] = queue;
+        try {
+            for (let round = 0; round < 64 && !stopped(); round++) {
+                // Another round only finds a script if something it reads changed
+                // since this one walked: every clip this one visited is left on a
+                // frame whose script ran, or one held back as it will be again.
+                const changes = scriptWork.changes;
+                if (!this.frameScriptRound(queue, root, also, stopped)) {
+                    break;
+                }
+                if (scriptWork.changes === changes) {
+                    if (Scripting.checkRounds) {
+                        this.checkRoundLeftOut(queue, root, also, stopped);
+                    }
+                    break;
+                }
+            }
+        }
+        finally {
+            this.scriptDepth--;
+        }
+    }
+    /**
+     * The checked build's proof that a round left out had nothing to do: run
+     * it anyway, and throw if it ran a script, marked a frame's script run or
+     * changed anything else a round reads.
+     */
+    checkRoundLeftOut(queue, root, also, stopped) {
+        const changes = scriptWork.changes;
+        const marked = this.framesMarked;
+        if (this.frameScriptRound(queue, root, also, stopped) ||
+            this.framesMarked !== marked ||
+            scriptWork.changes !== changes) {
+            throw new Error("a round of frame scripts left out had work to do");
+        }
+    }
+    /** A round of runFrameScripts, its clips listed in `queue`: whether any script ran. */
+    frameScriptRound(queue, root, also, stopped) {
+        let ran = false;
+        const own = (o) => {
+            // A clip whose super() is making the children that run this has
+            // registered no script for its frame yet, unless it did so before
+            // super(), and keeps the frame's for later: always, placed by a
+            // timeline, made with `new`, only outside the frame's own scripts;
+            // one a frame script makes loses it (`button-frame-order`).
+            if (o.makingChildren &&
+                !o.frameScripts.has(o.currentFrame) &&
+                (o.timelineChild || !this.scriptPhase)) {
+                return;
+            }
+            for (let jumps = 0; jumps < 64 && o.scriptedFrame !== o.currentFrame && !stopped(); jumps++) {
+                o.scriptedFrame = o.currentFrame;
+                this.framesMarked++;
+                const script = o.frameScripts.get(o.currentFrame);
+                if (!script) {
+                    return;
+                }
+                ran = true;
+                // The clip whose script runs, the one before it again after: a
+                // goto's cycle runs scripts inside another's (`goto-cycle-nested`).
+                const outer = this.inFrameScript;
+                this.inFrameScript = o;
+                try {
+                    this.rt.call(script, o.object);
+                }
+                catch (error) {
+                    this.reportUncaught(error);
+                }
+                finally {
+                    this.inFrameScript = outer;
+                }
+                // The goto the script asked for, now that it has returned, or
+                // thrown; the frame it lands on has its script run next, in this
+                // same phase, or, from version 10, in the goto's own cycle.
+                if (o.queuedGoto !== null) {
+                    const frame = o.queuedGoto;
+                    o.queuedGoto = null;
+                    o.playing = o.queuedPlay;
+                    o.gotoFrame(frame);
+                    try {
+                        this.gotoCycle(o);
+                    }
+                    catch (error) {
+                        this.reportUncaught(error);
+                    }
+                }
+            }
+        };
+        let count = 0;
+        const visit = (o) => {
+            // The clips under a container from the list it keeps (walkList); a button is visited as it
+            // is, for its states' first order.
+            if (o instanceof Container && o.kind !== BUTTON) {
+                const items = walkList(o).items;
+                for (let i = 0; i < items.length; i++) {
+                    const item = items[i];
+                    if (item.kind === BUTTON) {
+                        visit(item);
+                    }
+                    else if (item.object) {
+                        queue[count++] = item;
+                    }
+                }
+                return;
+            }
+            if (o.kind === CLIP && o.object) {
+                queue[count++] = o;
+            }
+            // An index, not for-of, and no call for a leaf.
+            const children = scriptChildren(o);
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                if (child.kind !== OTHER || child.frameChildren.length !== 0) {
+                    visit(child);
+                }
+            }
+        };
+        for (const orphan of this.lifecycle.orphanRoots()) {
+            visit(orphan);
+        }
+        visit(root);
+        for (const display of this.lifecycle.fresh) {
+            visit(display);
+        }
+        if (also) {
+            visit(also);
+        }
+        // Each let go of as it runs, so that the kept list holds none past the round.
+        for (let i = 0; i < count; i++) {
+            const o = queue[i];
+            queue[i] = null;
+            own(o);
+        }
+        return ran;
+    }
+    /**
+     * What a goto that has happened runs in a SWF of version 10 or later, as
+     * Flash does, from a listener, a frame script once it returns, or anyone:
+     * FRAME_CONSTRUCTED, the frame scripts due on the whole display list, the
+     * goto's frame's among them, and EXIT_FRAME (`goto-cycle`). What the goto
+     * placed it made alive already. Version 9 runs none (`goto-children`).
+     */
+    gotoCycle(clip) {
+        if ((clip.library.version ?? 10) < 10 || !this.stage) {
+            return;
+        }
+        // Two scripts that send their clip to each other's frame nest cycles
+        // without end, in Flash till it gives up some 1400 deep; here a script's
+        // stack overflow, before the JavaScript stack's. Overflowed once, no
+        // cycle runs for the rest of the frame, and the cycles under way stop
+        // their script loops, so a script that catches the error cannot start
+        // it over; the frame's own scripts still run.
+        if (this.overflowed) {
+            return;
+        }
+        if (this.cycles >= MAX_GOTO_CYCLES) {
+            this.overflowed = true;
+            throw this.rt.error("Error", 1023);
+        }
+        // The cycle's errors are not the goto's: its scripts', listeners' and
+        // constructors' are reported apart, as Flash reports them, and the rest
+        // of the cycle and the goto's caller go on (the unit test "a goto's
+        // caller goes on when a script its cycle runs throws"). An overflow
+        // still reaches the goto that went too deep, which threw it above. A
+        // goto between frames, from a pointer, keyboard or ExternalInterface
+        // handler, has its cycle's errors reported by onUncaught at once, or
+        // else thrown when the next frame ends.
+        this.cycles++;
+        try {
+            // What frames placed and has yet to be made alive is made first.
+            this.constructPending();
+            this.broadcast("frameConstructed");
+            this.runFrameScripts(this.stage);
+            this.broadcast("exitFrame");
+        }
+        finally {
+            this.cycles--;
+        }
+    }
+    /**
+     * The construct phase: what the frames placed is made alive after
+     * ENTER_FRAME, before frameConstructed, or as a goto's cycle begins;
+     * until then a script finds it in numChildren but getChildAt gives null
+     * (`instantiation_on_enter_frame`). One taken off since is never made,
+     * and one at a time: a constructor that throws is reported, and the rest
+     * are still made.
+     */
+    constructPending() {
+        for (let next = this.toConstruct.shift(); next; next = this.toConstruct.shift()) {
+            if (!next.display.object && next.display.parent) {
+                try {
+                    this.construct(next.display, next.character, next.library);
+                }
+                catch (error) {
+                    this.reportUncaught(error);
+                }
+            }
+        }
+    }
+    /**
+     * The children a goto placed made alive, in order, each once: taken off
+     * the list as it is made, so that a button's early frame among them that
+     * makes the rest first leaves none to make again. A constructor that
+     * throws is reported, and the rest are still made, as in Flash.
+     */
+    constructGoto(goto) {
+        for (let next = goto.placed.shift(); next; next = goto.placed.shift()) {
+            if (next.display.object || !next.display.parent) {
+                continue;
+            }
+            try {
+                this.construct(next.display, next.character, goto.library);
+            }
+            catch (error) {
+                this.reportUncaught(error);
+            }
+        }
+    }
+    /**
+     * What follows the timelines' advance in a frame: the frame events and
+     * scripts, in Flash's order. The first frame, after construction, has no
+     * ENTER_FRAME: Flash goes to FRAME_CONSTRUCTED, the scripts and EXIT_FRAME.
+     * Without onUncaught, the errors no script caught are thrown once the
+     * frame has ended: one alone, or several as an AggregateError, after any
+     * that stopped the frame early.
+     */
+    frame(root, entered = true, render = true) {
+        const errors = [];
+        try {
+            this.playFrame(root, entered, render);
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        this.throwUncaught(errors);
+    }
+    /** The rendering opportunity after a batch of frames that skipped drawing. */
+    renderFrame(errors = []) {
+        try {
+            this.render();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        this.throwUncaught(errors);
+    }
+    throwUncaught(errors) {
+        // Those of a goto between frames, as a pointer handler's, come with this frame's.
+        errors.push(...this.uncaught.splice(0));
+        if (errors.length === 1) {
+            throw errors[0];
+        }
+        if (errors.length > 1) {
+            throw new AggregateError(errors, `${errors.length} errors that nothing caught`);
+        }
+    }
+    playFrame(root, entered, render) {
+        this.overflowed = false;
+        finishSounds(this);
+        if (entered) {
+            this.frames++;
+            this.broadcast("enterFrame");
+            this.timers.frameTimers();
+            this.loads.tickAvm1();
+        }
+        this.constructPending();
+        const ends = [...this.loads.frameEnds.splice(0), ...this.loads.completeLoads()];
+        this.broadcast("frameConstructed");
+        const outer = this.scriptPhase;
+        this.scriptPhase = true;
+        scriptWork.changes++;
+        try {
+            this.runFrameScripts(root);
+        }
+        finally {
+            this.scriptPhase = outer;
+            scriptWork.changes++;
+        }
+        this.lifecycle.afterScripts();
+        this.broadcast("exitFrame");
+        for (const end of [...ends, ...this.afterExitFrame.splice(0)]) {
+            try {
+                end();
+            }
+            catch (error) {
+                this.reportUncaught(error);
+            }
+        }
+        this.loads.deliverAvm1Loads();
+        // What is under a mouse that stands still, as the frame left the list.
+        this.pointer?.frameEnded();
+        if (render) {
+            this.render();
+        }
+    }
+    /** Prepare an input's requested redraw without advancing the timeline. */
+    renderPending() {
+        if (!this.destroyed && this.renderedUpdates !== this.updates) {
+            this.render();
+        }
+    }
+    /**
+     * The stage renders, at the end of a frame or between frames for an
+     * event's updateAfterEvent: RENDER if a script invalidated the stage,
+     * and the scroll rectangles set since take effect, as Flash's do.
+     */
+    render() {
+        // A request made by a RENDER listener belongs to a later rendering opportunity.
+        this.renderedUpdates = this.updates;
+        if (this.invalidated) {
+            this.invalidated = false;
+            this.broadcast("render");
+        }
+        for (const d of this.scrolled) {
+            d.scroll = d.scrollRect;
+            d.invalidate(TRANSFORM);
+        }
+        this.scrolled.clear();
+    }
+}
+/** How deep goto cycles may nest before a goto throws a stack overflow, Error #1023. */
+const MAX_GOTO_CYCLES = 256;
+/** Whether `cls` is the class named `name` or extends it. */
+function extendsClass(cls, name) {
+    for (let t = cls.$it; t; t = t.base) {
+        if (t.name === name) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Whether a button's state is a clip or holds one among its own children. */
+function hasClip(state) {
+    return (state instanceof MovieClip ||
+        (state instanceof Container && state.children.some((c) => c instanceof MovieClip)));
+}
+//# sourceMappingURL=scripting.js.map