@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,352 @@
+// What an AVM1 load brings, made ready before the frame that delivers it:
+// a SWF read, its library's images decoded, or an image file's pixels,
+// sniffed by their bytes and not by the URL, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) core/src/loader.rs
+// (ContentType::sniff, movie_loader_data) has it: MIT OR Apache-2.0,
+// Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+//
+// AVM1 plays what it loads as AVM1, an ActionScript 3 SWF too: its
+// timeline plays and none of its code runs, as Ruffle forces such a SWF
+// to AVM1 (docs/avm1.md, "Loading movies").
+//
+// MovieLoads keeps loadMovie's and MovieClipLoader's loads from when they
+// are asked until they are done with: each arrives between frames in the
+// order asked, unloads what its clip showed and fills it, telling the
+// loader's listeners as it goes.
+import { readSwf } from "../../format/index.js";
+import { avm1 } from "../../runtime/index.js";
+import { BitmapStore } from "../bitmap/bitmap.js";
+import { decodeImageFile, decodeImages, imageFormat } from "../bitmap/images.js";
+import { BitmapObject, EMPTY_TIMELINE, MovieClip } from "../display/display.js";
+import { readLibrary, } from "../display/timeline.js";
+import { resolve } from "../scripting/loads.js";
+import { formRequest } from "./globals/LoadVars.js";
+import { textFor } from "./net.js";
+import { CALL, NO_BLOCKS, NORMAL, Queued } from "./queue.js";
+import { Avm1Swf, readRootFrames } from "./swf.js";
+/** What `result`'s bytes are, read and decoded as far as a frame needs them. */
+async function arrive(result, decode) {
+    const bytes = result.bytes;
+    const status = result.status;
+    if (bytes === null) {
+        return { type: "failed", status };
+    }
+    const format = imageFormat(bytes);
+    if (format !== null) {
+        const pixels = await decodeImageFile(bytes, format, decode);
+        return { type: "image", pixels, size: bytes.length, status };
+    }
+    const signature = String.fromCharCode(bytes[0], bytes[1], bytes[2]);
+    if (signature !== "FWS" && signature !== "CWS" && signature !== "ZWS") {
+        return { type: "unknown", status };
+    }
+    let swf;
+    let library;
+    try {
+        swf = readSwf(bytes);
+        library = readLibrary(swf);
+    }
+    catch {
+        return { type: "unknown", status };
+    }
+    await decodeImages(library, decode);
+    return { type: "swf", swf, library, size: bytes.length, status };
+}
+/**
+ * A URL's query as a loaded SWF's root gets it, each name a variable, as
+ * Ruffle's movie_loader_complete defines a movie's parameters: decoded,
+ * `+` a space, a name without `=` an empty value.
+ */
+function queryVariables(url) {
+    const path = url.split("#", 1)[0];
+    const at = path.indexOf("?");
+    if (at < 0) {
+        return [];
+    }
+    return [...new URLSearchParams(path.slice(at + 1))];
+}
+/** What a load replaced or cancelled before it was read brings: nothing it reads. */
+const SKIPPED = { type: "failed", status: 0 };
+/** The longest a load waits for the one asked before it, in ms, to arrive in their order. */
+const ORDER_WAIT = 2000;
+/** `previous` settled, or `ms` passed, whichever comes first. */
+function within(previous, ms) {
+    let timer;
+    const passed = new Promise((resolve) => {
+        timer = setTimeout(resolve, ms);
+    });
+    return Promise.race([previous, passed]).finally(() => clearTimeout(timer));
+}
+/** What a clip unloaded or in error shows: no frames, which it never enters. */
+const NO_FRAMES = { ...EMPTY_TIMELINE, frames: [] };
+/** loadMovie's and MovieClipLoader's loads, which the movie owns. */
+export class MovieLoads {
+    movie;
+    decodeImage;
+    /** The loads asked, in order, until they are done with. */
+    movieLoads = [];
+    /**
+     * The last load's arrival, nothing, into each clip and by each
+     * MovieClipLoader, which the next one's waits for: they arrive in the
+     * order asked.
+     */
+    arrivals = new WeakMap();
+    constructor(movie, decodeImage) {
+        this.movie = movie;
+        this.decodeImage = decodeImage;
+    }
+    /**
+     * loadMovie and loadMovieNum: the SWF or image at `url` into a clip, or
+     * into a level, which the load makes where there is none; an empty URL
+     * unloads what is there.
+     */
+    loadMovie(into, url, form) {
+        if (typeof into === "number") {
+            const level = this.movie.level(into);
+            if (url !== "") {
+                this.startLoad(level ?? this.movie.levelToLoad(into), url, form, null);
+            }
+            else if (level !== null) {
+                this.unloadMovie(level);
+            }
+        }
+        else if (into instanceof MovieClip) {
+            if (url !== "") {
+                this.startLoad(into, url, form, null);
+            }
+            else {
+                this.unloadMovie(into);
+            }
+        }
+    }
+    /**
+     * MovieClipLoader.loadClip: the SWF or image at `url` into `target`,
+     * `loader`'s listeners told of it; false for a target that is no clip.
+     */
+    loadClip(loader, target, url) {
+        if (!(target instanceof MovieClip)) {
+            return false;
+        }
+        this.startLoad(target, url, null, loader);
+        return true;
+    }
+    /**
+     * A load into `target` asked: the request goes now, and what it brings,
+     * read and its code compiled, arrives between frames, each load in the
+     * order asked, as Ruffle's test runner has them arrive; one whose answer
+     * is slow to come holds those after it a while at most.
+     */
+    startLoad(target, url, form, loader) {
+        // A load into a clip that another is under way into replaces it, which tells nothing.
+        for (const earlier of this.movieLoads) {
+            if (earlier.target === target && earlier.status === "pending") {
+                earlier.status = "done";
+            }
+        }
+        const request = form === null
+            ? { url, method: "GET", headers: [], body: null }
+            : formRequest(url, form.method, form.vars);
+        const load = {
+            target,
+            loader,
+            url: resolve(this.movie.url, url),
+            status: "pending",
+        };
+        this.movieLoads.push(load);
+        const arrival = this.movie.net
+            .request(request, "content")
+            .then(async (result) => {
+            // One replaced or cancelled meanwhile is not read, nor its code compiled.
+            if (load.status !== "pending") {
+                return SKIPPED;
+            }
+            // What came is the final URL's: a redirect to another origin must not pass as the one asked for.
+            if (result.url) {
+                load.url = result.url;
+            }
+            const a = await arrive(result, this.decodeImage);
+            if (a.type !== "swf") {
+                return a;
+            }
+            if (load.status !== "pending") {
+                return SKIPPED;
+            }
+            return { ...a, blocks: await this.movie.compile(a.swf, a.library.actions ?? null) };
+        })
+            .catch(() => ({ type: "unknown", status: 0 }));
+        // After the loads asked before it into the same clip or by the same loader, which
+        // are kept by what they settle to, nothing, not by what they brought.
+        const keys = loader === null ? [target] : [target, loader];
+        const previous = Promise.all(keys.map((key) => this.arrivals.get(key)));
+        const ordered = within(previous, ORDER_WAIT).then(() => arrival);
+        const settled = ordered.then(() => { });
+        for (const key of keys) {
+            this.arrivals.set(key, settled);
+        }
+        this.movie.net.after(ordered, (arrived) => this.arrived(load, arrived));
+    }
+    /**
+     * A load's bytes arrived, between frames: as Ruffle's movie_loader has
+     * it, what the clip showed unloads, its variables go, and onLoadStart;
+     * then the SWF or image takes its place, or an empty one where the bytes
+     * are neither, with onLoadProgress and onLoadComplete, or onLoadError
+     * where nothing came. A clip removed meanwhile takes nothing, and
+     * nothing is told; one a listener removes or unloads is told no more.
+     */
+    arrived(load, arrived) {
+        const target = load.target;
+        const face = target.avm1 ?? undefined;
+        const over = () => load.status !== "pending" || this.movie.removed(target);
+        // Told, and whether the load goes on.
+        const told = (name, args) => {
+            this.tell(load, name, args);
+            return !over();
+        };
+        if (over()) {
+            // One an unload cancelled still starts, and no more (the corpus's load_cancel_*).
+            if (load.status === "cancelled" && !this.movie.removed(target)) {
+                this.tell(load, "onLoadStart", [face]);
+            }
+            load.status = "done";
+            return;
+        }
+        const version = this.movie.swfOf(target).version;
+        this.movie.unload(target);
+        if (face !== undefined) {
+            for (const p of [...face.ownProperties()]) {
+                if ((p.flags & avm1.DONT_DELETE) === 0) {
+                    face.remove(p);
+                }
+            }
+        }
+        this.movie.fill(target, new Avm1Swf(null, null, version, load.url, 0));
+        if (!told("onLoadStart", [face])) {
+            load.status = "done";
+            return;
+        }
+        // Flash's error state: no frames, none loaded, no version, and -1 bytes (the corpus's
+        // movieclip_state_values).
+        const error = () => this.movie.fill(target, new Avm1Swf(null, null, 0, load.url, -1), NO_FRAMES);
+        let going = true;
+        switch (arrived.type) {
+            case "failed":
+                error();
+                load.status = "done";
+                this.tell(load, "onLoadError", [face, "URLNotFound", arrived.status]);
+                return;
+            case "unknown":
+                error();
+                going = told("onLoadProgress", [face, 0, 0]);
+                break;
+            case "image": {
+                // An image is a movie of no version, its one frame the image at depth 1.
+                const swf = new Avm1Swf(null, null, 0, load.url, arrived.size);
+                this.movie.fill(target, swf);
+                if (arrived.pixels !== null) {
+                    target.placeAtDepth(new BitmapObject(BitmapStore.of(arrived.pixels)), 1);
+                }
+                going = told("onLoadProgress", [face, arrived.size, arrived.size]);
+                break;
+            }
+            case "swf": {
+                const { swf: file, library, size } = arrived;
+                const swf = new Avm1Swf(library, library.actions ?? null, file.header.version, load.url, file.header.fileLength, size);
+                swf.blocks = arrived.blocks;
+                this.movie.external.ownCode(swf);
+                this.movie.adopt(swf);
+                readRootFrames(file, swf);
+                this.movie.fill(target, swf);
+                // The URL's query as the root's variables, as a movie's parameters.
+                if (face !== undefined) {
+                    for (const [name, value] of queryVariables(load.url)) {
+                        face.define(name, textFor(value, swf.version), 0);
+                    }
+                }
+                // Ruffle tells a load into level 0 twice.
+                going =
+                    (target !== this.movie.root || told("onLoadProgress", [face, size, size])) &&
+                        told("onLoadProgress", [face, size, size]);
+                break;
+            }
+        }
+        if (!going) {
+            load.status = "done";
+            return;
+        }
+        load.status = "loaded";
+        this.tell(load, "onLoadComplete", [face, arrived.status]);
+        // No onLoadInit for one a listener removed or unloaded.
+        if (this.movie.removed(target)) {
+            load.status = "done";
+        }
+    }
+    /**
+     * `load`'s loader's listeners told `name`, through its broadcastMessage,
+     * as a script would call it.
+     */
+    tell(load, name, args) {
+        if (load.loader !== null && !this.movie.halted) {
+            this.movie.callback(load.loader, "broadcastMessage", [name, ...args]);
+        }
+    }
+    /**
+     * Each load that has arrived done with: one that loaded has its
+     * loader's onLoadInit queued, after the frame's actions of what it
+     * loaded, the latest load's first (Ruffle's movie_clip_on_load).
+     */
+    loadsInitialized() {
+        for (let i = this.movieLoads.length - 1; i >= 0; i--) {
+            const load = this.movieLoads[i];
+            if (load.status === "pending") {
+                continue;
+            }
+            this.movieLoads.splice(i, 1);
+            if (load.status === "loaded" && load.loader !== null) {
+                this.movie.queue.enqueue(NORMAL, new Queued(CALL, this.movie.root, null, 0, 0, false, "broadcastMessage", NO_BLOCKS, load.loader, ["onLoadInit", load.target.avm1 ?? undefined]));
+            }
+        }
+    }
+    /**
+     * unloadMovie: what `d` shows unloaded, its unload events, and it left
+     * empty, as an empty movie of its parent's SWF; a level's or a loaded
+     * movie's root's between frames, a frame later, as Ruffle's
+     * avm1_unload_movie has them. A load into it under way is cancelled: it
+     * tells of its start as it arrives, and no more.
+     */
+    unloadMovie(d) {
+        if (!(d instanceof MovieClip)) {
+            return;
+        }
+        // One under way tells of its start as it arrives; one arrived has no onLoadInit.
+        for (const load of this.movieLoads) {
+            if (load.target === d && load.status === "pending") {
+                load.status = "cancelled";
+            }
+            else if (load.target === d && load.status === "loaded") {
+                load.status = "done";
+            }
+        }
+        if (this.movie.levelOf(d) !== null || this.movie.contents.has(d)) {
+            this.movie.net.after(Promise.resolve(), () => this.unloaded(d));
+        }
+        else {
+            this.unloaded(d);
+        }
+    }
+    /** `d` unloaded and left empty. */
+    unloaded(d) {
+        if (this.movie.removed(d)) {
+            return;
+        }
+        const parent = this.movie.levelOf(d) !== null ? null : d.parent;
+        const swf = parent === null ? this.movie.swfOf(d) : this.movie.swfOf(parent);
+        // The movie it played goes with it, and what codegen keeps of it: compiling its units again
+        // copies it in again.
+        const unloading = this.movie.swfOf(d);
+        if (unloading.root === d) {
+            this.movie.releaseCode(unloading);
+        }
+        this.movie.unload(d);
+        this.movie.fill(d, new Avm1Swf(null, null, swf.version, parent === null ? "" : swf.url, 0), NO_FRAMES);
+    }
+}

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

@@ -0,0 +1,219 @@
+import { resolve } from "../scripting/loads.js";
+const FAILED = { bytes: null, status: 0, headers: [] };
+const encoder = new TextEncoder();
+/**
+ * Text from the network as a SWF of `version` holds it: up to SWF 5 a
+ * string is bytes, a character each (the runtime's), here its UTF-8's.
+ */
+export function textFor(text, version) {
+    if (version > 5 || !/[^ -~\t\n\r]/.test(text)) {
+        return text;
+    }
+    const bytes = encoder.encode(text);
+    const parts = [];
+    for (let i = 0; i < bytes.length; i += 0x2000) {
+        parts.push(String.fromCharCode(...bytes.subarray(i, i + 0x2000)));
+    }
+    return parts.join("");
+}
+/** A string as the bytes it sends: up to SWF 5 its own bytes (UTF-8 past 0xFF), later its UTF-8. */
+export function bytesFor(text, version) {
+    if (version > 5) {
+        return encoder.encode(text);
+    }
+    const bytes = [];
+    for (const c of text) {
+        const code = c.codePointAt(0);
+        if (code <= 0xff) {
+            bytes.push(code);
+        }
+        else {
+            bytes.push(...encoder.encode(c));
+        }
+    }
+    return Uint8Array.from(bytes);
+}
+export class Avm1Net {
+    fetchHost;
+    socketHost;
+    base;
+    sends;
+    /** Host callbacks held for the next frame, in the order they came. */
+    ready = [];
+    pending = new Set();
+    stopped = new AbortController();
+    /** The connections open, for destroy to close. */
+    connections = new Set();
+    destroyed = false;
+    constructor(fetchHost, socketHost, 
+    /** Where relative URLs resolve: the page's base where it gives one, else the SWF's URL. */
+    base, 
+    /** Whether a send without a window goes, as allowNetworking "internal" or "none" has it not. */
+    sends = true) {
+        this.fetchHost = fetchHost;
+        this.socketHost = socketHost;
+        this.base = base;
+        this.sends = sends;
+    }
+    /** `url` as the request goes out: against the base, as a load's URL resolves in AS3. */
+    resolve(url) {
+        return resolve(this.base, url);
+    }
+    /**
+     * `request` sent by the host's fetch, as "data", which the host judges
+     * as it judges a URLLoader's; `deliver` gets the result in a frame
+     * after, a failure as no bytes, status 0, where nothing answered.
+     */
+    fetch(request, deliver) {
+        this.after(this.request(request, "data"), deliver);
+    }
+    /**
+     * `request` sent by the host's fetch, as `purpose`: its result, a
+     * failure as no bytes, status 0, where nothing answered. A movie's load
+     * is "content", as AS3's Loader's is.
+     */
+    request(request, purpose, signal) {
+        const fetch = this.fetchHost;
+        if (this.destroyed) {
+            return Promise.resolve(FAILED);
+        }
+        const outgoing = { ...request, url: this.resolve(request.url), purpose };
+        return (fetch
+            ? fetch(outgoing, signal ? AbortSignal.any([signal, this.stopped.signal]) : this.stopped.signal)
+            : Promise.reject()).then((result) => result, () => FAILED);
+    }
+    /**
+     * `task`'s value delivered to `deliver` in a frame after it settles;
+     * nothing for one that fails.
+     */
+    after(task, deliver) {
+        this.track(task.then((value) => this.defer(() => deliver(value)), () => { }));
+    }
+    /**
+     * `request` sent and its answer dropped, as a send without a window is,
+     * as AS3's sendToURL is: whether it went, which allowNetworking
+     * "internal" refuses as it refuses sendToURL.
+     */
+    send(request) {
+        if (!this.sends || this.destroyed) {
+            return false;
+        }
+        this.fetchHost?.({ ...request, url: this.resolve(request.url), purpose: "send" }, this.stopped.signal).catch(() => { });
+        return true;
+    }
+    /**
+     * A connection to `host` and `port` through the host's sockets, its
+     * events held for the next frame; null where there are none, or the host
+     * refused at once, which `refused` is then called for in a frame after.
+     * One that has not opened `timeout` ms on (none for 0) is closed, and
+     * fails as a refused one does, as XMLSocket.timeout has it.
+     */
+    connect(host, port, events, refused, timeout = 0) {
+        const sockets = this.socketHost;
+        if (sockets === null || this.destroyed) {
+            this.defer(refused);
+            return null;
+        }
+        let transport = null;
+        let timer = null;
+        let opened = false;
+        let ended = false;
+        const stopTimer = () => {
+            if (timer !== null) {
+                clearTimeout(timer);
+                timer = null;
+            }
+        };
+        // Closed or failed, by either end or the timeout: forgotten, and the timeout has nothing to do.
+        const end = () => {
+            ended = true;
+            stopTimer();
+            if (transport !== null) {
+                this.connections.delete(transport);
+            }
+        };
+        try {
+            transport = sockets.connect(host, port, {
+                open: (endpoints) => {
+                    opened = true;
+                    stopTimer();
+                    this.defer(() => events.open(endpoints));
+                },
+                data: (bytes) => {
+                    const copy = bytes.slice();
+                    this.defer(() => events.data(copy));
+                },
+                close: () => {
+                    end();
+                    this.defer(() => events.close());
+                },
+                error: (message) => {
+                    end();
+                    this.defer(() => events.error(message));
+                },
+            });
+        }
+        catch {
+            this.defer(refused);
+            return null;
+        }
+        if (ended) {
+            return transport;
+        }
+        this.connections.add(transport);
+        if (!opened && timeout > 0) {
+            const opening = transport;
+            timer = setTimeout(() => {
+                timer = null;
+                // Closed by the script, or the player gone, meanwhile: nothing to time out.
+                if (opened || ended || !this.connections.has(opening)) {
+                    return;
+                }
+                end();
+                opening.close();
+                this.defer(() => events.error("timeout"));
+            }, timeout);
+        }
+        return transport;
+    }
+    /** A connection the script closed: destroy need not close it. */
+    closed(transport) {
+        this.connections.delete(transport);
+        transport.close();
+    }
+    /** The callbacks the host has made since the last call, to deliver now. */
+    take() {
+        const ready = this.ready;
+        this.ready = [];
+        return ready;
+    }
+    /** Resolves once every request so far has come back, and is held for the next frame. */
+    settled() {
+        return Promise.all([...this.pending]).then(() => { });
+    }
+    /**
+     * The player gone, or its SWF stopped for good: the fetches under way are
+     * aborted, the connections closed, and nothing more is held.
+     */
+    destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        this.ready = [];
+        this.stopped.abort();
+        for (const transport of [...this.connections]) {
+            this.connections.delete(transport);
+            transport.close();
+        }
+    }
+    defer(event) {
+        if (!this.destroyed) {
+            this.ready.push(event);
+        }
+    }
+    track(task) {
+        this.pending.add(task);
+        void task.then(() => this.pending.delete(task));
+    }
+}

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

@@ -0,0 +1,104 @@
+// AVM1's names for display objects, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) core/src/display_object.rs (path,
+// slash_path, avm1_parent) and container.rs (child_by_name) have them: MIT
+// OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle
+// contributors. Where adl parts from Ruffle, adl decides (docs/avm1.md,
+// "Clips and paths").
+import { avm1 } from "../../runtime/index.js";
+import { Container } from "../display/display.js";
+/** ASCII's lower case, as Flash compares instance names and frame labels without case. */
+export function asciiLower(s) {
+    // A loop and not a regular expression's test, which allocates: clips' display properties are looked up so.
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c >= 0x41 && c <= 0x5a) {
+            return s.replace(/[A-Z]/g, (u) => String.fromCharCode(u.charCodeAt(0) + 32));
+        }
+    }
+    return s;
+}
+/**
+ * The dot path of `d`, `_level0.a.b`, as a clip converts to a string and
+ * TargetPath gives it: from its level, or from level 0 for one off the
+ * display list.
+ */
+export function pathOf(d, levelOf) {
+    const names = [];
+    let level = 0;
+    for (let o = d; o !== null; o = o.parent) {
+        const n = levelOf(o);
+        if (n !== null) {
+            level = n;
+            break;
+        }
+        names.push(o.name);
+    }
+    names.push(`_level${level}`);
+    return names.reverse().join(".");
+}
+/**
+ * The slash path of `d`, `_target`'s: "/" for a level, `/a/b` below level
+ * 0 and `_level1/a/b` below another, as Ruffle's slash_path has it.
+ */
+export function slashPathOf(d, levelOf) {
+    if (levelOf(d) !== null) {
+        return "/";
+    }
+    const names = [];
+    let level = 0;
+    for (let o = d; o !== null; o = o.parent) {
+        const n = levelOf(o);
+        if (n !== null) {
+            level = n;
+            break;
+        }
+        names.push(o.name);
+    }
+    return `${level === 0 ? "" : `_level${level}`}/${names.reverse().join("/")}`;
+}
+/**
+ * The child of `d` named `name`, the lowest in depth of those that are, in
+ * its case or, up to SWF 6, folded as Flash folds names (the corpus's
+ * `swf6_case_insensitive`).
+ */
+export function childByName(d, name, caseSensitive) {
+    if (!(d instanceof Container)) {
+        return null;
+    }
+    // An object without a name, a shape's, has none to find it by. Folding
+    // keeps a name's length, so a name of another length is passed by
+    // unfolded: `_x` read on a clip asks each of its children.
+    const key = caseSensitive ? name : avm1.fold(name);
+    for (const child of d.children) {
+        const n = child.name;
+        if (n.length === key.length && n !== "" && (caseSensitive ? n : avm1.fold(n)) === key) {
+            return child;
+        }
+    }
+    return null;
+}
+/**
+ * The display object at a dot path, `_level0.a.b`, as a clip's reference
+ * finds it again: names from the level, each a child. Null where none is.
+ */
+export function atPath(path, level, caseSensitive) {
+    const parts = path.split(".");
+    const match = /^_level(-?\d+)$/.exec(parts[0]);
+    if (match === null) {
+        return null;
+    }
+    let d = level(Number(match[1]));
+    for (let i = 1; i < parts.length && d !== null; i++) {
+        d = childByName(d, parts[i], caseSensitive);
+    }
+    return d;
+}
+/** Whether `d` is on `root`'s display list, the root itself included. */
+export function under(d, root) {
+    for (let o = d; o !== null; o = o.parent) {
+        if (o === root) {
+            return true;
+        }
+    }
+    return false;
+}