@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,64 @@
+// The builtins' native methods, in TypeScript, bound by the names the
+// compiler gives them: "Class.name" for a static method, "Class#name" for an
+// instance method, the name alone for a script's function, with "get:" and
+// "set:" for accessors and "uri::name" outside the public namespace. And how
+// the builtin classes differ from others: how their instances hold native
+// state, and what calling or constructing them does.
+import { aliasesNatives } from "./aliases.js";
+import { arrayHooks, arrayNatives } from "./array.js";
+import { byteArrayHook, byteArrayNatives } from "./bytearray.js";
+import { concurrentNatives } from "./concurrent.js";
+import { dateHook, dateNatives } from "./date.js";
+import { describeNatives } from "./describe.js";
+import { dictionaryNatives } from "./dictionary.js";
+import { floatHooks, floatNatives } from "./float.js";
+import { jsonNatives } from "./json.js";
+import { numberHooks, numberNatives } from "./number.js";
+import { objectHooks, objectNatives } from "./object.js";
+import { proxyHooks, proxyNatives } from "./proxy.js";
+import { regexpHooks, regexpNatives } from "./regexp.js";
+import { shellHooks, shellNatives } from "./shell.js";
+import { stringHooks, stringNatives } from "./string.js";
+import { errorHooks, toplevelNatives } from "./toplevel.js";
+import { vectorHooks, vectorNatives } from "./vector.js";
+import { xmlHooks, xmlNatives } from "./xml/xml.js";
+/** The builtins' natives for `rt`: most are the same for every runtime; a class of natives closes over it. */
+export function builtinNatives(rt) {
+    return {
+        ...objectNatives,
+        ...arrayNatives,
+        ...stringNatives,
+        ...regexpNatives(rt),
+        ...numberNatives,
+        ...floatNatives,
+        ...toplevelNatives,
+        ...describeNatives,
+        ...proxyNatives,
+        ...aliasesNatives,
+        ...shellNatives(rt),
+        ...dictionaryNatives,
+        ...vectorNatives,
+        ...byteArrayNatives(rt),
+        ...concurrentNatives(rt),
+        ...dateNatives(),
+        ...jsonNatives(),
+        ...xmlNatives,
+    };
+}
+export function builtinHooks() {
+    return {
+        ...objectHooks,
+        ...numberHooks,
+        ...floatHooks,
+        ...stringHooks,
+        ...arrayHooks,
+        ...regexpHooks,
+        "flash.utils::ByteArray": byteArrayHook,
+        Date: dateHook,
+        ...vectorHooks,
+        ...xmlHooks,
+        ...proxyHooks,
+        ...errorHooks,
+        ...shellHooks,
+    };
+}

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

@@ -0,0 +1,514 @@
+import { FloatValue } from "../float.js";
+import { FloatVector } from "./float-vector.js";
+import { NS_Public, publicQname } from "../names.js";
+/** Whether each traits binds a public toJSON, found once. */
+const boundToJSON = new WeakMap();
+/**
+ * As JSONParser, through the host's JSON.parse, then its values made AS3's
+ * in place. The text the host rejects goes to parse(): avmplus reads some
+ * of it (numbers with leading zeros, as 01), and fails the rest as
+ * SyntaxError 1132.
+ */
+function parseText(rt, text) {
+    let tree;
+    try {
+        tree = JSON.parse(text);
+    }
+    catch {
+        return parse(rt, text);
+    }
+    return fromHost(rt, tree);
+}
+/** How deep fromHost recurses before it continues with a stack of its own. */
+const RECURSION_DEPTH = 500;
+const LITERALS = ["null", "true", "false"];
+/**
+ * A value of the host's JSON.parse as AS3's: an array as an Array holding
+ * it, its elements made AS3's in place, and an object as an Object with its
+ * keys, each where a public name of a plain Object is set (JSON's
+ * `__proto__` is a key of the object's own). Deeper than RECURSION_DEPTH,
+ * as deepFromHost does, as avmplus reads any depth.
+ */
+function fromHost(rt, v, depth = 0) {
+    if (typeof v !== "object" || v === null) {
+        return v;
+    }
+    if (depth > RECURSION_DEPTH) {
+        return deepFromHost(rt, v);
+    }
+    if (Array.isArray(v)) {
+        for (let i = 0; i < v.length; i++) {
+            v[i] = fromHost(rt, v[i], depth + 1);
+        }
+        return rt.array(v);
+    }
+    const o = rt.newObject([]);
+    const d = o.$d;
+    const from = v;
+    for (const key in from) {
+        d.set(key, fromHost(rt, from[key], depth + 1));
+    }
+    return o;
+}
+/** As fromHost, with a stack of its own, not the host's: slower, and at any depth. */
+function deepFromHost(rt, root) {
+    const pending = [];
+    const wrap = (v) => {
+        if (typeof v !== "object" || v === null) {
+            return v;
+        }
+        const o = Array.isArray(v) ? rt.array(v) : rt.newObject([]);
+        pending.push([v, o]);
+        return o;
+    };
+    const result = wrap(root);
+    for (let next = pending.pop(); next; next = pending.pop()) {
+        const [host, o] = next;
+        if (Array.isArray(host)) {
+            for (let i = 0; i < host.length; i++) {
+                host[i] = wrap(host[i]);
+            }
+        }
+        else {
+            const d = o.$d;
+            const from = host;
+            for (const key in from) {
+                d.set(key, wrap(from[key]));
+            }
+        }
+    }
+    return result;
+}
+/** As JSONParser: the JSON text to a value, or SyntaxError 1132. */
+function parse(rt, text) {
+    let i = 0;
+    let token = "";
+    // The current token, read through a function: advance() changes it.
+    const current = () => token;
+    let value;
+    const fail = () => {
+        throw rt.error("SyntaxError", 1132);
+    };
+    const digits = () => {
+        const start = i;
+        while (i < text.length && text.charCodeAt(i) >= 48 && text.charCodeAt(i) <= 57) {
+            i++;
+        }
+        if (i <= start) {
+            fail();
+        }
+    };
+    const advance = () => {
+        token = "";
+        while (i < text.length) {
+            const c = text[i];
+            switch (c) {
+                case "\t":
+                case "\n":
+                case "\r":
+                case " ":
+                    i++;
+                    continue;
+                case ",":
+                case ":":
+                case "{":
+                case "}":
+                case "[":
+                case "]":
+                    i++;
+                    token = c;
+                    return;
+                case '"': {
+                    i++;
+                    let s = "";
+                    let start = i;
+                    while (i < text.length) {
+                        const code = text.charCodeAt(i);
+                        if (code < 32) {
+                            fail();
+                        }
+                        if (code === 34) {
+                            break;
+                        }
+                        if (code === 92) {
+                            s += text.slice(start, i);
+                            i++;
+                            if (i === text.length) {
+                                fail();
+                            }
+                            const e = text[i];
+                            const simple = {
+                                '"': '"',
+                                "/": "/",
+                                "\\": "\\",
+                                b: "\b",
+                                f: "\f",
+                                n: "\n",
+                                r: "\r",
+                                t: "\t",
+                            };
+                            if (e in simple) {
+                                s += simple[e];
+                            }
+                            else if (e === "u") {
+                                const hex = text.slice(i + 1, i + 5);
+                                if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+                                    fail();
+                                }
+                                s += String.fromCharCode(Number.parseInt(hex, 16));
+                                i += 4;
+                            }
+                            else {
+                                fail();
+                            }
+                            i++;
+                            start = i;
+                        }
+                        else {
+                            i++;
+                        }
+                    }
+                    if (i === text.length) {
+                        fail();
+                    }
+                    value = s + text.slice(start, i);
+                    i++;
+                    token = '"';
+                    return;
+                }
+                case "-":
+                case ".":
+                case "0":
+                case "1":
+                case "2":
+                case "3":
+                case "4":
+                case "5":
+                case "6":
+                case "7":
+                case "8":
+                case "9": {
+                    const start = i;
+                    if (text[i] === "-") {
+                        i++;
+                    }
+                    digits();
+                    if (text[i] === ".") {
+                        i++;
+                        digits();
+                    }
+                    if (text[i] === "e" || text[i] === "E") {
+                        i++;
+                        if (text[i] === "-" || text[i] === "+") {
+                            i++;
+                        }
+                        digits();
+                    }
+                    value = text.slice(start, i);
+                    token = "0";
+                    return;
+                }
+                default:
+                    for (const word of LITERALS) {
+                        if (text.startsWith(word, i)) {
+                            i += word.length;
+                            token = word[0];
+                            return;
+                        }
+                    }
+                    fail();
+            }
+        }
+    };
+    const parseValue = () => {
+        switch (current()) {
+            case "n":
+                advance();
+                return null;
+            case "t":
+                advance();
+                return true;
+            case "f":
+                advance();
+                return false;
+            case '"': {
+                const s = value;
+                advance();
+                return s;
+            }
+            case "0": {
+                const n = Number(value);
+                advance();
+                return n;
+            }
+            case "[": {
+                advance();
+                const a = [];
+                if (current() !== "]") {
+                    for (;;) {
+                        a.push(parseValue());
+                        if (current() !== ",") {
+                            break;
+                        }
+                        advance();
+                    }
+                }
+                if (current() !== "]") {
+                    fail();
+                }
+                advance();
+                return rt.array(a);
+            }
+            case "{": {
+                advance();
+                const o = rt.newObject([]);
+                if (current() !== "}") {
+                    for (;;) {
+                        if (current() !== '"') {
+                            fail();
+                        }
+                        const name = parseValue();
+                        if (current() !== ":") {
+                            fail();
+                        }
+                        advance();
+                        rt.setProperty(o, publicQname(name, rt.userVersions), parseValue());
+                        if (current() !== ",") {
+                            break;
+                        }
+                        advance();
+                    }
+                }
+                if (current() !== "}") {
+                    fail();
+                }
+                advance();
+                return o;
+            }
+            default:
+                return fail();
+        }
+    };
+    advance();
+    const result = parseValue();
+    if (current() !== "") {
+        fail();
+    }
+    return result;
+}
+/** A class instance's public variables and readable accessors but [Transient] ones, the class's own first, as TypeDescriber lists them. */
+function describedNames(traits, apiVersion) {
+    const variables = [];
+    const accessors = [];
+    for (let t = traits; t && t.name !== "Object"; t = t.base) {
+        for (const [name, list] of t.bindings) {
+            for (const b of list) {
+                // A member of a later version, AIR-only or VM-internal, is not the code's to see.
+                if (b.ns.kind !== NS_Public ||
+                    b.ns.uri !== "" ||
+                    b.version > apiVersion ||
+                    traits.isTransient(b.value)) {
+                    continue;
+                }
+                const kind = b.value & 7;
+                if (kind === 2 || kind === 3) {
+                    variables.push(name);
+                }
+                else if (kind === 5 || kind === 7) {
+                    accessors.push(name);
+                }
+            }
+        }
+    }
+    return [variables, accessors];
+}
+/**
+ * As JSONSerializer, in two steps, as Ruffle's does: the walk over the AS3
+ * values, calling toJSON and the replacer in avmplus' order and failing a
+ * cycle as it does, builds a tree of the host's values, which the host's
+ * JSON.stringify writes, gap and all. The text need not be avmplus' own:
+ * key order, escapes and numbers' digits differ, and it reads back as the
+ * same keys and values.
+ */
+class Serializer {
+    rt;
+    propertyList;
+    replacer;
+    gap;
+    active = new Set();
+    constructor(rt, propertyList, replacer, gap) {
+        this.rt = rt;
+        this.propertyList = propertyList;
+        this.replacer = replacer;
+        this.gap = gap;
+    }
+    stringify(v) {
+        const wrapper = this.rt.newObject([]);
+        wrapper.$d.set("", v);
+        const tree = this.str("", v, wrapper);
+        return tree === undefined ? undefined : JSON.stringify(tree, null, this.gap);
+    }
+    /**
+     * As StrFoundValue: the value to write for `valueIn`, the host's, or
+     * undefined for none. A number the host writes as null if it is not
+     * finite, as avmplus does.
+     */
+    str(key, valueIn, holder) {
+        const rt = this.rt;
+        let value = valueIn;
+        if (value !== null && value !== undefined) {
+            const probe = this.toJSONOf(value);
+            if (probe?.$f) {
+                value = rt.callValue(probe, value, [key], null);
+            }
+        }
+        if (this.replacer) {
+            value = rt.callValue(this.replacer, holder, [key, value], null);
+        }
+        if (value instanceof FloatValue) {
+            return value.value;
+        }
+        switch (typeof value) {
+            case "boolean":
+            case "string":
+            case "number":
+                return value;
+            case "object":
+                break;
+            default:
+                return undefined;
+        }
+        if (value === null) {
+            return null;
+        }
+        if (value.$f) {
+            return undefined;
+        }
+        const traits = rt.traitsOf(value);
+        if (isA(traits, "Array") || isVector(traits)) {
+            return this.array(value);
+        }
+        return this.object(value, traits);
+    }
+    /**
+     * As the probe of StrFoundValue: `value`'s toJSON, or null. A public
+     * binding first; else, as hasProperty finds a public name that is not an
+     * index, the object's own dynamic one and then its prototype chain's.
+     *
+     * avmplus probes the AS3 namespace before the public one, with the
+     * builtin's own AS3 namespace, which sees AS3 bindings only at the
+     * builtin's API version: no class of avmshell's binds an AS3 toJSON
+     * (theirs are its prototypes'), and a script's AS3 toJSON is never
+     * found, even when it has no public one. So only the public one is.
+     */
+    toJSONOf(value) {
+        const rt = this.rt;
+        const traits = rt.traitsOf(value);
+        let bound = boundToJSON.get(traits);
+        if (bound === undefined) {
+            bound = traits.find(rt.toJSONName) !== 0;
+            boundToJSON.set(traits, bound);
+        }
+        if (bound) {
+            return rt.getProperty(value, rt.toJSONName);
+        }
+        const own = typeof value === "object" ? value.$d : undefined;
+        if (own?.has("toJSON")) {
+            return own.get("toJSON");
+        }
+        for (let p = rt.protoOf(value); p; p = p.$p) {
+            if (p.$d?.has("toJSON")) {
+                return p.$d.get("toJSON");
+            }
+        }
+        return null;
+    }
+    enter(value) {
+        if (this.active.has(value)) {
+            throw this.rt.error("TypeError", 1129);
+        }
+        this.active.add(value);
+    }
+    /** As JO: the property list, or the described properties and then the dynamic ones. */
+    object(value, traits) {
+        const rt = this.rt;
+        this.enter(value);
+        const out = {};
+        const own = value.$d;
+        const prop = (name) => {
+            // A dynamic property of its own is where getProperty would find it.
+            const v = own?.has(name)
+                ? own.get(name)
+                : rt.getProperty(value, publicQname(name, rt.userVersions));
+            const written = this.str(name, v, value);
+            if (written === undefined) {
+                return;
+            }
+            if (name === "__proto__") {
+                // Assigned, it would set the prototype, not the key.
+                Object.defineProperty(out, name, { value: written, enumerable: true, writable: true });
+            }
+            else {
+                out[name] = written;
+            }
+        };
+        if (this.propertyList) {
+            for (const name of this.propertyList) {
+                prop(name);
+            }
+        }
+        else {
+            const [variables, accessors] = describedNames(traits, rt.apiVersion);
+            for (const name of [...variables, ...accessors]) {
+                prop(name);
+            }
+            for (const name of rt.enumerableNames(value)) {
+                prop(name);
+            }
+        }
+        this.active.delete(value);
+        return out;
+    }
+    /** As JAfinish: each element, null for one that writes nothing. */
+    array(value) {
+        this.enter(value);
+        const length = value.$a.length;
+        const out = new Array(length);
+        for (let i = 0; i < length; i++) {
+            // The elements as they are now: toJSON or the replacer may have
+            // changed them, or the Vector its storage. A hole, or an element
+            // since removed, is got as getUintProperty gets it: from the
+            // prototype chain, or a Vector's RangeError.
+            const elements = value.$a;
+            const element = !(elements instanceof FloatVector) && i in elements
+                ? elements[i]
+                : this.rt.getProperty(value, this.rt.publicName(i));
+            const written = this.str(String(i), element, value);
+            out[i] = written === undefined ? null : written;
+        }
+        this.active.delete(value);
+        return out;
+    }
+}
+function isVector(traits) {
+    for (let t = traits; t; t = t.base) {
+        if (t.name.startsWith("__AS3__.vec::Vector$")) {
+            return true;
+        }
+    }
+    return false;
+}
+function isA(traits, name) {
+    for (let t = traits; t; t = t.base) {
+        if (t.name === name) {
+            return true;
+        }
+    }
+    return false;
+}
+export function jsonNatives() {
+    return {
+        "JSON.JSON::parseCore": (rt) => (text) => parseText(rt, rt.toString(text)),
+        "JSON.JSON::stringifySpecializedToString": (rt) => (value, propertyList, replacer, gap) => new Serializer(rt, propertyList?.$a ? propertyList.$a.map((n) => rt.toString(n)) : null, replacer?.$f ? replacer : null, gap === null || gap === undefined ? "" : rt.toString(gap)).stringify(value),
+    };
+}