@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,385 @@
+import { PRIMITIVE } from "./inheritance.js";
+import { find, fold, foundValue, get, has, Avm1Object as ObjectClass, removeOwn, set, } from "./objects.js";
+/** `_global`, at the bottom of every chain. */
+export const SCOPE_Global = 0;
+/** A clip whose timeline's code runs: where a variable set without one is made. */
+export const SCOPE_Target = 1;
+/** A function's activation object. */
+export const SCOPE_Local = 2;
+/** A `with`'s object. */
+export const SCOPE_With = 3;
+/**
+ * How many scopes a chain may hold, `_global` included: a With that would
+ * make it longer skips its body, as adl does (docs/avm1.md, "With and Try").
+ */
+export const MAX_SCOPES = 15;
+export class Scope {
+    parent;
+    kind;
+    object;
+    depth;
+    constructor(parent, kind, object, 
+    /** How many scopes the chain holds, as adl counts them for MAX_SCOPES. */
+    depth = parent === null ? 1 : parent.depth + 1) {
+        this.parent = parent;
+        this.kind = kind;
+        this.object = object;
+        this.depth = depth;
+    }
+}
+/** Whether `c` ends a path's object part: `:`, and `.` from SWF 5. */
+const separates = (c, version) => c === 0x3a || (c === 0x2e && version >= 5);
+/** Where a name's last `:` or `.` is, the variable after it, -1 for a name without a path. */
+function lastSeparator(name, version) {
+    for (let i = name.length - 1; i >= 0; i--) {
+        if (separates(name.charCodeAt(i), version)) {
+            return i;
+        }
+    }
+    return -1;
+}
+/** Whether `a` and `b` are the same name for a SWF of `version`. */
+const sameName = (a, b, version) => a === b || (version <= 6 && fold(a) === fold(b));
+/** Whether `name` is `this`: case-insensitively up to SWF 6, in a function too (adl; Ruffle has a SWF 5 function's case-sensitive). */
+function isThis(name, version) {
+    if (name.length !== 4 || version < 5) {
+        return false;
+    }
+    if (name === "this") {
+        return true;
+    }
+    return version < 7 && fold(name) === "this";
+}
+/**
+ * `_root`, `_parent`, `_global` (from SWF 6) and `_levelN`: what a name
+ * the scope chain lacks may still be.
+ */
+function pathProperty(cx, name, version) {
+    if (version < 5 || name.length < 5 || name.charCodeAt(0) !== 0x5f) {
+        return undefined;
+    }
+    if (sameName(name, "_root", version)) {
+        return cx.host.root?.(cx.base);
+    }
+    if (sameName(name, "_parent", version)) {
+        return cx.host.parent?.(cx.scope.object);
+    }
+    if (version >= 6 && sameName(name, "_global", version)) {
+        return cx.global;
+    }
+    return level(cx, name, version);
+}
+/** Whether `name` starts `_level` or `_flash`, a level's name whatever follows. */
+function isLevel(name, version) {
+    const prefix = name.slice(0, 6);
+    return sameName(prefix, "_level", version) || sameName(prefix, "_flash", version);
+}
+/**
+ * `_levelN` or `_flashN`: level N, if the host has it. N is a sign and the
+ * digits up to anything else, wrapping, none 0, as Ruffle's parse_level
+ * reads it: `_level0:x` and `_levelx` are level 0.
+ */
+function level(cx, name, version) {
+    if (!isLevel(name, version)) {
+        return undefined;
+    }
+    const negative = name.charCodeAt(6) === 0x2d;
+    let n = 0;
+    for (let i = negative ? 7 : 6; i < name.length; i++) {
+        const d = name.charCodeAt(i) - 0x30;
+        if (d < 0 || d > 9) {
+            break;
+        }
+        n = (Math.imul(n, 10) + d) | 0;
+    }
+    return cx.host.level?.(negative ? -n | 0 : n);
+}
+/** A name without a path along the scope chain, as GetVariable and NewObject find it. */
+export function resolve(cx, name, version) {
+    if (isThis(name, version)) {
+        return cx.self;
+    }
+    for (let s = cx.scope; s !== null; s = s.parent) {
+        const p = find(s.object, name, version);
+        if (p !== undefined) {
+            // The first property found is what get finds too, where its version sees it.
+            return foundValue(p, s.object, name, version);
+        }
+    }
+    return pathProperty(cx, name, version);
+}
+/** What `resolveCallable` found a function on, for CallFunction's `this`. */
+export let foundOn;
+/** Whether that was a function's activation object. */
+export let foundLocal = false;
+/** As `resolve`, setting `foundOn` to the object that had the name, undefined for none. */
+export function resolveCallable(cx, name, version) {
+    foundOn = undefined;
+    foundLocal = false;
+    const separator = lastSeparator(name, version);
+    if (separator >= 0 || (version >= 5 && name.includes("/"))) {
+        return getVariable(cx, name, version);
+    }
+    if (isThis(name, version)) {
+        return cx.self;
+    }
+    for (let s = cx.scope; s !== null; s = s.parent) {
+        if (has(s.object, name, version)) {
+            const value = get(s.object, name, version);
+            foundOn = s.object;
+            foundLocal = s.kind === SCOPE_Local;
+            return value;
+        }
+    }
+    return pathProperty(cx, name, version);
+}
+/**
+ * GetVariable: a name, or a path to an object and a name on it, the path
+ * tried from each scope in turn; a path without a variable is the object
+ * it names, from SWF 5.
+ */
+export function getVariable(cx, name, version) {
+    const separator = lastSeparator(name, version);
+    if (separator >= 0) {
+        if (separator === 0) {
+            return undefined;
+        }
+        const path = name.slice(0, separator);
+        const variable = name.slice(separator + 1);
+        for (let s = cx.scope; s !== null; s = s.parent) {
+            const object = targetPath(cx, s.object, path, true, true, version);
+            if (object !== null && has(object, variable, version)) {
+                // After the getter, which may call functions of its own.
+                const value = get(object, variable, version);
+                foundOn = object;
+                return value;
+            }
+        }
+        return undefined;
+    }
+    if (version >= 5 && name.includes("/")) {
+        for (let s = cx.scope; s !== null; s = s.parent) {
+            const object = targetPath(cx, s.object, name, false, false, version);
+            if (object !== null) {
+                return object;
+            }
+        }
+    }
+    return resolve(cx, name, version);
+}
+/**
+ * SetVariable: a path's object takes the name, the first a scope resolves
+ * it to; a name without one is set where the scope chain has it, else on
+ * the target's clip. `this` from SWF 5 sets the activation's `this`.
+ */
+export function setVariable(cx, name, value, version) {
+    if (name === "") {
+        return;
+    }
+    if (isThis(name, version)) {
+        cx.self = value;
+        return;
+    }
+    // A path's separators are `:` and `.` here in every version, and its
+    // `this` is no object in a timeline's code (adl sets nothing for `this.x`
+    // there), but is in a function's (the corpus's `path_string`).
+    const separator = lastSeparator(name, 5);
+    if (separator >= 0) {
+        const path = name.slice(0, separator);
+        const variable = name.slice(separator + 1);
+        const handleThis = inLocalScope(cx);
+        for (let s = cx.scope; s !== null; s = s.parent) {
+            const object = targetPath(cx, s.object, path, true, handleThis, version);
+            if (object !== null) {
+                set(object, variable, value, version);
+                return;
+            }
+        }
+        return;
+    }
+    let s = cx.scope;
+    for (;;) {
+        if (s.kind === SCOPE_Target || has(s.object, name, version) || s.parent === null) {
+            set(s.object, name, value, version);
+            return;
+        }
+        s = s.parent;
+    }
+}
+/** Whether the activation's chain reaches a function's scope before a clip's. */
+function inLocalScope(cx) {
+    for (let s = cx.scope; s !== null; s = s.parent) {
+        if (s.kind === SCOPE_Local) {
+            return true;
+        }
+        if (s.kind === SCOPE_Target) {
+            return false;
+        }
+    }
+    return false;
+}
+/** Whether a name has a `:` or a `.`, a path, in every version. */
+const isPath = (name) => lastSeparator(name, 5) >= 0;
+/** Set `name` on the top scope, or on the first below a `with` that lacks it. */
+function defineOn(scope, name, value, version) {
+    let s = scope;
+    while (s.kind === SCOPE_With && s.parent !== null && s.object.own(name, version) === undefined) {
+        s = s.parent;
+    }
+    set(s.object, name, value, version);
+}
+/** DefineLocal: a variable of the activation's top scope; a path outside a function is set as SetVariable sets it. */
+export function defineLocal(cx, name, value, version) {
+    if (!inLocalScope(cx) && isPath(name)) {
+        setVariable(cx, name, value, version);
+    }
+    else {
+        defineOn(cx.scope, name, value, version);
+    }
+}
+/** DefineLocal2: as DefineLocal of undefined, where the variable is not there yet. */
+export function defineLocal2(cx, name, version) {
+    if (!inLocalScope(cx) && isPath(name)) {
+        if (getVariable(cx, name, version) === undefined) {
+            setVariable(cx, name, undefined, version);
+        }
+    }
+    else if (!has(cx.scope.object, name, version)) {
+        defineOn(cx.scope, name, undefined, version);
+    }
+}
+/** Delete2: a path's variable on its object, or a name on the first scope that has it. */
+export function deleteVariable(cx, name, version) {
+    const separator = lastSeparator(name, 5);
+    if (separator >= 0) {
+        const object = getVariable(cx, name.slice(0, separator), version);
+        // A primitive where the object would be writes Flash's line of it (the corpus's `delete2`).
+        if (!(object instanceof ObjectClass)) {
+            if (object !== undefined && object !== null && version >= 5) {
+                cx.host.trace(PRIMITIVE);
+            }
+            return false;
+        }
+        return removeOwn(object, name.slice(separator + 1), version);
+    }
+    for (let s = cx.scope; s !== null; s = s.parent) {
+        if (has(s.object, name, version)) {
+            return removeOwn(s.object, name, version);
+        }
+    }
+    return false;
+}
+/**
+ * The object a target path names from `start`: names separated by `.`,
+ * `:` or `/`, `..` the parent, a leading `/` the root, `this`, `_root` and
+ * `_levelN` first; each name a clip's child, else a property. Null where a
+ * step is no object.
+ */
+export function targetPath(cx, start, path, firstElement, handleThis, version) {
+    stoppedAtPrimitive = false;
+    if (path === "") {
+        return start;
+    }
+    const swf5 = version >= 5;
+    let object = start;
+    let slash = false;
+    let i = 0;
+    /** The delimiter that ended the last step, 0 for none. */
+    let prev = 0;
+    if (path.charCodeAt(0) === 0x2f) {
+        i = 1;
+        prev = 0x2f;
+        firstElement = false;
+        slash = true;
+        object = cx.host.root?.(cx.base);
+        if (!(object instanceof ObjectClass)) {
+            return null;
+        }
+    }
+    const n = path.length;
+    while (i < n) {
+        if (swf5) {
+            // A path that ends in one goes on to an empty name, as Ruffle's does: none.
+            while (i < n && path.charCodeAt(i) === 0x3a) {
+                i++;
+            }
+        }
+        let value;
+        const c2 = path.charCodeAt(i + 2);
+        if (path.charCodeAt(i) === 0x2e &&
+            path.charCodeAt(i + 1) === 0x2e &&
+            (i + 2 >= n || c2 === 0x2f || (swf5 && c2 === 0x3a))) {
+            if (c2 === 0x2f) {
+                slash = true;
+            }
+            i += 3;
+            prev = c2;
+            value = cx.host.parent?.(object);
+            // A level's parent is the level, but where a slash follows (the corpus's `target_paths`).
+            if (value === undefined) {
+                if (c2 === 0x2f) {
+                    return null;
+                }
+                value = object;
+            }
+        }
+        else {
+            let end = i;
+            for (; end < n; end++) {
+                const c = path.charCodeAt(end);
+                if ((c === 0x3a && swf5) || (c === 0x2e && swf5 && !slash)) {
+                    break;
+                }
+                if (c === 0x2f) {
+                    slash = true;
+                    break;
+                }
+            }
+            const name = path.slice(i, end);
+            const after = prev;
+            prev = end < n ? path.charCodeAt(end) : 0;
+            i = end + 1;
+            // An empty name is nothing first, after a slash, or at the end after a
+            // colon, else no step at all (`//a`, `.a` and `a::` name nothing, `a:/`
+            // and `a..` name `a`: the corpus's `target_paths` and `path_string`).
+            if (name === "") {
+                if (after === 0x2f || after === 0 || (end >= n && after === 0x3a)) {
+                    return null;
+                }
+                value = object;
+            }
+            else if (swf5 && handleThis && sameName(name, "this", version)) {
+                value = cx.self;
+            }
+            else if (swf5 && firstElement && sameName(name, "_root", version)) {
+                value = cx.host.root?.(cx.base);
+            }
+            else if (version >= 6 && firstElement && sameName(name, "_global", version)) {
+                value = cx.global;
+            }
+            else if (firstElement && isLevel(name, version)) {
+                value = level(cx, name, version);
+            }
+            else {
+                const o = object;
+                value = cx.host.child?.(o, name, version > 6);
+                if (value === undefined) {
+                    value = get(o, name, version);
+                }
+            }
+        }
+        firstElement = false;
+        if (!(value instanceof ObjectClass)) {
+            stoppedAtPrimitive = value !== undefined && value !== null;
+            return null;
+        }
+        object = value;
+    }
+    return object;
+}
+/**
+ * Whether the last `targetPath` that named no object stopped at a
+ * primitive, which a clip's path taken as an object writes Flash's line
+ * of to the log for (the corpus's `target_paths`).
+ */
+export let stoppedAtPrimitive = false;

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

@@ -0,0 +1,180 @@
+import { pathTarget, targetOrRoot } from "./clips.js";
+import { Avm1Throw } from "./errors.js";
+import { Avm1Object, get, keys } from "./objects.js";
+import { stringOf } from "./values.js";
+/** GetURL2's flags past the method (decode.ts reads a method of 3 as none). */
+const METHOD_MASK = 3;
+const LOAD_TARGET = 0x40;
+const LOAD_VARIABLES = 0x80;
+/** The command of an `FSCommand:` URL, in any case; null for any other URL. */
+function fsCommandOf(url) {
+    return url.length >= 10 && url.slice(0, 10).toLowerCase() === "fscommand:" ? url.slice(10) : null;
+}
+/** "blank" with or without its underscore, in any case, as "_blank"; any other window as given. */
+function windowOf(target) {
+    return /^_?blank$/i.test(target) ? "_blank" : target;
+}
+/** A level's number as Rust's i32 parse reads it: a sign and digits only, in range, else null. */
+function levelInt(text) {
+    if (!/^[+-]?\d+$/.test(text)) {
+        return null;
+    }
+    const n = Number(text);
+    return n >= -0x80000000 && n <= 0x7fffffff ? n : null;
+}
+/** A level's number as Rust's f64 parse reads it and `as i32` truncates it, saturated; null for no number. */
+function levelFloat(text) {
+    if (!/^[+-]?(\d+\.?\d*([eE][+-]?\d+)?|\.\d+([eE][+-]?\d+)?|inf|infinity|nan)$/i.test(text)) {
+        return null;
+    }
+    const body = text.replace(/^[+-]/, "").toLowerCase();
+    const n = body === "inf" || body === "infinity" ? Infinity : Number(body);
+    if (Number.isNaN(n)) {
+        return 0;
+    }
+    const signed = text.startsWith("-") ? -n : n;
+    return Math.max(-0x80000000, Math.min(0x7fffffff, Math.trunc(signed))) | 0;
+}
+/**
+ * The variables a request with a method sends: the innermost scope's
+ * object's, as for..in lists them, each as a string; one whose getter
+ * throws is "undefined", as Ruffle has it.
+ */
+function formOf(cx, flags, version) {
+    const method = flags & METHOD_MASK;
+    if (method === 0) {
+        return null;
+    }
+    const object = cx.scope.object;
+    const vars = [];
+    for (const name of keys(object, version)) {
+        let text;
+        try {
+            text = stringOf(get(object, name, version), version);
+        }
+        catch (error) {
+            if (!(error instanceof Avm1Throw)) {
+                throw error;
+            }
+            text = "undefined";
+        }
+        vars.push([name, text]);
+    }
+    return { method: method === 1 ? "GET" : "POST", vars };
+}
+/**
+ * GetURL: `FSCommand:` to the host's fscommand, the target the arguments;
+ * a target `_levelN` loads the URL into that level, or with an empty one
+ * unloads it, nothing where N is no number; any other target is a window
+ * the page opens in.
+ */
+export function getUrl(cx, url, target) {
+    if (target.startsWith("_level") && target.length > 6) {
+        const level = levelInt(target.slice(6));
+        if (level !== null) {
+            cx.host.loadMovie?.(level, url, null);
+        }
+        return;
+    }
+    const command = fsCommandOf(url);
+    if (command !== null) {
+        cx.host.fsCommand?.(command, target);
+        return;
+    }
+    cx.host.navigate?.(url, windowOf(target), null);
+}
+/**
+ * MovieClip.getURL(url, window, method), from the code `cx` runs:
+ * `FSCommand:` as GetURL's, the window the arguments; else the page, with
+ * the scope's variables where the method is "GET" or "POST" in any case.
+ */
+export function getUrlMethod(cx, args, version) {
+    if (args.length === 0) {
+        return;
+    }
+    const url = stringOf(args[0], version);
+    const command = fsCommandOf(url);
+    if (command !== null) {
+        cx.host.fsCommand?.(command, stringOf(args[1], version));
+        return;
+    }
+    const window = args.length > 1 ? stringOf(args[1], version) : "";
+    const method = typeof args[2] === "string" ? args[2].toLowerCase() : "";
+    const flags = method === "get" ? 1 : method === "post" ? 2 : 0;
+    cx.host.navigate?.(url, windowOf(window), formOf(cx, flags, version));
+}
+/**
+ * GetURL2, its target popped first and converted first: `FSCommand:` as
+ * GetURL's; else by its flags, loadVariables into a clip or a level (or,
+ * named by a path but not the root, a page after all), loadMovie into a
+ * clip or a level, loadMovieNum into a level the target names, or the page
+ * a window opens; those of a method send the scope's variables, but
+ * loadMovieNum and a page without one.
+ */
+export function getUrl2(cx, targetValue, urlValue, flags, version) {
+    const target = stringOf(targetValue, version);
+    const url = stringOf(urlValue, version);
+    const command = fsCommandOf(url);
+    if (command !== null) {
+        cx.host.fsCommand?.(command, target);
+        return;
+    }
+    let level = -1;
+    if (target.startsWith("_level")) {
+        level = levelFloat(target.slice(6)) ?? (target.length === 6 ? 0 : -1);
+    }
+    const loadVariables = (flags & LOAD_VARIABLES) !== 0;
+    const loadTarget = (flags & LOAD_TARGET) !== 0;
+    let clip = null;
+    if (level > -1) {
+        clip = levelClip(cx, level);
+    }
+    else if (loadVariables || loadTarget) {
+        clip = clipOf(cx, targetValue, version);
+    }
+    if (loadVariables) {
+        let into = loadTarget || level > -1;
+        // A path's clip that is not the root is a page to open.
+        if (!into && targetValue instanceof Avm1Object && clip !== null) {
+            into = clip === rootClip(cx);
+        }
+        if (into) {
+            if (clip !== null) {
+                cx.host.loadVariables?.(clip, url, formOf(cx, flags, version));
+            }
+            return;
+        }
+    }
+    else if (loadTarget) {
+        if (url === "") {
+            if (clip !== null) {
+                cx.host.loadMovie?.(clip, "", null);
+            }
+        }
+        else if (clip !== null || level > -1) {
+            cx.host.loadMovie?.(clip ?? level, url, formOf(cx, flags, version));
+        }
+        return;
+    }
+    else if (level > -1) {
+        cx.host.loadMovie?.(clip ?? level, url, null);
+        return;
+    }
+    cx.host.navigate?.(url, windowOf(target), formOf(cx, flags, version));
+}
+/** The clip of level `level`, null where there is none yet. */
+function levelClip(cx, level) {
+    const object = cx.host.level?.(level);
+    return object instanceof Avm1Object ? (cx.host.clipOf?.(object) ?? null) : null;
+}
+function rootClip(cx) {
+    const root = cx.host.root?.(cx.base);
+    return root instanceof Avm1Object ? (cx.host.clipOf?.(root) ?? null) : null;
+}
+/** The clip a target names: a clip's object itself, none for any other object, else its path from the target. */
+function clipOf(cx, value, version) {
+    if (value instanceof Avm1Object) {
+        return cx.host.clipOf?.(value) ?? null;
+    }
+    return pathTarget(cx, targetOrRoot(cx), stringOf(value, version), version);
+}

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

@@ -0,0 +1,97 @@
+// AVM1's values and their conversions, by the version of the SWF whose
+// code converts them, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/value.rs has them (as_bool, coerce_to_f64,
+// coerce_to_string, to_primitive): MIT OR Apache-2.0, Copyright (c)
+// 2018-2022 Ruffle LLC and Ruffle contributors.
+import { NotYet } from "./errors.js";
+import { numberToString, stringToNumber } from "./numbers.js";
+const notYet = (what) => () => {
+    throw new NotYet(what);
+};
+export const objects = {
+    valueOf: notYet("valueOf of an object"),
+    toPrimitive: notYet("an object to a primitive"),
+    toString: notYet("toString of an object"),
+    typeOf: notYet("typeof of an object"),
+};
+export const isPrimitive = (value) => value === null || (typeof value !== "object" && typeof value !== "function");
+/**
+ * A value as a condition: a string by its number up to SWF 6 ("0" and "a"
+ * are false), by its length from SWF 7; an object is true.
+ */
+export function toBoolean(value, version) {
+    switch (typeof value) {
+        case "boolean":
+            return value;
+        case "number":
+            return value !== 0 && !Number.isNaN(value);
+        case "string": {
+            if (version >= 7) {
+                return value.length > 0;
+            }
+            const n = stringToNumber(value, version);
+            return n !== 0 && !Number.isNaN(n);
+        }
+        case "undefined":
+            return false;
+        default:
+            return value !== null;
+    }
+}
+/**
+ * A primitive as a number: undefined and null are 0 up to SWF 6 and NaN
+ * from 7, and an object a `valueOf` left is 0 up to SWF 4 and NaN after.
+ */
+export function primitiveToNumber(value, version) {
+    switch (typeof value) {
+        case "number":
+            return value;
+        case "boolean":
+            return value ? 1 : 0;
+        case "string":
+            return stringToNumber(value, version);
+        case "undefined":
+            return version < 7 ? 0 : Number.NaN;
+        default:
+            if (value === null) {
+                return version < 7 ? 0 : Number.NaN;
+            }
+            return version < 5 ? 0 : Number.NaN;
+    }
+}
+/** A value as a number, an object by its `valueOf`. */
+export function toNumber(value, version) {
+    return isPrimitive(value)
+        ? primitiveToNumber(value, version)
+        : primitiveToNumber(objects.valueOf(value, version), version);
+}
+/** A value as a string: undefined is "" up to SWF 6, and a boolean 1 or 0 up to SWF 4. */
+export function stringOf(value, version) {
+    switch (typeof value) {
+        case "undefined":
+            return version >= 7 ? "undefined" : "";
+        case "boolean":
+            if (version < 5) {
+                return value ? "1" : "0";
+            }
+            return value ? "true" : "false";
+        case "number":
+            return numberToString(value);
+        case "string":
+            return value;
+        default:
+            return value === null ? "null" : objects.toString(value, version);
+    }
+}
+/** `typeof`, the same in every version. */
+export function typeOf(value) {
+    switch (typeof value) {
+        case "undefined":
+        case "number":
+        case "boolean":
+        case "string":
+            return typeof value;
+        default:
+            return value === null ? "null" : objects.typeOf(value);
+    }
+}