@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/text/text.js

@@ -0,0 +1,431 @@
+// A TextField's text and formatting, as Flash keeps them: the characters,
+// each with its own format, and a default format for text that comes with
+// none. Its htmlText is written as Flash writes it, a P for each paragraph
+// with a FONT of the run's five font attributes and a FONT inside it for
+// each later run's changes, and read as Flash reads it, a paragraph's end
+// and a BR a line only in a multiline field.
+/** A new TextField's defaultTextFormat, as adl gives it. */
+export const DEFAULT_FORMAT = {
+    font: "Times New Roman",
+    size: 12,
+    color: 0,
+    bold: false,
+    italic: false,
+    underline: false,
+    url: "",
+    target: "",
+    align: "left",
+    leftMargin: 0,
+    rightMargin: 0,
+    indent: 0,
+    leading: 0,
+    blockIndent: 0,
+    letterSpacing: 0,
+    kerning: false,
+    bullet: false,
+    tabStops: [],
+    display: "block",
+};
+const FORMAT_KEYS = Object.keys(DEFAULT_FORMAT);
+/** A TextFormat that sets nothing. */
+export function emptyFormat() {
+    const out = {};
+    for (const k of FORMAT_KEYS) {
+        out[k] = null;
+    }
+    out.display = "block";
+    return out;
+}
+/** `base` with what `change` sets. */
+export function applied(base, change) {
+    const out = { ...base };
+    for (const k of FORMAT_KEYS) {
+        const v = change[k];
+        if (v !== null) {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+function same(a, b) {
+    return (a === b ||
+        FORMAT_KEYS.every((k) => k === "tabStops" ? a.tabStops.join() === b.tabStops.join() : a[k] === b[k]));
+}
+/** Text as a field keeps it: Flash's line ends are \r. */
+function normalize(text) {
+    return text.replace(/\r\n|\n/g, "\r");
+}
+export class TextModel {
+    text = "";
+    /** Each character's format; runs share one object. */
+    formats = [];
+    /** Counts the changes, text, formats or the default, for a layout to know it is current. */
+    revision = 0;
+    fallback = { ...DEFAULT_FORMAT };
+    /** The format of text set as a whole, and of an empty field's line. */
+    get defaultFormat() {
+        return this.fallback;
+    }
+    set defaultFormat(format) {
+        this.fallback = format;
+        this.revision++;
+    }
+    /** The text, all in the default format, as `text` sets it. */
+    setText(text) {
+        this.revision++;
+        this.text = normalize(text);
+        this.formats = new Array(this.text.length).fill(this.defaultFormat);
+    }
+    /**
+     * `text` in place of [begin, end), as replaceText and appendText put it:
+     * in the format of the character before, else of the one it replaces,
+     * else the default.
+     */
+    replace(begin, end, text) {
+        this.revision++;
+        const inserted = normalize(text);
+        const format = this.formats[begin - 1] ?? this.formats[begin] ?? this.defaultFormat;
+        this.text = this.text.slice(0, begin) + inserted + this.text.slice(end);
+        // Not splice with the formats spread: a long text would be more arguments than a call takes.
+        this.formats = this.formats
+            .slice(0, begin)
+            .concat(new Array(inserted.length).fill(format), this.formats.slice(end));
+    }
+    /** What [begin, end) has in common: each value null where its characters differ; the default's for none. */
+    formatOf(begin, end) {
+        const out = { ...(this.formats[begin] ?? this.defaultFormat) };
+        for (let i = begin + 1; i < end; i++) {
+            const f = this.formats[i];
+            for (const k of FORMAT_KEYS) {
+                const v = out[k];
+                if (v !== null &&
+                    (k === "tabStops" ? v.join() !== f.tabStops.join() : v !== f[k])) {
+                    out[k] = null;
+                }
+            }
+        }
+        return out;
+    }
+    /** [begin, end) cut where the format changes: each run's [from, to). */
+    runs(begin, end) {
+        const out = [];
+        for (let i = begin; i < end; i++) {
+            const last = out[out.length - 1];
+            if (last && same(this.formats[i - 1], this.formats[i])) {
+                last[1] = i + 1;
+            }
+            else {
+                out.push([i, i + 1]);
+            }
+        }
+        return out;
+    }
+    /** [begin, end) given what `change` sets, as setTextFormat does. */
+    setFormat(change, begin, end) {
+        this.revision++;
+        const made = new Map();
+        for (let i = begin; i < end; i++) {
+            const old = this.formats[i];
+            let next = made.get(old);
+            if (!next) {
+                next = applied(old, change);
+                made.set(old, next);
+            }
+            this.formats[i] = next;
+        }
+    }
+    /** The runs of each paragraph: its text up to a \r, in runs of one format. */
+    paragraphs() {
+        const out = [];
+        let runs = [];
+        for (let i = 0; i < this.text.length; i++) {
+            const c = this.text[i];
+            if (c === "\r") {
+                out.push(runs);
+                runs = [];
+                continue;
+            }
+            const last = runs[runs.length - 1];
+            if (last && same(last.format, this.formats[i])) {
+                last.text += c;
+            }
+            else {
+                runs.push({ format: this.formats[i], text: c });
+            }
+        }
+        if (runs.length) {
+            out.push(runs);
+        }
+        return out;
+    }
+    /** The text as htmlText gives it. */
+    toHtml() {
+        const out = [];
+        for (const runs of this.paragraphs()) {
+            const first = runs[0]?.format ?? this.defaultFormat;
+            const block = [];
+            const extra = [];
+            for (const [key, name] of [
+                ["leftMargin", "LEFTMARGIN"],
+                ["rightMargin", "RIGHTMARGIN"],
+                ["indent", "INDENT"],
+                ["leading", "LEADING"],
+                ["blockIndent", "BLOCKINDENT"],
+            ]) {
+                if (first[key] !== 0) {
+                    extra.push(`${name}="${first[key]}"`);
+                }
+            }
+            if (first.tabStops.length) {
+                extra.push(`TABSTOPS="${first.tabStops.join(",")}"`);
+            }
+            // A bullet's paragraph is an LI alone, with no P.
+            block.push(first.bullet ? "<LI>" : `<P ALIGN="${first.align.toUpperCase()}">`);
+            let open = 0;
+            let current = null;
+            for (const { format, text } of runs) {
+                const attributes = fontAttributes(format, current);
+                if (attributes) {
+                    block.push(`<FONT ${attributes}>`);
+                    open++;
+                }
+                current = format;
+                let run = escapeHtml(text);
+                if (format.underline) {
+                    run = `<U>${run}</U>`;
+                }
+                if (format.italic) {
+                    run = `<I>${run}</I>`;
+                }
+                if (format.bold) {
+                    run = `<B>${run}</B>`;
+                }
+                if (format.url) {
+                    run = `<A HREF="${escapeHtml(format.url)}" TARGET="${escapeHtml(format.target)}">${run}</A>`;
+                }
+                block.push(run);
+            }
+            if (!runs.length) {
+                block.push(`<FONT ${fontAttributes(first, null)}>`);
+                open++;
+            }
+            block.push("</FONT>".repeat(open));
+            block.push(first.bullet ? "</LI>" : "</P>");
+            out.push(extra.length
+                ? `<TEXTFORMAT ${extra.join(" ")}>${block.join("")}</TEXTFORMAT>`
+                : block.join(""));
+        }
+        return out.join("");
+    }
+    /**
+     * htmlText set: tags read as Flash reads them, each run in the format
+     * its tags give over the default; a paragraph's end and a BR end a line
+     * only in a multiline field. With `styles`, a style sheet's, each tag
+     * takes its tag's and class's styles.
+     */
+    setHtml(html, multiline, trimTrailingBreak = false, styles = null) {
+        this.revision++;
+        let text = "";
+        const formats = [];
+        const stack = [this.defaultFormat];
+        const top = () => stack[stack.length - 1];
+        const add = (s, format) => {
+            text += s;
+            for (let k = 0; k < s.length; k++) {
+                formats.push(format);
+            }
+        };
+        const line = () => {
+            if (multiline) {
+                add("\r", top());
+            }
+        };
+        // Under a sheet, the elements a style displays: a tag of the sheet's
+        // own is a block unless inline, ending its line when closed by name, as
+        // adl has it (the corpus's `edittext_stylesheet_display`); one displayed
+        // as none hides what it holds until then.
+        const open = [];
+        let hidden = 0;
+        const tag = /<(\/?)([a-zA-Z]+)([^>]*)>/g;
+        let at = 0;
+        for (let m = tag.exec(html); m; m = tag.exec(html)) {
+            const plain = html.slice(at, m.index);
+            if (plain && hidden === 0) {
+                add(normalize(unescapeHtml(plain)), top());
+            }
+            at = m.index + m[0].length;
+            const closing = m[1] === "/";
+            const name = m[2].toLowerCase();
+            if (name === "br") {
+                line();
+                continue;
+            }
+            // Under a style sheet any tag may carry a style.
+            const known = ["p", "font", "b", "i", "u", "a", "textformat", "li", "span"];
+            if (!known.includes(name) && !styles) {
+                continue;
+            }
+            if (closing && open[open.length - 1]?.name === name) {
+                const element = open.pop();
+                hidden -= element.hides ? 1 : 0;
+                if (element.block && !text.endsWith("\r")) {
+                    add("\r", top());
+                }
+            }
+            if (closing) {
+                // A paragraph's line end is in the paragraph's format, as adl has it.
+                if (name === "p" || name === "li") {
+                    line();
+                }
+                if (stack.length > 1) {
+                    stack.pop();
+                }
+                continue;
+            }
+            const attributes = attributesOf(m[3]);
+            let f = { ...top() };
+            if (styles) {
+                // The tag's style, a link's, then its class's, each over the last;
+                // the display decides the element, not its characters' format.
+                const selectors = [name, ...(name === "a" ? ["a:link"] : [])];
+                if (attributes.class) {
+                    selectors.push(`.${attributes.class.toLowerCase()}`);
+                }
+                let display = "block";
+                for (const selector of selectors) {
+                    const style = styles(selector);
+                    if (style) {
+                        f = applied(f, { ...style, display: null });
+                        display = style.display ?? display;
+                    }
+                }
+                const hides = display === "none";
+                open.push({ name, block: !known.includes(name) && display !== "inline", hides });
+                hidden += hides ? 1 : 0;
+            }
+            switch (name) {
+                case "p":
+                    if (attributes.align) {
+                        f.align = attributes.align.toLowerCase();
+                    }
+                    break;
+                case "font":
+                    if (attributes.face) {
+                        f.font = attributes.face;
+                    }
+                    if (attributes.size) {
+                        const size = attributes.size;
+                        f.size = /^[+-]/.test(size) ? f.size + Number(size) : Number(size);
+                    }
+                    if (attributes.color) {
+                        f.color = Number.parseInt(attributes.color.replace("#", ""), 16) || 0;
+                    }
+                    if (attributes.letterspacing) {
+                        f.letterSpacing = Number(attributes.letterspacing) || 0;
+                    }
+                    if (attributes.kerning) {
+                        f.kerning = attributes.kerning !== "0";
+                    }
+                    break;
+                case "b":
+                    f.bold = true;
+                    break;
+                case "i":
+                    f.italic = true;
+                    break;
+                case "u":
+                    f.underline = true;
+                    break;
+                case "a":
+                    f.url = attributes.href ?? "";
+                    f.target = attributes.target ?? "";
+                    break;
+                case "li":
+                    f.bullet = true;
+                    break;
+                case "textformat":
+                    for (const [attribute, key] of [
+                        ["leftmargin", "leftMargin"],
+                        ["rightmargin", "rightMargin"],
+                        ["indent", "indent"],
+                        ["leading", "leading"],
+                        ["blockindent", "blockIndent"],
+                    ]) {
+                        if (attributes[attribute] !== undefined) {
+                            f[key] = Number(attributes[attribute]) || 0;
+                        }
+                    }
+                    if (attributes.tabstops) {
+                        f.tabStops = attributes.tabstops.split(",").map(Number);
+                    }
+                    break;
+            }
+            stack.push(f);
+        }
+        const rest = html.slice(at);
+        if (rest && hidden === 0) {
+            add(normalize(unescapeHtml(rest)), top());
+        }
+        if (trimTrailingBreak && text.endsWith("\r")) {
+            text = text.slice(0, -1);
+            formats.pop();
+        }
+        this.text = text;
+        this.formats = formats;
+    }
+}
+/** A FONT's attributes for `format`: all five for a paragraph's first run, else those that differ from `current`; "" for none. */
+function fontAttributes(format, current) {
+    const out = [];
+    if (!current || current.font !== format.font) {
+        out.push(`FACE="${escapeHtml(format.font)}"`);
+    }
+    if (!current || current.size !== format.size) {
+        out.push(`SIZE="${format.size}"`);
+    }
+    if (!current || current.color !== format.color) {
+        out.push(`COLOR="#${(format.color >>> 0).toString(16).toUpperCase().padStart(6, "0").slice(-6)}"`);
+    }
+    if (!current || current.letterSpacing !== format.letterSpacing) {
+        out.push(`LETTERSPACING="${format.letterSpacing}"`);
+    }
+    if (!current || current.kerning !== format.kerning) {
+        out.push(`KERNING="${format.kerning ? 1 : 0}"`);
+    }
+    return out.join(" ");
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function unescapeHtml(text) {
+    return text.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi, (whole, name) => {
+        if (name[0] === "#") {
+            const code = name[1] === "x" || name[1] === "X"
+                ? Number.parseInt(name.slice(2), 16)
+                : Number(name.slice(1));
+            return Number.isFinite(code) ? String.fromCodePoint(code) : whole;
+        }
+        const named = {
+            amp: "&",
+            lt: "<",
+            gt: ">",
+            quot: '"',
+            apos: "'",
+            nbsp: " ",
+        };
+        return named[name.toLowerCase()] ?? whole;
+    });
+}
+/** A tag's attributes by lower-case name, quoted with either quote or not. */
+function attributesOf(source) {
+    const out = {};
+    const attribute = /([a-zA-Z]+)\s*=\s*("([^"]*)"|'([^']*)'|([^\s>]+))/g;
+    for (let m = attribute.exec(source); m; m = attribute.exec(source)) {
+        out[m[1].toLowerCase()] = unescapeHtml(m[3] ?? m[4] ?? m[5] ?? "");
+    }
+    return out;
+}

package/dist/thread/player/workers/thread.js

@@ -0,0 +1,159 @@
+// A background worker's thread (docs/workers.md): a VM of its own, codegen,
+// runtime and playerglobal, playing the SWF createWorker was given with no
+// renderer, sound or input. Its frames run on a timer at the SWF's rate,
+// so that its timers, enterFrame and the events it is sent fire. A host
+// runs this in a Web Worker or a node worker_threads Worker; nothing here
+// knows which.
+import { createCodegen } from "../../codegen/index.js";
+import { avm2 } from "../../runtime/index.js";
+import { Player } from "../player.js";
+import { Scripting } from "../scripting.js";
+/** Run the worker the parent posts, on this thread, until the parent terminates it. */
+export function runWorkerThread(port) {
+    let scripting = null;
+    // Messages that came while the VM was being made, applied once it is.
+    const early = [];
+    // How many of the parent's messages have been applied, the start the first.
+    let applied = 0;
+    let idled = 0;
+    let player = null;
+    let stopped = false;
+    /**
+     * Once its worker is terminated, stop it for good, between frames, so
+     * that none of its code runs again, then say so in the shared memory: the
+     * Mutexes it held are free to take from then on. A lock or wait it asks
+     * for after it was terminated is refused, but the frame that asked plays
+     * on, its other listeners too, so this waits for the frame's end.
+     */
+    const stopIfTerminated = () => {
+        if (stopped || !scripting || !avm2.syncOf(scripting.rt).terminated) {
+            return stopped;
+        }
+        stopped = true;
+        try {
+            player?.destroy();
+            scripting.destroy();
+        }
+        catch (error) {
+            if (!(error instanceof avm2.SyncTerminated)) {
+                port.post({ type: "uncaught", text: describe(error) });
+            }
+        }
+        finally {
+            avm2.syncOf(scripting.rt).end(id);
+        }
+        return true;
+    };
+    let id = 0;
+    const describe = (error) => {
+        if (error instanceof Error) {
+            return `${error.name}: ${error.message}`;
+        }
+        try {
+            return scripting ? scripting.rt.toString(error) : String(error);
+        }
+        catch {
+            return "an error that could not be described";
+        }
+    };
+    const boot = async ({ codegen, init }) => {
+        id = init.id;
+        // What the embedder gave the primordial lives on its thread, as
+        // functions no message carries: a worker gets none of it, and none of
+        // the defaults that would reach past the primordial's (docs/workers.md).
+        const storage = new Map();
+        const s = new Scripting(await createCodegen(codegen), {
+            handedModules: init.modules,
+            url: init.url,
+            sandboxType: init.sandboxType,
+            air: init.air,
+            print: (line) => port.post({ type: "trace", line }),
+            onUncaught: (error) => port.post({ type: "uncaught", text: describe(error) }),
+            workerParent: { id: init.id, post: (message) => port.post(message), shared: init.shared },
+            // Its Mutexes, Conditions and channels' queues are among the primordial's.
+            sync: { memory: init.sync, thread: init.id },
+            audio: null,
+            navigate: null,
+            fileHost: null,
+            clipboard: null,
+            webSocket: null,
+            sendToUrl: false,
+            storage: {
+                get: (key) => storage.get(key) ?? null,
+                set: (key, bytes) => {
+                    storage.set(key, bytes.slice());
+                },
+                remove: (key) => {
+                    storage.delete(key);
+                },
+            },
+        });
+        await s.loadLibraries(init.libraries);
+        player = new Player(init.swf, s);
+        const playing = player;
+        scripting = s;
+        applied++;
+        for (const message of early.splice(0)) {
+            s.workers.fromParent(message);
+            applied++;
+        }
+        // Running, which the worker that made it sees at once.
+        avm2.syncOf(s.rt).start(init.id);
+        port.post({ type: "running" });
+        await playing.start();
+        if (stopIfTerminated()) {
+            return;
+        }
+        // Between frames none of its code runs: it stops there at once.
+        const watch = setInterval(() => {
+            if (stopIfTerminated()) {
+                clearInterval(watch);
+            }
+        }, 10);
+        // What was applied before a frame has had its events in it: the parent's settled() waits for that.
+        let last = performance.now();
+        const frame = () => {
+            if (stopIfTerminated()) {
+                return;
+            }
+            const upTo = applied;
+            const now = performance.now();
+            const played = playing.advance(now - last);
+            last = now;
+            if (stopIfTerminated()) {
+                return;
+            }
+            if (played > 0 && upTo > idled) {
+                idled = upTo;
+                port.post({ type: "idle", received: upTo });
+            }
+            setTimeout(frame, 1000 / playing.frameRate);
+        };
+        setTimeout(frame, 1000 / playing.frameRate);
+    };
+    port.listen((message) => {
+        if ("codegen" in message) {
+            boot(message).catch((error) => {
+                // A worker terminated while it started, its constructor waiting or
+                // its VM still being made, stops quietly.
+                if (stopIfTerminated()) {
+                    return;
+                }
+                if (error instanceof avm2.SyncTerminated) {
+                    stopped = true;
+                    new avm2.Sync(message.init.sync, message.init.id).end(message.init.id);
+                    return;
+                }
+                port.post({ type: "uncaught", text: describe(error) });
+                port.post({ type: "terminate" });
+            });
+            return;
+        }
+        if (!scripting) {
+            early.push(message);
+            return;
+        }
+        scripting.workers.fromParent(message);
+        applied++;
+    });
+}