@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/runtime/avm2/natives/toplevel.js

@@ -0,0 +1,139 @@
+// The global functions, bugzilla, and Error.
+import { formatClassName } from "../names.js";
+import { errorMessages } from "../player-messages.js";
+import { plain } from "./define.js";
+import { qualifiedClassName } from "./object.js";
+/** A String argument as avmplus has it: null, as undefined coerced to String is, as "null". */
+const text = (rt, s) => s === null || s === undefined ? "null" : rt.toString(s);
+/**
+ * A native of one String argument whose default is "undefined", as the URI
+ * functions and escape and unescape declare it: none given is the default,
+ * where an undefined given is coerced to null. A function, not an arrow,
+ * for `arguments`, and so that its length is 1.
+ */
+const ofText = (f) => (rt) => function (s) {
+    // biome-ignore lint/complexity/noArguments: how many were given, which a rest parameter would make its length 0
+    return f(rt, arguments.length === 0 ? "undefined" : text(rt, s));
+};
+/**
+ * As Toplevel's URI functions, which are ECMAScript 3's, as JavaScript's
+ * are (bugzilla 609416, the fix for surrogate pairs, in effect as avmshell
+ * runs): JavaScript's own, with URIError 1052, naming the function, for a
+ * malformed URI.
+ */
+const uri = (name, f) => ofText((rt, s) => {
+    try {
+        return f(s);
+    }
+    catch (e) {
+        if (!(e instanceof URIError)) {
+            throw e;
+        }
+        const decoded = f === decodeURI || f === decodeURIComponent ? surrogates(s, f) : null;
+        if (decoded === null) {
+            throw rt.error("URIError", 1052, name);
+        }
+        return decoded;
+    }
+});
+/** A UTF-8 encoded surrogate, which JavaScript's decoding refuses. */
+const ENCODED_SURROGATE = /%[eE][dD]%[aAbB][0-9a-fA-F]%[89aAbB][0-9a-fA-F]/g;
+/**
+ * As Toplevel::decode, which decodes a surrogate's code point as any other
+ * (Utf8ToUcs4): the parts between them JavaScript's, or null if one fails.
+ */
+function surrogates(s, f) {
+    const out = [];
+    let at = 0;
+    for (const m of s.matchAll(ENCODED_SURROGATE)) {
+        const b1 = Number.parseInt(m[0].slice(4, 6), 16);
+        const b2 = Number.parseInt(m[0].slice(7, 9), 16);
+        out.push(s.slice(at, m.index), String.fromCharCode(0xd000 | ((b1 & 0x3f) << 6) | (b2 & 0x3f)));
+        at = m.index + m[0].length;
+    }
+    if (at === 0) {
+        return null;
+    }
+    out.push(s.slice(at));
+    try {
+        return out.map((part, i) => (i % 2 === 0 ? f(part) : part)).join("");
+    }
+    catch {
+        return null;
+    }
+}
+export const toplevelNatives = {
+    // Global functions
+    isNaN: (rt) => (v) => Number.isNaN(rt.toNumber(v)),
+    isFinite: (rt) => (v) => Number.isFinite(rt.toNumber(v)),
+    parseInt: (rt) => (s, radix) => Number.parseInt(rt.toString(s), rt.toInt(radix)),
+    parseFloat: (rt) => (s) => Number.parseFloat(rt.toString(s)),
+    decodeURI: uri("decodeURI", decodeURI),
+    decodeURIComponent: uri("decodeURIComponent", decodeURIComponent),
+    encodeURI: uri("encodeURI", encodeURI),
+    encodeURIComponent: uri("encodeURIComponent", encodeURIComponent),
+    // As Toplevel::escape and unescape, which are ECMAScript's B.2.1 and B.2.2,
+    // as JavaScript's are: the same unescaped set, %XX and %uXXXX.
+    escape: ofText((_rt, s) => escape(s)),
+    unescape: ofText((_rt, s) => unescape(s)),
+    "avmplus::getQualifiedClassName": (rt) => (v) => qualifiedClassName(rt, v),
+    "avmplus::getQualifiedSuperclassName": (rt) => (v) => {
+        // null's and void's traits have no base.
+        if (v === null || v === undefined) {
+            return null;
+        }
+        const cls = v !== null && typeof v === "object" && v.$it ? v : rt.traitsOf(v).cls;
+        const base = cls?.$base;
+        return base ? formatClassName(base.$it.name) : null;
+    },
+    // As Toplevel::bugzilla: the bug fixes the builtins' AS3 asks about, all
+    // in effect at the latest SWF version, as avmshell runs.
+    bugzilla: plain((n) => n === 504525 || n === 574600 || n === 661330),
+    // Error
+    // Error.throwError fills in the template's %n: in debugger mode it has some.
+    // The debugger player writes the template as it is, %1 and all; an id it has no text for is the number alone.
+    "Error.getErrorMessage": (rt) => (id) => rt.debugger && errorMessages[id] ? `Error #${id}: ${errorMessages[id]}` : `Error #${id}`,
+    "Error#getStackTrace": plain(() => null),
+};
+/**
+ * The native error classes, which construct an error when called, as
+ * ErrorClass::call does: Error("x") is new Error("x"), not a coercion.
+ * flash.errors' are AS3 classes, and coerce.
+ */
+const constructs = { call: (rt, cls, args) => rt.constructClass(cls, args) };
+/**
+ * An AS3 error's JavaScript error, made with it: where it was made, the
+ * compiled method's name in it, for a host to show (Runtime.stackOf). The
+ * release player has no stack trace for AS3 to read, and getStackTrace
+ * still gives null.
+ */
+const errorClass = {
+    ...constructs,
+    create: (traits) => {
+        const o = Object.create(traits.proto);
+        // V8 keeps 10 frames, and the runtime's own take most of those before the first AS3 one.
+        const engine = Error;
+        const limit = engine.stackTraceLimit;
+        engine.stackTraceLimit = 48;
+        Object.defineProperty(o, "$jsError", { value: new Error() });
+        engine.stackTraceLimit = limit;
+        return o;
+    },
+};
+export const errorHooks = {
+    ...Object.fromEntries([
+        "DefinitionError",
+        "EvalError",
+        "RangeError",
+        "ReferenceError",
+        "SecurityError",
+        "SyntaxError",
+        "TypeError",
+        "URIError",
+        "VerifyError",
+        "UninitializedError",
+        "ArgumentError",
+    ].map((name) => [name, constructs])),
+    // Its subclasses inherit its create: one of their own would replace it.
+    Error: errorClass,
+};

package/dist/thread/runtime/avm2/natives/vector-elements.js

@@ -0,0 +1,46 @@
+// A Vector's elements, as the kind of its elements keeps them in V8.
+//
+// V8 merges the array maps a store site sees into the most general of
+// them: a site that has stored into an array of objects moves an array of
+// doubles that it stores into to objects too, each double boxed from then
+// on. A site that every Vector's elements pass through, as push's would
+// be, so makes every Vector.<Number>'s elements objects once a
+// Vector.<String> has been through it. Each kind stores through a function
+// of its own, and its elements start in the most general elements kind
+// they will take, so that no store moves them: a double's for uint and
+// Number, which a small integer cannot always hold, and an object's for
+// the others.
+export function storeInt(a, i, x) {
+    a[i] = x;
+}
+export function storeDouble(a, i, x) {
+    a[i] = x;
+}
+export function storeObject(a, i, x) {
+    a[i] = x;
+}
+// `length` elements of the kind's default, packed, each kind from an
+// array literal of its own.
+export function intElements(length) {
+    const a = [];
+    while (a.length < length) {
+        a.push(0);
+    }
+    return a;
+}
+export function doubleElements(length) {
+    const a = [0.5];
+    a.pop();
+    while (a.length < length) {
+        a.push(0);
+    }
+    return a;
+}
+export function objectElements(length) {
+    const a = [null];
+    a.pop();
+    while (a.length < length) {
+        a.push(null);
+    }
+    return a;
+}

package/dist/thread/runtime/avm2/natives/vector.js

@@ -0,0 +1,406 @@
+// The Vectors: one implementation, over their element conversions.
+import { arrayIndex, NS_Public, namespace, qname } from "../names.js";
+import { boundKey, methodKey } from "../traits.js";
+import { AS3, eachElement, elements, getElement, isObject, lengthOf, plain, } from "./define.js";
+import { FloatVector, setFloatElement } from "./float-vector.js";
+import { sort } from "./sort.js";
+import { doubleElements, intElements, objectElements, storeDouble, storeInt, storeObject, } from "./vector-elements.js";
+const VEC = "__AS3__.vec";
+export const vectorNatives = {};
+export const vectorHooks = {
+    [`${VEC}::Vector`]: {
+        apply: (rt, _factory, params) => vectorOf(rt, params[0] ?? null),
+        // As VectorClass::construct: only a Vector of some type is constructed.
+        construct: (rt) => {
+            throw rt.error("TypeError", 1007);
+        },
+    },
+};
+// The Vectors: one implementation, over their element conversions, and
+// their elements as each kind keeps them (see vector-elements.ts).
+const VECTORS = [
+    ["Vector$int", (rt, _cls, v) => rt.toInt(v), 0, intElements, storeInt],
+    ["Vector$uint", (rt, _cls, v) => rt.toUint(v), 0, doubleElements, storeDouble],
+    ["Vector$double", (rt, _cls, v) => rt.toNumber(v), 0, doubleElements, storeDouble],
+    // Vector.<*> holds Objects, as ObjectVectorObject does: undefined is null there.
+    [
+        "Vector$object",
+        (rt, cls, v) => rt.coerce(v, cls.$param ?? "Object"),
+        null,
+        objectElements,
+        storeObject,
+    ],
+];
+for (const [kind, , , elementsOf, store] of VECTORS) {
+    const c = `${VEC}::${kind}`;
+    const own = `${VEC}:${kind}`;
+    vectorNatives[`${c}#get:length`] = plain(function () {
+        return this.$a.length;
+    });
+    vectorNatives[`${c}#set:length`] = (rt) => function (n) {
+        if (this.$fixed) {
+            throw rt.error("RangeError", 1126);
+        }
+        const length = rt.toUint(n);
+        const a = this.$a;
+        if (a instanceof FloatVector) {
+            a.length = length;
+        }
+        else if (length === 0) {
+            // A new array: V8 empties one by a call into its runtime.
+            this.$a = elementsOf(0);
+        }
+        else if (length < a.length) {
+            a.length = length;
+        }
+        else if (length > a.length) {
+            // Pushed, not a length set then filled, so that V8 keeps it packed.
+            const fill = this.$traits.cls.$fill;
+            while (a.length < length) {
+                a.push(fill);
+            }
+        }
+    };
+    vectorNatives[`${c}#get:fixed`] = plain(function () {
+        return this.$fixed;
+    });
+    vectorNatives[`${c}#set:fixed`] = plain(function (fixed) {
+        this.$fixed = !!fixed;
+    });
+    vectorNatives[`${c}#${AS3}::push`] = (rt) => function (...args) {
+        if (this.$fixed) {
+            throw rt.error("RangeError", 1126);
+        }
+        // Each at the length there is before it, set as an element: after
+        // its conversion, which can run AS3 that changes the Vector.
+        const cls = this.$traits.cls;
+        const convert = cls.$convert;
+        for (let k = 0; k < args.length; k++) {
+            const i = this.$a.length;
+            const x = convert(rt, cls, args[k]);
+            const a = this.$a;
+            if (i > a.length || (i === a.length && this.$fixed)) {
+                throw rt.error("RangeError", 1125, i, a.length);
+            }
+            if (a instanceof FloatVector) {
+                setFloatElement(rt, this, i, x);
+            }
+            else {
+                store(a, i, x);
+            }
+        }
+        return this.$a.length;
+    };
+    vectorNatives[`${c}#${AS3}::pop`] = (rt) => function () {
+        if (this.$fixed) {
+            throw rt.error("RangeError", 1126);
+        }
+        const a = this.$a;
+        return a.length ? (a instanceof FloatVector ? rt.float(a.pop()) : a.pop()) : empty(this);
+    };
+    // As TypedVectorObject::AS3_insertAt and AS3_removeAt: a negative index
+    // counts from the end, no further back than 0; an insert past the end
+    // appends; a removal past the end is a RangeError, as an element get is.
+    vectorNatives[`${c}#${AS3}::insertAt`] = (rt) => function (index, element) {
+        if (this.$fixed) {
+            throw rt.error("RangeError", 1126);
+        }
+        const cls = this.$traits.cls;
+        const x = cls.$convert(rt, cls, element);
+        const a = this.$a;
+        const i = rt.toInt(index);
+        a.splice(i < 0 ? Math.max(0, a.length + i) : Math.min(i, a.length), 0, x);
+    };
+    vectorNatives[`${c}#${AS3}::removeAt`] = (rt) => function (index) {
+        if (this.$fixed) {
+            throw rt.error("RangeError", 1126);
+        }
+        const a = this.$a;
+        const i = rt.toInt(index);
+        const at = i < 0 ? Math.max(0, a.length + i) : i;
+        if (at >= a.length) {
+            throw rt.error("RangeError", 1125, at, a.length);
+        }
+        const value = a.splice(at, 1)[0];
+        return a instanceof FloatVector ? rt.float(value) : value;
+    };
+    vectorNatives[`${c}#${AS3}::shift`] = (rt) => function () {
+        if (this.$fixed) {
+            throw rt.error("RangeError", 1126);
+        }
+        const a = this.$a;
+        return a.length ? (a instanceof FloatVector ? rt.float(a.shift()) : a.shift()) : empty(this);
+    };
+    vectorNatives[`${c}#${AS3}::unshift`] = (rt) => function (...args) {
+        if (this.$fixed) {
+            throw rt.error("RangeError", 1126);
+        }
+        // Room made first, then each converted and written in its place.
+        const cls = this.$traits.cls;
+        this.$a.unshift(...args.map(() => cls.$fill));
+        for (let k = 0; k < args.length; k++) {
+            writeElement(this, k, cls.$convert(rt, cls, args[k]), store);
+        }
+        return this.$a.length;
+    };
+    vectorNatives[`${c}#${own}::newThisType`] = (rt) => function () {
+        return rt.constructClass(this.$traits.cls, []);
+    };
+    vectorNatives[`${c}#${own}::_reverse`] = plain(function () {
+        this.$a.reverse();
+        return this;
+    });
+    vectorNatives[`${c}#${own}::_spliceHelper`] = (rt) => function (insert, insertCount, deleteCount, args, offset) {
+        // As unshift: room made, then each item converted, as the Vector's
+        // type does, and written in its place.
+        const cls = this.$traits.cls;
+        const at = rt.toUint(insert);
+        const count = rt.toUint(insertCount);
+        const from = rt.toUint(offset);
+        const items = args?.$a ?? [];
+        this.$a.splice(at, rt.toUint(deleteCount), ...new Array(count).fill(cls.$fill));
+        for (let k = 0; k < count; k++) {
+            const value = items instanceof FloatVector
+                ? rt.getProperty(args, rt.publicName(from + k))
+                : items[from + k];
+            writeElement(this, at + k, cls.$convert(rt, cls, value), store);
+        }
+    };
+    vectorNatives[`${c}.${own}::_sort`] = (rt) => (o, args) => sort(rt, o, elements(args));
+    vectorNatives[`${c}.${own}::_every`] = (rt) => (o, f, receiver) => eachElement(rt, o, f, receiver, (result) => (result === true ? undefined : false)) ?? true;
+    vectorNatives[`${c}.${own}::_some`] = (rt) => (o, f, receiver) => eachElement(rt, o, f, receiver, (result) => (result === true ? true : undefined)) ?? false;
+    vectorNatives[`${c}.${own}::_forEach`] = (rt) => (o, f, receiver) => {
+        eachElement(rt, o, f, receiver, () => undefined);
+    };
+    // As TypedVectorObject's _map and _filter: a new Vector of the same type,
+    // a method closure called whatever the receiver.
+    vectorNatives[`${c}#${own}::_map`] = (rt) => function (f, receiver) {
+        const cls = this.$traits.cls;
+        const r = rt.constructClass(cls, [this.$a.length]);
+        let i = 0;
+        eachElement(rt, this, f, receiver, (result) => {
+            const value = cls.$convert(rt, cls, result);
+            if (r.$a instanceof FloatVector) {
+                r.$a.data[i++] = value;
+            }
+            else {
+                store(r.$a, i++, value);
+            }
+        }, true);
+        return r;
+    };
+    vectorNatives[`${c}#${own}::_filter`] = (rt) => function (f, receiver) {
+        const r = rt.constructClass(this.$traits.cls, []);
+        eachElement(rt, this, f, receiver, (result, element) => {
+            if (result === true) {
+                r.$a.push(element);
+            }
+        }, true);
+        return r;
+    };
+}
+for (const [kind, convert, fill, elementsOf, store] of VECTORS) {
+    vectorHooks[`${VEC}::${kind}`] = {
+        create: (traits) => {
+            const o = Object.create(traits.proto);
+            o.$a = elementsOf(0);
+            o.$fixed = false;
+            return o;
+        },
+        // As VectorBaseObject: any name but an index is refused, 1069 or 1056.
+        refusesNames: true,
+        getIndex: (o, i, rt) => {
+            if (i >= o.$a.length) {
+                throw rt.error("RangeError", 1125, i, o.$a.length);
+            }
+            return o.$a[i];
+        },
+        hasIndex: (o, i) => i < o.$a.length,
+        // As VectorBaseObject::getVectorIndex: a name starting with a digit or
+        // "-" that is a number is an index, and must be a whole one from 0 up.
+        index: (o, name, rt) => {
+            const i = arrayIndex(name);
+            if (i >= 0) {
+                return i;
+            }
+            const c = name.charCodeAt(0);
+            if (name.length === 0 || !((c >= 0x30 && c <= 0x39) || c === 0x2d)) {
+                return -1;
+            }
+            const d = rt.toNumber(name);
+            if (Number.isNaN(d)) {
+                return -1;
+            }
+            if ((d | 0) === d && d >= 0) {
+                return d;
+            }
+            throw rt.error("RangeError", 1125, rt.toString(d), o.$a.length);
+        },
+        setIndex: (o, i, v, rt) => rt.setElement(o, i, convert(rt, o.$traits.cls, v), store),
+        construct: (rt, cls, args) => {
+            prepareVector(rt, cls, convert, fill);
+            const o = cls.$it.instance();
+            const length = args.length ? rt.toUint(args[0]) : 0;
+            o.$a = cls.$param === "float" ? new FloatVector(length) : elementsOf(length);
+            o.$fixed = rt.toBoolean(args[1]);
+            return o;
+        },
+        // As VectorClass::call: a Vector of this class is itself; any other
+        // object is read as an array-like, its length and then each index, a
+        // ByteArray's bytes included; a primitive or null cannot convert.
+        call: (rt, cls, args) => {
+            prepareVector(rt, cls, convert, fill);
+            if (args.length !== 1) {
+                throw rt.error("ArgumentError", 1112, args.length);
+            }
+            const source = args[0];
+            if (!isObject(source)) {
+                throw rt.error("TypeError", 1034, rt.describe(source), cls.$it.name);
+            }
+            if (source.$traits === cls.$it) {
+                return source;
+            }
+            // Each element as a get of the source's, as its conversion may change
+            // the source: past a Vector's end, a RangeError.
+            const o = cls.$it.instance();
+            const length = lengthOf(rt, source);
+            const a = cls.$param === "float" ? new FloatVector() : elementsOf(0);
+            for (let i = 0; i < length; i++) {
+                // The storage read here too, where only this loop's sources are
+                // seen, as getElement reads it for every walk's.
+                const elements = source.$a;
+                const value = elements !== undefined && i in elements ? elements[i] : getElement(rt, source, i);
+                a.push(cls.$convert(rt, cls, value));
+            }
+            o.$a = a;
+            return o;
+        },
+    };
+}
+/**
+ * Element i of Vector o written as unshift and splice write what they
+ * insert, into the elements it has after the conversion, grown to it with
+ * the fill value if the conversion shrank them.
+ */
+function writeElement(o, i, x, store) {
+    const a = o.$a;
+    if (a instanceof FloatVector) {
+        if (i >= a.length) {
+            a.length = i + 1;
+        }
+        a.data[i] = x;
+        return;
+    }
+    while (a.length <= i) {
+        a.push(o.$traits.cls.$fill);
+    }
+    store(a, i, x);
+}
+/**
+ * What pop and shift give of an empty Vector, as TypedVectorConstants'
+ * undefinedValue: undefined for objects, else the fill value, 0.
+ */
+const empty = (v) => v.$traits.cls.$fill === null ? undefined : v.$traits.cls.$fill;
+/** A Vector class's element conversion and fill value, kept on the class for its natives. */
+function prepareVector(rt, cls, convert, fill) {
+    if (!cls.$convert) {
+        cls.$convert = convert;
+        cls.$fill = cls.$param === "float" ? rt.float(0) : fill;
+        cls.$rt = rt;
+        if (cls.$param === "float") {
+            cls.$convert = (rt, _cls, value) => rt.toNumber(value);
+            cls.$it.getIndex = (o, i, rt) => {
+                const a = o.$a;
+                if (i >= a.length) {
+                    throw rt.error("RangeError", 1125, i, a.length);
+                }
+                return rt.float(a.data[i]);
+            };
+            cls.$it.setIndex = (o, i, value, rt) => setFloatElement(rt, o, i, rt.toNumber(value));
+            floatSearchMethods(rt, cls);
+        }
+    }
+}
+/** Vector.<T>: the specialized classes for int, uint and Number, else Vector$object's for T; made once each. */
+function vectorOf(rt, param) {
+    const made = rt.vectorClasses.get(param);
+    if (made) {
+        return made;
+    }
+    const cls = makeVector(rt, param);
+    rt.vectorClasses.set(param, cls);
+    return cls;
+}
+function makeVector(rt, param) {
+    const kind = param === null
+        ? "Vector$object"
+        : param.$it.name === "int"
+            ? "Vector$int"
+            : param.$it.name === "uint"
+                ? "Vector$uint"
+                : param.$it.name === "Number"
+                    ? "Vector$double"
+                    : "Vector$object";
+    // The specialized classes are internal to their package.
+    const base = rt.resolve(rt.cls(rt.ns(1, VEC), kind));
+    const [, convert, fill] = VECTORS.find(([k]) => k === kind) ?? VECTORS[3];
+    prepareVector(rt, base, convert, fill);
+    if (kind !== "Vector$object" || param === null) {
+        return base;
+    }
+    let cls = rt.specialized.get(param);
+    if (!cls) {
+        cls = rt.specializeVector(base, param);
+        prepareVector(rt, cls, convert, fill);
+        rt.specialized.set(param, cls);
+        // A class's instances, as coerce checks them, by the traits found once.
+        const ref = cls.$param;
+        if (typeof ref === "object") {
+            const traits = param.$it;
+            cls.$convert = (rt, _cls, v) => {
+                if (v === null || v === undefined) {
+                    return null;
+                }
+                return v.$traits === traits || rt.isInstanceOf(v, traits) ? v : rt.coerce(v, ref);
+            };
+        }
+    }
+    return cls;
+}
+/** Float vectors coerce search values to float; the generic object's AS3 methods do not. */
+function floatSearchMethods(rt, cls) {
+    const proto = rt.objectTraits.instance();
+    proto.$p = cls.$prototype;
+    proto.$d.set("constructor", cls);
+    proto.$dontEnum = new Set(["constructor", "indexOf", "lastIndexOf"]);
+    cls.$prototype = proto;
+    cls.$it.proto.$p = proto;
+    for (const name of ["indexOf", "lastIndexOf"]) {
+        const search = function (value, from = name === "indexOf" ? 0 : 0x7fffffff) {
+            const needle = Math.fround(rt.toNumber(value));
+            const raw = rt.toInt(from);
+            const elements = this.$a;
+            const start = raw < 0 ? Math.max(elements.length + raw, 0) : Math.min(raw, elements.length);
+            if (name === "indexOf") {
+                for (let i = start; i < elements.length; i++) {
+                    if (elements.data[i] === needle) {
+                        return i;
+                    }
+                }
+            }
+            else {
+                for (let i = Math.min(start, elements.length - 1); i >= 0; i--) {
+                    if (elements.data[i] === needle) {
+                        return i;
+                    }
+                }
+            }
+            return -1;
+        };
+        Object.assign(search, { $min: 1, $max: 2, $length: 2 });
+        const binding = cls.$it.find(qname(namespace(NS_Public, AS3), name));
+        cls.$it.proto[methodKey(binding >> 3)] = search;
+        cls.$it.proto[boundKey(binding >> 3)] = search;
+        proto.$d.set(name, rt.newFunctionObject(search, null));
+    }
+}