@swf2es/runtime 0.0.0-stage → 0.1.1

package/src/avm1/globals/string.ts

@@ -0,0 +1,254 @@
+// String, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/string.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, "Array and String").
+//
+// The methods take `this` unboxed: a string's method call makes no String
+// object. Up to SWF 5 a string is its bytes, each a code unit here, which
+// the methods count and cut as they are. From SWF 6 they cut UTF-16 code
+// units, and keep half a surrogate pair as it is, which joins its other
+// half again (adl), unlike StringExtract's (operators.ts).
+
+import { lowerCase, upperCase } from "../case.js";
+import {
+  type Avm1Function,
+  Avm1Object,
+  DONT_DELETE,
+  DONT_ENUM,
+  type RawNative,
+} from "../objects.js";
+import type { Realm } from "../realm.js";
+import { stringOf, toNumber, type Value } from "../values.js";
+
+const toInt = (value: Value, version: number) => toNumber(value, version) | 0;
+
+/** An index as slice and substr take one: from the end where negative, within 0 and `length`. */
+function wrapping(i: number, length: number): number {
+  return i < 0 ? Math.max(length + i, 0) : Math.min(i, length);
+}
+
+/** An index as substring takes one: within 0 and `length`. */
+const clamped = (i: number, length: number) => (i < 0 ? 0 : Math.min(i, length));
+
+/** Each code unit of `s` mapped by `map`; up to SWF 5, a byte's mapping only to a byte. */
+function mapped(s: string, map: (c: number) => number, bytes: boolean): string {
+  let out = "";
+  let changed = false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    let m = map(c);
+    if (bytes && m > 0xff) {
+      m = c;
+    }
+
+    changed ||= m !== c;
+    out += String.fromCharCode(m);
+  }
+
+  return changed ? out : s;
+}
+
+/** The class: its constructor, prototype and methods. */
+export function stringClass(realm: Realm): { constr: Avm1Function; proto: Avm1Object } {
+  const proto = new Avm1Object();
+  const constr = realm.classOf(
+    proto,
+    (self, args, version) => {
+      const s = args.length > 0 ? stringOf(args[0], version) : "";
+      self.primitive = s;
+      self.define("length", s.length, DONT_ENUM | DONT_DELETE);
+      return self;
+    },
+    (_, args, version) => (args.length > 0 ? stringOf(args[0], version) : ""),
+  );
+  proto.define("__proto__", realm.objectProto, DONT_ENUM | DONT_DELETE);
+
+  /** `this` as the string the methods work on: a String's own, else what it converts to. */
+  const text = (self: Value, version: number): string => {
+    if (typeof self === "string") {
+      return self;
+    }
+
+    const o = realm.box(self, version);
+    return typeof o.primitive === "string" ? o.primitive : stringOf(o, version);
+  };
+  const define = (name: string, native: RawNative) =>
+    proto.define(name, realm.rawMethod(native), DONT_ENUM | DONT_DELETE);
+
+  // A String's own string, but undefined for anything else; valueOf gives
+  // anything else as a string, by its toString (adl; Ruffle gives undefined).
+  const own = (self: Value): Value => {
+    if (typeof self === "string") {
+      return self;
+    }
+
+    return self instanceof Avm1Object && typeof self.primitive === "string"
+      ? self.primitive
+      : undefined;
+  };
+  define("valueOf", (self, _, version) => own(self) ?? text(self, version));
+  define("toString", (self) => own(self));
+  define("toUpperCase", (self, _, version) => mapped(text(self, version), upperCase, version < 6));
+  define("toLowerCase", (self, _, version) => mapped(text(self, version), lowerCase, version < 6));
+  define("charAt", (self, args, version) => {
+    const s = text(self, version);
+    const i = toInt(args.length > 0 ? args[0] : undefined, version);
+    if (i < 0 || i >= s.length) {
+      return "";
+    }
+
+    return s[i];
+  });
+  define("charCodeAt", (self, args, version) => {
+    const s = text(self, version);
+    const i = toInt(args.length > 0 ? args[0] : undefined, version);
+    if (i >= 0 && i < s.length) {
+      return s.charCodeAt(i);
+    }
+
+    // A SWF 5 has 0 past the end.
+    return i >= 0 && version === 5 ? 0 : Number.NaN;
+  });
+  define("concat", (self, args, version) => {
+    let s = text(self, version);
+    for (const arg of args) {
+      s += stringOf(arg, version);
+    }
+
+    return s;
+  });
+  define("indexOf", (self, args, version) => {
+    const s = text(self, version);
+    if (args.length === 0) {
+      return undefined;
+    }
+
+    const pattern = stringOf(args[0], version);
+    const start =
+      args.length > 1 && args[1] !== undefined ? Math.max(toInt(args[1], version), 0) : 0;
+    return start > s.length ? -1 : s.indexOf(pattern, start);
+  });
+  define("lastIndexOf", (self, args, version) => {
+    const s = text(self, version);
+    if (args.length === 0) {
+      return undefined;
+    }
+
+    const pattern = stringOf(args[0], version);
+    let end = s.length;
+    if (args.length > 1 && args[1] !== undefined) {
+      const i = toInt(args[1], version);
+      if (i < 0) {
+        return -1;
+      }
+
+      end = Math.min(i + pattern.length, s.length);
+    }
+
+    const found = s.lastIndexOf(pattern, end - pattern.length);
+    return found >= 0 && found + pattern.length <= end ? found : -1;
+  });
+  define("slice", (self, args, version) => {
+    if (args.length === 0) {
+      return undefined;
+    }
+
+    const s = text(self, version);
+    const start = wrapping(toInt(args[0], version), s.length);
+    const end =
+      args.length > 1 && args[1] !== undefined
+        ? wrapping(toInt(args[1], version), s.length)
+        : s.length;
+    return start < end ? s.slice(start, end) : "";
+  });
+  define("substring", (self, args, version) => {
+    if (args.length === 0) {
+      return undefined;
+    }
+
+    const s = text(self, version);
+    let start = clamped(toInt(args[0], version), s.length);
+    // adl: nothing from the end on, whatever the end (Ruffle swaps first).
+    if (start >= s.length) {
+      return "";
+    }
+
+    let end =
+      args.length > 1 && args[1] !== undefined
+        ? clamped(toInt(args[1], version), s.length)
+        : s.length;
+    if (end < start) {
+      [start, end] = [end, start];
+    }
+
+    return s.slice(start, end);
+  });
+  define("split", (self, args, version) => {
+    const s = text(self, version);
+    const limitArg = args.length > 1 ? args[1] : undefined;
+    const limit =
+      limitArg === undefined ? Number.POSITIVE_INFINITY : Math.max(toInt(limitArg, version), 0);
+    const d = args.length > 0 ? args[0] : undefined;
+    const take = (parts: string[]) =>
+      realm.newArray(limit < parts.length ? parts.slice(0, limit) : parts, version);
+    // A SWF 5 splits at commas by default, and only at one character: an
+    // empty delimiter leaves the string whole whatever the limit, a longer
+    // one within it (adl).
+    if (version < 6) {
+      const delimiter = d === undefined ? "," : stringOf(d, version);
+      if (delimiter === "") {
+        return realm.newArray([s], version);
+      }
+
+      return take(delimiter.length === 1 ? s.split(delimiter) : [s]);
+    }
+
+    // Without a delimiter, the string whole whatever the limit; an empty
+    // string so too, but split by "" (adl).
+    if (d === undefined) {
+      return realm.newArray([s], version);
+    }
+
+    const delimiter = stringOf(d, version);
+    if (s === "" && delimiter !== "") {
+      return realm.newArray([s], version);
+    }
+
+    return take(delimiter === "" ? s.split("") : s.split(delimiter));
+  });
+  define("substr", (self, args, version) => {
+    if (args.length === 0) {
+      return undefined;
+    }
+
+    const s = text(self, version);
+    const start = wrapping(toInt(args[0], version), s.length);
+    const count = args.length > 1 && args[1] !== undefined ? toInt(args[1], version) : s.length;
+    const end = wrapping(start + count, s.length);
+    return start < end ? s.slice(start, end) : "";
+  });
+
+  constr.define(
+    "fromCharCode",
+    realm.method((_, args, version) => {
+      let s = "";
+      for (const arg of args) {
+        const code = toNumber(arg, version) & 0xffff;
+        if (code === 0) {
+          break;
+        }
+
+        // A SWF 5's string is bytes: a code past 0xFF is two, the high one first.
+        s +=
+          version < 6 && code > 0xff
+            ? String.fromCharCode(code >> 8, code & 0xff)
+            : String.fromCharCode(code);
+      }
+
+      return s;
+    }),
+    DONT_ENUM | DONT_DELETE,
+  );
+
+  return { constr, proto };
+}

package/src/avm1/globals/timers.ts

@@ -0,0 +1,144 @@
+// setInterval, setTimeout, clearInterval and clearTimeout (docs/avm1.md,
+// "Time"), as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/timer.rs and avm1/globals.rs (create_timer) have them: MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+// The timers are the runtime's, the clock the player's: it tells the
+// runtime the time and asks it to fire what is due between frames.
+
+import { Avm1Function, Avm1Object, type Native } from "../objects.js";
+import { toInt32 } from "../operators.js";
+import type { Realm } from "../realm.js";
+import { stringOf, type Value } from "../values.js";
+
+/** The shortest interval a timer has, in ms, as Ruffle has it: Flash fires none much faster. */
+const MIN_INTERVAL = 10;
+
+/** A timer: a function to call, or an object and the name of its method, every `interval` ms. */
+export class Timer {
+  constructor(
+    readonly id: number,
+    readonly callback: Avm1Object,
+    /** The method's name, null where `callback` is the function. */
+    readonly method: string | null,
+    readonly args: Value[],
+    readonly interval: number,
+    /** When it falls due next, in the clock's ms. */
+    public due: number,
+    /** setTimeout's: it fires once. */
+    readonly once: boolean,
+    /** Its place among those due at once: the one set first fires first. */
+    public seq: number,
+  ) {}
+}
+
+/** A runtime's timers, by when they fall due. */
+export class Timers {
+  /** The time now on the player's clock, in ms: a timer set now counts from it. */
+  now = 0;
+  private counter = 0;
+  private seq = 0;
+  private readonly list: Timer[] = [];
+
+  get size(): number {
+    return this.list.length;
+  }
+
+  /** A new timer, its id: from 1, as Flash never gives 0. */
+  add(
+    callback: Avm1Object,
+    method: string | null,
+    args: Value[],
+    interval: number,
+    once: boolean,
+  ): number {
+    this.counter = (this.counter + 1) | 0;
+    const ms = Math.max(interval, MIN_INTERVAL);
+    this.list.push(
+      new Timer(this.counter, callback, method, args, ms, this.now + ms, once, this.seq++),
+    );
+    return this.counter;
+  }
+
+  /** Clear timer `id`: whether there was one. */
+  remove(id: number): boolean {
+    const i = this.list.findIndex((t) => t.id === id);
+    if (i < 0) {
+      return false;
+    }
+
+    this.list.splice(i, 1);
+    return true;
+  }
+
+  has(timer: Timer): boolean {
+    return this.list.includes(timer);
+  }
+
+  /** The timer due first by `time`, of two due at once the one set first; null for none. */
+  due(time: number): Timer | null {
+    let first: Timer | null = null;
+    for (const t of this.list) {
+      if (
+        t.due <= time &&
+        (first === null || t.due < first.due || (t.due === first.due && t.seq < first.seq))
+      ) {
+        first = t;
+      }
+    }
+
+    return first;
+  }
+
+  /** `timer` fired: due again an interval on, or gone for a timeout. */
+  fired(timer: Timer): void {
+    if (timer.once) {
+      this.remove(timer.id);
+    } else {
+      timer.due += timer.interval;
+      timer.seq = this.seq++;
+    }
+  }
+
+  clear(): void {
+    this.list.length = 0;
+  }
+}
+
+/**
+ * setInterval's and setTimeout's native: `(function, interval, ...args)`
+ * or `(object, name, interval, ...args)`; undefined where there is no
+ * callback or no interval.
+ */
+function create(realm: Realm, args: Value[], version: number, once: boolean): Value {
+  const first = args.length > 0 ? args[0] : undefined;
+  if (!(first instanceof Avm1Object)) {
+    return undefined;
+  }
+
+  const isFunction = first instanceof Avm1Function;
+  const interval = isFunction ? args[1] : args[2];
+  if (interval === undefined) {
+    return undefined;
+  }
+
+  const method = isFunction ? null : stringOf(args.length > 1 ? args[1] : undefined, version);
+  const rest = args.slice(isFunction ? 2 : 3);
+  return realm.timers.add(first, method, rest, toInt32(interval, version), once);
+}
+
+/** The timer natives, in Flash's order on `_global`, and ASnative(250, i): setInterval, clearInterval, setTimeout. */
+export function timerFunctions(realm: Realm): [string, Native][] {
+  const setInterval: Native = (_, args, version) => create(realm, args, version, false);
+  const setTimeout: Native = (_, args, version) => create(realm, args, version, true);
+  const clear: Native = (_, args, version) => {
+    realm.timers.remove(toInt32(args.length > 0 ? args[0] : undefined, version));
+    return undefined;
+  };
+  realm.natives.set(250, (i) => [setInterval, clear, setTimeout][i] ?? null);
+  return [
+    ["setInterval", setInterval],
+    ["clearTimeout", clear],
+    ["clearInterval", clear],
+    ["setTimeout", setTimeout],
+  ];
+}

package/src/avm1/host.ts

@@ -0,0 +1,155 @@
+// What AVM1 code asks of the player, which has the display list the
+// runtime does not (docs/avm1.md, "Where each piece lives"). A clip is the
+// player's, opaque here.
+
+import type { Avm1Object } from "./objects.js";
+import type { Value } from "./values.js";
+
+/** A display object the player gives the runtime, as an activation's target. */
+export type Target = object;
+
+/** What a display object's AVM1 object found for a name that is none of its own properties: nothing. */
+export const ABSENT: unique symbol = Symbol("absent");
+
+/**
+ * A display object's side of its AVM1 object (docs/avm1.md, "Hosting AVM1
+ * objects"): what the object has beyond its own properties, looked up
+ * after them and before its prototypes', as Ruffle's stage_object.rs has
+ * it. The player gives each clip, button and text field one.
+ */
+export interface DisplayNative {
+  /** What `typeof` says of the object: "movieclip" for a clip, else "object". */
+  readonly type: string;
+  /** The display object. */
+  readonly target: Target;
+  /**
+   * `_root`, `_parent`, `_global` and `_levelN`, in the version's case; a
+   * child by its instance name; a display property (`_x`...), in any case;
+   * ABSENT for none of them.
+   */
+  get(name: string, version: number): Value | typeof ABSENT;
+  /**
+   * A set of a display property by name, which the object takes where it
+   * has no property of its own of the name: whether it was one.
+   */
+  set(name: string, value: Value, version: number): boolean;
+  /**
+   * Any property of the object set, before it is stored: a text field
+   * bound to the name as a variable shows the value (Ruffle's
+   * notify_property_change).
+   */
+  changed?(name: string, value: Value, version: number): void;
+  /** Its children's names, the highest depth first, which for..in lists after its own properties. */
+  keys(out: string[]): void;
+  /** Its path, `_level0.a.b`, which TargetPath gives, and a clip converts to as a string. */
+  path(): string;
+  /**
+   * The AVM1 object a reference to this one reaches now: itself, or once
+   * its display object is gone, the one placed at its path since (a clip's
+   * reference is its path in Flash), null where there is none.
+   */
+  live(): Avm1Object | null;
+  /** GetProperty's property `index` (0 `_x` to 21 `_ymouse`), undefined for none. */
+  property(index: number, version: number): Value;
+  /** SetProperty's property `index` set: false where there is none. */
+  setProperty(index: number, value: Value, version: number): boolean;
+}
+
+/** What timeline actions do to a clip. */
+export interface Timeline {
+  readonly currentFrame: number;
+  readonly totalFrames: number;
+  /** A goto of frame `frame`, 1 the first, past the last the last, after the clip is played or stopped. */
+  goto(frame: number, play: boolean): void;
+  /** The frame of label `label`, in any ASCII case, undefined for none. */
+  labelFrame(label: string): number | undefined;
+  /** The actions of frame `frame` run now, as CallFrame runs them. */
+  call(frame: number): void;
+}
+
+/**
+ * The variables a getURL, loadMovie or loadVariables sends, the code's
+ * locals as strings in for..in's order, and how: in the query or the body.
+ */
+export interface UrlForm {
+  method: "GET" | "POST";
+  vars: [name: string, value: string][];
+}
+
+export interface Host {
+  /**
+   * A trace's text, as it is: Flash's log breaks its lines at a carriage
+   * return as at a line feed, which is the host's to do where it writes one.
+   */
+  trace(text: string): void;
+  /** Play or stop `target`'s timeline. */
+  play(target: Target): void;
+  stop(target: Target): void;
+  /**
+   * Stop the whole SWF, every timeline and every action of it, as Flash
+   * does at an action it cannot read.
+   */
+  halt(): void;
+  /**
+   * What paths need of the display list (docs/avm1.md, "Scopes, targets
+   * and names"), each a clip's AVM1 object: the `_root` of the code whose
+   * clip is `base` (its level, or the clip below it that locks the root),
+   * `_levelN`, a clip's parent, and a clip's child by its instance name,
+   * found in its case from SWF 7. A host without a display list leaves
+   * them out.
+   */
+  root?(base: Target): Value;
+  level?(level: number): Value;
+  parent?(clip: object): Value;
+  child?(clip: object, name: string, caseSensitive: boolean): Value;
+  /** The display object whose AVM1 object `object` is, where it is one's. */
+  clipOf?(object: object): Target | undefined;
+  /** The AVM1 object of `target`. */
+  objectOf?(target: Target): Avm1Object;
+  /** Whether `target` has been removed: SetTarget in its code finds no clip. */
+  removed?(target: Target): boolean;
+  /** The timeline of `target` where it is a clip, null for anything else. */
+  timeline?(target: Target): Timeline | null;
+  /** StopSounds: every sound playing stops. */
+  stopSounds?(): void;
+  /** GetTime: ms since the movie started, on the player's clock. */
+  time?(): number;
+  /**
+   * CloneSprite: `target` duplicated as `name` at timeline depth `depth`,
+   * as duplicateMovieClip does it, without an init object.
+   */
+  duplicate?(target: Target, name: string, depth: number): void;
+  /** RemoveSprite: `target` removed, where it is at a depth a script may remove. */
+  remove?(target: Target): void;
+  /**
+   * StartDrag: `target` follows the pointer, its registration point under
+   * it where `lockCenter`, kept within `bounds` (left, top, right, bottom
+   * in its parent's space) where given; one drag at a time.
+   */
+  startDrag?(target: Target, lockCenter: boolean, bounds: number[] | null): void;
+  /** EndDrag: the drag ends. */
+  stopDrag?(): void;
+  /**
+   * A function of the SWF's that code called by CallFunction or
+   * CallMethod returned: Flash runs the initialize events queued by then.
+   */
+  returned?(): void;
+  /** ToggleQuality: the stage's quality from high or best to low, or back. */
+  toggleQuality?(): void;
+  /** fscommand: a GetURL's or GetURL2's URL `FSCommand:command`, its target the arguments. */
+  fsCommand?(command: string, args: string): void;
+  /**
+   * getURL: the page `url`, as the SWF gave it, opened in the browser
+   * window or frame named `window` ("_blank" in any spelling as
+   * "_blank"), with `form`'s variables where a method was given.
+   */
+  navigate?(url: string, window: string, form: UrlForm | null): void;
+  /**
+   * loadMovie and loadMovieNum: the SWF or image at `url` into a clip, or
+   * into the level of a number, which the load makes where there is none;
+   * an empty URL unloads what is there.
+   */
+  loadMovie?(into: Target | number, url: string, form: UrlForm | null): void;
+  /** loadVariables and loadVariablesNum: the variables at `url` set on a clip. */
+  loadVariables?(into: Target, url: string, form: UrlForm | null): void;
+}

package/src/avm1/index.ts

@@ -0,0 +1,69 @@
+/** The AVM1 (AS1 and AS2) runtime: values, their conversions by version, and what modules call. */
+
+export { goto } from "./clips.js";
+export { Avm1Super, ScriptFunction } from "./functions.js";
+export { broadcastMessage, initializeBroadcaster } from "./globals/broadcaster.js";
+export { DateCell } from "./globals/date.js";
+export { escapeAvm1, parseIntAvm1, unescapeAvm1 } from "./globals/global.js";
+export {
+  ABSENT,
+  type DisplayNative,
+  type Host,
+  type Target,
+  type Timeline,
+  type UrlForm,
+} from "./host.js";
+export { numberToString, parseFloatAvm1, stringToNumber } from "./numbers.js";
+export {
+  Avm1Function,
+  Avm1Object,
+  allowed,
+  caseSensitive,
+  DONT_DELETE,
+  DONT_ENUM,
+  find,
+  fold,
+  get,
+  has,
+  invoke,
+  keys,
+  markNames,
+  type Native,
+  Property,
+  READ_ONLY,
+  removeOwn,
+  set,
+  VERSION_6,
+  VERSION_7,
+  VERSION_8,
+} from "./objects.js";
+export { Realm } from "./realm.js";
+export {
+  Activation,
+  Avm1Throw,
+  type Blocks,
+  Disabled,
+  type Factory,
+  Halt,
+  NotYet,
+  type Operations,
+  OwnUnits,
+  type Region,
+  Runtime,
+  TimedOut,
+  type Units,
+  type UnitTable,
+} from "./runtime.js";
+export { Scope, targetPath } from "./scope.js";
+export { getUrlMethod } from "./urls.js";
+export {
+  isPrimitive,
+  type ObjectConversions,
+  objects,
+  type Primitive,
+  stringOf,
+  toBoolean,
+  toNumber,
+  typeOf,
+  type Value,
+} from "./values.js";