@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/scripting/sha256.js

@@ -0,0 +1,95 @@
+// SHA-256 of an ABC's bytes, the fingerprint the AOT side and the cache
+// key name ABCs by: from crypto.subtle where there is one, which only a
+// secure context (https, localhost) has, else computed here, so that a
+// player on a plain http page loads too, with the same fingerprint.
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/** The digest as 64 hex digits. */
+export async function sha256(bytes) {
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle) {
+        // The bytes are a view of the SWF's buffer, never a shared one, as digest requires.
+        return hex(new Uint8Array(await subtle.digest("SHA-256", bytes)));
+    }
+    return hex(sha256Here(bytes));
+}
+/** FIPS 180-4, one block at a time; the message length goes in the last block as 64 bits big-endian. */
+export function sha256Here(bytes) {
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    const n = bytes.length;
+    // Padded: 0x80, zeros to 56 mod 64, then the bit length.
+    const padded = new Uint8Array(((n + 9 + 63) >> 6) << 6);
+    padded.set(bytes);
+    padded[n] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor((n * 8) / 0x100000000));
+    view.setUint32(padded.length - 4, (n * 8) >>> 0);
+    for (let block = 0; block < padded.length; block += 64) {
+        for (let i = 0; i < 16; i++) {
+            w[i] = view.getUint32(block + i * 4);
+        }
+        for (let i = 16; i < 64; i++) {
+            const x = w[i - 15];
+            const y = w[i - 2];
+            const s0 = ((x >>> 7) | (x << 25)) ^ ((x >>> 18) | (x << 14)) ^ (x >>> 3);
+            const s1 = ((y >>> 17) | (y << 15)) ^ ((y >>> 19) | (y << 13)) ^ (y >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let a = h[0];
+        let b = h[1];
+        let c = h[2];
+        let d = h[3];
+        let e = h[4];
+        let f = h[5];
+        let g = h[6];
+        let hh = h[7];
+        for (let i = 0; i < 64; i++) {
+            const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + S1 + ch + K[i] + w[i]) >>> 0;
+            const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    const digest = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++) {
+        digest.setUint32(i * 4, h[i]);
+    }
+    return out;
+}
+function hex(digest) {
+    let s = "";
+    for (let i = 0; i < digest.length; i++) {
+        s += digest[i].toString(16).padStart(2, "0");
+    }
+    return s;
+}

package/dist/thread/player/scripting/symbols.js

@@ -0,0 +1,348 @@
+// What SymbolClass binds: the character, and its library, a class makes
+// when a script constructs it, a display object's or a resource's (bitmap,
+// bytes, sound, font); the fonts scripts register; and the decodes of
+// identical sounds, which the libraries alive share.
+import { readSymbolClass, tags } from "../../format/index.js";
+import { BitmapStore } from "../bitmap/bitmap.js";
+import { BitmapObject, ButtonObject, Container, displayFor, EMPTY_TIMELINE, MovieClip, ShapeObject, TextObject, VideoObject, } from "../display/display.js";
+import { INVALID_PIXELS, } from "../display/timeline.js";
+import { FontSet } from "../text/fonts.js";
+export class Symbols {
+    s;
+    audioEntries = new WeakMap();
+    sharedAudio = new Map();
+    sharedAudioGone = new FinalizationRegistry(({ hash, entry, serial }) => {
+        if (entry.serial !== serial || entry.definition.deref()) {
+            return;
+        }
+        this.removeSharedAudio(hash, entry);
+    });
+    /**
+     * The character, and its SWF's library, each class SymbolClass bound
+     * makes, for a `new` of the class from a script: by the module that
+     * defines the class, as the SWF's domain found it, then its name, so a
+     * class of the same name in another domain has its own; `unbound` for a
+     * name nothing defined when it was bound. Weakly, by the module: a SWF
+     * let go takes its symbols with it.
+     */
+    symbols = new WeakMap();
+    unbound = new Map();
+    /**
+     * The font sets of the libraries whose embedded fonts have been made
+     * visible to this player, for the fonts registered later. Weakly, so
+     * that a SWF let go is not kept for them; but by the set, not the
+     * library, as a text field keeps only its library's set, and a field
+     * kept from a SWF otherwise let go still takes the fonts registered.
+     */
+    fontSets = new Set();
+    fontSetsSeen = new WeakSet();
+    /** Font classes explicitly registered by scripts, in registration order. */
+    registeredFonts = new Map();
+    constructor(s) {
+        this.s = s;
+    }
+    /** SymbolClass: bind the SWF's characters to their classes, in its library. */
+    bind(swf, library) {
+        const domain = library.domain ?? this.s.mainDomain;
+        for (const t of swf.tags) {
+            if (t.code === tags.SymbolClass) {
+                for (const [id, name] of readSymbolClass(swf.bytes, t)) {
+                    const qualified = qualify(name);
+                    library.classes.set(id, qualified);
+                    const character = library.characters.get(id);
+                    if (character) {
+                        const abc = this.s.rt.definingAbc(qualified, domain);
+                        let byName = abc ? this.symbols.get(abc) : this.unbound;
+                        if (!byName) {
+                            byName = new Map();
+                            this.symbols.set(abc, byName);
+                        }
+                        // A class keeps the symbol first bound to it: another SWF that
+                        // binds it, one that finds it in a parent's domain, makes its own
+                        // timeline's instances of it but not a script's (the corpus's
+                        // loader_duplicate_class).
+                        if (!byName.has(qualified)) {
+                            byName.set(qualified, { character, library });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /** The bitmap a class SymbolClass bound is of, if `traits` or a base is one's. */
+    bitmapSymbol(traits) {
+        for (let t = traits; t; t = t.base) {
+            const symbol = this.symbolOf(t);
+            if (symbol) {
+                return symbol.character.type === "bitmap" ? symbol.character : null;
+            }
+        }
+        return null;
+    }
+    /**
+     * The bytes of the DefineBinaryData a class SymbolClass bound, if
+     * `traits` or a base is one's: one buffer for all its instances, which
+     * see each other's writes, as Flash's.
+     */
+    binarySymbol(traits) {
+        for (let t = traits; t; t = t.base) {
+            const symbol = this.symbolOf(t);
+            if (symbol) {
+                const character = symbol.character;
+                if (character.type !== "binary") {
+                    return null;
+                }
+                character.shared ??= new Uint8Array(character.data);
+                return character.shared;
+            }
+        }
+        return null;
+    }
+    /** A DefineSound a class or one of its bases was bound to. */
+    soundSymbol(traits) {
+        for (let t = traits; t; t = t.base) {
+            const symbol = this.symbolOf(t);
+            if (symbol) {
+                return symbol.character.type === "sound" ? symbol.character : null;
+            }
+        }
+        return null;
+    }
+    /** A DefineFont a class or one of its bases was bound to. */
+    fontSymbol(traits) {
+        for (let t = traits; t; t = t.base) {
+            const symbol = this.symbolOf(t);
+            if (symbol) {
+                return symbol.character.type === "font" || symbol.character.type === "fontCff"
+                    ? symbol.character
+                    : null;
+            }
+        }
+        return null;
+    }
+    /** Keep a SWF's own fonts and fonts registered elsewhere available to its fields. */
+    addFontLibrary(library) {
+        if (this.fontSetsSeen.has(library.fonts)) {
+            return;
+        }
+        for (const ref of this.fontSets) {
+            if (!ref.deref()) {
+                this.fontSets.delete(ref);
+            }
+        }
+        this.fontSetsSeen.add(library.fonts);
+        this.fontSets.add(new WeakRef(library.fonts));
+        for (const font of this.registeredFonts.values()) {
+            if (font.type === "font") {
+                library.fonts.add(font.font);
+            }
+        }
+    }
+    /** Make a registered font available to fields made by every loaded SWF. */
+    registerFont(cls, font) {
+        if (this.registeredFonts.has(cls) ||
+            [...this.registeredFonts.values()].some((registered) => registered.name.toLowerCase() === font.name.toLowerCase() &&
+                registered.type === font.type &&
+                registered.bold === font.bold &&
+                registered.italic === font.italic)) {
+            return;
+        }
+        this.registeredFonts.set(cls, font);
+        for (const ref of this.fontSets) {
+            const fonts = ref.deref();
+            if (!fonts) {
+                this.fontSets.delete(ref);
+            }
+            else if (font.type === "font") {
+                fonts.add(font.font);
+            }
+        }
+    }
+    /** Decode a sound on first play; live libraries can share an identical decode. */
+    soundClip(character) {
+        if (!this.s.audio) {
+            return null;
+        }
+        const own = this.audioEntries.get(character);
+        if (own?.pending) {
+            return own.pending;
+        }
+        const ownDecoded = own?.decoded;
+        if (ownDecoded) {
+            return Promise.resolve(ownDecoded);
+        }
+        const definition = character.definition;
+        const hash = soundHash(definition);
+        for (const entry of this.sharedAudio.get(hash) ?? []) {
+            const prior = entry.definition.deref();
+            if (!prior || !sameSound(prior, definition)) {
+                continue;
+            }
+            const decoded = entry.decoded;
+            const clip = entry.pending ?? (decoded ? Promise.resolve(decoded) : null);
+            if (clip) {
+                entry.definition = new WeakRef(definition);
+                this.sharedAudioGone.register(definition, {
+                    hash,
+                    entry,
+                    serial: ++entry.serial,
+                });
+                this.audioEntries.set(character, entry);
+                return clip;
+            }
+        }
+        const entry = {
+            definition: new WeakRef(definition),
+            decoded: null,
+            pending: null,
+            serial: 1,
+        };
+        const audio = this.s.audio;
+        const clip = Promise.resolve().then(() => audio.decode(definition));
+        entry.pending = clip;
+        const matches = this.sharedAudio.get(hash) ?? [];
+        matches.push(entry);
+        this.sharedAudio.set(hash, matches);
+        this.sharedAudioGone.register(definition, { hash, entry, serial: 1 });
+        void clip.then((decoded) => {
+            entry.decoded = decoded;
+            entry.pending = null;
+        }, () => this.removeSharedAudio(hash, entry));
+        this.audioEntries.set(character, entry);
+        return clip;
+    }
+    removeSharedAudio(hash, entry) {
+        const matches = this.sharedAudio.get(hash)?.filter((candidate) => candidate !== entry) ?? [];
+        if (matches.length > 0) {
+            this.sharedAudio.set(hash, matches);
+        }
+        else {
+            this.sharedAudio.delete(hash);
+        }
+    }
+    /** What SymbolClass bound the class of `traits` to, if anything: by its defining module, then its name. */
+    symbolOf(traits) {
+        const abc = traits.abc;
+        return (abc && this.symbols.get(abc)?.get(traits.name)) ?? this.unbound.get(traits.name);
+    }
+    /** A new plain BitmapData of a bitmap's pixels, as a Bitmap of the bitmap gets. */
+    bitmapDataOf(character) {
+        const data = this.s.rt.construct(this.s.rt.classNamed("flash.display::BitmapData"), 1, 1);
+        data.$store = BitmapStore.of(character.pixels ?? INVALID_PIXELS);
+        return data;
+    }
+    /**
+     * The display object for an instance a script makes with `new`: the
+     * character of a class SymbolClass bound, if the class or a base of it
+     * is one, else an empty clip, shape or container by the nearest base.
+     */
+    displayFor(traits) {
+        const library = this.s.library ?? {
+            characters: new Map(),
+            root: EMPTY_TIMELINE,
+            classes: new Map(),
+            construct: null,
+            constructLater: null,
+            constructPlaced: null,
+            uncaught: null,
+            removing: null,
+            fonts: new FontSet(),
+        };
+        for (let t = traits; t; t = t.base) {
+            // A display object's class bound to data has no display of it.
+            const symbol = this.symbolOf(t);
+            if (symbol &&
+                symbol.character.type !== "binary" &&
+                symbol.character.type !== "font" &&
+                symbol.character.type !== "fontCff" &&
+                symbol.character.type !== "sound") {
+                if (symbol.character.type === "text") {
+                    // A new linked TextField has its symbol's bounds, but not its timeline's initial text.
+                    const text = new TextObject(symbol.character, false);
+                    text.fonts = symbol.library.fonts;
+                    return text;
+                }
+                const display = displayFor(symbol.character, symbol.library);
+                // A bound button a script makes has its states, as a timeline's does.
+                if (display instanceof ButtonObject && symbol.character.type === "button") {
+                    this.s.makeButtonStates(display, symbol.character, symbol.library);
+                }
+                return display;
+            }
+            if (t.name === "flash.display::SimpleButton") {
+                return new ButtonObject();
+            }
+            if (t.name === "flash.display::MovieClip") {
+                return new MovieClip(EMPTY_TIMELINE, library);
+            }
+            if (t.name === "flash.display::Shape") {
+                return new ShapeObject(null);
+            }
+            // Only a timeline makes a MorphShape or a StaticText.
+            if (t.name === "flash.display::MorphShape") {
+                throw this.s.rt.error("ArgumentError", 2012, "MorphShape$");
+            }
+            if (t.name === "flash.text::StaticText") {
+                throw this.s.rt.error("ArgumentError", 2012, "StaticText$");
+            }
+            // Only a load of an AVM1 SWF makes one (requestLoad).
+            if (t.name === "flash.display::AVM1Movie") {
+                throw this.s.rt.error("ArgumentError", 2012, "AVM1Movie$");
+            }
+            if (t.name === "flash.display::Bitmap") {
+                return new BitmapObject(null);
+            }
+            if (t.name === "flash.media::Video") {
+                return new VideoObject();
+            }
+            if (t.name === "flash.text::TextField") {
+                const text = new TextObject(null);
+                text.fonts = (this.s.code.codeLibrary() ?? library).fonts;
+                return text;
+            }
+        }
+        return new Container();
+    }
+}
+/** Compare the bytes too: a 32-bit hash only narrows a bucket, never decides identity. */
+function sameSound(a, b) {
+    if (a.format !== b.format ||
+        a.sampleRate !== b.sampleRate ||
+        a.sampleSize !== b.sampleSize ||
+        a.channels !== b.channels ||
+        a.sampleCount !== b.sampleCount ||
+        a.seekSamples !== b.seekSamples ||
+        a.data.length !== b.data.length) {
+        return false;
+    }
+    for (let i = 0; i < a.data.length; i++) {
+        if (a.data[i] !== b.data[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function soundHash(sound) {
+    let hash = 0x811c9dc5;
+    for (const value of [
+        sound.format,
+        sound.sampleRate,
+        sound.sampleSize,
+        sound.channels,
+        sound.sampleCount,
+        sound.seekSamples,
+    ]) {
+        hash = Math.imul(hash ^ value, 0x01000193);
+    }
+    // By index: a sound's data runs to megabytes.
+    const data = sound.data;
+    for (let i = 0; i < data.length; i++) {
+        hash = Math.imul(hash ^ data[i], 0x01000193);
+    }
+    return hash >>> 0;
+}
+/** "pkg.Name", as SymbolClass writes a class, as "pkg::Name". */
+function qualify(name) {
+    const i = name.lastIndexOf(".");
+    return i < 0 ? name : `${name.slice(0, i)}::${name.slice(i + 1)}`;
+}