@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/runtime/avm2/definitions.js

@@ -0,0 +1,69 @@
+// Definitions by qualified name, "pkg::Name" or "Name", as a host and
+// ApplicationDomain look them up: a SWF's SymbolClass, a player's own
+// classes, and getDefinition.
+import { CONSTANT_Qname, Multiname, NS_Public, namespace, publicNs, qname } from "./names.js";
+/**
+ * The class `qualified` names, "pkg::Name" or "Name", its defining script
+ * run; a ReferenceError if no script defines it. What a SWF's SymbolClass
+ * and a player's lookups by name go through, at every version.
+ */
+export function classNamed(rt, qualified, domain) {
+    return classIn(rt, qualified, domain, (domain ?? rt.root).named, null);
+}
+/**
+ * The class `qualified` names in `domain` as code finds it, at user code's
+ * version, as avmshell's Domain.getClass does: a name of the other series'
+ * or the VM's own is a ReferenceError.
+ */
+export function classNamedByCode(rt, qualified, domain) {
+    return classIn(rt, qualified, domain, domain.namedByCode, rt.userVersions);
+}
+/** The class `qualified` names, at `versions` or every version, kept in `named` once found. */
+function classIn(rt, qualified, domain, named, versions) {
+    const known = named.get(qualified);
+    if (known) {
+        return known;
+    }
+    const cls = rt.resolveName(qualifiedNameIn(rt, qualified, domain, versions));
+    // A script still running its initializer may not have made the class yet.
+    if (cls) {
+        named.set(qualified, cls);
+    }
+    return cls;
+}
+/**
+ * What `qualified` names in `domain`, as Flash's
+ * ApplicationDomain.getDefinition finds it: a name no script defines is
+ * refused by its local name, and a script whose initializer threw runs
+ * again, its error coming through each time, where a name's lookup by
+ * code keeps it as run, as avmplus does. Seen at user code's version, as
+ * avmplus' public namespace is the caller's: a name of the other series'
+ * or the VM's own is not defined, as it is not to the code itself.
+ */
+export function definitionNamed(rt, qualified, domain) {
+    const mn = qualifiedNameIn(rt, qualified, domain, rt.userVersions);
+    const script = rt.findScript(mn);
+    if (!script) {
+        throw rt.error("ReferenceError", 1065, mn.name);
+    }
+    return rt.getProperty(rt.initScript(script, true), mn);
+}
+/** The module whose script defines `qualified` for `domain`, or null: by it a player keys what SymbolClass binds. */
+export function definingAbc(rt, qualified, domain) {
+    return rt.findScript(qualifiedNameIn(rt, qualified, domain, null))?.abc ?? null;
+}
+/**
+ * The public name "pkg::Name" or "Name" stands for, looked up in `domain`:
+ * at `versions`, user code's as code finds a name, or with null at every
+ * version, as the host reaches names.
+ */
+function qualifiedNameIn(rt, qualified, domain, versions) {
+    const i = qualified.lastIndexOf("::");
+    const ns = i < 0 ? publicNs : namespace(NS_Public, qualified.slice(0, i));
+    const local = i < 0 ? qualified : qualified.slice(i + 2);
+    const mn = versions
+        ? new Multiname(CONSTANT_Qname, [ns], versions, local, false)
+        : qname(ns, local);
+    mn.domain = domain === rt.root ? null : domain;
+    return mn;
+}

package/dist/thread/runtime/avm2/descriptors.js

@@ -0,0 +1,5 @@
+// What a compiled module is built against: the values it handles, and the
+// descriptors of its traits, classes and scripts it gives the runtime
+// (docs/architecture/compiler.md, "Modules and the bootstrap").
+/** Not a property: distinct from undefined, which a property can hold. */
+export const NOT_FOUND = Symbol("not found");

package/dist/thread/runtime/avm2/dictionary-keys.js

@@ -0,0 +1,295 @@
+// A Dictionary's object keys, and the slots a for-in goes through them by.
+// As DictionaryObject's hashtable, the store itself holds each key's slot,
+// so that a for-in reads a slot for its name and value, with no list of
+// names built at its start and no lookup at each step. Weak keys (new
+// Dictionary(true)) keep no key alive, as Flash's do not: their entries are
+// held strongly only by a WeakMap keyed by the key, and their slots hold
+// them weakly, so neither a for-in left off nor a value that refers to its
+// key keeps the key.
+/** The value of an entry not there: deleted, or kept spare. No ActionScript value is a symbol. */
+const GONE = Symbol("gone");
+/** What valueAt gives where a dynamic property's name is, whose value is the property's. */
+export const NAMED = Symbol("named");
+/**
+ * A key and its value. Once deleted and its slot freed, it is kept to hold
+ * a key added later, with the WeakRef a weak one has: V8 keeps each
+ * WeakRef's target alive until the current job ends, so a new one for each
+ * key added would keep every entry made in a long frame.
+ */
+class Entry {
+    /** Null once deleted from a slot. */
+    key = null;
+    /** GONE while not there: its slot is passed over, and free when a for-in next starts. */
+    value = GONE;
+    /** Its slot, -1 until a for-in starts and gives it one. */
+    slot = -1;
+}
+class WeakEntry extends Entry {
+    /** How the slots hold it. */
+    ref = new WeakRef(this);
+}
+/**
+ * As avmplus' hashtable, a name keeps its slot while it is there, so that a
+ * for-in started inside another never moves the outer one's names. One
+ * deleted stays in its slot, which a for-in passes over, until a for-in next
+ * starts: then its slot is free, and the names added since take the free
+ * slots, the Dictionary's dynamic properties first, then its keys in the
+ * order they were added; only with none free does the list grow. So a for-in
+ * goes through neither a name added during it nor one deleted before it gets
+ * there, and goes through each other once.
+ */
+export class DictionaryKeys {
+    weak;
+    /**
+     * Each key's entry. One deleted before it had a slot stays, GONE, so that
+     * the key set again takes it back: deleting and setting a key over and
+     * over between for-ins makes nothing. A strong key deleted so stays alive
+     * until a for-in starts or `added` is settled, which keeps that bounded by
+     * twice the keys there, and 64.
+     */
+    map;
+    /** Each slot: a key's entry, a dynamic property's name, or null where free. */
+    slots = [];
+    /** The entries added since a for-in last started, which take slots when one next does. */
+    added = [];
+    /** The count of those at which the ones deleted or collected are dropped, so none pile up. */
+    addedLimit = 64;
+    /** The entries with slots deleted since a for-in last started, freed when one next does. */
+    deleted = [];
+    /** The slots of keys collected that a for-in has come across since one last started. */
+    collected = [];
+    /** Entries no longer used, to hold keys added later; trimmed when a for-in starts. */
+    spare = [];
+    /** The slot of each dynamic property's name. */
+    named = null;
+    constructor(weak) {
+        this.weak = weak;
+        this.map = weak ? new WeakMap() : new Map();
+    }
+    get(key) {
+        const value = this.map.get(key)?.value;
+        return value === GONE ? undefined : value;
+    }
+    has(key) {
+        const entry = this.map.get(key);
+        return entry !== undefined && entry.value !== GONE;
+    }
+    set(key, value) {
+        if (!this.replace(key, value)) {
+            this.add(key, value);
+        }
+        return this;
+    }
+    /**
+     * Sets the value of a key that has an entry, there or deleted, and says
+     * whether it had one; set's first half, so that a caller can look at a
+     * key before it is added.
+     */
+    replace(key, value) {
+        const known = this.map.get(key);
+        if (known === undefined) {
+            return false;
+        }
+        known.value = value;
+        return true;
+    }
+    /** Adds a key that has no entry (replace said so). */
+    add(key, value) {
+        const entry = this.spare.pop() ?? (this.weak ? new WeakEntry() : new Entry());
+        entry.key = key;
+        entry.value = value;
+        this.map.set(key, entry);
+        this.added.push(this.hold(entry));
+        if (this.added.length >= this.addedLimit) {
+            this.added = this.settle(this.added);
+            this.addedLimit = Math.max(64, this.added.length * 2);
+        }
+    }
+    delete(key) {
+        const entry = this.map.get(key);
+        if (entry === undefined || entry.value === GONE) {
+            return false;
+        }
+        entry.value = GONE;
+        if (entry.slot >= 0) {
+            this.map.delete(key);
+            entry.key = null;
+            this.deleted.push(entry);
+        }
+        return true;
+    }
+    /** The keys there now: those with slots, in their slots' order, then those added since. */
+    *keys() {
+        for (const entry of this.entries()) {
+            yield entry.key;
+        }
+    }
+    *[Symbol.iterator]() {
+        for (const entry of this.entries()) {
+            yield [entry.key, entry.value];
+        }
+    }
+    get size() {
+        let n = 0;
+        for (const _ of this.entries()) {
+            n++;
+        }
+        return n;
+    }
+    /**
+     * The index after `index` of a name of Dictionary `o` there now, or 0. A
+     * for-in's start (index 0) first frees the slots of names gone and gives
+     * those added theirs.
+     */
+    next(o, index) {
+        if (index === 0) {
+            this.start(o);
+        }
+        const slots = this.slots;
+        for (let i = index; i < slots.length; i++) {
+            const held = slots[i];
+            if (held === null) {
+                continue;
+            }
+            if (typeof held === "string") {
+                if (o.$d?.has(held) && !o.$dontEnum?.has(held)) {
+                    return i + 1;
+                }
+                continue;
+            }
+            const entry = this.open(held);
+            if (entry === undefined) {
+                slots[i] = null;
+                this.collected.push(i);
+            }
+            else if (entry.value !== GONE) {
+                return i + 1;
+            }
+        }
+        return 0;
+    }
+    /** The name at a for-in's index: a key, a dynamic property's name, or "" once a key is gone. */
+    nameAt(index) {
+        const held = this.slots[index - 1];
+        if (held === null || held === undefined) {
+            return "";
+        }
+        return typeof held === "string" ? held : (this.open(held)?.key ?? "");
+    }
+    /** The value at a for-in's index: a key's, undefined once it is gone, or NAMED. */
+    valueAt(index) {
+        const held = this.slots[index - 1];
+        if (held === null || held === undefined) {
+            return undefined;
+        }
+        if (typeof held === "string") {
+            return NAMED;
+        }
+        const value = this.open(held)?.value;
+        return value === GONE ? undefined : value;
+    }
+    /** The entry a slot or `added` holds, or undefined once its key is collected. */
+    open(held) {
+        return this.weak ? held.deref() : held;
+    }
+    hold(entry) {
+        return this.weak ? entry.ref : entry;
+    }
+    *entries() {
+        for (let i = 0; i < this.slots.length; i++) {
+            const held = this.slots[i];
+            const entry = held === null || typeof held === "string" ? undefined : this.open(held);
+            if (entry !== undefined && entry.value !== GONE) {
+                yield entry;
+            }
+        }
+        for (let i = 0; i < this.added.length; i++) {
+            const entry = this.open(this.added[i]);
+            if (entry !== undefined && entry.value !== GONE) {
+                yield entry;
+            }
+        }
+    }
+    /** Those of `added` still there; the others are let go, their keys with them. */
+    settle(added) {
+        let kept = 0;
+        for (let i = 0; i < added.length; i++) {
+            const held = added[i];
+            const entry = this.open(held);
+            if (entry === undefined) {
+                continue;
+            }
+            if (entry.value !== GONE) {
+                added[kept++] = held;
+            }
+            else {
+                this.map.delete(entry.key);
+                entry.key = null;
+                this.spare.push(entry);
+            }
+        }
+        added.length = kept;
+        return added;
+    }
+    start(o) {
+        const d = o.$d;
+        const deleted = this.deleted;
+        if (this.added.length === 0 &&
+            deleted.length === 0 &&
+            this.collected.length === 0 &&
+            !d?.size &&
+            !this.named?.size) {
+            return;
+        }
+        const slots = this.slots;
+        const free = [];
+        for (let i = 0; i < deleted.length; i++) {
+            const entry = deleted[i];
+            slots[entry.slot] = null;
+            free.push(entry.slot);
+            entry.slot = -1;
+            this.spare.push(entry);
+        }
+        deleted.length = 0;
+        for (let i = 0; i < this.collected.length; i++) {
+            free.push(this.collected[i]);
+        }
+        this.collected.length = 0;
+        if (this.named !== null) {
+            for (const [name, i] of this.named) {
+                if (!d?.has(name)) {
+                    this.named.delete(name);
+                    slots[i] = null;
+                    free.push(i);
+                }
+            }
+        }
+        // Lowest first, so that the names added fill the earliest gaps.
+        free.sort((a, b) => a - b);
+        let next = 0;
+        // Freed, `named` holds only names still there: as many as there are, and none is new.
+        if (d?.size && d.size !== (this.named?.size ?? 0)) {
+            this.named ??= new Map();
+            for (const name of d.keys()) {
+                if (!this.named.has(name)) {
+                    const i = next < free.length ? free[next++] : slots.length;
+                    slots[i] = name;
+                    this.named.set(name, i);
+                }
+            }
+        }
+        const added = this.settle(this.added);
+        for (let n = 0; n < added.length; n++) {
+            const i = next < free.length ? free[next++] : slots.length;
+            slots[i] = added[n];
+            this.open(added[n]).slot = i;
+        }
+        // Kept for as many keys as were added since the last start, as the next
+        // may add as many again; an emptied Dictionary keeps almost none.
+        if (this.spare.length > added.length + 64) {
+            this.spare.length = added.length + 64;
+        }
+        this.added = [];
+        this.addedLimit = 64;
+    }
+}

package/dist/thread/runtime/avm2/domain-memory.js

@@ -0,0 +1,75 @@
+/**
+ * The messages of the RangeErrors a DataView throws for an offset out of
+ * its range, as this engine words them: below 0, past the end, and with
+ * too few bytes left, for a load and a store.
+ */
+const viewRangeMessages = (() => {
+    const messages = new Set();
+    const view = new DataView(new ArrayBuffer(4));
+    const probes = [
+        () => view.getUint8(-1),
+        () => view.getUint8(4),
+        () => view.getInt32(1, true),
+        () => view.getFloat64(0, true),
+        () => view.setUint8(-1, 0),
+        () => view.setUint16(3, 0, true),
+        () => view.setFloat64(0, 0, true),
+        () => view.getUint8(0xffffffff),
+    ];
+    for (let i = 0; i < probes.length; i++) {
+        try {
+            probes[i]();
+        }
+        catch (e) {
+            if (e instanceof RangeError) {
+                messages.add(e.message);
+            }
+        }
+    }
+    return messages;
+})();
+/** Whether `e` is the RangeError a DataView throws for an offset out of its range. */
+export function isViewRangeError(e) {
+    return e instanceof RangeError && viewRangeMessages.has(e.message);
+}
+/**
+ * Domain memory another worker shares, as generated code reaches it: each
+ * access through the runtime's li8 and the others, which read the length
+ * again, as that worker may have grown it, before they reject an address.
+ */
+export class SharedMemoryView {
+    rt;
+    constructor(rt) {
+        this.rt = rt;
+    }
+    getUint8(at) {
+        return this.rt.li8(at);
+    }
+    getUint16(at, _littleEndian) {
+        return this.rt.li16(at);
+    }
+    getInt32(at, _littleEndian) {
+        return this.rt.li32(at);
+    }
+    getFloat32(at, _littleEndian) {
+        return this.rt.lf32(at);
+    }
+    getFloat64(at, _littleEndian) {
+        return this.rt.lf64(at);
+    }
+    setUint8(at, value) {
+        this.rt.si8(value, at);
+    }
+    setUint16(at, value, _littleEndian) {
+        this.rt.si16(value, at);
+    }
+    setInt32(at, value, _littleEndian) {
+        this.rt.si32(value, at);
+    }
+    setFloat32(at, value, _littleEndian) {
+        this.rt.sf32(value, at);
+    }
+    setFloat64(at, value, _littleEndian) {
+        this.rt.sf64(value, at);
+    }
+}