@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/playerglobal/air/net/WebSocket.js

@@ -0,0 +1,250 @@
+// air.net.WebSocket, AIR 51's client, over the host's WebSocket (hosts.ts).
+// What it throws and dispatches is what adl does (docs/architecture/services.md);
+// where a browser cannot do as AIR does, the nearest it can.
+import { avm2 } from "../../../../runtime/index.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+const TEXT = 1;
+const BINARY = 2;
+const CLOSE = 8;
+/** The close codes a browser lets a page send. */
+const sendable = (code) => code === 1000 || (code >= 3000 && code <= 4999);
+export function webSocketNatives(s) {
+    const natives = {};
+    const connections = new WeakMap();
+    const connection = (o) => {
+        let c = connections.get(o);
+        if (!c) {
+            c = {
+                state: "new",
+                url: "",
+                transport: null,
+                protocol: null,
+                closeReason: -1,
+                closedHere: false,
+            };
+            connections.set(o, c);
+        }
+        return c;
+    };
+    const byteArray = () => s.rt.classNamed("flash.utils::ByteArray");
+    const invalid = () => {
+        throw s.rt.error("flash.errors::IOError", 2002);
+    };
+    const errorEvent = (o, cls, type, id, text) => {
+        const event = s.rt.construct(s.rt.classNamed(cls), type, false, false, text, id);
+        dispatchEvent(s, o, event);
+    };
+    // As adl words it: a connection that failed gives its host, a handshake its URL.
+    const ioError = (o, where) => errorEvent(o, "flash.events::IOErrorEvent", "ioError", 2031, `Error #2031: Socket Error.${where && ` URL: ${where}`}`);
+    const hostOf = (url) => {
+        try {
+            return new URL(url).hostname;
+        }
+        catch {
+            return "";
+        }
+    };
+    /** End a connection before its handshake is done, as AIR does when a frame goes out first. */
+    const interrupt = (o, c) => {
+        c.transport?.close();
+        c.transport = null;
+        c.state = "closed";
+        s.loads.deferHostEvent(() => {
+            ioError(o, c.url);
+            dispatchEvent(s, o, s.event("close"));
+        });
+    };
+    const send = (c, opcode, bytes) => {
+        const transport = c.transport;
+        if (!transport) {
+            return;
+        }
+        // AIR writes the opcode's low four bits, whatever they are.
+        switch (opcode & 0x0f) {
+            case TEXT:
+                // A leading BOM is the SWF's bytes, as AIR sends them, not a mark to drop.
+                transport.send(new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes));
+                break;
+            case BINARY:
+                transport.send(bytes);
+                break;
+            case CLOSE: {
+                // A close frame of the SWF's own: adl sends its code alone, and then
+                // dispatches the close, as for the server's.
+                const code = bytes.length >= 2 ? (bytes[0] << 8) | bytes[1] : 0;
+                c.state = "closing";
+                transport.close(sendable(code) ? code : undefined);
+                break;
+            }
+            default:
+                // Pings, pongs and reserved opcodes, which AIR sends as they are and a
+                // browser cannot: the browser answers the server's pings itself, and
+                // AIR dispatches nothing for a pong or for a reserved frame echoed.
+                break;
+        }
+    };
+    class WebSocketNatives {
+        "air.net:WebSocket::internalConnect"(url, protocols) {
+            if (url === null || url === undefined) {
+                throw s.rt.error("TypeError", 2007, "url");
+            }
+            const c = connection(this);
+            if (c.state !== "new") {
+                throw s.rt.error("flash.errors::IllegalOperationError", 2082);
+            }
+            const text = s.rt.toString(url);
+            if (!/^wss?:\/\//.test(text)) {
+                throw s.rt.error("ArgumentError", 2147, text);
+            }
+            c.state = "connecting";
+            c.url = text;
+            // AIR offers the vector's protocols, null ones left out, not `protocol`.
+            const offered = protocols === null || protocols === undefined
+                ? []
+                : protocols.$a
+                    .filter((p) => p !== null && p !== undefined)
+                    .map((p) => s.rt.toString(p));
+            const fail = () => {
+                if (c.state !== "connecting") {
+                    return;
+                }
+                c.transport = null;
+                c.state = "failed";
+                ioError(this, hostOf(text));
+            };
+            const host = s.webSocket;
+            if (!host) {
+                s.loads.deferHostEvent(fail);
+                return;
+            }
+            try {
+                // AIR sends a URL's fragment in its request line; a browser refuses one.
+                c.transport = host.connect(text.replace(/#.*$/s, ""), offered, {
+                    open: (protocol) => s.loads.deferHostEvent(() => {
+                        if (c.state !== "connecting") {
+                            return;
+                        }
+                        c.state = "open";
+                        if (protocol !== "") {
+                            c.protocol = protocol;
+                        }
+                        dispatchEvent(s, this, s.event("connect"));
+                    }),
+                    message: (data) => s.loads.deferHostEvent(() => {
+                        if (c.state !== "open" && c.state !== "closing") {
+                            return;
+                        }
+                        const array = s.rt.construct(byteArray());
+                        const bytes = avm2.bytesOf(s.rt, array);
+                        bytes.write(typeof data === "string" ? new TextEncoder().encode(data) : data.slice());
+                        bytes.position = 0;
+                        const format = typeof data === "string" ? TEXT : BINARY;
+                        const cls = s.rt.classNamed("flash.events::WebSocketEvent");
+                        dispatchEvent(s, this, s.rt.construct(cls, "websocketData", format, array));
+                    }),
+                    close: (code) => s.loads.deferHostEvent(() => {
+                        if (c.state === "connecting") {
+                            fail();
+                            return;
+                        }
+                        if (c.state !== "open" && c.state !== "closing") {
+                            return;
+                        }
+                        c.state = "closed";
+                        c.transport = null;
+                        // A close without a frame, or a frame without a code, leaves AIR's -1.
+                        if (code !== 1005 && code !== 1006) {
+                            c.closeReason = code;
+                        }
+                        if (!c.closedHere) {
+                            dispatchEvent(s, this, s.event("close"));
+                        }
+                    }),
+                    error: () => s.loads.deferHostEvent(fail),
+                });
+            }
+            catch (e) {
+                if (e?.name === "SecurityError") {
+                    c.state = "failed";
+                    s.loads.deferHostEvent(() => errorEvent(this, "flash.events::SecurityErrorEvent", "securityError", 2048, `Error #2048: Security sandbox violation: ${s.url} cannot load data from ${text}.`));
+                }
+                else {
+                    s.loads.deferHostEvent(fail);
+                }
+            }
+        }
+        sendMessage(opcode, data) {
+            let bytes;
+            if (typeof data === "string") {
+                bytes = new TextEncoder().encode(data);
+            }
+            else if (data !== null && data !== undefined && s.rt.isInstance(data, byteArray())) {
+                const b = avm2.bytesOf(s.rt, data);
+                bytes = b.buffer.slice(0, b.length);
+            }
+            else {
+                throw s.rt.error("ArgumentError", 1508, "data");
+            }
+            const c = connection(this);
+            switch (c.state) {
+                case "open":
+                    send(c, s.rt.toUint(opcode), bytes);
+                    break;
+                case "connecting":
+                    interrupt(this, c);
+                    break;
+                case "new":
+                case "closed":
+                    // Before connect, adl crashes; this is what it throws once closed.
+                    invalid();
+                    break;
+                default:
+                    break;
+            }
+        }
+        "air.net:WebSocket::internalClose"(reasonCode) {
+            const c = connection(this);
+            switch (c.state) {
+                case "open": {
+                    // AIR sends any code, cut to 16 bits; a browser sends only these.
+                    const code = s.rt.toUint(reasonCode) & 0xffff;
+                    c.state = "closing";
+                    c.closedHere = true;
+                    c.transport?.close(sendable(code) ? code : undefined);
+                    break;
+                }
+                case "connecting":
+                    interrupt(this, c);
+                    break;
+                case "new":
+                case "closed":
+                    invalid();
+                    break;
+                default:
+                    break;
+            }
+        }
+        get protocol() {
+            return connection(this).protocol;
+        }
+        set protocol(value) {
+            const c = connection(this);
+            if (c.state === "open" || c.state === "closing" || c.state === "closed") {
+                throw s.rt.error("ArgumentError", 2014);
+            }
+            c.protocol = value === null || value === undefined ? null : s.rt.toString(value);
+        }
+        get closeReason() {
+            return connection(this).closeReason;
+        }
+        startServer(socket) {
+            if (socket === null || socket === undefined) {
+                throw s.rt.error("TypeError", 2007, "socket");
+            }
+            // What AIR throws for a method its profile lacks (Updater.update in adl).
+            throw s.rt.construct(s.rt.classNamed("flash.errors::IllegalOperationError"), "This method is not supported in this profile.");
+        }
+    }
+    avm2.registerNativeClass(natives, "air.net::WebSocket", WebSocketNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/air-library.js

@@ -0,0 +1,8 @@
+// AIR's air.net.WebSocket and flash.events.WebSocketEvent, declared for
+// the player: the ABC compiled from their .as files under as3/air.
+// Generated by tests/player/air-library.ts; not to be edited.
+/**
+ * An ABC to load after builtin and playerglobal (Scripting.loadLibraries),
+ * for SWFs that use AIR 51's WebSocket client.
+ */
+export const airLibrary = Uint8Array.from(atob("EAAuAAcBAggJCugHAAA5BERBVEEABlN0cmluZw13ZWJzb2NrZXREYXRhB19mb3JtYXQbZmxhc2guZXZlbnRzOldlYlNvY2tldEV2ZW50BHVpbnQFX2RhdGEJQnl0ZUFycmF5C2ZsYXNoLnV0aWxzBmZvcm1hdARkYXRhCnN0cmluZ0RhdGEOV2ViU29ja2V0RXZlbnQMZmxhc2guZXZlbnRzBUV2ZW50B2ZtdFRFWFQJZm10QklOQVJZCGZtdENMT1NFB2ZtdFBJTkcHZm10UE9ORwdjb25uZWN0D2ludGVybmFsQ29ubmVjdBFhaXIubmV0OldlYlNvY2tldAtzZW5kTWVzc2FnZQVjbG9zZQ1pbnRlcm5hbENsb3NlCHByb3RvY29sC2Nsb3NlUmVhc29uC3N0YXJ0U2VydmVyCVdlYlNvY2tldAdhaXIubmV0D0V2ZW50RGlzcGF0Y2hlcghwb3NpdGlvbgZsZW5ndGgMcmVhZFVURkJ5dGVzBHR5cGUGVmVjdG9yC19fQVMzX18udmVjBHZvaWQDdXJsCXByb3RvY29scwpyZWFzb25Db2RlBk9iamVjdAZvcGNvZGUFdmFsdWUDaW50BlNvY2tldAlmbGFzaC5uZXQGc29ja2V0A+6KlA5mbGFzaC51dGlsc+6KlA9mbGFzaC5ldmVudHPuipQKYWlyLm5ldO6KlA5fX0FTM19fLnZlY+6KlAxmbGFzaC5uZXTuipQJFjMFBhY0FjUFGBY2FjcWOAAkBwEBBwEDBwIFBwEHBwIIBwMJBwELBwEMBwENBwQOBwQQBwERBwESBwETBwEUBwEVBwEWBwUXBwEZBwEaBwUbBwEcBwEdBwEeBwYfBwQhBwEiBwEjBwEkHR8BAgcHJgcBKAcBLAcBLwcIMBEAAAAAAAQLAAAGDAAAAg0AAwACBAYOgCULDAAAAAACIAIeFogBDAwpKgIgAh4XoCkqAiAEABmgLQwBIAQaiAEGAysBIAQboCsAAhwgASACHKAuACIdIAEgIx6gMgAAHwAAAAAAAAIKCwEABAUDAAAEAAUAAAYABwIAAQgCAAIJAgADGRoBAA8JEQEABhIBAAcTAQAIFAEACRUBAAoWAgALFgMADBcCAA0YAQAOBQEBBgACBAEQBQwGAAQBAw0GAAQCAw4GAAQDAw8GAAQEAxAGAAQFAwEAAgoEAAAZBAABCgEBAQABBdAwYANIAAACAgEAAQvQMGAFJABhG2AFSAAAAwIBAAEe0DBgAyQBq5YSAgAAIEhgBSQAYRtgBWAFZhxGHQFIAAAEBAQAARXQMNDRJydJA9JeAythA9NeBSthBUcAAAUAAQAAAUcAAAYDAwABCtAwXRLR0k8SAkcAAAkCAgABCdAwXRXRTxUBRwAADwEBAAEG0DDQSQBHAAAQAAEAAAFHAAAAAwEAAyHQMGUAYCEwYAsqMFgAHR1oCmUAYCEwYBoqMFgBHR1oGUcAAA=="), (c) => c.charCodeAt(0));

package/dist/thread/player/playerglobal/flash/accessibility/Accessibility.js

@@ -0,0 +1,21 @@
+// flash.accessibility.Accessibility: this player has no platform accessibility bridge.
+import { avm2 } from "../../../../runtime/index.js";
+export function accessibilityNatives(s) {
+    const natives = {};
+    class AccessibilityNatives {
+        static get active() {
+            return false;
+        }
+        static sendEvent(source, _childId, _eventType, _nonHtml) {
+            if (source === null || source === undefined) {
+                throw s.rt.error("TypeError", 2007, "source");
+            }
+            // No platform accessibility bridge receives events.
+        }
+        static updateProperties() {
+            // No platform accessibility bridge holds properties.
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.accessibility::Accessibility", AccessibilityNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/crypto/generateRandomBytes.js

@@ -0,0 +1,32 @@
+// flash.crypto contains one function: cryptographically strong bytes from
+// the host, with Flash's bounded length and a fresh ByteArray at position 0.
+import { avm2 } from "../../../../runtime/index.js";
+export function cryptoNatives() {
+    return {
+        "flash.crypto::generateRandomBytes": (rt) => (count) => {
+            const length = rt.toUint(count);
+            if (length === 0) {
+                // AIR returns null here, though the API reference gives 1 as the minimum.
+                return null;
+            }
+            if (length > 1024) {
+                throw rt.error("Error", 2004);
+            }
+            const crypto = globalThis.crypto;
+            if (!crypto?.getRandomValues) {
+                throw rt.error("Error", 0);
+            }
+            const array = rt.construct(rt.classNamed("flash.utils::ByteArray"));
+            const bytes = avm2.bytesOf(rt, array);
+            bytes.setLength(length);
+            try {
+                // A new ByteArray, never shared.
+                crypto.getRandomValues(bytes.buffer.subarray(0, length));
+            }
+            catch {
+                throw rt.error("Error", 0);
+            }
+            return array;
+        },
+    };
+}

package/dist/thread/player/playerglobal/flash/data/EncryptedLocalStore.js

@@ -0,0 +1,61 @@
+// flash.data.EncryptedLocalStore over the host's EncryptedStoreHost
+// (hosts.ts), as adl (AIR 51.3) has it: an item is the whole of a
+// ByteArray, whatever its position, which stays as it was; getItem gives
+// a new ByteArray of it at position 0, and null for a name of none or of
+// empty bytes. A null name or data is ArgumentError 2007, an empty name
+// 2085. stronglyBound, which ties an item to the application's signature,
+// is taken and changes nothing: there is no signature to tie it to.
+import { avm2 } from "../../../../runtime/index.js";
+export function encryptedLocalStoreNatives(s) {
+    const natives = {};
+    const store = () => s.encryptedStore;
+    /** An item's name; ArgumentError for none, or for "". */
+    const nameOf = (name) => {
+        if (name === null || name === undefined) {
+            throw s.rt.error("ArgumentError", 2007, "name");
+        }
+        const named = s.rt.toString(name);
+        if (named === "") {
+            throw s.rt.error("ArgumentError", 2085, "name");
+        }
+        return named;
+    };
+    class EncryptedLocalStoreNatives {
+        static get isSupported() {
+            return store() !== null;
+        }
+        static setItem(name, data, _stronglyBound = false) {
+            const named = nameOf(name);
+            if (data === null || data === undefined) {
+                throw s.rt.error("ArgumentError", 2007, "data");
+            }
+            const bytes = avm2.bytesOf(s.rt, data);
+            const copy = bytes.buffer.slice(0, bytes.length);
+            if (copy.length === 0) {
+                store()?.removeItem(named);
+            }
+            else {
+                store()?.setItem(named, copy);
+            }
+        }
+        static getItem(name) {
+            const bytes = store()?.getItem(nameOf(name));
+            if (!bytes || bytes.length === 0) {
+                return null;
+            }
+            const out = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray"));
+            const into = avm2.bytesOf(s.rt, out);
+            into.write(bytes);
+            into.position = 0;
+            return out;
+        }
+        static removeItem(name) {
+            store()?.removeItem(nameOf(name));
+        }
+        static reset() {
+            store()?.reset();
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.data::EncryptedLocalStore", EncryptedLocalStoreNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/desktop/Clipboard.js

@@ -0,0 +1,173 @@
+// flash.desktop.Clipboard as Flash Player has it: one Clipboard, the
+// system's, generalClipboard, over the player's (scripting/clipboard.ts).
+// playerglobal's AS3 maps formats to these natives and checks access with
+// canReadContents and canWriteContents: a script reads only in a paste,
+// writes only in a user's event. Flash Player carries text, HTML, rich
+// text, a script's own formats as references and serialized objects; a
+// URL is kept as AIR keeps it, but bitmaps and files are AIR's alone.
+import { avm2 } from "../../../../runtime/index.js";
+import { HTML, TEXT } from "../../../scripting/clipboard.js";
+const RTF = "air:rtf";
+const URL_FORMAT = "air:url";
+const REFERENCE = "air:reference:";
+const SERIALIZATION = "air:serialization:";
+/** Whether `format` is one of Flash's own, which keeps its name, rather than a script's. */
+const system = (format) => format.startsWith("air:") || format.startsWith("flash:");
+export function clipboardNatives(s) {
+    const natives = {};
+    const clipboard = () => s.clipboard;
+    const str = (v) => s.rt.toString(v);
+    /** clear and clearData check their own access, as no AS3 does it for them. */
+    const writing = () => {
+        if (!clipboard().writable) {
+            throw s.rt.error("SecurityError", 2191);
+        }
+    };
+    /** A stored ByteArray from its start, as each read deserializes it anew. */
+    const rewound = (v) => {
+        if (v) {
+            avm2.bytesOf(s.rt, v).position = 0;
+        }
+        return v ?? null;
+    };
+    class ClipboardNatives {
+        static get generalClipboard() {
+            return general(s);
+        }
+        /** Its formats, a script's own by the names it gave them. */
+        get formats() {
+            const names = clipboard().formats.map((f) => f.startsWith(REFERENCE)
+                ? f.slice(REFERENCE.length)
+                : f.startsWith(SERIALIZATION)
+                    ? f.slice(SERIALIZATION.length)
+                    : f);
+            return s.rt.array([...new Set(names)]);
+        }
+        clear() {
+            writing();
+            clipboard().clear();
+        }
+        clearData(format) {
+            writing();
+            const name = str(format);
+            if (system(name)) {
+                clipboard().delete(name);
+            }
+            else {
+                clipboard().delete(REFERENCE + name);
+                clipboard().delete(SERIALIZATION + name);
+            }
+        }
+        // A dead clipboard is AIR's, one let go of after a drag.
+        get "flash.desktop:Clipboard::alive"() {
+            return true;
+        }
+        get "flash.desktop:Clipboard::canReadContents"() {
+            return clipboard().readable;
+        }
+        get "flash.desktop:Clipboard::canWriteContents"() {
+            return clipboard().writable;
+        }
+        "flash.desktop:Clipboard::nativeSetHandler"(format, handler) {
+            clipboard().setHandler(str(format), () => {
+                s.rt.call(handler, null);
+            });
+        }
+        "flash.desktop:Clipboard::setHandlerStoringData"(storing) {
+            clipboard().storing = !!storing;
+        }
+        "flash.desktop:Clipboard::getObjectReference"(format) {
+            return clipboard().get(str(format));
+        }
+        "flash.desktop:Clipboard::putObjectReference"(format, value) {
+            clipboard().set(str(format), value);
+        }
+        "flash.desktop:Clipboard::getString"() {
+            return clipboard().get(TEXT) ?? null;
+        }
+        "flash.desktop:Clipboard::putString"(text) {
+            clipboard().set(TEXT, str(text));
+        }
+        "flash.desktop:Clipboard::getHTML"() {
+            return clipboard().get(HTML) ?? null;
+        }
+        "flash.desktop:Clipboard::putHTML"(html) {
+            clipboard().set(HTML, str(html));
+        }
+        "flash.desktop:Clipboard::getRTF"() {
+            return rewound(clipboard().get(RTF));
+        }
+        "flash.desktop:Clipboard::putRTF"(bytes) {
+            clipboard().set(RTF, bytes);
+        }
+        "flash.desktop:Clipboard::getByteArray"(format) {
+            return rewound(clipboard().get(str(format)));
+        }
+        "flash.desktop:Clipboard::putByteArray"(format, bytes) {
+            clipboard().set(str(format), bytes);
+        }
+        get "flash.desktop:Clipboard::swfVersion"() {
+            return s.rt.swfVersion;
+        }
+        get supportsFilePromise() {
+            return false;
+        }
+        "flash.desktop:Clipboard::getURL"() {
+            return clipboard().get(URL_FORMAT) ?? null;
+        }
+        "flash.desktop:Clipboard::putURL"(url) {
+            clipboard().set(URL_FORMAT, str(url));
+        }
+        // Bitmaps and files go only through AIR's clipboard.
+        "flash.desktop:Clipboard::getBitmapData"() {
+            return null;
+        }
+        "flash.desktop:Clipboard::putBitmapData"() { }
+        "flash.desktop:Clipboard::getFileList"() {
+            return null;
+        }
+        "flash.desktop:Clipboard::nativePutFileList"() { }
+        "flash.desktop:Clipboard::nativeGetFilePromiseList"() {
+            return null;
+        }
+        "flash.desktop:Clipboard::nativePutFilePromiseList"() { }
+    }
+    avm2.registerNativeClass(natives, "flash.desktop::Clipboard", ClipboardNatives);
+    return natives;
+}
+/** Each player's generalClipboard, made on first use. */
+const generals = new WeakMap();
+/** Whether the player is making its generalClipboard, the one Clipboard `new` may make. */
+let making = false;
+function general(s) {
+    let o = generals.get(s);
+    if (!o) {
+        making = true;
+        try {
+            o = s.rt.constructClass(s.rt.classNamed("flash.desktop::Clipboard"), []);
+        }
+        finally {
+            making = false;
+        }
+        generals.set(s, o);
+    }
+    return o;
+}
+/**
+ * `new Clipboard()` is AIR's: Flash Player has the system's alone, and
+ * refuses another with IllegalOperationError #2178.
+ */
+export function clipboardHooks() {
+    return {
+        "flash.desktop::Clipboard": {
+            construct(rt, cls, args) {
+                if (!making) {
+                    throw rt.error("flash.errors::IllegalOperationError", 2178);
+                }
+                const o = cls.$it.instance();
+                cls.$it.proto.$init.apply(o, args);
+                return o;
+            },
+        },
+    };
+}