@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/format/actions.js

@@ -0,0 +1,222 @@
+// A SWF's AVM1 action blocks, listed from its tags: DoAction, DoInitAction,
+// a PlaceObject 2 to 4's clip actions and a button's actions, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) swf/src/read.rs reads them
+// (read_clip_actions, read_clip_event_flags, read_define_button_1 and 2,
+// read_button_action) and its swf/src/types.rs numbers their flags: MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+// Where they differ on clip actions, what adl does decides (clipActions, the
+// list's `corrupt`). A malformed button action ends the button's list and
+// keeps those before it: adl defines the button, and its actions cannot run
+// there without a pointer to check them.
+import { buttonActionsOffset } from "./button.js";
+import { clipActionsOffset, readSprite } from "./display.js";
+import { SwfReader } from "./swf.js";
+import { DefineButton, DefineButton2, DefineSprite, DoAction, DoInitAction, PlaceObject2, PlaceObject3, PlaceObject4, ShowFrame, } from "./tags.js";
+/** A clip action's events, CLIPEVENTFLAGS' bits; SWF 5 has only the low 16. */
+export const ClipEvent = {
+    load: 1 << 0,
+    enterFrame: 1 << 1,
+    unload: 1 << 2,
+    mouseMove: 1 << 3,
+    mouseDown: 1 << 4,
+    mouseUp: 1 << 5,
+    keyDown: 1 << 6,
+    keyUp: 1 << 7,
+    data: 1 << 8,
+    initialize: 1 << 9,
+    press: 1 << 10,
+    release: 1 << 11,
+    releaseOutside: 1 << 12,
+    rollOver: 1 << 13,
+    rollOut: 1 << 14,
+    dragOver: 1 << 15,
+    dragOut: 1 << 16,
+    keyPress: 1 << 17,
+    construct: 1 << 18,
+};
+/** The bits Flash knows; it skips a record with none of them, and only flags of 0 end the list. */
+const CLIP_EVENTS = 0x7ffff;
+/** A button's state transitions, BUTTONCONDACTION's low 9 bits; its key code is above them. */
+export const ButtonCondition = {
+    idleToOverUp: 1 << 0,
+    overUpToIdle: 1 << 1,
+    overUpToOverDown: 1 << 2,
+    overDownToOverUp: 1 << 3,
+    overDownToOutDown: 1 << 4,
+    outDownToOverDown: 1 << 5,
+    outDownToIdle: 1 << 6,
+    idleToOverDown: 1 << 7,
+    overDownToIdle: 1 << 8,
+};
+/**
+ * A SWF's action blocks, a pure function of its bytes. A block may be empty.
+ * They are listed in an ActionScript 3 SWF too, where Flash runs none.
+ */
+export function readActions(swf) {
+    const list = {
+        version: swf.header.version,
+        blocks: [],
+        byTag: new Map(),
+        corrupt: [],
+        corruptEvents: new Map(),
+    };
+    walk(swf.bytes, swf.tags, null, list);
+    return list;
+}
+function walk(bytes, tags, timeline, list) {
+    let frame = 0;
+    for (const tag of tags) {
+        const end = tag.offset + tag.length;
+        switch (tag.code) {
+            case ShowFrame:
+                frame++;
+                break;
+            case DoAction:
+                add(list, tag, { type: "frame", timeline, frame }, tag.offset, end);
+                break;
+            case DoInitAction:
+                // A tag too short for its sprite id is no block, as Ruffle fails to read it.
+                if (tag.length >= 2) {
+                    const sprite = bytes[tag.offset] | (bytes[tag.offset + 1] << 8);
+                    add(list, tag, { type: "init", sprite, timeline, frame }, tag.offset + 2, end);
+                }
+                break;
+            case PlaceObject2:
+            case PlaceObject3:
+            case PlaceObject4: {
+                const { depth, offset } = clipActionsOffset(bytes, tag);
+                if (offset >= 0) {
+                    clipActions(bytes, tag, offset, list, timeline, frame, depth);
+                }
+                break;
+            }
+            case DefineButton:
+            case DefineButton2:
+                buttonActions(bytes, tag, list);
+                break;
+            case DefineSprite: {
+                const sprite = readSprite(bytes, tag);
+                walk(bytes, sprite.tags, sprite.id, list);
+                break;
+            }
+        }
+    }
+}
+function add(list, tag, owner, offset, end) {
+    const index = list.blocks.length;
+    list.blocks.push({ index, owner, tag: tag.offset, offset, length: end - offset });
+    const indices = list.byTag.get(tag.offset);
+    if (indices) {
+        indices.push(index);
+    }
+    else {
+        list.byTag.set(tag.offset, [index]);
+    }
+}
+function corrupt(list, tag, events) {
+    list.corrupt.push(tag.offset);
+    list.corruptEvents.set(tag.offset, events);
+}
+/** CLIPACTIONS: a reserved u16, the events Flash dispatches, then records to one of no events. */
+function clipActions(bytes, tag, start, list, timeline, frame, depth) {
+    const end = tag.offset + tag.length;
+    const r = new SwfReader(bytes, start, end);
+    const wide = list.version >= 6;
+    const flagSize = wide ? 4 : 2;
+    r.u16();
+    // Flags cut short end the list whatever their bytes, in adl as in Ruffle (its #2899).
+    const flags = () => {
+        if (r.pos + flagSize > end) {
+            r.pos = end;
+            return 0;
+        }
+        return wide ? r.u32() : r.u16();
+    };
+    // Flash runs a record only for the events this field also has.
+    const all = flags() & CLIP_EVENTS;
+    const records = [];
+    for (;;) {
+        const raw = flags();
+        if (raw === 0) {
+            break;
+        }
+        // A record cut short stops the whole SWF in Flash, before any of the place's records runs.
+        if (r.pos + 4 > end) {
+            corrupt(list, tag, all);
+            return;
+        }
+        const events = raw & all;
+        const length = r.u32();
+        let start = r.pos;
+        let key = 0;
+        // keyPress's key code is the first byte of the record's length. Flash
+        // reads it even of a length of 0, as the next record's first byte, and
+        // goes on from there: that record keeps its key and has no actions.
+        if (raw & ClipEvent.keyPress) {
+            if (r.pos >= end) {
+                corrupt(list, tag, all);
+                return;
+            }
+            key = bytes[r.pos];
+            start += Math.min(length, 1);
+        }
+        if (length > end - r.pos) {
+            corrupt(list, tag, all);
+            return;
+        }
+        if (events !== 0) {
+            const owner = { type: "clip", timeline, frame, depth, events, key };
+            records.push({ owner, start, end: r.pos + length });
+        }
+        r.pos += length;
+    }
+    for (const record of records) {
+        add(list, tag, record.owner, record.start, record.end);
+    }
+}
+/**
+ * DefineButton's actions run to the tag's end. DefineButton2's, after its
+ * records when its action offset is not 0, are BUTTONCONDACTIONs: a size,
+ * 0 for the last, which runs to the end, then the conditions and key.
+ */
+function buttonActions(bytes, tag, list) {
+    const { id, offset } = buttonActionsOffset(bytes, tag);
+    const end = tag.offset + tag.length;
+    if (offset < 0) {
+        return;
+    }
+    if (tag.code === DefineButton) {
+        const owner = {
+            type: "button",
+            button: id,
+            conditions: ButtonCondition.overDownToOverUp,
+            key: 0,
+        };
+        add(list, tag, owner, offset, end);
+        return;
+    }
+    const r = new SwfReader(bytes, offset, end);
+    for (;;) {
+        if (r.pos + 4 > end) {
+            return;
+        }
+        const size = r.u16();
+        const conditions = r.u16();
+        // Sizes 1 to 3 are shorter than the record's own head: Ruffle's error, so the end here.
+        if ((size !== 0 && size < 4) || size - 4 > end - r.pos) {
+            return;
+        }
+        const blockEnd = size === 0 ? end : r.pos + size - 4;
+        const owner = {
+            type: "button",
+            button: id,
+            conditions: conditions & 0x1ff,
+            key: conditions >> 9,
+        };
+        add(list, tag, owner, r.pos, blockEnd);
+        if (size === 0) {
+            return;
+        }
+        r.pos = blockEnd;
+    }
+}

package/dist/thread/format/air-descriptor.js

@@ -0,0 +1,63 @@
+// An AIR application's descriptor (`<name>-app.xml`), as adl reads what it
+// needs of one to run it: the application's id, and its first window's
+// content SWF, title and size. Elements are found by name, whatever
+// namespace the descriptor's AIR version gives them; what is not there is
+// left to its default. A desktop app reads it from disk, a page from an
+// AIR package (`.air`) or the files of one.
+/** The text of the first `<name>` element in `xml`, entities decoded; null for none. */
+function element(xml, name) {
+    const m = new RegExp(`<(?:[\\w.-]+:)?${name}(?:\\s[^>]*)?>([\\s\\S]*?)</(?:[\\w.-]+:)?${name}\\s*>`).exec(xml);
+    return m ? decode(m[1].trim()) : null;
+}
+/** XML's five entities and its character references, and a CDATA section's text. */
+function decode(text) {
+    const cdata = /^<!\[CDATA\[([\s\S]*)\]\]>$/.exec(text);
+    if (cdata) {
+        return cdata[1];
+    }
+    return text.replace(/&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);/gi, (_, e) => {
+        switch (e.toLowerCase()) {
+            case "amp":
+                return "&";
+            case "lt":
+                return "<";
+            case "gt":
+                return ">";
+            case "quot":
+                return '"';
+            case "apos":
+                return "'";
+            default:
+                return String.fromCodePoint(e[1].toLowerCase() === "x" ? Number.parseInt(e.slice(2), 16) : Number(e.slice(1)));
+        }
+    });
+}
+/** A whole number of pixels, or null for none or nonsense. */
+function size(text) {
+    const n = text === null ? Number.NaN : Number(text);
+    return Number.isInteger(n) && n > 0 ? n : null;
+}
+/** What `xml`, a descriptor, says; an Error naming what it lacks that adl requires. */
+export function readAirDescriptor(xml) {
+    if (!/<(?:[\w.-]+:)?application[\s>]/.test(xml)) {
+        throw new Error("not an AIR application descriptor: no <application>");
+    }
+    // The comments out first, which may hold an element of each name.
+    const text = xml.replace(/<!--[\s\S]*?-->/g, "");
+    const id = element(text, "id");
+    const window = element(text, "initialWindow");
+    const content = window === null ? null : element(window, "content");
+    if (!id) {
+        throw new Error("the descriptor names no <id>");
+    }
+    if (!content) {
+        throw new Error("the descriptor's <initialWindow> names no <content>");
+    }
+    return {
+        id,
+        content: content.replaceAll("\\", "/"),
+        title: window === null ? null : element(window, "title"),
+        width: window === null ? null : size(element(window, "width")),
+        height: window === null ? null : size(element(window, "height")),
+    };
+}

package/dist/thread/format/api-versions.js

@@ -0,0 +1,22 @@
+// The API versions of avmplus' core/api-versions.h that hosts run ABCs at,
+// in one place for the compiler and the runtime, which must agree: a
+// version names a series of names, Flash Player's or AIR's, which
+// alternate, and what code of that version sees in it.
+/** Flash Player's latest, SWF_31: what a browser's SWFs, and avmshell's by default, run at. */
+export const API_VERSION = 50;
+/** AIR's latest, AIR_20_0: what an AIR host's SWFs run at. */
+export const AIR_API_VERSION = 51;
+/** VM_INTERNAL, which no ABC runs at: the first version past both series. */
+const API_INTERNAL = 52;
+/**
+ * `version` if ABCs can run at it, a version of either series, as
+ * avmshell's -api names them (1, AIR_1_0, up to AIR_API_VERSION); else a
+ * RangeError, so that the compiler, which keeps a byte, and the runtime
+ * never take two different versions for one.
+ */
+export function checkApiVersion(version) {
+    if (!Number.isInteger(version) || version < 1 || version >= API_INTERNAL) {
+        throw new RangeError(`swf2es: no ABC runs at API version ${version}`);
+    }
+    return version;
+}

package/dist/thread/format/bitmap.js

@@ -0,0 +1,199 @@
+// The SWF's bitmap tags. The lossless formats are read here to pixels; the
+// JPEG tags hold an image (a JPEG, PNG or GIF) for the player to decode,
+// with what Flash does to its bytes first already done.
+import { zlibUncompress } from "./compression.js";
+import { DefineBits, DefineBitsJPEG2, DefineBitsJPEG3, DefineBitsJPEG4, DefineBitsLossless, DefineBitsLossless2, } from "./tags.js";
+/** Whether a tag defines a bitmap. */
+export function isBitmapTag(code) {
+    return (code === DefineBits ||
+        code === DefineBitsJPEG2 ||
+        code === DefineBitsJPEG3 ||
+        code === DefineBitsJPEG4 ||
+        code === DefineBitsLossless ||
+        code === DefineBitsLossless2);
+}
+/**
+ * A bitmap tag's character. `tables` is the JPEGTables tag's data that
+ * DefineBits needs, null if there was none.
+ */
+export function readBitmap(bytes, tag, tables) {
+    const body = bytes.subarray(tag.offset, tag.offset + tag.length);
+    const id = body.length >= 2 ? body[0] | (body[1] << 8) : 0;
+    // Flash refuses a bitmap tag written with the short header, whatever it holds.
+    if (!tag.long || body.length < 2) {
+        return { id, type: "invalid" };
+    }
+    try {
+        switch (tag.code) {
+            case DefineBitsLossless:
+            case DefineBitsLossless2:
+                return lossless(id, body, tag.code === DefineBitsLossless2);
+            case DefineBits:
+                return tables ? image(id, concat(tables, body.subarray(2)), null, false) : invalid(id);
+            case DefineBitsJPEG2:
+                return image(id, body.subarray(2), null, false);
+            default: {
+                const size = u32(body, 2);
+                const start = tag.code === DefineBitsJPEG4 ? 8 : 6;
+                if (start + size > body.length) {
+                    return invalid(id);
+                }
+                const alpha = zlibUncompress(body.subarray(start + size));
+                return image(id, body.subarray(start, start + size), alpha, tag.code === DefineBitsJPEG4);
+            }
+        }
+    }
+    catch {
+        // Corrupt zlib data.
+        return invalid(id);
+    }
+}
+function invalid(id) {
+    return { id, type: "invalid" };
+}
+function u16(b, at) {
+    return b[at] | (b[at + 1] << 8);
+}
+function u32(b, at) {
+    return (b[at] | (b[at + 1] << 8) | (b[at + 2] << 16) | (b[at + 3] << 24)) >>> 0;
+}
+function concat(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a);
+    out.set(b, a.length);
+    return out;
+}
+function image(id, data, alpha, jpeg4) {
+    if (data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47) {
+        // A PNG or GIF keeps its own alpha; the tag's is ignored.
+        return { id, type: "image", format: "png", data, alpha: null, opaque: false };
+    }
+    if (data[0] === 0x47 && data[1] === 0x49 && data[2] === 0x46 && data[3] === 0x38) {
+        return { id, type: "image", format: "gif", data, alpha: null, opaque: false };
+    }
+    const jpeg = cleanJpeg(data);
+    if (!jpeg) {
+        return invalid(id);
+    }
+    return {
+        id,
+        type: "image",
+        format: "jpeg",
+        data: jpeg,
+        alpha: jpeg4 ? null : alpha,
+        opaque: jpeg4,
+    };
+}
+/**
+ * A JPEG as a decoder takes it: one SOI, then its segments, with the EOI
+ * and SOI between tables and image that SWFs carry dropped. Old tools
+ * wrote a stray FF D9 FF D8 at the start, and DefineBits' tables come as
+ * a JPEG of their own; Flash reads both. Null if it is not a JPEG.
+ */
+function cleanJpeg(data) {
+    const out = [Uint8Array.of(0xff, 0xd8)];
+    let at = 0;
+    while (at + 1 < data.length) {
+        if (data[at] !== 0xff) {
+            return null;
+        }
+        const marker = data[at + 1];
+        if (marker === 0xd8 || marker === 0xd9) {
+            at += 2;
+            continue;
+        }
+        if (marker === 0xff) {
+            // Fill bytes before a marker.
+            at++;
+            continue;
+        }
+        if (marker === 0xda) {
+            // The scan, and everything after it, as it is.
+            out.push(data.subarray(at));
+            return concatAll(out);
+        }
+        if (at + 3 >= data.length) {
+            return null;
+        }
+        const end = at + 2 + ((data[at + 2] << 8) | data[at + 3]);
+        out.push(data.subarray(at, end));
+        at = end;
+    }
+    return null;
+}
+function concatAll(parts) {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let at = 0;
+    for (const p of parts) {
+        out.set(p, at);
+        at += p.length;
+    }
+    return out;
+}
+/** DefineBitsLossless and 2: a palette, 15-bit or 32-bit pixels, zlib'd. */
+function lossless(id, body, alpha) {
+    if (body.length < 7) {
+        return invalid(id);
+    }
+    const format = body[2];
+    const width = u16(body, 3);
+    const height = u16(body, 5);
+    if (width === 0 || height === 0 || (format !== 3 && format !== 4 && format !== 5)) {
+        return invalid(id);
+    }
+    const colors = format === 3 ? body[7] + 1 : 0;
+    const data = zlibUncompress(body.subarray(format === 3 ? 8 : 7));
+    const pixels = new Uint32Array(width * height);
+    if (format === 3) {
+        const entry = alpha ? 4 : 3;
+        const palette = new Uint32Array(256);
+        for (let i = 0; i < colors; i++) {
+            const p = i * entry;
+            // Lossless2's palette is premultiplied ARGB, as its pixels are.
+            palette[i] = alpha
+                ? ((data[p + 3] << 24) | (data[p] << 16) | (data[p + 1] << 8) | data[p + 2]) >>> 0
+                : (0xff000000 | (data[p] << 16) | (data[p + 1] << 8) | data[p + 2]) >>> 0;
+        }
+        const stride = (width + 3) & ~3;
+        const start = colors * entry;
+        if (start + stride * (height - 1) + width > data.length) {
+            return invalid(id);
+        }
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                pixels[y * width + x] = palette[data[start + y * stride + x]];
+            }
+        }
+    }
+    else if (format === 4) {
+        // 15-bit RGB, rows padded to 4 bytes; a channel v is v * 8 + 7, 0 kept at 0.
+        const stride = (width * 2 + 3) & ~3;
+        if (stride * (height - 1) + width * 2 > data.length) {
+            return invalid(id);
+        }
+        const widen = (v) => (v === 0 ? 0 : v * 8 + 7);
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const p = y * stride + x * 2;
+                const v = (data[p] << 8) | data[p + 1];
+                pixels[y * width + x] =
+                    (0xff000000 |
+                        (widen((v >> 10) & 31) << 16) |
+                        (widen((v >> 5) & 31) << 8) |
+                        widen(v & 31)) >>>
+                        0;
+            }
+        }
+    }
+    else {
+        if (width * height * 4 > data.length) {
+            return invalid(id);
+        }
+        for (let i = 0; i < width * height; i++) {
+            const p = i * 4;
+            const rgb = (data[p + 1] << 16) | (data[p + 2] << 8) | data[p + 3];
+            pixels[i] = alpha ? ((data[p] << 24) | rgb) >>> 0 : (0xff000000 | rgb) >>> 0;
+        }
+    }
+    return { id, type: "pixels", width, height, transparent: alpha, pixels };
+}

package/dist/thread/format/button.js

@@ -0,0 +1,60 @@
+import { readFilterBytes } from "./display.js";
+import { readColorTransform, readMatrix } from "./shape.js";
+import { SwfReader } from "./swf.js";
+import { DefineButton2 } from "./tags.js";
+/** A button's state, as BUTTONRECORD's flags have them. */
+export const BUTTON_UP = 0x01;
+export const BUTTON_OVER = 0x02;
+export const BUTTON_DOWN = 0x04;
+export const BUTTON_HIT_TEST = 0x08;
+/** A DefineButton or DefineButton2; given the SWF's action list, with the indices of its actions. */
+export function readButton(bytes, tag, actions) {
+    const { button } = parseButton(bytes, tag);
+    button.actions = actions?.byTag.get(tag.offset) ?? null;
+    return button;
+}
+/** A button's id, and where its actions start: -1 for a DefineButton2 whose action offset is 0. */
+export function buttonActionsOffset(bytes, tag) {
+    const { button, actions } = parseButton(bytes, tag);
+    return { id: button.id, offset: actions };
+}
+function parseButton(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const two = tag.code === DefineButton2;
+    const button = { id: r.u16(), records: [], trackAsMenu: false, actions: null };
+    // Only whether it is 0 counts: the actions start after the records' end, as Ruffle reads them.
+    let hasActions = true;
+    if (two) {
+        button.trackAsMenu = (r.u8() & 0x01) !== 0;
+        hasActions = r.u16() !== 0;
+    }
+    // The records end at a flags byte of 0.
+    while (r.pos < r.end && !r.overrun) {
+        const flags = r.u8();
+        if (flags === 0) {
+            break;
+        }
+        const record = {
+            states: flags & 0x0f,
+            character: r.u16(),
+            depth: r.u16(),
+            matrix: readMatrix(r),
+            colorTransform: null,
+            filters: null,
+            blendMode: null,
+        };
+        if (two) {
+            record.colorTransform = readColorTransform(r, true);
+            if (flags & 0x10) {
+                record.filters = readFilterBytes(r);
+            }
+            if (flags & 0x20) {
+                record.blendMode = r.u8();
+            }
+        }
+        if (!r.overrun) {
+            button.records.push(record);
+        }
+    }
+    return { button, actions: hasActions ? Math.min(r.pos, r.end) : -1 };
+}