@swf2es/player 0.0.0-stage → 0.1.1

package/src/playerglobal/flash/ui/Multitouch.ts

@@ -0,0 +1,62 @@
+// flash.ui.Multitouch: the host's touch screen, and how the player hands
+// its touches to scripts (input/touch.ts). Gestures are not recognized, so
+// the player reports none, as Flash does where the system has none.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+const MODES: ReadonlySet<string> = new Set(["none", "gesture", "touchPoint"]);
+
+export function multitouchNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class MultitouchNatives {
+    static get inputMode(): string {
+      return s.inputMode;
+    }
+
+    // Flash checks the value, then keeps "none" where the system has no touch screen.
+    static set inputMode(value: Value) {
+      if (value === null || value === undefined) {
+        throw s.rt.error("TypeError", 2007, "inputMode");
+      }
+
+      const mode = s.rt.toString(value);
+      if (!MODES.has(mode)) {
+        throw s.rt.error("ArgumentError", 2008, "inputMode");
+      }
+
+      if (s.maxTouchPoints > 0) {
+        s.inputMode = mode as typeof s.inputMode;
+      }
+    }
+
+    static get supportsTouchEvents(): boolean {
+      return s.maxTouchPoints > 0;
+    }
+
+    static get supportsGestureEvents(): boolean {
+      return false;
+    }
+
+    static get supportedGestures(): Value {
+      return null;
+    }
+
+    static get maxTouchPoints(): number {
+      return s.maxTouchPoints;
+    }
+
+    static get mapTouchToMouse(): boolean {
+      return s.mapTouchToMouse;
+    }
+
+    static set mapTouchToMouse(value: Value) {
+      s.mapTouchToMouse = !!value;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.ui::Multitouch", MultitouchNatives);
+  return natives;
+}

package/src/playerglobal/flash/utils/ByteArray.ts

@@ -0,0 +1,184 @@
+// The player supplies charset decoding where avmshell has a stub.
+// Instances of a subclass bound to DefineBinaryData start with shared data
+// at position 0, each seeing the others' writes until resized. Crossbridge
+// keeps a C program's initialized data so, one subclass per data section.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+// AIR retains BOMs here, unlike readUTFBytes. Bound the cache for SWF-supplied labels.
+const decoders = new Map<string, TextDecoder>();
+let fallback: TextDecoder | undefined;
+
+function decoderFor(name: string): TextDecoder {
+  let decoder = decoders.get(name);
+  if (decoder) {
+    return decoder;
+  }
+
+  try {
+    // Windows Flash does not accept these web-only labels or trim encoding names.
+    if (name !== name.trim() || name === "utf8" || name === "euc-kr") {
+      throw new RangeError();
+    }
+
+    decoder = new TextDecoder(name === "cn-gb" ? "gbk" : name, { ignoreBOM: true });
+  } catch {
+    // A browser has no system code page. Use the Western Windows Flash default.
+    fallback ??= new TextDecoder("windows-1252");
+    decoder = fallback;
+  }
+
+  if (name.length <= 64) {
+    if (decoders.size === 32) {
+      decoders.delete(decoders.keys().next().value as string);
+    }
+
+    decoders.set(name, decoder);
+  }
+
+  return decoder;
+}
+
+function singleByte(bytes: Uint8Array, ascii: boolean): string {
+  if (ascii) {
+    const end = bytes.findIndex((byte) => byte >= 0x80);
+    if (end >= 0) {
+      bytes = bytes.subarray(0, end);
+    }
+  }
+
+  const parts: string[] = [];
+  for (let i = 0; i < bytes.length; i += 4096) {
+    parts.push(String.fromCharCode(...bytes.subarray(i, i + 4096)));
+  }
+
+  return parts.join("");
+}
+
+function utf16(bytes: Uint8Array, little: boolean): string {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+  const parts: string[] = [];
+  const units: number[] = [];
+  for (let i = 0; i < bytes.length; i += 2) {
+    const unit = view.getUint16(i, little);
+    if (unit === 0) {
+      break;
+    }
+
+    units.push(unit);
+    if (units.length === 4096) {
+      parts.push(String.fromCharCode(...units));
+      units.length = 0;
+    }
+  }
+
+  parts.push(String.fromCharCode(...units));
+  return parts.join("");
+}
+
+// Windows Flash uses CP932's replacement and private-use characters for invalid Shift-JIS.
+function shiftJisFallback(bytes: Uint8Array, decoder: TextDecoder): string {
+  const parts: string[] = [];
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i];
+    if ((byte >= 0x81 && byte <= 0x9f) || (byte >= 0xe0 && byte <= 0xfc)) {
+      const next = bytes[++i];
+      if (next === undefined || next < 0x40 || next === 0x7f || next > 0xfc) {
+        parts.push("\u30fb");
+      } else {
+        parts.push(decoder.decode(bytes.subarray(i - 1, i + 1)).replaceAll("\ufffd", "\u30fb"));
+      }
+    } else if (byte === 0x80) {
+      parts.push("\u0080");
+    } else if (byte === 0xa0 || byte >= 0xfd) {
+      parts.push(String.fromCharCode(byte === 0xa0 ? 0xf8f0 : 0xf8f1 + byte - 0xfd));
+    } else {
+      parts.push(decoder.decode(bytes.subarray(i, i + 1)));
+    }
+  }
+
+  return parts.join("");
+}
+
+export function byteArrayNatives(s: Scripting): avm2.Natives {
+  const read = (b: avm2.Bytes, length: Value, charset: Value): string => {
+    const rt = s.rt;
+    if (charset === null || charset === undefined) {
+      throw rt.error("TypeError", 2007, "charSet");
+    }
+
+    const count = rt.toUint(length);
+    b.checkEOF(count);
+    const name = rt.toString(charset).toLowerCase();
+    switch (name) {
+      case "utf-16":
+      case "utf-16le":
+      case "unicode":
+        return utf16(b.readView(count - (count % 2)), true);
+      case "utf-16be":
+      case "unicodefffe":
+        return utf16(b.readView(count - (count % 2)), false);
+    }
+
+    let bytes = b.readView(count);
+    const nul = bytes.indexOf(0);
+    if (nul >= 0) {
+      bytes = bytes.subarray(0, nul);
+    }
+
+    switch (name) {
+      case "iso-8859-1":
+      case "iso_8859-1":
+      case "latin1":
+        return singleByte(bytes, false);
+      case "ascii":
+      case "us-ascii":
+        return singleByte(bytes, true);
+    }
+
+    const decoder = decoderFor(name);
+    const text = decoder.decode(bytes);
+    return decoder.encoding === "shift_jis" && text.includes("\ufffd")
+      ? shiftJisFallback(bytes, decoder)
+      : text;
+  };
+
+  return {
+    "flash.utils::ByteArray#readMultiByte": avm2.plain(function (
+      this: avm2.AsObject,
+      length: Value,
+      charset: Value,
+    ) {
+      return read(avm2.bytesOf(s.rt, this), length, charset);
+    }),
+    "flash.utils::ObjectInput#readMultiByte": avm2.plain(function (
+      this: avm2.AsObject,
+      length: Value,
+      charset: Value,
+    ) {
+      return read(this.$amf.bytes, length, charset);
+    }),
+  };
+}
+
+export function byteArrayHooks(s: Scripting): Record<string, avm2.ClassHook> {
+  return {
+    "flash.utils::ByteArray": {
+      ...avm2.byteArrayHook,
+      create: (traits, rt) => {
+        const o = avm2.byteArrayHook.create(traits, rt);
+        const data = s.symbols.binarySymbol(traits);
+        if (data) {
+          const b = avm2.bytesOf(rt, o);
+          b.buffer = data;
+          b.view = new DataView(data.buffer);
+          b.length = data.length;
+        }
+
+        return o;
+      },
+    },
+  };
+}

package/src/playerglobal/flash/utils/Timer.ts

@@ -0,0 +1,39 @@
+// flash.utils.Timer: playerglobal counts, checks the delay and completes
+// in AS3; the player keeps the started timers and fires them in its frames
+// and between them (scripting/timers.ts), each firing dispatching the
+// timer event here.
+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 timerNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class TimerNatives {
+    get running(): boolean {
+      return s.timers.timerRunning(this as unknown as AsObject);
+    }
+
+    "flash.utils:Timer::_start"(delay: Value, closure: Value): void {
+      s.timers.startTimer(this as unknown as AsObject, Number(delay), closure);
+    }
+
+    stop(): void {
+      s.timers.stopTimer(this as unknown as AsObject);
+    }
+
+    "flash.utils:Timer::_timerDispatch"(): void {
+      dispatchEvent(
+        s,
+        this as unknown as AsObject,
+        s.rt.construct(s.rt.classNamed("flash.events::TimerEvent"), "timer") as AsObject,
+      );
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.utils::Timer", TimerNatives);
+  return natives;
+}

package/src/playerglobal/flash/xml/XMLDocument.ts

@@ -0,0 +1,101 @@
+// flash.xml's legacy XMLDocument: playerglobal's parseXML builds its tree
+// from the tags of avmplus' XML tokenizer, the runtime's, through
+// XMLParser and XMLTag; XMLNode escapes text as its toString writes it.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+const ESCAPES: Record<string, string> = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&apos;",
+};
+
+export function xmlDocumentNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class XMLParserNatives {
+    declare $parser: avm2.XMLParser | undefined;
+
+    startParse(source: Value, ignoreWhite: Value): void {
+      const parser = new avm2.XMLParser(s.rt.toString(source));
+      parser.parse(!!ignoreWhite);
+      this.$parser = parser;
+    }
+
+    /** The next tag into `tag`, an element's attributes as an object; a status, 0 for a tag. */
+    getNext(tag: Value): number {
+      if (tag === null || tag === undefined) {
+        throw s.rt.error("TypeError", 2007, "tag");
+      }
+
+      const parser = this.$parser;
+      if (!parser) {
+        return -1;
+      }
+
+      const next = new avm2.XMLTag();
+      const status = parser.getNext(next);
+      const o = tag as AsObject;
+      o.$type = next.type;
+      o.$value = next.text;
+      o.$empty = next.empty;
+      o.$attrs = next.type === 1 ? s.rt.newObject(next.attributes) : null;
+      return status;
+    }
+  }
+
+  class XMLTagNatives {
+    declare $type: number | undefined;
+    declare $empty: boolean | undefined;
+    declare $value: string | null | undefined;
+    declare $attrs: Value;
+
+    get type(): number {
+      return this.$type ?? 0;
+    }
+
+    set type(v: Value) {
+      this.$type = s.rt.toUint(v);
+    }
+
+    get empty(): boolean {
+      return this.$empty ?? false;
+    }
+
+    set empty(v: Value) {
+      this.$empty = !!v;
+    }
+
+    get value(): Value {
+      return this.$value ?? null;
+    }
+
+    set value(v: Value) {
+      this.$value = v === null || v === undefined ? null : s.rt.toString(v);
+    }
+
+    get attrs(): Value {
+      return this.$attrs ?? null;
+    }
+
+    set attrs(v: Value) {
+      this.$attrs = v;
+    }
+  }
+
+  class XMLNodeNatives {
+    static "flash.xml:XMLNode::escapeXML"(value: Value): string {
+      return s.rt.toString(value).replace(/[&<>"']/g, (c) => ESCAPES[c]);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.xml::XMLParser", XMLParserNatives);
+  avm2.registerNativeClass(natives, "flash.xml::XMLTag", XMLTagNatives);
+  avm2.registerNativeClass(natives, "flash.xml::XMLNode", XMLNodeNatives);
+  return natives;
+}

package/src/playerglobal/index.ts

@@ -0,0 +1,233 @@
+// playerglobal's natives and class hooks, a file per class under flash/...,
+// as the runtime's natives are a file per family of builtins. Bound by the
+// names the compiler gives them: "flash.display::DisplayObject#get:x", and
+// a private native as "Class#pkg:Class::name".
+import type { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../scripting.js";
+import { webSocketNatives } from "./air/net/WebSocket.js";
+import { accessibilityNatives } from "./flash/accessibility/Accessibility.js";
+import { cryptoNatives } from "./flash/crypto/generateRandomBytes.js";
+import { encryptedLocalStoreNatives } from "./flash/data/EncryptedLocalStore.js";
+import { clipboardHooks, clipboardNatives } from "./flash/desktop/Clipboard.js";
+import { nativeApplicationNatives } from "./flash/desktop/NativeApplication.js";
+import { avm1MovieNatives } from "./flash/display/AVM1Movie.js";
+import { bitmapNatives } from "./flash/display/Bitmap.js";
+import { bitmapDataHooks, bitmapDataNatives } from "./flash/display/BitmapData.js";
+import { displayObjectHooks, displayObjectNatives } from "./flash/display/DisplayObject.js";
+import { containerNatives } from "./flash/display/DisplayObjectContainer.js";
+import { graphicsNatives } from "./flash/display/Graphics.js";
+import { interactiveObjectNatives } from "./flash/display/InteractiveObject.js";
+import { loaderNatives } from "./flash/display/Loader.js";
+import { loaderInfoNatives } from "./flash/display/LoaderInfo.js";
+import { movieClipNatives } from "./flash/display/MovieClip.js";
+import { nativeWindowNatives } from "./flash/display/NativeWindow.js";
+import { shaderNatives } from "./flash/display/Shader.js";
+import { shaderDataNatives } from "./flash/display/ShaderData.js";
+import { shaderInputNatives } from "./flash/display/ShaderInput.js";
+import { shaderJobNatives } from "./flash/display/ShaderJob.js";
+import { shaderParameterNatives } from "./flash/display/ShaderParameter.js";
+import { shapeNatives } from "./flash/display/Shape.js";
+import { simpleButtonNatives } from "./flash/display/SimpleButton.js";
+import { spriteNatives } from "./flash/display/Sprite.js";
+import { stageNatives } from "./flash/display/Stage.js";
+import { stage3DNatives } from "./flash/display/Stage3D.js";
+import { eventNatives } from "./flash/events/Event.js";
+import { eventDispatcherNatives } from "./flash/events/EventDispatcher.js";
+import { gestureEventNatives } from "./flash/events/GestureEvent.js";
+import { httpStatusHooks } from "./flash/events/HTTPStatusEvent.js";
+import { keyboardEventNatives } from "./flash/events/KeyboardEvent.js";
+import { mouseEventNatives } from "./flash/events/MouseEvent.js";
+import { pressAndTapGestureEventNatives } from "./flash/events/PressAndTapGestureEvent.js";
+import { timerEventNatives } from "./flash/events/TimerEvent.js";
+import { touchEventNatives } from "./flash/events/TouchEvent.js";
+import { externalInterfaceNatives } from "./flash/external/ExternalInterface.js";
+import { fileNatives } from "./flash/filesystem/File.js";
+import { fileStreamNatives } from "./flash/filesystem/FileStream.js";
+import { bevelFilterNatives } from "./flash/filters/BevelFilter.js";
+import { bitmapFilterHooks } from "./flash/filters/BitmapFilter.js";
+import { blurFilterNatives } from "./flash/filters/BlurFilter.js";
+import { colorMatrixFilterNatives } from "./flash/filters/ColorMatrixFilter.js";
+import { convolutionFilterNatives } from "./flash/filters/ConvolutionFilter.js";
+import { displacementMapFilterNatives } from "./flash/filters/DisplacementMapFilter.js";
+import { dropShadowFilterNatives } from "./flash/filters/DropShadowFilter.js";
+import { glowFilterNatives } from "./flash/filters/GlowFilter.js";
+import { gradientBevelFilterNatives } from "./flash/filters/GradientBevelFilter.js";
+import { gradientGlowFilterNatives } from "./flash/filters/GradientGlowFilter.js";
+import { shaderFilterNatives } from "./flash/filters/ShaderFilter.js";
+import { matrix3DNatives } from "./flash/geom/Matrix3D.js";
+import { perspectiveProjectionNatives } from "./flash/geom/PerspectiveProjection.js";
+import { transformNatives } from "./flash/geom/Transform.js";
+import { utils3DNatives } from "./flash/geom/Utils3D.js";
+import { collatorNatives } from "./flash/globalization/Collator.js";
+import { currencyFormatterNatives } from "./flash/globalization/CurrencyFormatter.js";
+import { currencyParseResultNatives } from "./flash/globalization/CurrencyParseResult.js";
+import { dateTimeFormatterNatives } from "./flash/globalization/DateTimeFormatter.js";
+import { localeIDNatives } from "./flash/globalization/LocaleID.js";
+import { numberFormatterNatives } from "./flash/globalization/NumberFormatter.js";
+import { numberParseResultNatives } from "./flash/globalization/NumberParseResult.js";
+import { stringToolsNatives } from "./flash/globalization/StringTools.js";
+import { cameraNatives } from "./flash/media/Camera.js";
+import { microphoneNatives } from "./flash/media/Microphone.js";
+import { soundHooks, soundNatives } from "./flash/media/Sound.js";
+import { soundMixerNatives } from "./flash/media/SoundMixer.js";
+import { soundTransformNatives } from "./flash/media/SoundTransform.js";
+import { videoNatives } from "./flash/media/Video.js";
+import { fileFilterNatives } from "./flash/net/FileFilter.js";
+import { fileReferenceNatives } from "./flash/net/FileReference.js";
+import { localConnectionNatives } from "./flash/net/LocalConnection.js";
+import { netConnectionNatives } from "./flash/net/NetConnection.js";
+import { navigateNatives } from "./flash/net/navigateToURL.js";
+import { sharedObjectNatives } from "./flash/net/SharedObject.js";
+import { socketNatives } from "./flash/net/Socket.js";
+import { urlRequestNatives } from "./flash/net/URLRequest.js";
+import { urlStreamNatives } from "./flash/net/URLStream.js";
+import { xmlSocketNatives } from "./flash/net/XMLSocket.js";
+import { telemetryNatives } from "./flash/profiler/Telemetry.js";
+import { accelerometerNatives } from "./flash/sensors/Accelerometer.js";
+import { applicationDomainNatives } from "./flash/system/ApplicationDomain.js";
+import { capabilitiesNatives } from "./flash/system/Capabilities.js";
+import { fsCommandNatives } from "./flash/system/FSCommandHost.js";
+import { securityNatives } from "./flash/system/Security.js";
+import { securityDomainNatives } from "./flash/system/SecurityDomain.js";
+import { systemNatives } from "./flash/system/System.js";
+import { workerHooks, workerNatives } from "./flash/system/Worker.js";
+import { fontDescriptionNatives } from "./flash/text/engine/FontDescription.js";
+import { tabStopNatives } from "./flash/text/engine/TabStop.js";
+import { fontHooks, fontNatives } from "./flash/text/Font.js";
+import { staticTextNatives } from "./flash/text/StaticText.js";
+import { styleSheetNatives } from "./flash/text/StyleSheet.js";
+import { textFieldNatives } from "./flash/text/TextField.js";
+import { textRendererNatives } from "./flash/text/TextRenderer.js";
+import { traceNatives } from "./flash/trace/Trace.js";
+import { contextMenuNatives } from "./flash/ui/ContextMenu.js";
+import { gameInputNatives } from "./flash/ui/GameInput.js";
+import { keyboardNatives } from "./flash/ui/Keyboard.js";
+import { mouseNatives } from "./flash/ui/Mouse.js";
+import { multitouchNatives } from "./flash/ui/Multitouch.js";
+import { byteArrayHooks, byteArrayNatives } from "./flash/utils/ByteArray.js";
+import { timerNatives } from "./flash/utils/Timer.js";
+import { xmlDocumentNatives } from "./flash/xml/XMLDocument.js";
+import { toplevelNatives } from "./toplevel.js";
+
+export { airLibrary, builtinLibrary, playerglobalLibrary } from "./libraries.js";
+
+export function playerNatives(s: Scripting): avm2.Natives {
+  return {
+    ...accessibilityNatives(s),
+    ...toplevelNatives(s),
+    ...cryptoNatives(),
+    ...byteArrayNatives(s),
+    ...clipboardNatives(s),
+    ...nativeApplicationNatives(s),
+    ...fileNatives(s),
+    ...fileStreamNatives(s),
+    ...encryptedLocalStoreNatives(s),
+    ...nativeWindowNatives(s),
+    ...eventNatives(s),
+    ...keyboardEventNatives(s),
+    ...timerEventNatives(s),
+    ...mouseEventNatives(s),
+    ...touchEventNatives(s),
+    ...gestureEventNatives(s),
+    ...pressAndTapGestureEventNatives(s),
+    ...mouseNatives(s),
+    ...multitouchNatives(s),
+    ...eventDispatcherNatives(s),
+    ...displayObjectNatives(s),
+    ...avm1MovieNatives(),
+    ...bitmapNatives(s),
+    ...bitmapDataNatives(s),
+    ...containerNatives(s),
+    ...spriteNatives(s),
+    ...movieClipNatives(s),
+    ...stageNatives(s),
+    ...loaderNatives(s),
+    ...loaderInfoNatives(s),
+    ...externalInterfaceNatives(s),
+    ...currencyParseResultNatives(s),
+    ...numberParseResultNatives(),
+    ...collatorNatives(s),
+    ...currencyFormatterNatives(s),
+    ...dateTimeFormatterNatives(s),
+    ...localeIDNatives(s),
+    ...numberFormatterNatives(s),
+    ...stringToolsNatives(s),
+    ...urlRequestNatives(s),
+    ...urlStreamNatives(s),
+    ...navigateNatives(s),
+    ...applicationDomainNatives(s),
+    ...capabilitiesNatives(s),
+    ...securityNatives(s),
+    ...securityDomainNatives(s),
+    ...systemNatives(s),
+    ...workerNatives(s),
+    ...telemetryNatives(),
+    ...interactiveObjectNatives(s),
+    ...fileFilterNatives(s),
+    ...socketNatives(s),
+    ...xmlSocketNatives(s),
+    ...localConnectionNatives(s),
+    ...webSocketNatives(s),
+    ...sharedObjectNatives(s),
+    ...transformNatives(s),
+    ...matrix3DNatives(s),
+    ...blurFilterNatives(s),
+    ...glowFilterNatives(s),
+    ...dropShadowFilterNatives(s),
+    ...bevelFilterNatives(s),
+    ...gradientGlowFilterNatives(s),
+    ...gradientBevelFilterNatives(s),
+    ...colorMatrixFilterNatives(s),
+    ...convolutionFilterNatives(s),
+    ...displacementMapFilterNatives(s),
+    ...shaderFilterNatives(s),
+    ...soundTransformNatives(s),
+    ...soundNatives(s),
+    ...soundMixerNatives(s),
+    ...graphicsNatives(s),
+    ...shapeNatives(s),
+    ...shaderNatives(s),
+    ...shaderDataNatives(s),
+    ...shaderInputNatives(s),
+    ...shaderParameterNatives(s),
+    ...shaderJobNatives(s),
+    ...simpleButtonNatives(s),
+    ...timerNatives(s),
+    ...staticTextNatives(),
+    ...fontNatives(s),
+    ...fontDescriptionNatives(s),
+    ...tabStopNatives(s),
+    ...textFieldNatives(s),
+    ...textRendererNatives(s),
+    ...traceNatives(),
+    ...utils3DNatives(s),
+    ...perspectiveProjectionNatives(s),
+    ...styleSheetNatives(s),
+    ...fileReferenceNatives(s),
+    ...fsCommandNatives(s),
+    ...netConnectionNatives(s),
+    ...stage3DNatives(s),
+    ...xmlDocumentNatives(s),
+    ...videoNatives(s),
+    ...cameraNatives(s),
+    ...microphoneNatives(s),
+    ...keyboardNatives(),
+    ...gameInputNatives(s),
+    ...contextMenuNatives(s),
+    ...accelerometerNatives(),
+  };
+}
+
+export function playerHooks(s: Scripting): Record<string, avm2.ClassHook> {
+  return {
+    ...displayObjectHooks(s),
+    ...bitmapDataHooks(s),
+    ...byteArrayHooks(s),
+    ...httpStatusHooks,
+    ...bitmapFilterHooks,
+    ...workerHooks(s),
+    ...clipboardHooks(),
+    ...soundHooks(s),
+    ...fontHooks(s),
+  };
+}

package/src/playerglobal/libraries.ts

@@ -0,0 +1,12 @@
+// The ABCs a SWF's ActionScript 3 links against, in the order
+// Scripting.loadLibraries takes them: avmplus' builtin, swf2es's
+// playerglobal, and AIR's library after them for an AIR application. Also
+// @swf2es/player/libraries, for a host that compiles ahead of time, as the
+// command does, without loading the player.
+import { avm2 } from "@swf2es/runtime";
+
+export { airLibrary } from "./air-library.js";
+export { playerglobalLibrary } from "./playerglobal-library.js";
+
+/** avmplus' builtin.abc (MPL-2.0), @swf2es/runtime's. */
+export const builtinLibrary: Uint8Array = avm2.builtinLibrary;