@swf2es/player 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,140 @@
+// flash.net.URLRequest: a URL and how to ask for it, kept as fields.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function urlRequestNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class URLRequestNatives {
+    declare $url: Value;
+    declare $data: Value;
+    declare $method: string | undefined;
+    declare $contentType: Value;
+    declare $headers: Value;
+    declare $digest: Value;
+    declare $followRedirects: boolean | undefined;
+    declare $userAgent: Value;
+    declare $manageCookies: boolean | undefined;
+    declare $useCache: boolean | undefined;
+    declare $cacheResponse: boolean | undefined;
+    declare $idleTimeout: number | undefined;
+    declare $authenticate: boolean | undefined;
+
+    get url(): Value {
+      return this.$url ?? null;
+    }
+
+    set url(v: Value) {
+      this.$url = v === null || v === undefined ? null : String(v);
+    }
+
+    get data(): Value {
+      return this.$data ?? null;
+    }
+
+    set data(v: Value) {
+      this.$data = v;
+    }
+
+    get method(): string {
+      return this.$method ?? "GET";
+    }
+
+    "flash.net:URLRequest::setMethod"(v: Value): void {
+      this.$method = String(v);
+    }
+
+    get contentType(): Value {
+      return this.$contentType ?? "application/x-www-form-urlencoded";
+    }
+
+    set contentType(v: Value) {
+      this.$contentType = v;
+    }
+
+    get requestHeaders(): Value {
+      if (!this.$headers) {
+        this.$headers = s.rt.array([]);
+      }
+
+      return this.$headers;
+    }
+
+    "flash.net:URLRequest::setRequestHeaders"(v: Value): void {
+      this.$headers = v;
+    }
+
+    get digest(): Value {
+      return this.$digest ?? null;
+    }
+
+    set digest(v: Value) {
+      this.$digest = v;
+    }
+
+    useRedirectedURL(): void {
+      // Nothing redirects.
+    }
+
+    get followRedirects(): boolean {
+      return this.$followRedirects ?? true;
+    }
+
+    set followRedirects(v: Value) {
+      this.$followRedirects = !!v;
+    }
+
+    get userAgent(): Value {
+      return this.$userAgent ?? null;
+    }
+
+    set userAgent(v: Value) {
+      this.$userAgent = v;
+    }
+
+    get manageCookies(): boolean {
+      return this.$manageCookies ?? true;
+    }
+
+    set manageCookies(v: Value) {
+      this.$manageCookies = !!v;
+    }
+
+    get useCache(): boolean {
+      return this.$useCache ?? true;
+    }
+
+    set useCache(v: Value) {
+      this.$useCache = !!v;
+    }
+
+    get cacheResponse(): boolean {
+      return this.$cacheResponse ?? true;
+    }
+
+    set cacheResponse(v: Value) {
+      this.$cacheResponse = !!v;
+    }
+
+    "flash.net:URLRequest::_SetIdleTimeout"(v: Value): void {
+      this.$idleTimeout = Number(v);
+    }
+
+    get idleTimeout(): number {
+      return this.$idleTimeout ?? 0;
+    }
+
+    get authenticate(): boolean {
+      return this.$authenticate ?? true;
+    }
+
+    set authenticate(v: Value) {
+      this.$authenticate = !!v;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.net::URLRequest", URLRequestNatives);
+  return natives;
+}

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

@@ -0,0 +1,203 @@
+// flash.net.URLStream: bytes fetched by the host, read through ByteArray's
+// DataInput implementation and delivered to scripts on a later frame.
+import { avm2 } from "@swf2es/runtime";
+import { dispatchEvent } from "../../../scripting/events.js";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+export function urlStreamNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const bufferOf = (stream: AsObject): AsObject =>
+    (stream.$buffer ??= s.rt.construct(s.rt.classNamed("flash.utils::ByteArray")) as AsObject);
+  const read = (stream: AsObject, method: string, ...args: Value[]): Value =>
+    s.rt.callProperty(bufferOf(stream), s.rt.publicName(method), ...args);
+  const stop = (stream: AsObject): void => {
+    stream.$generation = (stream.$generation ?? 0) + 1;
+    stream.$abort?.abort();
+    stream.$abort = null;
+    stream.$connected = false;
+  };
+
+  class URLStreamNatives {
+    declare $buffer: AsObject | undefined;
+    declare $generation: number | undefined;
+    declare $abort: AbortController | null | undefined;
+    declare $connected: boolean | undefined;
+
+    load(request: Value): void {
+      if (request === null || request === undefined) {
+        throw s.rt.error("TypeError", 2007, "request");
+      }
+
+      this.$abort?.abort();
+      const generation = (this.$generation ?? 0) + 1;
+      this.$generation = generation;
+      this.$connected = false;
+      this.$buffer = undefined;
+      const abort = new AbortController();
+      this.$abort = abort;
+      const source = request as AsObject;
+      s.loads.requestBytes(source, abort.signal, ({ bytes, status, local }, url) => {
+        if (this.$generation !== generation) {
+          return;
+        }
+
+        this.$abort = null;
+        if (bytes === null) {
+          this.$connected = false;
+          dispatchEvent(s, this, s.httpStatus(status));
+          if (this.$generation !== generation) {
+            return;
+          }
+
+          dispatchEvent(
+            s,
+            this,
+            s.rt.construct(
+              s.rt.classNamed("flash.events::IOErrorEvent"),
+              "ioError",
+              false,
+              false,
+              s.loads.streamError(url, local),
+            ) as AsObject,
+          );
+          return;
+        }
+
+        this.$connected = true;
+        dispatchEvent(s, this, s.event("open"));
+        if (this.$generation !== generation) {
+          return;
+        }
+
+        const buffer = avm2.bytesOf(s.rt, bufferOf(this));
+        buffer.write(bytes);
+        buffer.position = 0;
+        dispatchEvent(
+          s,
+          this,
+          s.rt.construct(
+            s.rt.classNamed("flash.events::ProgressEvent"),
+            "progress",
+            false,
+            false,
+            bytes.length,
+            bytes.length,
+          ) as AsObject,
+        );
+        if (this.$generation !== generation) {
+          return;
+        }
+
+        dispatchEvent(s, this, s.httpStatus(status));
+        if (this.$generation !== generation) {
+          return;
+        }
+
+        dispatchEvent(s, this, s.event("complete"));
+      });
+    }
+
+    get connected(): boolean {
+      return this.$connected ?? false;
+    }
+
+    get bytesAvailable(): number {
+      return avm2.bytesOf(s.rt, bufferOf(this)).available;
+    }
+
+    close(): void {
+      if (!this.$abort && !this.$connected) {
+        throw s.rt.error("flash.errors::IOError", 2029);
+      }
+
+      stop(this);
+    }
+
+    stop(): void {
+      stop(this);
+    }
+
+    readBytes(bytes: Value, offset: Value = 0, length: Value = 0): void {
+      read(this, "readBytes", bytes, offset, length);
+    }
+
+    readBoolean(): Value {
+      return read(this, "readBoolean");
+    }
+    readByte(): Value {
+      return read(this, "readByte");
+    }
+    readUnsignedByte(): Value {
+      return read(this, "readUnsignedByte");
+    }
+    readShort(): Value {
+      return read(this, "readShort");
+    }
+    readUnsignedShort(): Value {
+      return read(this, "readUnsignedShort");
+    }
+    readInt(): Value {
+      return read(this, "readInt");
+    }
+    readUnsignedInt(): Value {
+      return read(this, "readUnsignedInt");
+    }
+    readFloat(): Value {
+      return read(this, "readFloat");
+    }
+    readDouble(): Value {
+      return read(this, "readDouble");
+    }
+    readUTF(): Value {
+      return read(this, "readUTF");
+    }
+    readUTFBytes(length: Value): Value {
+      return read(this, "readUTFBytes", length);
+    }
+    readMultiByte(length: Value, charset: Value): Value {
+      return read(this, "readMultiByte", length, charset);
+    }
+    readObject(): Value {
+      return read(this, "readObject");
+    }
+
+    get objectEncoding(): Value {
+      return s.rt.getProperty(bufferOf(this), s.rt.publicName("objectEncoding"));
+    }
+
+    set objectEncoding(value: Value) {
+      s.rt.setProperty(bufferOf(this), s.rt.publicName("objectEncoding"), value);
+    }
+
+    get endian(): Value {
+      return s.rt.getProperty(bufferOf(this), s.rt.publicName("endian"));
+    }
+
+    set endian(value: Value) {
+      s.rt.setProperty(bufferOf(this), s.rt.publicName("endian"), value);
+    }
+
+    get diskCacheEnabled(): boolean {
+      return false;
+    }
+
+    get position(): number {
+      return avm2.bytesOf(s.rt, bufferOf(this)).position;
+    }
+
+    set position(value: Value) {
+      // As ByteArray's setter: a uint32 of its own, not toUint's (see Bytes).
+      avm2.bytesOf(s.rt, bufferOf(this)).position = s.rt.toUint(value) >>> 0;
+    }
+
+    get length(): number {
+      return avm2.bytesOf(s.rt, bufferOf(this)).length;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.net::URLStream", URLStreamNatives);
+  return natives;
+}

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

@@ -0,0 +1,18 @@
+// flash.net.XMLSocket: AS3 over a Socket (as3/playerglobal); connect with a
+// null host asks here for the SWF's own domain.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { swfDomain } from "./LocalConnection.js";
+
+export function xmlSocketNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class XMLSocketNatives {
+    get "flash.net:XMLSocket::domain"(): string {
+      return swfDomain(s.url);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.net::XMLSocket", XMLSocketNatives);
+  return natives;
+}

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

@@ -0,0 +1,164 @@
+// AS3 peers retain AMF3's ByteArray, XML, Vector and alias semantics.
+// Reuse the runtime's codec through its public API, with a bounded output
+// and scratch buffers leased separately for reentrant serialization.
+import { avm2 } from "@swf2es/runtime";
+import { MAX_DEPTH } from "../../../avm1/amf.js";
+import { LOCAL_MESSAGE_LIMIT } from "../../../localconnection.js";
+
+class MessageBytes extends avm2.Bytes {
+  override setLength(length: number, fromSetter = false): void {
+    if (length > LOCAL_MESSAGE_LIMIT) {
+      throw new RangeError("LocalConnection message too large");
+    }
+
+    super.setLength(length, fromSetter);
+  }
+
+  override write(source: Uint8Array, offset = 0, count = source.length): void {
+    if (count > LOCAL_MESSAGE_LIMIT - this.position) {
+      throw new RangeError("LocalConnection message too large");
+    }
+
+    super.write(source, offset, count);
+  }
+}
+
+class MessageWriter extends avm2.Amf3Writer {
+  private depth = 0;
+  escaped = false;
+  private readonly externalizable: avm2.AsObject;
+
+  constructor(
+    private readonly runtime: avm2.Runtime,
+    bytes: MessageBytes,
+  ) {
+    super(runtime, bytes);
+    this.externalizable = runtime.classNamed("flash.utils::IExternalizable");
+  }
+
+  override string(value: string): void {
+    if (value.length > LOCAL_MESSAGE_LIMIT - this.bytes.position) {
+      throw new RangeError("LocalConnection message too large");
+    }
+
+    super.string(value);
+  }
+
+  override value(value: avm2.Value): void {
+    if (
+      value?.$traits?.isSubtypeOf(this.externalizable.$it) ||
+      this.runtime.dynamicPropertyWriter
+    ) {
+      this.escaped = true;
+    }
+
+    if (this.depth >= MAX_DEPTH || value?.$bytes?.length > LOCAL_MESSAGE_LIMIT) {
+      throw new RangeError("LocalConnection message too large");
+    }
+
+    if (value?.$node) {
+      const text = this.runtime.callProperty(value, this.runtime.publicName("toXMLString"));
+      if (text.length > LOCAL_MESSAGE_LIMIT) {
+        throw new RangeError("LocalConnection message too large");
+      }
+    }
+
+    this.depth++;
+    try {
+      super.value(value);
+    } finally {
+      this.depth--;
+    }
+  }
+}
+
+const writers = new WeakMap<avm2.Runtime, MessageBytes[]>();
+const readers = new WeakMap<avm2.Runtime, avm2.Bytes[]>();
+const empty = new Uint8Array(0);
+const emptyView = new DataView(empty.buffer);
+
+class MessageReader extends avm2.Amf3Reader {
+  escaped = false;
+  private readonly externalizable: avm2.AsObject;
+
+  constructor(rt: avm2.Runtime, bytes: avm2.Bytes) {
+    super(rt, bytes);
+    this.externalizable = rt.classNamed("flash.utils::IExternalizable");
+  }
+
+  override value(): avm2.Value {
+    try {
+      const value = super.value();
+      if (value?.$traits?.isSubtypeOf(this.externalizable.$it)) {
+        this.escaped = true;
+      }
+
+      return value;
+    } catch (error) {
+      this.escaped = true;
+      throw error;
+    }
+  }
+}
+
+export function writeModernValues(rt: avm2.Runtime, args: avm2.Value[]): Uint8Array<ArrayBuffer> {
+  let pool = writers.get(rt);
+  if (!pool) {
+    pool = [];
+    writers.set(rt, pool);
+  }
+
+  let bytes = pool.pop();
+  if (!bytes) {
+    const owner = rt.construct(rt.classNamed("flash.utils::ByteArray"));
+    bytes = new MessageBytes(rt, owner);
+    owner.$bytes = bytes;
+  }
+
+  const writer = new MessageWriter(rt, bytes);
+  try {
+    writer.value(rt.newArray(args));
+    return bytes.buffer.slice(0, bytes.length);
+  } finally {
+    // An externalizable may retain its ObjectOutput; that stream must stay independent.
+    if (!writer.escaped) {
+      bytes.position = 0;
+      bytes.setLength(0);
+      if (pool.length < 2) {
+        pool.push(bytes);
+      }
+    }
+  }
+}
+
+export function readModernValues(rt: avm2.Runtime, data: Uint8Array<ArrayBuffer>): avm2.Value[] {
+  let pool = readers.get(rt);
+  if (!pool) {
+    pool = [];
+    readers.set(rt, pool);
+  }
+
+  let bytes = pool.pop();
+  if (!bytes) {
+    const owner = rt.construct(rt.classNamed("flash.utils::ByteArray"));
+    bytes = avm2.bytesOf(rt, owner);
+  }
+
+  bytes.buffer = data;
+  bytes.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  bytes.length = data.length;
+  const reader = new MessageReader(rt, bytes);
+  try {
+    return reader.value().$a;
+  } finally {
+    if (!reader.escaped) {
+      bytes.buffer = empty;
+      bytes.view = emptyView;
+      bytes.position = 0;
+      bytes.length = 0;
+      if (pool.length < 2) {
+        pool.push(bytes);
+      }
+    }
+  }
+}