@swf2es/runtime 0.1.20 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swf2es/runtime",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "AVM2 and AVM1 language runtime used by generated code",
   "keywords": [
     "actionscript",
@@ -41,6 +41,6 @@
     "LICENSE.third-party"
   ],
   "dependencies": {
-    "@swf2es/format": "0.1.20"
+    "@swf2es/format": "0.1.21"
   }
 }

package/src/avm2/amf.ts

@@ -15,7 +15,7 @@
 import type { AsObject, Value } from "./descriptors.js";
 import { FloatValue } from "./float.js";
 import { NS_PackageInternal, NS_Public, namespace, publicQname, qname } from "./names.js";
-import { type Bytes, bytesOf } from "./natives/bytearray.js";
+import { type Bytes, bytesOf } from "./natives/bytes.js";
 import { xmlToXMLString } from "./natives/xml/strings.js";
 import type { Runtime } from "./runtime.js";
 import type { Traits } from "./traits.js";

package/src/avm2/enumeration.ts

@@ -9,6 +9,7 @@ import { DictionaryKeys } from "./dictionary-keys.js";
 import { type DynamicProperties, GONE, type Walk } from "./dynamic-properties.js";
 import { Namespace } from "./names.js";
 import { FloatVector } from "./natives/float-vector.js";
+import { firstAtOrAfter, hashed, indicesOf, retake, type SparseIndices } from "./sparse-indices.js";
 import type { Traits } from "./traits.js";
 
 /**
@@ -22,25 +23,6 @@ export interface Enumeration {
   sparse?: SparseIndices;
 }
 
-/**
- * The indices of a sparse Array, in order, taken when a for-in first meets
- * a run of holes too long to step through, so that it crosses each gap by
- * them, and dropped when the for-in ends or another starts.
- */
-interface SparseIndices {
-  indices: number[];
-  /** The Array's length when they were last brought up to it. */
-  length: number;
-  /** Where in them the index last given is, and that index, so that the next step goes on from there. */
-  at: number;
-  given: number;
-  /** How many were given since they were taken, and whether they were taken again since this for-in met them. */
-  sinceTaken: number;
-  retaken: boolean;
-  /** Whether avmplus holds the Array's elements in its hashtable (see hashed). */
-  hashed: boolean;
-}
-
 /**
  * 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
@@ -559,63 +541,6 @@ function nextSparse(o: AsObject, a: Value[], sparse: SparseIndices, from: number
   return -1;
 }
 
-/** Take a sparse Array's indices again. */
-function retake(a: Value[], sparse: SparseIndices): void {
-  sparse.indices = indicesOf(a, 0);
-  sparse.length = a.length;
-  sparse.at = -1;
-  sparse.given = -1;
-  sparse.sinceTaken = 0;
-  // An Array in avmplus' hashtable never leaves it.
-  sparse.hashed ||= hashed(sparse.indices);
-}
-
-/**
- * Whether avmplus holds an Array with these elements in its hashtable, as
- * it must when they span more than 32 slots and more than four times one
- * more than their count (ArrayObject's shouldBeSparse): its dense part
- * never holds so few over so many. Else avmplus may hold them dense,
- * walking them by index, as the for-in here does.
- */
-function hashed(indices: number[]): boolean {
-  const n = indices.length;
-  if (n === 0) {
-    return false;
-  }
-
-  const span = indices[n - 1] - indices[0] + 1;
-  return span > 32 && span > (n + 1) * 4;
-}
-
-/** An Array's indices from `from` on, in order, as Object.keys gives them, appended to `indices`. */
-function indicesOf(a: Value[], from: number, indices: number[] = []): number[] {
-  const keys = Object.keys(a);
-  for (let k = 0; k < keys.length; k++) {
-    const i = Number(keys[k]);
-    if (i >= from) {
-      indices.push(i);
-    }
-  }
-
-  return indices;
-}
-
-/** Where in `indices`, in order, the first at or after `from` is. */
-function firstAtOrAfter(indices: number[], from: number): number {
-  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;
-}
-
 /** Whether element `i` of `o`, the object nextIndex steps over, is there and not hidden. */
 function enumerable(o: AsObject, a: Value[], i: number): boolean {
   const hidden = hiddenOf(o);

package/src/avm2/errors.ts

@@ -1,10 +1,12 @@
 // 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.
+// one; where an AS3 error was made, for a host to show; and what an AS3
+// catch gets, Runtime.caught's.
 
-import type { Value } from "./descriptors.js";
+import type { AsObject, Value } from "./descriptors.js";
+import { isViewRangeError } from "./domain-memory.js";
 import { FloatValue } from "./float.js";
-import { Namespace } from "./names.js";
+import { Namespace, NS_Public, namespace } from "./names.js";
 import { errorMessages } from "./player-messages.js";
 import type { Runtime } from "./runtime.js";
 
@@ -72,3 +74,46 @@ export function describe(rt: Runtime, v: Value): string {
   const colons = name.lastIndexOf("::");
   return `${colons < 0 ? name : name.slice(colons + 2)}@0`;
 }
+
+/** An exception as AS3 catches it: a stack overflow is an AS3 Error; the runtime's own errors are not caught. */
+export function caught(rt: Runtime, e: unknown): Value {
+  if (e instanceof RangeError && /call stack/.test(e.message)) {
+    return rt.error("Error", 1023);
+  }
+
+  // Domain memory's, in the handler's own method (see memoryError).
+  if (isViewRangeError(e)) {
+    return rt.error("RangeError", 1506);
+  }
+
+  if (e instanceof UnsupportedError) {
+    return unsupportedCaught(rt, e);
+  }
+
+  if (e instanceof Error && !(e instanceof AsError)) {
+    throw e;
+  }
+
+  return e;
+}
+
+/**
+ * What is not supported as the AS3 error a catch gets: an
+ * IllegalOperationError with its message, or an Error where the player's
+ * classes are not loaded; said once to the host, as the code may say nothing.
+ */
+function unsupportedCaught(rt: Runtime, e: UnsupportedError): Value {
+  if (!rt.unsupportedTold.has(e.message)) {
+    rt.unsupportedTold.add(e.message);
+    rt.onUnsupported?.(e.message);
+  }
+
+  let cls: AsObject;
+  try {
+    cls = rt.resolve(rt.cls(namespace(NS_Public, "flash.errors"), "IllegalOperationError"));
+  } catch {
+    cls = rt.builtinClass("Error");
+  }
+
+  return rt.constructClass(cls, [e.message, 0]);
+}

package/src/avm2/index.ts

@@ -17,18 +17,8 @@ export { floatLibrary } from "./float-library.js";
 export type { ClassHook, NativesProvider } from "./hooks.js";
 export { messages } from "./messages.js";
 export { publicNs, qname } from "./names.js";
-export {
-  Bytes,
-  byteArrayHook,
-  bytesOf,
-  canShareMemory,
-  GLOBAL_MEMORY_MIN_SIZE,
-  notIsolated,
-  type SharedBytesMemory,
-  setDomainMemory,
-  shareBytes,
-  sharedByteArray,
-} from "./natives/bytearray.js";
+export { byteArrayHook, setDomainMemory } from "./natives/bytearray.js";
+export { Bytes, bytesOf, GLOBAL_MEMORY_MIN_SIZE } from "./natives/bytes.js";
 export {
   type SyncRef,
   syncError,
@@ -40,6 +30,13 @@ export type { Natives } from "./natives/define.js";
 export { type NativeClass, 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 {
+  canShareMemory,
+  notIsolated,
+  type SharedBytesMemory,
+  shareBytes,
+  sharedByteArray,
+} from "./natives/shared-bytes.js";
 export {
   endShellWorker,
   shellWorkerTerminated,

package/src/avm2/natives/aliases.ts

@@ -1,7 +1,7 @@
 // Class aliases, and AMF through ByteArray's readObject and writeObject.
 import { readObject, writeObject } from "../amf.js";
 import type { AsObject, Value } from "../descriptors.js";
-import { bytesOf } from "./bytearray.js";
+import { bytesOf } from "./bytes.js";
 import type { Natives } from "./define.js";
 
 export const aliasesNatives: Natives = {