@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/runtime/avm2/enumeration.js

@@ -0,0 +1,393 @@
+// What a for-in goes through, as avmplus' nextNameIndex: an Array's or a
+// Vector's elements by index up to their length at each step, then the
+// object's other names, each kept in a slot for as long as it is there, as
+// in avmplus' hashtable, so that names come and go during a for-in without
+// moving the others.
+import { DictionaryKeys } from "./dictionary-keys.js";
+import { GONE } from "./dynamic-properties.js";
+import { Namespace } from "./names.js";
+import { FloatVector } from "./natives/float-vector.js";
+/**
+ * How many Arrays keep sparse indices, across runtimes, so that a for-in
+ * over a dense one, as nearly all are, never looks for them. One collected
+ * while it keeps them, its for-in left off, is never taken off: then they
+ * are looked for, as before.
+ */
+let sparseKept = 0;
+/**
+ * The Array whose sparse indices a for-in last took or went on by, and
+ * those, so that each of its steps past a gap finds them without a lookup
+ * in the WeakMap. Let go when they are dropped; until then held, as
+ * lastStep holds its object.
+ */
+let sparseOwner = null;
+let ownerSparse = null;
+/** Drop the sparse indices `o` keeps, if any: its for-in is over, or another starts. */
+function dropSparse(enumerating, o) {
+    if (sparseKept === 0) {
+        return;
+    }
+    const e = enumerating.get(o);
+    if (e?.sparse !== undefined) {
+        e.sparse = undefined;
+        sparseKept--;
+    }
+    if (o === sparseOwner) {
+        sparseOwner = null;
+        ownerSparse = null;
+    }
+}
+/** The names below this come back from a for-in as numbers: avmplus' int atoms, of 29 bits. */
+export const INT_ATOM_LIMIT = 0x10000000;
+/** An object's own names, its elements' included, then its dynamic properties' and a Dictionary's keys. */
+export function ownNames(o) {
+    const names = [];
+    if (o.$a instanceof FloatVector) {
+        for (let i = 0; i < o.$a.length; i++) {
+            names.push(String(i));
+        }
+    }
+    else if (o.$a !== undefined) {
+        for (const i of Object.keys(o.$a)) {
+            names.push(i);
+        }
+    }
+    if (o.$d) {
+        names.push(...o.$d.keys());
+    }
+    if (o.$keys !== undefined) {
+        for (const k of o.$keys.keys()) {
+            names.push(k);
+        }
+    }
+    return names;
+}
+/**
+ * The name of `o`, not a Dictionary, at a for-in's index among the names
+ * past its elements, the index less their length.
+ */
+export function enumerated(o, at, index) {
+    // The slots the step itself went through, without looking them up again.
+    const walk = o === lastStep.o && index === lastStep.index && lastStep.walk !== null
+        ? lastStep.walk
+        : walkOf(o);
+    return walk?.slots[at - 1] ?? "";
+}
+function walkOf(o) {
+    const d = o.$d;
+    return d ? d.walk : null;
+}
+/**
+ * The index after `index` of an enumerable name of `o`, or 0. As avmplus'
+ * ArrayObject and TypedVectorObject, the elements come first, by their
+ * length at each step, not when the for-in started, so it goes on through
+ * those pushed or filled in during it; then the other names, whose indices
+ * come after the elements' length, which moves them if it changes then.
+ */
+export function nextIndex(enumerating, o, index) {
+    // An object without elements never gains them: past its first step, no need to look again.
+    const known = o === lastStep.o && index === lastStep.index;
+    const a = known && lastStep.none ? undefined : o.$a;
+    if (!known) {
+        lastStep.walk = null;
+        if (a !== undefined) {
+            // Not the keys of a Dictionary whose for-in was left off.
+            lastStep.keys = null;
+        }
+    }
+    const next = a === undefined
+        ? nextOfNames(o, index, known)
+        : nextOfElements(enumerating, o, a, index, known);
+    if (next === 0) {
+        lastStep.o = null;
+        lastStep.keys = null;
+        lastStep.walk = null;
+    }
+    else {
+        lastStep.o = o;
+        lastStep.index = next;
+        lastStep.none = a === undefined;
+    }
+    return next;
+}
+/**
+ * As nextIndex, over an object without elements: a Dictionary by its keys,
+ * any other by the names of its dynamic properties.
+ */
+function nextOfNames(o, index, known) {
+    // One is a Dictionary or not for good: past its first step, no need to look again.
+    const keys = known ? lastStep.keys : dictionaryKeys(o);
+    lastStep.keys = keys;
+    return keys !== null ? keys.next(o, index) : nextNameIndex(o, index, index === 0, known);
+}
+function dictionaryKeys(o) {
+    const keys = o?.$keys;
+    return keys instanceof DictionaryKeys ? keys : null;
+}
+/**
+ * The keys of Dictionary `o` at a for-in's index, which hold its names and
+ * values there; null for any other object.
+ */
+export function dictionaryAt(o, index) {
+    return o === lastStep.o && index === lastStep.index ? lastStep.keys : dictionaryKeys(o);
+}
+/**
+ * The step a for-in last took: the object, the index it gave, whether the
+ * object has no elements and its keys if a Dictionary, so that the next
+ * step and the nextName and nextValue right after it need not look for
+ * them again, which misses, at a cost, on the many objects that have
+ * neither, and never gain any. Let go when a for-in ends.
+ */
+const lastStep = {
+    o: null,
+    index: 0,
+    none: false,
+    keys: null,
+    walk: null,
+};
+/**
+ * Whether a for-in's step over `o` at `index` goes on from the last one
+ * nextIndex gave, so that `o` is an ordinary object: no hook, no QName.
+ */
+export function continues(o, index) {
+    return o === lastStep.o && index === lastStep.index;
+}
+/** The length of the elements of `o` at a for-in's index: where those end and its other names start. */
+export function elementsAt(o, index) {
+    if (o === lastStep.o && index === lastStep.index && lastStep.none) {
+        return 0;
+    }
+    return o?.$a?.length ?? 0;
+}
+/** As nextIndex, over an object with elements. */
+function nextOfElements(enumerating, o, a, index, known) {
+    if (index === 0) {
+        dropSparse(enumerating, o);
+        walkOf(o)?.freeDeleted();
+    }
+    const length = a.length;
+    if (index < length) {
+        const i = nextElement(enumerating, o, a, index);
+        if (i >= 0) {
+            return i + 1;
+        }
+    }
+    const at = Math.max(index - length, 0);
+    // An Array that has never had other names needs no list of them.
+    const next = at === 0 && !o.$d?.size ? 0 : nextNameIndex(o, at, false, known);
+    if (next === 0) {
+        // The for-in is over: its indices go with it.
+        dropSparse(enumerating, o);
+        return 0;
+    }
+    return length + next;
+}
+/** After this many holes in a row, the next element is found by an Array's indices, so that a sparse one stays cheap. */
+const HOLE_SCAN_LIMIT = 16;
+/** The first element of `o` at or after `from`, or -1. */
+function nextElement(enumerating, o, a, from) {
+    const length = a.length;
+    if (a instanceof FloatVector) {
+        return from < length ? from : -1;
+    }
+    if (enumerable(o, a, from)) {
+        return from;
+    }
+    let e;
+    if (sparseKept !== 0) {
+        if (o === sparseOwner) {
+            return nextSparse(o, a, ownerSparse, from);
+        }
+        e = enumerating.get(o);
+        if (e?.sparse !== undefined) {
+            sparseOwner = o;
+            ownerSparse = e.sparse;
+            return nextSparse(o, a, e.sparse, from);
+        }
+    }
+    // From the hole at `from`, up to HOLE_SCAN_LIMIT of them one by one.
+    const scanned = Math.min(length, from + HOLE_SCAN_LIMIT);
+    for (let i = from + 1; i < scanned; i++) {
+        if (enumerable(o, a, i)) {
+            return i;
+        }
+    }
+    if (scanned === length) {
+        return -1;
+    }
+    const keeper = e ?? enumerating.get(o) ?? {};
+    enumerating.set(o, keeper);
+    sparseKept++;
+    keeper.sparse = {
+        indices: indicesOf(a, 0),
+        length,
+        at: -1,
+        given: -1,
+        sinceTaken: 0,
+        retaken: false,
+    };
+    sparseOwner = o;
+    ownerSparse = keeper.sparse;
+    return nextSparse(o, a, keeper.sparse, scanned);
+}
+/**
+ * The first element of `o` at or after `from` by its indices, brought up to
+ * a length grown or shrunk since. One of them gone was deleted, or moved by
+ * a reorder such as reverse: the first time, and then once as many have
+ * been given since as a sixteenth of them, they are taken again, so that
+ * one moved is found; between, those gone are passed over, so that a for-in
+ * deleting ahead of itself stays linear. As in avmplus' hashtable, which a
+ * sparse Array keeps its elements in, one moved may then be missed.
+ */
+function nextSparse(o, a, sparse, from) {
+    const length = a.length;
+    if (length > sparse.length) {
+        if (length - sparse.length <= HOLE_SCAN_LIMIT * HOLE_SCAN_LIMIT) {
+            for (let i = sparse.length; i < length; i++) {
+                if (i in a) {
+                    sparse.indices.push(i);
+                }
+            }
+        }
+        else {
+            // Appended one by one: spread as arguments, many would overflow the stack.
+            indicesOf(a, sparse.length, sparse.indices);
+        }
+        sparse.length = length;
+    }
+    else if (length < sparse.length) {
+        retake(a, sparse);
+    }
+    let j = sparse.given === from - 1 ? sparse.at + 1 : firstAtOrAfter(sparse.indices, from);
+    while (j < sparse.indices.length) {
+        const i = sparse.indices[j];
+        if (enumerable(o, a, i)) {
+            sparse.at = j;
+            sparse.given = i;
+            sparse.sinceTaken++;
+            return i;
+        }
+        if (!sparse.retaken || sparse.sinceTaken * 16 >= sparse.indices.length) {
+            retake(a, sparse);
+            sparse.retaken = true;
+            j = firstAtOrAfter(sparse.indices, from);
+        }
+        else {
+            j++;
+        }
+    }
+    return -1;
+}
+/** Take a sparse Array's indices again. */
+function retake(a, sparse) {
+    sparse.indices = indicesOf(a, 0);
+    sparse.length = a.length;
+    sparse.at = -1;
+    sparse.given = -1;
+    sparse.sinceTaken = 0;
+}
+/** An Array's indices from `from` on, in order, as Object.keys gives them, appended to `indices`. */
+function indicesOf(a, from, indices = []) {
+    for (const k of Object.keys(a)) {
+        const i = Number(k);
+        if (i >= from) {
+            indices.push(i);
+        }
+    }
+    return indices;
+}
+/** Where in `indices`, in order, the first at or after `from` is. */
+function firstAtOrAfter(indices, from) {
+    let low = 0;
+    let high = indices.length;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (indices[mid] < from) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return low;
+}
+function enumerable(o, a, i) {
+    return i in a && !o.$dontEnum?.has(String(i));
+}
+/**
+ * The index after `index` among the names of `o` but its elements, or 0,
+ * `starting` a for-in over it.
+ */
+function nextNameIndex(o, index, starting, known) {
+    // As the prototypes a for-in goes on to, whose methods are all hidden:
+    // nothing to go through, and no slots to keep for it.
+    if (index === 0 && !anyEnumerable(o)) {
+        return 0;
+    }
+    const walk = index === 0
+        ? o.$d.startWalk(starting)
+        : known && lastStep.walk !== null
+            ? lastStep.walk
+            : walkOf(o);
+    lastStep.walk = walk;
+    if (walk === null) {
+        return 0;
+    }
+    // A name deleted since the for-in started is passed over.
+    const slots = walk.slots;
+    const live = walk.live;
+    for (let i = index; i < slots.length; i++) {
+        if (live[i] !== GONE && !o.$dontEnum?.has(slots[i])) {
+            return i + 1;
+        }
+    }
+    return 0;
+}
+/**
+ * Whether prototype `p` has nothing a for-in goes through, as most have:
+ * no names but hidden methods, no elements, keys or hook. Then a for-in
+ * passes over it with nothing to set up, as one starting over it does
+ * nothing, but for an Array's, whose start frees its deleted names'
+ * slots: one that has kept slots is left to that.
+ */
+export function walkless(p) {
+    const d = p.$d;
+    if (d === null || d === undefined || (d.size !== 0 && !d.allHidden)) {
+        return false;
+    }
+    const a = p.$a;
+    return ((a === undefined || (a.length === 0 && d.walk === null)) &&
+        p.$keys === undefined &&
+        p.$local === undefined &&
+        !p.$traits?.properties);
+}
+/** Whether any dynamic property of `o` is not hidden. */
+function anyEnumerable(o) {
+    const d = o.$d;
+    if (!d?.size || d.allHidden) {
+        return false;
+    }
+    // Fewer hidden than there are names leaves one shown, whatever else is hidden.
+    const hidden = o.$dontEnum;
+    if (hidden === undefined || hidden.size < d.size) {
+        return true;
+    }
+    for (const name of d.keys()) {
+        if (!hidden.has(name)) {
+            return true;
+        }
+    }
+    d.allHidden = true;
+    return false;
+}
+/**
+ * A Namespace or QName, which enumerate "uri" and the name this gives
+ * ("prefix" or "localName"), as avmplus' nextName does; else null.
+ */
+export function pairOf(o) {
+    if (o instanceof Namespace) {
+        return "prefix";
+    }
+    return typeof o === "object" && o !== null && o.$local !== undefined ? "localName" : null;
+}
+export const pairIndex = (index) => (index < 2 ? index + 1 : 0);

package/dist/thread/runtime/avm2/errors.js

@@ -0,0 +1,45 @@
+// What the runtime's errors say: their messages, the number alone or, in
+// debugger mode, its text, as avmplus words them; how a value is named in
+// one; and where an AS3 error was made, for a host to show.
+import { FloatValue } from "./float.js";
+import { Namespace } from "./names.js";
+import { errorMessages } from "./player-messages.js";
+/** Thrown for an AS3 exception that is an Error the runtime made, before its class existed. */
+export class AsError extends Error {
+}
+/**
+ * Where an AS3 error was made, as JavaScript stack lines from the first
+ * compiled method's (their names begin with `$`), the runtime's and the
+ * player's frames before it left out, those between kept; every line if
+ * no compiled method made it, and null for anything but an AS3 error.
+ */
+export function stackOf(error) {
+    const made = error?.$jsError;
+    if (!(made instanceof Error) || !made.stack) {
+        return null;
+    }
+    // V8 heads its stack with the error's own line; other engines give frames alone, `name@url`.
+    const frames = made.stack.split("\n").filter((line) => !/^Error\b/.test(line));
+    const first = frames.findIndex((line) => /^(?:\s*at (?:[\w$]+\.)?)?\$[\w$]/.test(line));
+    return frames.slice(Math.max(0, first)).join("\n");
+}
+/**
+ * Error `id`'s message as AS3 sees it: its number, as the release player
+ * and avmshell give it, or with its text and arguments in debugger mode.
+ */
+export function errorMessage(debuggerMode, id, args) {
+    if (!debuggerMode) {
+        return `Error #${id}`;
+    }
+    const template = errorMessages[id] ?? "";
+    const text = template.replace(/%(\d)/g, (_, n) => String(args[Number(n) - 1] ?? ""));
+    return `Error #${id}: ${text}`;
+}
+/** A value as avmplus names it in an error message. */
+export function describe(rt, v) {
+    if (v === null || typeof v !== "object" || v instanceof FloatValue || v instanceof Namespace) {
+        return rt.toString(v);
+    }
+    const name = v.$traits.name;
+    return `${name.slice(name.lastIndexOf("::") + (name.includes("::") ? 2 : 0))}@0`;
+}

package/dist/thread/runtime/avm2/float-library.js

@@ -0,0 +1,66 @@
+// Generated from as3/builtin/src/float.as by tests/libraries/float.ts.
+// Load after builtin.abc, as a builtin, to expose AIR's scalar float type.
+// biome-ignore format: preserve the generated byte table.
+export const floatLibrary = new Uint8Array([
+    16, 0, 46, 0, 4, 1, 10, 0, 0, 0, 65, 6, 108, 101, 110, 103, 116, 104, 0, 3, 105, 110, 116, 9,
+    77, 65, 88, 95, 86, 65, 76, 85, 69, 5, 102, 108, 111, 97, 116, 9, 77, 73, 78, 95, 86, 65, 76, 85,
+    69, 3, 78, 97, 78, 17, 80, 79, 83, 73, 84, 73, 86, 69, 95, 73, 78, 70, 73, 78, 73, 84, 89, 17,
+    78, 69, 71, 65, 84, 73, 86, 69, 95, 73, 78, 70, 73, 78, 73, 84, 89, 1, 69, 4, 76, 78, 49, 48,
+    3, 76, 78, 50, 5, 76, 79, 71, 50, 69, 2, 80, 73, 7, 83, 81, 82, 84, 49, 95, 50, 5, 83, 81,
+    82, 84, 50, 3, 97, 98, 115, 4, 97, 99, 111, 115, 4, 97, 115, 105, 110, 4, 97, 116, 97, 110, 4, 99,
+    101, 105, 108, 3, 99, 111, 115, 3, 101, 120, 112, 5, 102, 108, 111, 111, 114, 3, 108, 111, 103, 5, 114, 111,
+    117, 110, 100, 3, 115, 105, 110, 4, 115, 113, 114, 116, 3, 116, 97, 110, 5, 97, 116, 97, 110, 50, 3, 112,
+    111, 119, 3, 109, 97, 120, 3, 109, 105, 110, 6, 114, 97, 110, 100, 111, 109, 10, 114, 101, 99, 105, 112, 114,
+    111, 99, 97, 108, 5, 114, 115, 113, 114, 116, 9, 95, 116, 111, 83, 116, 114, 105, 110, 103, 8, 95, 116, 111,
+    70, 105, 120, 101, 100, 14, 95, 116, 111, 69, 120, 112, 111, 110, 101, 110, 116, 105, 97, 108, 12, 95, 116, 111,
+    80, 114, 101, 99, 105, 115, 105, 111, 110, 7, 118, 97, 108, 117, 101, 79, 102, 33, 104, 116, 116, 112, 58, 47,
+    47, 97, 100, 111, 98, 101, 46, 99, 111, 109, 47, 65, 83, 51, 47, 50, 48, 48, 54, 47, 98, 117, 105, 108,
+    116, 105, 110, 8, 116, 111, 83, 116, 114, 105, 110, 103, 7, 116, 111, 70, 105, 120, 101, 100, 13, 116, 111, 69,
+    120, 112, 111, 110, 101, 110, 116, 105, 97, 108, 11, 116, 111, 80, 114, 101, 99, 105, 115, 105, 111, 110, 6, 79,
+    98, 106, 101, 99, 116, 6, 83, 116, 114, 105, 110, 103, 5, 114, 97, 100, 105, 120, 14, 102, 114, 97, 99, 116,
+    105, 111, 110, 68, 105, 103, 105, 116, 115, 9, 112, 114, 101, 99, 105, 115, 105, 111, 110, 20, 102, 108, 111, 97,
+    116, 46, 97, 115, 36, 48, 58, 97, 110, 111, 110, 121, 109, 111, 117, 115, 20, 102, 108, 111, 97, 116, 46, 97,
+    115, 36, 49, 58, 97, 110, 111, 110, 121, 109, 111, 117, 115, 20, 102, 108, 111, 97, 116, 46, 97, 115, 36, 50,
+    58, 97, 110, 111, 110, 121, 109, 111, 117, 115, 20, 102, 108, 111, 97, 116, 46, 97, 115, 36, 51, 58, 97, 110,
+    111, 110, 121, 109, 111, 117, 115, 20, 102, 108, 111, 97, 116, 46, 97, 115, 36, 52, 58, 97, 110, 111, 110, 121,
+    109, 111, 117, 115, 5, 118, 97, 108, 117, 101, 9, 112, 114, 111, 116, 111, 116, 121, 112, 101, 19, 70, 105, 108,
+    101, 80, 114, 105, 118, 97, 116, 101, 78, 83, 58, 102, 108, 111, 97, 116, 14, 116, 111, 76, 111, 99, 97, 108,
+    101, 83, 116, 114, 105, 110, 103, 1, 120, 1, 121, 6, 100, 105, 103, 105, 116, 115, 3, 238, 138, 148, 8, 22,
+    64, 5, 5, 8, 42, 26, 5, 26, 47, 23, 2, 5, 59, 2, 6, 2, 4, 5, 1, 6, 7, 54, 7, 1,
+    1, 7, 1, 3, 7, 1, 4, 7, 1, 5, 7, 1, 6, 7, 1, 7, 7, 1, 8, 7, 1, 9, 7, 1,
+    10, 7, 1, 11, 7, 1, 12, 7, 1, 13, 7, 1, 14, 7, 1, 15, 7, 1, 16, 7, 1, 17, 7, 1,
+    18, 7, 1, 19, 7, 1, 20, 7, 1, 21, 7, 1, 22, 7, 1, 23, 7, 1, 24, 7, 1, 25, 7, 1,
+    26, 7, 1, 27, 7, 1, 28, 7, 1, 29, 7, 1, 30, 7, 1, 31, 7, 1, 32, 7, 1, 33, 7, 1,
+    34, 7, 1, 35, 7, 1, 36, 7, 2, 37, 7, 2, 38, 7, 2, 39, 7, 2, 40, 7, 3, 41, 7, 3,
+    43, 7, 3, 44, 7, 3, 45, 7, 3, 46, 7, 1, 47, 7, 1, 48, 9, 58, 1, 9, 41, 1, 9, 43,
+    1, 9, 60, 1, 9, 44, 1, 9, 45, 1, 9, 46, 1, 37, 0, 0, 0, 0, 1, 4, 4, 17, 160, 61,
+    1, 4, 4, 18, 160, 61, 1, 4, 4, 19, 160, 61, 1, 4, 4, 20, 160, 61, 1, 4, 4, 21, 160, 61,
+    1, 4, 4, 22, 160, 61, 1, 4, 4, 23, 160, 61, 1, 4, 4, 24, 160, 61, 1, 4, 4, 25, 160, 61,
+    1, 4, 4, 26, 160, 61, 1, 4, 4, 27, 160, 61, 1, 4, 4, 28, 160, 61, 1, 4, 4, 29, 160, 61,
+    2, 4, 4, 4, 30, 160, 62, 61, 2, 4, 4, 4, 31, 160, 61, 62, 0, 4, 32, 164, 0, 4, 33, 164,
+    0, 4, 34, 32, 1, 4, 4, 35, 160, 61, 1, 4, 4, 36, 160, 61, 0, 0, 0, 0, 0, 4, 52, 0,
+    1, 46, 0, 53, 8, 1, 2, 3, 1, 46, 0, 54, 8, 1, 3, 3, 1, 46, 0, 55, 8, 1, 3, 3,
+    1, 46, 0, 56, 8, 1, 3, 3, 0, 4, 41, 0, 1, 46, 0, 43, 136, 1, 2, 3, 49, 1, 46, 0,
+    44, 136, 1, 3, 3, 50, 1, 46, 0, 45, 136, 1, 3, 3, 50, 1, 46, 0, 46, 136, 1, 3, 3, 51,
+    2, 46, 4, 0, 37, 160, 57, 49, 2, 46, 4, 0, 38, 160, 57, 63, 2, 46, 4, 0, 39, 160, 57, 63,
+    2, 46, 4, 0, 40, 160, 57, 63, 1, 0, 0, 5, 136, 1, 3, 3, 57, 0, 1, 4, 45, 3, 0, 36,
+    5, 40, 1, 0, 27, 41, 1, 0, 28, 42, 1, 0, 29, 43, 1, 0, 30, 44, 1, 0, 31, 21, 37, 1,
+    6, 0, 2, 1, 3, 3, 6, 0, 4, 0, 5, 6, 0, 4, 0, 6, 6, 0, 4, 0, 7, 6, 0, 4,
+    0, 8, 6, 0, 4, 0, 9, 6, 0, 4, 0, 10, 6, 0, 4, 0, 11, 6, 0, 4, 0, 12, 6, 0,
+    4, 0, 13, 6, 0, 4, 0, 14, 6, 0, 4, 0, 15, 6, 0, 4, 0, 16, 1, 0, 1, 17, 1, 0,
+    2, 18, 1, 0, 3, 19, 1, 0, 4, 20, 1, 0, 5, 21, 1, 0, 6, 22, 1, 0, 7, 23, 1, 0,
+    8, 24, 1, 0, 9, 25, 1, 0, 10, 26, 1, 0, 11, 27, 1, 0, 12, 28, 1, 0, 13, 29, 1, 0,
+    14, 30, 1, 0, 15, 31, 1, 0, 16, 32, 1, 0, 17, 33, 1, 0, 18, 34, 1, 0, 19, 35, 1, 0,
+    20, 36, 1, 0, 32, 37, 1, 0, 33, 38, 1, 0, 34, 39, 1, 0, 35, 1, 0, 1, 4, 4, 0, 0,
+    13, 27, 1, 1, 0, 1, 4, 208, 48, 208, 72, 0, 0, 28, 3, 2, 0, 1, 10, 208, 48, 93, 36, 208,
+    209, 70, 36, 2, 72, 0, 0, 29, 3, 2, 0, 1, 10, 208, 48, 93, 37, 208, 209, 70, 37, 2, 72, 0,
+    0, 30, 3, 2, 0, 1, 10, 208, 48, 93, 38, 208, 209, 70, 38, 2, 72, 0, 0, 31, 3, 2, 0, 1,
+    10, 208, 48, 93, 39, 208, 209, 70, 39, 2, 72, 0, 0, 22, 3, 1, 0, 0, 6, 208, 208, 208, 65, 1,
+    72, 0, 0, 23, 4, 2, 0, 0, 12, 93, 36, 208, 208, 208, 65, 1, 209, 70, 36, 2, 72, 0, 0, 24,
+    4, 2, 0, 0, 12, 93, 37, 208, 208, 208, 65, 1, 209, 70, 37, 2, 72, 0, 0, 25, 4, 2, 0, 0,
+    12, 93, 38, 208, 208, 208, 65, 1, 209, 70, 38, 2, 72, 0, 0, 26, 4, 2, 0, 0, 12, 93, 39, 208,
+    208, 208, 65, 1, 209, 70, 39, 2, 72, 0, 0, 36, 1, 2, 0, 1, 6, 208, 48, 208, 73, 0, 71, 0,
+    0, 21, 2, 1, 0, 1, 41, 208, 48, 96, 47, 64, 22, 97, 48, 96, 47, 64, 23, 97, 49, 96, 47, 96,
+    47, 102, 49, 97, 50, 96, 47, 64, 24, 97, 51, 96, 47, 64, 25, 97, 52, 96, 47, 64, 26, 97, 53, 71,
+    0, 0, 0, 3, 1, 0, 2, 14, 208, 48, 101, 0, 96, 45, 42, 48, 88, 0, 29, 104, 4, 71, 0, 0,
+]);

package/dist/thread/runtime/avm2/float.js

@@ -0,0 +1,26 @@
+import { floatLibrary } from "./float-library.js";
+// A scalar float keeps its identity when it escapes into a dynamic value.
+// Its numeric payload is rounded only when a float is produced.
+export class FloatValue {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    valueOf() {
+        return this.value;
+    }
+}
+const ZERO = new FloatValue(0);
+const NEGATIVE_ZERO = new FloatValue(-0);
+const NAN = new FloatValue(NaN);
+export function floatValue(value) {
+    const rounded = Math.fround(value);
+    if (rounded === 0) {
+        return Object.is(rounded, -0) ? NEGATIVE_ZERO : ZERO;
+    }
+    return Number.isNaN(rounded) ? NAN : new FloatValue(rounded);
+}
+/** Whether a caller already supplied the scalar float builtin. */
+export function hasFloatLibrary(abcs) {
+    return abcs.some((abc) => abc.length === floatLibrary.length && abc.every((byte, i) => byte === floatLibrary[i]));
+}

package/dist/thread/runtime/avm2/hooks.js

@@ -0,0 +1,19 @@
+// What the natives and a player plug into the runtime for the builtin
+// classes that differ from others: how they allocate, index, resolve
+// names, and are called and constructed.
+import { NS_Public } from "./names.js";
+import { BIND_Method } from "./traits.js";
+/**
+ * Whether a hooked class's hook resolves `mn`, bound to `b`: a name its
+ * traits do not bind, an attribute's, or a public name of a method, as a
+ * child or attribute of XML hides the methods of its names (as avmplus'
+ * getproperty does for XML and XMLList).
+ */
+export function hookedBinding(b, mn, hook) {
+    if (b === 0 || mn.attribute) {
+        return true;
+    }
+    return (hook.hidesMethods &&
+        (b & 7) === BIND_Method &&
+        mn.namespaces.some((ns) => ns?.kind === NS_Public && ns.uri === ""));
+}

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

@@ -0,0 +1,38 @@
+// The AVM2 runtime: what generated modules call as `rt`.
+import { builtinHooks, builtinNatives } from "./natives/index.js";
+import { Runtime } from "./runtime.js";
+export { Reader as Amf3Reader, Writer as Amf3Writer } from "./amf.js";
+/** avmplus' builtin.abc (MPL-2.0), which every runtime loads first. */
+export { builtinLibrary } from "./builtin-library.js";
+export { frameScripts, frameSites, siteScript, stackFrames } from "./domain.js";
+export { FloatValue, hasFloatLibrary } from "./float.js";
+export { floatLibrary } from "./float-library.js";
+export { messages } from "./messages.js";
+export { publicNs, qname } from "./names.js";
+export { Bytes, byteArrayHook, bytesOf, canShareMemory, GLOBAL_MEMORY_MIN_SIZE, notIsolated, setDomainMemory, shareBytes, sharedByteArray, } from "./natives/bytearray.js";
+export { syncError, syncObject, syncOf, syncRef, } from "./natives/concurrent.js";
+export { plain, registerNativeClass } from "./natives/define.js";
+// The builtins' natives and hooks, for a player that adds playerglobal's to them.
+export { builtinHooks, builtinNatives } from "./natives/index.js";
+export { endShellWorker, shellWorkerTerminated, startShellWorker, } from "./natives/shell-workers.js";
+export { newSyncMemory, SCRIPT_TIMEOUT, Sync, SyncFull, SyncTerminated, SyncTimeout, } from "./natives/sync.js";
+// avmplus' XML tokenizer, which playerglobal's flash.xml.XMLDocument parses with too.
+export { XMLParser, XMLTag } from "./natives/xml/parser.js";
+export { errorMessages } from "./player-messages.js";
+// A destroyed host must not remain reachable through shared inline-cache entries.
+export { invalidate as clearPropertyCaches } from "./property-cache.js";
+export { Runtime } from "./runtime.js";
+// methodKey: where a method sits on its traits, for a player that makes a closure of its own.
+export { instanceVarField, methodKey, setStaticVar } from "./traits.js";
+/** A runtime with the builtins' natives, for modules compiled from builtin.abc and after. */
+export function createRuntime(options = {}) {
+    return new Runtime(builtinNatives, builtinHooks(), options);
+}
+/** AS3 `int(value)`: ToInt32(ToNumber(value)). */
+export function toInt(value) {
+    return Number(value) | 0;
+}
+/** AS3 `uint(value)`: ToUint32(ToNumber(value)). */
+export function toUint(value) {
+    return Number(value) >>> 0;
+}