@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/files.js

@@ -0,0 +1,334 @@
+/**
+ * Whether the browser's file picker greys out every file of a type it does not know when an
+ * input names any, as iOS's and iPadOS's do (an iPad asks as a Mac with touch; so does a Mac
+ * emulating touch in its developer tools): there an input takes no filter, and every file can
+ * be picked.
+ */
+export function filtersGreyOutFiles(navigator) {
+    if (!navigator) {
+        return false;
+    }
+    return (/\b(iPhone|iPad|iPod)\b/.test(navigator.userAgent) ||
+        (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1));
+}
+/** The extensions FileReference's filters name, ".xml" for "*.xml"; none for a filter of any file. */
+function extensionsOf(filters) {
+    return filters
+        .flatMap((filter) => filter.extension.split(";"))
+        .map((ext) => ext.trim().replace(/^\*\./, "."))
+        .filter((ext) => /^\.[\w-]+$/.test(ext));
+}
+/** A file input's `accept` for FileReference's filters, none where the picker would grey files out. */
+export function acceptOf(filters, navigator) {
+    return filtersGreyOutFiles(navigator) ? "" : extensionsOf(filters).join(",");
+}
+/**
+ * Whether a file picked with no filter is one the filters take: where the picker could not
+ * filter, the files it gives are held to them here, as Flash's dialog never offers others.
+ */
+export function filtersTake(filters, name) {
+    const extensions = extensionsOf(filters);
+    const lower = name.toLowerCase();
+    return extensions.length === 0 || extensions.some((ext) => lower.endsWith(ext.toLowerCase()));
+}
+/** Browser dialogs are asked synchronously, while transient user activation is still present. */
+export function browserFileHost() {
+    if (typeof document === "undefined") {
+        return null;
+    }
+    const active = () => globalThis.navigator?.userActivation?.isActive === true;
+    return {
+        browse(filters, multiple, signal) {
+            if (!active() || signal.aborted) {
+                return [];
+            }
+            return new Promise((resolve, reject) => {
+                const input = document.createElement("input");
+                input.type = "file";
+                input.multiple = multiple;
+                input.accept = acceptOf(filters, globalThis.navigator);
+                const unfiltered = input.accept === "";
+                input.hidden = true;
+                const finish = (files) => {
+                    signal.removeEventListener("abort", abort);
+                    input.remove();
+                    resolve(files);
+                };
+                const abort = () => finish([]);
+                input.addEventListener("cancel", () => finish([]), { once: true });
+                input.addEventListener("change", () => finish(
+                // None that the filters take is a cancel, as a dialog closed with none chosen.
+                Array.from(input.files ?? [])
+                    .filter((file) => !unfiltered || filtersTake(filters, file.name))
+                    .map((file) => ({
+                    name: file.name,
+                    size: file.size,
+                    modificationDate: file.lastModified,
+                    read: async () => new Uint8Array(await file.arrayBuffer()),
+                }))), { once: true });
+                signal.addEventListener("abort", abort, { once: true });
+                document.body.append(input);
+                try {
+                    if (typeof input.showPicker === "function") {
+                        input.showPicker();
+                    }
+                    else {
+                        input.click();
+                    }
+                }
+                catch (error) {
+                    signal.removeEventListener("abort", abort);
+                    input.remove();
+                    reject(error);
+                }
+            });
+        },
+        save(name, signal) {
+            if (!active() || signal.aborted) {
+                return null;
+            }
+            return pickSaveFile(name);
+        },
+    };
+}
+/** Where `save` writes: a file the user picks, or a download where the browser has no picker. */
+async function pickSaveFile(name) {
+    const picker = globalThis.showSaveFilePicker;
+    if (picker) {
+        try {
+            const handle = await picker.call(globalThis, { suggestedName: name });
+            return {
+                name: handle.name,
+                async write(bytes, signal) {
+                    signal.throwIfAborted();
+                    const stream = await handle.createWritable();
+                    try {
+                        await stream.write(bytes);
+                        signal.throwIfAborted();
+                        await stream.close();
+                    }
+                    catch (error) {
+                        await stream.abort();
+                        throw error;
+                    }
+                },
+            };
+        }
+        catch (error) {
+            if (error.name === "AbortError") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    return {
+        name,
+        async write(bytes, signal) {
+            signal.throwIfAborted();
+            const url = URL.createObjectURL(new Blob([bytes.slice().buffer]));
+            const link = document.createElement("a");
+            link.href = url;
+            link.download = name;
+            link.hidden = true;
+            document.body.append(link);
+            link.click();
+            link.remove();
+            // The browser may consume the URL after click returns.
+            setTimeout(() => URL.revokeObjectURL(url), 60_000);
+        },
+    };
+}
+/** One reference's operation, with stale host callbacks suppressed after cancel or destruction. */
+export class FileReference {
+    services;
+    event;
+    file = null;
+    data = null;
+    operation = null;
+    generation = 0;
+    constructor(services, event) {
+        this.services = services;
+        this.event = event;
+    }
+    cancel() {
+        this.generation++;
+        this.operation?.abort();
+        this.operation = null;
+    }
+    begin() {
+        if (this.operation) {
+            this.services.error(2174);
+        }
+        const abort = new AbortController();
+        const operation = {
+            generation: ++this.generation,
+            signal: AbortSignal.any([abort.signal, this.services.signal]),
+            abort: () => abort.abort(),
+        };
+        this.operation = operation;
+        return operation;
+    }
+    emit(operation, type, loaded = 0, total = 0, text = "") {
+        if (operation.signal.aborted || operation.generation !== this.generation) {
+            return false;
+        }
+        this.event(type, loaded, total, text);
+        return !operation.signal.aborted && operation.generation === this.generation;
+    }
+    fail(operation) {
+        this.operation = null;
+        try {
+            this.emit(operation, "ioError", 0, 0, "Error #2038: File I/O Error.");
+        }
+        finally {
+            // Hosts may hold a save destination even when the transfer never reached write().
+            operation.abort();
+        }
+    }
+    /**
+     * Deliver what `task` gives in the next frame; a value already known goes without a promise's
+     * delay. Any thenable is a promise here: a host built in another window has that realm's.
+     */
+    after(operation, task, deliver) {
+        if (typeof task?.then !== "function") {
+            this.services.defer(() => {
+                if (!operation.signal.aborted && operation.generation === this.generation) {
+                    deliver(task);
+                }
+            });
+            return;
+        }
+        this.services.track(Promise.resolve(task).then((value) => this.services.defer(() => {
+            if (!operation.signal.aborted && operation.generation === this.generation) {
+                deliver(value);
+            }
+        }), () => this.services.defer(() => {
+            if (!operation.signal.aborted && operation.generation === this.generation) {
+                this.fail(operation);
+            }
+        })));
+    }
+    browse(filters, multiple = false, selected) {
+        const operation = this.begin();
+        const task = this.services.host?.browse(filters, multiple, operation.signal) ?? [];
+        this.after(operation, task, (files) => {
+            this.operation = null;
+            if (files.length) {
+                this.file = files[0];
+                this.data = null;
+                selected?.(files);
+            }
+            this.emit(operation, files.length ? "select" : "cancel");
+        });
+    }
+    load() {
+        const file = this.file ?? this.services.error(2037);
+        const operation = this.begin();
+        this.after(operation, file.read(operation.signal), (bytes) => {
+            this.data = bytes;
+            if (this.emit(operation, "open") &&
+                this.emit(operation, "progress", bytes.length, bytes.length)) {
+                this.operation = null;
+                this.emit(operation, "complete");
+            }
+        });
+    }
+    save(name, bytes) {
+        const operation = this.begin();
+        const task = this.services.host?.save(name, operation.signal) ?? null;
+        this.after(operation, task, (destination) => {
+            if (!destination) {
+                this.operation = null;
+                this.emit(operation, "cancel");
+                return;
+            }
+            this.file = {
+                name: destination.name,
+                size: 0,
+                modificationDate: 0,
+                read: async () => this.services.error(2037),
+            };
+            this.data = null;
+            if (!this.emit(operation, "select") || !this.emit(operation, "open")) {
+                return;
+            }
+            const transfer = async () => {
+                const result = bytes instanceof Uint8Array
+                    ? bytes
+                    : (await this.services.fetch(bytes, operation.signal)).bytes;
+                if (result === null) {
+                    throw new Error("download failed");
+                }
+                operation.signal.throwIfAborted();
+                await destination.write(result, operation.signal);
+                return result;
+            };
+            this.after(operation, transfer(), (bytes) => {
+                if (this.file) {
+                    this.file.size = bytes.length;
+                    this.file.modificationDate = Date.now();
+                    this.file.read = async () => bytes.slice();
+                }
+                if (this.emit(operation, "progress", bytes.length, bytes.length)) {
+                    this.operation = null;
+                    this.emit(operation, "complete");
+                }
+            });
+        });
+    }
+    upload(request, field, test = false) {
+        const file = this.file ?? this.services.error(2037);
+        const operation = this.begin();
+        const transfer = async () => {
+            const bytes = await file.read(operation.signal);
+            operation.signal.throwIfAborted();
+            const outgoing = field === null
+                ? { ...request, body: bytes }
+                : await multipart(request, file.name, field, bytes);
+            if (test && bytes.length > 10 * 1024) {
+                const probe = await this.services.fetch({ ...outgoing, body: new Uint8Array() }, operation.signal);
+                if (probe.bytes === null) {
+                    throw new Error("test upload failed");
+                }
+            }
+            const result = await this.services.fetch(outgoing, operation.signal);
+            return { result, size: bytes.length };
+        };
+        this.services.defer(() => this.emit(operation, "open"));
+        this.after(operation, transfer(), ({ result, size }) => {
+            if (!this.emit(operation, "progress", size, size)) {
+                return;
+            }
+            if (result.bytes === null || result.status >= 400) {
+                if (result.status && !this.emit(operation, "httpStatus", result.status)) {
+                    return;
+                }
+                this.fail(operation);
+                return;
+            }
+            this.operation = null;
+            if (this.emit(operation, "complete")) {
+                this.emit(operation, "uploadCompleteData", 0, 0, new TextDecoder().decode(result.bytes));
+            }
+        });
+    }
+}
+/** Let the platform encode multipart quoting and the boundary, then send through the host's fetch. */
+async function multipart(request, name, field, bytes) {
+    const form = new FormData();
+    if (request.body) {
+        for (const [key, value] of new URLSearchParams(new TextDecoder().decode(request.body))) {
+            form.append(key, value);
+        }
+    }
+    form.append("Filename", name);
+    form.append(field, new Blob([bytes.slice().buffer], { type: "application/octet-stream" }), name);
+    form.append("Upload", "Submit Query");
+    const encoded = new Response(form);
+    return {
+        ...request,
+        method: "POST",
+        headers: [["Content-Type", encoded.headers.get("content-type")]],
+        body: new Uint8Array(await encoded.arrayBuffer()),
+    };
+}

package/dist/thread/player/hosts.js

@@ -0,0 +1,207 @@
+/** Targets that would replace the player's own page or a frame around it. */
+const IN_PLACE = new Set(["_self", "_parent", "_top", ""]);
+/**
+ * The browser's navigation, deliberately conservative, as a SWF is not to
+ * be trusted by the page that embeds it: only an http: or https: URL opens,
+ * so a javascript: one cannot run in the embedding page; a target that
+ * would replace the page or a frame around it is refused, as Ruffle's web
+ * navigator refuses it without script access; and every other target opens
+ * a new window, since a name reaches the window or frame of that name,
+ * noopener or not, so a SWF cannot reuse a window it named. A GET opens in
+ * window.open without an opener; a POST is a form submitted to a new
+ * window, the only way a browser posts into one, its body read as form
+ * data. A host that trusts its SWFs further gives a navigate of its own.
+ * Null where there is no window to open, as in node.
+ */
+export function browserNavigate() {
+    if (typeof globalThis.open !== "function" || typeof document === "undefined") {
+        return null;
+    }
+    return (request, window) => {
+        if (window !== null && IN_PLACE.has(window.toLowerCase())) {
+            return;
+        }
+        let url;
+        try {
+            url = new URL(request.url, globalThis.location?.href);
+        }
+        catch {
+            return;
+        }
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            return;
+        }
+        if (request.method.toUpperCase() !== "POST" || !request.body) {
+            globalThis.open(url.href, "_blank", "noopener");
+            return;
+        }
+        if (!document.body) {
+            return;
+        }
+        const form = document.createElement("form");
+        form.method = "POST";
+        form.action = url.href;
+        form.target = "_blank";
+        form.rel = "noopener";
+        form.style.display = "none";
+        for (const [name, value] of new URLSearchParams(new TextDecoder().decode(request.body))) {
+            const input = document.createElement("input");
+            input.type = "hidden";
+            input.name = name;
+            input.value = value;
+            form.append(input);
+        }
+        document.body.append(form);
+        form.submit();
+        form.remove();
+    };
+}
+/**
+ * The default storage: localStorage, base64 under a prefix, where the host
+ * has it and lets it be read; memory otherwise. localStorage is first reached
+ * when a SWF first uses a shared object, since merely reading it can throw
+ * (a SecurityError where site data is blocked). A write it refuses, a full
+ * quota say, throws, which flush reports as Error #2130.
+ */
+export function defaultStorage() {
+    const memory = new Map();
+    const inMemory = {
+        get: (key) => memory.get(key) ?? null,
+        set: (key, bytes) => {
+            memory.set(key, bytes.slice());
+        },
+        remove: (key) => {
+            memory.delete(key);
+        },
+    };
+    let chosen;
+    const storage = () => {
+        if (!chosen) {
+            let local;
+            try {
+                local = globalThis.localStorage;
+                local?.getItem(PREFIX);
+            }
+            catch {
+                local = undefined;
+            }
+            chosen = local ? localStorageOf(local) : inMemory;
+        }
+        return chosen;
+    };
+    return {
+        get: (key) => storage().get(key),
+        set: (key, bytes) => storage().set(key, bytes),
+        remove: (key) => storage().remove(key),
+    };
+}
+const PREFIX = "swf2es:so:";
+function localStorageOf(local) {
+    return {
+        get: (key) => {
+            const text = local.getItem(PREFIX + key);
+            return text === null ? null : Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
+        },
+        set: (key, bytes) => {
+            // In chunks: one String.fromCharCode of every byte overflows the stack.
+            const parts = [];
+            for (let i = 0; i < bytes.length; i += 0x2000) {
+                parts.push(String.fromCharCode(...bytes.subarray(i, i + 0x2000)));
+            }
+            local.setItem(PREFIX + key, btoa(parts.join("")));
+        },
+        remove: (key) => local.removeItem(PREFIX + key),
+    };
+}
+/** The platform as the host's browser reports it, a Linux plugin's where it has none. */
+export function platformCapabilities() {
+    const navigator = globalThis
+        .navigator;
+    const agent = navigator?.userAgent ?? "";
+    const mac = /Mac OS X (\d+)[._](\d+)(?:[._](\d+))?/.exec(agent);
+    const [os, manufacturer, platform] = /Windows/.test(agent)
+        ? ["Windows 10", "Adobe Windows", "WIN"]
+        : mac
+            ? [`Mac OS ${mac[1]}.${mac[2]}${mac[3] ? `.${mac[3]}` : ""}`, "Adobe Macintosh", "MAC"]
+            : ["Linux", "Adobe Linux", "LNX"];
+    // Flash gives the country only where the language needs it.
+    const tag = navigator?.language ?? new Intl.DateTimeFormat().resolvedOptions().locale;
+    const [lang, country] = tag.split("-");
+    const language = (lang === "zh" || lang === "pt") && country ? `${lang}-${country}` : lang;
+    return {
+        os,
+        manufacturer,
+        version: `${platform} 32,0,0,465`,
+        language,
+        locale: tag,
+        playerType: "PlugIn",
+    };
+}
+/** How many touches the browser's screen takes at once, as Multitouch.maxTouchPoints reports; 0 without a browser. */
+export function hostTouchPoints() {
+    const navigator = globalThis.navigator;
+    return navigator?.maxTouchPoints ?? 0;
+}
+/** An EncryptedLocalStore of an application's items held in memory, for as long as it plays. */
+export function memoryStore() {
+    const items = new Map();
+    return {
+        getItem: (name) => items.get(name) ?? null,
+        setItem: (name, bytes) => {
+            items.set(name, bytes);
+        },
+        removeItem: (name) => {
+            items.delete(name);
+        },
+        reset: () => items.clear(),
+    };
+}
+/** The global WebSocket's client, a browser's or node's; null where there is none. */
+export function globalWebSocketHost() {
+    const Client = globalThis.WebSocket;
+    if (typeof Client !== "function") {
+        return null;
+    }
+    return {
+        connect(url, protocols, events) {
+            const socket = new Client(url, protocols);
+            socket.binaryType = "arraybuffer";
+            socket.addEventListener("open", () => events.open(socket.protocol));
+            socket.addEventListener("message", ({ data }) => {
+                events.message(typeof data === "string" ? data : new Uint8Array(data));
+            });
+            socket.addEventListener("close", ({ code }) => events.close(code));
+            socket.addEventListener("error", () => events.error());
+            return {
+                // The natives send bytes of their own, never a view of a shared buffer.
+                send: (data) => socket.send(data),
+                close: (code) => socket.close(code),
+            };
+        },
+    };
+}
+/**
+ * The browser's async Clipboard API, which writes during a user's gesture
+ * without asking; HTML only where ClipboardItem takes it, else the text
+ * alone. Null where there is none, as in node.
+ */
+export function browserClipboard() {
+    const clipboard = globalThis.navigator?.clipboard;
+    if (!clipboard || typeof clipboard.writeText !== "function") {
+        return null;
+    }
+    const Item = globalThis.ClipboardItem;
+    return {
+        write: ({ text, html }) => {
+            const written = html !== undefined && Item && typeof clipboard.write === "function"
+                ? clipboard.write([
+                    new Item({
+                        "text/plain": new Blob([text], { type: "text/plain" }),
+                        "text/html": new Blob([html], { type: "text/html" }),
+                    }),
+                ])
+                : clipboard.writeText(text);
+            written.catch(() => { });
+        },
+    };
+}

package/dist/thread/player/input/avm1.js

@@ -0,0 +1,82 @@
+import { Avm1Pointer } from "../avm1/pointer.js";
+export class LoadedAvm1Input {
+    s;
+    movies = new Map();
+    over = null;
+    constructor(s) {
+        this.s = s;
+    }
+    add(root, vm) {
+        const stage = this.s.stage;
+        if (!stage) {
+            return;
+        }
+        const pointer = new Avm1Pointer(stage, vm, root);
+        pointer.onCursor = () => this.s.pointer?.updateCursor();
+        this.movies.set(root, pointer);
+    }
+    remove(root) {
+        const pointer = this.movies.get(root);
+        if (this.over === pointer) {
+            this.over = null;
+        }
+        this.movies.delete(root);
+        return this.movies.size === 0;
+    }
+    /** A stable callback for the AS3 pick: the AVM1Movie stands in for its interactive children. */
+    hit = (root, x, y) => this.movies.get(root)?.hit(x, y) ?? false;
+    broadcast(type, p) {
+        for (const pointer of this.movies.values()) {
+            pointer.broadcast(type, p);
+        }
+    }
+    /** Global listeners ran already; only the winning movie gets button picks. */
+    prepare(type, p, target) {
+        this.over = this.movies.get(target) ?? null;
+        let redraws = 0;
+        for (const pointer of this.movies.values()) {
+            const before = pointer.redraws;
+            pointer.pickable = pointer === this.over;
+            if (type === "move") {
+                pointer.handle(type, p, false);
+            }
+            else {
+                pointer.sync(p, pointer.pickable);
+            }
+            redraws += pointer.redraws - before;
+        }
+        return redraws;
+    }
+    finish(type, p) {
+        let redraws = 0;
+        for (const pointer of this.movies.values()) {
+            const before = pointer.redraws;
+            pointer.handle(type, p, false);
+            redraws += pointer.redraws - before;
+        }
+        return redraws;
+    }
+    sync(p, target) {
+        this.over = this.movies.get(target) ?? null;
+        let redraws = 0;
+        for (const pointer of this.movies.values()) {
+            const before = pointer.redraws;
+            pointer.sync(p, pointer === this.over);
+            redraws += pointer.redraws - before;
+        }
+        return redraws;
+    }
+    leave(p) {
+        let redraws = 0;
+        this.over = null;
+        for (const pointer of this.movies.values()) {
+            const before = pointer.redraws;
+            pointer.handle("leave", p, false);
+            redraws += pointer.redraws - before;
+        }
+        return redraws;
+    }
+    cursor() {
+        return this.over?.cursor() ?? null;
+    }
+}

package/dist/thread/player/input/context-menu.js

@@ -0,0 +1,63 @@
+import { dispatchTo } from "../scripting/events.js";
+import { pointerTarget } from "./pointer.js";
+export function customContextMenu(s, stage, p) {
+    const result = { items: [], quality: s.showDefaultContextMenu };
+    s.mouseStageX = p.x;
+    s.mouseStageY = p.y;
+    const rt = s.rt;
+    const get = (o, name) => rt.getProperty(o, rt.publicName(name));
+    const picked = pointerTarget(stage, p.x, p.y, s.stageViewportWidth || s.stageWidth, s.stageViewportHeight || s.stageHeight, undefined, s.stageViewportX, s.stageViewportY);
+    const target = picked === stage ? s.root : picked;
+    let owner = target;
+    let menu = null;
+    for (; owner; owner = owner.parent) {
+        const value = owner.object?.$contextMenu;
+        if (value && rt.isInstance(value, rt.classNamed("flash.ui::ContextMenu"))) {
+            menu = value;
+            break;
+        }
+    }
+    if (!menu) {
+        return result;
+    }
+    const mouse = target?.object ?? null;
+    const contextOwner = owner?.object ?? null;
+    const event = (type) => rt.construct(rt.classNamed("flash.events::ContextMenuEvent"), type, false, false, mouse, contextOwner);
+    dispatchTo(s, menu, event("menuSelect"));
+    const builtIn = get(menu, "builtInItems");
+    result.quality &&= !!builtIn && rt.toBoolean(get(builtIn, "quality"));
+    const custom = get(menu, "customItems");
+    if (!custom) {
+        return result;
+    }
+    const length = rt.toUint(get(custom, "length"));
+    const cls = rt.classNamed("flash.ui::ContextMenuItem");
+    const captions = new Set();
+    let selected = false;
+    for (let i = 0; i < length && result.items.length < 15; i++) {
+        const item = get(custom, String(i));
+        if (!rt.isInstance(item, cls) || !rt.toBoolean(get(item, "visible"))) {
+            continue;
+        }
+        const caption = rt.toString(get(item, "caption"));
+        if (!caption || captions.has(caption)) {
+            continue;
+        }
+        captions.add(caption);
+        const enabled = rt.toBoolean(get(item, "enabled"));
+        result.items.push({
+            caption,
+            enabled,
+            separatorBefore: rt.toBoolean(get(item, "separatorBefore")),
+            select: () => {
+                if (!enabled || selected || s.destroyed) {
+                    return;
+                }
+                selected = true;
+                s.clipboard.gesture(() => dispatchTo(s, item, event("menuItemSelect")));
+                s.updates++;
+            },
+        });
+    }
+    return result;
+}