@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,299 @@
+// flash.net.SharedObject, the local kind: its data kept in the host's
+// storage (Scripting.storage) as Flash's .sol file has it, written when it
+// is flushed, read when getLocal first asks for it, one object for a name
+// and path. Remote ones, getRemote's, are not here.
+//
+// A .sol file: 0x00BF, the length of what follows, "TCSO", 00 04 00 00 00
+// 00, the name (u16 length, UTF-8), the AMF version as a u32 (0 or 3),
+// then each of the data's properties: its name (AMF3: a string's U29
+// header; AMF0: u16 length), its value as writeObject writes it, and a 0.
+// Flash's size is the file's, 0 for none, as the shared-objects case has it.
+import { avm2 } from "../../../../runtime/index.js";
+// SharedObject's private invoke codes, as its AS3 numbers them.
+const FLUSH = 2;
+const CLOSE = 3;
+const GET_SIZE = 4;
+const CLEAR = 6;
+/** What a name may not hold, as Flash refuses it (Error #2134); % it allows. */
+const BAD_NAME = /[~&\\;:"',<>?#\s]/;
+export function sharedObjectNatives(s) {
+    const natives = {};
+    /** The shared objects getLocal made, by key: one for each, as Flash's. */
+    const open = new Map();
+    let defaultEncoding = 3;
+    let preventBackup = false;
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    const byteArray = (encoding) => {
+        const array = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray"));
+        s.rt.setProperty(array, avm2.qname(avm2.publicNs, "objectEncoding"), encoding);
+        return array;
+    };
+    /** What `o` serializes to now, for destroy to tell a change by; null where it cannot. */
+    const saved = (o) => {
+        try {
+            return serialize(o);
+        }
+        catch {
+            return null;
+        }
+    };
+    /** Write `o`'s .sol file, or remove it for no data: false where storage refuses, as a full quota, which flush reports as #2130. */
+    const write = (o) => {
+        const file = serialize(o);
+        try {
+            if (file.length) {
+                s.storage.set(o.$key, file);
+            }
+            else {
+                s.storage.remove(o.$key);
+            }
+        }
+        catch {
+            return false;
+        }
+        o.$saved = file;
+        return true;
+    };
+    /**
+     * The .sol file of `o`'s data, in its encoding; none, empty, for no
+     * properties. AMF0 is the runtime's to write, which has none yet.
+     */
+    const serialize = (o) => {
+        if (o.$encoding !== 3) {
+            throw s.rt.unsupported("an AMF0 SharedObject");
+        }
+        // Chunks joined once at the end: a value can be large enough that
+        // spreading its bytes into one call would overflow the stack.
+        const chunks = [];
+        for (const [key, value] of o.$data.$d ?? new Map()) {
+            const name = encoder.encode(String(key));
+            chunks.push(u29((name.length << 1) | 1), name);
+            const array = byteArray(o.$encoding);
+            s.rt.callProperty(array, avm2.qname(avm2.publicNs, "writeObject"), value);
+            const b = avm2.bytesOf(s.rt, array);
+            chunks.push(b.buffer.subarray(0, b.length), END);
+        }
+        if (chunks.length === 0) {
+            return new Uint8Array(0);
+        }
+        const name = encoder.encode(o.$name);
+        const header = new Uint8Array(6 + 10 + 2 + name.length + 4);
+        header.set([0x00, 0xbf], 0);
+        header.set([0x54, 0x43, 0x53, 0x4f, 0, 4, 0, 0, 0, 0], 6);
+        header.set([name.length >> 8, name.length & 0xff], 16);
+        header.set(name, 18);
+        header[header.length - 1] = 3;
+        let n = header.length;
+        for (const chunk of chunks) {
+            n += chunk.length;
+        }
+        const file = new Uint8Array(n);
+        file.set(header);
+        new DataView(file.buffer).setUint32(2, n - 6);
+        let at = header.length;
+        for (const chunk of chunks) {
+            file.set(chunk, at);
+            at += chunk.length;
+        }
+        return file;
+    };
+    /** The data a .sol file holds, or null for one it cannot read. */
+    const deserialize = (bytes) => {
+        if (bytes.length < 18 || bytes[0] !== 0x00 || bytes[1] !== 0xbf) {
+            return null;
+        }
+        let at = 16;
+        const nameLength = (bytes[at] << 8) | bytes[at + 1];
+        at += 2 + nameLength;
+        const encoding = bytes[at + 3] === 3 ? 3 : 0;
+        at += 4;
+        const array = byteArray(encoding);
+        const b = avm2.bytesOf(s.rt, array);
+        b.write(bytes);
+        const data = s.rt.newObject([]);
+        try {
+            while (at < bytes.length) {
+                let length;
+                if (encoding === 3) {
+                    const [n, next] = readU29(bytes, at);
+                    length = n >> 1;
+                    at = next;
+                }
+                else {
+                    length = (bytes[at] << 8) | bytes[at + 1];
+                    at += 2;
+                }
+                const key = decoder.decode(bytes.subarray(at, at + length));
+                b.position = (at + length) >>> 0;
+                const value = s.rt.callProperty(array, avm2.qname(avm2.publicNs, "readObject"));
+                s.rt.setProperty(data, avm2.qname(avm2.publicNs, key), value);
+                // The 0 after each value.
+                at = b.position + 1;
+            }
+        }
+        catch {
+            return null;
+        }
+        return data;
+    };
+    const unavailable = (url) => {
+        if (url === null || url === undefined) {
+            throw s.rt.error("TypeError", 2007, "url");
+        }
+        throw s.rt.error("Error", 2014);
+    };
+    class SharedObjectNatives {
+        static getLocal(name, localPath, secure) {
+            if (name === null || name === undefined) {
+                throw s.rt.error("TypeError", 2007, "name");
+            }
+            const text = s.rt.toString(name);
+            if (text === "" || BAD_NAME.test(text)) {
+                throw s.rt.error("Error", 2134);
+            }
+            // The SWF whose code asks, which a loaded one's is, not the main SWF.
+            const url = new URL(s.code.codeUrl(), "file:///");
+            // A secure one only for a SWF that came over HTTPS; adl, whose SWFs
+            // never do, refuses it so.
+            if (secure && url.protocol !== "https:") {
+                throw s.rt.error("Error", 2134);
+            }
+            // By default the SWF's own path, file name and all, which is never a
+            // directory's; one known by no file name is kept apart from its
+            // directory's as well. A path it names must lead to the SWF: "/" or
+            // one of the directories above it, as adl refuses any other.
+            const own = url.pathname.endsWith("/") ? `${url.pathname}[swf]` : url.pathname;
+            let path = own;
+            if (localPath !== null && localPath !== undefined) {
+                path = s.rt.toString(localPath);
+                const directory = path.endsWith("/") ? path : `${path}/`;
+                if (path !== own && !own.startsWith(directory)) {
+                    throw s.rt.error("Error", 2134);
+                }
+            }
+            // Secure ones apart: a SWF that comes over HTTP never sees them.
+            const key = `${url.host}${path.startsWith("/") ? "" : "/"}${path}/${text}${secure ? "#secure" : ""}`;
+            const known = open.get(key);
+            if (known) {
+                return known;
+            }
+            const o = s.rt.construct(s.rt.classNamed("flash.net::SharedObject"));
+            o.$key = key;
+            o.$name = text;
+            o.$encoding = defaultEncoding;
+            o.$client = o;
+            const stored = s.storage.get(key);
+            o.$data = (stored && deserialize(stored)) ?? s.rt.newObject([]);
+            o.$saved = saved(o);
+            open.set(key, o);
+            return o;
+        }
+        // Hidden from authoring tools, and refused to content: a SWF in the
+        // browser's Flash Player 32 or in adl gets Error #2014 whatever it
+        // names, its own site included, and nothing is deleted. Taking them
+        // as named would let any SWF on a page's origin measure or wipe every
+        // other SWF's saves there.
+        static deleteAll(url) {
+            return unavailable(url);
+        }
+        static getDiskUsage(url) {
+            return unavailable(url);
+        }
+        static get defaultObjectEncoding() {
+            return defaultEncoding;
+        }
+        static set defaultObjectEncoding(v) {
+            defaultEncoding = s.rt.toUint(v) === 0 ? 0 : 3;
+        }
+        static get "flash.net:SharedObject::preventBackupImpl"() {
+            return preventBackup;
+        }
+        static set "flash.net:SharedObject::preventBackupImpl"(v) {
+            preventBackup = !!v;
+        }
+        get data() {
+            return this.$data;
+        }
+        get objectEncoding() {
+            return this.$encoding;
+        }
+        set objectEncoding(v) {
+            this.$encoding = s.rt.toUint(v) === 0 ? 0 : 3;
+        }
+        get client() {
+            return this.$client;
+        }
+        set client(v) {
+            this.$client = v;
+        }
+        setDirty(_name) { }
+        // Flush returns true, which flush reports as FLUSHED, or false for #2130.
+        "flash.net:SharedObject::invoke"(code, ..._args) {
+            switch (s.rt.toUint(code)) {
+                case FLUSH:
+                    return write(this);
+                case GET_SIZE:
+                    return serialize(this).length;
+                case CLEAR:
+                    this.$data = s.rt.newObject([]);
+                    this.$saved = new Uint8Array(0);
+                    s.storage.remove(this.$key);
+                    return undefined;
+                case CLOSE:
+                    return undefined;
+                default:
+                    throw s.rt.unsupported("SharedObject's remote calls");
+            }
+        }
+    }
+    // Flash wrote each open object as its SWF went: a destroyed player
+    // writes those a script changed since they were read or written. Never
+    // a removal: an object whose stored file it could not read starts empty,
+    // and an unchanged one would take the file away.
+    s.flushSharedObjects = () => {
+        for (const o of open.values()) {
+            try {
+                const file = serialize(o);
+                if (file.length && !sameBytes(file, o.$saved)) {
+                    s.storage.set(o.$key, file);
+                }
+            }
+            catch {
+                // One that cannot be written, AMF0's or a full quota's, keeps the others from nothing.
+            }
+        }
+    };
+    avm2.registerNativeClass(natives, "flash.net::SharedObject", SharedObjectNatives);
+    return natives;
+}
+function sameBytes(a, b) {
+    return b !== null && a.length === b.length && a.every((byte, i) => byte === b[i]);
+}
+/** The 0 after each value. */
+const END = new Uint8Array(1);
+/** An AMF3 U29: 1 to 4 bytes, 7 bits each but the fourth's 8. */
+function u29(n) {
+    if (n < 0x80) {
+        return Uint8Array.of(n);
+    }
+    if (n < 0x4000) {
+        return Uint8Array.of((n >> 7) | 0x80, n & 0x7f);
+    }
+    if (n < 0x200000) {
+        return Uint8Array.of((n >> 14) | 0x80, ((n >> 7) & 0x7f) | 0x80, n & 0x7f);
+    }
+    return Uint8Array.of((n >> 22) | 0x80, ((n >> 15) & 0x7f) | 0x80, ((n >> 8) & 0x7f) | 0x80, n & 0xff);
+}
+/** The U29 at `at`, and where what follows it starts. */
+function readU29(bytes, at) {
+    let n = 0;
+    for (let i = 0; i < 3; i++) {
+        const b = bytes[at++];
+        n = (n << 7) | (b & 0x7f);
+        if (!(b & 0x80)) {
+            return [n, at];
+        }
+    }
+    return [(n << 8) | bytes[at], at + 1];
+}

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

@@ -0,0 +1,282 @@
+// flash.net.Socket: DataInput/DataOutput over a host-provided TCP transport.
+import { avm2 } from "../../../../runtime/index.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+const UNKNOWN = {
+    localAddress: "",
+    localPort: 0,
+    remoteAddress: "",
+    remotePort: 0,
+};
+export function socketNatives(s) {
+    const natives = {};
+    const connections = new WeakMap();
+    const byteArray = () => s.rt.classNamed("flash.utils::ByteArray");
+    const connection = (o) => {
+        let c = connections.get(o);
+        if (!c) {
+            c = {
+                input: s.rt.construct(byteArray()),
+                output: s.rt.construct(byteArray()),
+                transport: null,
+                generation: 0,
+                connected: false,
+                connecting: false,
+                failed: false,
+                endpoints: null,
+            };
+            connections.set(o, c);
+        }
+        return c;
+    };
+    // The runtime's message, which is the debugger player's text or the release player's number alone.
+    const invalid = () => {
+        throw s.rt.error("flash.errors::IOError", 2002);
+    };
+    const active = (o) => {
+        const c = connection(o);
+        if (!c.connected) {
+            invalid();
+        }
+        return c;
+    };
+    const input = (o, method, ...args) => s.rt.callProperty(active(o).input, s.rt.publicName(method), ...args);
+    const output = (o, method, ...args) => s.rt.callProperty(active(o).output, s.rt.publicName(method), ...args);
+    const event = (o, type) => {
+        dispatchEvent(s, o, s.event(type));
+    };
+    class SocketNatives {
+        "flash.net:Socket::internalGetSecurityErrorMessage"(host, port) {
+            return `Error #2048: Security sandbox violation: ${String(host)}:${Number(port)}`;
+        }
+        "flash.net:Socket::internalConnect"(host, port) {
+            const c = connection(this);
+            c.transport?.close();
+            c.generation++;
+            c.transport = null;
+            c.connected = false;
+            c.connecting = true;
+            c.failed = false;
+            c.endpoints = UNKNOWN;
+            avm2.bytesOf(s.rt, c.input).clear();
+            avm2.bytesOf(s.rt, c.output).clear();
+            const generation = c.generation;
+            const current = () => c.generation === generation;
+            const fail = (message) => {
+                if (!current()) {
+                    return;
+                }
+                c.generation++;
+                c.connecting = false;
+                c.connected = false;
+                c.transport?.close();
+                c.transport = null;
+                c.failed = true;
+                dispatchEvent(s, this, s.rt.construct(s.rt.classNamed("flash.events::IOErrorEvent"), "ioError", false, false, message));
+            };
+            if (!s.socket) {
+                s.loads.deferHostEvent(() => fail("Error #2031: Socket Error."));
+                return;
+            }
+            try {
+                c.transport = s.socket.connect(host === null ? "localhost" : s.rt.toString(host), s.rt.toInt(port), {
+                    open: (endpoints) => s.loads.deferHostEvent(() => {
+                        if (!current()) {
+                            return;
+                        }
+                        c.connecting = false;
+                        c.connected = true;
+                        c.endpoints = endpoints ? { ...endpoints } : UNKNOWN;
+                        event(this, "connect");
+                    }),
+                    data: (bytes) => {
+                        const copy = bytes.slice();
+                        s.loads.deferHostEvent(() => {
+                            if (!current() || !c.connected) {
+                                return;
+                            }
+                            const buffer = avm2.bytesOf(s.rt, c.input);
+                            if (buffer.position >= 65536 && buffer.position * 2 >= buffer.length) {
+                                const unread = buffer.available;
+                                buffer.buffer.copyWithin(0, buffer.position, buffer.length);
+                                buffer.setLength(unread);
+                                buffer.position = 0;
+                            }
+                            const position = buffer.position;
+                            buffer.position = buffer.length;
+                            buffer.write(copy);
+                            buffer.position = position;
+                            dispatchEvent(s, this, s.rt.construct(s.rt.classNamed("flash.events::ProgressEvent"), "socketData", false, false, copy.length, 0));
+                        });
+                    },
+                    close: () => s.loads.deferHostEvent(() => {
+                        if (!current()) {
+                            return;
+                        }
+                        if (c.connecting) {
+                            fail("Error #2031: Socket Error.");
+                            return;
+                        }
+                        c.connected = false;
+                        c.connecting = false;
+                        c.transport = null;
+                        event(this, "close");
+                    }),
+                    error: (message) => s.loads.deferHostEvent(() => fail(message)),
+                });
+            }
+            catch (e) {
+                s.loads.deferHostEvent(() => fail(String(e)));
+            }
+        }
+        "flash.net:Socket::didFailureOccur"() {
+            return connection(this).failed;
+        }
+        "flash.net:Socket::internalClose"() {
+            const c = connection(this);
+            if (!c.connected && !c.connecting) {
+                invalid();
+            }
+            c.generation++;
+            c.transport?.close();
+            c.transport = null;
+            c.connected = false;
+            c.connecting = false;
+            c.endpoints = null;
+        }
+        "flash.net:Socket::OnError"() { }
+        "flash.net:Socket::wasCalledByAppContent"() {
+            return false;
+        }
+        /**
+         * AIR's, as adl reads them: null and 0 before a connection and after
+         * close(), "" and 0 while one opens or after it fails, and the ends,
+         * resolved, once open, kept after the peer closes.
+         */
+        get localAddress() {
+            return connection(this).endpoints?.localAddress ?? null;
+        }
+        get localPort() {
+            return connection(this).endpoints?.localPort ?? 0;
+        }
+        get remoteAddress() {
+            return connection(this).endpoints?.remoteAddress ?? null;
+        }
+        get remotePort() {
+            return connection(this).endpoints?.remotePort ?? 0;
+        }
+        get connected() {
+            return connection(this).connected;
+        }
+        get bytesAvailable() {
+            return avm2.bytesOf(s.rt, connection(this).input).available;
+        }
+        get bytesPending() {
+            return avm2.bytesOf(s.rt, connection(this).output).length;
+        }
+        flush() {
+            const c = active(this);
+            const bytes = avm2.bytesOf(s.rt, c.output);
+            if (bytes.length !== 0) {
+                c.transport?.send(bytes.buffer.slice(0, bytes.length));
+                bytes.setLength(0);
+                bytes.position = 0;
+            }
+        }
+        readBytes(bytes, offset, length) {
+            input(this, "readBytes", bytes, offset, length);
+        }
+        readBoolean() {
+            return input(this, "readBoolean");
+        }
+        readByte() {
+            return input(this, "readByte");
+        }
+        readUnsignedByte() {
+            return input(this, "readUnsignedByte");
+        }
+        readShort() {
+            return input(this, "readShort");
+        }
+        readUnsignedShort() {
+            return input(this, "readUnsignedShort");
+        }
+        readInt() {
+            return input(this, "readInt");
+        }
+        readUnsignedInt() {
+            return input(this, "readUnsignedInt");
+        }
+        readFloat() {
+            return input(this, "readFloat");
+        }
+        readDouble() {
+            return input(this, "readDouble");
+        }
+        readUTF() {
+            return input(this, "readUTF");
+        }
+        readUTFBytes(length) {
+            return input(this, "readUTFBytes", length);
+        }
+        readMultiByte(length, charset) {
+            return input(this, "readMultiByte", length, charset);
+        }
+        readObject() {
+            return input(this, "readObject");
+        }
+        writeBytes(bytes, offset, length) {
+            output(this, "writeBytes", bytes, offset, length);
+        }
+        writeBoolean(value) {
+            output(this, "writeBoolean", value);
+        }
+        writeByte(value) {
+            output(this, "writeByte", value);
+        }
+        writeShort(value) {
+            output(this, "writeShort", value);
+        }
+        writeInt(value) {
+            output(this, "writeInt", value);
+        }
+        writeUnsignedInt(value) {
+            output(this, "writeUnsignedInt", value);
+        }
+        writeFloat(value) {
+            output(this, "writeFloat", value);
+        }
+        writeDouble(value) {
+            output(this, "writeDouble", value);
+        }
+        writeMultiByte(value, charset) {
+            output(this, "writeMultiByte", value, charset);
+        }
+        writeUTF(value) {
+            output(this, "writeUTF", value);
+        }
+        writeUTFBytes(value) {
+            output(this, "writeUTFBytes", value);
+        }
+        writeObject(value) {
+            output(this, "writeObject", value);
+        }
+        get objectEncoding() {
+            return s.rt.getProperty(connection(this).input, s.rt.publicName("objectEncoding"));
+        }
+        set objectEncoding(value) {
+            const c = connection(this);
+            s.rt.setProperty(c.input, s.rt.publicName("objectEncoding"), value);
+            s.rt.setProperty(c.output, s.rt.publicName("objectEncoding"), value);
+        }
+        get endian() {
+            return s.rt.getProperty(connection(this).input, s.rt.publicName("endian"));
+        }
+        set endian(value) {
+            const c = connection(this);
+            s.rt.setProperty(c.input, s.rt.publicName("endian"), value);
+            s.rt.setProperty(c.output, s.rt.publicName("endian"), value);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.net::Socket", SocketNatives);
+    return natives;
+}

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

@@ -0,0 +1,93 @@
+// flash.net.URLRequest: a URL and how to ask for it, kept as fields.
+import { avm2 } from "../../../../runtime/index.js";
+export function urlRequestNatives(s) {
+    const natives = {};
+    class URLRequestNatives {
+        get url() {
+            return this.$url ?? null;
+        }
+        set url(v) {
+            this.$url = v === null || v === undefined ? null : String(v);
+        }
+        get data() {
+            return this.$data ?? null;
+        }
+        set data(v) {
+            this.$data = v;
+        }
+        get method() {
+            return this.$method ?? "GET";
+        }
+        "flash.net:URLRequest::setMethod"(v) {
+            this.$method = String(v);
+        }
+        get contentType() {
+            return this.$contentType ?? "application/x-www-form-urlencoded";
+        }
+        set contentType(v) {
+            this.$contentType = v;
+        }
+        get requestHeaders() {
+            if (!this.$headers) {
+                this.$headers = s.rt.array([]);
+            }
+            return this.$headers;
+        }
+        "flash.net:URLRequest::setRequestHeaders"(v) {
+            this.$headers = v;
+        }
+        get digest() {
+            return this.$digest ?? null;
+        }
+        set digest(v) {
+            this.$digest = v;
+        }
+        useRedirectedURL() {
+            // Nothing redirects.
+        }
+        get followRedirects() {
+            return this.$followRedirects ?? true;
+        }
+        set followRedirects(v) {
+            this.$followRedirects = !!v;
+        }
+        get userAgent() {
+            return this.$userAgent ?? null;
+        }
+        set userAgent(v) {
+            this.$userAgent = v;
+        }
+        get manageCookies() {
+            return this.$manageCookies ?? true;
+        }
+        set manageCookies(v) {
+            this.$manageCookies = !!v;
+        }
+        get useCache() {
+            return this.$useCache ?? true;
+        }
+        set useCache(v) {
+            this.$useCache = !!v;
+        }
+        get cacheResponse() {
+            return this.$cacheResponse ?? true;
+        }
+        set cacheResponse(v) {
+            this.$cacheResponse = !!v;
+        }
+        "flash.net:URLRequest::_SetIdleTimeout"(v) {
+            this.$idleTimeout = Number(v);
+        }
+        get idleTimeout() {
+            return this.$idleTimeout ?? 0;
+        }
+        get authenticate() {
+            return this.$authenticate ?? true;
+        }
+        set authenticate(v) {
+            this.$authenticate = !!v;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.net::URLRequest", URLRequestNatives);
+    return natives;
+}