@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,208 @@
+// LoadVars, AS1 and AS2's, and the loading it shares with XML, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) core/src/avm1/globals/load_vars.rs
+// and core/src/loader.rs (load_form_into_load_vars) have them: MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+// A load sets the object's hidden _bytesLoaded, _bytesTotal and loaded
+// first; once the answer has come, between frames, it calls onHTTPStatus
+// with its status, then onData with its text, or with undefined where it
+// failed or was empty. LoadVars' onData decodes the text's variables onto
+// the object and calls onLoad.
+import { avm1 } from "../../../runtime/index.js";
+import { textFor } from "../net.js";
+const HIDDEN = avm1.DONT_ENUM | avm1.DONT_DELETE;
+const FORM = "application/x-www-form-urlencoded";
+/** `name` on `o` as `value`: defined hidden where it has none, else set as a script would. */
+function setHidden(o, name, value, version) {
+    if (avm1.has(o, name, version)) {
+        avm1.set(o, name, value, version);
+    }
+    else {
+        o.define(name, value, HIDDEN);
+    }
+}
+/** The text of a load's answer as Flash reads it: UTF-8, a BOM dropped, bad bytes replaced. */
+function textOf(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+/** `request` loaded for `target`, by LoadVars' and XML's rules (above). */
+export function startLoad(host, target, request, version, httpStatus = true) {
+    setHidden(target, "_bytesLoaded", 0, version);
+    setHidden(target, "_bytesTotal", undefined, version);
+    setHidden(target, "loaded", false, version);
+    host.net.fetch(request, (result) => {
+        const v = host.version;
+        const length = result.bytes?.length ?? 0;
+        if (result.bytes !== null) {
+            avm1.set(target, "_bytesTotal", length, v);
+            if (length > 0) {
+                avm1.set(target, "_bytesLoaded", length, v);
+            }
+        }
+        if (httpStatus) {
+            host.callback(target, "onHTTPStatus", [result.status]);
+        }
+        const data = result.bytes !== null && length > 0 ? textFor(textOf(result.bytes), v) : undefined;
+        host.callback(target, "onData", [data]);
+    });
+}
+/**
+ * URL-encoded variables, `a=1&b=2`, as name and value pairs in order,
+ * empty parts left out, each unescaped as unescape does (adl: `%zz` is `z`).
+ */
+export function parseForm(text, version) {
+    const pairs = [];
+    for (const part of text.split("&")) {
+        if (part === "") {
+            continue;
+        }
+        const eq = part.indexOf("=");
+        const name = eq < 0 ? part : part.slice(0, eq);
+        const value = eq < 0 ? "" : part.slice(eq + 1);
+        pairs.push([avm1.unescapeAvm1(name, version), avm1.unescapeAvm1(value, version)]);
+    }
+    return pairs;
+}
+/**
+ * `o`'s variables as for..in lists them, each as a string; one whose
+ * getter throws is "undefined", as a form of them sends it.
+ */
+export function formVars(o, version) {
+    const vars = [];
+    for (const name of avm1.keys(o, version)) {
+        let text;
+        try {
+            text = avm1.stringOf(avm1.get(o, name, version), version);
+        }
+        catch (error) {
+            if (!(error instanceof avm1.Avm1Throw)) {
+                throw error;
+            }
+            text = "undefined";
+        }
+        vars.push([name, text]);
+    }
+    return vars;
+}
+/**
+ * A request for `url` with `vars`: in the query for a GET, after a `&`
+ * where the URL has a query already, or in a POST's body as a form's.
+ */
+export function formRequest(url, method, vars, contentType = FORM, headers = []) {
+    const query = new URLSearchParams(vars).toString();
+    if (method === "GET") {
+        return {
+            url: `${url}${url.includes("?") ? "&" : "?"}${query}`,
+            method,
+            headers: [],
+            body: null,
+        };
+    }
+    return {
+        url,
+        method,
+        headers: [...headers, ["Content-Type", contentType]],
+        body: new TextEncoder().encode(query),
+    };
+}
+/** A method's name, "GET" in any case for a GET; anything else a POST. */
+function methodOf(value, version) {
+    return avm1.stringOf(value, version).toUpperCase() === "GET" ? "GET" : "POST";
+}
+/** The headers addRequestHeader gave a LoadVars or an XML, name and value. */
+const requestHeaders = new WeakMap();
+export function headersOf(o) {
+    return requestHeaders.get(o) ?? [];
+}
+/** addRequestHeader, LoadVars' and XML's: a name and a value, or an array of names and values. */
+export function addRequestHeader(self, args, version) {
+    const headers = requestHeaders.get(self) ?? [];
+    requestHeaders.set(self, headers);
+    const add = (name, value) => {
+        if (typeof name === "string" && typeof value === "string") {
+            headers.push([name, value]);
+        }
+    };
+    const list = args[0];
+    if (list instanceof avm1.Avm1Object && list.array) {
+        const length = avm1.toNumber(avm1.get(list, "length", version), version);
+        for (let i = 0; i + 1 < length; i += 2) {
+            add(avm1.get(list, String(i), version), avm1.get(list, String(i + 1), version));
+        }
+    }
+    else {
+        add(args[0], args[1]);
+    }
+    return undefined;
+}
+/** `self[name](...args)` where it is a function. */
+function call(self, name, args, v) {
+    return avm1.invoke(avm1.get(self, name, v), self, args, v);
+}
+const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE;
+/** `_global.LoadVars`. */
+export function loadVarsClass(host) {
+    const realm = host.realm;
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self) => self, () => undefined);
+    const method = (name, fn) => proto.define(name, realm.method(fn), FIXED);
+    const contentType = (self, v) => avm1.stringOf(avm1.get(self, "contentType", v), v);
+    method("load", (self, args, v) => {
+        if (args.length === 0) {
+            return false;
+        }
+        startLoad(host, self, { url: avm1.stringOf(args[0], v), method: "GET", headers: [], body: null }, v);
+        return true;
+    });
+    method("send", (self, args, v) => {
+        if (args.length === 0) {
+            return false;
+        }
+        const url = avm1.stringOf(args[0], v);
+        const window = args.length > 1 ? avm1.stringOf(args[1], v) : "";
+        host.navigate(url, window, { method: methodOf(args[2], v), vars: formVars(self, v) });
+        return true;
+    });
+    method("sendAndLoad", (self, args, v) => {
+        const url = avm1.stringOf(args[0], v);
+        const target = args[1];
+        if (!(target instanceof avm1.Avm1Object)) {
+            return false;
+        }
+        const request = formRequest(url, methodOf(args[2], v), formVars(self, v), contentType(self, v), headersOf(self));
+        startLoad(host, target, request, v);
+        return true;
+    });
+    method("decode", (self, args, v) => {
+        if (args.length === 0) {
+            return false;
+        }
+        for (const [name, value] of parseForm(avm1.stringOf(args[0], v), v)) {
+            avm1.set(self, name, value, v);
+        }
+        return undefined;
+    });
+    method("getBytesLoaded", (self, _, v) => avm1.get(self, "_bytesLoaded", v));
+    method("getBytesTotal", (self, _, v) => avm1.get(self, "_bytesTotal", v));
+    method("toString", (self, _, v) => {
+        const parts = [];
+        for (const name of avm1.keys(self, v)) {
+            const value = avm1.stringOf(avm1.get(self, name, v), v);
+            parts.push(`${avm1.escapeAvm1(name, v)}=${avm1.escapeAvm1(value, v)}`);
+        }
+        return parts.join("&");
+    });
+    proto.define("contentType", FORM, FIXED);
+    method("onLoad", () => undefined);
+    method("onData", (self, args, v) => {
+        const data = args[0];
+        const success = data !== undefined && data !== null;
+        if (success) {
+            call(self, "decode", [data], v);
+            avm1.set(self, "loaded", true, v);
+        }
+        call(self, "onLoad", [success], v);
+        return undefined;
+    });
+    method("addRequestHeader", (self, args, v) => addRequestHeader(self, args, v));
+    return constr;
+}

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

@@ -0,0 +1,92 @@
+// AS2's LocalConnection. Argument copies use the player's AMF0 codec;
+// names, status ordering and argument validation are checked against adl.
+import { avm1 } from "../../../runtime/index.js";
+import { LOCAL_MESSAGE_LIMIT, localDomain, localMethodAllowed, } from "../../localconnection.js";
+import { Reader, Writer } from "../amf.js";
+import { serialize } from "./XMLNode.js";
+export function localConnectionClass(movie, xml, nodes) {
+    const realm = movie.realm;
+    const states = new WeakMap();
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self) => {
+        const origin = localDomain(movie.currentSwf().url);
+        const endpoint = {
+            owner: movie,
+            ...origin,
+            key: null,
+            alive: () => !movie.halted && !movie.fileLifetime.signal.aborted,
+            allows: (sender) => {
+                const v = movie.version;
+                const insecure = endpoint.secure && !sender.secure && v >= 7;
+                const name = insecure ? "allowInsecureDomain" : "allowDomain";
+                return avm1.toBoolean(movie.localInvoke(self, name, [sender.domain], !insecure && endpoint.domain === sender.domain), v);
+            },
+            defer: (deliver) => movie.net.defer(deliver),
+            status: (success) => {
+                const info = realm.newObject(movie.version);
+                info.define("level", success ? "status" : "error", 0);
+                movie.localInvoke(self, "onStatus", [info]);
+            },
+            receive: (method, message) => {
+                const bytes = message.encoding === 0 ? message.bytes : message.legacy();
+                const v = movie.version;
+                const values = new Reader(bytes, realm, v, false, undefined, (text) => realm.construct(xml, [text], v)).value();
+                const args = [];
+                if (values instanceof avm1.Avm1Object) {
+                    const count = avm1.toNumber(avm1.get(values, "length", v), v) >>> 0;
+                    for (let i = 0; i < count; i++) {
+                        args.push(avm1.get(values, String(i), v));
+                    }
+                }
+                movie.localInvoke(self, method, args);
+            },
+        };
+        states.set(self, endpoint);
+        return self;
+    }, () => undefined);
+    const method = (name, native) => proto.define(name, realm.method(native), avm1.DONT_ENUM | avm1.DONT_DELETE);
+    method("connect", (self, args) => {
+        const state = states.get(self);
+        return typeof args[0] !== "string"
+            ? false
+            : state === undefined
+                ? undefined
+                : movie.localConnections.connect(state, args[0]);
+    });
+    method("close", (self) => {
+        const state = states.get(self);
+        return state !== undefined && movie.localConnections.close(state);
+    });
+    method("domain", () => localDomain(movie.currentSwf().url).domain);
+    method("send", (self, args, v) => {
+        const name = args[0], target = args[1], state = states.get(self);
+        if (typeof name !== "string" ||
+            name === "" ||
+            typeof target !== "string" ||
+            !localMethodAllowed(target) ||
+            !state) {
+            return false;
+        }
+        let bytes;
+        try {
+            const writer = new Writer((c) => movie.registeredName(c), v, null, {
+                first: 1,
+                xmlText: (o) => {
+                    const node = nodes.nodeOf(o);
+                    return node === null ? null : serialize(node, v);
+                },
+            }, LOCAL_MESSAGE_LIMIT);
+            writer.arguments(args.slice(2));
+            bytes = writer.finish();
+        }
+        catch (error) {
+            if (error instanceof RangeError) {
+                return false;
+            }
+            throw error;
+        }
+        movie.localConnections.send(state, name, target, { encoding: 0, bytes });
+        return true;
+    });
+    return constr;
+}