@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,79 @@
+// flash.display.Loader: a container whose one child is the root of the SWF
+// it loaded. Its loads complete in a later frame (Loads.completeLoads),
+// but an AVM1 SWF's from bytes, at the end of the frame (Loads.requestLoad).
+import { avm2 } from "../../../../runtime/index.js";
+import { uncaughtErrorEvents } from "./LoaderInfo.js";
+/** A copy of a ByteArray's bytes, as they are now. */
+function copyOf(s, v) {
+    if (!v) {
+        throw s.rt.error("TypeError", 2007, "bytes");
+    }
+    const b = avm2.bytesOf(s.rt, v);
+    return new Uint8Array(b.buffer.subarray(0, b.length));
+}
+/**
+ * A LoaderContext's parameters, which take the place of the content's URL
+ * query in its loaderInfo.parameters: null when none were set. Flash
+ * refuses any value that is not a String, null and undefined among them,
+ * with Error #2196 at the call; an object that is not one, such as a
+ * String, has no names and gives none.
+ */
+function contextParameters(s, v) {
+    if (v === null || v === undefined) {
+        return null;
+    }
+    const parameters = new Map();
+    for (let i = s.rt.hasNext(v, 0); i !== 0; i = s.rt.hasNext(v, i)) {
+        const value = s.rt.nextValue(v, i);
+        if (typeof value !== "string") {
+            throw s.rt.error("flash.errors::IllegalOperationError", 2196, "LoaderContext.parameters");
+        }
+        parameters.set(String(s.rt.nextName(v, i)), value);
+    }
+    return parameters;
+}
+export function loaderNatives(s) {
+    const natives = {};
+    class LoaderNatives {
+        get content() {
+            return this.$content ?? null;
+        }
+        get contentLoaderInfo() {
+            if (!this.$loaderInfo) {
+                this.$loaderInfo = s.loads.loaderInfo(this);
+            }
+            return this.$loaderInfo;
+        }
+        // Both take the LoaderContext's fields after the source: checkPolicyFile,
+        // applicationDomain, securityDomain, requestedContentParent, parameters,
+        // the JPEG deblocking, allowCodeImport and imageDecodingPolicy. Only
+        // applicationDomain, for where the content's code loads, and parameters
+        // are read.
+        "flash.display:Loader::_loadBytes"(bytes, _checkPolicyFile, applicationDomain, _securityDomain, _requestedContentParent, parameters) {
+            const copy = copyOf(s, bytes);
+            const given = contextParameters(s, parameters);
+            s.loads.requestLoad(this, copy, s.loads.loadDomain(applicationDomain), given);
+        }
+        "flash.display:Loader::_load"(request, _checkPolicyFile, applicationDomain, _securityDomain, _requestedContentParent, parameters) {
+            const given = contextParameters(s, parameters);
+            s.loads.requestLoadUrl(this, request, s.loads.loadDomain(applicationDomain), given);
+        }
+        "flash.display:Loader::_unload"(stopAllMovieClips, _gc) {
+            s.loads.unload(this, !!stopAllMovieClips);
+        }
+        "flash.display:Loader::_getJPEGLoaderContextdeblockingfilter"(_context) {
+            return 0;
+        }
+        "flash.display:Loader::_close"() {
+            s.loads.closeLoad(this);
+        }
+        "flash.display:Loader::_getUncaughtErrorEvents"() {
+            return uncaughtErrorEvents(s, this);
+        }
+        "flash.display:Loader::_setUncaughtErrorEvents"(v) {
+            this.$uncaught = v;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::Loader", LoaderNatives);
+    return natives;
+}

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

@@ -0,0 +1,128 @@
+// flash.display.LoaderInfo: what is known of a SWF or image, the main one's or a
+// Loader's; Loads.loaderInfo makes one and keeps its facts on it.
+import { avm2 } from "../../../../runtime/index.js";
+/** A LoaderInfo's facts about its SWF, which Flash refuses to tell before the SWF is loaded: Error #2099. */
+function factsOf(s, info) {
+    if (info.$image) {
+        throw s.rt.error("Error", 2098);
+    }
+    if (!info.$swf) {
+        throw s.rt.error("Error", 2099);
+    }
+    return info.$swf;
+}
+/** The UncaughtErrorEvents of `owner`, a Loader or the main SWF's LoaderInfo, made when first asked for. */
+export function uncaughtErrorEvents(s, owner) {
+    if (!owner.$uncaught) {
+        owner.$uncaught = s.rt.construct(s.rt.classNamed("flash.events::UncaughtErrorEvents"));
+    }
+    return owner.$uncaught;
+}
+export function loaderInfoNatives(s) {
+    const natives = {};
+    class LoaderInfoNatives {
+        get loader() {
+            return this.$loader;
+        }
+        get content() {
+            return this.$content;
+        }
+        get url() {
+            return this.$url;
+        }
+        get loaderURL() {
+            return this.$loaderURL;
+        }
+        get isURLInaccessible() {
+            return false;
+        }
+        get bytesLoaded() {
+            return this.$loaded;
+        }
+        get bytesTotal() {
+            return this.$total;
+        }
+        // The domain its load chose (Loads.loadDomain), or the main SWF's.
+        get applicationDomain() {
+            return this.$domain || this.$swf
+                ? s.code.applicationDomainOf(this.$domain ?? s.mainDomain)
+                : null;
+        }
+        get swfVersion() {
+            return factsOf(s, this).version;
+        }
+        get actionScriptVersion() {
+            return factsOf(s, this).as3 ? 3 : 2;
+        }
+        get frameRate() {
+            return factsOf(s, this).frameRate;
+        }
+        get width() {
+            return (this.$image ?? factsOf(s, this)).width;
+        }
+        get height() {
+            return (this.$image ?? factsOf(s, this)).height;
+        }
+        get contentType() {
+            return this.$image?.contentType ?? (this.$swf ? "application/x-shockwave-flash" : null);
+        }
+        get sharedEvents() {
+            if (!this.$shared) {
+                this.$shared = s.rt.construct(s.rt.classNamed("flash.events::EventDispatcher"));
+            }
+            return this.$shared;
+        }
+        get sameDomain() {
+            return true;
+        }
+        get childAllowsParent() {
+            return true;
+        }
+        get parentAllowsChild() {
+            return true;
+        }
+        get parentSandboxBridge() {
+            return null;
+        }
+        set parentSandboxBridge(_v) {
+            // One sandbox.
+        }
+        get childSandboxBridge() {
+            return null;
+        }
+        set childSandboxBridge(_v) {
+            // One sandbox.
+        }
+        /** The SWF's bytes as a ByteArray, when they are known. */
+        get bytes() {
+            if (!this.$bytes) {
+                return null;
+            }
+            const array = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray"));
+            const b = avm2.bytesOf(s.rt, array);
+            b.write(this.$bytes);
+            b.position = 0;
+            return array;
+        }
+        // A new object at each ask, as Flash's: a script that changes one changes no other.
+        "flash.display:LoaderInfo::_getArgs"() {
+            const args = s.rt.objectTraits.instance();
+            for (const [name, value] of this.$params) {
+                s.rt.setProperty(args, s.rt.publicName(name), value);
+            }
+            return args;
+        }
+        /** The Loader's and its LoaderInfo's uncaughtErrorEvents are one dispatcher. */
+        "flash.display:LoaderInfo::_getUncaughtErrorEvents"() {
+            return uncaughtErrorEvents(s, this.$loader ?? this);
+        }
+        "flash.display:LoaderInfo::_setUncaughtErrorEvents"(v) {
+            (this.$loader ?? this).$uncaught = v;
+        }
+        static getLoaderInfoByDefinition(_object) {
+            return null;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::LoaderInfo", LoaderInfoNatives);
+    return natives;
+}

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

@@ -0,0 +1,194 @@
+// flash.display.MovieClip and FrameLabel: the timeline from a script, its
+// scenes and labels. Frame scripts registered with addFrameScript run when
+// their frame is entered, in the frame's script phase; a goto takes the
+// next phase there.
+import { avm2 } from "../../../../runtime/index.js";
+export function movieClipNatives(s) {
+    const natives = {};
+    // s.rt at call time: the natives are made before the runtime that holds them is.
+    /** The scene the clip's frame is in, by its index in the timeline's scenes. */
+    const sceneIndex = (clip) => {
+        const scenes = clip.timeline.scenes;
+        const frame = Math.max(1, clip.currentFrame);
+        let i = 0;
+        while (i + 1 < scenes.length && scenes[i + 1].frame <= frame) {
+            i++;
+        }
+        return i;
+    };
+    /** A scene's first frame, and the first after it. */
+    const sceneFrames = (clip, i) => {
+        const scenes = clip.timeline.scenes;
+        return [scenes[i].frame, i + 1 < scenes.length ? scenes[i + 1].frame : clip.totalFrames + 1];
+    };
+    /** Labels in a scene; the last scene's run on past the last frame, as a label after it may. */
+    const inScene = (clip, i, labels) => {
+        const [first, after] = sceneFrames(clip, i);
+        const last = i + 1 === clip.timeline.scenes.length;
+        return labels.filter((l) => l.frame >= first && (last || l.frame < after));
+    };
+    /** A flash.display.Scene, made anew on each read as Flash does: its labels' frames count from its first. */
+    const sceneObject = (clip, i) => {
+        const [first, after] = sceneFrames(clip, i);
+        const labelClass = s.rt.classNamed("flash.display::FrameLabel");
+        const labels = inScene(clip, i, clip.timeline.labels).map((l) => s.rt.construct(labelClass, l.name, l.frame - first + 1));
+        return s.rt.construct(s.rt.classNamed("flash.display::Scene"), clip.timeline.scenes[i].name, s.rt.array(labels), after - first);
+    };
+    /**
+     * The frame a goto names, on the whole timeline: a number counts from the
+     * scene's first frame, the named scene's or the clip's own, and a label is
+     * looked for in that scene alone. A scene of that name must exist (2108),
+     * and in a named scene, or one of several, as only scene data makes, a
+     * label in it (2109); in a timeline's one unnamed scene an unknown label
+     * is a number, 0, which takes Flash to frame 1.
+     */
+    const frameOf = (clip, frame, scene) => {
+        const scenes = clip.timeline.scenes;
+        let i = sceneIndex(clip);
+        if (scene !== null && scene !== undefined) {
+            const name = s.rt.toString(scene);
+            i = scenes.findIndex((x) => x.name === name);
+            if (i < 0) {
+                throw s.rt.error("ArgumentError", 2108, name);
+            }
+        }
+        const first = sceneFrames(clip, i)[0];
+        if (typeof frame === "string" && !/^\d+$/.test(frame)) {
+            const label = inScene(clip, i, clip.timeline.gotoLabels).find((l) => l.name === frame);
+            if (label) {
+                return label.frame;
+            }
+            if (scenes[i].name !== "" || scenes.length > 1) {
+                throw s.rt.error("ArgumentError", 2109, frame, scenes[i].name);
+            }
+        }
+        return first + s.rt.toInt(frame) - 1;
+    };
+    /**
+     * Jump to `frame`, playing or stopped: at once, or when the frame script
+     * asking returns, as Flash defers a goto from one. The clip plays or stops
+     * as the goto happens, before the landing frame's script runs, so a
+     * stop() or play() there has the last word, and one the asking script
+     * calls after a deferred goto has none (`goto-stops`).
+     */
+    const goto = (clip, frame, play) => {
+        if ((clip.library.version ?? 10) <= 9) {
+            clip.skipsAfter = s.frames;
+        }
+        if (s.inFrameScript === clip) {
+            clip.queuedGoto = frame;
+            clip.queuedPlay = play;
+        }
+        else {
+            clip.playing = play;
+            clip.gotoFrame(frame);
+            s.gotoCycle(clip);
+        }
+    };
+    class MovieClipNatives {
+        addFrameScript(...args) {
+            const clip = this.$display;
+            for (let i = 0; i + 1 < args.length; i += 2) {
+                clip.setFrameScript(s.rt.toInt(args[i]) + 1, args[i + 1]);
+            }
+        }
+        /** The frame in its scene, 1 the scene's first. */
+        get currentFrame() {
+            const clip = this.$display;
+            return Math.max(1, clip.currentFrame) - sceneFrames(clip, sceneIndex(clip))[0] + 1;
+        }
+        get totalFrames() {
+            return this.$display.totalFrames;
+        }
+        get framesLoaded() {
+            return this.$display.totalFrames;
+        }
+        /** The nearest label at or before the frame, whatever scene it is in. */
+        get currentLabel() {
+            const clip = this.$display;
+            let label = null;
+            for (const l of clip.timeline.labels) {
+                if (l.frame > clip.currentFrame) {
+                    break;
+                }
+                label = l.name;
+            }
+            return label;
+        }
+        /** A FrameLabel tag on this very frame, which Flash reads even where the scene data has none. */
+        get currentFrameLabel() {
+            return this.$display.timeline.frameLabels.get(this.$display.currentFrame) ?? null;
+        }
+        get scenes() {
+            const clip = this.$display;
+            return s.rt.array(clip.timeline.scenes.map((_, i) => sceneObject(clip, i)));
+        }
+        get currentScene() {
+            const clip = this.$display;
+            return sceneObject(clip, sceneIndex(clip));
+        }
+        /** The scene before's first frame, playing; in the first scene, its own. */
+        prevScene() {
+            const clip = this.$display;
+            goto(clip, sceneFrames(clip, Math.max(0, sceneIndex(clip) - 1))[0], true);
+        }
+        /** The next scene's first frame, playing; in the last scene, its own. */
+        nextScene() {
+            const clip = this.$display;
+            const i = sceneIndex(clip);
+            goto(clip, sceneFrames(clip, Math.min(clip.timeline.scenes.length - 1, i + 1))[0], true);
+        }
+        get isPlaying() {
+            return this.$display.playing;
+        }
+        play() {
+            this.$display.playing = true;
+        }
+        stop() {
+            this.$display.playing = false;
+        }
+        nextFrame() {
+            const clip = this.$display;
+            goto(clip, clip.currentFrame + 1, false);
+        }
+        prevFrame() {
+            const clip = this.$display;
+            goto(clip, clip.currentFrame - 1, false);
+        }
+        gotoAndPlay(frame, scene = null) {
+            const clip = this.$display;
+            goto(clip, frameOf(clip, frame, scene), true);
+        }
+        gotoAndStop(frame, scene = null) {
+            const clip = this.$display;
+            goto(clip, frameOf(clip, frame, scene), false);
+        }
+        get enabled() {
+            return this.$enabled ?? true;
+        }
+        set enabled(v) {
+            this.$enabled = !!v;
+        }
+        get trackAsMenu() {
+            return false;
+        }
+        set trackAsMenu(_v) {
+            // No menus.
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::MovieClip", MovieClipNatives);
+    class FrameLabelNatives {
+        "flash.display:FrameLabel::ctor"(name, frame) {
+            this.$name = s.rt.toString(name);
+            this.$frame = s.rt.toInt(frame);
+        }
+        get name() {
+            return this.$name;
+        }
+        get frame() {
+            return this.$frame;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::FrameLabel", FrameLabelNatives);
+    return natives;
+}

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

@@ -0,0 +1,245 @@
+// flash.display.NativeWindow: an AIR application's window, as
+// Stage.nativeWindow gives it, over the host's AirWindow (hosts.ts). Its
+// bounds are the window's on the screen, its frame included, as AIR's are;
+// the stage keeps the size its scale mode gives it. A window a script opens
+// itself is not supported. Where the host does not say: adl's values
+// (AIR 51.3), but for the system's sizes, a browser's window having no
+// least size of its own.
+import { avm2 } from "../../../../runtime/index.js";
+/** The window each player's stage is in, made as a script first asks for it. */
+const windows = new WeakMap();
+/** The application's window, Stage.nativeWindow's, or null where the host has none. */
+export function nativeWindowOf(s) {
+    if (!s.application?.window) {
+        return null;
+    }
+    let window = windows.get(s);
+    if (!window) {
+        window = s.rt.construct(s.rt.classNamed("flash.display::NativeWindow"), null);
+        windows.set(s, window);
+    }
+    return window;
+}
+/** AIR's largest window, either way. */
+const MAX_SIDE = 107374182;
+export function nativeWindowNatives(s) {
+    const natives = {};
+    const prop = (o, name) => Number(s.rt.getProperty(o, avm2.qname(avm2.publicNs, name)));
+    const point = (x, y) => s.rt.construct(s.rt.classNamed("flash.geom::Point"), x, y);
+    let closed = false;
+    let alwaysInFront = false;
+    let minSize = null;
+    let maxSize = null;
+    /** The host's window behind `o`, which only the application's window has. */
+    const hostOf = (o) => {
+        const window = s.application?.window;
+        if (!window || o !== windows.get(s)) {
+            throw s.rt.unsupported("a NativeWindow a script opens");
+        }
+        return window;
+    };
+    const bounds = (o) => hostOf(o).bounds();
+    const move = (o, change) => {
+        const window = hostOf(o);
+        window.setBounds?.({ ...window.bounds(), ...change });
+    };
+    class NativeWindowNatives {
+        static get isSupported() {
+            return s.air;
+        }
+        static get supportsMenu() {
+            return false;
+        }
+        static get supportsNotification() {
+            return false;
+        }
+        static get supportsTransparency() {
+            return false;
+        }
+        static get systemMinSize() {
+            return point(1, 1);
+        }
+        static get systemMaxSize() {
+            return point(MAX_SIDE, MAX_SIDE);
+        }
+        get stage() {
+            hostOf(this);
+            return s.stage?.object ?? null;
+        }
+        get title() {
+            return hostOf(this).title();
+        }
+        set title(v) {
+            hostOf(this).setTitle?.(String(v));
+        }
+        get bounds() {
+            const b = bounds(this);
+            return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), b.x, b.y, b.width, b.height);
+        }
+        set bounds(v) {
+            if (v === null) {
+                throw s.rt.error("TypeError", 2007, "bounds");
+            }
+            move(this, {
+                x: prop(v, "x"),
+                y: prop(v, "y"),
+                width: prop(v, "width"),
+                height: prop(v, "height"),
+            });
+        }
+        get x() {
+            return bounds(this).x;
+        }
+        set x(v) {
+            move(this, { x: Number(v) });
+        }
+        get y() {
+            return bounds(this).y;
+        }
+        set y(v) {
+            move(this, { y: Number(v) });
+        }
+        get width() {
+            return bounds(this).width;
+        }
+        set width(v) {
+            move(this, { width: Number(v) });
+        }
+        get height() {
+            return bounds(this).height;
+        }
+        set height(v) {
+            move(this, { height: Number(v) });
+        }
+        get displayState() {
+            return hostOf(this).displayState();
+        }
+        minimize() {
+            hostOf(this).minimize?.();
+        }
+        maximize() {
+            hostOf(this).maximize?.();
+        }
+        restore() {
+            hostOf(this).restore?.();
+        }
+        close() {
+            const window = hostOf(this);
+            if (!closed) {
+                closed = true;
+                window.close?.();
+            }
+        }
+        get closed() {
+            hostOf(this);
+            return closed;
+        }
+        get visible() {
+            return hostOf(this).visible();
+        }
+        set visible(v) {
+            hostOf(this).setVisible?.(!!v);
+        }
+        get active() {
+            return hostOf(this).active();
+        }
+        activate() {
+            hostOf(this).activate?.();
+        }
+        get systemChrome() {
+            hostOf(this);
+            return "standard";
+        }
+        get transparent() {
+            hostOf(this);
+            return false;
+        }
+        get type() {
+            hostOf(this);
+            return "normal";
+        }
+        get minimizable() {
+            hostOf(this);
+            return true;
+        }
+        get maximizable() {
+            hostOf(this);
+            return true;
+        }
+        get resizable() {
+            hostOf(this);
+            return true;
+        }
+        // Moving and resizing by the mouse are the window manager's.
+        startMove() {
+            hostOf(this);
+            return false;
+        }
+        startResize() {
+            hostOf(this);
+            return false;
+        }
+        get minSize() {
+            hostOf(this);
+            minSize ??= point(1, 1);
+            return minSize;
+        }
+        set minSize(v) {
+            hostOf(this);
+            minSize = v;
+        }
+        get maxSize() {
+            hostOf(this);
+            maxSize ??= point(MAX_SIDE, MAX_SIDE);
+            return maxSize;
+        }
+        set maxSize(v) {
+            hostOf(this);
+            maxSize = v;
+        }
+        get alwaysInFront() {
+            hostOf(this);
+            return alwaysInFront;
+        }
+        set alwaysInFront(v) {
+            hostOf(this);
+            alwaysInFront = !!v;
+        }
+        // One window: nothing to order it among.
+        orderToFront() {
+            hostOf(this);
+            return false;
+        }
+        orderToBack() {
+            hostOf(this);
+            return false;
+        }
+        orderInFrontOf(_window) {
+            hostOf(this);
+            return false;
+        }
+        orderInBackOf(_window) {
+            hostOf(this);
+            return false;
+        }
+        /** A point of the stage's on the screen: past the window's corner and its frame's border and title bar. */
+        globalToScreen(p) {
+            const window = hostOf(this);
+            const b = window.bounds();
+            const offset = window.stageOffset();
+            return point(b.x + offset.x + prop(p, "x"), b.y + offset.y + prop(p, "y"));
+        }
+        get menu() {
+            hostOf(this);
+            return null;
+        }
+        set menu(_v) {
+            hostOf(this);
+        }
+        notifyUser(_type) {
+            hostOf(this);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::NativeWindow", NativeWindowNatives);
+    return natives;
+}

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

@@ -0,0 +1,26 @@
+// flash.display.Shader: its ShaderData, which byteCode's AS3 setter makes,
+// and the precision hint, "full" or "fast": the CPU runs every kernel in full.
+import { avm2 } from "../../../../runtime/index.js";
+export function shaderNatives(s) {
+    const natives = {};
+    class ShaderNatives {
+        get data() {
+            return this.$data ?? null;
+        }
+        set data(v) {
+            this.$data = v ?? null;
+        }
+        get precisionHint() {
+            return this.$precision ?? "full";
+        }
+        set precisionHint(v) {
+            const hint = v === null || v === undefined ? null : s.rt.toString(v);
+            if (hint !== "full" && hint !== "fast") {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            this.$precision = hint;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::Shader", ShaderNatives);
+    return natives;
+}