@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/runtime/avm1/realm.js

@@ -0,0 +1,529 @@
+import { TimedOut } from "./errors.js";
+import { pendingLocal, ScriptFunction } from "./functions.js";
+import { arrayClass } from "./globals/array.js";
+import { broadcasterClass } from "./globals/broadcaster.js";
+import { DateCell, dateClass } from "./globals/date.js";
+import { asnative, globalFunctions } from "./globals/global.js";
+import { mathNative, mathObject } from "./globals/math.js";
+import { booleanClass, numberClass } from "./globals/number.js";
+import { stringClass } from "./globals/string.js";
+import { Timers } from "./globals/timers.js";
+import { Avm1Function, Avm1Object, arraySet, caseSensitive, DONT_DELETE, DONT_ENUM, elementIndex, fold, get, invoke, lengthOf, nameOf, Property, READ_ONLY, set, VERSION_6, } from "./objects.js";
+import { SCOPE_Global, Scope } from "./scope.js";
+import { isPrimitive, objects, stringOf, toNumber } from "./values.js";
+/** The arguments' first, undefined where there is none. */
+const first = (args) => (args.length > 0 ? args[0] : undefined);
+/** A value as ASSetPropFlags takes its bits: an int's low 16, as adl wraps them. */
+const u16 = (value, version) => (toNumber(value, version) | 0) & 0xffff;
+/** Jumps back and calls between two readings of the clock for the script timeout. */
+export const BUDGET = 100_000;
+export class Realm {
+    /** `_global`: no prototype, as Flash's has none. */
+    global = new Avm1Object();
+    objectProto = new Avm1Object();
+    functionProto = new Avm1Object();
+    Object;
+    Function;
+    String;
+    Number;
+    Boolean;
+    Array;
+    Error;
+    AsBroadcaster;
+    Date;
+    Math;
+    /**
+     * ASnative's tables: by category, the native at an index, null for none
+     * (an index past its natives is undefined's, but Math's, NaN's).
+     */
+    natives = new Map();
+    /** The bottom of every scope chain. */
+    globalScope;
+    /** The four registers outside DefineFunction2's own, which every activation shares. */
+    registers = [undefined, undefined, undefined, undefined];
+    /** By the regions of a block or a unit, the units of its SWF, which V.far runs. */
+    units = new WeakMap();
+    /** The activation running, null between the player's calls into AVM1 code. */
+    current = null;
+    /** How many function calls are running, one in another. */
+    calls = 0;
+    /**
+     * How deep function calls may go, the call that reaches it disabling the
+     * movie's actions: a SWF's ScriptLimits sets it, adl's is 1000.
+     */
+    maxCalls = 1000;
+    /**
+     * How many clips the player has removed: code whose own clip may be one
+     * of them checks it only after a call, where this moved on.
+     */
+    removals = 0;
+    /** setInterval's and setTimeout's timers, which the player fires by its clock. */
+    timers = new Timers();
+    /**
+     * When the scripts running must have stopped by, on `clock`, the script
+     * timeout's ms after the player started them; Infinity while none run.
+     */
+    deadline = Number.POSITIVE_INFINITY;
+    /** The player's clock, in ms, which the script timeout reads. */
+    clock = () => 0;
+    /**
+     * What code counts down as it jumps back or calls: the clock is read
+     * only as it runs out, so a loop pays a decrement for the timeout.
+     */
+    budget = BUDGET;
+    constructor() {
+        // Object's `prototype` is read-only (adl: Extends and a set leave it).
+        const object = this.classOf(this.objectProto, (self, args, version) => {
+            const v = first(args);
+            return v === undefined || v === null ? self : this.box(v, version);
+        }, (_, args, version) => {
+            const v = first(args);
+            return v === undefined || v === null ? new Avm1Object() : this.box(v, version);
+        }, READ_ONLY);
+        // Function() of nothing gives an object without a prototype, as Ruffle has it.
+        const fn = this.classOf(this.functionProto, (self, args) => (args.length > 0 ? args[0] : self), (_, args) => (args.length > 0 ? args[0] : new Avm1Object()));
+        this.Object = object;
+        this.Function = fn;
+        object.define("constructor", fn, DONT_ENUM | DONT_DELETE);
+        fn.define("constructor", fn, DONT_ENUM | DONT_DELETE);
+        this.functionProto.define("__proto__", this.objectProto, DONT_ENUM | DONT_DELETE);
+        this.objectPrototype();
+        this.functionPrototype();
+        this.String = stringClass(this);
+        this.Number = numberClass(this);
+        this.Boolean = booleanClass(this);
+        this.Array = arrayClass(this);
+        this.Error = this.errorClass();
+        this.AsBroadcaster = broadcasterClass(this);
+        this.Date = dateClass(this);
+        this.Math = mathObject(this);
+        this.natives.set(200, (i) => mathNative(i));
+        // In Flash's order (Ruffle's globals.rs), each DontEnum.
+        const g = this.global;
+        this.globalScope = new Scope(null, SCOPE_Global, g);
+        g.define("ASnative", this.method((_, args, version) => args.length === 2
+            ? asnative(this, toNumber(args[0], version) >>> 0, toNumber(args[1], version) >>> 0)
+            : undefined), DONT_ENUM);
+        g.define("Object", object, DONT_ENUM);
+        g.define("Function", fn, DONT_ENUM | VERSION_6);
+        // Getters, which give undefined to a SWF 4.
+        this.getter(g, "NaN", (version) => (version > 4 ? Number.NaN : undefined));
+        this.getter(g, "Infinity", (version) => (version > 4 ? Number.POSITIVE_INFINITY : undefined));
+        g.define("AsBroadcaster", this.AsBroadcaster.constr, DONT_ENUM);
+        g.define("ASSetPropFlags", this.method((_, args, version) => setPropFlags(this, args, version)), DONT_ENUM);
+        globalFunctions(this, (name, native) => g.define(name, this.method(native), DONT_ENUM));
+        // Flash's own globals leave a variable `o`, set to null.
+        g.define("o", null, 0);
+        g.define("Number", this.Number.constr, DONT_ENUM);
+        g.define("Boolean", this.Boolean.constr, DONT_ENUM);
+        g.define("Date", this.Date.constr, DONT_ENUM);
+        g.define("String", this.String.constr, DONT_ENUM);
+        g.define("Array", this.Array.constr, DONT_ENUM);
+        g.define("Math", this.Math, DONT_ENUM);
+        g.define("Error", this.Error.constr, DONT_ENUM);
+    }
+    /** The budget ran out: read the clock, and past the deadline, disable the movie's actions. */
+    timeout() {
+        this.budget = BUDGET;
+        if (this.clock() > this.deadline) {
+            throw new TimedOut("a script ran past the script timeout");
+        }
+    }
+    /** A property of `object` whose value a native getter gives, without a setter. */
+    getter(object, name, value) {
+        object.add(name, undefined, DONT_ENUM).get = this.method((_, __, version) => value(version));
+    }
+    /** A native function, a method's: no `prototype`. */
+    method(native) {
+        return new Avm1Function(this.functionProto, this, native);
+    }
+    /** A native method that takes `this` unboxed. */
+    rawMethod(native) {
+        return new Avm1Function(this.functionProto, this, native, null, true);
+    }
+    /** `value` as an object, as a native's `this`: a primitive boxed by its class on `_global`. */
+    box(value, version) {
+        if (value instanceof Avm1Object) {
+            return value;
+        }
+        const name = boxName(value);
+        if (name === null) {
+            return new Avm1Object();
+        }
+        const constr = this.global.own(name, version)?.value;
+        const boxed = constr instanceof Avm1Object ? this.construct(constr, [value], version) : undefined;
+        return boxed instanceof Avm1Object ? boxed : new Avm1Object();
+    }
+    /**
+     * `new constr(...args)`: an object whose `__proto__` is the constructor's
+     * `prototype`, which knows its constructor, given to the constructor;
+     * a native constructor's result is the result. Anything but a function
+     * constructs undefined.
+     */
+    construct(constr, args, version) {
+        if (!(constr instanceof Avm1Function)) {
+            return undefined;
+        }
+        const prototype = constr.own("prototype", version);
+        const self = new Avm1Object(prototype?.value);
+        if (version < 7) {
+            self.define("constructor", constr, DONT_ENUM);
+        }
+        self.define("__constructor__", constr, DONT_ENUM);
+        if (constr.construct !== null) {
+            return constr.construct(self, args, version);
+        }
+        constr.initialize(self, args, version);
+        return self;
+    }
+    /**
+     * DefineFunction's function of `region`, in the activation `cx` that
+     * defines it: its scope, constant pool and clip kept, a new `prototype`
+     * whose `constructor` it is.
+     */
+    newFunction(cx, region, params, flags, version) {
+        const fn = new ScriptFunction(this.functionProto, this, region, cx.code, params, flags, version, cx.scope, cx.pool, cx.base, cx.host.objectOf?.(cx.base) ?? cx.clip, version < 6 ? undefined : cx.self);
+        const prototype = new Avm1Object(this.objectProto);
+        prototype.define("constructor", fn, DONT_ENUM);
+        fn.define("prototype", prototype, DONT_ENUM | DONT_DELETE);
+        return fn;
+    }
+    /** `arguments` or `super` of a function's activation object, as it is first asked for. */
+    pendingLocal(cx, o, name, version) {
+        return pendingLocal(cx, o, name, version);
+    }
+    /**
+     * `value[name]` of a primitive, as Flash finds it on the object boxing it,
+     * without making one: its own `length`, `__constructor__` and
+     * `constructor` up to SWF 6, then its class's prototype, with the
+     * primitive as `this`. A class replaced on `_global` boxes it.
+     */
+    primitiveMember(value, name, version) {
+        const boxName_ = boxName(value);
+        if (boxName_ === null) {
+            return undefined;
+        }
+        const constr = this.global.own(boxName_, version)?.value;
+        const builtin = constr === this.String.constr ||
+            constr === this.Number.constr ||
+            constr === this.Boolean.constr;
+        if (!builtin) {
+            return get(this.box(value, version), name, version);
+        }
+        const prototype = constr.own("prototype", version);
+        const key = caseSensitive(version) ? name : fold(name);
+        switch (key) {
+            case "__proto__":
+                if (prototype !== undefined) {
+                    return prototype.value;
+                }
+                break;
+            case "__constructor__":
+                return constr;
+            case "constructor":
+                if (version < 7) {
+                    return constr;
+                }
+                break;
+            case "length":
+                if (typeof value === "string") {
+                    return value.length;
+                }
+                break;
+        }
+        const proto = prototype?.value;
+        return proto instanceof Avm1Object ? get(proto, name, version, value) : undefined;
+    }
+    /**
+     * A class with its own prototype object, in Flash's order: `prototype`,
+     * `constructor`, `__proto__`; `flags` adds to `prototype`'s attributes.
+     */
+    classOf(proto, construct, call, flags = 0) {
+        const constr = new Avm1Function(undefined, this, call, construct);
+        constr.define("prototype", proto, DONT_ENUM | DONT_DELETE | flags);
+        constr.define("constructor", this.Function ?? constr, DONT_ENUM | DONT_DELETE);
+        constr.define("__proto__", this.functionProto, DONT_ENUM | DONT_DELETE | VERSION_6);
+        proto.define("constructor", constr, DONT_ENUM | DONT_DELETE);
+        return constr;
+    }
+    /**
+     * Error, as far as Throw's values need it: a `message` and a `name`,
+     * both "Error" on the prototype and listed by for..in, as adl has them,
+     * and a `toString` that gives the message. Called as a function it gives
+     * undefined. Step 9 completes the classes.
+     */
+    errorClass() {
+        const proto = new Avm1Object(this.objectProto);
+        const constr = this.classOf(proto, (self, args, version) => {
+            if (args.length > 0 && args[0] !== undefined) {
+                set(self, "message", args[0], version);
+            }
+            return self;
+        }, () => undefined);
+        proto.define("message", "Error", 0);
+        proto.define("name", "Error", 0);
+        proto.define("toString", this.method((self, _, version) => get(self, "message", version)), 0);
+        return { constr, proto };
+    }
+    /** A new array of `elements`, as InitArray makes it. */
+    newArray(elements, version) {
+        const self = new Avm1Object();
+        const constr = this.global.own("Array", version)?.value;
+        const prototype = constr instanceof Avm1Object ? constr.own("prototype", version) : undefined;
+        if (prototype !== undefined) {
+            self.define("__proto__", prototype.value, DONT_ENUM | DONT_DELETE);
+        }
+        if (constr instanceof Avm1Object) {
+            self.define("constructor", constr, DONT_ENUM | DONT_DELETE);
+        }
+        return this.fillArray(self, elements, version);
+    }
+    /** `self` made an array of `elements`, then its `length`. */
+    fillArray(self, elements, _version) {
+        self.array = true;
+        if (self.elems === null && !hasIndex(self)) {
+            self.elems = [];
+        }
+        const elems = self.elems;
+        if (elems !== null && elems.length === 0) {
+            // A new array's elements, straight to their places.
+            for (let i = 0; i < elements.length; i++) {
+                elems.push(new Property(String(i), elements[i], 0));
+            }
+        }
+        else {
+            for (let i = 0; i < elements.length; i++) {
+                self.define(String(i), elements[i], 0);
+            }
+        }
+        self.define("length", elements.length, DONT_ENUM | DONT_DELETE);
+        return self;
+    }
+    /**
+     * A new object as InitObject makes one: `_global.Object` its
+     * `constructor`, which adl has before `__proto__`, its `prototype`.
+     */
+    newObject(version) {
+        const self = new Avm1Object();
+        const constr = this.global.own("Object", version)?.value;
+        if (constr instanceof Avm1Object) {
+            self.define("constructor", constr, DONT_ENUM | DONT_DELETE);
+            const prototype = constr.own("prototype", version);
+            if (prototype !== undefined) {
+                self.define("__proto__", prototype.value, DONT_ENUM | DONT_DELETE);
+            }
+        }
+        return self;
+    }
+    /** Function.prototype's `call` and `apply`: `this` an object, the global object for none. */
+    functionPrototype() {
+        const proto = this.functionProto;
+        const thisOf = (args, version) => {
+            const v = first(args);
+            return v === undefined || v === null ? this.global : this.box(v, version);
+        };
+        proto.define("call", this.method((self, args, version) => invoke(self, thisOf(args, version), args.slice(1), version, 1)), DONT_ENUM | DONT_DELETE);
+        proto.define("apply", this.method((self, args, version) => {
+            const list = args.length > 1 ? args[1] : undefined;
+            const elements = [];
+            if (list instanceof Avm1Object) {
+                const length = list.array
+                    ? lengthOf(list)
+                    : toNumber(get(list, "length", version), version);
+                // A length far past any list's is cut short, as no SWF gives one.
+                const n = Math.min(length | 0, 1 << 20);
+                for (let i = 0; i < n; i++) {
+                    elements.push(get(list, String(i), version));
+                }
+            }
+            return invoke(self, thisOf(args, version), elements, version, 1);
+        }), DONT_ENUM | DONT_DELETE);
+    }
+    objectPrototype() {
+        const proto = this.objectProto;
+        const v6 = DONT_ENUM | DONT_DELETE | VERSION_6;
+        // ASnative(101, i): the methods in the order defined, then registerClass (the player's) and Object.
+        const table = [];
+        const define = (name, flags, native) => {
+            if (name !== "toLocaleString") {
+                table.push(native);
+            }
+            proto.define(name, this.method(native), flags);
+        };
+        this.natives.set(101, (i) => i === 9 ? this.Object.construct : i === 8 ? () => undefined : (table[i] ?? null));
+        define("watch", v6, (self, args, version) => {
+            if (args.length === 0) {
+                return false;
+            }
+            const name = nameOf(args[0], version);
+            const callback = this.box(args.length > 1 ? args[1] : undefined, version);
+            if (!(callback instanceof Avm1Function)) {
+                return false;
+            }
+            const data = args.length > 2 ? args[2] : undefined;
+            const w = self.watcher(name, version);
+            if (w !== undefined) {
+                w.callback = callback;
+                w.data = data;
+            }
+            else {
+                self.watchers ??= [];
+                self.watchers.push({ name, callback, data, calls: 0 });
+            }
+            return true;
+        });
+        define("unwatch", v6, (self, args, version) => {
+            if (args.length === 0 || self.watchers === null) {
+                return false;
+            }
+            const w = self.watcher(nameOf(args[0], version), version);
+            if (w === undefined) {
+                return false;
+            }
+            self.watchers.splice(self.watchers.indexOf(w), 1);
+            return true;
+        });
+        define("addProperty", v6, (self, args, version) => {
+            if (args.length === 0) {
+                return false;
+            }
+            const name = nameOf(args[0], version);
+            const getter = args.length > 1 ? args[1] : undefined;
+            const setter = args.length > 2 ? args[2] : undefined;
+            // adl takes functions only, and null for no setter.
+            if (!(getter instanceof Avm1Function) || name === "") {
+                return false;
+            }
+            if (!(setter instanceof Avm1Function) && setter !== null) {
+                return false;
+            }
+            let p = self.own(name, version);
+            if (p === undefined) {
+                p = self.add(name, undefined, setter === null ? READ_ONLY : 0);
+            }
+            p.get = getter;
+            p.set = setter;
+            // An index's property lengthens an array as its element would (adl).
+            if (self.array && p.get !== null && fold(name) !== "length") {
+                arraySet(self, name, undefined, version);
+            }
+            return true;
+        });
+        define("valueOf", DONT_ENUM | DONT_DELETE, (self) => self);
+        define("toString", DONT_ENUM | DONT_DELETE, (self) => self instanceof Avm1Function ? "[type Function]" : "[object Object]");
+        // adl's hasOwnProperty does not see a property with ASSetPropFlags' bit 0x100.
+        define("hasOwnProperty", v6, (self, args, version) => {
+            if (args.length === 0) {
+                return false;
+            }
+            const p = self.own(nameOf(args[0], version), version);
+            return p !== undefined && (p.flags & 0x100) === 0;
+        });
+        define("isPrototypeOf", v6, (self, args, version) => {
+            if (args.length === 0) {
+                return false;
+            }
+            let p = this.box(args[0], version).protoFor(version);
+            for (let depth = 0; p instanceof Avm1Object && depth < 255; depth++) {
+                if (p === self) {
+                    return true;
+                }
+                p = p.protoFor(version);
+            }
+            return false;
+        });
+        define("isPropertyEnumerable", v6, (self, args, version) => {
+            if (args.length === 0) {
+                return false;
+            }
+            const p = self.own(nameOf(args[0], version), version);
+            return p !== undefined && (p.flags & DONT_ENUM) === 0;
+        });
+        define("toLocaleString", DONT_ENUM | DONT_DELETE, (self, _, version) => stringOf(self, version));
+    }
+}
+/** The class on `_global` that boxes a primitive, null for undefined and null. */
+function boxName(value) {
+    switch (typeof value) {
+        case "string":
+            return "String";
+        case "number":
+            return "Number";
+        case "boolean":
+            return "Boolean";
+        default:
+            return null;
+    }
+}
+/**
+ * `ASSetPropFlags(object, names, set, clear)`: the attributes of the named
+ * properties, or of all where `names` is null, cleared of `clear`'s bits
+ * and given `set`'s. Names are a string, split at commas, or what an array
+ * converts to; they are found whatever their case, in every version.
+ */
+function setPropFlags(realm, args, version) {
+    if (args.length === 0) {
+        return undefined;
+    }
+    const object = realm.box(args[0], version);
+    const set = args.length > 2 ? u16(args[2], version) : 0;
+    const clear = args.length > 3 ? u16(args[3], version) : 0;
+    const change = (p) => {
+        p.flags = (p.flags & ~clear) | set;
+    };
+    if (args.length < 2) {
+        return undefined;
+    }
+    if (args[1] === null) {
+        for (const p of object.ownProperties()) {
+            change(p);
+        }
+        return undefined;
+    }
+    for (const name of stringOf(args[1], version).split(",")) {
+        const p = object.own(name, 6);
+        if (p !== undefined) {
+            change(p);
+        }
+    }
+    return undefined;
+}
+/**
+ * A method's call as a conversion makes it, Flash's "special" calls: no
+ * `__resolve` asked, a method that is no function giving undefined.
+ */
+function callMethod(object, name, version) {
+    return invoke(get(object, name, version, object, false), object, [], version);
+}
+objects.valueOf = (object, version) => callMethod(object, "valueOf", version);
+objects.toPrimitive = (object, version) => {
+    // A Date adds as its string from SWF 6.
+    const o = object;
+    const value = callMethod(o, version > 5 && o.primitive instanceof DateCell ? "toString" : "valueOf", version);
+    return isPrimitive(value) ? value : object;
+};
+objects.toString = (object, version) => {
+    const o = object;
+    if (typeof o.primitive === "string") {
+        return o.primitive;
+    }
+    // A display object is its path, a clip's wherever its reference reaches now, "" where nothing.
+    if (o.display !== null) {
+        return o.display.live()?.display?.path() ?? "";
+    }
+    const value = callMethod(o, "toString", version);
+    if (typeof value === "string") {
+        return value;
+    }
+    return o instanceof Avm1Function ? "[type Function]" : "[type Object]";
+};
+objects.typeOf = (object) => object.typeOf();
+/** Whether `o` has a property named as an element. */
+function hasIndex(o) {
+    for (const name of o.props.keys()) {
+        if (elementIndex(name) >= 0) {
+            return true;
+        }
+    }
+    return false;
+}