@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,198 @@
+const NUMBER = 0;
+const TRUE = 1;
+const FALSE = 2;
+const STRING = 3;
+const NULL = 4;
+const AMF = 5;
+const BYTES = 6;
+const SHARED = 7;
+const CHANNEL = 8;
+const MUTEX = 9;
+const CONDITION = 10;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function tagged(tag, length) {
+    const out = new Uint8Array(1 + length);
+    out[0] = tag;
+    return { out, view: new DataView(out.buffer) };
+}
+function withBytes(tag, bytes) {
+    const { out } = tagged(tag, bytes.length);
+    out.set(bytes, 1);
+    return out;
+}
+export function pack(wire) {
+    switch (wire.kind) {
+        case "value": {
+            const v = wire.value;
+            if (v === null) {
+                return tagged(NULL, 0).out;
+            }
+            if (typeof v === "boolean") {
+                return tagged(v ? TRUE : FALSE, 0).out;
+            }
+            if (typeof v === "string") {
+                return withBytes(STRING, encoder.encode(v));
+            }
+            const { out, view } = tagged(NUMBER, 8);
+            view.setFloat64(1, v, true);
+            return out;
+        }
+        case "amf":
+            return withBytes(AMF, wire.bytes);
+        case "bytes":
+            return withBytes(BYTES, wire.bytes);
+        case "shared": {
+            const { out, view } = tagged(SHARED, 8);
+            view.setFloat64(1, wire.memory.id, true);
+            return out;
+        }
+        case "channel": {
+            const { out, view } = tagged(CHANNEL, 20);
+            view.setFloat64(1, wire.channel.id, true);
+            view.setInt32(9, wire.channel.sender, true);
+            view.setInt32(13, wire.channel.receiver, true);
+            view.setInt32(17, wire.channel.queue, true);
+            return out;
+        }
+        case "sync": {
+            const { out, view } = tagged(wire.ref.kind === "mutex" ? MUTEX : CONDITION, 4);
+            view.setInt32(1, wire.ref.address, true);
+            return out;
+        }
+    }
+}
+export function unpack(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const rest = () => bytes.slice(1);
+    switch (bytes[0]) {
+        case NUMBER:
+            return { kind: "value", value: view.getFloat64(1, true) };
+        case TRUE:
+        case FALSE:
+            return { kind: "value", value: bytes[0] === TRUE };
+        case STRING:
+            return { kind: "value", value: decoder.decode(bytes.subarray(1)) };
+        case NULL:
+            return { kind: "value", value: null };
+        case AMF:
+            return { kind: "amf", bytes: rest() };
+        case BYTES:
+            return { kind: "bytes", bytes: rest() };
+        case SHARED:
+            return { kind: "shared", id: view.getFloat64(1, true) };
+        case CHANNEL: {
+            const channel = {
+                id: view.getFloat64(1, true),
+                sender: view.getInt32(9, true),
+                receiver: view.getInt32(13, true),
+                queue: view.getInt32(17, true),
+            };
+            return { kind: "channel", channel };
+        }
+        default:
+            return {
+                kind: "sync",
+                ref: { kind: bytes[0] === MUTEX ? "mutex" : "condition", address: view.getInt32(1, true) },
+            };
+    }
+}
+export function packTable(entries) {
+    const parts = [];
+    for (const e of entries) {
+        const key = e.key === null ? null : encoder.encode(e.key);
+        const head = new DataView(new ArrayBuffer(16));
+        head.setInt32(0, e.worker, true);
+        head.setInt32(4, key === null ? -1 : key.length, true);
+        head.setInt32(8, e.token, true);
+        head.setUint32(12, e.value.length, true);
+        parts.push(new Uint8Array(head.buffer), key ?? new Uint8Array(0), e.value);
+    }
+    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;
+}
+export function unpackTable(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const entries = [];
+    let at = 0;
+    while (at < bytes.length) {
+        const worker = view.getInt32(at, true);
+        const keyLength = view.getInt32(at + 4, true);
+        const token = view.getInt32(at + 8, true);
+        const valueLength = view.getUint32(at + 12, true);
+        at += 16;
+        const key = keyLength < 0 ? null : decoder.decode(bytes.subarray(at, at + keyLength));
+        at += Math.max(keyLength, 0);
+        entries.push({ worker, key, token, value: bytes.slice(at, at + valueLength) });
+        at += valueLength;
+    }
+    return entries;
+}
+const START = 0;
+const END = 1;
+export function packEnd(id, creator) {
+    const out = new DataView(new ArrayBuffer(9));
+    out.setUint8(0, END);
+    out.setInt32(1, id, true);
+    out.setInt32(5, creator, true);
+    return new Uint8Array(out.buffer);
+}
+export function unpackRequest(bytes) {
+    if (bytes[0] === END) {
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return { type: "end", id: view.getInt32(1, true), creator: view.getInt32(5, true) };
+    }
+    return { type: "start", job: unpackJob(bytes.subarray(1)) };
+}
+export function packJob(id, creator, swf, shared) {
+    const head = new DataView(new ArrayBuffer(16));
+    head.setInt32(0, id, true);
+    head.setInt32(4, creator, true);
+    head.setUint32(8, swf.length, true);
+    head.setUint32(12, shared.length, true);
+    const parts = [new Uint8Array([START]), new Uint8Array(head.buffer), swf];
+    for (const p of shared) {
+        const key = p.key === null ? null : encoder.encode(p.key);
+        const value = pack(p.value);
+        const entry = new DataView(new ArrayBuffer(12));
+        entry.setInt32(0, p.worker, true);
+        entry.setInt32(4, key === null ? -1 : key.length, true);
+        entry.setUint32(8, value.length, true);
+        parts.push(new Uint8Array(entry.buffer), key ?? new Uint8Array(0), value);
+    }
+    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;
+}
+function unpackJob(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const swfLength = view.getUint32(8, true);
+    const count = view.getUint32(12, true);
+    let at = 16 + swfLength;
+    const shared = [];
+    for (let i = 0; i < count; i++) {
+        const worker = view.getInt32(at, true);
+        const keyLength = view.getInt32(at + 4, true);
+        const valueLength = view.getUint32(at + 8, true);
+        at += 12;
+        const key = keyLength < 0 ? null : decoder.decode(bytes.subarray(at, at + keyLength));
+        at += Math.max(keyLength, 0);
+        shared.push({ worker, key, value: unpack(bytes.slice(at, at + valueLength)) });
+        at += valueLength;
+    }
+    return {
+        id: view.getInt32(0, true),
+        creator: view.getInt32(4, true),
+        swf: bytes.slice(16, 16 + swfLength),
+        shared,
+    };
+}

package/dist/thread/player-hosts/web-worker.js

@@ -0,0 +1,19 @@
+// A Web Worker running one background flash.system.Worker (workers.ts).
+import { runWorkerThread } from "../player/workers/thread.js";
+// The DOM's types, not a worker's, are this package's: its global scope as a worker sees it.
+const scope = globalThis;
+runWorkerThread({
+    post: (message) => scope.postMessage(message),
+    listen: (receive) => {
+        scope.onmessage = (event) => {
+            // The host's first message: answered, it tells the host that what it
+            // posts reaches this worker, which it then counts on while the page's
+            // thread is blocked (workers.ts).
+            if (event.data?.type === "ping") {
+                scope.postMessage({ type: "ready" });
+                return;
+            }
+            receive(event.data);
+        };
+    },
+});

package/dist/thread/runtime/avm1/activation.js

@@ -0,0 +1,89 @@
+/** A function's `arguments`, made as its activation object is first asked for it. */
+export const PENDING_Arguments = 1;
+/** A function's `super`, likewise. */
+export const PENDING_Super = 2;
+/**
+ * What a region runs in: the operand stack, the constant pool, the target
+ * and the host. Flash has one operand stack, not one an activation: every
+ * activation of a frame's actions shares the frame's, which the player
+ * empties between frames, and a function's shares its caller's.
+ */
+export class Activation {
+    st;
+    pool;
+    base;
+    host;
+    realm;
+    scope;
+    self;
+    clip;
+    /** The block's regions, which DefineFunction makes functions of. */
+    code = [];
+    /** The function running, null in a block: `arguments.callee`, and its callees' caller. */
+    callee = null;
+    /** The function that called it, null from a block: `arguments.caller`. */
+    caller = null;
+    /** The arguments it was called with. */
+    args = NO_ARGS;
+    /** How far up `this`'s prototypes the function was found, which `super` starts from. */
+    depth = 0;
+    /** The `this` it was called with, which `super` is made of. */
+    receiver = undefined;
+    /** What of `arguments` and `super` its activation object has yet to make (PENDING_ bits). */
+    pending = 0;
+    /** The movie's four global registers. */
+    g;
+    /** What its Withs and Trys hold while control stays in their bodies (control.ts), the latest last. */
+    held = null;
+    /** What the region returns where control goes to its exit through a Try (control.ts). */
+    ret = undefined;
+    /**
+     * The realm's count of removals as this last looked at its clip, which a
+     * call may have removed only where the count moved on; none at first.
+     */
+    removals;
+    /** The register a catch just took a value into, -1 for none, and the value, which the region sets. */
+    into = -1;
+    thrown = undefined;
+    /**
+     * The clip timeline actions act on, which SetTarget changes; null where
+     * a SetTarget found none, where they do nothing.
+     */
+    target;
+    constructor(
+    /** The operand stack, the frame's. */
+    st, 
+    /** The constant pool the region reads where the compiler cannot tell which: see V.constantPool. */
+    pool, 
+    /** The clip whose code runs, the target a SetTarget of "" gives back. */
+    base, host, realm, 
+    /** The scope chain, searched from here down to `_global`. */
+    scope, 
+    /** `this`. */
+    self, 
+    /**
+     * The target's AVM1 object, the root's where SetTarget found none: a
+     * function called by name without an object takes it as `this`.
+     */
+    clip) {
+        this.st = st;
+        this.pool = pool;
+        this.base = base;
+        this.host = host;
+        this.realm = realm;
+        this.scope = scope;
+        this.self = self;
+        this.clip = clip;
+        this.target = base;
+        this.g = realm.registers;
+        this.removals = -1;
+    }
+    get global() {
+        return this.realm.global;
+    }
+    /** `arguments` or `super`, made on the activation object `o` as it is first asked for. */
+    local(o, name, version) {
+        return this.realm.pendingLocal(this, o, name, version);
+    }
+}
+const NO_ARGS = [];

package/dist/thread/runtime/avm1/case.js

@@ -0,0 +1,249 @@
+// Flash's lower and upper case of a UTF-16 code unit: the lower case AVM1
+// folds names by up to SWF 6, and String's toLowerCase and toUpperCase.
+// An old Unicode's simple mappings, one code unit to one, without
+// JavaScript's later letters (Cherokee, Glagolitic, Coptic, Latin
+// Extended-C and -D...), with İ to i, Georgian capitals to Mkhedruli and
+// U+03A2 to ς, and back, ß and ʼn left as they are. Measured in adl: every
+// code unit through String's toLowerCase and toUpperCase, and each lower
+// case mapping through names.
+/** Runs of mappings: their first code unit, how many, what each adds, and the step between them. */
+const LOWER = [
+    [0x0041, 26, 32, 1],
+    [0x00c0, 23, 32, 1],
+    [0x00d8, 7, 32, 1],
+    [0x0100, 24, 1, 2],
+    [0x0130, 1, -199, 1],
+    [0x0132, 3, 1, 2],
+    [0x0139, 8, 1, 2],
+    [0x014a, 23, 1, 2],
+    [0x0178, 1, -121, 1],
+    [0x0179, 3, 1, 2],
+    [0x0181, 1, 210, 1],
+    [0x0182, 2, 1, 2],
+    [0x0186, 1, 206, 1],
+    [0x0187, 1, 1, 1],
+    [0x0189, 2, 205, 1],
+    [0x018b, 1, 1, 1],
+    [0x018e, 1, 79, 1],
+    [0x018f, 1, 202, 1],
+    [0x0190, 1, 203, 1],
+    [0x0191, 1, 1, 1],
+    [0x0193, 1, 205, 1],
+    [0x0194, 1, 207, 1],
+    [0x0196, 1, 211, 1],
+    [0x0197, 1, 209, 1],
+    [0x0198, 1, 1, 1],
+    [0x019c, 1, 211, 1],
+    [0x019d, 1, 213, 1],
+    [0x019f, 1, 214, 1],
+    [0x01a0, 3, 1, 2],
+    [0x01a6, 1, 218, 1],
+    [0x01a7, 1, 1, 1],
+    [0x01a9, 1, 218, 1],
+    [0x01ac, 1, 1, 1],
+    [0x01ae, 1, 218, 1],
+    [0x01af, 1, 1, 1],
+    [0x01b1, 2, 217, 1],
+    [0x01b3, 2, 1, 2],
+    [0x01b7, 1, 219, 1],
+    [0x01b8, 1, 1, 1],
+    [0x01bc, 1, 1, 1],
+    [0x01c4, 1, 2, 1],
+    [0x01c5, 1, 1, 1],
+    [0x01c7, 1, 2, 1],
+    [0x01c8, 1, 1, 1],
+    [0x01ca, 1, 2, 1],
+    [0x01cb, 9, 1, 2],
+    [0x01de, 9, 1, 2],
+    [0x01f1, 1, 2, 1],
+    [0x01f2, 2, 1, 2],
+    [0x01f6, 1, -97, 1],
+    [0x01f7, 1, -56, 1],
+    [0x01f8, 20, 1, 2],
+    [0x0222, 9, 1, 2],
+    [0x0386, 1, 38, 1],
+    [0x0388, 3, 37, 1],
+    [0x038c, 1, 64, 1],
+    [0x038e, 2, 63, 1],
+    [0x0391, 27, 32, 1],
+    [0x03d8, 12, 1, 2],
+    [0x03f4, 1, -60, 1],
+    [0x0400, 16, 80, 1],
+    [0x0410, 32, 32, 1],
+    [0x0460, 17, 1, 2],
+    [0x048a, 27, 1, 2],
+    [0x04c1, 2, 1, 2],
+    [0x04c7, 1, 1, 1],
+    [0x04cb, 1, 1, 1],
+    [0x04d0, 21, 1, 2],
+    [0x0531, 38, 48, 1],
+    [0x10a0, 38, 48, 1],
+    [0x1e00, 75, 1, 2],
+    [0x1ea0, 45, 1, 2],
+    [0x1f08, 8, -8, 1],
+    [0x1f18, 6, -8, 1],
+    [0x1f28, 8, -8, 1],
+    [0x1f38, 8, -8, 1],
+    [0x1f48, 6, -8, 1],
+    [0x1f59, 4, -8, 2],
+    [0x1f68, 8, -8, 1],
+    [0x1f88, 8, -8, 1],
+    [0x1f98, 8, -8, 1],
+    [0x1fa8, 8, -8, 1],
+    [0x1fb8, 2, -8, 1],
+    [0x1fba, 2, -74, 1],
+    [0x1fbc, 1, -9, 1],
+    [0x1fc8, 4, -86, 1],
+    [0x1fcc, 1, -9, 1],
+    [0x1fd8, 2, -8, 1],
+    [0x1fda, 2, -100, 1],
+    [0x1fe8, 2, -8, 1],
+    [0x1fea, 2, -112, 1],
+    [0x1fec, 1, -7, 1],
+    [0x1ff8, 2, -128, 1],
+    [0x1ffa, 2, -126, 1],
+    [0x1ffc, 1, -9, 1],
+    [0x2126, 1, -7517, 1],
+    [0x212a, 1, -8383, 1],
+    [0x212b, 1, -8262, 1],
+    [0x2160, 16, 16, 1],
+    [0x24b6, 26, 26, 1],
+    [0xff21, 26, 32, 1],
+];
+/** The upper case's runs, as the lower case's. */
+const UPPER = [
+    [0x0061, 26, -32, 1],
+    [0x00e0, 23, -32, 1],
+    [0x00f8, 7, -32, 1],
+    [0x00ff, 1, 121, 1],
+    [0x0101, 24, -1, 2],
+    [0x0131, 1, -232, 1],
+    [0x0133, 3, -1, 2],
+    [0x013a, 8, -1, 2],
+    [0x014b, 23, -1, 2],
+    [0x017a, 3, -1, 2],
+    [0x017f, 1, -300, 1],
+    [0x0183, 2, -1, 2],
+    [0x0188, 1, -1, 1],
+    [0x018c, 1, -1, 1],
+    [0x0192, 1, -1, 1],
+    [0x0195, 1, 97, 1],
+    [0x0199, 1, -1, 1],
+    [0x01a1, 3, -1, 2],
+    [0x01a8, 1, -1, 1],
+    [0x01ad, 1, -1, 1],
+    [0x01b0, 1, -1, 1],
+    [0x01b4, 2, -1, 2],
+    [0x01b9, 1, -1, 1],
+    [0x01bd, 1, -1, 1],
+    [0x01bf, 1, 56, 1],
+    [0x01c5, 1, -1, 1],
+    [0x01c6, 1, -2, 1],
+    [0x01c8, 1, -1, 1],
+    [0x01c9, 1, -2, 1],
+    [0x01cb, 1, -1, 1],
+    [0x01cc, 1, -2, 1],
+    [0x01ce, 8, -1, 2],
+    [0x01dd, 1, -79, 1],
+    [0x01df, 9, -1, 2],
+    [0x01f2, 1, -1, 1],
+    [0x01f3, 1, -2, 1],
+    [0x01f5, 1, -1, 1],
+    [0x01f9, 20, -1, 2],
+    [0x0223, 9, -1, 2],
+    [0x0253, 1, -210, 1],
+    [0x0254, 1, -206, 1],
+    [0x0256, 2, -205, 1],
+    [0x0259, 1, -202, 1],
+    [0x025b, 1, -203, 1],
+    [0x0260, 1, -205, 1],
+    [0x0263, 1, -207, 1],
+    [0x0268, 1, -209, 1],
+    [0x0269, 1, -211, 1],
+    [0x026f, 1, -211, 1],
+    [0x0272, 1, -213, 1],
+    [0x0275, 1, -214, 1],
+    [0x0280, 1, -218, 1],
+    [0x0283, 1, -218, 1],
+    [0x0288, 1, -218, 1],
+    [0x028a, 2, -217, 1],
+    [0x0292, 1, -219, 1],
+    [0x0345, 1, 84, 1],
+    [0x03ac, 1, -38, 1],
+    [0x03ad, 3, -37, 1],
+    [0x03b1, 27, -32, 1],
+    [0x03cc, 1, -64, 1],
+    [0x03cd, 2, -63, 1],
+    [0x03d0, 1, -62, 1],
+    [0x03d1, 1, -57, 1],
+    [0x03d5, 1, -47, 1],
+    [0x03d6, 1, -54, 1],
+    [0x03d9, 12, -1, 2],
+    [0x03f0, 1, -86, 1],
+    [0x03f1, 1, -80, 1],
+    [0x03f2, 1, -79, 1],
+    [0x03f5, 1, -96, 1],
+    [0x0430, 32, -32, 1],
+    [0x0450, 16, -80, 1],
+    [0x0461, 17, -1, 2],
+    [0x048b, 27, -1, 2],
+    [0x04c2, 2, -1, 2],
+    [0x04c8, 1, -1, 1],
+    [0x04cc, 1, -1, 1],
+    [0x04d1, 21, -1, 2],
+    [0x0561, 38, -48, 1],
+    [0x1e01, 75, -1, 2],
+    [0x1e9b, 1, -59, 1],
+    [0x1ea1, 45, -1, 2],
+    [0x1f00, 8, 8, 1],
+    [0x1f10, 6, 8, 1],
+    [0x1f20, 8, 8, 1],
+    [0x1f30, 8, 8, 1],
+    [0x1f40, 6, 8, 1],
+    [0x1f51, 4, 8, 2],
+    [0x1f60, 8, 8, 1],
+    [0x1f70, 2, 74, 1],
+    [0x1f72, 4, 86, 1],
+    [0x1f76, 2, 100, 1],
+    [0x1f78, 2, 128, 1],
+    [0x1f7a, 2, 112, 1],
+    [0x1f7c, 2, 126, 1],
+    [0x1f80, 8, 8, 1],
+    [0x1f90, 8, 8, 1],
+    [0x1fa0, 8, 8, 1],
+    [0x1fb0, 2, 8, 1],
+    [0x1fb3, 1, 9, 1],
+    [0x1fbe, 1, -7205, 1],
+    [0x1fc3, 1, 9, 1],
+    [0x1fd0, 2, 8, 1],
+    [0x1fe0, 2, 8, 1],
+    [0x1fe5, 1, 7, 1],
+    [0x1ff3, 1, 9, 1],
+    [0x2170, 16, -16, 1],
+    [0x24d0, 26, -26, 1],
+    [0xff41, 26, -32, 1],
+];
+/** A table of every code unit's mapping, made as it is first needed. */
+function table(runs) {
+    const t = new Uint16Array(0x10000);
+    for (let i = 0; i < t.length; i++) {
+        t[i] = i;
+    }
+    for (const [start, count, delta, step] of runs) {
+        for (let i = 0; i < count; i++) {
+            const u = start + i * step;
+            t[u] = u + delta;
+        }
+    }
+    return t;
+}
+let lower = null;
+let upper = null;
+export function lowerCase(c) {
+    lower ??= table(LOWER);
+    return lower[c];
+}
+export function upperCase(c) {
+    upper ??= table(UPPER);
+    return upper[c];
+}