@swf2es/runtime 0.1.15 → 0.1.17

package/src/avm2/errors.ts

@@ -11,6 +11,14 @@ import type { Runtime } from "./runtime.js";
 /** Thrown for an AS3 exception that is an Error the runtime made, before its class existed. */
 export class AsError extends Error {}
 
+/**
+ * Thrown where a SWF asks for something swf2es has not got (Runtime.unsupported).
+ * Uncaught, it stops the script as any error of the runtime's own does; an
+ * AS3 catch gets it as an AS3 error (Runtime.caught), since content written
+ * for several runtimes guards what one of them may lack with try and catch.
+ */
+export class UnsupportedError 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
@@ -29,6 +37,16 @@ export function stackOf(error: Value): string | null {
   return frames.slice(Math.max(0, first)).join("\n");
 }
 
+/**
+ * What an error the runtime made says in full, its text and arguments as
+ * debugger mode words them, for a host to show: the release player's
+ * message, which the SWF sees, is the number alone. Null for any other value.
+ */
+export function detailOf(error: Value): string | null {
+  const detail = (error as { $detail?: unknown } | null)?.$detail;
+  return typeof detail === "string" ? detail : null;
+}
+
 /**
  * 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.
@@ -49,6 +67,8 @@ export function describe(rt: Runtime, v: Value): string {
     return rt.toString(v);
   }
 
+  // Its class's name without the package, as "Object@0", the address left out.
   const name: string = v.$traits.name;
-  return `${name.slice(name.lastIndexOf("::") + (name.includes("::") ? 2 : 0))}@0`;
+  const colons = name.lastIndexOf("::");
+  return `${colons < 0 ? name : name.slice(colons + 2)}@0`;
 }

package/src/avm2/index.ts

@@ -4,10 +4,14 @@ import type { RuntimeOptions } from "./options.js";
 import { Runtime } from "./runtime.js";
 
 export { Reader as Amf3Reader, Writer as Amf3Writer } from "./amf.js";
+// The classes' declarations, for natives to reach AS3 objects by (Runtime.prop).
+export type { MethodName, PropertyName, Ref, WritableName } from "./as3-types.js";
 /** avmplus' builtin.abc (MPL-2.0), which every runtime loads first. */
 export { builtinLibrary } from "./builtin-library.js";
+export type { BuiltinClasses, BuiltinStatics } from "./builtin-types.generated.js";
 export type { Abc, AsObject, CompileUnit, FoundDefinition, Method, Value } from "./descriptors.js";
 export { type Domain, frameScripts, frameSites, siteScript, stackFrames } from "./domain.js";
+export { UnsupportedError } from "./errors.js";
 export { FloatValue, hasFloatLibrary } from "./float.js";
 export { floatLibrary } from "./float-library.js";
 export type { ClassHook, NativesProvider } from "./hooks.js";
@@ -67,6 +71,8 @@ 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";
+// avmplus' UTF-8, for a player's bytes that must read and write as ByteArray's do.
+export { fromUtf8, utf8 } from "./utf8.js";
 
 /** A runtime with the builtins' natives, for modules compiled from builtin.abc and after. */
 export function createRuntime(options: RuntimeOptions = {}): Runtime {

package/src/avm2/names.ts

@@ -85,6 +85,11 @@ export const CONSTANT_MultinameA = 0x0e;
 export const CONSTANT_MultinameL = 0x1b;
 export const CONSTANT_MultinameLA = 0x1c;
 
+// What a name made at run time was made of (Multiname.made).
+export const MADE_Unknown = 0;
+export const MADE_Number = 1;
+export const MADE_Value = 2;
+
 /**
  * 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.
@@ -121,6 +126,14 @@ export class Multiname {
   cls: AsObject | null = null;
   /** Fixed at construction so indexed access needs no getter in its hot path. */
   readonly elementName: boolean;
+  /**
+   * What made it, where the code's own value did at run time: a number
+   * read or written as an element (MADE_Number), which avmplus hands a
+   * Proxy as its string, or a string or any other value (MADE_Value), which
+   * it hands it as a QName. MADE_Unknown for a name of the code's own and
+   * one the runtime made.
+   */
+  made = MADE_Unknown;
 
   constructor(
     readonly kind: number,

package/src/avm2/natives/array.ts

@@ -28,7 +28,7 @@ function sealed(rt: Runtime, o: AsObject, adding: number): boolean {
   }
 
   if (adding > 0) {
-    throw rt.error("ReferenceError", 1056, "0", o.$traits.name);
+    throw rt.error("ReferenceError", 1056, "0", o.$traits.errorName);
   }
 
   return true;

package/src/avm2/natives/bytearray.ts

@@ -760,13 +760,11 @@ export function byteArrayNatives(rt: Runtime): Natives {
       return rt.defaultObjectEncoding;
     }
 
+    // Unchecked, unlike an instance's: avmshell and Flash take any uint, a
+    // new ByteArray starts with it, and writeObject reads an encoding below
+    // 3 as AMF0 (#1508 in avmshell), any other as AMF3.
     static set defaultObjectEncoding(v: Value) {
-      const e = rt.toUint(v);
-      if (e !== kAMF0 && e !== kAMF3) {
-        throw rt.error("ArgumentError", 2008, "objectEncoding");
-      }
-
-      rt.defaultObjectEncoding = e;
+      rt.defaultObjectEncoding = rt.toUint(v);
     }
 
     get length() {
@@ -1215,13 +1213,11 @@ export function byteArrayNatives(rt: Runtime): Natives {
     },
   };
 
+  // AMF3 whatever their objectEncoding, as ObjectOutputObject::writeObject
+  // and ObjectInputObject::readObject: avmshell and Flash alike.
   class ObjectOutputNatives {
     writeObject(this: AsObject, v: Value): void {
       const stream: Writer = this.$amf;
-      if (stream.objectEncoding !== 3) {
-        throw rt.unsupported("AMF0");
-      }
-
       stream.value(v);
     }
   }
@@ -1229,10 +1225,6 @@ export function byteArrayNatives(rt: Runtime): Natives {
   class ObjectInputNatives {
     readObject(this: AsObject): Value {
       const stream: Reader = this.$amf;
-      if (stream.objectEncoding !== 3) {
-        throw rt.unsupported("AMF0");
-      }
-
       return stream.value();
     }
 

package/src/avm2/natives/describe.ts

@@ -121,7 +121,14 @@ function chooseTraits(rt: Runtime, v: Value): Traits | string {
     return "null";
   }
 
-  if (typeof v === "number" && (v | 0) === v && v >= -(1 << 28) && v < 1 << 28) {
+  // An int atom: -0 is a double.
+  if (
+    typeof v === "number" &&
+    (v | 0) === v &&
+    v >= -(1 << 28) &&
+    v < 1 << 28 &&
+    !Object.is(v, -0)
+  ) {
     return rt.traitsOfType("int");
   }
 

package/src/avm2/natives/object.ts

@@ -191,9 +191,12 @@ function shortName(qualified: string): string {
 
 export function qualifiedClassName(rt: Runtime, v: Value): string {
   switch (typeof v) {
-    // As TypeDescriber::chooseTraits: an int is one that fits avmplus' 29-bit int atom.
+    // As TypeDescriber::chooseTraits: an int is one that fits avmplus' 29-bit
+    // int atom, which -0, always a double, never is.
     case "number":
-      return (v | 0) === v && v >= -(1 << 28) && v < 1 << 28 ? "int" : "Number";
+      return (v | 0) === v && v >= -(1 << 28) && v < 1 << 28 && !Object.is(v, -0)
+        ? "int"
+        : "Number";
     case "string":
       return "String";
     case "boolean":

package/src/avm2/natives/proxy.ts

@@ -7,7 +7,16 @@
 
 import type { AsObject, Value } from "../descriptors.js";
 import type { ClassHook, PropertyHook } from "../hooks.js";
-import { type Multiname, NS_Public, namespace, publicNs, publicQname, qname } from "../names.js";
+import {
+  MADE_Number,
+  MADE_Unknown,
+  type Multiname,
+  NS_Public,
+  namespace,
+  publicNs,
+  publicQname,
+  qname,
+} from "../names.js";
 import type { Runtime } from "../runtime.js";
 import type { Natives } from "./define.js";
 
@@ -15,8 +24,11 @@ const FLASH_PROXY = namespace(NS_Public, "http://www.adobe.com/2006/actionscript
 
 /**
  * The name a flash_proxy method gets for `mn`: a QName that was the name
- * stays one, an index comes as its string, as avmplus' getUintProperty
- * interns it, and any other name as a QName in its namespace.
+ * stays one; a number read or written as an element comes as its string,
+ * as avmplus' getUintProperty and getpropertylate_d intern it, whatever
+ * the number; a string or another value of the code's comes as a QName,
+ * "0" too, as does any other name, in its namespace. A name whose maker
+ * is not known is told by its string: an index's is the string.
  */
 function nameFor(rt: Runtime, mn: Multiname): Value {
   if (mn.key !== undefined && (mn.key as AsObject)?.$local !== undefined) {
@@ -24,7 +36,11 @@ function nameFor(rt: Runtime, mn: Multiname): Value {
   }
 
   const name = mn.name;
-  if (name !== null && !mn.attribute && isIndex(name)) {
+  if (
+    name !== null &&
+    !mn.attribute &&
+    (mn.made === MADE_Number || (mn.made === MADE_Unknown && isIndex(name)))
+  ) {
     return name;
   }
 

package/src/avm2/natives/vector.ts

@@ -330,7 +330,7 @@ for (const [kind, convert, fill, elementsOf, store] of VECTORS) {
 
       const source = args[0];
       if (!isObject(source)) {
-        throw rt.error("TypeError", 1034, rt.describe(source), cls.$it.name);
+        throw rt.error("TypeError", 1034, rt.describe(source), cls.$it.errorName);
       }
 
       if (source.$traits === cls.$it) {

package/src/avm2/options.ts

@@ -8,6 +8,11 @@ import type { Runtime } from "./runtime.js";
 export interface RuntimeOptions {
   /** Where trace and print write a line. */
   print?: (line: string) => void;
+  /**
+   * Told what is not supported that the code asked for and caught, once
+   * for each: caught, it reaches no one else.
+   */
+  onUnsupported?: (message: string) => void;
   /**
    * Behave as the debugger player: error messages carry avmplus' text
    * ("Error #1009: Cannot access ..."), and System.isDebugger is true. By

package/src/avm2/property-cache.ts

@@ -11,8 +11,13 @@
 // entry still looks for the property on the object, which may have lost it,
 // then on its prototypes, which may have gained or lost it, and leaves
 // what neither has to the full lookup.
+//
+// A name looked up on more traits than its cache keeps, as `x` is on every
+// class with an x, stops replacing entries; what it finds on traits it has
+// no entry for is kept on those traits instead, by name, so that the one
+// class it is mostly read on is not left to the full lookup.
 
-import type { Method, TypeRef } from "./descriptors.js";
+import type { AsObject, Method, TypeRef } from "./descriptors.js";
 import type { Multiname } from "./names.js";
 import type { Traits } from "./traits.js";
 
@@ -25,7 +30,7 @@ export const IC_GetSet = 5;
 export const IC_Method = 6;
 /** A method a property hook resolves the name of for get and set, as XML's: callproperty only. */
 export const IC_Call = 7;
-/** No binding: a dynamic property, the object's own or else a prototype's, if either has it. */
+/** No binding: a dynamic property, the object's own (a dynamic object's) or else a prototype's, if either has it. */
 export const IC_Dynamic = 8;
 
 /** Entries a name keeps, for as many traits, before it replaces the oldest. */
@@ -35,7 +40,7 @@ const ENTRIES = 8;
  * keeps would replace one on every miss, and still miss as often. It keeps
  * those it has until the epoch changes.
  */
-export const REPLACEMENTS = 16;
+const REPLACEMENTS = 16;
 
 /**
  * One traits' entry for a name. A name's first entry heads its list and
@@ -70,6 +75,8 @@ export function epoch(): number {
 
 /** The caches filled in this epoch, which invalidate empties so that they keep no traits or code. */
 const filled: PropertyCache[] = [];
+/** The traits given entries of their own in this epoch (Traits.manyTraitsEntries). */
+const filledTraits: Traits[] = [];
 
 /** Note that `head`'s cache is being filled in this epoch. */
 function filling(head: PropertyCache): void {
@@ -88,6 +95,11 @@ export function invalidate(): void {
   }
 
   filled.length = 0;
+  for (let i = 0; i < filledTraits.length; i++) {
+    filledTraits[i].manyTraitsEntries = null;
+  }
+
+  filledTraits.length = 0;
   current++;
 }
 
@@ -98,11 +110,12 @@ export const UNFILLED = new PropertyCache();
 
 /** The entry of `mn`'s cache for objects with traits `t`, or null. */
 export function cached(t: Traits | undefined, mn: Multiname): PropertyCache | null {
-  let e: PropertyCache | null = mn.cache;
-  if (t === undefined || e.epoch !== epoch()) {
+  const head = mn.cache;
+  if (t === undefined || head.epoch !== epoch()) {
     return null;
   }
 
+  let e: PropertyCache | null = head;
   do {
     if (e.traits === t) {
       return e;
@@ -111,16 +124,20 @@ export function cached(t: Traits | undefined, mn: Multiname): PropertyCache | nu
     e = e.next;
   } while (e !== null);
 
+  if (head.replaced === REPLACEMENTS && t.manyTraitsEntries !== null) {
+    return t.manyTraitsEntries.get(mn) ?? null;
+  }
+
   return null;
 }
 
 /**
- * The entry of a cache to fill for traits `t`: its own, a free one, a new
- * one while the list is shorter than ENTRIES, else the oldest, until it has
- * replaced REPLACEMENTS; then none. A cache of an earlier epoch is emptied
- * first.
+ * The entry of `mn`'s cache, `head`, to fill for traits `t`: its own, a
+ * free one, a new one while the list is shorter than ENTRIES, else the
+ * oldest, until it has replaced REPLACEMENTS; then one `t` keeps for `mn`.
+ * A cache of an earlier epoch is emptied first.
  */
-export function entryFor(head: PropertyCache, t: Traits): PropertyCache | null {
+export function entryFor(head: PropertyCache, t: Traits, mn: Multiname): PropertyCache {
   if (head.epoch !== epoch()) {
     for (let e: PropertyCache | null = head; e !== null; e = e.next) {
       e.traits = null;
@@ -150,7 +167,7 @@ export function entryFor(head: PropertyCache, t: Traits): PropertyCache | null {
   }
 
   if (head.replaced === REPLACEMENTS) {
-    return null;
+    return traitsEntry(t, mn);
   }
 
   head.replaced++;
@@ -158,3 +175,32 @@ export function entryFor(head: PropertyCache, t: Traits): PropertyCache | null {
   head.victim = victim.next ?? head;
   return victim;
 }
+
+/** The entry `t` keeps for `mn`, a name its cache has no room for. */
+function traitsEntry(t: Traits, mn: Multiname): PropertyCache {
+  let entries = t.manyTraitsEntries;
+  if (entries === null) {
+    entries = new Map();
+    t.manyTraitsEntries = entries;
+    filledTraits.push(t);
+  }
+
+  let e = entries.get(mn);
+  if (e === undefined) {
+    e = new PropertyCache();
+    entries.set(mn, e);
+  }
+
+  return e;
+}
+
+/**
+ * Which of a scope chain's objects binds each name findProperty looked up
+ * on it, the innermost that does, or null where none does, in the epoch it
+ * was found in: a chain's objects never change, nor do their traits'
+ * bindings within an epoch. Only for a chain without a with scope, which
+ * has a name by its dynamic properties too.
+ */
+export class ScopeFinds extends Map<Multiname, AsObject | null> {
+  epoch = current;
+}