@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/runtime/avm2/array-conversion.js

@@ -0,0 +1,100 @@
+// Number(array) without formatting and parsing, for the Arrays whose
+// conversion is still the builtins'.
+import { NOT_FOUND } from "./descriptors.js";
+import { numberReadBack, stringToNumber } from "./number-strings.js";
+/**
+ * What Number(array) runs unless a script replaced it: Array's traits,
+ * Array.prototype, its toString and Object.prototype.valueOf, as the
+ * script defining Object leaves them, before any other script runs.
+ */
+export class ArrayConversion {
+    arrayClass = null;
+    arrayTraits = null;
+    arrayPrototype = null;
+    arrayToString = NOT_FOUND;
+    objectValueOf = NOT_FOUND;
+    noteArrayClass(cls) {
+        this.arrayClass = cls;
+    }
+    /**
+     * Notes Array's builtin conversion functions, once the script defining
+     * Object, and Array beside it, has set its prototypes' functions.
+     */
+    noteConversions() {
+        const cls = this.arrayClass;
+        if (cls === null) {
+            return;
+        }
+        const prototype = cls.$prototype;
+        const objectPrototype = prototype.$p;
+        const toStringFn = prototype.$d.get("toString");
+        const valueOfFn = objectPrototype?.$d.get("valueOf");
+        if (toStringFn?.$f && valueOfFn?.$f) {
+            this.arrayTraits = cls.$it;
+            this.arrayPrototype = prototype;
+            this.arrayToString = toStringFn;
+            this.objectValueOf = valueOfFn;
+        }
+    }
+    /**
+     * Number(a) for an Array whose conversion is still the builtins': its
+     * valueOf returns it, and its toString joins its elements with commas,
+     * which then read back as a number. Without formatting and parsing, for
+     * the Arrays whose result is plain: none or one primitive element, or
+     * only primitives, whose join holds a comma and so is NaN, unless a NUL
+     * ends the number before it. Undefined for any other, which takes the
+     * general path, as does one with a hole, whose element the prototypes
+     * give.
+     */
+    arrayToNumber(o) {
+        const traits = this.arrayTraits;
+        if (traits === null || o.$traits !== traits) {
+            return undefined;
+        }
+        const prototype = this.arrayPrototype;
+        const d = o.$d;
+        const pd = prototype.$d;
+        if ((d !== null && (d.has("valueOf") || d.has("toString"))) ||
+            pd.has("valueOf") ||
+            pd.get("toString") !== this.arrayToString ||
+            prototype.$p.$d.get("valueOf") !== this.objectValueOf) {
+            return undefined;
+        }
+        const a = o.$a;
+        const length = a.length;
+        if (length === 0) {
+            return 0;
+        }
+        if (length === 1) {
+            if (!(0 in a)) {
+                return undefined;
+            }
+            const v = a[0];
+            switch (typeof v) {
+                case "number":
+                    return numberReadBack(v);
+                case "string":
+                    return stringToNumber(v);
+                case "boolean":
+                    return Number.NaN;
+                case "undefined":
+                    return 0;
+                default:
+                    return v === null ? 0 : undefined;
+            }
+        }
+        for (let i = 0; i < length; i++) {
+            if (!(i in a)) {
+                return undefined;
+            }
+            const v = a[i];
+            if (v !== null && typeof v === "object") {
+                return undefined;
+            }
+            if (typeof v === "string" && v.includes("\0")) {
+                return undefined;
+            }
+        }
+        return Number.NaN;
+    }
+}

package/dist/thread/runtime/avm2/builtin-library.js

@@ -0,0 +1,21 @@
+// avmplus' builtin.abc: ActionScript 3's standard library, which every runtime loads first.
+// Generated by tools/avmplus-libraries.ts --update; not to be edited.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Its source form is the ActionScript in core/
+// of avmplus, https://github.com/swf2es/avmplus at commit
+// 858d034a3bd3a54d9b70909386435cf4aec81d21,
+// which core/builtin.py compiles into generated/builtin.abc.
+/** Base64 to bytes with a plain loop: Uint8Array.from with a callback takes some 8 times as long. */
+function decode(text) {
+    const raw = atob(text);
+    const bytes = new Uint8Array(raw.length);
+    for (let i = 0; i < raw.length; i++) {
+        bytes[i] = raw.charCodeAt(i);
+    }
+    return bytes;
+}
+export const builtinLibrary = decode("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");

package/dist/thread/runtime/avm2/cache-fill.js

@@ -0,0 +1,86 @@
+// What a full lookup leaves in its multiname's inline cache for the next
+// get, set or call on an object with the same traits (property-cache.ts).
+import { hookedBinding } from "./hooks.js";
+import { arrayIndex } from "./names.js";
+import { entryFor, IC_Call, IC_Const, IC_Dynamic, IC_Get, IC_GetSet, IC_Method, IC_Set, IC_Slot, PropertyCache, UNFILLED, } from "./property-cache.js";
+import { BIND_Const, BIND_Get, BIND_GetSet, BIND_Method, BIND_Set, BIND_Var, methodKey, slotKey, untypedSetKey, } from "./traits.js";
+/**
+ * Keep what `mn` found on `traits`, `o`'s, in `head`, its cache: a
+ * binding, as getProperty, setProperty and callProperty use it, or a
+ * dynamic property's name. Not where the name resolves otherwise: through
+ * a property hook (a Proxy's, XML's), an index (a Vector's, an Array's
+ * element), or a Dictionary's key; nor on a primitive's dynamic property,
+ * which its prototypes have.
+ */
+export function fillCache(head, o, traits, b, mn) {
+    const hook = traits.properties;
+    const id = b >> 3;
+    let kind;
+    let key = "";
+    let get = null;
+    let set = null;
+    let type = null;
+    if (b === 0) {
+        const name = mn.dynamicName();
+        if (name === null ||
+            (typeof o !== "object" && typeof o !== "function") ||
+            hook !== null ||
+            !traits.dynamic ||
+            traits.refusesNames ||
+            traits.getIndex !== undefined ||
+            traits.index !== undefined ||
+            arrayIndex(name) >= 0) {
+            return;
+        }
+        kind = IC_Dynamic;
+        key = name;
+    }
+    else {
+        const hooked = hook !== null && hookedBinding(b, mn, hook);
+        switch (b & 7) {
+            case BIND_Method:
+                kind = hooked ? IC_Call : IC_Method;
+                get = traits.proto[methodKey(id)];
+                break;
+            case BIND_Var:
+            case BIND_Const:
+                kind = (b & 7) === BIND_Var ? IC_Slot : IC_Const;
+                key = slotKey(id);
+                type = traits.slotType(id);
+                break;
+            case BIND_Get:
+                kind = IC_Get;
+                get = traits.proto[methodKey(id)];
+                break;
+            case BIND_Set:
+                kind = IC_Set;
+                set = traits.proto[untypedSetKey(id + 1)] ?? traits.proto[methodKey(id + 1)];
+                break;
+            case BIND_GetSet:
+                kind = IC_GetSet;
+                get = traits.proto[methodKey(id)];
+                set = traits.proto[untypedSetKey(id + 1)] ?? traits.proto[methodKey(id + 1)];
+                break;
+            default:
+                return;
+        }
+        if (hooked && kind !== IC_Call) {
+            return;
+        }
+    }
+    if (head === UNFILLED) {
+        head = new PropertyCache();
+        mn.cache = head;
+    }
+    const e = entryFor(head, traits);
+    if (e === null) {
+        return;
+    }
+    e.traits = traits;
+    e.kind = kind;
+    e.key = key;
+    e.get = get;
+    e.set = set;
+    e.type = type;
+    e.id = id;
+}

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

@@ -0,0 +1,211 @@
+// Classes as OP_newclass makes them: a class object and its instances'
+// traits from the module's descriptor, with its hooks, its prototype
+// object and its methods bound to the scope chain it is made in; and the
+// Vector.<T> classes applying Vector to a type makes.
+import { firstDefinition } from "./domain.js";
+import { installMethod } from "./method-factories.js";
+import { formatClassName, NS_Public, qualifiedName } from "./names.js";
+import { invalidate } from "./property-cache.js";
+import { BIND_Set, boundKey, methodKey, Traits, VALUE_TESTS } from "./traits.js";
+/**
+ * As OP_newclass: a class from its module's descriptor, extending `base`,
+ * its methods bound to the scope chain here. Object, Class and Function
+ * use the traits the runtime made for them before they existed.
+ */
+export function newClass(rt, desc, base, scope) {
+    const error = desc.instance.error ?? desc.static.error;
+    if (error) {
+        throw rt.error("VerifyError", error);
+    }
+    const abc = desc.abc;
+    const name = abc.names[desc.name];
+    const qualified = qualifiedName(name);
+    // As MethodEnv::newclass: a class with a base needs one (#1009), and
+    // one whose traits are the base's it linked to, which avmplus finds as
+    // a type (#1108). Compared by definition, as avmplus compares traits: a
+    // class made twice is one class. Where the base is the class its name
+    // finds by name, but not the one it finds as a type, as for a child's
+    // class it found by name after its parent defined the name too,
+    // avmshell rejects the class sooner, as corrupt (#1107). Only a class
+    // that exists is compared: the check runs no script.
+    if (desc.base && (base === null || base === undefined)) {
+        throw rt.error("TypeError", 1009);
+    }
+    if (rt.children && base) {
+        const baseName = abc.names[desc.base];
+        const script = rt.findScript(baseName, true);
+        const expected = script?.global ? rt.getProperty(script.global, baseName) : undefined;
+        if (expected?.$it && expected.$desc !== base.$desc) {
+            const byName = rt.findScript(baseName);
+            const named = byName?.global ? rt.getProperty(byName.global, baseName) : undefined;
+            throw rt.error("VerifyError", named === base ? 1107 : 1108);
+        }
+    }
+    // A builtin or a player's class, whose hook and type tests are its own,
+    // is the first definition of its name, as avmplus' natives belong to
+    // their ABC; a top-level one is public. A class only named as one, as a
+    // file's own internal Boolean is, is a class like any other.
+    const ns = name.namespaces[0];
+    const own = (ns?.kind === NS_Public || !!ns?.uri) &&
+        firstDefinition(name.domain ?? rt.root, name)?.abc === abc;
+    const baseTraits = base ? base.$it : null;
+    let itraits;
+    if (own && qualified === "Object") {
+        itraits = rt.objectTraits;
+    }
+    else if (own && qualified === "Class") {
+        itraits = rt.classTraits;
+    }
+    else if (own && qualified === "Function") {
+        itraits = rt.functionTraits;
+    }
+    else {
+        itraits = new Traits(qualified, baseTraits);
+        itraits.testsValues = own && VALUE_TESTS.has(qualified);
+    }
+    itraits.describe(desc.instance);
+    const hooks = own ? rt.classHooks[qualified] : undefined;
+    itraits.hooks = hooks ?? null;
+    itraits.dynamic = !desc.sealed;
+    itraits.final = desc.final;
+    itraits.isInterface = desc.interface;
+    itraits.ctor = desc.ctor ?? null;
+    itraits.metadata = desc.meta ?? null;
+    itraits.refusesNames = !!hooks?.refusesNames;
+    // As ClassClosure::checkForRestrictedInheritance.
+    itraits.restricted = !!hooks?.restricted;
+    itraits.uninstantiable =
+        !!baseTraits &&
+            (baseTraits.uninstantiable || (baseTraits.restricted && baseTraits.abc !== abc));
+    itraits.abc = abc;
+    // A class's allocation, bound to the runtime; its subclasses inherit it.
+    const create = hooks?.create;
+    if (create) {
+        itraits.create = (traits) => create(traits, rt);
+    }
+    if (hooks?.properties) {
+        itraits.properties = hooks.properties;
+    }
+    if (hooks?.getIndex) {
+        itraits.getIndex = hooks.getIndex;
+        itraits.setIndex = hooks.setIndex;
+        itraits.hasIndex = hooks.hasIndex;
+        itraits.index = hooks.index;
+    }
+    for (const i of desc.interfaces) {
+        const mn = abc.names[i];
+        const iface = rt.resolveName(mn);
+        if (iface) {
+            itraits.interfaces.add(iface.$it);
+            for (const t of iface.$it.interfaces) {
+                itraits.interfaces.add(t);
+            }
+        }
+        else {
+            // Its script is the one running, and has not made it yet.
+            if (!itraits.pendingInterfaces) {
+                itraits.pendingInterfaces = [];
+            }
+            itraits.pendingInterfaces.push(() => rt.resolveName(mn)?.$it ?? null);
+        }
+    }
+    // The class object: Class's instance, with its own statics.
+    // Class is dynamic, so its instances are: String.fromCharCode = ... is legal.
+    const straits = new Traits(`${qualified}$`, rt.classTraits);
+    straits.dynamic = true;
+    straits.final = true;
+    straits.describe(desc.static);
+    const cls = straits.instance();
+    cls.$it = itraits;
+    cls.$desc = desc;
+    cls.$base = base;
+    itraits.cls = cls;
+    straits.cls = cls;
+    // Its prototype object: an Object whose prototype is the base class's.
+    // A class object's own $p comes from Class's instance prototype, which
+    // it inherits: class objects made before Class see it once Class exists.
+    // Date's, RegExp's and Array's are instances of their own class, as avmplus has them.
+    const prototype = hooks?.prototype ? hooks.prototype(rt, cls) : rt.objectTraits.instance();
+    prototype.$p = base ? base.$prototype : null;
+    cls.$prototype = prototype;
+    itraits.proto.$p = prototype;
+    prototype.$d.set("constructor", cls);
+    prototype.$dontEnum = new Set(["constructor"]);
+    const iscope = rt.scope(scope, [cls], 0);
+    for (const [d, factory, id, , params] of desc.static.methods) {
+        installMethod(rt, straits.methodHome(3), d, withId(factory(scope, base), id), factory, params);
+    }
+    for (const [d, factory, id, , params] of desc.instance.methods) {
+        installMethod(rt, itraits.methodHome(3), d, withId(factory(iscope, base), id), factory, params);
+    }
+    // Playerglobal can declare an accessor whose setter has no ABC body.
+    // Install it here so both direct bound calls and dynamic property writes reach it.
+    if (hooks?.setOnlySlots) {
+        for (const [name, slot] of Object.entries(hooks.setOnlySlots)) {
+            const binding = itraits.find(rt.publicName(name));
+            const d = (binding >> 3) + 1;
+            if ((binding & 7) === BIND_Set && itraits.proto[methodKey(d)] == null) {
+                const set = function (value) {
+                    this[slot] = value;
+                };
+                itraits.proto[methodKey(d)] = set;
+                itraits.proto[boundKey(d)] = set;
+            }
+        }
+    }
+    // Calls through an interface read one name whatever the class; set
+    // here, before any instance exists, so that the prototype keeps its shape.
+    const aliases = desc.aliases;
+    if (aliases) {
+        const proto = itraits.proto;
+        for (let i = 0; i < aliases.length; i += 2) {
+            itraits.methodHome(1)[aliases[i]] = proto[boundKey(aliases[i + 1])];
+        }
+    }
+    // Caches keep the methods and what the hooks decide.
+    invalidate();
+    const init = desc.init(iscope, base);
+    itraits.proto.$init = init;
+    // Its entry for `new` and `super()` of the class where the compiler
+    // coerced the arguments, as for bound calls (installMethod).
+    itraits.proto.$binit = init.$bound ?? init;
+    // A class constructClass only allocates and initializes, which compiled
+    // code constructs itself (see the codegen's constructSlot).
+    cls.$new = !hooks?.construct && !desc.interface && !itraits.uninstantiable;
+    // Its static initializer may name the class as a type, as avmplus
+    // resolves from traits, before initproperty has stored it anywhere.
+    rt.defining.set(qualified, cls);
+    try {
+        desc.cinit(scope, base).call(cls);
+    }
+    finally {
+        rt.defining.delete(qualified);
+    }
+    hooks?.created?.(rt, cls);
+    return cls;
+}
+/**
+ * Vector.<T> for a T other than int, uint and Number: Vector$object's
+ * class, typed, whose name names T as avmplus does, a builtin Vector as
+ * Vector.<int>, and whose superclass is Vector.<*>, Vector$object.
+ */
+export function specializeVector(rt, base, param) {
+    const itraits = new Traits(`__AS3__.vec::Vector.<${formatClassName(param.$it.name)}>`, base.$it);
+    itraits.dynamic = base.$it.dynamic;
+    itraits.refusesNames = base.$it.refusesNames;
+    itraits.hooks = base.$it.hooks;
+    const cls = Object.create(Object.getPrototypeOf(base));
+    cls.$d = null;
+    cls.$it = itraits;
+    cls.$desc = base.$desc;
+    cls.$base = base;
+    cls.$prototype = base.$prototype;
+    cls.$param = rt.refOf(param);
+    itraits.cls = cls;
+    return cls;
+}
+/** `f`, a method, with its method id, which a closure of it keeps. */
+export function withId(f, id) {
+    f.$id = id;
+    return f;
+}