@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/playerglobal/flash/text/TextRenderer.js

@@ -0,0 +1,77 @@
+// flash.text.TextRenderer: settings for advanced anti-aliasing, kept for the
+// SWF to read back, with the values adl takes and ignores, and the tables
+// of cutoffs a font's advanced text is drawn by (text/csm.ts).
+import { avm2 } from "../../../../runtime/index.js";
+import { setCsmTable } from "../../../text/csm.js";
+export function textRendererNatives(s) {
+    const natives = {};
+    let displayMode = "default";
+    let maxLevel = 4;
+    let antiAliasType = "default";
+    class TextRendererNatives {
+        /** "default" reads as the mode it stands for, "crt" in adl. */
+        static get displayMode() {
+            return displayMode === "default" ? "crt" : displayMode;
+        }
+        /** "lcd" and "crt" set; null leaves it, anything else is "default". */
+        static set displayMode(v) {
+            if (v === null || v === undefined) {
+                return;
+            }
+            const mode = s.rt.toString(v);
+            displayMode = mode === "lcd" || mode === "crt" ? mode : "default";
+        }
+        static get maxLevel() {
+            return maxLevel;
+        }
+        /** Only 3, 4 and 7 are levels; others leave it. */
+        static set maxLevel(v) {
+            const level = s.rt.toInt(v);
+            if (level === 3 || level === 4 || level === 7) {
+                maxLevel = level;
+            }
+        }
+        static get antiAliasType() {
+            return antiAliasType;
+        }
+        /** "on" and "default" set, anything else is "off"; null TypeError #2007. */
+        static set antiAliasType(v) {
+            if (v === null || v === undefined) {
+                // adl spells the parameter so.
+                throw s.rt.error("TypeError", 2007, "antialiasType");
+            }
+            const type = s.rt.toString(v);
+            antiAliasType = type === "on" || type === "default" ? type : "off";
+        }
+        /** Checked as adl checks it; then the font's table, for its light and dark text alike, as adl takes it. */
+        static setAdvancedAntiAliasingTable(fontName, fontStyle, colorType, table) {
+            for (const [name, v] of [
+                ["fontName", fontName],
+                ["fontStyle", fontStyle],
+                ["colorType", colorType],
+            ]) {
+                if (v === null || v === undefined) {
+                    throw s.rt.error("TypeError", 2007, name);
+                }
+            }
+            const entries = table?.$a;
+            if (!entries) {
+                return;
+            }
+            const settings = s.rt.classNamed("flash.text::CSMSettings");
+            for (const entry of entries) {
+                if (!s.rt.isInstance(entry, settings)) {
+                    throw s.rt.error("TypeError", 2005, 4, "CSMSettings");
+                }
+            }
+            const read = (entry, k) => s.rt.toNumber(s.rt.getProperty(entry, s.rt.publicName(k)));
+            setCsmTable(s.rt.toString(fontName), s.rt.toString(fontStyle), entries.map((entry) => [
+                read(entry, "fontSize"),
+                read(entry, "insideCutoff"),
+                read(entry, "outsideCutoff"),
+            ]));
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.text::TextRenderer", TextRendererNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/text/engine/FontDescription.js

@@ -0,0 +1,141 @@
+import { avm2 } from "../../../../../runtime/index.js";
+import { deviceMetrics } from "../../../../text/fonts.js";
+const accepted = {
+    fontWeight: ["normal", "bold"],
+    fontPosture: ["normal", "italic"],
+    fontLookup: ["device", "embeddedCFF"],
+    renderingMode: ["normal", "cff"],
+    cffHinting: ["none", "horizontalStem"],
+};
+function data(o) {
+    if (!o.$fontDescription) {
+        o.$fontDescription = {
+            fontName: "_serif",
+            fontWeight: "normal",
+            fontPosture: "normal",
+            fontLookup: "device",
+            renderingMode: "cff",
+            cffHinting: "horizontalStem",
+            locked: false,
+        };
+    }
+    return o.$fontDescription;
+}
+export function fontDescriptionNatives(s) {
+    const natives = {};
+    const checked = (value, name) => {
+        if (value === null || value === undefined) {
+            throw s.rt.error("TypeError", 2007, name);
+        }
+        const string = s.rt.toString(value);
+        if (accepted[name] && !accepted[name].includes(string)) {
+            throw s.rt.error("ArgumentError", 2008, name);
+        }
+        return string;
+    };
+    const set = (o, name, value) => {
+        const state = data(o);
+        if (state.locked) {
+            throw s.rt.error("Error", 2185);
+        }
+        state[name] = checked(value, name);
+    };
+    const compatible = (name, weight, posture, device) => {
+        if (!device && (name === null || name === undefined)) {
+            return false;
+        }
+        const fontName = checked(name, "fontName");
+        const fontWeight = checked(weight, "fontWeight");
+        const fontPosture = checked(posture, "fontPosture");
+        const bold = fontWeight === "bold";
+        const italic = fontPosture === "italic";
+        if (!device) {
+            const fonts = [
+                ...(s.code.codeLibrary()?.characters.values() ?? []),
+                ...s.symbols.registeredFonts.values(),
+            ];
+            return fonts.some((font) => font.type === "fontCff" &&
+                font.name.toLowerCase() === fontName.toLowerCase() &&
+                font.bold === bold &&
+                font.italic === italic);
+        }
+        if (["_sans", "_serif", "_typewriter"].includes(fontName.toLowerCase())) {
+            return false;
+        }
+        // A missing face resolves to the same fallback metrics on every sample.
+        const font = deviceMetrics(fontName, 48, bold, italic);
+        const sample = ["M", "W", "i", "1", "@"];
+        if (s.platform.os === "Linux") {
+            const substitutes = {
+                arial: "Liberation Sans",
+                "times new roman": "Liberation Serif",
+                "courier new": "Liberation Mono",
+            };
+            const substitute = substitutes[fontName.toLowerCase()];
+            if (substitute) {
+                const mapped = deviceMetrics(substitute, 48, bold, italic);
+                if (sample.every((char) => font.advance(char) === mapped.advance(char))) {
+                    return false;
+                }
+            }
+        }
+        const fallback = deviceMetrics("__swf2es_missing_font__", 48, bold, italic);
+        return sample.some((char) => font.advance(char) !== fallback.advance(char));
+    };
+    class FontDescriptionNatives {
+        get fontName() {
+            return data(this).fontName;
+        }
+        set fontName(value) {
+            set(this, "fontName", value);
+        }
+        get fontWeight() {
+            return data(this).fontWeight;
+        }
+        set fontWeight(value) {
+            set(this, "fontWeight", value);
+        }
+        get fontPosture() {
+            return data(this).fontPosture;
+        }
+        set fontPosture(value) {
+            set(this, "fontPosture", value);
+        }
+        get fontLookup() {
+            return data(this).fontLookup;
+        }
+        set fontLookup(value) {
+            set(this, "fontLookup", value);
+        }
+        get renderingMode() {
+            return data(this).renderingMode;
+        }
+        set renderingMode(value) {
+            set(this, "renderingMode", value);
+        }
+        get cffHinting() {
+            return data(this).cffHinting;
+        }
+        set cffHinting(value) {
+            set(this, "cffHinting", value);
+        }
+        get locked() {
+            return data(this).locked;
+        }
+        set locked(value) {
+            const state = data(this);
+            if (state.locked) {
+                throw s.rt.error("Error", 2185);
+            }
+            state.locked = !!value;
+        }
+        static isFontCompatible(name, weight, posture) {
+            return compatible(name, weight, posture, false);
+        }
+        static isDeviceFontCompatible(name, weight, posture) {
+            return compatible(name, weight, posture, true);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.text.engine::FontDescription", FontDescriptionNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/text/engine/TabStop.js

@@ -0,0 +1,46 @@
+import { avm2 } from "../../../../../runtime/index.js";
+function data(o) {
+    if (!o.$tabStop) {
+        o.$tabStop = { alignment: "start", position: 0, decimalAlignmentToken: "" };
+    }
+    return o.$tabStop;
+}
+export function tabStopNatives(s) {
+    const natives = {};
+    class TabStopNatives {
+        get alignment() {
+            return data(this).alignment;
+        }
+        set alignment(value) {
+            if (value === null || value === undefined) {
+                throw s.rt.error("TypeError", 2007, "alignment");
+            }
+            const alignment = s.rt.toString(value);
+            if (!["start", "center", "end", "decimal"].includes(alignment)) {
+                throw s.rt.error("ArgumentError", 2008, "alignment");
+            }
+            data(this).alignment = alignment;
+        }
+        get position() {
+            return data(this).position;
+        }
+        set position(value) {
+            const position = Number(value);
+            if (position < 0) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            data(this).position = position;
+        }
+        get decimalAlignmentToken() {
+            return data(this).decimalAlignmentToken;
+        }
+        set decimalAlignmentToken(value) {
+            if (value === null || value === undefined) {
+                throw s.rt.error("TypeError", 2007, "decimalAlignmentToken");
+            }
+            data(this).decimalAlignmentToken = s.rt.toString(value);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.text.engine::TabStop", TabStopNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/trace/Trace.js

@@ -0,0 +1,17 @@
+// Release Flash Player does not expose its trace listener or levels to SWFs.
+import { avm2 } from "../../../../runtime/index.js";
+export function traceNatives() {
+    const natives = {};
+    class TraceNatives {
+        static setLevel(_level, _target) { }
+        static getLevel(_target) {
+            return 0;
+        }
+        static setListener(_listener) { }
+        static getListener() {
+            return null;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.trace::Trace", TraceNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/ui/ContextMenu.js

@@ -0,0 +1,17 @@
+// flash.ui.ContextMenu: AS3 keeps the items; input/context-menu.ts snapshots them on opening.
+// Links are kept for readback; link-specific built-in actions are not offered yet.
+import { avm2 } from "../../../../runtime/index.js";
+import { coerceArgument } from "../display/InteractiveObject.js";
+export function contextMenuNatives(s) {
+    const natives = {};
+    class ContextMenuNatives {
+        get link() {
+            return this.$link ?? null;
+        }
+        set link(v) {
+            this.$link = coerceArgument(s, v, "flash.net::URLRequest");
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.ui::ContextMenu", ContextMenuNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/ui/GameInput.js

@@ -0,0 +1,19 @@
+// flash.ui.GameInput without game controllers: none are found, so there is
+// no device to get, RangeError 1506 as Flash's for an index past them.
+import { avm2 } from "../../../../runtime/index.js";
+export function gameInputNatives(s) {
+    const natives = {};
+    class GameInputNatives {
+        static get isSupported() {
+            return false;
+        }
+        static get numDevices() {
+            return 0;
+        }
+        static getDeviceAt(_index) {
+            throw s.rt.error("RangeError", 1506);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.ui::GameInput", GameInputNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/ui/Keyboard.js

@@ -0,0 +1,27 @@
+// flash.ui.Keyboard's statics of the keyboard itself: a desktop's,
+// alphanumeric, not virtual, its locks reported off, as a browser keeps
+// their state from a page until a key event carries it.
+import { avm2 } from "../../../../runtime/index.js";
+export function keyboardNatives() {
+    const natives = {};
+    class KeyboardNatives {
+        static get capsLock() {
+            return false;
+        }
+        static get numLock() {
+            return false;
+        }
+        static get hasVirtualKeyboard() {
+            return false;
+        }
+        static get physicalKeyboardType() {
+            return "alphanumeric";
+        }
+        /** Whether the keys may be read: no screen reader is in the way. */
+        static isAccessible() {
+            return true;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.ui::Keyboard", KeyboardNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/ui/Mouse.js

@@ -0,0 +1,127 @@
+// flash.ui.Mouse controls the cursor the host shows: whether it shows one,
+// which of Flash's own it forces, and bitmap cursors registered by name.
+// MouseCursorData holds a cursor's frames, hot spot and frame rate.
+import { avm2 } from "../../../../runtime/index.js";
+import { encodePng } from "../../../bitmap/png.js";
+import { storeOf } from "../display/BitmapData.js";
+/** The names Mouse.cursor takes besides registered ones, as flash.ui.MouseCursor has them. */
+const BUILT_IN = new Set(["auto", "arrow", "button", "hand", "ibeam"]);
+/** The largest cursor Flash takes, a side. */
+const MAX_SIZE = 32;
+export function mouseNatives(s) {
+    const natives = {};
+    class MouseNatives {
+        static hide() {
+            s.mouseVisible = false;
+            s.pointer?.updateCursor();
+        }
+        static show() {
+            s.mouseVisible = true;
+            s.pointer?.updateCursor();
+        }
+        // Desktop Flash Player and AIR report both.
+        static get supportsCursor() {
+            return true;
+        }
+        static get supportsNativeCursor() {
+            return true;
+        }
+        static get cursor() {
+            return s.mouseCursor;
+        }
+        static set cursor(value) {
+            if (value === null || value === undefined) {
+                throw s.rt.error("TypeError", 2007, "cursor");
+            }
+            const name = s.rt.toString(value);
+            if (!BUILT_IN.has(name) && !s.cursors.has(name)) {
+                throw s.rt.error("ArgumentError", 2008, "cursor");
+            }
+            s.mouseCursor = name;
+            s.pointer?.updateCursor();
+        }
+        static registerCursor(name, cursorData) {
+            if (cursorData === null || cursorData === undefined) {
+                throw s.rt.error("TypeError", 2007, "cursorData");
+            }
+            if (name === null || name === undefined) {
+                throw s.rt.error("TypeError", 2007, "name");
+            }
+            // Flash registers nothing, and says nothing, for data never set.
+            const d = cursorData;
+            const data = d.$cursorFrames;
+            if (!data) {
+                return;
+            }
+            const frames = data.$a;
+            if (frames.length === 0) {
+                throw s.rt.error("ArgumentError", 2008, "cursorData");
+            }
+            // Within the largest cursor's pixels, whatever its frames' sizes.
+            const x = d.$cursorHotX ?? 0;
+            const y = d.$cursorHotY ?? 0;
+            if (x < 0 || x > MAX_SIZE - 1 || y < 0 || y > MAX_SIZE - 1) {
+                throw s.rt.error("ArgumentError", 2008, "hotSpot");
+            }
+            for (const frame of frames) {
+                if (frame === null || frame === undefined) {
+                    throw s.rt.error("ArgumentError", 2004);
+                }
+                const store = storeOf(s, frame);
+                if (store.width > MAX_SIZE || store.height > MAX_SIZE) {
+                    throw s.rt.error("ArgumentError", 2004);
+                }
+            }
+            // The first frame alone: a CSS cursor does not animate.
+            const first = storeOf(s, frames[0]);
+            const png = encodePng(first, { x: 0, y: 0, width: first.width, height: first.height }, true);
+            // A hot spot past the image would make the browser refuse the cursor.
+            const hotX = Math.min(Math.floor(x) || 0, first.width - 1);
+            const hotY = Math.min(Math.floor(y) || 0, first.height - 1);
+            const url = `data:image/png;base64,${btoa(String.fromCharCode(...png))}`;
+            s.cursors.set(s.rt.toString(name), `url("${url}") ${hotX} ${hotY}, default`);
+            s.pointer?.updateCursor();
+        }
+        static unregisterCursor(name) {
+            if (name === null || name === undefined) {
+                throw s.rt.error("TypeError", 2007, "name");
+            }
+            const key = s.rt.toString(name);
+            if (s.cursors.delete(key) && s.mouseCursor === key) {
+                s.mouseCursor = "auto";
+            }
+            s.pointer?.updateCursor();
+        }
+    }
+    class MouseCursorDataNatives {
+        get data() {
+            return this.$cursorFrames ?? null;
+        }
+        set data(value) {
+            this.$cursorFrames = value;
+        }
+        // A copy each way, as Flash keeps the values and not the Point.
+        get hotSpot() {
+            return s.rt.construct(s.rt.classNamed("flash.geom::Point"), this.$cursorHotX ?? 0, this.$cursorHotY ?? 0);
+        }
+        set hotSpot(value) {
+            if (value === null || value === undefined) {
+                throw s.rt.error("TypeError", 2007, "hotSpot");
+            }
+            const p = value;
+            this.$cursorHotX = s.rt.toNumber(s.rt.getProperty(p, s.rt.publicName("x")));
+            this.$cursorHotY = s.rt.toNumber(s.rt.getProperty(p, s.rt.publicName("y")));
+        }
+        get frameRate() {
+            return this.$cursorFrameRate ?? 0;
+        }
+        // A negative rate is 0; NaN stays.
+        set frameRate(value) {
+            const rate = s.rt.toNumber(value);
+            this.$cursorFrameRate = rate < 0 ? 0 : rate;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.ui::Mouse", MouseNatives);
+    avm2.registerNativeClass(natives, "flash.ui::MouseCursorData", MouseCursorDataNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/ui/Multitouch.js

@@ -0,0 +1,46 @@
+// 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 "../../../../runtime/index.js";
+const MODES = new Set(["none", "gesture", "touchPoint"]);
+export function multitouchNatives(s) {
+    const natives = {};
+    class MultitouchNatives {
+        static get inputMode() {
+            return s.inputMode;
+        }
+        // Flash checks the value, then keeps "none" where the system has no touch screen.
+        static set inputMode(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;
+            }
+        }
+        static get supportsTouchEvents() {
+            return s.maxTouchPoints > 0;
+        }
+        static get supportsGestureEvents() {
+            return false;
+        }
+        static get supportedGestures() {
+            return null;
+        }
+        static get maxTouchPoints() {
+            return s.maxTouchPoints;
+        }
+        static get mapTouchToMouse() {
+            return s.mapTouchToMouse;
+        }
+        static set mapTouchToMouse(value) {
+            s.mapTouchToMouse = !!value;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.ui::Multitouch", MultitouchNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/utils/ByteArray.js

@@ -0,0 +1,155 @@
+// 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 "../../../../runtime/index.js";
+// AIR retains BOMs here, unlike readUTFBytes. Bound the cache for SWF-supplied labels.
+const decoders = new Map();
+let fallback;
+function decoderFor(name) {
+    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);
+        }
+        decoders.set(name, decoder);
+    }
+    return decoder;
+}
+function singleByte(bytes, ascii) {
+    if (ascii) {
+        const end = bytes.findIndex((byte) => byte >= 0x80);
+        if (end >= 0) {
+            bytes = bytes.subarray(0, end);
+        }
+    }
+    const parts = [];
+    for (let i = 0; i < bytes.length; i += 4096) {
+        parts.push(String.fromCharCode(...bytes.subarray(i, i + 4096)));
+    }
+    return parts.join("");
+}
+function utf16(bytes, little) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+    const parts = [];
+    const units = [];
+    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, decoder) {
+    const parts = [];
+    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) {
+    const read = (b, length, charset) => {
+        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 (length, charset) {
+            return read(avm2.bytesOf(s.rt, this), length, charset);
+        }),
+        "flash.utils::ObjectInput#readMultiByte": avm2.plain(function (length, charset) {
+            return read(this.$amf.bytes, length, charset);
+        }),
+    };
+}
+export function byteArrayHooks(s) {
+    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;
+            },
+        },
+    };
+}