@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,177 @@
+// Error messages of avmplus, in English, by error number.
+//
+// Generated from oracle/avmplus/core/ErrorConstants.cpp; not to be edited.
+// Derived from avmplus, this file is subject to the Mozilla Public License,
+// v. 2.0: http://mozilla.org/MPL/2.0/.
+export const messages = {
+    1000: "The system is out of memory.",
+    1001: "The method %1 is not implemented.",
+    1002: "Number.toPrecision has a range of 1 to 21. Number.toFixed and Number.toExponential have a range of 0 to 20. Specified value is not within expected range.",
+    1003: "The radix argument must be between 2 and 36; got %1.",
+    1004: "Method %1 was invoked on an incompatible object.",
+    1005: "Array index is not a positive integer (%1).",
+    1006: "%1 is not a function.",
+    1007: "Instantiation attempted on a non-constructor.",
+    1008: "%1 is ambiguous; Found more than one matching binding.",
+    1009: "Cannot access a property or method of a null object reference.",
+    1010: "A term is undefined and has no properties.",
+    1011: "Method %1 contained illegal opcode %2 at offset %3.",
+    1012: "The last instruction exceeded code size.",
+    1013: "Cannot call OP_findproperty when scopeDepth is 0.",
+    1014: "Class %1 could not be found.",
+    1015: "Method %1 cannot set default xml namespace",
+    1016: "Descendants operator (..) not supported on type %1.",
+    1017: "Scope stack overflow occurred.",
+    1018: "Scope stack underflow occurred.",
+    1019: "Getscopeobject %1 is out of bounds.",
+    1020: "Code cannot fall off the end of a method.",
+    1021: "At least one branch target was not on a valid instruction in the method.",
+    1022: "Type void may only be used as a function return type.",
+    1023: "Stack overflow occurred.",
+    1024: "Stack underflow occurred.",
+    1025: "An invalid register %1 was accessed.",
+    1026: "Slot %1 exceeds slotCount=%2 of %3.",
+    1027: "Method_info %1 exceeds method_count=%2.",
+    1028: "Disp_id %1 exceeds max_disp_id=%2 of %3.",
+    1029: "Disp_id %1 is undefined on %2.",
+    1030: "Stack depth is unbalanced. %1 != %2.",
+    1031: "Scope depth is unbalanced. %1 != %2.",
+    1032: "Cpool index %1 is out of range %2.",
+    1033: "Cpool entry %1 is wrong type.",
+    1034: "Type Coercion failed: cannot convert %1 to %2.",
+    1035: "Illegal super expression found in method %1.",
+    1037: "Cannot assign to a method %1 on %2.",
+    1038: "%1 is already defined.",
+    1039: "Cannot verify method until it is referenced.",
+    1040: "The right-hand side of instanceof must be a class or function.",
+    1041: "The right-hand side of operator must be a class.",
+    1042: "Not an ABC file.  major_version=%1 minor_version=%2.",
+    1043: "Invalid code_length=%1.",
+    1044: "MethodInfo-%1 unsupported flags=%2.",
+    1045: "Unsupported traits kind=%1.",
+    1046: "MethodInfo-%1 referenced before definition.",
+    1047: "No entry point was found.",
+    1049: "Prototype objects must be vanilla Objects.",
+    1050: "Cannot convert %1 to primitive.",
+    1051: "Illegal early binding access to %1.",
+    1052: "Invalid URI passed to %1 function.",
+    1053: "Illegal override of %1 in %2.",
+    1054: "Illegal range or target offsets in exception handler.",
+    1056: "Cannot create property %1 on %2.",
+    1057: "%1 can only contain methods.",
+    1058: "Illegal operand type: %1 must be %2.",
+    1059: "ClassInfo-%1 is referenced before definition.",
+    1060: "ClassInfo %1 exceeds class_count=%2.",
+    1061: "The value %1 cannot be converted to %2 without losing precision.",
+    1063: "Argument count mismatch on %1. Expected %2, got %3.",
+    1064: "Cannot call method %1 as constructor.",
+    1065: "Variable %1 is not defined.",
+    1066: "The form function('function body') is not supported.",
+    1067: "Native method %1 has illegal method body.",
+    1068: "%1 and %2 cannot be reconciled.",
+    1069: "Property %1 not found on %2 and there is no default value.",
+    1070: "Method %1 not found on %2",
+    1071: "Function %1 has already been bound to %2.",
+    1072: "Disp_id 0 is illegal.",
+    1073: "Non-override method %1 replaced because of duplicate disp_id %2.",
+    1074: "Illegal write to read-only property %1 on %2.",
+    1075: "Math is not a function.",
+    1076: "Math is not a constructor.",
+    1077: "Illegal read of write-only property %1 on %2.",
+    1078: "Illegal opcode/multiname combination: %1<%2>.",
+    1079: "Native methods are not allowed in loaded code.",
+    1080: "Illegal value for namespace.",
+    1081: "Property %1 not found on %2 and there is no default value.",
+    1082: "No default namespace has been set.",
+    1083: 'The prefix "%1" for element "%2" is not bound.',
+    1084: "Element or attribute (\"%1\") does not match QName production: QName::=(NCName':')?NCName.",
+    1085: 'The element type "%1" must be terminated by the matching end-tag "</%2>".',
+    1086: "The %1 method only works on lists containing one item.",
+    1087: "Assignment to indexed XML is not allowed.",
+    1088: "The markup in the document following the root element must be well-formed.",
+    1089: "Assignment to lists with more than one item is not supported.",
+    1090: "XML parser failure: element is malformed.",
+    1091: "XML parser failure: Unterminated CDATA section.",
+    1092: "XML parser failure: Unterminated XML declaration.",
+    1093: "XML parser failure: Unterminated DOCTYPE declaration.",
+    1094: "XML parser failure: Unterminated comment.",
+    1095: "XML parser failure: Unterminated attribute.",
+    1096: "XML parser failure: Unterminated element.",
+    1097: "XML parser failure: Unterminated processing instruction.",
+    1098: "Illegal prefix %1 for no namespace.",
+    1100: "Cannot supply flags when constructing one RegExp from another.",
+    1101: "Cannot verify method %1 with unknown scope.",
+    1102: "Illegal default value for type %1.",
+    1103: "Class %1 cannot extend final base class.",
+    1104: 'Attribute "%1" was already specified for element "%2".',
+    1107: "The ABC data is corrupt, attempt to read out of bounds.",
+    1108: "The OP_newclass opcode was used with the incorrect base class.",
+    1109: "Attempt to directly call unbound function %1 from method %2.",
+    1110: "%1 cannot extend %2.",
+    1111: "%1 cannot implement %2.",
+    1112: "Argument count mismatch on class coercion.  Expected 1, got %1.",
+    1113: "OP_newactivation used in method without NEED_ACTIVATION flag.",
+    1114: "OP_getglobalslot or OP_setglobalslot used with no global scope.",
+    1115: "%1 is not a constructor.",
+    1116: "second argument to Function.prototype.apply must be an array.",
+    1117: "Invalid XML name: %1.",
+    1118: "Illegal cyclical loop between nodes.",
+    1119: "Delete operator is not supported with operand of type %1.",
+    1120: "Cannot delete property %1 on %2.",
+    1121: "Method %1 has a duplicate method body.",
+    1122: "Interface method %1 has illegal method body.",
+    1123: "Filter operator not supported on type %1.",
+    1124: "OP_hasnext2 requires object and index to be distinct registers.",
+    1125: "The index %1 is out of range %2.",
+    1126: "Cannot change the length of a fixed Vector.",
+    1127: "Type application attempted on a non-parameterized type.",
+    1128: "Incorrect number of type parameters for %1. Expected %2, got %3.",
+    1129: "Cyclic structure cannot be converted to JSON string.",
+    1131: "Replacer argument to JSON stringifier must be an array or a two parameter function.",
+    1132: "Invalid JSON parse input.",
+    1500: "Error occurred opening file %1.",
+    1501: "Error occurred writing to file %1.",
+    1502: "A script has executed for longer than the default timeout period of 15 seconds.",
+    1503: "A script failed to exit after 30 seconds and was terminated.",
+    1504: "End of file.",
+    1505: "The string index %1 is out of bounds; must be in range %2 to %3.",
+    1506: "The specified range is invalid.",
+    1507: "Argument %1 cannot be null.",
+    1508: "The value specified for argument %1 is invalid.",
+    1510: "When the callback argument is a method of a class, the optional this argument must be null.",
+    1511: "Worker is already started.",
+    1512: "Starting a worker that already failed is not supported.",
+    1513: 'Worker has terminated."',
+    1514: "unlock() with no preceding matching lock().",
+    1515: "Invalid condition timeout value: %1.",
+    1516: "Condition cannot notify if associated mutex is not owned.",
+    1517: "Condition cannot notifyAll if associated mutex is not owned.",
+    1518: "Condition cannot wait if associated mutex is not owned.",
+    1519: "Condition cannot be initialized.",
+    1520: "Mutex cannot be initialized.",
+    1521: "Only the worker's parent may call start.",
+    2004: "One of the parameters is invalid.",
+    2006: "The supplied index is out of bounds.",
+    2007: "Parameter %1 must be non-null.",
+    2008: "Parameter %1 must be one of the accepted values.",
+    2012: "%1 class cannot be instantiated.",
+    2030: "End of file was encountered.",
+    2035: "URL Not Found.",
+    2058: "There was an error decompressing the data.",
+    2078: "The name property of a Timeline-placed object cannot be modified.",
+    2099: "The loading object is not sufficiently loaded to provide this information.",
+    2085: "Parameter %1 must be non-empty string.",
+    2088: "The Proxy class does not implement getProperty. It must be overridden by a subclass.",
+    2089: "The Proxy class does not implement setProperty. It must be overridden by a subclass.",
+    2090: "The Proxy class does not implement callProperty. It must be overridden by a subclass.",
+    2091: "The Proxy class does not implement hasProperty. It must be overridden by a subclass.",
+    2092: "The Proxy class does not implement deleteProperty. It must be overridden by a subclass.",
+    2093: "The Proxy class does not implement getDescendants. It must be overridden by a subclass.",
+    2105: "The Proxy class does not implement nextNameIndex. It must be overridden by a subclass.",
+    2106: "The Proxy class does not implement nextName. It must be overridden by a subclass.",
+    2107: "The Proxy class does not implement nextValue. It must be overridden by a subclass.",
+    2108: "The value %1 is not a valid Array length.",
+    2124: "Loaded file is an unknown type.",
+    2173: "Unable to read object in stream.  The class %1 does not implement flash.utils.IExternalizable but is aliased to an externalizable class.",
+    3735: "This API cannot accept shared ByteArrays.",
+};

package/dist/thread/runtime/avm2/method-factories.js

@@ -0,0 +1,95 @@
+// The factories of methods whose bodies are not generated, as a module binds
+// them through Runtime.native, noBody, unverified and verifyError: once,
+// when it loads, never on a call.
+import { boundKey, methodKey, untypedSetKey } from "./traits.js";
+/**
+ * The parameter types avmplus' coerceEnter converts to without a class to
+ * test against: the primitives, and Object, which takes undefined as null.
+ * A native checks a class-typed parameter itself.
+ */
+const COERCED = new Set(["String", "Number", "int", "uint", "Boolean", "float", "Object"]);
+/** Factories nativeFactory made, whose methods coercedNative coerces. */
+const natives = new WeakSet();
+/** A native method, bound by its name; one the runtime lacks throws when called. */
+export function nativeFactory(rt, name, required, max) {
+    const make = rt.natives[name];
+    if (!make) {
+        return () => () => {
+            throw rt.unsupported(`native ${name}`);
+        };
+    }
+    let f = null;
+    const factory = () => {
+        if (!f) {
+            f = make(rt);
+            // Checked where a call was not bound (callBound, methodClosure): the
+            // verifier binds only a call its argument count fits.
+            if (required > 0 || max >= 0) {
+                f.$min = required;
+                f.$max = max;
+            }
+            // Its Function.length is the ABC's parameter count, as avmplus'
+            // (FunctionClass.cpp), not what the JavaScript declares: a native
+            // with optional parameters gives them defaults, which length skips.
+            if (max >= 0) {
+                f.$length = max;
+            }
+        }
+        return f;
+    };
+    natives.add(factory);
+    return factory;
+}
+/**
+ * `f`, a method `factory` made, installed in `proto` at dispatch id `d`,
+ * with what a call the compiler did not bind needs to coerce its arguments
+ * by its declared `params`, if it is a native that declares a primitive or
+ * Object one. avmplus coerces a native's arguments on entry, however it was
+ * called; a compiled call bound to it has coerced them already, and calls
+ * it as it is, so only the runtime's untyped paths pay: callBound, by the
+ * types kept on `f`, the same for every runtime, which may share it; and
+ * an untyped set, through a wrapper this runtime's `proto` keeps at
+ * untypedSetKey(d), which a method that needs none hides from its base's.
+ */
+export function installMethod(rt, proto, d, f, factory, params) {
+    proto[methodKey(d)] = f;
+    proto[boundKey(d)] = f.$bound ?? f;
+    const key = untypedSetKey(d);
+    if (!natives.has(factory) || !params.some((t) => COERCED.has(t))) {
+        if (key in proto) {
+            proto[key] = undefined;
+        }
+        return;
+    }
+    const m = f;
+    const types = params.map((t) => (COERCED.has(t) ? t : null));
+    m.$coerce = types;
+    // callBound coerces only a method with counts.
+    m.$min ??= 0;
+    m.$max ??= -1;
+    const type = types[0];
+    proto[key] =
+        type === null || type === undefined
+            ? undefined
+            : function (v) {
+                return f.call(this, rt.coerce(v, type));
+            };
+}
+/** A method with no body, as an interface's: VerifyError 1001 when called. */
+export function noBodyFactory(rt) {
+    return () => () => {
+        throw rt.error("VerifyError", 1001, "method");
+    };
+}
+/** A method the compiler did not verify. */
+export function unverifiedFactory(rt) {
+    return () => () => {
+        throw rt.unsupported("a method the compiler did not verify");
+    };
+}
+/** A method the verifier rejected with VerifyError `id`, thrown when it is called. */
+export function verifyErrorFactory(rt, id) {
+    return () => () => {
+        throw rt.error("VerifyError", id);
+    };
+}

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

@@ -0,0 +1,105 @@
+// The modules a runtime loads into its application domains, and which of
+// them the code on a stack is from: a Runtime's (Runtime.modules), apart
+// from its object model, as nothing compiled code calls goes through it.
+import { add, Domain, definedInChain, frameScripts, stackFrames } from "./domain.js";
+import { TypeName } from "./names.js";
+export class Modules {
+    domainCount = 1;
+    loads = 0;
+    /**
+     * The domain of each loaded module's code, by the script a stack's frame
+     * names it with (see Runtime.codeDomain); found from the stacks its loads
+     * took, which wait in `unlocated` until a domain other than the root
+     * exists. Weakly: a module's code keeps its domain, through its Abc, for
+     * as long as it can run, and a domain no code is left of is let go, an
+     * entry dropped with it.
+     */
+    moduleDomains = new Map();
+    moduleDomainGone = new FinalizationRegistry((at) => {
+        if (!this.moduleDomains.get(at)?.deref()) {
+            this.moduleDomains.delete(at);
+        }
+    });
+    unlocated = [];
+    /** A domain whose definitions are looked up after `parent`'s. */
+    newDomain(parent) {
+        return new Domain(parent, this.domainCount++);
+    }
+    /**
+     * Load a module into `domain`: its scripts' names become visible there.
+     * `at` is the stack its load took, made in Runtime.abc, whose frame is
+     * its first and the module's factory its second (see locate); null for a
+     * player's own, whose code is not a domain's to Runtime.codeDomain.
+     */
+    load(desc, domain, at) {
+        // Its layouts are those of its ABC after exactly these ABCs; the
+        // root's, which a player loads thousands into, are not copied.
+        const loaded = domain.parent ? domain.chain() : domain.own;
+        const linked = desc.linked;
+        if (linked.length !== loaded.length || linked.some((h, i) => h !== loaded[i])) {
+            throw new Error(`swf2es: a module compiled after [${linked.join(", ")}] cannot load after [${loaded.join(", ")}]`);
+        }
+        const abc = desc;
+        abc.domain = domain;
+        abc.index = domain.own.length;
+        domain.own.push(desc.hash);
+        domain.ownOrder.push(this.loads++);
+        if (at !== null) {
+            this.unlocated.push([at, domain]);
+        }
+        for (const name of abc.names) {
+            if (name instanceof TypeName) {
+                name.names = abc.names;
+            }
+        }
+        for (const cls of abc.classes) {
+            cls.abc = abc;
+        }
+        abc.scriptStates = abc.scripts.map((s) => ({ desc: s, abc, global: null, state: 0 }));
+        // As DomainMgr::addNamedScript: a name the domain's chain defines
+        // already, cached or loaded, is unreachable, and not added.
+        for (const script of abc.scriptStates) {
+            for (const [ns, version, name] of script.desc.traits.bindings) {
+                if (!definedInChain(domain, name, ns)) {
+                    add(domain.globals, { ns, version, script }, name);
+                }
+            }
+        }
+        return abc;
+    }
+    /**
+     * The domain of the innermost code in `stack` that a module defines, or
+     * null. A frame is a module's by its script, so a host gives each module
+     * a script of its own: its URL, or a sourceURL comment for code it
+     * evaluates.
+     */
+    domainOf(stack) {
+        this.locate();
+        for (const at of frameScripts(stack)) {
+            const domain = this.moduleDomains.get(at)?.deref();
+            if (domain) {
+                return domain;
+            }
+        }
+        return null;
+    }
+    /**
+     * The scripts of the modules loaded since last asked, by the stacks their
+     * loads took. Their stacks reach the modules' code, so they are not kept
+     * past the load once there are domains to tell apart.
+     */
+    locate() {
+        for (const [error, domain] of this.unlocated) {
+            // Its first frame is abc's own, its second the module's factory. An
+            // engine may name no script for the factory's frame (JavaScriptCore,
+            // for code a Function made), and the next frame that names one is
+            // the host's, which must not stand for the module.
+            const at = stackFrames(error.stack)[1];
+            if (at) {
+                this.moduleDomains.set(at, new WeakRef(domain));
+                this.moduleDomainGone.register(domain, at);
+            }
+        }
+        this.unlocated.length = 0;
+    }
+}

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

@@ -0,0 +1,248 @@
+// Namespaces and multinames, as generated modules describe them.
+//
+// Namespaces are interned by kind and URI across modules, as the compiler
+// interns them, so two modules' `public` are one object and names compare by
+// identity. A private namespace is only ever equal to itself.
+import { NO_CACHE } from "./property-cache.js";
+/** Namespace kinds, numbered as the compiler's NS_* constants. */
+export const NS_Public = 0;
+export const NS_PackageInternal = 1;
+export const NS_Protected = 2;
+export const NS_Explicit = 3;
+export const NS_StaticProtected = 4;
+export const NS_Private = 5;
+export class Namespace {
+    kind;
+    uri;
+    prefix;
+    constructor(kind, 
+    /** null for a namespace without a URI (the any namespace). */
+    uri, 
+    /**
+     * E4X's prefix, undefined for none, as a Namespace value can have one.
+     * A namespace with a prefix is not interned: names look it up as the
+     * interned one of its kind and URI (see interned).
+     */
+    prefix = undefined) {
+        this.kind = kind;
+        this.uri = uri;
+        this.prefix = prefix;
+    }
+    /** The namespace names look this one up as: this one, or without its prefix, interned. */
+    get interned() {
+        return this.prefix === undefined ? this : namespace(this.kind, this.uri);
+    }
+}
+/** The interned namespaces, by kind, then URI: null, the any namespace, is not "null". */
+const interned = [];
+/** The namespace of `kind` and `uri`, the same object each time. */
+export function namespace(kind, uri) {
+    let byUri = interned[kind];
+    if (!byUri) {
+        byUri = new Map();
+        interned[kind] = byUri;
+    }
+    let ns = byUri.get(uri);
+    if (!ns) {
+        ns = new Namespace(kind, uri);
+        byUri.set(uri, ns);
+    }
+    return ns;
+}
+export const publicNs = namespace(NS_Public, "");
+const PUBLIC_NAMESPACES = [publicNs];
+const ALL_VERSIONS = [255];
+/**
+ * A public Namespace value of `uri` with `prefix`, as E4X makes one: with
+ * no prefix, or the empty one for the empty URI, the interned namespace.
+ */
+export function prefixedNamespace(prefix, uri) {
+    if (prefix === undefined || (prefix === "" && uri === "")) {
+        return namespace(NS_Public, uri);
+    }
+    return new Namespace(NS_Public, uri, prefix);
+}
+/** A Namespace value's prefix, as avmplus has it: the empty URI's is "", else undefined unless given. */
+export function prefixOf(ns) {
+    return ns.prefix ?? (ns.uri === "" ? "" : undefined);
+}
+// Multiname kinds, as the ABC numbers them.
+export const CONSTANT_Qname = 0x07;
+export const CONSTANT_QnameA = 0x0d;
+export const CONSTANT_RTQname = 0x0f;
+export const CONSTANT_RTQnameA = 0x10;
+export const CONSTANT_RTQnameL = 0x11;
+export const CONSTANT_RTQnameLA = 0x12;
+export const CONSTANT_Multiname = 0x09;
+export const CONSTANT_MultinameA = 0x0e;
+export const CONSTANT_MultinameL = 0x1b;
+export const CONSTANT_MultinameLA = 0x1c;
+export const CONSTANT_TypeName = 0x1d;
+/**
+ * A name as a property lookup uses it: its namespaces, each with the API
+ * version it sees bindings at, and its local name, null for any name.
+ */
+export class Multiname {
+    kind;
+    namespaces;
+    versions;
+    attribute;
+    /**
+     * The object a runtime name was, which a Dictionary keys by itself; its
+     * name is the object's string for any other. Declared, so that every
+     * multiname has the same shape.
+     */
+    key = undefined;
+    /** The local name, or undefined until a key's is first needed. */
+    local;
+    /** How a key's name is made, as the object's string, when a lookup first needs it. */
+    nameOf = null;
+    /**
+     * The application domain whose definitions the name is looked up in: its
+     * module's, or the one of the name it was made from; null for the root.
+     */
+    domain = null;
+    /** What its lookups found, for a module's name (property-cache.ts); a name made at run time keeps none. */
+    cache = NO_CACHE;
+    /**
+     * The script that defines it, once found: the first definition of a name
+     * wins, so later modules cannot change it (Runtime.definingScript).
+     */
+    script = null;
+    /**
+     * That script's global object, once the script has been asked to run: a
+     * module's finddef reads it before calling the runtime (Runtime.findDef).
+     */
+    global = null;
+    /** The class it names, once resolved (Runtime.resolveName). */
+    cls = null;
+    /** Fixed at construction so indexed access needs no getter in its hot path. */
+    elementName;
+    constructor(kind, 
+    /** Its namespaces; one of null, as a Qname's, is any namespace. */
+    namespaces, versions, name, attribute) {
+        this.kind = kind;
+        this.namespaces = namespaces;
+        this.versions = versions;
+        this.attribute = attribute;
+        this.local = name;
+        this.elementName =
+            !attribute && namespaces.some((ns) => ns !== null && ns.kind === NS_Public && ns.uri === "");
+    }
+    /**
+     * A runtime name that was an object: a Dictionary keys by the object
+     * itself, and anything else by its string, which is made only then, as
+     * avmplus converts it only for an object that is not a Dictionary.
+     */
+    static keyed(kind, namespaces, versions, key, attribute, nameOf) {
+        const mn = new Multiname(kind, namespaces, versions, null, attribute);
+        mn.key = key;
+        mn.local = undefined;
+        mn.nameOf = nameOf;
+        return mn;
+    }
+    /** The local name, null for any name. */
+    get name() {
+        const local = this.local;
+        if (local !== undefined) {
+            return local;
+        }
+        const name = this.nameOf(this.key);
+        this.local = name;
+        return name;
+    }
+    /** Whether the name still needs a namespace from the stack. */
+    get runtimeNs() {
+        const k = this.kind;
+        return (k === CONSTANT_RTQname ||
+            k === CONSTANT_RTQnameA ||
+            k === CONSTANT_RTQnameL ||
+            k === CONSTANT_RTQnameLA);
+    }
+    /** Whether the local name comes from the stack. */
+    get runtimeName() {
+        const k = this.kind;
+        return (k === CONSTANT_RTQnameL ||
+            k === CONSTANT_RTQnameLA ||
+            k === CONSTANT_MultinameL ||
+            k === CONSTANT_MultinameLA);
+    }
+    /**
+     * The dynamic property the name names, or null, as
+     * Multiname::isValidDynamicName: not an attribute and with a public
+     * namespace, one of the public kind and an empty URI, as
+     * Namespace::isPublic.
+     */
+    dynamicName() {
+        if (this.attribute || this.name === null) {
+            return null;
+        }
+        for (const ns of this.namespaces) {
+            // null is any namespace, as in *::x.
+            if (ns !== null && ns.kind === NS_Public && ns.uri === "") {
+                return this.name;
+            }
+        }
+        return null;
+    }
+    toString() {
+        const ns = this.namespaces.length === 1 ? this.namespaces[0] : null;
+        const name = this.name ?? "*";
+        return ns?.uri ? `${ns.uri}::${name}` : name;
+    }
+}
+/** A TypeName, `Base.<Param>`, whose parts are other multinames of its module. */
+export class TypeName {
+    base;
+    params;
+    names = [];
+    constructor(base, params) {
+        this.base = base;
+        this.params = params;
+    }
+    get baseName() {
+        return this.names[this.base];
+    }
+    param(i) {
+        return this.names[this.params[i]];
+    }
+}
+/** A Qname in one namespace, seen at every version. */
+export function qname(ns, name) {
+    return new Multiname(CONSTANT_Qname, ns === publicNs ? PUBLIC_NAMESPACES : [ns], ALL_VERSIONS, name, false);
+}
+/**
+ * A public name the runtime makes from a string, as `in`, hasOwnProperty,
+ * JSON and AMF do: seen at user code's version, as avmplus' findPublicNamespace
+ * sees it from the user code on the call stack, so an AIR-only or a
+ * VM-internal binding is not there, as it is not to the code itself.
+ */
+export function publicQname(name, versions) {
+    return new Multiname(CONSTANT_Qname, PUBLIC_NAMESPACES, versions, name, false);
+}
+/** The builtin Vector classes, which avmplus names as the types they are vectors of. */
+const VECTOR_NAMES = {
+    "__AS3__.vec::Vector$int": "__AS3__.vec::Vector.<int>",
+    "__AS3__.vec::Vector$uint": "__AS3__.vec::Vector.<uint>",
+    "__AS3__.vec::Vector$double": "__AS3__.vec::Vector.<Number>",
+    "__AS3__.vec::Vector$object": "__AS3__.vec::Vector.<*>",
+};
+/** A traits' name as avmplus writes it: a class's statics' without their trailing $, a builtin Vector's as Vector.<T>. */
+export function formatClassName(name) {
+    const own = name.endsWith("$") ? name.slice(0, -1) : name;
+    return VECTOR_NAMES[own] ?? own;
+}
+/** A name's index as an array element, or -1: a canonical uint below 2^32 - 1. */
+export function arrayIndex(name) {
+    const c = name.charCodeAt(0);
+    if (!(c >= 0x30 && c <= 0x39)) {
+        return -1;
+    }
+    const i = Number(name);
+    return i >>> 0 === i && i !== 0xffffffff && String(i) === name ? i : -1;
+}
+/** The qualified name of a class's name, "uri::name", or the name in the unnamed package. */
+export function qualifiedName(mn) {
+    const ns = mn.namespaces[0];
+    return ns?.uri ? `${ns.uri}::${mn.name}` : (mn.name ?? "*");
+}

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

@@ -0,0 +1,47 @@
+// Class aliases, and AMF through ByteArray's readObject and writeObject.
+import { readObject, writeObject } from "../amf.js";
+import { bytesOf } from "./bytearray.js";
+export const aliasesNatives = {
+    // Class aliases and AMF.
+    "flash.net::registerClassAlias": (rt) => (aliasName, cls) => {
+        if (cls === null || cls === undefined) {
+            throw rt.error("TypeError", 2007, "classObject");
+        }
+        if (aliasName === null || aliasName === undefined) {
+            throw rt.error("TypeError", 2007, "aliasName");
+        }
+        const name = rt.toString(aliasName);
+        if (name === "") {
+            throw rt.error("ArgumentError", 2085, "aliasName");
+        }
+        rt.registerClassAlias(name, cls);
+    },
+    "flash.net::getClassByAlias": (rt) => (aliasName) => {
+        if (aliasName === null || aliasName === undefined) {
+            throw rt.error("TypeError", 2007, "aliasName");
+        }
+        const name = rt.toString(aliasName);
+        if (name === "") {
+            throw rt.error("ArgumentError", 2085, "aliasName");
+        }
+        return rt.classByAlias(name);
+    },
+    "flash.net::ObjectEncoding.get:dynamicPropertyWriter": (rt) => () => rt.dynamicPropertyWriter,
+    "flash.net::ObjectEncoding.set:dynamicPropertyWriter": (rt) => (writer) => {
+        rt.dynamicPropertyWriter = writer ?? null;
+    },
+    // What writeDynamicProperties writes through: the object being written's
+    // dynamic part, each name and value.
+    "flash.net::DynamicPropertyOutput#writeDynamicProperty": (rt) => function (name, value) {
+        if (name === null || name === undefined) {
+            throw rt.error("TypeError", 2007, "name");
+        }
+        this.$amf.dynamicProperty(rt.toString(name), value);
+    },
+    "flash.utils::ByteArray#writeObject": (rt) => function (v) {
+        writeObject(rt, bytesOf(rt, this), v);
+    },
+    "flash.utils::ByteArray#readObject": (rt) => function () {
+        return readObject(rt, bytesOf(rt, this));
+    },
+};