@swf2es/player 0.0.0-stage → 0.1.1

package/src/playerglobal/flash/net/local-values.ts

@@ -0,0 +1,245 @@
+// AMF0 values crossing LocalConnection's VM boundary. The AS2 codec owns
+// the byte format; this adapter creates and reads AS3 objects without
+// retaining either VM's live arguments in a queued message.
+import { avm2 } from "@swf2es/runtime";
+import * as A from "../../../avm1/amf.js";
+import { LOCAL_MESSAGE_LIMIT } from "../../../localconnection.js";
+
+type Value = avm2.Value;
+type Obj = avm2.AsObject;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+export function writeLocalValues(rt: avm2.Runtime, args: Value[]): Uint8Array {
+  // The original AMF3 payload is already bounded; AMF0 can expand small integers.
+  const out = new A.Writer(() => null, 8, null, null);
+  const references = new Map<Obj, number>();
+  let next = 1;
+  const write = (value: Value, depth: number): void => {
+    if (depth >= A.MAX_DEPTH - 2) {
+      out.bytes(A.UNDEFINED);
+      return;
+    }
+
+    if (value instanceof avm2.FloatValue) {
+      out.value(value.value);
+      return;
+    }
+
+    if (value === null || (typeof value !== "object" && typeof value !== "function")) {
+      out.value(value as number | string | boolean | null | undefined);
+      return;
+    }
+
+    if (value.$display) {
+      out.bytes(A.UNDEFINED);
+      return;
+    }
+
+    const traits = rt.traitsOf(value);
+    if ("$time" in value) {
+      out.bytes(A.DATE);
+      out.double(value.$time);
+      out.u16(0);
+      return;
+    }
+
+    if (traits.name === "XML" || traits.name === "flash.xml::XMLDocument") {
+      const text = rt.toString(
+        rt.callProperty(value, rt.publicName(traits.name === "XML" ? "toXMLString" : "toString")),
+      );
+      if (text.length > LOCAL_MESSAGE_LIMIT) {
+        throw new RangeError("LocalConnection message too large");
+      }
+
+      const bytes = encoder.encode(text);
+      out.bytes(A.XML);
+      out.u32(bytes.length);
+      out.push(bytes);
+      return;
+    }
+
+    const seen = references.get(value);
+    if (seen !== undefined) {
+      out.bytes(A.REFERENCE);
+      out.u16(seen);
+      return;
+    }
+
+    references.set(value, next++);
+    if (value.$a) {
+      const array = value.$a as Value[];
+      const properties = value.$d;
+      if (properties?.size) {
+        out.bytes(A.ECMA_ARRAY);
+        out.u32(array.length);
+        for (const key of Object.keys(array)) {
+          out.name(key);
+          write(array[Number(key)], depth + 1);
+        }
+        for (const [key, field] of properties) {
+          out.name(key);
+          write(field, depth + 1);
+        }
+
+        out.bytes(0, 0, A.OBJECT_END);
+        return;
+      }
+
+      if (array.length > LOCAL_MESSAGE_LIMIT) {
+        throw new RangeError("LocalConnection message too large");
+      }
+
+      out.bytes(A.STRICT_ARRAY);
+      out.u32(array.length);
+      for (let i = 0; i < array.length; i++) {
+        write(array[i], depth + 1);
+      }
+      return;
+    }
+
+    const alias = rt.aliasOf(traits);
+    out.bytes(alias === "" ? A.OBJECT : A.TYPED_OBJECT);
+    if (alias !== "") {
+      out.name(alias);
+    }
+
+    const names = new Set<string>();
+    for (let t: typeof traits | null = traits; t !== null; t = t.base) {
+      for (const [name, bindings] of t.bindings) {
+        for (const binding of bindings) {
+          if (
+            binding.ns.kind === avm2.publicNs.kind &&
+            binding.ns.uri === "" &&
+            (binding.value & 7) === 2
+          ) {
+            names.add(name);
+          }
+        }
+      }
+    }
+    for (const name of value.$d?.keys() ?? []) {
+      names.add(name);
+    }
+    for (const name of names) {
+      const field = rt.getProperty(value, rt.publicName(name));
+      if (typeof field === "function" || (field && typeof field === "object" && field.$f)) {
+        continue;
+      }
+
+      out.name(name);
+      write(field, depth + 1);
+    }
+    out.bytes(0, 0, A.OBJECT_END);
+  };
+  out.bytes(A.STRICT_ARRAY);
+  out.u32(args.length);
+  for (const value of args) {
+    write(value, 0);
+  }
+
+  return out.finish();
+}
+
+export function readLocalValues(rt: avm2.Runtime, bytes: Uint8Array): Value[] {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const references: Value[] = [];
+  let at = 0;
+  const u16 = () => {
+    const n = view.getUint16(at);
+    at += 2;
+    return n;
+  };
+  const u32 = () => {
+    const n = view.getUint32(at);
+    at += 4;
+    return n;
+  };
+  const utf = (length: number) => {
+    if (length > bytes.length - at) {
+      throw new RangeError("LocalConnection message ended early");
+    }
+    const text = decoder.decode(bytes.subarray(at, at + length));
+    at += length;
+
+    return text;
+  };
+  const name = () => utf(u16());
+  const read = (depth: number): Value => {
+    if (depth >= A.MAX_DEPTH) {
+      throw new RangeError("LocalConnection arguments nested too deeply");
+    }
+
+    const marker = bytes[at++];
+    switch (marker) {
+      case A.NUMBER: {
+        const n = view.getFloat64(at);
+        at += 8;
+        return n;
+      }
+      case A.BOOLEAN:
+        return bytes[at++] !== 0;
+      case A.STRING:
+        return name();
+      case A.LONG_STRING:
+        return utf(u32());
+      case A.NULL:
+        return null;
+      case A.UNDEFINED:
+      case A.UNSUPPORTED:
+        return undefined;
+      case A.REFERENCE:
+        return references[u16()];
+      case A.DATE: {
+        const time = view.getFloat64(at);
+        at += 10;
+        return rt.construct(rt.classNamed("Date"), time);
+      }
+      case A.XML:
+        return rt.construct(rt.classNamed("flash.xml::XMLDocument"), utf(u32()));
+      case A.STRICT_ARRAY: {
+        const count = u32();
+        if (count > bytes.length - at) {
+          throw new RangeError("LocalConnection message ended early");
+        }
+        const result = rt.newArray([]);
+        references.push(result);
+        for (let i = 0; i < count; i++) {
+          result.$a.push(read(depth + 1));
+        }
+
+        return result;
+      }
+      case A.OBJECT:
+      case A.TYPED_OBJECT:
+      case A.ECMA_ARRAY: {
+        let result: Obj;
+        if (marker === A.TYPED_OBJECT) {
+          result = rt.allocate(rt.classByAlias(name(), true)) ?? rt.newObject([]);
+        } else {
+          result = marker === A.ECMA_ARRAY ? rt.newArray([]) : rt.newObject([]);
+        }
+        const length = marker === A.ECMA_ARRAY ? u32() : 0;
+        references.push(result);
+        for (;;) {
+          const key = name();
+          if (key === "" && bytes[at] === A.OBJECT_END) {
+            at++;
+            break;
+          }
+          rt.setProperty(result, rt.publicName(key), read(depth + 1));
+        }
+        if (marker === A.ECMA_ARRAY && length > result.$a.length) {
+          result.$a.length = length;
+        }
+
+        return result;
+      }
+      default:
+        throw new RangeError("Invalid LocalConnection AMF0 marker");
+    }
+  };
+  const result = read(0) as Obj;
+
+  return result.$a as Value[];
+}

package/src/playerglobal/flash/net/navigateToURL.ts

@@ -0,0 +1,42 @@
+// flash.net's navigateToURL and sendToURL: a page the host opens, and a
+// request the host sends whose response nobody reads. Both check their
+// arguments as Flash does, request then its url (TypeError #2007, as adl
+// throws them), and take the request as URLStream's load does.
+import type { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function navigateNatives(s: Scripting): avm2.Natives {
+  const checked = (rt: avm2.Runtime, request: Value): avm2.AsObject => {
+    if (request === null || request === undefined) {
+      throw rt.error("TypeError", 2007, "request");
+    }
+
+    if (request.$url === null || request.$url === undefined) {
+      throw rt.error("TypeError", 2007, "url");
+    }
+
+    return request;
+  };
+
+  return {
+    "flash.net::navigateToURL": (rt) => (request: Value, window: Value) => {
+      const page = checked(rt, request);
+      const name = window === null || window === undefined ? null : rt.toString(window);
+      s.loads.navigateTo(page, name === null ? null : target(name));
+    },
+    "flash.net::sendToURL": (rt) => (request: Value) => {
+      s.loads.sendTo(checked(rt, request));
+    },
+  };
+}
+
+/**
+ * "blank" in any case, with or without its underscore, as "_blank", and any
+ * other name as given, as Ruffle's navigateToURL_target_normalize records
+ * Flash Player doing.
+ */
+function target(name: string): string {
+  return /^_?blank$/i.test(name) ? "_blank" : name;
+}

package/src/playerglobal/flash/profiler/Telemetry.ts

@@ -0,0 +1,35 @@
+// flash.profiler.Telemetry: no profiler is ever connected, so metrics go
+// nowhere and no command handler is called. Crossbridge sends metrics as it
+// runs.
+import { avm2 } from "@swf2es/runtime";
+
+type Value = avm2.Value;
+
+export function telemetryNatives(): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class TelemetryNatives {
+    static get connected(): boolean {
+      return false;
+    }
+
+    static get spanMarker(): number {
+      return 0;
+    }
+
+    static sendMetric(_name: Value, _value: Value): void {}
+
+    static sendSpanMetric(_name: Value, _start: Value, _value: Value): void {}
+
+    static registerCommandHandler(_name: Value, _f: Value): boolean {
+      return false;
+    }
+
+    static unregisterCommandHandler(_name: Value): boolean {
+      return false;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.profiler::Telemetry", TelemetryNatives);
+  return natives;
+}

package/src/playerglobal/flash/sensors/Accelerometer.ts

@@ -0,0 +1,15 @@
+// flash.sensors.Accelerometer: none, as on a desktop's Flash Player.
+import { avm2 } from "@swf2es/runtime";
+
+export function accelerometerNatives(): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class AccelerometerNatives {
+    static get isSupported(): boolean {
+      return false;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.sensors::Accelerometer", AccelerometerNatives);
+  return natives;
+}

package/src/playerglobal/flash/system/ApplicationDomain.ts

@@ -0,0 +1,94 @@
+// flash.system.ApplicationDomain: one of the runtime's application
+// domains (avm2.Domain), kept on the object as $domain: a child's
+// definitions after its parent's, its own invisible to its parent and to
+// its siblings. The root is Flash's system domain, the player's classes,
+// and the main SWF's is its child (Scripting.mainDomain), so `new
+// ApplicationDomain(null)` sees none of the main SWF's. Its domain memory
+// is the runtime's one, as avmshell's Domain's is.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { definitionNamed } from "../../toplevel.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+export function applicationDomainNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  const domainOf = (o: AsObject): avm2.Domain => o.$domain ?? s.mainDomain;
+  const definitionOf = (o: AsObject, name: Value): Value =>
+    definitionNamed(s.rt, String(name), (q) => s.rt.definitionNamed(q, domainOf(o)));
+
+  // Not defined, as Flash has it, for a name whose script throws as it
+  // runs too: a script that threw runs again, as for getDefinition.
+  const has = (o: AsObject, name: Value): boolean => {
+    if (name === null || name === undefined) {
+      return false;
+    }
+
+    // A Vector of a definition that is not a class is defined, though
+    // getDefinition refuses it; an error, the requested name's or one an
+    // initializer the lookup ran threw, leaves the name not defined.
+    try {
+      definitionNamed(
+        s.rt,
+        String(name),
+        (q) => s.rt.definitionNamed(q, domainOf(o)),
+        () => true,
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  class ApplicationDomainNatives {
+    declare $domain: avm2.Domain | undefined;
+
+    // The domain of the code that asks, as Flash's.
+    static get currentDomain(): Value {
+      return s.code.applicationDomainOf(s.code.codeDomain());
+    }
+
+    static get MIN_DOMAIN_MEMORY_LENGTH(): number {
+      return avm2.GLOBAL_MEMORY_MIN_SIZE;
+    }
+
+    get domainMemory(): Value {
+      return s.rt.memoryProvider;
+    }
+
+    set domainMemory(v: Value) {
+      avm2.setDomainMemory(s.rt, v);
+    }
+
+    "flash.system:ApplicationDomain::ctor"(parent: Value): void {
+      this.$domain = s.rt.childDomain(parent ? domainOf(parent) : s.rt.root);
+    }
+
+    // The system domain, the root, is no script's to see: the main SWF's has no parent.
+    get parentDomain(): Value {
+      const parent = domainOf(this).parent;
+      return parent && parent !== s.rt.root ? s.code.applicationDomainOf(parent) : null;
+    }
+
+    getQualifiedDefinitionNames(): Value {
+      const cls = s.rt.resolve(s.rt.vector("String"));
+      const names = cls.$it.instance();
+      names.$a = s.rt.definitionNames(domainOf(this));
+      return names;
+    }
+
+    // As Flash's: an initializer's error comes through (Runtime.definitionNamed).
+    getDefinition(name: Value): Value {
+      return definitionOf(this, name);
+    }
+
+    hasDefinition(name: Value): boolean {
+      return has(this, name);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.system::ApplicationDomain", ApplicationDomainNatives);
+  return natives;
+}

package/src/playerglobal/flash/system/Capabilities.ts

@@ -0,0 +1,203 @@
+// flash.system.Capabilities: the screen values the host captured for this
+// player, and the rest as Flash Player 32's browser plugin reports them on
+// the host's system (hosts.ts's platformCapabilities), which a host may
+// set apart.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+export function capabilitiesNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const p = () => s.platform;
+
+  class CapabilitiesNatives {
+    static get screenResolutionX(): number {
+      return s.screenCapabilities.screenResolutionX;
+    }
+
+    static get screenResolutionY(): number {
+      return s.screenCapabilities.screenResolutionY;
+    }
+
+    static get pixelAspectRatio(): number {
+      return s.screenCapabilities.pixelAspectRatio;
+    }
+
+    static get screenDPI(): number {
+      return s.screenCapabilities.screenDPI;
+    }
+
+    static get os(): string {
+      return p().os;
+    }
+
+    static get manufacturer(): string {
+      return p().manufacturer;
+    }
+
+    static get version(): string {
+      return p().version;
+    }
+
+    static get language(): string {
+      return p().language;
+    }
+
+    static get languages(): avm2.Value {
+      return s.rt.newArray([p().language]);
+    }
+
+    static get playerType(): string {
+      return p().playerType;
+    }
+
+    static get isDebugger(): boolean {
+      return s.rt.debugger;
+    }
+
+    static get cpuArchitecture(): string {
+      return "x86";
+    }
+
+    static get screenColor(): string {
+      return "color";
+    }
+
+    // A browser tells a finger's screen from none, not a stylus's.
+    static get touchscreenType(): string {
+      return s.maxTouchPoints > 0 ? "finger" : "none";
+    }
+
+    static get maxLevelIDC(): string {
+      return "5.1";
+    }
+
+    static get serverString(): string {
+      return serverString(s);
+    }
+
+    static get "flash.system:Capabilities::_internal"(): number {
+      return 0;
+    }
+
+    static hasMultiChannelAudio(_type: avm2.Value): boolean {
+      return false;
+    }
+
+    // What a browser plugin has: sound, video and the rest it plays, printing,
+    // accessibility, an IME and TLS; no screen broadcast, no local file reads.
+    static get hasAudio(): boolean {
+      return true;
+    }
+
+    static get hasMP3(): boolean {
+      return true;
+    }
+
+    static get hasStreamingAudio(): boolean {
+      return true;
+    }
+
+    static get hasStreamingVideo(): boolean {
+      return true;
+    }
+
+    static get hasEmbeddedVideo(): boolean {
+      return true;
+    }
+
+    static get hasAudioEncoder(): boolean {
+      return true;
+    }
+
+    static get hasVideoEncoder(): boolean {
+      return true;
+    }
+
+    static get hasPrinting(): boolean {
+      return true;
+    }
+
+    static get hasAccessibility(): boolean {
+      return true;
+    }
+
+    static get hasIME(): boolean {
+      return true;
+    }
+
+    static get hasTLS(): boolean {
+      return true;
+    }
+
+    static get supports32BitProcesses(): boolean {
+      return true;
+    }
+
+    static get supports64BitProcesses(): boolean {
+      return true;
+    }
+
+    static get hasScreenBroadcast(): boolean {
+      return false;
+    }
+
+    static get hasScreenPlayback(): boolean {
+      return false;
+    }
+
+    static get avHardwareDisable(): boolean {
+      return false;
+    }
+
+    static get localFileReadDisable(): boolean {
+      return true;
+    }
+
+    static get isEmbeddedInAcrobat(): boolean {
+      return false;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.system::Capabilities", CapabilitiesNatives);
+  return natives;
+}
+
+/** The capabilities as Flash sends them to a server: its fields' codes, URL-encoded, in its order. */
+function serverString(s: Scripting): string {
+  const p = s.platform;
+  const yes = (b: boolean) => (b ? "t" : "f");
+  const sc = s.screenCapabilities;
+  const fields: [string, string][] = [
+    ["A", "t"],
+    ["SA", "t"],
+    ["SV", "t"],
+    ["EV", "t"],
+    ["MP3", "t"],
+    ["AE", "t"],
+    ["VE", "t"],
+    ["ACC", "t"],
+    ["PR", "t"],
+    ["SP", "f"],
+    ["SB", "f"],
+    ["DEB", yes(s.rt.debugger)],
+    ["V", p.version],
+    ["M", p.manufacturer],
+    ["R", `${sc.screenResolutionX}x${sc.screenResolutionY}`],
+    ["COL", "color"],
+    ["AR", String(sc.pixelAspectRatio)],
+    ["OS", p.os],
+    ["ARCH", "x86"],
+    ["L", p.language],
+    ["IME", "t"],
+    ["PR32", "t"],
+    ["PR64", "t"],
+    ["PT", p.playerType],
+    ["AVD", "f"],
+    ["LFD", "t"],
+    ["WD", "f"],
+    ["TLS", "t"],
+    ["ML", "5.1"],
+    ["DP", String(sc.screenDPI)],
+  ];
+  return fields.map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+}

package/src/playerglobal/flash/system/FSCommandHost.ts

@@ -0,0 +1,23 @@
+// flash.system.fscommand: a message to the player's host, which a plug-in
+// passed to its page and a projector acted on; here the host's, if it
+// takes them, else nothing, as a plug-in whose page defines no handler.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function fsCommandNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class FSCommandHostNatives {
+    static _fscommand(command: Value, args: Value): void {
+      // With the calling SWF's URL, or every loaded SWF's where the caller
+      // cannot be told, for a host that lets some SWFs command it and not
+      // others; 1 counts this native as the player's frame (Code.callerUrl).
+      s.fsCommand?.(s.rt.toString(command), s.rt.toString(args), s.code.securityUrls(1));
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.system::FSCommandHost", FSCommandHostNatives);
+  return natives;
+}