@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,146 @@
+// flash.net.URLStream: bytes fetched by the host, read through ByteArray's
+// DataInput implementation and delivered to scripts on a later frame.
+import { avm2 } from "../../../../runtime/index.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+export function urlStreamNatives(s) {
+    const natives = {};
+    const bufferOf = (stream) => (stream.$buffer ??= s.rt.construct(s.rt.classNamed("flash.utils::ByteArray")));
+    const read = (stream, method, ...args) => s.rt.callProperty(bufferOf(stream), s.rt.publicName(method), ...args);
+    const stop = (stream) => {
+        stream.$generation = (stream.$generation ?? 0) + 1;
+        stream.$abort?.abort();
+        stream.$abort = null;
+        stream.$connected = false;
+    };
+    class URLStreamNatives {
+        load(request) {
+            if (request === null || request === undefined) {
+                throw s.rt.error("TypeError", 2007, "request");
+            }
+            this.$abort?.abort();
+            const generation = (this.$generation ?? 0) + 1;
+            this.$generation = generation;
+            this.$connected = false;
+            this.$buffer = undefined;
+            const abort = new AbortController();
+            this.$abort = abort;
+            const source = request;
+            s.loads.requestBytes(source, abort.signal, ({ bytes, status, local }, url) => {
+                if (this.$generation !== generation) {
+                    return;
+                }
+                this.$abort = null;
+                if (bytes === null) {
+                    this.$connected = false;
+                    dispatchEvent(s, this, s.httpStatus(status));
+                    if (this.$generation !== generation) {
+                        return;
+                    }
+                    dispatchEvent(s, this, s.rt.construct(s.rt.classNamed("flash.events::IOErrorEvent"), "ioError", false, false, s.loads.streamError(url, local)));
+                    return;
+                }
+                this.$connected = true;
+                dispatchEvent(s, this, s.event("open"));
+                if (this.$generation !== generation) {
+                    return;
+                }
+                const buffer = avm2.bytesOf(s.rt, bufferOf(this));
+                buffer.write(bytes);
+                buffer.position = 0;
+                dispatchEvent(s, this, s.rt.construct(s.rt.classNamed("flash.events::ProgressEvent"), "progress", false, false, bytes.length, bytes.length));
+                if (this.$generation !== generation) {
+                    return;
+                }
+                dispatchEvent(s, this, s.httpStatus(status));
+                if (this.$generation !== generation) {
+                    return;
+                }
+                dispatchEvent(s, this, s.event("complete"));
+            });
+        }
+        get connected() {
+            return this.$connected ?? false;
+        }
+        get bytesAvailable() {
+            return avm2.bytesOf(s.rt, bufferOf(this)).available;
+        }
+        close() {
+            if (!this.$abort && !this.$connected) {
+                throw s.rt.error("flash.errors::IOError", 2029);
+            }
+            stop(this);
+        }
+        stop() {
+            stop(this);
+        }
+        readBytes(bytes, offset = 0, length = 0) {
+            read(this, "readBytes", bytes, offset, length);
+        }
+        readBoolean() {
+            return read(this, "readBoolean");
+        }
+        readByte() {
+            return read(this, "readByte");
+        }
+        readUnsignedByte() {
+            return read(this, "readUnsignedByte");
+        }
+        readShort() {
+            return read(this, "readShort");
+        }
+        readUnsignedShort() {
+            return read(this, "readUnsignedShort");
+        }
+        readInt() {
+            return read(this, "readInt");
+        }
+        readUnsignedInt() {
+            return read(this, "readUnsignedInt");
+        }
+        readFloat() {
+            return read(this, "readFloat");
+        }
+        readDouble() {
+            return read(this, "readDouble");
+        }
+        readUTF() {
+            return read(this, "readUTF");
+        }
+        readUTFBytes(length) {
+            return read(this, "readUTFBytes", length);
+        }
+        readMultiByte(length, charset) {
+            return read(this, "readMultiByte", length, charset);
+        }
+        readObject() {
+            return read(this, "readObject");
+        }
+        get objectEncoding() {
+            return s.rt.getProperty(bufferOf(this), s.rt.publicName("objectEncoding"));
+        }
+        set objectEncoding(value) {
+            s.rt.setProperty(bufferOf(this), s.rt.publicName("objectEncoding"), value);
+        }
+        get endian() {
+            return s.rt.getProperty(bufferOf(this), s.rt.publicName("endian"));
+        }
+        set endian(value) {
+            s.rt.setProperty(bufferOf(this), s.rt.publicName("endian"), value);
+        }
+        get diskCacheEnabled() {
+            return false;
+        }
+        get position() {
+            return avm2.bytesOf(s.rt, bufferOf(this)).position;
+        }
+        set position(value) {
+            // As ByteArray's setter: a uint32 of its own, not toUint's (see Bytes).
+            avm2.bytesOf(s.rt, bufferOf(this)).position = s.rt.toUint(value) >>> 0;
+        }
+        get length() {
+            return avm2.bytesOf(s.rt, bufferOf(this)).length;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.net::URLStream", URLStreamNatives);
+    return natives;
+}

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

@@ -0,0 +1,14 @@
+// flash.net.XMLSocket: AS3 over a Socket (as3/playerglobal); connect with a
+// null host asks here for the SWF's own domain.
+import { avm2 } from "../../../../runtime/index.js";
+import { swfDomain } from "./LocalConnection.js";
+export function xmlSocketNatives(s) {
+    const natives = {};
+    class XMLSocketNatives {
+        get "flash.net:XMLSocket::domain"() {
+            return swfDomain(s.url);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.net::XMLSocket", XMLSocketNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/net/local-modern.js

@@ -0,0 +1,142 @@
+// AS3 peers retain AMF3's ByteArray, XML, Vector and alias semantics.
+// Reuse the runtime's codec through its public API, with a bounded output
+// and scratch buffers leased separately for reentrant serialization.
+import { avm2 } from "../../../../runtime/index.js";
+import { MAX_DEPTH } from "../../../avm1/amf.js";
+import { LOCAL_MESSAGE_LIMIT } from "../../../localconnection.js";
+class MessageBytes extends avm2.Bytes {
+    setLength(length, fromSetter = false) {
+        if (length > LOCAL_MESSAGE_LIMIT) {
+            throw new RangeError("LocalConnection message too large");
+        }
+        super.setLength(length, fromSetter);
+    }
+    write(source, offset = 0, count = source.length) {
+        if (count > LOCAL_MESSAGE_LIMIT - this.position) {
+            throw new RangeError("LocalConnection message too large");
+        }
+        super.write(source, offset, count);
+    }
+}
+class MessageWriter extends avm2.Amf3Writer {
+    runtime;
+    depth = 0;
+    escaped = false;
+    externalizable;
+    constructor(runtime, bytes) {
+        super(runtime, bytes);
+        this.runtime = runtime;
+        this.externalizable = runtime.classNamed("flash.utils::IExternalizable");
+    }
+    string(value) {
+        if (value.length > LOCAL_MESSAGE_LIMIT - this.bytes.position) {
+            throw new RangeError("LocalConnection message too large");
+        }
+        super.string(value);
+    }
+    value(value) {
+        if (value?.$traits?.isSubtypeOf(this.externalizable.$it) ||
+            this.runtime.dynamicPropertyWriter) {
+            this.escaped = true;
+        }
+        if (this.depth >= MAX_DEPTH || value?.$bytes?.length > LOCAL_MESSAGE_LIMIT) {
+            throw new RangeError("LocalConnection message too large");
+        }
+        if (value?.$node) {
+            const text = this.runtime.callProperty(value, this.runtime.publicName("toXMLString"));
+            if (text.length > LOCAL_MESSAGE_LIMIT) {
+                throw new RangeError("LocalConnection message too large");
+            }
+        }
+        this.depth++;
+        try {
+            super.value(value);
+        }
+        finally {
+            this.depth--;
+        }
+    }
+}
+const writers = new WeakMap();
+const readers = new WeakMap();
+const empty = new Uint8Array(0);
+const emptyView = new DataView(empty.buffer);
+class MessageReader extends avm2.Amf3Reader {
+    escaped = false;
+    externalizable;
+    constructor(rt, bytes) {
+        super(rt, bytes);
+        this.externalizable = rt.classNamed("flash.utils::IExternalizable");
+    }
+    value() {
+        try {
+            const value = super.value();
+            if (value?.$traits?.isSubtypeOf(this.externalizable.$it)) {
+                this.escaped = true;
+            }
+            return value;
+        }
+        catch (error) {
+            this.escaped = true;
+            throw error;
+        }
+    }
+}
+export function writeModernValues(rt, args) {
+    let pool = writers.get(rt);
+    if (!pool) {
+        pool = [];
+        writers.set(rt, pool);
+    }
+    let bytes = pool.pop();
+    if (!bytes) {
+        const owner = rt.construct(rt.classNamed("flash.utils::ByteArray"));
+        bytes = new MessageBytes(rt, owner);
+        owner.$bytes = bytes;
+    }
+    const writer = new MessageWriter(rt, bytes);
+    try {
+        writer.value(rt.newArray(args));
+        return bytes.buffer.slice(0, bytes.length);
+    }
+    finally {
+        // An externalizable may retain its ObjectOutput; that stream must stay independent.
+        if (!writer.escaped) {
+            bytes.position = 0;
+            bytes.setLength(0);
+            if (pool.length < 2) {
+                pool.push(bytes);
+            }
+        }
+    }
+}
+export function readModernValues(rt, data) {
+    let pool = readers.get(rt);
+    if (!pool) {
+        pool = [];
+        readers.set(rt, pool);
+    }
+    let bytes = pool.pop();
+    if (!bytes) {
+        const owner = rt.construct(rt.classNamed("flash.utils::ByteArray"));
+        bytes = avm2.bytesOf(rt, owner);
+    }
+    bytes.buffer = data;
+    bytes.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    bytes.length = data.length;
+    const reader = new MessageReader(rt, bytes);
+    try {
+        return reader.value().$a;
+    }
+    finally {
+        if (!reader.escaped) {
+            bytes.buffer = empty;
+            bytes.view = emptyView;
+            bytes.position = 0;
+            bytes.length = 0;
+            if (pool.length < 2) {
+                pool.push(bytes);
+            }
+        }
+    }
+}

package/dist/thread/player/playerglobal/flash/net/local-values.js

@@ -0,0 +1,217 @@
+// AMF0 values crossing LocalConnection's VM boundary. The AS2 codec owns
+// the byte format; this adapter creates and reads AS3 objects without
+// retaining either VM's live arguments in a queued message.
+import { avm2 } from "../../../../runtime/index.js";
+import * as A from "../../../avm1/amf.js";
+import { LOCAL_MESSAGE_LIMIT } from "../../../localconnection.js";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export function writeLocalValues(rt, args) {
+    // The original AMF3 payload is already bounded; AMF0 can expand small integers.
+    const out = new A.Writer(() => null, 8, null, null);
+    const references = new Map();
+    let next = 1;
+    const write = (value, depth) => {
+        if (depth >= A.MAX_DEPTH - 2) {
+            out.bytes(A.UNDEFINED);
+            return;
+        }
+        if (value instanceof avm2.FloatValue) {
+            out.value(value.value);
+            return;
+        }
+        if (value === null || (typeof value !== "object" && typeof value !== "function")) {
+            out.value(value);
+            return;
+        }
+        if (value.$display) {
+            out.bytes(A.UNDEFINED);
+            return;
+        }
+        const traits = rt.traitsOf(value);
+        if ("$time" in value) {
+            out.bytes(A.DATE);
+            out.double(value.$time);
+            out.u16(0);
+            return;
+        }
+        if (traits.name === "XML" || traits.name === "flash.xml::XMLDocument") {
+            const text = rt.toString(rt.callProperty(value, rt.publicName(traits.name === "XML" ? "toXMLString" : "toString")));
+            if (text.length > LOCAL_MESSAGE_LIMIT) {
+                throw new RangeError("LocalConnection message too large");
+            }
+            const bytes = encoder.encode(text);
+            out.bytes(A.XML);
+            out.u32(bytes.length);
+            out.push(bytes);
+            return;
+        }
+        const seen = references.get(value);
+        if (seen !== undefined) {
+            out.bytes(A.REFERENCE);
+            out.u16(seen);
+            return;
+        }
+        references.set(value, next++);
+        if (value.$a) {
+            const array = value.$a;
+            const properties = value.$d;
+            if (properties?.size) {
+                out.bytes(A.ECMA_ARRAY);
+                out.u32(array.length);
+                for (const key of Object.keys(array)) {
+                    out.name(key);
+                    write(array[Number(key)], depth + 1);
+                }
+                for (const [key, field] of properties) {
+                    out.name(key);
+                    write(field, depth + 1);
+                }
+                out.bytes(0, 0, A.OBJECT_END);
+                return;
+            }
+            if (array.length > LOCAL_MESSAGE_LIMIT) {
+                throw new RangeError("LocalConnection message too large");
+            }
+            out.bytes(A.STRICT_ARRAY);
+            out.u32(array.length);
+            for (let i = 0; i < array.length; i++) {
+                write(array[i], depth + 1);
+            }
+            return;
+        }
+        const alias = rt.aliasOf(traits);
+        out.bytes(alias === "" ? A.OBJECT : A.TYPED_OBJECT);
+        if (alias !== "") {
+            out.name(alias);
+        }
+        const names = new Set();
+        for (let t = traits; t !== null; t = t.base) {
+            for (const [name, bindings] of t.bindings) {
+                for (const binding of bindings) {
+                    if (binding.ns.kind === avm2.publicNs.kind &&
+                        binding.ns.uri === "" &&
+                        (binding.value & 7) === 2) {
+                        names.add(name);
+                    }
+                }
+            }
+        }
+        for (const name of value.$d?.keys() ?? []) {
+            names.add(name);
+        }
+        for (const name of names) {
+            const field = rt.getProperty(value, rt.publicName(name));
+            if (typeof field === "function" || (field && typeof field === "object" && field.$f)) {
+                continue;
+            }
+            out.name(name);
+            write(field, depth + 1);
+        }
+        out.bytes(0, 0, A.OBJECT_END);
+    };
+    out.bytes(A.STRICT_ARRAY);
+    out.u32(args.length);
+    for (const value of args) {
+        write(value, 0);
+    }
+    return out.finish();
+}
+export function readLocalValues(rt, bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const references = [];
+    let at = 0;
+    const u16 = () => {
+        const n = view.getUint16(at);
+        at += 2;
+        return n;
+    };
+    const u32 = () => {
+        const n = view.getUint32(at);
+        at += 4;
+        return n;
+    };
+    const utf = (length) => {
+        if (length > bytes.length - at) {
+            throw new RangeError("LocalConnection message ended early");
+        }
+        const text = decoder.decode(bytes.subarray(at, at + length));
+        at += length;
+        return text;
+    };
+    const name = () => utf(u16());
+    const read = (depth) => {
+        if (depth >= A.MAX_DEPTH) {
+            throw new RangeError("LocalConnection arguments nested too deeply");
+        }
+        const marker = bytes[at++];
+        switch (marker) {
+            case A.NUMBER: {
+                const n = view.getFloat64(at);
+                at += 8;
+                return n;
+            }
+            case A.BOOLEAN:
+                return bytes[at++] !== 0;
+            case A.STRING:
+                return name();
+            case A.LONG_STRING:
+                return utf(u32());
+            case A.NULL:
+                return null;
+            case A.UNDEFINED:
+            case A.UNSUPPORTED:
+                return undefined;
+            case A.REFERENCE:
+                return references[u16()];
+            case A.DATE: {
+                const time = view.getFloat64(at);
+                at += 10;
+                return rt.construct(rt.classNamed("Date"), time);
+            }
+            case A.XML:
+                return rt.construct(rt.classNamed("flash.xml::XMLDocument"), utf(u32()));
+            case A.STRICT_ARRAY: {
+                const count = u32();
+                if (count > bytes.length - at) {
+                    throw new RangeError("LocalConnection message ended early");
+                }
+                const result = rt.newArray([]);
+                references.push(result);
+                for (let i = 0; i < count; i++) {
+                    result.$a.push(read(depth + 1));
+                }
+                return result;
+            }
+            case A.OBJECT:
+            case A.TYPED_OBJECT:
+            case A.ECMA_ARRAY: {
+                let result;
+                if (marker === A.TYPED_OBJECT) {
+                    result = rt.allocate(rt.classByAlias(name(), true)) ?? rt.newObject([]);
+                }
+                else {
+                    result = marker === A.ECMA_ARRAY ? rt.newArray([]) : rt.newObject([]);
+                }
+                const length = marker === A.ECMA_ARRAY ? u32() : 0;
+                references.push(result);
+                for (;;) {
+                    const key = name();
+                    if (key === "" && bytes[at] === A.OBJECT_END) {
+                        at++;
+                        break;
+                    }
+                    rt.setProperty(result, rt.publicName(key), read(depth + 1));
+                }
+                if (marker === A.ECMA_ARRAY && length > result.$a.length) {
+                    result.$a.length = length;
+                }
+                return result;
+            }
+            default:
+                throw new RangeError("Invalid LocalConnection AMF0 marker");
+        }
+    };
+    const result = read(0);
+    return result.$a;
+}

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

@@ -0,0 +1,29 @@
+export function navigateNatives(s) {
+    const checked = (rt, request) => {
+        if (request === null || request === undefined) {
+            throw rt.error("TypeError", 2007, "request");
+        }
+        if (request.$url === null || request.$url === undefined) {
+            throw rt.error("TypeError", 2007, "url");
+        }
+        return request;
+    };
+    return {
+        "flash.net::navigateToURL": (rt) => (request, window) => {
+            const page = checked(rt, request);
+            const name = window === null || window === undefined ? null : rt.toString(window);
+            s.loads.navigateTo(page, name === null ? null : target(name));
+        },
+        "flash.net::sendToURL": (rt) => (request) => {
+            s.loads.sendTo(checked(rt, request));
+        },
+    };
+}
+/**
+ * "blank" in any case, with or without its underscore, as "_blank", and any
+ * other name as given, as Ruffle's navigateToURL_target_normalize records
+ * Flash Player doing.
+ */
+function target(name) {
+    return /^_?blank$/i.test(name) ? "_blank" : name;
+}

package/dist/thread/player/playerglobal/flash/profiler/Telemetry.js

@@ -0,0 +1,25 @@
+// flash.profiler.Telemetry: no profiler is ever connected, so metrics go
+// nowhere and no command handler is called. Crossbridge sends metrics as it
+// runs.
+import { avm2 } from "../../../../runtime/index.js";
+export function telemetryNatives() {
+    const natives = {};
+    class TelemetryNatives {
+        static get connected() {
+            return false;
+        }
+        static get spanMarker() {
+            return 0;
+        }
+        static sendMetric(_name, _value) { }
+        static sendSpanMetric(_name, _start, _value) { }
+        static registerCommandHandler(_name, _f) {
+            return false;
+        }
+        static unregisterCommandHandler(_name) {
+            return false;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.profiler::Telemetry", TelemetryNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/sensors/Accelerometer.js

@@ -0,0 +1,12 @@
+// flash.sensors.Accelerometer: none, as on a desktop's Flash Player.
+import { avm2 } from "../../../../runtime/index.js";
+export function accelerometerNatives() {
+    const natives = {};
+    class AccelerometerNatives {
+        static get isSupported() {
+            return false;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.sensors::Accelerometer", AccelerometerNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/system/ApplicationDomain.js

@@ -0,0 +1,69 @@
+// flash.system.ApplicationDomain: one of the runtime's application
+// domains (avm2.Domain), kept on the object as $domain: a child's
+// definitions after its parent's, its own invisible to its parent and to
+// its siblings. The root is Flash's system domain, the player's classes,
+// and the main SWF's is its child (Scripting.mainDomain), so `new
+// ApplicationDomain(null)` sees none of the main SWF's. Its domain memory
+// is the runtime's one, as avmshell's Domain's is.
+import { avm2 } from "../../../../runtime/index.js";
+import { definitionNamed } from "../../toplevel.js";
+export function applicationDomainNatives(s) {
+    const natives = {};
+    const domainOf = (o) => o.$domain ?? s.mainDomain;
+    const definitionOf = (o, name) => definitionNamed(s.rt, String(name), (q) => s.rt.definitionNamed(q, domainOf(o)));
+    // Not defined, as Flash has it, for a name whose script throws as it
+    // runs too: a script that threw runs again, as for getDefinition.
+    const has = (o, name) => {
+        if (name === null || name === undefined) {
+            return false;
+        }
+        // A Vector of a definition that is not a class is defined, though
+        // getDefinition refuses it; an error, the requested name's or one an
+        // initializer the lookup ran threw, leaves the name not defined.
+        try {
+            definitionNamed(s.rt, String(name), (q) => s.rt.definitionNamed(q, domainOf(o)), () => true);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    class ApplicationDomainNatives {
+        // The domain of the code that asks, as Flash's.
+        static get currentDomain() {
+            return s.code.applicationDomainOf(s.code.codeDomain());
+        }
+        static get MIN_DOMAIN_MEMORY_LENGTH() {
+            return avm2.GLOBAL_MEMORY_MIN_SIZE;
+        }
+        get domainMemory() {
+            return s.rt.memoryProvider;
+        }
+        set domainMemory(v) {
+            avm2.setDomainMemory(s.rt, v);
+        }
+        "flash.system:ApplicationDomain::ctor"(parent) {
+            this.$domain = s.rt.childDomain(parent ? domainOf(parent) : s.rt.root);
+        }
+        // The system domain, the root, is no script's to see: the main SWF's has no parent.
+        get parentDomain() {
+            const parent = domainOf(this).parent;
+            return parent && parent !== s.rt.root ? s.code.applicationDomainOf(parent) : null;
+        }
+        getQualifiedDefinitionNames() {
+            const cls = s.rt.resolve(s.rt.vector("String"));
+            const names = cls.$it.instance();
+            names.$a = s.rt.definitionNames(domainOf(this));
+            return names;
+        }
+        // As Flash's: an initializer's error comes through (Runtime.definitionNamed).
+        getDefinition(name) {
+            return definitionOf(this, name);
+        }
+        hasDefinition(name) {
+            return has(this, name);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.system::ApplicationDomain", ApplicationDomainNatives);
+    return natives;
+}