@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,90 @@
+// MovieClipLoader, AS2's loadMovie with events, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) core/src/avm1/globals/movie_clip_loader.rs
+// has it: MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle
+// contributors. A loader is a broadcaster, itself its first listener; the
+// player tells its listeners of each load (loads.ts, "loadClip"):
+// onLoadStart, onLoadProgress, onLoadComplete or onLoadError as the load
+// arrives, and onLoadInit once the loaded movie's first frame's actions
+// have run.
+import { avm1 } from "../../../runtime/index.js";
+const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE;
+/** A level's number as Rust's `as i32` casts one: cut toward zero, saturated, NaN 0. */
+function levelNumber(n) {
+    return Number.isNaN(n) ? 0 : Math.trunc(Math.max(-0x80000000, Math.min(0x7fffffff, n)));
+}
+/** `_global.MovieClipLoader`. */
+export function movieClipLoaderClass(host, version) {
+    const realm = host.realm;
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    avm1.initializeBroadcaster(proto, realm, version);
+    const constr = realm.classOf(proto, (self, _, v) => {
+        self.define("_listeners", realm.newArray([self], v), avm1.DONT_ENUM);
+        return self;
+    }, () => undefined);
+    /**
+     * The display object a target names: a path from the code's target, a
+     * level by number (made for a load), a display object's AVM1 object;
+     * null for anything else.
+     */
+    const targetOf = (value, v, load) => {
+        if (typeof value === "number") {
+            const n = levelNumber(value);
+            return load ? host.levelToLoad(n) : host.level(n);
+        }
+        if (typeof value === "string" || value instanceof avm1.Avm1Object) {
+            return host.resolve(value, v);
+        }
+        return null;
+    };
+    // The URL must be a string; true where the target names a clip.
+    proto.define("loadClip", realm.method((self, args, v) => {
+        if (args.length < 2) {
+            return undefined;
+        }
+        const url = args[0];
+        if (typeof url !== "string") {
+            return false;
+        }
+        const target = targetOf(args[1], v, true);
+        if (target === null) {
+            return false;
+        }
+        return host.loadClip(self, target, url);
+    }), FIXED);
+    // Each of the target's SWF's size, as it came; an object without either where the target
+    // names nothing, undefined for no target or an object that is no display object's.
+    proto.define("getProgress", realm.method((_, args, v) => {
+        if (args.length === 0) {
+            return undefined;
+        }
+        const value = args[0];
+        if (value instanceof avm1.Avm1Object && value.display === null) {
+            return undefined;
+        }
+        if (typeof value !== "string" &&
+            typeof value !== "number" &&
+            !(value instanceof avm1.Avm1Object)) {
+            return undefined;
+        }
+        const result = new avm1.Avm1Object(null);
+        const target = targetOf(value, v, false);
+        if (target !== null) {
+            const size = host.sizeOf(target);
+            result.define("bytesLoaded", size, 0);
+            result.define("bytesTotal", size, 0);
+        }
+        return result;
+    }), FIXED);
+    proto.define("unloadClip", realm.method((_, args, v) => {
+        if (args.length === 0) {
+            return undefined;
+        }
+        const target = targetOf(args[0], v, false);
+        if (target === null) {
+            return false;
+        }
+        host.unloadMovie(target);
+        return true;
+    }), FIXED);
+    return constr;
+}

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

@@ -0,0 +1,261 @@
+// NetConnection's AS2 face, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/netconnection.rs and core/src/net_connection.rs
+// have it: MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle
+// contributors. connect(null) is the local connection, connected at once;
+// an http or https URL is Flash Remoting: each call is queued, and the
+// frame's calls go together as one AMF0 packet POSTed to the URL, the
+// connection's headers with them, each call's answer, /n/onResult or
+// /n/onStatus, going to its responder. Any other URL connects nothing.
+import { avm1 } from "../../../runtime/index.js";
+import { Reader, Writer } from "../amf.js";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/** Bytes, joined once. */
+function join(chunks) {
+    const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+    let at = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, at);
+        at += chunk.length;
+    }
+    return out;
+}
+/**
+ * A call's arguments as AMF0, a strict array of them, written with one
+ * table of references, the array itself the first (adl: an argument met
+ * twice, or an array or object holding itself, is a reference, the first
+ * argument's object 1); or with `first` 0, a header's value, itself the
+ * first (adl).
+ */
+export function remotingValue(v, typedName, version, xml, first = 0) {
+    const w = new Writer(typedName, version, null, { xmlText: xml, first });
+    if (first === 1 && Array.isArray(v)) {
+        w.arguments(v);
+    }
+    else {
+        w.value(v);
+    }
+    return w.finish();
+}
+/** A u16-long UTF-8 string, no marker. */
+function utf(text) {
+    const b = encoder.encode(text).subarray(0, 0xffff);
+    return join([Uint8Array.of(b.length >> 8, b.length & 0xff), b]);
+}
+const u16 = (n) => Uint8Array.of((n >> 8) & 0xff, n & 0xff);
+const u32 = (n) => Uint8Array.of((n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff);
+/** An AMF0 remoting packet: version 0, the headers, the calls, each answered at /1, /2... */
+function packet(headers, calls) {
+    const out = [u16(0), u16(headers.length)];
+    for (const h of headers) {
+        out.push(utf(h.name), Uint8Array.of(h.mustUnderstand ? 1 : 0), u32(h.value.length), h.value);
+    }
+    out.push(u16(calls.length));
+    calls.forEach((call, i) => {
+        out.push(utf(call.method), utf(`/${i + 1}`), u32(call.args.length), call.args);
+    });
+    return join(out);
+}
+/** A packet's messages' targets and values read, null where it is no packet. */
+function messagesOf(bytes, realm, version) {
+    try {
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        let at = 2;
+        const text = () => {
+            const n = view.getUint16(at);
+            at += 2;
+            if (at + n > bytes.length) {
+                throw new RangeError("past the end");
+            }
+            const s = decoder.decode(bytes.subarray(at, at + n));
+            at += n;
+            return s;
+        };
+        const value = () => {
+            const reader = new Reader(bytes.subarray(at), realm, version);
+            const v = reader.value();
+            at += reader.at;
+            return v;
+        };
+        const headers = view.getUint16(at);
+        at += 2;
+        for (let i = 0; i < headers; i++) {
+            text();
+            at += 5;
+            value();
+        }
+        const count = view.getUint16(at);
+        at += 2;
+        const messages = [];
+        for (let i = 0; i < count; i++) {
+            const target = text();
+            text();
+            at += 4;
+            messages.push([target, value()]);
+        }
+        return messages;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The connections open, held by their objects weakly, and those with calls
+ * waiting, sent a packet each at the end of a frame and let go.
+ */
+export class Remoting {
+    host;
+    connections = new WeakMap();
+    waiting = new Set();
+    constructor(host) {
+        this.host = host;
+    }
+    /** `c`'s call queued for the frame's end. */
+    queue(c, call) {
+        c.queue.push(call);
+        this.waiting.add(c);
+    }
+    /** A frame's end: each connection's calls sent as one packet. */
+    flush() {
+        const waiting = this.waiting;
+        this.waiting = new Set();
+        for (const c of waiting) {
+            if (c.url === null || c.queue.length === 0 || this.connections.get(c.self) !== c) {
+                continue;
+            }
+            const calls = c.queue;
+            c.queue = [];
+            const body = packet(c.headers, calls);
+            this.host.net.fetch({
+                url: c.url,
+                method: "POST",
+                headers: [["Content-Type", "application/x-amf"]],
+                body,
+            }, (result) => this.answered(c, calls, result.bytes));
+        }
+    }
+    answered(c, calls, bytes) {
+        const host = this.host;
+        if (bytes === null) {
+            // A failed request: the connection's onStatus with nothing, if it is still open.
+            if (this.connections.get(c.self) === c) {
+                host.callback(c.self, "onStatus", []);
+            }
+            return;
+        }
+        // Flash ignores an answer that is no packet.
+        for (const [target, value] of messagesOf(bytes, host.realm, host.version) ?? []) {
+            const m = /^\/(\d+)\/(onResult|onStatus)$/.exec(target);
+            const responder = m ? calls[Number(m[1]) - 1]?.responder : null;
+            if (m && responder) {
+                host.callback(responder, m[2], [value]);
+            }
+        }
+    }
+    connection(self) {
+        return this.connections.get(self);
+    }
+    /** `self` connected to `url`, local for null; the connection it had closed first. */
+    open(self, url) {
+        if (this.connections.has(self)) {
+            this.close(self, false);
+        }
+        this.connections.set(self, { self, url, headers: [], queue: [] });
+        if (url === null) {
+            this.status(self, "NetConnection.Connect.Success");
+        }
+    }
+    /** `self`'s connection closed: Closed, and where a script closed remoting, onStatus with nothing. */
+    close(self, explicit) {
+        const c = this.connections.get(self);
+        if (c === undefined) {
+            return;
+        }
+        this.connections.delete(self);
+        this.waiting.delete(c);
+        this.status(self, "NetConnection.Connect.Closed");
+        if (explicit && c.url !== null) {
+            this.host.callback(self, "onStatus", []);
+        }
+    }
+    status(self, code) {
+        const { realm, version } = this.host;
+        const event = realm.newObject(version);
+        avm1.set(event, "code", code, version);
+        avm1.set(event, "level", "status", version);
+        this.host.callback(self, "onStatus", [event]);
+    }
+}
+/** `NetConnection`. */
+export function netConnectionClass(host, remoting) {
+    const realm = host.realm;
+    const made = new WeakSet();
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self) => {
+        made.add(self);
+        return self;
+    }, () => undefined);
+    const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE;
+    const typedName = (c) => host.registeredName(c);
+    const xml = (o) => host.xmlText(o);
+    // A subclass's `super.call(...)` is the connection's call: super's `this` is it.
+    const connectionOf = (self) => {
+        const o = self instanceof avm1.Avm1Super ? self.self : self;
+        return made.has(o) ? o : null;
+    };
+    const getter = (name, get) => {
+        const p = proto.add(name, undefined, 0);
+        p.get = realm.method((self) => {
+            const o = connectionOf(self);
+            return o === null ? undefined : get(remoting.connection(o));
+        });
+    };
+    const method = (name, f) => proto.define(name, realm.method((self, args, v) => {
+        const o = connectionOf(self);
+        if (o !== null) {
+            f(o, args, v);
+        }
+        return undefined;
+    }), FIXED);
+    getter("protocol", (c) => (c !== undefined && c.url === null ? "rtmp" : undefined));
+    method("connect", (self, args, v) => {
+        const url = args[0];
+        if (url === undefined || url === null) {
+            remoting.open(self, null);
+            return;
+        }
+        const text = avm1.stringOf(url, v);
+        if (/^https?:\/\//i.test(text)) {
+            remoting.open(self, text);
+        }
+    });
+    method("close", (self) => remoting.close(self, true));
+    method("call", (self, args, v) => {
+        const method = avm1.stringOf(args[0], v);
+        const values = args.slice(2);
+        const c = remoting.connection(self);
+        if (c === undefined) {
+            return;
+        }
+        // The local connection sends nothing, so writes nothing.
+        if (c.url === null) {
+            return;
+        }
+        const responder = args.length > 1 ? (args[1] instanceof avm1.Avm1Object ? args[1] : realm.newObject(v)) : null;
+        remoting.queue(c, { method, args: remotingValue(values, typedName, v, xml, 1), responder });
+    });
+    method("addHeader", (self, args, v) => {
+        const name = avm1.stringOf(args[0], v);
+        const mustUnderstand = args.length > 1 ? avm1.toBoolean(args[1], v) : true;
+        const value = remotingValue(args.length > 2 ? args[2] : null, typedName, v, xml);
+        const c = remoting.connection(self);
+        if (c !== undefined) {
+            // One header of a name, its case aside: the last set.
+            c.headers = c.headers.filter((h) => h.name.toLowerCase() !== name.toLowerCase());
+            c.headers.push({ name, mustUnderstand, value });
+        }
+    });
+    getter("isConnected", (c) => c !== undefined && c.url === null);
+    getter("uri", (c) => (c === undefined ? undefined : (c.url ?? "null")));
+    return constr;
+}

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

@@ -0,0 +1,37 @@
+// PrintJob's AS2 face, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/print_job.rs has it: MIT OR Apache-2.0, Copyright
+// (c) 2018-2022 Ruffle LLC and Ruffle contributors. Nothing prints: start
+// gives false, as Flash does where the user cancels the print dialog, so
+// addPage gives false and send does nothing.
+import { avm1 } from "../../../runtime/index.js";
+const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE;
+/** The page's and paper's measures, which a job reads once started: 0 before. */
+const MEASURES = ["paperHeight", "paperWidth", "pageHeight", "pageWidth", "orientation"];
+/** `PrintJob`. */
+export function printJobClass(realm) {
+    // Flash's prototype has its constructor before its __proto__, which SWF 7
+    // on sees: up to 6 it inherits nothing, not even toString (adl).
+    const proto = new avm1.Avm1Object();
+    const jobs = new WeakSet();
+    let measured = false;
+    const constr = realm.classOf(proto, (self) => {
+        jobs.add(self);
+        // The first job made adds the measures to the prototype, over what a
+        // script set there, in its place; later jobs add none again, not even
+        // one deleted. Read of anything but a job, they are undefined (adl).
+        if (!measured) {
+            measured = true;
+            for (const name of MEASURES) {
+                const p = proto.define(name, undefined, 0);
+                p.get = realm.method((job) => (jobs.has(job) ? 0 : undefined));
+                p.set = realm.method(() => undefined);
+            }
+        }
+        return self;
+    }, () => undefined);
+    proto.define("__proto__", realm.objectProto, FIXED | avm1.VERSION_7);
+    proto.define("start", realm.method(() => false), FIXED | avm1.VERSION_7);
+    proto.define("addPage", realm.method(() => false), FIXED | avm1.VERSION_7);
+    proto.define("send", realm.method(() => undefined), FIXED | avm1.VERSION_7);
+    return constr;
+}

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

@@ -0,0 +1,62 @@
+// Selection, the focus's AS2 face, as Ruffle's (https://github.com/ruffle-rs/
+// ruffle) core/src/avm1/globals/selection.rs has it: MIT OR Apache-2.0,
+// Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors. A
+// broadcaster, whose listeners hear onSetFocus(old, new) as the focus moves
+// (focus.ts). The text selection is the focused text field's.
+import { avm1 } from "../../../runtime/index.js";
+import { TextObject } from "../../display/display.js";
+import { stateOf } from "./TextField.js";
+const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE | avm1.READ_ONLY;
+/** `_global.Selection`. */
+export function selectionObject(realm, focus, version) {
+    const selection = new avm1.Avm1Object(realm.objectProto);
+    avm1.initializeBroadcaster(selection, realm, version);
+    // Nothing given is false; undefined or null take the focus away; anything
+    // else focuses what it names, where that may have the focus.
+    selection.define("setFocus", realm.method((_, args, v) => {
+        if (args.length === 0) {
+            return false;
+        }
+        const value = args[0];
+        if (value === undefined || value === null) {
+            focus.focus(null);
+            return true;
+        }
+        const d = focus.resolve(value, v);
+        if (d === null || !focus.focusable(d)) {
+            return false;
+        }
+        focus.focus(d);
+        return true;
+    }), FIXED);
+    selection.define("getFocus", realm.method(() => (focus.focused ? focus.pathOf(focus.focused) : null)), FIXED);
+    // The focused field's selection, -1 without one.
+    const field = () => (focus.focused instanceof TextObject ? focus.focused : null);
+    const selected = () => {
+        const f = field();
+        return f !== null && stateOf(f).selected ? f : null;
+    };
+    const indices = [
+        ["getBeginIndex", (f) => f.selection[0]],
+        ["getEndIndex", (f) => f.selection[1]],
+        ["getCaretIndex", (f) => f.caret],
+    ];
+    for (const [name, index] of indices) {
+        selection.define(name, realm.method(() => {
+            const f = selected();
+            return f === null ? -1 : index(f);
+        }), FIXED);
+    }
+    // From begin to end, each at least 0; no end is the text's.
+    selection.define("setSelection", realm.method((_, args, v) => {
+        const f = field();
+        if (f !== null && args.length > 0) {
+            const begin = Math.max(0, avm1.toNumber(args[0], v) | 0);
+            const end = args.length > 1 ? Math.max(0, avm1.toNumber(args[1], v) | 0) : 0x7fffffff;
+            stateOf(f).selected = true;
+            f.select(begin, end);
+        }
+        return undefined;
+    }), FIXED);
+    return selection;
+}