@swf2es/player 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,61 @@
+// flash.system.Security: the sandbox the host placed the SWF in, a remote
+// SWF's by default, which allows what a browser's would; the policy files
+// a SWF names go to the host, which judges its requests by them.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function securityNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  // Kept as set, nothing reads them: a data field is not a native.
+  let exactSettings = true;
+  let disableAVM1Loading = false;
+
+  class SecurityNatives {
+    static get exactSettings(): boolean {
+      return exactSettings;
+    }
+
+    static set exactSettings(v: Value) {
+      exactSettings = !!v;
+    }
+
+    static get disableAVM1Loading(): boolean {
+      return disableAVM1Loading;
+    }
+
+    static set disableAVM1Loading(v: Value) {
+      disableAVM1Loading = !!v;
+    }
+
+    static get sandboxType(): string {
+      return s.sandboxType;
+    }
+
+    static get pageDomain(): Value {
+      return null;
+    }
+
+    static allowDomain(): void {
+      // Every domain is allowed already.
+    }
+
+    static allowInsecureDomain(): void {
+      // Every domain is allowed already.
+    }
+
+    static loadPolicyFile(url: Value): void {
+      if (url !== null && url !== undefined) {
+        s.loads.policyFile(s.rt.toString(url));
+      }
+    }
+
+    static showSettings(_panel: Value): void {
+      // There is no settings panel.
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.system::Security", SecurityNatives);
+  return natives;
+}

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

@@ -0,0 +1,27 @@
+// All content in this player shares one browser security sandbox. Flash's
+// SecurityDomain.currentDomain is the stable object for that sandbox.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+export function securityDomainNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  let current: avm2.AsObject | null = null;
+
+  class SecurityDomainNatives {
+    static get currentDomain(): avm2.AsObject {
+      // Its public constructor throws; the player creates the singleton directly.
+      if (!current) {
+        current = s.rt.classNamed("flash.system::SecurityDomain").$it.instance();
+      }
+
+      return current;
+    }
+
+    "flash.system:SecurityDomain::ctor_impl"(): void {
+      throw s.rt.error("ArgumentError", 2012, "SecurityDomain");
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.system::SecurityDomain", SecurityDomainNatives);
+  return natives;
+}

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

@@ -0,0 +1,96 @@
+// flash.system.System: statics about the player's memory, of which there
+// is nothing here to tell or do, and setClipboard.
+import { avm2 } from "@swf2es/runtime";
+import { TEXT } from "../../../scripting/clipboard.js";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function systemNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  let useCodePage = false;
+
+  class SystemNatives {
+    static get ime(): Value {
+      return null;
+    }
+
+    /**
+     * The clipboard's text alone, in place of all it held, while a user's
+     * event is handled; outside one Error #2176, as Ruffle has the plug-in
+     * throw it, and TypeError #2007 for null, as Ruffle's does.
+     */
+    static setClipboard(text: Value): void {
+      if (text === null || text === undefined) {
+        throw s.rt.error("TypeError", 2007, "text");
+      }
+
+      const clipboard = s.clipboard;
+      if (!clipboard.writable) {
+        throw s.rt.error("Error", 2176);
+      }
+
+      clipboard.clear();
+      clipboard.set(TEXT, s.rt.toString(text));
+    }
+
+    static get totalMemory(): number {
+      return 0;
+    }
+
+    static get totalMemoryNumber(): number {
+      return 0;
+    }
+
+    static get freeMemory(): number {
+      return 0;
+    }
+
+    static get privateMemory(): number {
+      return 0;
+    }
+
+    static get processCPUUsage(): number {
+      return 0;
+    }
+
+    static get useCodePage(): boolean {
+      return useCodePage;
+    }
+
+    static set useCodePage(v: Value) {
+      useCodePage = !!v;
+    }
+
+    static get vmVersion(): string {
+      return "swf2es";
+    }
+
+    static pause(): void {
+      // Nothing to pause.
+    }
+
+    static resume(): void {
+      // Nothing to resume.
+    }
+
+    static exit(_code: Value): void {
+      // A browser's page does not exit.
+    }
+
+    static gc(): void {
+      // JavaScript's collector decides.
+    }
+
+    static pauseForGCIfCollectionImminent(_imminence: Value): void {
+      // JavaScript's collector decides.
+    }
+
+    static disposeXML(_node: Value): void {
+      // It frees an XML tree early, which JavaScript's collector does once nothing refers to it.
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.system::System", SystemNatives);
+  return natives;
+}

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

@@ -0,0 +1,147 @@
+// flash.system.Worker, WorkerDomain and MessageChannel: the AS3 faces of
+// the workers scripting/workers.ts runs. A Worker object stands for a
+// worker by its id, a MessageChannel for a channel by its own; with no
+// worker host, the primordial is the one worker, and none other starts.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { eventDispatcherNatives } from "../events/EventDispatcher.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+/** A shared property's key: null is one of its own, apart from "null", as in avmplus. */
+const keyOf = (s: Scripting, key: Value): string | null =>
+  key === null || key === undefined ? null : s.rt.toString(key);
+
+export function workerNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class WorkerNatives {
+    declare $worker: number;
+
+    static get isSupported(): boolean {
+      return s.workers.supported;
+    }
+
+    get isPrimordial(): boolean {
+      return this.$worker === 0;
+    }
+
+    "flash.system:Worker::internalGetState"(): string {
+      return s.workers.state(this.$worker);
+    }
+
+    getSharedProperty(key: Value): Value {
+      return s.workers.getShared(this.$worker, keyOf(s, key));
+    }
+
+    setSharedProperty(key: Value, value: Value): void {
+      s.workers.setShared(this.$worker, keyOf(s, key), value);
+    }
+
+    // Flash's own setSharedProperty and getSharedProperty call these.
+    "flash.system:Worker::internalGetSharedProperty"(key: Value): Value {
+      return s.workers.getShared(this.$worker, keyOf(s, key));
+    }
+
+    "flash.system:Worker::internalSetSharedProperty"(key: Value, value: Value): void {
+      s.workers.setShared(this.$worker, keyOf(s, key), value);
+    }
+
+    // workerState is dispatched to the Worker object whoever listens.
+    "flash.system:Worker::internalAddEventListener"(): void {}
+
+    "flash.system:Worker::internalRemoveEventListener"(): void {}
+
+    start(): void {
+      s.workers.start(this.$worker);
+    }
+
+    terminate(): boolean {
+      return s.workers.terminate(this.$worker);
+    }
+
+    createMessageChannel(receiver: Value): Value {
+      if (receiver === null || receiver === undefined) {
+        throw s.rt.error("TypeError", 2007, "receiver");
+      }
+
+      return s.workers.createChannel(this.$worker, (receiver as AsObject).$worker);
+    }
+  }
+
+  class WorkerDomainNatives {
+    static get isSupported(): boolean {
+      return s.workers.supported;
+    }
+
+    createWorker(swf: Value): Value {
+      return s.workers.create(swf);
+    }
+
+    listWorkers(): Value {
+      const rt = s.rt;
+      const cls = rt.applyType(rt.classNamed("__AS3__.vec::Vector"), [
+        rt.classNamed("flash.system::Worker"),
+      ]);
+      const o = cls.$it.instance();
+      o.$a = s.workers.list();
+      o.$fixed = false;
+      return o;
+    }
+  }
+
+  // Its addEventListener and removeEventListener are natives in Flash's
+  // playerglobal, which only add to EventDispatcher's.
+  const dispatcher = eventDispatcherNatives(s);
+  const inherited = (name: string) => dispatcher[`flash.events::EventDispatcher#${name}`](s.rt);
+  class MessageChannelNatives {
+    send(value: Value): void {
+      s.workers.send(this as unknown as AsObject, value);
+    }
+
+    get messageAvailable(): boolean {
+      return s.workers.messageAvailable(this as unknown as AsObject);
+    }
+
+    receive(block: Value): Value {
+      return s.workers.receive(this as unknown as AsObject, !!block);
+    }
+
+    addEventListener(...args: Value[]): Value {
+      return inherited("addEventListener").apply(this, args);
+    }
+
+    removeEventListener(...args: Value[]): Value {
+      return inherited("removeEventListener").apply(this, args);
+    }
+
+    close(): void {
+      s.workers.close(this as unknown as AsObject);
+    }
+
+    get state(): string {
+      return s.workers.channelState(this as unknown as AsObject);
+    }
+
+    toString(): string {
+      return "[object MessageChannel]";
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.system::Worker", WorkerNatives);
+  avm2.registerNativeClass(natives, "flash.system::WorkerDomain", WorkerDomainNatives);
+  avm2.registerNativeClass(natives, "flash.system::MessageChannel", MessageChannelNatives);
+  return natives;
+}
+
+/** Worker.current, which the VM keeps in Worker's private static _current: this VM's own worker. */
+export function workerHooks(s: Scripting): Record<string, avm2.ClassHook> {
+  return {
+    "flash.system::Worker": {
+      created(_rt: avm2.Runtime, cls: AsObject): void {
+        avm2.setStaticVar(cls, "_current", s.workers.objectOf(s.workers.id, cls));
+      },
+    },
+  };
+}

package/src/playerglobal/flash/text/Font.ts

@@ -0,0 +1,124 @@
+// flash.text.Font: embedded SWF font metadata and explicit font registration.
+import { avm2 } from "@swf2es/runtime";
+import type { AnyFontCharacter, FontCharacter } from "../../../display/timeline.js";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+
+function style(font: AnyFontCharacter): string {
+  if (font.bold && font.italic) {
+    return "boldItalic";
+  }
+  if (font.bold) {
+    return "bold";
+  }
+
+  return font.italic ? "italic" : "regular";
+}
+
+/** The fonts enumerateFonts lists: the running code's SWF's, with layout or no glyphs, and those registered. */
+export function embeddedFonts(s: Scripting): AnyFontCharacter[] {
+  const fonts: AnyFontCharacter[] = [];
+  const library = s.code.codeLibrary();
+  if (library) {
+    for (const character of library.characters.values()) {
+      if (
+        character.type === "font" &&
+        (character.font.layout || character.font.glyphs.length === 0)
+      ) {
+        fonts.push(character);
+      }
+    }
+  }
+
+  fonts.push(...s.symbols.registeredFonts.values());
+  return fonts;
+}
+
+export function fontNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const glyphCodes = new WeakMap<FontCharacter, Set<number>>();
+
+  class FontNatives {
+    declare $font: AnyFontCharacter | null;
+
+    get fontName(): string | null {
+      return this.$font?.name ?? null;
+    }
+
+    get fontStyle(): string | null {
+      return this.$font ? style(this.$font) : null;
+    }
+
+    get fontType(): string | null {
+      return this.$font ? (this.$font.type === "fontCff" ? "embeddedCFF" : "embedded") : null;
+    }
+
+    hasGlyphs(text: string): boolean {
+      const font = this.$font;
+      if (!font) {
+        return false;
+      }
+
+      if (font.type === "fontCff") {
+        return text.length === 0;
+      }
+
+      let glyphs = glyphCodes.get(font);
+      if (!glyphs) {
+        glyphs = new Set(font.font.glyphs.map((glyph) => glyph.code));
+        glyphCodes.set(font, glyphs);
+      }
+
+      for (let i = 0; i < text.length; i++) {
+        if (!glyphs.has(text.charCodeAt(i))) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    static enumerateFonts(_enumerateDeviceFonts: boolean): AsObject {
+      const cls = s.rt.classNamed("flash.text::Font");
+      const fonts = embeddedFonts(s);
+      fonts.sort((a, b) => {
+        const first = a.name.toLowerCase();
+        const second = b.name.toLowerCase();
+        return first < second ? -1 : first > second ? 1 : 0;
+      });
+
+      return s.rt.array(
+        fonts.map((font) => {
+          const object = s.rt.construct(cls) as AsObject;
+          object.$font = font;
+          return object;
+        }),
+      );
+    }
+
+    static registerFont(cls: AsObject): void {
+      const font = cls?.$it && s.symbols.fontSymbol(cls.$it);
+      if (!font) {
+        throw s.rt.error("ArgumentError", 1508, "font");
+      }
+
+      s.symbols.registerFont(cls, font);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.text::Font", FontNatives);
+  return natives;
+}
+
+export function fontHooks(s: Scripting): Record<string, avm2.ClassHook> {
+  return {
+    "flash.text::Font": {
+      create: (traits) => {
+        const object = Object.create(traits.proto);
+        object.$font = s.symbols.fontSymbol(traits);
+        return object;
+      },
+    },
+  };
+}

package/src/playerglobal/flash/text/StaticText.ts

@@ -0,0 +1,21 @@
+// flash.text.StaticText: DefineText's glyphs, which a script reads as its text.
+import { avm2 } from "@swf2es/runtime";
+import { StaticTextObject } from "../../../display/display.js";
+import { displayOf } from "../display/DisplayObject.js";
+
+type Value = avm2.Value;
+
+export function staticTextNatives(): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class StaticTextNatives {
+    /** Its glyphs' characters; null where a glyph's font is not the SWF's, or there are none. */
+    get text(): Value {
+      const display = displayOf(this as unknown as avm2.AsObject);
+      return display instanceof StaticTextObject ? display.glyphs.text : null;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.text::StaticText", StaticTextNatives);
+  return natives;
+}

package/src/playerglobal/flash/text/StyleSheet.ts

@@ -0,0 +1,87 @@
+// flash.text.StyleSheet's natives: playerglobal keeps the style objects
+// and their TextFormats itself, and asks these to parse CSS, colours and
+// font lists, to hold the TextFormats by selector, and to tell the fields
+// that use the sheet that it changed.
+import { avm2 } from "@swf2es/runtime";
+import type { TextObject } from "../../../display/display.js";
+import type { Scripting } from "../../../scripting.js";
+import { camelCase, cssColor, fontList, parseCss } from "../../../text/css.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+/** The fields a sheet styles, weakly: a field set to another sheet, or collected, drops out. */
+const users = new WeakMap<AsObject, Set<WeakRef<TextObject>>>();
+
+/** `field` now styled by `sheet`, which tells it of changes. */
+export function useSheet(sheet: AsObject, field: TextObject): void {
+  let set = users.get(sheet);
+  if (!set) {
+    set = new Set();
+    users.set(sheet, set);
+  }
+
+  set.add(field.ref as WeakRef<TextObject>);
+}
+
+export function styleSheetNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class StyleSheetNatives {
+    declare $styles: Value;
+
+    get "flash.text:StyleSheet::_styles"(): Value {
+      return this.$styles ?? null;
+    }
+
+    set "flash.text:StyleSheet::_styles"(v: Value) {
+      this.$styles = v;
+    }
+
+    /** The fields that use this sheet styled again from their HTML. */
+    "flash.text:StyleSheet::_update"(): void {
+      const set = users.get(this as unknown as AsObject);
+      for (const ref of set ?? []) {
+        const field = ref.deref();
+        if (!field || field.styleSheet !== (this as unknown as AsObject)) {
+          set?.delete(ref);
+          continue;
+        }
+
+        field.restyle?.();
+      }
+    }
+
+    /** Each selector's style object, its properties camel-cased strings; null for a sheet Flash rejects. */
+    "flash.text:StyleSheet::_parseCSSInternal"(css: Value): Value {
+      const parsed = parseCss(s.rt.toString(css));
+      if (!parsed) {
+        return null;
+      }
+
+      const pairs: Value[] = [];
+      for (const [selector, properties] of parsed) {
+        const style: Value[] = [];
+        for (const [name, value] of properties) {
+          style.push(camelCase(name), value);
+        }
+
+        // Selectors as setStyle keeps them, lower-cased: of KEY and key, the later is kept.
+        pairs.push(selector.toLowerCase(), s.rt.newObject(style));
+      }
+
+      return s.rt.newObject(pairs);
+    }
+
+    "flash.text:StyleSheet::_parseCSSFontFamily"(family: Value): string {
+      return fontList(s.rt.toString(family));
+    }
+
+    "flash.text:StyleSheet::_parseColor"(color: Value): number {
+      return cssColor(s.rt.toString(color));
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.text::StyleSheet", StyleSheetNatives);
+  return natives;
+}