@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/playerglobal/flash/net/FileFilter.js

@@ -0,0 +1,27 @@
+// flash.net.FileFilter: three strings a file dialog would show.
+import { avm2 } from "../../../../runtime/index.js";
+export function fileFilterNatives(_s) {
+    const natives = {};
+    class FileFilterNatives {
+        get description() {
+            return this.$description ?? null;
+        }
+        set description(v) {
+            this.$description = v;
+        }
+        get extension() {
+            return this.$extension ?? null;
+        }
+        set extension(v) {
+            this.$extension = v;
+        }
+        get macType() {
+            return this.$macType ?? null;
+        }
+        set macType(v) {
+            this.$macType = v;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.net::FileFilter", FileFilterNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/net/FileReference.js

@@ -0,0 +1,197 @@
+// File dialogs and transfers, shared with AVM1 through the host's file services.
+import { avm2 } from "../../../../runtime/index.js";
+import { FileReference } from "../../../files.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+import { fileEntry } from "../filesystem/File.js";
+export function fileReferenceNatives(s) {
+    const natives = {};
+    const states = new WeakMap();
+    const services = {
+        host: s.fileHost,
+        signal: s.fileLifetime.signal,
+        defer: (deliver) => s.loads.deferHostEvent(deliver),
+        track: (task) => s.loads.trackRequest(task),
+        fetch: (request, signal) => s.fetch ? s.fetch({ ...request, purpose: "data" }, signal) : Promise.reject(),
+        error: (id) => {
+            throw s.rt.error("Error", id);
+        },
+    };
+    const state = (target) => {
+        let ref = states.get(target);
+        if (!ref) {
+            ref = new FileReference(services, (type, loaded, total, text) => {
+                let event;
+                switch (type) {
+                    case "httpStatus":
+                        event = s.httpStatus(loaded ?? 0);
+                        break;
+                    case "progress":
+                        event = s.rt.construct(s.rt.classNamed("flash.events::ProgressEvent"), type, false, false, loaded, total);
+                        break;
+                    case "ioError":
+                        target.$fileInto = null;
+                        event = s.rt.construct(s.rt.classNamed("flash.events::IOErrorEvent"), type, false, false, text);
+                        break;
+                    case "uploadCompleteData":
+                        event = s.rt.construct(s.rt.classNamed("flash.events::DataEvent"), type, false, false, text);
+                        break;
+                    case "complete": {
+                        const into = target.$fileInto;
+                        const data = states.get(target)?.data;
+                        if (into && data) {
+                            const bytes = avm2.bytesOf(s.rt, into);
+                            bytes.length = 0;
+                            bytes.position = 0;
+                            bytes.write(data);
+                            bytes.position = 0;
+                            target.$fileData = into;
+                        }
+                        target.$fileInto = null;
+                        event = s.event(type);
+                        break;
+                    }
+                    case "select":
+                        target.$fileData = null;
+                        target.$fileInto = null;
+                        event = s.event(type);
+                        break;
+                    default:
+                        event = s.event(type);
+                }
+                dispatchEvent(s, target, event);
+            });
+            states.set(target, ref);
+        }
+        return ref;
+    };
+    const file = (target) => state(target).file ?? services.error(2037);
+    const property = (target, name) => s.rt.getProperty(target, s.rt.publicName(name));
+    const filters = (value) => (value?.$a ?? []).map((filter) => ({
+        description: s.rt.toString(property(filter, "description")),
+        extension: s.rt.toString(property(filter, "extension")),
+    }));
+    const requestOf = (request) => {
+        if (request === null || request === undefined) {
+            throw s.rt.error("TypeError", 2007, "request");
+        }
+        return request;
+    };
+    /**
+     * What a File with a path has on disk, as a selected file's fields: its
+     * name whether or not it is there, the rest Error 3003 where it is not.
+     */
+    const onDisk = (target) => {
+        const entry = fileEntry(s, target);
+        if (!entry) {
+            return null;
+        }
+        const stat = entry.stat;
+        const missing = () => {
+            throw s.rt.error("Error", 3003);
+        };
+        return {
+            name: entry.name,
+            get size() {
+                return stat ? (stat.directory ? 0 : stat.size) : missing();
+            },
+            get modificationDate() {
+                return stat ? stat.modified : missing();
+            },
+            get creationDate() {
+                return stat ? stat.created : missing();
+            },
+            directory: stat?.directory ?? false,
+        };
+    };
+    const described = (target) => onDisk(target) ?? file(target);
+    class FileReferenceNatives {
+        get creationDate() {
+            const selected = described(this);
+            return s.rt.construct(s.rt.classNamed("Date"), selected.creationDate ?? selected.modificationDate);
+        }
+        get modificationDate() {
+            return s.rt.construct(s.rt.classNamed("Date"), described(this).modificationDate);
+        }
+        get name() {
+            return described(this).name;
+        }
+        get size() {
+            return described(this).size;
+        }
+        get type() {
+            const { name, directory } = described(this);
+            // A directory's is empty, a file's its extension with the dot, as adl's.
+            if (directory) {
+                return "";
+            }
+            const dot = name.lastIndexOf(".");
+            return dot < 0 ? "" : name.slice(dot);
+        }
+        get creator() {
+            return null;
+        }
+        get data() {
+            return this.$fileData ?? null;
+        }
+        browse(typeFilter = null) {
+            state(this).browse(filters(typeFilter));
+            return true;
+        }
+        cancel() {
+            state(this).cancel();
+            this.$fileInto = null;
+        }
+        download(request, name = null) {
+            const outgoing = s.loads.fetchRequest(requestOf(request), s.url, { requestHeaders: false });
+            const suggested = name == null
+                ? outgoing.url.split(/[?#]/, 1)[0].split("/").pop() || "download"
+                : s.rt.toString(name);
+            state(this).save(suggested, outgoing);
+        }
+        upload(request, field = "Filedata", test = false) {
+            const outgoing = s.loads.fetchRequest(requestOf(request), s.url, { requestHeaders: false });
+            if (field === null || field === undefined) {
+                throw s.rt.error("TypeError", 2007, "uploadDataFieldName");
+            }
+            const name = s.rt.toString(field);
+            const data = request.$data;
+            if (name === "" ||
+                (data && typeof data === "object" && s.rt.traitsOf(data).name === "flash.utils::ByteArray")) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            state(this).upload(outgoing, name, Boolean(test) && s.platform.os.startsWith("Windows"));
+        }
+        uploadUnencoded(request) {
+            state(this).upload(s.loads.fetchRequest(requestOf(request), s.url, { requestHeaders: "all" }), null);
+        }
+        "flash.net:FileReference::_load"(into) {
+            state(this).load();
+            this.$fileInto = into;
+            this.$fileData = null;
+        }
+        "flash.net:FileReference::_save"(data, name) {
+            const bytes = avm2.bytesOf(s.rt, data);
+            state(this).save(name == null ? "Untitled" : s.rt.toString(name), bytes.buffer.slice(0, bytes.length));
+        }
+        static "flash.net:FileReference::_ensureIsRootPlayer"() { }
+    }
+    class FileReferenceListNatives {
+        get fileList() {
+            return this.$fileList ?? null;
+        }
+        browse(typeFilter = null) {
+            this.$fileList = s.rt.array([]);
+            state(this).browse(filters(typeFilter), true, (files) => {
+                this.$fileList = s.rt.array(files.map((file) => {
+                    const object = s.rt.construct(s.rt.classNamed("flash.net::FileReference"));
+                    state(object).file = file;
+                    return object;
+                }));
+            });
+            return true;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.net::FileReference", FileReferenceNatives);
+    avm2.registerNativeClass(natives, "flash.net::FileReferenceList", FileReferenceListNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/net/LocalConnection.js

@@ -0,0 +1,167 @@
+// Both VMs use the player's LocalConnection registry. The AS3 class keeps
+// its public API in playerglobal; only transport and VM values live here.
+import { avm2 } from "../../../../runtime/index.js";
+import { localDomain, localMethodAllowed } from "../../../localconnection.js";
+import { dispatchEvent, heard } from "../../../scripting/events.js";
+import { readModernValues, writeModernValues } from "./local-modern.js";
+import { readLocalValues, writeLocalValues } from "./local-values.js";
+export function swfDomain(url) {
+    return localDomain(url).domain;
+}
+export function localConnectionNatives(s) {
+    const natives = {};
+    const states = new WeakMap();
+    const state = (self) => {
+        const found = states.get(self);
+        if (found) {
+            return found;
+        }
+        const origins = s.code.securityUrls(3).map(localDomain);
+        const origin = origins[0] ?? localDomain(s.url);
+        if (origins.some((other) => other.domain !== origin.domain || other.secure !== origin.secure)) {
+            // Where the engine cannot identify a caller, do not borrow the main SWF's permissions.
+            origin.domain = "";
+        }
+        const endpoint = {
+            owner: s,
+            ...origin,
+            key: null,
+            client: self,
+            locked: false,
+            perUser: false,
+            domains: new Set(),
+            insecure: new Set(),
+            alive: () => !s.destroyed,
+            allows: (sender) => {
+                const allowed = endpoint.secure && !sender.secure ? endpoint.insecure : endpoint.domains;
+                return ((!(endpoint.secure && !sender.secure) && sender.domain === endpoint.domain) ||
+                    allowed.has("*") ||
+                    allowed.has(sender.domain));
+            },
+            defer: (deliver) => s.loads.deferHostEvent(deliver),
+            status: (success) => {
+                if (!heard(self, "status")) {
+                    return;
+                }
+                dispatchEvent(s, self, s.rt.construct(s.rt.classNamed("flash.events::StatusEvent"), "status", false, false, null, success ? "status" : "error"));
+            },
+            receive: (method, message) => {
+                try {
+                    s.rt.callProperty(endpoint.client, s.rt.publicName(method), ...(message.encoding === 0
+                        ? readLocalValues(s.rt, message.bytes)
+                        : readModernValues(s.rt, message.bytes)));
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        s.reportUncaught(error);
+                        return;
+                    }
+                    const failure = s.rt.error("Error", 2095, "flash.net.LocalConnection", method);
+                    if (!heard(self, "asyncError")) {
+                        s.reportUncaught(failure);
+                        return;
+                    }
+                    dispatchEvent(s, self, s.rt.construct(s.rt.classNamed("flash.events::AsyncErrorEvent"), "asyncError", false, false, s.rt.getProperty(failure, s.rt.publicName("message")), s.rt.isInstance(error, s.rt.classNamed("Error"))
+                        ? error
+                        : s.rt.construct(s.rt.classNamed("Error"), s.rt.toString(error))));
+                }
+            },
+        };
+        states.set(self, endpoint);
+        return endpoint;
+    };
+    class LocalConnectionNatives {
+        "flash.net:LocalConnection::ctor"() {
+            state(this);
+        }
+        get domain() {
+            return state(this).domain;
+        }
+        connect(name) {
+            const endpoint = state(this);
+            endpoint.locked = true;
+            if (name === null) {
+                throw s.rt.error("TypeError", 2007, "connectionName");
+            }
+            if (name === "") {
+                throw s.rt.error("ArgumentError", 2085, "connectionName");
+            }
+            if (name.includes(":")) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            if (!s.localConnections.connect(endpoint, name)) {
+                throw s.rt.error("ArgumentError", 2082);
+            }
+        }
+        close() {
+            const endpoint = state(this);
+            endpoint.locked = true;
+            if (!s.localConnections.close(endpoint)) {
+                throw s.rt.error("ArgumentError", 2083);
+            }
+        }
+        send(name, method, ...args) {
+            const endpoint = state(this);
+            endpoint.locked = true;
+            if (name === null || method === null) {
+                throw s.rt.error("TypeError", 2007, name === null ? "connectionName" : "methodName");
+            }
+            if (name === "" || method === "") {
+                throw s.rt.error("ArgumentError", 2085, name === "" ? "connectionName" : "methodName");
+            }
+            if (!localMethodAllowed(method)) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            let bytes;
+            try {
+                bytes = writeModernValues(s.rt, args);
+            }
+            catch (error) {
+                if (!(error instanceof RangeError)) {
+                    throw error;
+                }
+                throw s.rt.error("ArgumentError", 2084);
+            }
+            s.localConnections.send(endpoint, name, method, {
+                encoding: 3,
+                bytes,
+                legacy: () => writeLocalValues(s.rt, readModernValues(s.rt, bytes)),
+            });
+        }
+        get client() {
+            return state(this).client;
+        }
+        set client(value) {
+            if (value === null || value === undefined) {
+                throw s.rt.error("TypeError", 2007, "client");
+            }
+            state(this).client = value;
+        }
+        get isPerUser() {
+            return state(this).perUser;
+        }
+        set isPerUser(value) {
+            const endpoint = state(this);
+            if (endpoint.locked) {
+                throw s.rt.error("Error", 3316);
+            }
+            endpoint.perUser = value;
+        }
+        allowDomain(...domains) {
+            const endpoint = state(this);
+            for (const domain of domains) {
+                endpoint.domains.add(s.rt.toString(domain).toLowerCase());
+            }
+        }
+        allowInsecureDomain(...domains) {
+            const endpoint = state(this);
+            for (const domain of domains) {
+                const name = s.rt.toString(domain).toLowerCase();
+                endpoint.insecure.add(name);
+                endpoint.domains.add(name);
+            }
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.net::LocalConnection", LocalConnectionNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/net/NetConnection.js

@@ -0,0 +1,155 @@
+// flash.net.NetConnection in its local mode, connect(null), which Flash
+// keeps for progressive video, with its properties and status events as
+// Flash gives them; an HTTP URI is kept, as Flash Remoting would use it,
+// and a call over it is not supported yet. Responder holds its callbacks.
+import { avm2 } from "../../../../runtime/index.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+/** NetConnection's private invoke codes, as playerglobal's constants have them. */
+const CLOSE = 1;
+const CALL = 2;
+const ADD_HEADER = 3;
+const NONCE = "0".repeat(64);
+export function netConnectionNatives(s) {
+    const natives = {};
+    let defaultEncoding = 3;
+    const status = (target, info) => {
+        dispatchEvent(s, target, s.rt.construct(s.rt.classNamed("flash.events::NetStatusEvent"), "netStatus", false, false, s.rt.newObject(info)));
+    };
+    /** What a local connection has; ArgumentError 2126 for any other. */
+    const connectedOnly = (o, value) => {
+        if (!o.$connected) {
+            throw s.rt.error("ArgumentError", 2126);
+        }
+        return value;
+    };
+    class NetConnectionNatives {
+        get connected() {
+            return this.$connected ?? false;
+        }
+        get uri() {
+            return this.$uri ?? null;
+        }
+        /** Null is the local connection, at once and connected; an HTTP URI is only kept. A connection made goes first. */
+        connect(command) {
+            const self = this;
+            if (this.$connected) {
+                this.$connected = false;
+                status(self, ["code", "NetConnection.Connect.Closed", "level", "status"]);
+            }
+            if (command === null || command === undefined || s.rt.toString(command) === "null") {
+                this.$uri = "null";
+                this.$connected = true;
+                status(self, ["code", "NetConnection.Connect.Success", "level", "status"]);
+                return;
+            }
+            this.$uri = s.rt.toString(command);
+        }
+        "flash.net:NetConnection::invoke"(code) {
+            if (s.rt.toUint(code) === CLOSE) {
+                close(this);
+                return undefined;
+            }
+            throw s.rt.unsupported(`NetConnection invoke ${s.rt.toUint(code)}`);
+        }
+        "flash.net:NetConnection::invokeWithArgsArray"(code, _args) {
+            const which = s.rt.toUint(code);
+            if (which === ADD_HEADER) {
+                return undefined;
+            }
+            if (which === CALL) {
+                throw s.rt.unsupported("NetConnection.call, Flash Remoting");
+            }
+            throw s.rt.unsupported(`NetConnection invoke ${which}`);
+        }
+        get client() {
+            return this.$client ?? this;
+        }
+        set client(v) {
+            if (v === null || v === undefined) {
+                throw s.rt.error("TypeError", 2004);
+            }
+            this.$client = v;
+        }
+        get objectEncoding() {
+            return this.$objectEncoding ?? defaultEncoding;
+        }
+        set objectEncoding(v) {
+            this.$objectEncoding = s.rt.toUint(v);
+        }
+        get proxyType() {
+            return this.$proxyType ?? "none";
+        }
+        set proxyType(v) {
+            this.$proxyType = s.rt.toString(v);
+        }
+        get maxPeerConnections() {
+            return this.$maxPeers ?? 8;
+        }
+        set maxPeerConnections(v) {
+            this.$maxPeers = s.rt.toUint(v);
+        }
+        get httpIdleTimeout() {
+            return this.$idleTimeout ?? 0;
+        }
+        "flash.net:NetConnection::_SetHTTPIdleTimeout"(v) {
+            this.$idleTimeout = s.rt.toNumber(v);
+        }
+        get connectedProxyType() {
+            return connectedOnly(this, "none");
+        }
+        get usingTLS() {
+            return connectedOnly(this, false);
+        }
+        get protocol() {
+            return connectedOnly(this, "rtmp");
+        }
+        get nearID() {
+            return connectedOnly(this, "");
+        }
+        get farID() {
+            return connectedOnly(this, "");
+        }
+        get nearNonce() {
+            return connectedOnly(this, NONCE);
+        }
+        get farNonce() {
+            return connectedOnly(this, NONCE);
+        }
+        get unconnectedPeerStreams() {
+            return connectedOnly(this, s.rt.array([]));
+        }
+        static get defaultObjectEncoding() {
+            return defaultEncoding;
+        }
+        static set defaultObjectEncoding(v) {
+            defaultEncoding = s.rt.toUint(v);
+        }
+    }
+    /**
+     * Closed, as Flash reports it: a local connection's CLOSED; for a kept
+     * URI, CLOSED and then a status of empty strings, as the corpus's
+     * `netconnection_close` has it; nothing for no connection.
+     */
+    const close = (o) => {
+        const uri = o.$uri ?? null;
+        const wasConnected = o.$connected ?? false;
+        o.$connected = false;
+        o.$uri = null;
+        if (wasConnected) {
+            status(o, ["code", "NetConnection.Connect.Closed", "level", "status"]);
+        }
+        else if (uri !== null) {
+            status(o, ["code", "NetConnection.Connect.Closed", "level", "status"]);
+            status(o, ["code", "", "description", "", "details", "", "level", "status"]);
+        }
+    };
+    class ResponderNatives {
+        "flash.net:Responder::ctor"(result, status) {
+            this.$result = result;
+            this.$status = status;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.net::NetConnection", NetConnectionNatives);
+    avm2.registerNativeClass(natives, "flash.net::Responder", ResponderNatives);
+    return natives;
+}