@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/runtime/avm1/globals/string.js

@@ -0,0 +1,201 @@
+// String, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/string.rs has it: MIT OR Apache-2.0, Copyright (c)
+// 2018-2022 Ruffle LLC and Ruffle contributors. Where adl parts from
+// Ruffle, adl decides (docs/avm1.md, "Array and String").
+//
+// The methods take `this` unboxed: a string's method call makes no String
+// object. Up to SWF 5 a string is its bytes, each a code unit here, which
+// the methods count and cut as they are. From SWF 6 they cut UTF-16 code
+// units, and keep half a surrogate pair as it is, which joins its other
+// half again (adl), unlike StringExtract's (operators.ts).
+import { lowerCase, upperCase } from "../case.js";
+import { Avm1Object, DONT_DELETE, DONT_ENUM, } from "../objects.js";
+import { stringOf, toNumber } from "../values.js";
+const toInt = (value, version) => toNumber(value, version) | 0;
+/** An index as slice and substr take one: from the end where negative, within 0 and `length`. */
+function wrapping(i, length) {
+    return i < 0 ? Math.max(length + i, 0) : Math.min(i, length);
+}
+/** An index as substring takes one: within 0 and `length`. */
+const clamped = (i, length) => (i < 0 ? 0 : Math.min(i, length));
+/** Each code unit of `s` mapped by `map`; up to SWF 5, a byte's mapping only to a byte. */
+function mapped(s, map, bytes) {
+    let out = "";
+    let changed = false;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        let m = map(c);
+        if (bytes && m > 0xff) {
+            m = c;
+        }
+        changed ||= m !== c;
+        out += String.fromCharCode(m);
+    }
+    return changed ? out : s;
+}
+/** The class: its constructor, prototype and methods. */
+export function stringClass(realm) {
+    const proto = new Avm1Object();
+    const constr = realm.classOf(proto, (self, args, version) => {
+        const s = args.length > 0 ? stringOf(args[0], version) : "";
+        self.primitive = s;
+        self.define("length", s.length, DONT_ENUM | DONT_DELETE);
+        return self;
+    }, (_, args, version) => (args.length > 0 ? stringOf(args[0], version) : ""));
+    proto.define("__proto__", realm.objectProto, DONT_ENUM | DONT_DELETE);
+    /** `this` as the string the methods work on: a String's own, else what it converts to. */
+    const text = (self, version) => {
+        if (typeof self === "string") {
+            return self;
+        }
+        const o = realm.box(self, version);
+        return typeof o.primitive === "string" ? o.primitive : stringOf(o, version);
+    };
+    const define = (name, native) => proto.define(name, realm.rawMethod(native), DONT_ENUM | DONT_DELETE);
+    // A String's own string, but undefined for anything else; valueOf gives
+    // anything else as a string, by its toString (adl; Ruffle gives undefined).
+    const own = (self) => {
+        if (typeof self === "string") {
+            return self;
+        }
+        return self instanceof Avm1Object && typeof self.primitive === "string"
+            ? self.primitive
+            : undefined;
+    };
+    define("valueOf", (self, _, version) => own(self) ?? text(self, version));
+    define("toString", (self) => own(self));
+    define("toUpperCase", (self, _, version) => mapped(text(self, version), upperCase, version < 6));
+    define("toLowerCase", (self, _, version) => mapped(text(self, version), lowerCase, version < 6));
+    define("charAt", (self, args, version) => {
+        const s = text(self, version);
+        const i = toInt(args.length > 0 ? args[0] : undefined, version);
+        if (i < 0 || i >= s.length) {
+            return "";
+        }
+        return s[i];
+    });
+    define("charCodeAt", (self, args, version) => {
+        const s = text(self, version);
+        const i = toInt(args.length > 0 ? args[0] : undefined, version);
+        if (i >= 0 && i < s.length) {
+            return s.charCodeAt(i);
+        }
+        // A SWF 5 has 0 past the end.
+        return i >= 0 && version === 5 ? 0 : Number.NaN;
+    });
+    define("concat", (self, args, version) => {
+        let s = text(self, version);
+        for (const arg of args) {
+            s += stringOf(arg, version);
+        }
+        return s;
+    });
+    define("indexOf", (self, args, version) => {
+        const s = text(self, version);
+        if (args.length === 0) {
+            return undefined;
+        }
+        const pattern = stringOf(args[0], version);
+        const start = args.length > 1 && args[1] !== undefined ? Math.max(toInt(args[1], version), 0) : 0;
+        return start > s.length ? -1 : s.indexOf(pattern, start);
+    });
+    define("lastIndexOf", (self, args, version) => {
+        const s = text(self, version);
+        if (args.length === 0) {
+            return undefined;
+        }
+        const pattern = stringOf(args[0], version);
+        let end = s.length;
+        if (args.length > 1 && args[1] !== undefined) {
+            const i = toInt(args[1], version);
+            if (i < 0) {
+                return -1;
+            }
+            end = Math.min(i + pattern.length, s.length);
+        }
+        const found = s.lastIndexOf(pattern, end - pattern.length);
+        return found >= 0 && found + pattern.length <= end ? found : -1;
+    });
+    define("slice", (self, args, version) => {
+        if (args.length === 0) {
+            return undefined;
+        }
+        const s = text(self, version);
+        const start = wrapping(toInt(args[0], version), s.length);
+        const end = args.length > 1 && args[1] !== undefined
+            ? wrapping(toInt(args[1], version), s.length)
+            : s.length;
+        return start < end ? s.slice(start, end) : "";
+    });
+    define("substring", (self, args, version) => {
+        if (args.length === 0) {
+            return undefined;
+        }
+        const s = text(self, version);
+        let start = clamped(toInt(args[0], version), s.length);
+        // adl: nothing from the end on, whatever the end (Ruffle swaps first).
+        if (start >= s.length) {
+            return "";
+        }
+        let end = args.length > 1 && args[1] !== undefined
+            ? clamped(toInt(args[1], version), s.length)
+            : s.length;
+        if (end < start) {
+            [start, end] = [end, start];
+        }
+        return s.slice(start, end);
+    });
+    define("split", (self, args, version) => {
+        const s = text(self, version);
+        const limitArg = args.length > 1 ? args[1] : undefined;
+        const limit = limitArg === undefined ? Number.POSITIVE_INFINITY : Math.max(toInt(limitArg, version), 0);
+        const d = args.length > 0 ? args[0] : undefined;
+        const take = (parts) => realm.newArray(limit < parts.length ? parts.slice(0, limit) : parts, version);
+        // A SWF 5 splits at commas by default, and only at one character: an
+        // empty delimiter leaves the string whole whatever the limit, a longer
+        // one within it (adl).
+        if (version < 6) {
+            const delimiter = d === undefined ? "," : stringOf(d, version);
+            if (delimiter === "") {
+                return realm.newArray([s], version);
+            }
+            return take(delimiter.length === 1 ? s.split(delimiter) : [s]);
+        }
+        // Without a delimiter, the string whole whatever the limit; an empty
+        // string so too, but split by "" (adl).
+        if (d === undefined) {
+            return realm.newArray([s], version);
+        }
+        const delimiter = stringOf(d, version);
+        if (s === "" && delimiter !== "") {
+            return realm.newArray([s], version);
+        }
+        return take(delimiter === "" ? s.split("") : s.split(delimiter));
+    });
+    define("substr", (self, args, version) => {
+        if (args.length === 0) {
+            return undefined;
+        }
+        const s = text(self, version);
+        const start = wrapping(toInt(args[0], version), s.length);
+        const count = args.length > 1 && args[1] !== undefined ? toInt(args[1], version) : s.length;
+        const end = wrapping(start + count, s.length);
+        return start < end ? s.slice(start, end) : "";
+    });
+    constr.define("fromCharCode", realm.method((_, args, version) => {
+        let s = "";
+        for (const arg of args) {
+            const code = toNumber(arg, version) & 0xffff;
+            if (code === 0) {
+                break;
+            }
+            // A SWF 5's string is bytes: a code past 0xFF is two, the high one first.
+            s +=
+                version < 6 && code > 0xff
+                    ? String.fromCharCode(code >> 8, code & 0xff)
+                    : String.fromCharCode(code);
+        }
+        return s;
+    }), DONT_ENUM | DONT_DELETE);
+    return { constr, proto };
+}

package/dist/thread/runtime/avm1/globals/timers.js

@@ -0,0 +1,129 @@
+// setInterval, setTimeout, clearInterval and clearTimeout (docs/avm1.md,
+// "Time"), as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/timer.rs and avm1/globals.rs (create_timer) have them: MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+// The timers are the runtime's, the clock the player's: it tells the
+// runtime the time and asks it to fire what is due between frames.
+import { Avm1Function, Avm1Object } from "../objects.js";
+import { toInt32 } from "../operators.js";
+import { stringOf } from "../values.js";
+/** The shortest interval a timer has, in ms, as Ruffle has it: Flash fires none much faster. */
+const MIN_INTERVAL = 10;
+/** A timer: a function to call, or an object and the name of its method, every `interval` ms. */
+export class Timer {
+    id;
+    callback;
+    method;
+    args;
+    interval;
+    due;
+    once;
+    seq;
+    constructor(id, callback, 
+    /** The method's name, null where `callback` is the function. */
+    method, args, interval, 
+    /** When it falls due next, in the clock's ms. */
+    due, 
+    /** setTimeout's: it fires once. */
+    once, 
+    /** Its place among those due at once: the one set first fires first. */
+    seq) {
+        this.id = id;
+        this.callback = callback;
+        this.method = method;
+        this.args = args;
+        this.interval = interval;
+        this.due = due;
+        this.once = once;
+        this.seq = seq;
+    }
+}
+/** A runtime's timers, by when they fall due. */
+export class Timers {
+    /** The time now on the player's clock, in ms: a timer set now counts from it. */
+    now = 0;
+    counter = 0;
+    seq = 0;
+    list = [];
+    get size() {
+        return this.list.length;
+    }
+    /** A new timer, its id: from 1, as Flash never gives 0. */
+    add(callback, method, args, interval, once) {
+        this.counter = (this.counter + 1) | 0;
+        const ms = Math.max(interval, MIN_INTERVAL);
+        this.list.push(new Timer(this.counter, callback, method, args, ms, this.now + ms, once, this.seq++));
+        return this.counter;
+    }
+    /** Clear timer `id`: whether there was one. */
+    remove(id) {
+        const i = this.list.findIndex((t) => t.id === id);
+        if (i < 0) {
+            return false;
+        }
+        this.list.splice(i, 1);
+        return true;
+    }
+    has(timer) {
+        return this.list.includes(timer);
+    }
+    /** The timer due first by `time`, of two due at once the one set first; null for none. */
+    due(time) {
+        let first = null;
+        for (const t of this.list) {
+            if (t.due <= time &&
+                (first === null || t.due < first.due || (t.due === first.due && t.seq < first.seq))) {
+                first = t;
+            }
+        }
+        return first;
+    }
+    /** `timer` fired: due again an interval on, or gone for a timeout. */
+    fired(timer) {
+        if (timer.once) {
+            this.remove(timer.id);
+        }
+        else {
+            timer.due += timer.interval;
+            timer.seq = this.seq++;
+        }
+    }
+    clear() {
+        this.list.length = 0;
+    }
+}
+/**
+ * setInterval's and setTimeout's native: `(function, interval, ...args)`
+ * or `(object, name, interval, ...args)`; undefined where there is no
+ * callback or no interval.
+ */
+function create(realm, args, version, once) {
+    const first = args.length > 0 ? args[0] : undefined;
+    if (!(first instanceof Avm1Object)) {
+        return undefined;
+    }
+    const isFunction = first instanceof Avm1Function;
+    const interval = isFunction ? args[1] : args[2];
+    if (interval === undefined) {
+        return undefined;
+    }
+    const method = isFunction ? null : stringOf(args.length > 1 ? args[1] : undefined, version);
+    const rest = args.slice(isFunction ? 2 : 3);
+    return realm.timers.add(first, method, rest, toInt32(interval, version), once);
+}
+/** The timer natives, in Flash's order on `_global`, and ASnative(250, i): setInterval, clearInterval, setTimeout. */
+export function timerFunctions(realm) {
+    const setInterval = (_, args, version) => create(realm, args, version, false);
+    const setTimeout = (_, args, version) => create(realm, args, version, true);
+    const clear = (_, args, version) => {
+        realm.timers.remove(toInt32(args.length > 0 ? args[0] : undefined, version));
+        return undefined;
+    };
+    realm.natives.set(250, (i) => [setInterval, clear, setTimeout][i] ?? null);
+    return [
+        ["setInterval", setInterval],
+        ["clearTimeout", clear],
+        ["clearInterval", clear],
+        ["setTimeout", setTimeout],
+    ];
+}

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

@@ -0,0 +1,5 @@
+// What AVM1 code asks of the player, which has the display list the
+// runtime does not (docs/avm1.md, "Where each piece lives"). A clip is the
+// player's, opaque here.
+/** What a display object's AVM1 object found for a name that is none of its own properties: nothing. */
+export const ABSENT = Symbol("absent");

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

@@ -0,0 +1,14 @@
+/** The AVM1 (AS1 and AS2) runtime: values, their conversions by version, and what modules call. */
+export { goto } from "./clips.js";
+export { Avm1Super, ScriptFunction } from "./functions.js";
+export { broadcastMessage, initializeBroadcaster } from "./globals/broadcaster.js";
+export { DateCell } from "./globals/date.js";
+export { escapeAvm1, parseIntAvm1, unescapeAvm1 } from "./globals/global.js";
+export { ABSENT, } from "./host.js";
+export { numberToString, parseFloatAvm1, stringToNumber } from "./numbers.js";
+export { Avm1Function, Avm1Object, allowed, caseSensitive, DONT_DELETE, DONT_ENUM, find, fold, get, has, invoke, keys, markNames, Property, READ_ONLY, removeOwn, set, VERSION_6, VERSION_7, VERSION_8, } from "./objects.js";
+export { Realm } from "./realm.js";
+export { Activation, Avm1Throw, Disabled, Halt, NotYet, OwnUnits, Runtime, TimedOut, } from "./runtime.js";
+export { Scope, targetPath } from "./scope.js";
+export { getUrlMethod } from "./urls.js";
+export { isPrimitive, objects, stringOf, toBoolean, toNumber, typeOf, } from "./values.js";

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

@@ -0,0 +1,132 @@
+// AS2's classes as the compiler writes them: Extends, InstanceOf, CastOp
+// and ImplementsOp, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/activation.rs and object.rs (is_instance_of) have them:
+// MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle
+// contributors. Where adl parts from Ruffle, adl decides (docs/avm1.md,
+// "Classes").
+import { Avm1Object, DONT_ENUM, get, set, VERSION_6 } from "./objects.js";
+import { isPrimitive, toNumber } from "./values.js";
+/** What Flash's log says of a primitive where an action takes an object. */
+export const PRIMITIVE = "Parameters of primitive types are no longer coerced into the required type - Object.";
+/** And of an object where it takes a number. */
+const OBJECT = "Parameters of type Object are no longer coerced into the required primitive type - number.";
+/** A primitive where an object is taken: undefined and null say nothing, any other writes to the log. */
+function refuse(cx, value) {
+    if (value !== undefined && value !== null) {
+        cx.host.trace(PRIMITIVE);
+    }
+}
+/** The deepest a prototype chain is walked, as objects.ts walks one. */
+const DEPTH = 255;
+/**
+ * A class's or an interface's `prototype` as InstanceOf and ImplementsOp
+ * read it: its own stored value, no getter called, nothing inherited.
+ */
+function prototypeOf(o, version) {
+    return o.own("prototype", version)?.value;
+}
+/**
+ * Whether `value` is an instance of `constr`: its `prototype` on the
+ * object's chain, or among the interfaces of one there, and theirs. A
+ * primitive class, or prototype, is boxed, by `_global`'s class.
+ */
+export function instanceOf(realm, value, constr, version) {
+    if (!(value instanceof Avm1Object) || constr === undefined || constr === null) {
+        return false;
+    }
+    let prototype = prototypeOf(realm.box(constr, version), version);
+    if (isPrimitive(prototype) && prototype !== undefined && prototype !== null) {
+        prototype = realm.box(prototype, version);
+    }
+    if (!(prototype instanceof Avm1Object)) {
+        return false;
+    }
+    let p = value.protoFor(version);
+    for (let depth = 0; p instanceof Avm1Object && depth < DEPTH; depth++) {
+        if (p === prototype) {
+            return true;
+        }
+        if (p.interfaces !== null && implementsOf(p.interfaces, prototype, 0)) {
+            return true;
+        }
+        p = p.protoFor(version);
+    }
+    return false;
+}
+/** Whether `prototype` is among `interfaces`, or theirs. */
+function implementsOf(interfaces, prototype, depth) {
+    for (const i of interfaces) {
+        if (i === prototype) {
+            return true;
+        }
+        if (i.interfaces !== null &&
+            depth < DEPTH &&
+            implementsOf(i.interfaces, prototype, depth + 1)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Extends: the subclass's `prototype` a new object whose prototype is the
+ * superclass's, which knows its `__constructor__` but has no `constructor`
+ * of its own (adl; Ruffle gives it one). A primitive on either side
+ * changes nothing (adl).
+ */
+export function extend(cx, superclass, subclass, version) {
+    if (!(superclass instanceof Avm1Object)) {
+        refuse(cx, superclass);
+        return;
+    }
+    if (!(subclass instanceof Avm1Object)) {
+        refuse(cx, subclass);
+        return;
+    }
+    // `__constructor__` is hidden from a SWF 5 (adl).
+    const prototype = new Avm1Object(get(superclass, "prototype", version));
+    prototype.define("__constructor__", superclass, DONT_ENUM | VERSION_6);
+    set(subclass, "prototype", prototype, version);
+}
+/**
+ * ImplementsOp: the constructor, the interfaces' count and the interfaces
+ * popped, the interfaces' prototypes given to the constructor's: only the
+ * first time, as adl has it (Ruffle replaces them), and from SWF 6 too.
+ */
+export function implementsOp(cx, version) {
+    const st = cx.st;
+    const constr = st.pop();
+    if (!(constr instanceof Avm1Object)) {
+        refuse(cx, constr);
+    }
+    const countValue = st.pop();
+    let count = 0;
+    if (isPrimitive(countValue)) {
+        count = toNumber(countValue, version) | 0;
+    }
+    else {
+        cx.host.trace(OBJECT);
+    }
+    count = Math.min(count, st.length);
+    if (count <= 0) {
+        return;
+    }
+    const interfaces = [];
+    for (let k = 0; k < count; k++) {
+        const i = st.pop();
+        if (i instanceof Avm1Object) {
+            const p = prototypeOf(i, version);
+            if (p instanceof Avm1Object) {
+                interfaces.push(p);
+            }
+        }
+        else {
+            refuse(cx, i);
+        }
+    }
+    if (constr instanceof Avm1Object) {
+        const prototype = prototypeOf(constr, version);
+        if (prototype instanceof Avm1Object && prototype.interfaces === null) {
+            prototype.interfaces = interfaces;
+        }
+    }
+}