@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,280 @@
+// Application domains, as avmplus' DomainMgr keeps them: the scripts each
+// one's modules define, by name, and what each has found, from which a
+// name's definition is looked up along a domain's chain.
+import { NS_Private } from "./names.js";
+/**
+ * An application domain, as avmplus' Domain: the scripts its modules
+ * define, by name, a name its chain defines already not again (see
+ * Runtime.abc); the definitions it has found, by name, which it keeps
+ * (see Runtime.findScript), as names and, apart, as types; and the ABCs
+ * loaded into it, by hash.
+ */
+export class Domain {
+    parent;
+    id;
+    globals = new Map();
+    cached = new Map();
+    /** As avmplus' m_cachedTraits, which a name's lookup never fills, nor a type's m_cachedScripts. */
+    types = new Map();
+    classRefs = new Map();
+    /**
+     * The classes classNamed found here, by qualified name: what a name
+     * finds in a domain is kept once found, so a player's lookups by name,
+     * one for each object it makes, need not name it anew each time.
+     */
+    named = new Map();
+    /** The same, of the classes code finds by name, at user code's version (classNamedByCode). */
+    namedByCode = new Map();
+    own = [];
+    /** Each of its ABCs' place among all the runtime loads. */
+    ownOrder = [];
+    constructor(parent, 
+    /** Its number in its runtime, which a host's compiler knows it by: the root's is 0. */
+    id) {
+        this.parent = parent;
+        this.id = id;
+    }
+    /**
+     * The ABCs a module loaded into it now is compiled after: its own and
+     * its ancestors', including those loaded after it was made, in the order
+     * they loaded.
+     */
+    chain() {
+        if (!this.parent) {
+            return [...this.own];
+        }
+        const loads = [];
+        for (let d = this; d; d = d.parent) {
+            const { own, ownOrder } = d;
+            for (let i = 0; i < own.length; i++) {
+                loads.push([ownOrder[i], own[i]]);
+            }
+        }
+        return loads.sort((a, b) => a[0] - b[0]).map(([, hash]) => hash);
+    }
+}
+/**
+ * Each frame's site, "script:line:column", innermost first, or null for a
+ * frame line it cannot read: V8's "at f (script:1:2)" and "at script:1:2",
+ * and SpiderMonkey's and JavaScriptCore's "f@script:1:2". Lines that are
+ * no frame, as V8's heading "Error", are left out. The site is read so
+ * that nothing a name holds can stand for it: in V8's frames, inside the
+ * last parentheses; in the others, after the first "@", since URLs may
+ * hold one ("/npm/p@1.0/m.js") and the names a SWF's code can have
+ * cannot (codegen spells them from [A-Za-z0-9_$]). One without a line and
+ * column is unread: JavaScriptCore's for code a Function or eval made,
+ * whatever its sourceURL ("f@"), and for native code ("f@[native code]"),
+ * and V8's "native", "<anonymous>" or "index 0".
+ */
+export function frameSites(stack) {
+    const lines = stack?.split("\n") ?? [];
+    const v8 = lines.some((line) => /^\s*at /.test(line));
+    const sites = [];
+    for (const line of lines) {
+        if (v8 ? !/^\s*at /.test(line) : !line.includes("@")) {
+            continue;
+        }
+        let site;
+        if (v8) {
+            const text = line.replace(/^\s*at /, "");
+            const open = text.lastIndexOf(" (");
+            site =
+                text.endsWith(")") && open >= 0 ? text.slice(open + 2, -1) : text.replace(/^async /, "");
+        }
+        else {
+            site = line.slice(line.indexOf("@") + 1);
+        }
+        sites.push(/:\d+:\d+$/.test(site) ? site : null);
+    }
+    return sites;
+}
+/** A frame site's script: "script:1:2" without its line and column. */
+export function siteScript(site) {
+    const script = /^(.+):\d+:\d+$/.exec(site)?.[1];
+    // Deferred entries have separate debugger files but their module's code context.
+    return script?.replace(/^(swf2es-\d+\.js)\/\$f\d+\.js$/, "$1") ?? null;
+}
+/**
+ * The script each of a stack's frames names, innermost first, or null for
+ * a frame that names none or a line it cannot read (see frameSites). For
+ * security checks, where such a frame must not be passed over;
+ * frameScripts leaves them out.
+ */
+export function stackFrames(stack) {
+    return frameSites(stack).map((site) => (site === null ? null : siteScript(site)));
+}
+/** The scripts a stack's frames name, innermost first, those that name none left out. */
+export function frameScripts(stack) {
+    return stackFrames(stack).filter((at) => at !== null);
+}
+/** The definition of a table's that `mn` names: its namespaces in order, each at a version it sees. */
+function match(table, mn, name) {
+    const list = table.get(name);
+    if (!list) {
+        return null;
+    }
+    for (let i = 0; i < mn.namespaces.length; i++) {
+        const ns = mn.namespaces[i];
+        for (const g of list) {
+            if (g.ns === ns && g.version <= mn.versions[i]) {
+                return g;
+            }
+        }
+    }
+    return null;
+}
+/** Add a definition to a table, unless it has one of that name in that namespace. */
+export function add(table, g, name) {
+    let list = table.get(name);
+    if (!list) {
+        list = [];
+        table.set(name, list);
+    }
+    if (!list.some((other) => other.ns === g.ns)) {
+        list.push(g);
+    }
+}
+/**
+ * The script that defines `mn` for `domain`, or null, as
+ * DomainMgr::findScriptInDomainByMultinameImpl finds it: a definition a
+ * domain of the chain has found before, from the name's own up; else the
+ * first loaded, from the root down. Either is kept by the name's domain,
+ * and one loaded by the domain that loaded it, so a child that found its
+ * own keeps it when its parent defines the name later. A type is found
+ * the same way through caches of its own (`asType`), as avmplus finds
+ * traits, so a class a child found by name is not the type it finds.
+ */
+export function findScript(domain, mn, asType) {
+    const name = mn.name;
+    if (name === null) {
+        return null;
+    }
+    const cache = (d) => (asType ? d.types : d.cached);
+    for (let d = domain; d; d = d.parent) {
+        const found = match(cache(d), mn, name);
+        if (found) {
+            if (d !== domain) {
+                add(cache(domain), found, name);
+            }
+            return found.script;
+        }
+    }
+    const chain = [];
+    for (let d = domain; d; d = d.parent) {
+        chain.push(d);
+    }
+    for (let k = chain.length - 1; k >= 0; k--) {
+        const found = match(chain[k].globals, mn, name);
+        if (found) {
+            add(cache(chain[k]), found, name);
+            add(cache(domain), found, name);
+            return found.script;
+        }
+    }
+    return null;
+}
+/**
+ * The script of the first definition of `mn` from the root down to
+ * `domain`, what no cache has changed, and caching none: for a question
+ * that must not decide what a later lookup finds.
+ */
+export function firstDefinition(domain, mn) {
+    const name = mn.name;
+    if (name === null) {
+        return null;
+    }
+    const chain = [];
+    for (let d = domain; d; d = d.parent) {
+        chain.push(d);
+    }
+    for (let k = chain.length - 1; k >= 0; k--) {
+        const found = match(chain[k].globals, mn, name);
+        if (found) {
+            return found.script;
+        }
+    }
+    return null;
+}
+/** What an ABC loaded into `domain` now compiles in. */
+export function compileUnit(domain) {
+    const domains = [];
+    for (let d = domain; d; d = d.parent) {
+        domains.push(d.id);
+    }
+    return { linked: domain.chain(), domains, found: foundIn(domain) };
+}
+/**
+ * What `domain` finds, by name and as a type, that is not the first
+ * definition from the root down: what a cache of its chain holds, from
+ * the domain up. The root's caches hold only its own first definitions.
+ */
+function foundIn(domain) {
+    const found = [];
+    for (const asType of [false, true]) {
+        const seen = new Set();
+        for (let d = domain; d?.parent; d = d.parent) {
+            for (const [name, list] of asType ? d.types : d.cached) {
+                for (const g of list) {
+                    const key = `${g.ns.kind}:${g.ns.uri}::${name}`;
+                    if (seen.has(key) || g.ns.uri === null || g.ns.kind === NS_Private) {
+                        continue;
+                    }
+                    seen.add(key);
+                    if (firstLoaded(domain, name, g.ns) !== g.script) {
+                        const abc = g.script.abc;
+                        found.push({
+                            nsKind: g.ns.kind,
+                            uri: g.ns.uri,
+                            name,
+                            domain: abc.domain.id,
+                            index: abc.index,
+                            hash: abc.hash,
+                            asType,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return found;
+}
+/** The script that first defines `name` in `ns` for `domain`, from the root down. */
+function firstLoaded(domain, name, ns) {
+    const chain = [];
+    for (let d = domain; d; d = d.parent) {
+        chain.push(d);
+    }
+    for (let k = chain.length - 1; k >= 0; k--) {
+        const g = chain[k].globals.get(name)?.find((other) => other.ns === ns);
+        if (g) {
+            return g.script;
+        }
+    }
+    return null;
+}
+/** Whether `domain`'s chain defines `name` in `ns`, cached or loaded, without keeping what it finds. */
+export function definedInChain(domain, name, ns) {
+    for (let d = domain; d; d = d.parent) {
+        if (d.cached.get(name)?.some((g) => g.ns === ns) ||
+            d.globals.get(name)?.some((g) => g.ns === ns)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * The names `domain`'s own modules define, private ones left out, as
+ * Flash's ApplicationDomain.getQualifiedDefinitionNames lists them:
+ * "pkg::Name", or the name alone in the top-level package.
+ */
+export function definitionNames(domain) {
+    const names = [];
+    for (const [name, list] of domain.globals) {
+        for (const g of list) {
+            if (g.ns.kind !== NS_Private) {
+                names.push(g.ns.uri ? `${g.ns.uri}::${name}` : name);
+            }
+        }
+    }
+    return names;
+}

package/dist/thread/runtime/avm2/dynamic-properties.js

@@ -0,0 +1,182 @@
+// A dynamic object's properties, and the slots a for-in goes through them
+// by. As avmplus' hashtable, where a name, its value and its place in a
+// for-in are one slot, the properties keep the slots themselves, as they
+// are set and deleted: a for-in reads a slot at each step, with no lookup,
+// and finds at its start only what changed since the last, with no list of
+// names to build and compare. An object no for-in has gone through keeps no
+// slots, and its properties are a Map as any other.
+/**
+ * The slots of an object's names, as avmplus' hashtable keeps them: 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.
+ * Names added since take the free slots, lowest first, in the order they
+ * were added, and only with none free does the list grow; set again before
+ * its slot is freed, a name takes it back.
+ */
+/** A slot's name deleted, or the slot free: passed over. */
+export const GONE = 0;
+/** A slot's name there. */
+const THERE = 1;
+/** A slot's name set again after it was deleted, its slot still in `deleted`. */
+const BACK = 2;
+export class Walk {
+    /** Each slot's name, null where free. */
+    slots;
+    /** Whether each slot's name is there: GONE, THERE or BACK. */
+    live;
+    slotOf;
+    /** The names added since a for-in last placed them, oldest first, some since deleted or added again. */
+    added = [];
+    /** The count of those at which the ones deleted are dropped and each kept once, so that none pile up. */
+    addedLimit = 64;
+    /** The slots of the names deleted since a for-in last started, to free when one next does. */
+    deleted = [];
+    /** The free slots, lowest first. */
+    free = [];
+    constructor(names) {
+        this.slots = names;
+        this.live = new Array(names.length).fill(THERE);
+        this.slotOf = new Map();
+        for (let i = 0; i < names.length; i++) {
+            this.slotOf.set(names[i], i);
+        }
+    }
+    /** `name`, not there, set: back in its slot if it still has one, else to take one. */
+    noteAdded(name, properties) {
+        const i = this.slotOf.get(name);
+        if (i !== undefined) {
+            // In `deleted` still: set again and deleted over and over, it is there once.
+            this.live[i] = BACK;
+            return;
+        }
+        this.added.push(name);
+        if (this.added.length >= this.addedLimit) {
+            this.added = this.settle(properties);
+            this.addedLimit = Math.max(64, this.added.length * 2);
+        }
+    }
+    /** `name`, there, deleted: passed over in its slot, if it has one, until a for-in next starts. */
+    noteDeleted(name) {
+        const i = this.slotOf.get(name);
+        if (i === undefined) {
+            return;
+        }
+        if (this.live[i] === THERE) {
+            this.deleted.push(i);
+        }
+        this.live[i] = GONE;
+    }
+    /** At a for-in's start: the slots of the names deleted since the last are free. */
+    freeDeleted() {
+        const deleted = this.deleted;
+        if (deleted.length === 0) {
+            return;
+        }
+        const slots = this.slots;
+        for (let n = 0; n < deleted.length; n++) {
+            const i = deleted[n];
+            if (this.live[i] === BACK) {
+                this.live[i] = THERE;
+            }
+            else {
+                this.slotOf.delete(slots[i]);
+                slots[i] = null;
+                this.free.push(i);
+            }
+        }
+        deleted.length = 0;
+        this.free.sort((a, b) => a - b);
+    }
+    /** The names added since this was last called, in the slots free, then after them. */
+    place(properties) {
+        if (this.added.length === 0) {
+            return;
+        }
+        const names = this.settle(properties);
+        const slots = this.slots;
+        const free = this.free;
+        let taken = 0;
+        for (let n = 0; n < names.length; n++) {
+            const name = names[n];
+            const i = taken < free.length ? free[taken++] : slots.length;
+            slots[i] = name;
+            this.live[i] = THERE;
+            this.slotOf.set(name, i);
+        }
+        free.splice(0, taken);
+        this.added = [];
+        this.addedLimit = 64;
+    }
+    /**
+     * The names of `added` still there and without a slot, each once, in the
+     * order the properties have them: by when each was last added.
+     */
+    settle(properties) {
+        const added = this.added;
+        const kept = [];
+        const seen = new Set();
+        for (let n = added.length - 1; n >= 0; n--) {
+            const name = added[n];
+            if (!seen.has(name) && properties.has(name) && !this.slotOf.has(name)) {
+                seen.add(name);
+                kept.push(name);
+            }
+        }
+        return kept.reverse();
+    }
+}
+/** An object's dynamic properties, by name, which keep their slots once a for-in has gone through them. */
+export class DynamicProperties extends Map {
+    /** The slots, from the first for-in over the object. */
+    walk = null;
+    /**
+     * Whether every name was found hidden, as a prototype's methods are, so
+     * that a for-in passing through need not look at each again: until a
+     * name is set, or one shown (setPropertyIsEnumerable).
+     */
+    allHidden = false;
+    set(name, value) {
+        this.allHidden = false;
+        // Undefined while the Map's constructor runs, before the field is set.
+        const walk = this.walk;
+        if (walk && !super.has(name)) {
+            walk.noteAdded(name, this);
+        }
+        return super.set(name, value);
+    }
+    delete(name) {
+        if (!super.delete(name)) {
+            return false;
+        }
+        this.walk?.noteDeleted(name);
+        return true;
+    }
+    clear() {
+        const walk = this.walk;
+        if (walk) {
+            for (const name of super.keys()) {
+                walk.noteDeleted(name);
+            }
+        }
+        super.clear();
+    }
+    /**
+     * The slots at the start of a for-in over the names (`starting`), whose
+     * deleted names' slots are then free, or going on to them from an Array's
+     * elements, whose start freed them: with the names added since in them.
+     */
+    startWalk(starting) {
+        let walk = this.walk;
+        if (walk === null) {
+            walk = new Walk([...super.keys()]);
+            this.walk = walk;
+            return walk;
+        }
+        if (starting) {
+            walk.freeDeleted();
+        }
+        walk.place(this);
+        return walk;
+    }
+}