@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,163 @@
+// flash.system.Capabilities: the screen values the host captured for this
+// player, and the rest as Flash Player 32's browser plugin reports them on
+// the host's system (hosts.ts's platformCapabilities), which a host may
+// set apart.
+import { avm2 } from "../../../../runtime/index.js";
+export function capabilitiesNatives(s) {
+    const natives = {};
+    const p = () => s.platform;
+    class CapabilitiesNatives {
+        static get screenResolutionX() {
+            return s.screenCapabilities.screenResolutionX;
+        }
+        static get screenResolutionY() {
+            return s.screenCapabilities.screenResolutionY;
+        }
+        static get pixelAspectRatio() {
+            return s.screenCapabilities.pixelAspectRatio;
+        }
+        static get screenDPI() {
+            return s.screenCapabilities.screenDPI;
+        }
+        static get os() {
+            return p().os;
+        }
+        static get manufacturer() {
+            return p().manufacturer;
+        }
+        static get version() {
+            return p().version;
+        }
+        static get language() {
+            return p().language;
+        }
+        static get languages() {
+            return s.rt.newArray([p().language]);
+        }
+        static get playerType() {
+            return p().playerType;
+        }
+        static get isDebugger() {
+            return s.rt.debugger;
+        }
+        static get cpuArchitecture() {
+            return "x86";
+        }
+        static get screenColor() {
+            return "color";
+        }
+        // A browser tells a finger's screen from none, not a stylus's.
+        static get touchscreenType() {
+            return s.maxTouchPoints > 0 ? "finger" : "none";
+        }
+        static get maxLevelIDC() {
+            return "5.1";
+        }
+        static get serverString() {
+            return serverString(s);
+        }
+        static get "flash.system:Capabilities::_internal"() {
+            return 0;
+        }
+        static hasMultiChannelAudio(_type) {
+            return false;
+        }
+        // What a browser plugin has: sound, video and the rest it plays, printing,
+        // accessibility, an IME and TLS; no screen broadcast, no local file reads.
+        static get hasAudio() {
+            return true;
+        }
+        static get hasMP3() {
+            return true;
+        }
+        static get hasStreamingAudio() {
+            return true;
+        }
+        static get hasStreamingVideo() {
+            return true;
+        }
+        static get hasEmbeddedVideo() {
+            return true;
+        }
+        static get hasAudioEncoder() {
+            return true;
+        }
+        static get hasVideoEncoder() {
+            return true;
+        }
+        static get hasPrinting() {
+            return true;
+        }
+        static get hasAccessibility() {
+            return true;
+        }
+        static get hasIME() {
+            return true;
+        }
+        static get hasTLS() {
+            return true;
+        }
+        static get supports32BitProcesses() {
+            return true;
+        }
+        static get supports64BitProcesses() {
+            return true;
+        }
+        static get hasScreenBroadcast() {
+            return false;
+        }
+        static get hasScreenPlayback() {
+            return false;
+        }
+        static get avHardwareDisable() {
+            return false;
+        }
+        static get localFileReadDisable() {
+            return true;
+        }
+        static get isEmbeddedInAcrobat() {
+            return false;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.system::Capabilities", CapabilitiesNatives);
+    return natives;
+}
+/** The capabilities as Flash sends them to a server: its fields' codes, URL-encoded, in its order. */
+function serverString(s) {
+    const p = s.platform;
+    const yes = (b) => (b ? "t" : "f");
+    const sc = s.screenCapabilities;
+    const fields = [
+        ["A", "t"],
+        ["SA", "t"],
+        ["SV", "t"],
+        ["EV", "t"],
+        ["MP3", "t"],
+        ["AE", "t"],
+        ["VE", "t"],
+        ["ACC", "t"],
+        ["PR", "t"],
+        ["SP", "f"],
+        ["SB", "f"],
+        ["DEB", yes(s.rt.debugger)],
+        ["V", p.version],
+        ["M", p.manufacturer],
+        ["R", `${sc.screenResolutionX}x${sc.screenResolutionY}`],
+        ["COL", "color"],
+        ["AR", String(sc.pixelAspectRatio)],
+        ["OS", p.os],
+        ["ARCH", "x86"],
+        ["L", p.language],
+        ["IME", "t"],
+        ["PR32", "t"],
+        ["PR64", "t"],
+        ["PT", p.playerType],
+        ["AVD", "f"],
+        ["LFD", "t"],
+        ["WD", "f"],
+        ["TLS", "t"],
+        ["ML", "5.1"],
+        ["DP", String(sc.screenDPI)],
+    ];
+    return fields.map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+}

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

@@ -0,0 +1,17 @@
+// flash.system.fscommand: a message to the player's host, which a plug-in
+// passed to its page and a projector acted on; here the host's, if it
+// takes them, else nothing, as a plug-in whose page defines no handler.
+import { avm2 } from "../../../../runtime/index.js";
+export function fsCommandNatives(s) {
+    const natives = {};
+    class FSCommandHostNatives {
+        static _fscommand(command, args) {
+            // With the calling SWF's URL, or every loaded SWF's where the caller
+            // cannot be told, for a host that lets some SWFs command it and not
+            // others; 1 counts this native as the player's frame (Code.callerUrl).
+            s.fsCommand?.(s.rt.toString(command), s.rt.toString(args), s.code.securityUrls(1));
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.system::FSCommandHost", FSCommandHostNatives);
+    return natives;
+}

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

@@ -0,0 +1,46 @@
+// flash.system.Security: the sandbox the host placed the SWF in, a remote
+// SWF's by default, which allows what a browser's would; the policy files
+// a SWF names go to the host, which judges its requests by them.
+import { avm2 } from "../../../../runtime/index.js";
+export function securityNatives(s) {
+    const natives = {};
+    // Kept as set, nothing reads them: a data field is not a native.
+    let exactSettings = true;
+    let disableAVM1Loading = false;
+    class SecurityNatives {
+        static get exactSettings() {
+            return exactSettings;
+        }
+        static set exactSettings(v) {
+            exactSettings = !!v;
+        }
+        static get disableAVM1Loading() {
+            return disableAVM1Loading;
+        }
+        static set disableAVM1Loading(v) {
+            disableAVM1Loading = !!v;
+        }
+        static get sandboxType() {
+            return s.sandboxType;
+        }
+        static get pageDomain() {
+            return null;
+        }
+        static allowDomain() {
+            // Every domain is allowed already.
+        }
+        static allowInsecureDomain() {
+            // Every domain is allowed already.
+        }
+        static loadPolicyFile(url) {
+            if (url !== null && url !== undefined) {
+                s.loads.policyFile(s.rt.toString(url));
+            }
+        }
+        static showSettings(_panel) {
+            // There is no settings panel.
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.system::Security", SecurityNatives);
+    return natives;
+}

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

@@ -0,0 +1,21 @@
+// All content in this player shares one browser security sandbox. Flash's
+// SecurityDomain.currentDomain is the stable object for that sandbox.
+import { avm2 } from "../../../../runtime/index.js";
+export function securityDomainNatives(s) {
+    const natives = {};
+    let current = null;
+    class SecurityDomainNatives {
+        static get currentDomain() {
+            // Its public constructor throws; the player creates the singleton directly.
+            if (!current) {
+                current = s.rt.classNamed("flash.system::SecurityDomain").$it.instance();
+            }
+            return current;
+        }
+        "flash.system:SecurityDomain::ctor_impl"() {
+            throw s.rt.error("ArgumentError", 2012, "SecurityDomain");
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.system::SecurityDomain", SecurityDomainNatives);
+    return natives;
+}

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

@@ -0,0 +1,73 @@
+// flash.system.System: statics about the player's memory, of which there
+// is nothing here to tell or do, and setClipboard.
+import { avm2 } from "../../../../runtime/index.js";
+import { TEXT } from "../../../scripting/clipboard.js";
+export function systemNatives(s) {
+    const natives = {};
+    let useCodePage = false;
+    class SystemNatives {
+        static get ime() {
+            return null;
+        }
+        /**
+         * The clipboard's text alone, in place of all it held, while a user's
+         * event is handled; outside one Error #2176, as Ruffle has the plug-in
+         * throw it, and TypeError #2007 for null, as Ruffle's does.
+         */
+        static setClipboard(text) {
+            if (text === null || text === undefined) {
+                throw s.rt.error("TypeError", 2007, "text");
+            }
+            const clipboard = s.clipboard;
+            if (!clipboard.writable) {
+                throw s.rt.error("Error", 2176);
+            }
+            clipboard.clear();
+            clipboard.set(TEXT, s.rt.toString(text));
+        }
+        static get totalMemory() {
+            return 0;
+        }
+        static get totalMemoryNumber() {
+            return 0;
+        }
+        static get freeMemory() {
+            return 0;
+        }
+        static get privateMemory() {
+            return 0;
+        }
+        static get processCPUUsage() {
+            return 0;
+        }
+        static get useCodePage() {
+            return useCodePage;
+        }
+        static set useCodePage(v) {
+            useCodePage = !!v;
+        }
+        static get vmVersion() {
+            return "swf2es";
+        }
+        static pause() {
+            // Nothing to pause.
+        }
+        static resume() {
+            // Nothing to resume.
+        }
+        static exit(_code) {
+            // A browser's page does not exit.
+        }
+        static gc() {
+            // JavaScript's collector decides.
+        }
+        static pauseForGCIfCollectionImminent(_imminence) {
+            // JavaScript's collector decides.
+        }
+        static disposeXML(_node) {
+            // It frees an XML tree early, which JavaScript's collector does once nothing refers to it.
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.system::System", SystemNatives);
+    return natives;
+}

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

@@ -0,0 +1,112 @@
+// flash.system.Worker, WorkerDomain and MessageChannel: the AS3 faces of
+// the workers scripting/workers.ts runs. A Worker object stands for a
+// worker by its id, a MessageChannel for a channel by its own; with no
+// worker host, the primordial is the one worker, and none other starts.
+import { avm2 } from "../../../../runtime/index.js";
+import { eventDispatcherNatives } from "../events/EventDispatcher.js";
+/** A shared property's key: null is one of its own, apart from "null", as in avmplus. */
+const keyOf = (s, key) => key === null || key === undefined ? null : s.rt.toString(key);
+export function workerNatives(s) {
+    const natives = {};
+    class WorkerNatives {
+        static get isSupported() {
+            return s.workers.supported;
+        }
+        get isPrimordial() {
+            return this.$worker === 0;
+        }
+        "flash.system:Worker::internalGetState"() {
+            return s.workers.state(this.$worker);
+        }
+        getSharedProperty(key) {
+            return s.workers.getShared(this.$worker, keyOf(s, key));
+        }
+        setSharedProperty(key, value) {
+            s.workers.setShared(this.$worker, keyOf(s, key), value);
+        }
+        // Flash's own setSharedProperty and getSharedProperty call these.
+        "flash.system:Worker::internalGetSharedProperty"(key) {
+            return s.workers.getShared(this.$worker, keyOf(s, key));
+        }
+        "flash.system:Worker::internalSetSharedProperty"(key, value) {
+            s.workers.setShared(this.$worker, keyOf(s, key), value);
+        }
+        // workerState is dispatched to the Worker object whoever listens.
+        "flash.system:Worker::internalAddEventListener"() { }
+        "flash.system:Worker::internalRemoveEventListener"() { }
+        start() {
+            s.workers.start(this.$worker);
+        }
+        terminate() {
+            return s.workers.terminate(this.$worker);
+        }
+        createMessageChannel(receiver) {
+            if (receiver === null || receiver === undefined) {
+                throw s.rt.error("TypeError", 2007, "receiver");
+            }
+            return s.workers.createChannel(this.$worker, receiver.$worker);
+        }
+    }
+    class WorkerDomainNatives {
+        static get isSupported() {
+            return s.workers.supported;
+        }
+        createWorker(swf) {
+            return s.workers.create(swf);
+        }
+        listWorkers() {
+            const rt = s.rt;
+            const cls = rt.applyType(rt.classNamed("__AS3__.vec::Vector"), [
+                rt.classNamed("flash.system::Worker"),
+            ]);
+            const o = cls.$it.instance();
+            o.$a = s.workers.list();
+            o.$fixed = false;
+            return o;
+        }
+    }
+    // Its addEventListener and removeEventListener are natives in Flash's
+    // playerglobal, which only add to EventDispatcher's.
+    const dispatcher = eventDispatcherNatives(s);
+    const inherited = (name) => dispatcher[`flash.events::EventDispatcher#${name}`](s.rt);
+    class MessageChannelNatives {
+        send(value) {
+            s.workers.send(this, value);
+        }
+        get messageAvailable() {
+            return s.workers.messageAvailable(this);
+        }
+        receive(block) {
+            return s.workers.receive(this, !!block);
+        }
+        addEventListener(...args) {
+            return inherited("addEventListener").apply(this, args);
+        }
+        removeEventListener(...args) {
+            return inherited("removeEventListener").apply(this, args);
+        }
+        close() {
+            s.workers.close(this);
+        }
+        get state() {
+            return s.workers.channelState(this);
+        }
+        toString() {
+            return "[object MessageChannel]";
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.system::Worker", WorkerNatives);
+    avm2.registerNativeClass(natives, "flash.system::WorkerDomain", WorkerDomainNatives);
+    avm2.registerNativeClass(natives, "flash.system::MessageChannel", MessageChannelNatives);
+    return natives;
+}
+/** Worker.current, which the VM keeps in Worker's private static _current: this VM's own worker. */
+export function workerHooks(s) {
+    return {
+        "flash.system::Worker": {
+            created(_rt, cls) {
+                avm2.setStaticVar(cls, "_current", s.workers.objectOf(s.workers.id, cls));
+            },
+        },
+    };
+}

package/dist/thread/player/playerglobal/flash/text/Font.js

@@ -0,0 +1,95 @@
+// flash.text.Font: embedded SWF font metadata and explicit font registration.
+import { avm2 } from "../../../../runtime/index.js";
+function style(font) {
+    if (font.bold && font.italic) {
+        return "boldItalic";
+    }
+    if (font.bold) {
+        return "bold";
+    }
+    return font.italic ? "italic" : "regular";
+}
+/** The fonts enumerateFonts lists: the running code's SWF's, with layout or no glyphs, and those registered. */
+export function embeddedFonts(s) {
+    const fonts = [];
+    const library = s.code.codeLibrary();
+    if (library) {
+        for (const character of library.characters.values()) {
+            if (character.type === "font" &&
+                (character.font.layout || character.font.glyphs.length === 0)) {
+                fonts.push(character);
+            }
+        }
+    }
+    fonts.push(...s.symbols.registeredFonts.values());
+    return fonts;
+}
+export function fontNatives(s) {
+    const natives = {};
+    const glyphCodes = new WeakMap();
+    class FontNatives {
+        get fontName() {
+            return this.$font?.name ?? null;
+        }
+        get fontStyle() {
+            return this.$font ? style(this.$font) : null;
+        }
+        get fontType() {
+            return this.$font ? (this.$font.type === "fontCff" ? "embeddedCFF" : "embedded") : null;
+        }
+        hasGlyphs(text) {
+            const font = this.$font;
+            if (!font) {
+                return false;
+            }
+            if (font.type === "fontCff") {
+                return text.length === 0;
+            }
+            let glyphs = glyphCodes.get(font);
+            if (!glyphs) {
+                glyphs = new Set(font.font.glyphs.map((glyph) => glyph.code));
+                glyphCodes.set(font, glyphs);
+            }
+            for (let i = 0; i < text.length; i++) {
+                if (!glyphs.has(text.charCodeAt(i))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        static enumerateFonts(_enumerateDeviceFonts) {
+            const cls = s.rt.classNamed("flash.text::Font");
+            const fonts = embeddedFonts(s);
+            fonts.sort((a, b) => {
+                const first = a.name.toLowerCase();
+                const second = b.name.toLowerCase();
+                return first < second ? -1 : first > second ? 1 : 0;
+            });
+            return s.rt.array(fonts.map((font) => {
+                const object = s.rt.construct(cls);
+                object.$font = font;
+                return object;
+            }));
+        }
+        static registerFont(cls) {
+            const font = cls?.$it && s.symbols.fontSymbol(cls.$it);
+            if (!font) {
+                throw s.rt.error("ArgumentError", 1508, "font");
+            }
+            s.symbols.registerFont(cls, font);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.text::Font", FontNatives);
+    return natives;
+}
+export function fontHooks(s) {
+    return {
+        "flash.text::Font": {
+            create: (traits) => {
+                const object = Object.create(traits.proto);
+                object.$font = s.symbols.fontSymbol(traits);
+                return object;
+            },
+        },
+    };
+}

package/dist/thread/player/playerglobal/flash/text/StaticText.js

@@ -0,0 +1,16 @@
+// flash.text.StaticText: DefineText's glyphs, which a script reads as its text.
+import { avm2 } from "../../../../runtime/index.js";
+import { StaticTextObject } from "../../../display/display.js";
+import { displayOf } from "../display/DisplayObject.js";
+export function staticTextNatives() {
+    const natives = {};
+    class StaticTextNatives {
+        /** Its glyphs' characters; null where a glyph's font is not the SWF's, or there are none. */
+        get text() {
+            const display = displayOf(this);
+            return display instanceof StaticTextObject ? display.glyphs.text : null;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.text::StaticText", StaticTextNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/text/StyleSheet.js

@@ -0,0 +1,65 @@
+// flash.text.StyleSheet's natives: playerglobal keeps the style objects
+// and their TextFormats itself, and asks these to parse CSS, colours and
+// font lists, to hold the TextFormats by selector, and to tell the fields
+// that use the sheet that it changed.
+import { avm2 } from "../../../../runtime/index.js";
+import { camelCase, cssColor, fontList, parseCss } from "../../../text/css.js";
+/** The fields a sheet styles, weakly: a field set to another sheet, or collected, drops out. */
+const users = new WeakMap();
+/** `field` now styled by `sheet`, which tells it of changes. */
+export function useSheet(sheet, field) {
+    let set = users.get(sheet);
+    if (!set) {
+        set = new Set();
+        users.set(sheet, set);
+    }
+    set.add(field.ref);
+}
+export function styleSheetNatives(s) {
+    const natives = {};
+    class StyleSheetNatives {
+        get "flash.text:StyleSheet::_styles"() {
+            return this.$styles ?? null;
+        }
+        set "flash.text:StyleSheet::_styles"(v) {
+            this.$styles = v;
+        }
+        /** The fields that use this sheet styled again from their HTML. */
+        "flash.text:StyleSheet::_update"() {
+            const set = users.get(this);
+            for (const ref of set ?? []) {
+                const field = ref.deref();
+                if (!field || field.styleSheet !== this) {
+                    set?.delete(ref);
+                    continue;
+                }
+                field.restyle?.();
+            }
+        }
+        /** Each selector's style object, its properties camel-cased strings; null for a sheet Flash rejects. */
+        "flash.text:StyleSheet::_parseCSSInternal"(css) {
+            const parsed = parseCss(s.rt.toString(css));
+            if (!parsed) {
+                return null;
+            }
+            const pairs = [];
+            for (const [selector, properties] of parsed) {
+                const style = [];
+                for (const [name, value] of properties) {
+                    style.push(camelCase(name), value);
+                }
+                // Selectors as setStyle keeps them, lower-cased: of KEY and key, the later is kept.
+                pairs.push(selector.toLowerCase(), s.rt.newObject(style));
+            }
+            return s.rt.newObject(pairs);
+        }
+        "flash.text:StyleSheet::_parseCSSFontFamily"(family) {
+            return fontList(s.rt.toString(family));
+        }
+        "flash.text:StyleSheet::_parseColor"(color) {
+            return cssColor(s.rt.toString(color));
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.text::StyleSheet", StyleSheetNatives);
+    return natives;
+}