@swf2es/runtime 0.0.0-stage → 0.1.0

package/src/avm1/globals/global.ts

@@ -0,0 +1,420 @@
+// The global functions and ASnative, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) core/src/avm1/globals.rs and
+// globals/asnative.rs have them: MIT OR Apache-2.0, Copyright (c)
+// 2018-2022 Ruffle LLC and Ruffle contributors. Where adl parts from
+// Ruffle, adl decides (docs/avm1.md, "The global functions").
+//
+// ASnative(category, index) gives a new function of Flash's table of
+// natives each call; ASSetNative and ASSetNativeAccessor set an object's
+// methods and properties from it, a version prefixed to a name hiding it
+// from earlier SWFs.
+
+import { parseFloatAvm1 } from "../numbers.js";
+import {
+  Avm1Function,
+  type Native,
+  set,
+  VERSION_6,
+  VERSION_7,
+  VERSION_8,
+  VERSION_9,
+  VERSION_10,
+} from "../objects.js";
+import type { Realm } from "../realm.js";
+import { stringOf, toNumber, type Value } from "../values.js";
+import { timerFunctions } from "./timers.js";
+
+const HEX = "0123456789ABCDEF";
+
+// The web's and node's alike, though not ECMAScript's.
+declare const TextEncoder: new () => { encode(s: string): Uint8Array };
+const encoder = new TextEncoder();
+
+/** A string's bytes: up to SWF 5 its characters, each a byte; from 6 its UTF-8. */
+function bytesOf(s: string, version: number): ArrayLike<number> {
+  if (version >= 6) {
+    return encoder.encode(s);
+  }
+
+  const bytes: number[] = [];
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c <= 0xff) {
+      bytes.push(c);
+    } else {
+      bytes.push(...encoder.encode(s[i]));
+    }
+  }
+
+  return bytes;
+}
+
+/** escape: every byte but a letter or a digit as %XX. */
+export function escapeAvm1(s: string, version: number): string {
+  const bytes = bytesOf(s, version);
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    const b = bytes[i];
+    if ((b >= 0x30 && b <= 0x39) || (b >= 0x41 && b <= 0x5a) || (b >= 0x61 && b <= 0x7a)) {
+      out += String.fromCharCode(b);
+    } else {
+      out += `%${HEX[b >> 4]}${HEX[b & 15]}`;
+    }
+  }
+
+  return out;
+}
+
+const hexValue = (c: number): number =>
+  c >= 0x30 && c <= 0x39
+    ? c - 0x30
+    : c >= 0x41 && c <= 0x46
+      ? c - 0x37
+      : c >= 0x61 && c <= 0x66
+        ? c - 0x57
+        : -1;
+
+/**
+ * unescape: %XX the byte XX, + a space; a % before what is no hex digit
+ * drops that character. The bytes are a SWF 5's string, and from SWF 6
+ * read as its strings' UTF-8 is (decodeLenient).
+ */
+export function unescapeAvm1(s: string, version: number): string {
+  const bytes = bytesOf(s, version);
+  const out: number[] = [];
+  let remain = 0;
+  let digits = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    const b = bytes[i];
+    if (b === 0x25) {
+      remain = 2;
+      digits = 0;
+      continue;
+    }
+
+    if (remain > 0) {
+      const v = hexValue(b);
+      if (v < 0) {
+        remain = 0;
+        continue;
+      }
+
+      digits = (digits << 4) | v;
+      remain--;
+      if (remain === 0) {
+        out.push(digits);
+      }
+
+      continue;
+    }
+
+    out.push(b === 0x2b ? 0x20 : b);
+  }
+
+  if (version < 6) {
+    let text = "";
+    for (const b of out) {
+      text += String.fromCharCode(b);
+    }
+
+    return text;
+  }
+
+  return decodeLenient(out);
+}
+
+/** What ConvertUTF.c subtracts from the sum of a sequence of 1 to 6 bytes. */
+const OFFSETS = [0, 0x3080, 0xe2080, 0x3c82080, 0xfa082080, 0x82082080];
+
+/**
+ * Bytes read as UTF-8 leniently, as adl reads a SWF 6's strings
+ * (codegen's avm1/emit/strings.ts): a lead byte takes as many bytes as its
+ * high bits say, continuation bytes or not, summed as Unicode's old
+ * ConvertUTF.c sums them; a surrogate or a code point past U+10FFFF is
+ * U+FFFD, and a code point of 0, or a sequence cut short, ends the string.
+ */
+function decodeLenient(bytes: ArrayLike<number>): string {
+  let out = "";
+  let i = 0;
+  while (i < bytes.length) {
+    const b = bytes[i];
+    if (b === 0) {
+      break;
+    }
+
+    if (b < 0x80) {
+      out += String.fromCharCode(b);
+      i++;
+      continue;
+    }
+
+    const more = b < 0xc0 ? 0 : b < 0xe0 ? 1 : b < 0xf0 ? 2 : b < 0xf8 ? 3 : b < 0xfc ? 4 : 5;
+    if (more >= bytes.length - i) {
+      break;
+    }
+
+    let c = 0;
+    for (let k = 0; k <= more; k++) {
+      c = ((c << 6) + bytes[i + k]) >>> 0;
+    }
+
+    c = (c - OFFSETS[more]) >>> 0;
+    i += more + 1;
+    if (c === 0) {
+      break;
+    }
+
+    out += c > 0x10ffff || (c >= 0xd800 && c <= 0xdfff) ? "�" : String.fromCodePoint(c);
+  }
+
+  return out;
+}
+
+const isSign = (c: number) => c === 0x2b || c === 0x2d;
+
+/**
+ * parseInt, as Ruffle has it and adl agrees: "0x" after a sign is NaN
+ * unless the radix reads it, a leading "0x" is hex whatever the radix, a
+ * leading 0 octal where every digit after it is, spaces and a sign after
+ * the prefix, NaN without a digit.
+ */
+export function parseIntAvm1(
+  s: string,
+  radixValue: Value,
+  hasRadix: boolean,
+  version: number,
+): number {
+  let radix = 0;
+  if (hasRadix) {
+    radix = toNumber(radixValue, version) | 0;
+    if (radix < 2 || radix > 36) {
+      return Number.NaN;
+    }
+  }
+
+  const signed = s.length > 0 && isSign(s.charCodeAt(0));
+  const off = signed ? 1 : 0;
+  const zero = s.charCodeAt(off) === 0x30;
+  const x = s.charCodeAt(off + 1);
+  const hex = zero && (x === 0x78 || x === 0x58);
+  let ignoreSign = false;
+  let rest = s;
+  if (hex) {
+    if (signed) {
+      if (radix <= 33) {
+        return Number.NaN;
+      }
+
+      ignoreSign = true;
+    } else {
+      radix ||= 16;
+      rest = s.slice(2);
+    }
+  } else if (zero && radix === 0 && /^[0-7]*$/.test(s.slice(1))) {
+    radix = 8;
+  } else {
+    radix ||= 10;
+  }
+
+  let i = 0;
+  while (i < rest.length) {
+    const c = rest.charCodeAt(i);
+    if (c !== 0x20 && c !== 0x09 && c !== 0x0a && c !== 0x0d) {
+      break;
+    }
+
+    i++;
+  }
+
+  let sign = 1;
+  if (i < rest.length && isSign(rest.charCodeAt(i))) {
+    if (!ignoreSign && rest.charCodeAt(i) === 0x2d) {
+      sign = -1;
+    }
+
+    i++;
+  }
+
+  let result = 0;
+  let empty = true;
+  for (; i < rest.length; i++) {
+    const c = rest.charCodeAt(i);
+    const d =
+      c >= 0x30 && c <= 0x39
+        ? c - 0x30
+        : c >= 0x61 && c <= 0x7a
+          ? c - 0x57
+          : c >= 0x41 && c <= 0x5a
+            ? c - 0x37
+            : 99;
+    if (d >= radix) {
+      break;
+    }
+
+    result = result * radix + d;
+    empty = false;
+  }
+
+  return empty ? Number.NaN : sign * result;
+}
+
+/** The version a name's prefix says, and the name without it: `8max` is max from SWF 8. */
+function versioned(name: string): [string, number] {
+  switch (name.charCodeAt(0)) {
+    case 0x36:
+      return [name.slice(1), VERSION_6];
+    case 0x37:
+      return [name.slice(1), VERSION_7];
+    case 0x38:
+      return [name.slice(1), VERSION_8];
+    case 0x39:
+      return [name.slice(1), VERSION_9];
+    case 0x31:
+      return name.charCodeAt(1) === 0x30 ? [name.slice(2), VERSION_10] : [name.slice(1), 0];
+    default:
+      return [name, 0];
+  }
+}
+
+/**
+ * The categories Flash Player has a table of natives for, as ranges: adl
+ * gives a function for any index of these, and undefined for any other.
+ * Those of the classes swf2es has no natives of yet give functions of none.
+ */
+const CATEGORIES = [
+  [1, 5],
+  [9, 9],
+  [11, 15],
+  [100, 107],
+  [110, 113],
+  [200, 200],
+  [250, 253],
+  [300, 301],
+  [400, 400],
+  [500, 500],
+  [600, 600],
+  [666, 667],
+  [700, 700],
+  [800, 800],
+  [900, 901],
+  [1021, 1021],
+  [1066, 1067],
+  [1100, 1103],
+  [1105, 1112],
+  [1999, 1999],
+  [2100, 2102],
+  [2104, 2104],
+  [2106, 2108],
+  [2150, 2151],
+  [2198, 2198],
+  [2200, 2201],
+  [2204, 2205],
+  [2341, 2341],
+  [2401, 2401],
+];
+
+const isCategory = (category: number) =>
+  CATEGORIES.some(([first, last]) => category >= first && category <= last);
+
+/** ASnative(category, index): a new function of the table's native, undefined for no table. */
+export function asnative(realm: Realm, category: number, index: number): Value {
+  const table = realm.natives.get(category);
+  if (table === undefined) {
+    return isCategory(category) ? realm.method(none) : undefined;
+  }
+
+  // An index past a u16 is no native's.
+  // Any index of a table is a function, one of none giving undefined.
+  return realm.method(table(index > 0xffff ? 0xffff : index) ?? none);
+}
+
+/** ASSetNative (`accessor` false) and ASSetNativeAccessor. */
+function setNative(realm: Realm, args: Value[], version: number, accessor: boolean): Value {
+  if (args.length < 3) {
+    return undefined;
+  }
+
+  const object = realm.box(args[0], version);
+  const major = toNumber(args[1], version) | 0;
+  const names = stringOf(args[2], version);
+  let minor = args.length > 3 ? toNumber(args[3], version) | 0 : 0;
+  for (const prefixed of names.split(",")) {
+    const [name, flags] = versioned(prefixed);
+    if (!accessor) {
+      const f = asnative(realm, major, minor >>> 0);
+      minor++;
+      if (name !== "") {
+        const had = object.own(name, version) !== undefined;
+        set(object, name, f, version);
+        const p = object.own(name, version);
+        if (!had && p !== undefined) {
+          p.flags |= flags;
+        }
+      }
+
+      continue;
+    }
+
+    const getter = asnative(realm, major, minor >>> 0);
+    const setter = asnative(realm, major, (minor + 1) >>> 0);
+    minor += 2;
+    if (name !== "" && getter instanceof Avm1Function) {
+      const p = object.own(name, version) ?? object.add(name, undefined, 0);
+      p.get = getter;
+      p.set = setter instanceof Avm1Function ? setter : null;
+      p.flags |= flags;
+    }
+  }
+
+  return undefined;
+}
+
+/** The global functions, defined on `_global` in Flash's order by `define`. */
+export function globalFunctions(realm: Realm, define: (name: string, native: Native) => void) {
+  const escapeFn: Native = (_, args, version) =>
+    args.length > 0 ? escapeAvm1(stringOf(args[0], version), version) : undefined;
+  const unescapeFn: Native = (_, args, version) =>
+    args.length > 0 ? unescapeAvm1(stringOf(args[0], version), version) : undefined;
+  const parseIntFn: Native = (_, args, version) =>
+    args.length > 0
+      ? parseIntAvm1(stringOf(args[0], version), args[1], args.length > 1, version)
+      : undefined;
+  const parseFloatFn: Native = (_, args, version) =>
+    args.length > 0 ? parseFloatAvm1(stringOf(args[0], version), false) : undefined;
+  // _global.trace: undefined is "" up to SWF 6, as any string conversion has it.
+  // Flash's authoring tool shows it, where Flash Player's log and adl's do
+  // not; the log is for debugging, so it writes, as Ruffle's does.
+  const traceFn: Native = (_, args, version) => {
+    realm.current?.host.trace(stringOf(args.length > 0 ? args[0] : undefined, version));
+    return undefined;
+  };
+  const setNativeFn: Native = (_, args, version) => setNative(realm, args, version, false);
+  const setAccessorFn: Native = (_, args, version) => setNative(realm, args, version, true);
+
+  realm.natives.set(
+    100,
+    (i) => [escapeFn, unescapeFn, parseIntFn, parseFloatFn, traceFn][i] ?? none,
+  );
+  realm.natives.set(4, (i) => [setNativeFn, setAccessorFn][i] ?? none);
+
+  define("ASSetNative", setNativeFn);
+  define("ASSetNativeAccessor", setAccessorFn);
+  define("escape", escapeFn);
+  define("unescape", unescapeFn);
+  define("parseInt", parseIntFn);
+  define("parseFloat", parseFloatFn);
+  define("trace", traceFn);
+  define("updateAfterEvent", () => undefined);
+  define("isNaN", (_, args, version) =>
+    args.length > 0 ? Number.isNaN(toNumber(args[0], version)) : true,
+  );
+  define("isFinite", (_, args, version) =>
+    args.length > 0 ? Number.isFinite(toNumber(args[0], version)) : false,
+  );
+  for (const [name, native] of timerFunctions(realm)) {
+    define(name, native);
+  }
+}
+
+/** A table's native for an index it has none at: undefined. */
+const none: Native = () => undefined;

package/src/avm1/globals/math.ts

@@ -0,0 +1,152 @@
+// Math, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/math.rs has it: MIT OR Apache-2.0, Copyright (c)
+// 2018-2022 Ruffle LLC and Ruffle contributors. Where adl parts from
+// Ruffle, adl decides (docs/avm1.md, "Number, Boolean and Math").
+//
+// Each method is ASnative(200, i), which converts its first two arguments
+// whether it uses them or not, as their valueOf can tell; a SWF up to 6
+// gets NaN from a method given fewer arguments than it takes.
+
+import { Avm1Object, DONT_DELETE, DONT_ENUM, type Native, READ_ONLY } from "../objects.js";
+import type { Realm } from "../realm.js";
+import { toNumber } from "../values.js";
+
+/** The methods, in the order of their ASnative indices. */
+const MATH_METHODS = [
+  "abs",
+  "min",
+  "max",
+  "sin",
+  "cos",
+  "atan2",
+  "tan",
+  "exp",
+  "log",
+  "sqrt",
+  "round",
+  "random",
+  "floor",
+  "ceil",
+  "atan",
+  "asin",
+  "acos",
+  "pow",
+] as const;
+
+const MIN = 1;
+const MAX = 2;
+const ATAN2 = 5;
+const RANDOM = 11;
+const POW = 17;
+
+/** A random number from 0 to 1, of the 2^31 Flash's generator gives. */
+const random = () => Math.floor(Math.random() * 0x80000000) / 0x80000000;
+
+/** Whether a SWF up to 6 runs method `index` with `count` arguments, `x` the first. */
+function enough(index: number, count: number, x: number): boolean {
+  switch (index) {
+    case RANDOM:
+      return true;
+    case MIN:
+    case MAX:
+      return count !== 1;
+    case POW:
+      return count > 1 || (count === 1 && x === 1);
+    case ATAN2:
+      return count > 1;
+    default:
+      return count > 0;
+  }
+}
+
+/**
+ * C's pow, as Flash Player's is (the corpus's math tests): 1 to any power
+ * and -1 to an infinite one are 1, where JavaScript's are NaN. adl's, AIR's
+ * under Wine, is JavaScript's there, and off it elsewhere (2^0.5's last
+ * bit, 1.0000001^1e9 from the ninth digit): JavaScript's precision stays.
+ */
+function pow(x: number, y: number): number {
+  if (x === 1 || (x === -1 && (y === Number.POSITIVE_INFINITY || y === Number.NEGATIVE_INFINITY))) {
+    return 1;
+  }
+
+  return x ** y;
+}
+
+function compute(index: number, x: number, y: number, count: number): number {
+  switch (index) {
+    case 0:
+      return Math.abs(x);
+    case MIN:
+      return count === 0 ? Number.POSITIVE_INFINITY : Math.min(x, y);
+    case MAX:
+      return count === 0 ? Number.NEGATIVE_INFINITY : Math.max(x, y);
+    case 3:
+      return Math.sin(x);
+    case 4:
+      return Math.cos(x);
+    case ATAN2:
+      return Math.atan2(x, y);
+    case 6:
+      return Math.tan(x);
+    case 7:
+      return Math.exp(x);
+    case 8:
+      return Math.log(x);
+    case 9:
+      return Math.sqrt(x);
+    // Flash rounds a half up, towards infinity.
+    case 10:
+      return Math.floor(x + 0.5);
+    case RANDOM:
+      return random();
+    case 12:
+      return Math.floor(x);
+    case 13:
+      return Math.ceil(x);
+    case 14:
+      return Math.atan(x);
+    case 15:
+      return Math.asin(x);
+    case 16:
+      return Math.acos(x);
+    case POW:
+      return pow(x, y);
+    default:
+      return Number.NaN;
+  }
+}
+
+/** ASnative(200, index): a Math method, NaN for an index of none. */
+export function mathNative(index: number): Native {
+  return (_, args, version) => {
+    const x = toNumber(args.length > 0 ? args[0] : undefined, version);
+    const y = toNumber(args.length > 1 ? args[1] : undefined, version);
+    if (version <= 6 && !enough(index, args.length, x)) {
+      return Number.NaN;
+    }
+
+    return compute(index, x, y, args.length);
+  };
+}
+
+/** The Math object: `constructor` and `__proto__` as an object's, its constants, then its methods. */
+export function mathObject(realm: Realm): Avm1Object {
+  const math = new Avm1Object();
+  math.define("constructor", realm.Object, DONT_ENUM | DONT_DELETE);
+  math.define("__proto__", realm.objectProto, DONT_ENUM | DONT_DELETE);
+  const flags = DONT_ENUM | DONT_DELETE | READ_ONLY;
+  math.define("SQRT2", Math.SQRT2, flags);
+  math.define("SQRT1_2", Math.SQRT1_2, flags);
+  math.define("PI", Math.PI, flags);
+  math.define("LOG2E", Math.LOG2E, flags);
+  math.define("LOG10E", Math.LOG10E, flags);
+  math.define("LN2", Math.LN2, flags);
+  math.define("LN10", Math.LN10, flags);
+  math.define("E", Math.E, flags);
+  for (let i = 0; i < MATH_METHODS.length; i++) {
+    math.define(MATH_METHODS[i], realm.method(mathNative(i)), flags);
+  }
+
+  return math;
+}

package/src/avm1/globals/number.ts

@@ -0,0 +1,122 @@
+// Number and Boolean, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/number.rs and boolean.rs have them: MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+// Where adl parts from Ruffle, adl decides (docs/avm1.md, "Number, Boolean
+// and Math").
+//
+// Their methods take `this` unboxed, and give undefined for anything but
+// their own kind of value, a primitive or its object.
+
+import { numberToString } from "../numbers.js";
+import { Avm1Object, DONT_DELETE, DONT_ENUM, type RawNative, READ_ONLY } from "../objects.js";
+import { clampInt } from "../operators.js";
+import type { Class, Realm } from "../realm.js";
+import { toBoolean, toNumber, type Value } from "../values.js";
+
+/** `this` as a Number's number, undefined for anything else. */
+const numberOf = (self: Value): number | undefined =>
+  typeof self === "number"
+    ? self
+    : self instanceof Avm1Object && typeof self.primitive === "number"
+      ? self.primitive
+      : undefined;
+
+/** `this` as a Boolean's boolean, undefined for anything else. */
+const booleanOf = (self: Value): boolean | undefined =>
+  typeof self === "boolean"
+    ? self
+    : self instanceof Avm1Object && typeof self.primitive === "boolean"
+      ? self.primitive
+      : undefined;
+
+/** A double cast to an int as Rust's `as` casts it: saturated, NaN 0. */
+const saturated = (n: number): number =>
+  Number.isNaN(n) ? 0 : Math.trunc(Math.max(-2147483648, Math.min(2147483647, n)));
+
+/**
+ * `n` in base `radix`, as Flash writes it: the number cast to an int, so
+ * that a fraction is cut, and NaN, the infinities and anything out of range
+ * are -2^31, whose digits Flash writes as the remainders it takes, each
+ * negative: `(1e20).toString(16)` is "-(0000000".
+ */
+export function toRadix(n: number, radix: number): string {
+  let v = clampInt(n);
+  if (v === 0) {
+    return "0";
+  }
+
+  const negative = v < 0;
+  if (negative) {
+    v = -v | 0;
+  }
+
+  let digits = "";
+  while (v !== 0) {
+    const d = v % radix;
+    v = Math.trunc(v / radix);
+    digits = String.fromCharCode(d < 10 ? 0x30 + d : 0x61 + d - 10) + digits;
+  }
+
+  return negative ? `-${digits}` : digits;
+}
+
+export function numberClass(realm: Realm): Class {
+  const proto = new Avm1Object();
+  const constr = realm.classOf(
+    proto,
+    (self, args, version) => {
+      self.primitive = args.length > 0 ? toNumber(args[0], version) : 0;
+      return self;
+    },
+    (_, args, version) => (args.length > 0 ? toNumber(args[0], version) : 0),
+    // Read-only, as Object's is (adl), unlike Boolean's and String's.
+    READ_ONLY,
+  );
+  proto.define("__proto__", realm.objectProto, DONT_ENUM | DONT_DELETE);
+
+  const constant = DONT_ENUM | DONT_DELETE | READ_ONLY;
+  constr.define("NaN", Number.NaN, constant);
+  constr.define("POSITIVE_INFINITY", Number.POSITIVE_INFINITY, constant);
+  constr.define("NEGATIVE_INFINITY", Number.NEGATIVE_INFINITY, constant);
+  constr.define("MIN_VALUE", Number.MIN_VALUE, constant);
+  constr.define("MAX_VALUE", Number.MAX_VALUE, constant);
+
+  const define = (name: string, native: RawNative) =>
+    proto.define(name, realm.rawMethod(native), DONT_ENUM | DONT_DELETE);
+  define("valueOf", (self) => numberOf(self));
+  define("toString", (self, args, version) => {
+    const n = numberOf(self);
+    if (n === undefined) {
+      return undefined;
+    }
+
+    const radix = args.length > 0 ? saturated(toNumber(args[0], version)) : 10;
+    return radix < 2 || radix > 36 || radix === 10 ? numberToString(n) : toRadix(n, radix);
+  });
+
+  return { constr, proto };
+}
+
+export function booleanClass(realm: Realm): Class {
+  const proto = new Avm1Object();
+  const constr = realm.classOf(
+    proto,
+    (self, args, version) => {
+      self.primitive = args.length > 0 && toBoolean(args[0], version);
+      return self;
+    },
+    // Boolean() of nothing is undefined.
+    (_, args, version) => (args.length > 0 ? toBoolean(args[0], version) : undefined),
+  );
+  proto.define("__proto__", realm.objectProto, DONT_ENUM | DONT_DELETE);
+
+  const define = (name: string, native: RawNative) =>
+    proto.define(name, realm.rawMethod(native), DONT_ENUM | DONT_DELETE);
+  define("valueOf", (self) => booleanOf(self));
+  define("toString", (self) => {
+    const b = booleanOf(self);
+    return b === undefined ? undefined : String(b);
+  });
+
+  return { constr, proto };
+}