@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,162 @@
+// Number, int, uint and Boolean, and Math, whose functions Number has
+// copies of.
+import { numberToString } from "../number-strings.js";
+import { convertDoubleToString, convertDoubleToStringRadix, DTOSTR_EXPONENTIAL, DTOSTR_FIXED, DTOSTR_PRECISION, } from "../numbers.js";
+import { conversion, plain } from "./define.js";
+export const numberNatives = {
+    // As NumberClass::_numberToString: another radix writes the integer part only.
+    "Number.Number::_numberToString": (rt) => (n, radix) => {
+        if (radix === 10 || !Number.isFinite(n)) {
+            return numberToString(n);
+        }
+        if (radix < 2 || radix > 36) {
+            throw rt.error("RangeError", 1003, radix);
+        }
+        return convertDoubleToStringRadix(n, radix);
+    },
+    // As NumberClass::_convert: toFixed, toPrecision and toExponential.
+    "Number.Number::_convert": (rt) => (n, precision, mode) => {
+        const [min, max] = mode === DTOSTR_PRECISION ? [1, 21] : [0, 20];
+        if (precision < min || precision > max) {
+            throw rt.error("RangeError", 1002, precision, min, max);
+        }
+        switch (mode) {
+            case DTOSTR_FIXED:
+                return numberToFixed(n, precision);
+            case DTOSTR_PRECISION:
+                return numberToPrecision(n, precision);
+            default:
+                return numberToExponential(n, precision);
+        }
+    },
+    "Number.Number::_minValue": plain(() => Number.MIN_VALUE),
+};
+// toFixed, toPrecision and toExponential write avmplus' text, which is not
+// JavaScript's, though JavaScript's methods give it for most numbers at a
+// fraction of the cost. avmplus takes the digits D of a number x from its
+// D2A, the shortest within half an ulp of x narrowed by 10^precision, in
+// exact arithmetic. Scaled so that the last place written is 1, x is some y
+// and D is within y * 2^-53 of it. toFixed and toPrecision then round D
+// half up there, as JavaScript rounds x itself; toExponential truncates D,
+// since avmplus rounds only on D2A's fast path, which no 53-bit mantissa
+// takes. So where y is clear of the point where the rounding (or the
+// truncation) changes, both write the same digits. The guards scale x by
+// a power of ten up to 1e22, which doubles hold exactly, so f is within
+// y * 2^-53 of y, and take JavaScript's text only where f is more than
+// f * 2^-50 from those points. Elsewhere avmplus goes its own way: toFixed
+// writes zeros, unrounded, for a number below its last place (0.006 to
+// "0.00"); toPrecision never writes an exponent below 1, and keeps the
+// exponent it had before rounding carried ("10.0" for 9.99 to 2 digits,
+// "0.e+5" for 99999.9); toExponential leaves out "e+0", and writes 0 as
+// "0.00e-16". tests/unit/runtime/numbers.test.ts checks every precision.
+const powersOfTen = Array.from({ length: 23 }, (_, i) => Number(`1e${i}`));
+/** x * 10^k, rounded once, for k from -22 to 22. */
+function scaled(x, k) {
+    return k >= 0 ? x * powersOfTen[k] : x / powersOfTen[-k];
+}
+/** As Number.toFixed. */
+export function numberToFixed(n, digits) {
+    // NaN, infinities and f past 2^49, where the tolerance reaches 0.5, fail every test.
+    const f = (n < 0 ? -n : n) * powersOfTen[digits];
+    const tolerance = f / 2 ** 50;
+    const half = f - Math.floor(f) - 0.5;
+    if ((half > tolerance || half < -tolerance) && (f < 0.5 || f > 1 + tolerance)) {
+        return n.toFixed(digits);
+    }
+    return convertDoubleToString(n, DTOSTR_FIXED, digits);
+}
+/** As Number.toPrecision. */
+export function numberToPrecision(n, digits) {
+    // log10 may be one off next to a power of ten: the bounds on f catch that.
+    const x = n < 0 ? -n : n;
+    const exponent = Math.floor(Math.log10(x));
+    const k = digits - 1 - exponent;
+    if (exponent >= -6 && k >= -22 && k <= 22) {
+        const f = scaled(x, k);
+        const tolerance = f / 2 ** 50;
+        const half = f - Math.floor(f) - 0.5;
+        const clear = half > tolerance || half < -tolerance;
+        if (clear && f >= powersOfTen[digits - 1] + tolerance && f < powersOfTen[digits] - 0.5) {
+            return n.toPrecision(digits);
+        }
+    }
+    return convertDoubleToString(n, DTOSTR_PRECISION, digits);
+}
+/**
+ * As Number.toExponential: JavaScript's digits to one place more, the last
+ * dropped, which truncates as avmplus does where rounding that place does
+ * not carry.
+ */
+export function numberToExponential(n, digits) {
+    const x = n < 0 ? -n : n;
+    const exponent = Math.floor(Math.log10(x));
+    const k = digits - exponent;
+    if (k >= -22 && k <= 22) {
+        const f = scaled(x, k);
+        const fraction = f - Math.floor(f);
+        const inRange = f >= powersOfTen[digits] && f < powersOfTen[digits + 1];
+        if (fraction > f / 2 ** 50 && fraction < 0.9 && inRange) {
+            const text = x.toExponential(digits + 1);
+            const e = text.indexOf("e");
+            const mantissa = text.slice(0, digits === 0 ? 1 : e - 1);
+            const written = exponent === 0 ? mantissa : mantissa + text.slice(e);
+            return n < 0 ? `-${written}` : written;
+        }
+    }
+    return convertDoubleToString(n, DTOSTR_EXPONENTIAL, digits);
+}
+// Math, and Number's copies of it.
+for (const name of [
+    "abs",
+    "acos",
+    "asin",
+    "atan",
+    "ceil",
+    "cos",
+    "exp",
+    "floor",
+    "log",
+    "sin",
+    "sqrt",
+    "tan",
+]) {
+    const f = Math[name];
+    const native = (rt) => (x) => f(rt.toNumber(x));
+    numberNatives[`Math.${name}`] = native;
+    numberNatives[`Number.${name}`] = native;
+}
+for (const prefix of ["Math", "Number"]) {
+    // As MathUtils::round, floor(x + 0.5): never -0, as JavaScript's is for -0.5 to -0.
+    numberNatives[`${prefix}.round`] = (rt) => (x) => {
+        const r = Math.round(rt.toNumber(x));
+        return r === 0 ? 0 : r;
+    };
+    numberNatives[`${prefix}.atan2`] = (rt) => (y, x) => Math.atan2(rt.toNumber(y), rt.toNumber(x));
+    numberNatives[`${prefix}.pow`] = (rt) => (x, y) => rt.toNumber(x) ** rt.toNumber(y);
+    numberNatives[`${prefix}.random`] = plain(() => Math.random());
+    // Of two declared parameters, and any more, so that their length is 2.
+    numberNatives[`${prefix}.max`] = (rt) => function (x, y) {
+        // biome-ignore lint/complexity/noArguments: all of them, however many
+        const args = arguments;
+        if (args.length === 2) {
+            return Math.max(rt.toNumber(x), rt.toNumber(y));
+        }
+        return Math.max(...Array.from(args, (a) => rt.toNumber(a)));
+    };
+    numberNatives[`${prefix}.min`] = (rt) => function (x, y) {
+        // biome-ignore lint/complexity/noArguments: all of them, however many
+        const args = arguments;
+        if (args.length === 2) {
+            return Math.min(rt.toNumber(x), rt.toNumber(y));
+        }
+        return Math.min(...Array.from(args, (a) => rt.toNumber(a)));
+    };
+}
+numberNatives["Math.Math::_max"] = plain((x, y) => Math.max(x, y));
+numberNatives["Math.Math::_min"] = plain((x, y) => Math.min(x, y));
+export const numberHooks = {
+    int: conversion((rt, args) => (args.length ? rt.toInt(args[0]) : 0)),
+    uint: conversion((rt, args) => (args.length ? rt.toUint(args[0]) : 0)),
+    Number: conversion((rt, args) => (args.length ? rt.toNumber(args[0]) : 0)),
+    Boolean: conversion((rt, args) => rt.toBoolean(args[0])),
+};

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

@@ -0,0 +1,237 @@
+// Object, Class, Function, Namespace and QName: their natives, and what
+// calling or constructing Object, Namespace, QName or Function does.
+import { formatClassName, Namespace, prefixOf, publicQname } from "../names.js";
+import { NOT_FOUND } from "../runtime.js";
+import { AS3, elements, plain } from "./define.js";
+import { constructNamespace, newNamespace } from "./xml/names.js";
+export const objectNatives = {
+    // Object
+    "Object.Object::_hasOwnProperty": (rt) => (o, v) => {
+        const name = rt.toString(v);
+        const traits = rt.traitsOf(o);
+        if (traits.find(publicQname(name, rt.userVersions)) !== 0) {
+            return true;
+        }
+        // An index of a class with its own elements, a Vector's: in range or not, no RangeError.
+        if (traits.hasIndex && /^(?:0|[1-9]\d*)$/.test(name) && Number(name) < 0xffffffff) {
+            return traits.hasIndex(o, Number(name));
+        }
+        return rt.getOwn(o, name) !== NOT_FOUND;
+    },
+    "Object.Object::_propertyIsEnumerable": (rt) => (o, v) => {
+        const name = rt.toString(v);
+        // E4X 13.2.5: a Namespace's prefix and uri are enumerable.
+        if (o instanceof Namespace) {
+            return name === "uri" || name === "prefix";
+        }
+        // A Vector's elements are not enumerable to it, in or out of range, as avmplus has it.
+        if (o?.$traits?.refusesNames) {
+            return false;
+        }
+        return rt.getOwn(o, name) !== NOT_FOUND && !o.$dontEnum?.has(name);
+    },
+    "Object.Object::_setPropertyIsEnumerable": (rt) => (o, v, enumerable) => {
+        if (typeof o !== "object" || o === null) {
+            return;
+        }
+        const name = rt.toString(v);
+        if (enumerable) {
+            o.$dontEnum?.delete(name);
+            if (o.$d) {
+                // A name shown: the for-ins that found them all hidden look again.
+                o.$d.allHidden = false;
+            }
+        }
+        else {
+            o.$dontEnum ??= new Set();
+            o.$dontEnum.add(name);
+        }
+    },
+    // A primitive's prototype chain is its class's, as toPrototype gives it.
+    "Object.Object::_isPrototypeOf": (rt) => (o, v) => {
+        if (v === null || v === undefined) {
+            return false;
+        }
+        for (let p = rt.protoOf(v); p; p = p.$p) {
+            if (p === o) {
+                return true;
+            }
+        }
+        return false;
+    },
+    "Object.Object::_toString": (rt) => (o) => {
+        if (o !== null && typeof o === "object" && o.$it) {
+            return `[class ${shortName(o.$it.name)}]`;
+        }
+        // As FunctionObject::implToString: its method's id.
+        if (o !== null && typeof o === "object" && o.$f) {
+            return `[object Function-${o.$id}]`;
+        }
+        const traits = rt.traitsOf(o);
+        traits.objectString ??= `[object ${shortName(traits.name)}]`;
+        return traits.objectString;
+    },
+    // Class and Function
+    "Class#get:prototype": plain(function () {
+        return this.$prototype;
+    }),
+    "Function#get:prototype": (rt) => function () {
+        return rt.functionPrototype(this);
+    },
+    // As FunctionObject's setter: null and undefined clear it, a primitive is refused.
+    "Function#set:prototype": (rt) => function (p) {
+        if (p === null || p === undefined) {
+            this.$prototype = undefined;
+            this.$noPrototype = true;
+            return;
+        }
+        if (typeof p !== "object" && typeof p !== "function") {
+            throw rt.error("TypeError", 1049);
+        }
+        this.$prototype = p;
+        this.$noPrototype = false;
+    },
+    "Function#get:length": plain(function () {
+        return this.$length ?? this.$f.length;
+    }),
+    [`Function#${AS3}::call`]: (rt) => function (receiver, ...args) {
+        // Not a tail call, as the runtime's calls are not (see Runtime.getProperty).
+        // biome-ignore lint/style/useConst: a const is folded into a tail call (see Runtime.getProperty)
+        let r;
+        r = rt.callValue(this, receiver, args, null);
+        return r;
+    },
+    [`Function#${AS3}::apply`]: (rt) => function (receiver, args) {
+        // Its arguments an Array, or none, as FunctionObject::AS3_apply has them.
+        if (args !== null && args !== undefined && args.$a === undefined) {
+            throw rt.error("TypeError", 1116);
+        }
+        // biome-ignore lint/style/useConst: a const is folded into a tail call (see Runtime.getProperty)
+        let r;
+        r = rt.callValue(this, receiver, elements(args).slice(), null);
+        return r;
+    },
+    // Namespace and QName: a QName holds its namespace, null for any, and its
+    // local name, null for any.
+    "Namespace#get:uri": plain(function () {
+        return this.uri ?? "";
+    }),
+    "QName#get:localName": plain(function () {
+        return this.$local ?? "*";
+    }),
+    "QName#get:uri": plain(function () {
+        return this.$ns ? this.$ns.uri : null;
+    }),
+    "Namespace#get:prefix": plain(function () {
+        return prefixOf(this);
+    }),
+};
+/** As QNameClass::construct: QName(name) or QName(namespace, name). */
+function newQName(rt, cls, args) {
+    if (args.length === 1 && args[0]?.$local !== undefined) {
+        return args[0];
+    }
+    const name = args.length >= 2 ? args[1] : args[0];
+    const o = cls.$it.instance();
+    // With no namespace, a name is in the default XML namespace.
+    let ns = rt.defaultXmlNamespace.interned;
+    if (args.length >= 2 && args[0] !== undefined) {
+        ns =
+            args[0] === null
+                ? null
+                : args[0] instanceof Namespace
+                    ? args[0].interned
+                    : newNamespace(rt, args[0]);
+    }
+    else if (name?.$local !== undefined) {
+        ns = name.$ns;
+    }
+    const local = name === undefined ? "" : name?.$local !== undefined ? name.$local : rt.toString(name);
+    // With no namespace given, the any name is in any namespace too.
+    if (local === "*" && (args.length < 2 || args[0] === undefined)) {
+        ns = null;
+    }
+    o.$ns = ns;
+    o.$local = local === "*" ? null : local;
+    o.$attr = false;
+    return o;
+}
+/** A class's name without its package, as its toString has it: a Vector's parameter keeps its own, "Vector.<pkg::T>". */
+function shortName(qualified) {
+    const name = formatClassName(qualified);
+    const i = name.indexOf("::");
+    return i < 0 ? name : name.slice(i + 2);
+}
+export function qualifiedClassName(rt, v) {
+    switch (typeof v) {
+        // As TypeDescriber::chooseTraits: an int is one that fits avmplus' 29-bit int atom.
+        case "number":
+            return (v | 0) === v && v >= -(1 << 28) && v < 1 << 28 ? "int" : "Number";
+        case "string":
+            return "String";
+        case "boolean":
+            return "Boolean";
+        case "undefined":
+            return "void";
+        default:
+            if (v === null) {
+                return "null";
+            }
+            return formatClassName(v.$it ? v.$it.name : rt.traitsOf(v).name);
+    }
+}
+function emptyFunction(rt, args) {
+    if (args.length) {
+        throw rt.error("EvalError", 1066);
+    }
+    return rt.newFunctionObject(() => undefined, null);
+}
+/** A class of static natives only, which cannot be instantiated: construct="none" in its declaration. */
+const notInstantiated = (name) => ({
+    construct: (rt) => {
+        throw rt.error("ArgumentError", 2012, name);
+    },
+});
+export const objectHooks = {
+    JSON: notInstantiated("JSON"),
+    "flash.net::ObjectEncoding": notInstantiated("ObjectEncoding"),
+    "avmplus::System": notInstantiated("System"),
+    "avmplus::File": notInstantiated("File"),
+    // Math is neither a function nor a constructor.
+    Math: {
+        call: (rt) => {
+            throw rt.error("TypeError", 1075);
+        },
+        construct: (rt) => {
+            throw rt.error("TypeError", 1076);
+        },
+    },
+    Object: {
+        call: (rt, _cls, args) => args[0] === null || args[0] === undefined ? rt.newObject([]) : args[0],
+        construct: (rt, _cls, args) => args[0] === null || args[0] === undefined ? rt.newObject([]) : args[0],
+    },
+    // As ClassClass::construct: Class itself makes no classes.
+    Class: {
+        construct: (rt) => {
+            throw rt.error("TypeError", 1115, "Class");
+        },
+    },
+    // As NamespaceClass: Namespace(),Namespace(uri) or Namespace(prefix, uri).
+    Namespace: {
+        construct: (rt, _cls, args) => constructNamespace(rt, args),
+        call: (rt, _cls, args) => args.length === 1 && args[0] instanceof Namespace ? args[0] : constructNamespace(rt, args),
+    },
+    // As QNameClass::construct.
+    QName: {
+        construct: newQName,
+        call: newQName,
+    },
+    // Function() and new Function(): an empty function; with a body, which
+    // would be compiled at run time, EvalError 1066, as FunctionClass has it.
+    Function: {
+        construct: (rt, _cls, args) => emptyFunction(rt, args),
+        call: (rt, _cls, args) => emptyFunction(rt, args),
+        // Function.prototype is a function, that does nothing.
+        prototype: (rt) => rt.newFunctionObject(() => undefined, null),
+    },
+};

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

@@ -0,0 +1,75 @@
+// flash.utils.Proxy: an instance's names its traits do not bind go to its
+// flash_proxy methods, as avmplus' ProxyObject (core/ProxyGlue.cpp) sends
+// them: a name the code wrote, a multiname, as a QName object; a name made
+// at run time, as proxy[name], as the value it was, a string or a QName.
+// callProperty gets the QName and the arguments; for-in asks
+// nextNameIndex, nextName and nextValue.
+import { NS_Public, namespace, publicNs, publicQname, qname } from "../names.js";
+const FLASH_PROXY = namespace(NS_Public, "http://www.adobe.com/2006/actionscript/flash/proxy");
+/**
+ * The name a flash_proxy method gets for `mn`: a QName that was the name
+ * stays one, an index comes as its string, as avmplus' getUintProperty
+ * interns it, and any other name as a QName in its namespace.
+ */
+function nameFor(rt, mn) {
+    if (mn.key !== undefined && mn.key?.$local !== undefined) {
+        return mn.key;
+    }
+    const name = mn.name;
+    if (name !== null && !mn.attribute && isIndex(name)) {
+        return name;
+    }
+    // A QName keeps the whole multiname in avmplus; of a set of several it
+    // reports the empty URI, and still names all of them as a lookup's name.
+    const ns = mn.namespaces.length > 1 ? publicNs : mn.namespaces.length ? mn.namespaces[0] : null;
+    const q = rt.builtinClass("QName").$it.instance();
+    q.$ns = ns;
+    q.$local = name;
+    q.$attr = mn.attribute;
+    if (mn.namespaces.length > 1) {
+        q.$mn = mn;
+    }
+    return q;
+}
+function isIndex(name) {
+    return /^(?:0|[1-9]\d*)$/.test(name) && Number(name) < 0xffffffff;
+}
+function call(rt, o, method, ...args) {
+    // Not a tail call, as the runtime's calls are not (see Runtime.getProperty).
+    // biome-ignore lint/style/useConst: a const is folded into a tail call (see Runtime.getProperty)
+    let r;
+    r = rt.callProperty(o, qname(FLASH_PROXY, method), ...args);
+    return r;
+}
+const proxyHook = {
+    // A method the traits bind is the method, as for any object; only unbound names reach the proxy.
+    hidesMethods: false,
+    get: (rt, o, mn) => call(rt, o, "getProperty", nameFor(rt, mn)),
+    set: (rt, o, mn, v) => {
+        call(rt, o, "setProperty", nameFor(rt, mn), v);
+    },
+    // The flash_proxy methods declare Boolean results, coerced on their way out.
+    delete: (rt, o, mn) => call(rt, o, "deleteProperty", nameFor(rt, mn)) === true,
+    // `in` asks with the name's string, as hasAtomProperty gets it.
+    has: (rt, o, mn) => call(rt, o, "hasProperty", mn.key !== undefined ? mn.key : mn.name) === true,
+    callee: (rt, o, mn) => {
+        const name = nameFor(rt, mn);
+        return rt.newFunctionObject((...args) => call(rt, o, "callProperty", name, ...args), null);
+    },
+    descendants: (rt, o, mn) => call(rt, o, "getDescendants", nameFor(rt, mn)),
+    nextIndex: (rt, o, index) => rt.toInt(call(rt, o, "nextNameIndex", index)),
+    nextName: (rt, o, index) => call(rt, o, "nextName", index),
+    nextValue: (rt, o, index) => call(rt, o, "nextValue", index),
+    equals: () => undefined,
+    add: () => undefined,
+    // toString is a call like any other the traits do not bind: callProperty answers it.
+    toString: (rt, o) => rt.toString(call(rt, o, "callProperty", nameFor(rt, publicQname("toString", rt.userVersions)))),
+    toXMLString: (rt, o) => rt.toString(call(rt, o, "callProperty", nameFor(rt, publicQname("toString", rt.userVersions)))),
+};
+export const proxyHooks = {
+    "flash.utils::Proxy": { properties: proxyHook },
+};
+export const proxyNatives = {
+    // As ProxyObject::flash_proxy_isAttribute: whether the name is a QName of an attribute.
+    "flash.utils::Proxy#http://www.adobe.com/2006/actionscript/flash/proxy::isAttribute": () => (name) => name !== null && typeof name === "object" && name.$local !== undefined && name.$attr === true,
+};