@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,707 @@
+// flash.text.TextField and TextFormat: a field's text and formats as a
+// TextModel (text/text.ts), its properties as adl reports them; a TextFormat's
+// values stored as Flash converts them, null for one it does not set.
+import { avm2 } from "../../../../runtime/index.js";
+import { CONTENT } from "../../../display/display.js";
+import { lineOf, maxScrollV, shownLines } from "../../../text/layout.js";
+import { applied, emptyFormat } from "../../../text/text.js";
+import { embeddedFonts } from "./Font.js";
+import { useSheet } from "./StyleSheet.js";
+const ALIGNS = ["left", "center", "right", "justify", "start", "end"];
+/** A number Flash keeps as an int: rounded, a half to even (12.7 is 13, -3.5 is -4, 10.5 is 10, 11.5 is 12). */
+function rounded(v) {
+    // What is no number is the int nearest none, as x86's conversion gives (the corpus's `stylesheet_transform`).
+    if (!Number.isFinite(v)) {
+        return -2147483648;
+    }
+    const r = Math.round(v);
+    return r - v === 0.5 && r % 2 !== 0 ? r - 1 : r;
+}
+/** The line a point in the field is on, by the lines' tops and heights: -1 for none. */
+function lineAtPoint(field, x, y) {
+    const layout = field.layout;
+    if (x < 0 || x > field.width * 20) {
+        return -1;
+    }
+    for (const [i, line] of layout.lines.entries()) {
+        if (y >= line.y && y < line.y + line.ascent + line.descent + line.leading) {
+            return i;
+        }
+    }
+    return -1;
+}
+/** The start and length of the paragraph `i` is in, as Flash gives them (Ruffle's edit_text.rs); [-1, -1] outside the text. */
+function paragraphAt(text, i) {
+    if (i < 0 || i > text.length) {
+        return [-1, -1];
+    }
+    let start = i;
+    while (start > 0 && text[start - 1] !== "\r" && text[start - 1] !== "\n") {
+        start--;
+    }
+    if (i === text.length) {
+        return [start, text.length - start + 1];
+    }
+    let end = i;
+    while (end < text.length && text[end] !== "\r" && text[end] !== "\n") {
+        end++;
+    }
+    return [start, Math.min(end + 1, text.length) - start];
+}
+export function textFieldNatives(s) {
+    const natives = {};
+    const formatOf = (o) => {
+        o.$format ??= emptyFormat();
+        return o.$format;
+    };
+    /** A TextFormat object of `values`. */
+    const textFormat = (values) => {
+        const o = s.rt.construct(s.rt.classNamed("flash.text::TextFormat"));
+        o.$format = { ...values, tabStops: values.tabStops ? [...values.tabStops] : null };
+        return o;
+    };
+    /** The text or the field changed: drawn again, and fitted to its text under autoSize. */
+    const changed = (o) => {
+        o.$display.invalidate(CONTENT);
+        o.$display.fit();
+    };
+    /** A line's index, or RangeError 2006 past the lines. */
+    const lineAt = (field, v) => {
+        const i = s.rt.toInt(v);
+        if (i < 0 || i >= field.layout.lines.length) {
+            throw s.rt.error("RangeError", 2006);
+        }
+        return i;
+    };
+    /** [begin, end) as getTextFormat and setTextFormat take them: -1 for the start or the end; RangeError 2006 past them. */
+    const range = (field, begin, end) => {
+        const length = field.model.text.length;
+        const b = begin === undefined || s.rt.toInt(begin) === -1 ? 0 : s.rt.toInt(begin);
+        const e = end === undefined || s.rt.toInt(end) === -1 ? length : s.rt.toInt(end);
+        if (b < 0 || e < b || e > length) {
+            throw s.rt.error("RangeError", 2006);
+        }
+        return [b, e];
+    };
+    const choice = (v, allowed, name) => {
+        const value = s.rt.toString(v);
+        if (!allowed.includes(value)) {
+            throw s.rt.error("ArgumentError", 2008, name);
+        }
+        return value;
+    };
+    class TextFormatNatives {
+        get font() {
+            return formatOf(this).font;
+        }
+        set font(v) {
+            formatOf(this).font = v === null || v === undefined ? null : s.rt.toString(v);
+        }
+        get size() {
+            return formatOf(this).size;
+        }
+        set size(v) {
+            formatOf(this).size = v === null || v === undefined ? null : rounded(s.rt.toNumber(v));
+        }
+        get color() {
+            return formatOf(this).color;
+        }
+        set color(v) {
+            formatOf(this).color = v === null || v === undefined ? null : rounded(s.rt.toNumber(v));
+        }
+        get bold() {
+            return formatOf(this).bold;
+        }
+        set bold(v) {
+            formatOf(this).bold = v === null || v === undefined ? null : !!v;
+        }
+        get italic() {
+            return formatOf(this).italic;
+        }
+        set italic(v) {
+            formatOf(this).italic = v === null || v === undefined ? null : !!v;
+        }
+        get underline() {
+            return formatOf(this).underline;
+        }
+        set underline(v) {
+            formatOf(this).underline = v === null || v === undefined ? null : !!v;
+        }
+        get url() {
+            return formatOf(this).url;
+        }
+        set url(v) {
+            formatOf(this).url = v === null || v === undefined ? null : s.rt.toString(v);
+        }
+        get target() {
+            return formatOf(this).target;
+        }
+        set target(v) {
+            formatOf(this).target = v === null || v === undefined ? null : s.rt.toString(v);
+        }
+        get align() {
+            return formatOf(this).align;
+        }
+        set align(v) {
+            formatOf(this).align = v === null || v === undefined ? null : choice(v, ALIGNS, "align");
+        }
+        get leftMargin() {
+            return formatOf(this).leftMargin;
+        }
+        set leftMargin(v) {
+            formatOf(this).leftMargin = v === null || v === undefined ? null : rounded(s.rt.toNumber(v));
+        }
+        get rightMargin() {
+            return formatOf(this).rightMargin;
+        }
+        set rightMargin(v) {
+            formatOf(this).rightMargin = v === null || v === undefined ? null : rounded(s.rt.toNumber(v));
+        }
+        get indent() {
+            return formatOf(this).indent;
+        }
+        set indent(v) {
+            formatOf(this).indent = v === null || v === undefined ? null : rounded(s.rt.toNumber(v));
+        }
+        get leading() {
+            return formatOf(this).leading;
+        }
+        set leading(v) {
+            formatOf(this).leading = v === null || v === undefined ? null : rounded(s.rt.toNumber(v));
+        }
+        get blockIndent() {
+            return formatOf(this).blockIndent;
+        }
+        set blockIndent(v) {
+            formatOf(this).blockIndent = v === null || v === undefined ? null : rounded(s.rt.toNumber(v));
+        }
+        get letterSpacing() {
+            return formatOf(this).letterSpacing;
+        }
+        set letterSpacing(v) {
+            formatOf(this).letterSpacing = v === null || v === undefined ? null : s.rt.toNumber(v);
+        }
+        get kerning() {
+            return formatOf(this).kerning;
+        }
+        set kerning(v) {
+            formatOf(this).kerning = v === null || v === undefined ? null : !!v;
+        }
+        get bullet() {
+            return formatOf(this).bullet;
+        }
+        set bullet(v) {
+            formatOf(this).bullet = v === null || v === undefined ? null : !!v;
+        }
+        get tabStops() {
+            const stops = formatOf(this).tabStops;
+            return stops === null ? null : s.rt.array(stops);
+        }
+        set tabStops(v) {
+            const values = v?.$a ?? null;
+            formatOf(this).tabStops =
+                values === null ? null : values.map((n) => rounded(s.rt.toNumber(n)));
+        }
+        // An unknown display is null, as adl leaves it.
+        get display() {
+            return formatOf(this).display;
+        }
+        set display(v) {
+            const value = v === null || v === undefined ? null : s.rt.toString(v);
+            formatOf(this).display =
+                value === "block" || value === "inline" || value === "none" ? value : null;
+        }
+    }
+    class TextFieldNatives {
+        get text() {
+            return this.$display.model.text;
+        }
+        set text(v) {
+            if (v === null || v === undefined) {
+                throw s.rt.error("TypeError", 2007, "value");
+            }
+            const field = this.$display;
+            const text = s.rt.toString(v);
+            // A field not of type input selects nothing at its start for new text.
+            // An input field keeps its selection, cut to the text, as Flash Player
+            // does in Ruffle's avm2/selection, though adl moves it to the start too.
+            const moves = field.type !== "input" && text !== field.model.text;
+            // Under a sheet, text is read as HTML too, as adl reads it.
+            if (field.styleSheet) {
+                setStyledHtml(field, text);
+            }
+            else {
+                field.model.setText(text);
+            }
+            if (moves) {
+                field.select(0, 0);
+            }
+            changed(this);
+        }
+        get htmlText() {
+            const field = this.$display;
+            return field.styleSheet && field.htmlSource !== null
+                ? field.htmlSource
+                : field.model.toHtml();
+        }
+        set htmlText(v) {
+            if (v === null || v === undefined) {
+                throw s.rt.error("TypeError", 2007, "value");
+            }
+            // Under a sheet, the HTML it has set again is not read again.
+            if (this.$display.styleSheet) {
+                const html = s.rt.toString(v);
+                if (html !== this.$display.htmlSource) {
+                    setStyledHtml(this.$display, html);
+                    htmlMoves(this.$display);
+                    changed(this);
+                }
+                return;
+            }
+            this.$display.model.setHtml(s.rt.toString(v), this.$display.multiline, s.trimTrailingHtmlBreak);
+            htmlMoves(this.$display);
+            changed(this);
+        }
+        get length() {
+            return this.$display.model.text.length;
+        }
+        getRawText() {
+            return this.$display.model.text;
+        }
+        appendText(v) {
+            const model = this.$display.model;
+            model.replace(model.text.length, model.text.length, s.rt.toString(v));
+            // An input field keeps its selection; another's caret follows the text.
+            if (this.$display.type !== "input") {
+                caretAtEnd(this.$display);
+            }
+            changed(this);
+        }
+        replaceText(begin, end, v) {
+            if (this.$display.styleSheet) {
+                throw s.rt.error("Error", 2009);
+            }
+            const model = this.$display.model;
+            const b = Math.max(0, Math.min(model.text.length, s.rt.toInt(begin)));
+            const e = Math.max(b, Math.min(model.text.length, s.rt.toInt(end)));
+            const text = s.rt.toString(v);
+            model.replace(b, e, text);
+            // An input field keeps its selection; another's caret follows what came in.
+            if (this.$display.type !== "input") {
+                this.$display.select(b + text.length, b + text.length);
+            }
+            changed(this);
+        }
+        get textColor() {
+            const model = this.$display.model;
+            return (model.formats[0] ?? model.defaultFormat).color >>> 0;
+        }
+        /** Every character's colour and the default's, as adl sets them. */
+        set textColor(v) {
+            const color = s.rt.toUint(v);
+            const model = this.$display.model;
+            model.defaultFormat = { ...model.defaultFormat, color };
+            const change = emptyFormat();
+            change.color = color;
+            model.setFormat(change, 0, model.text.length);
+            changed(this);
+        }
+        get defaultTextFormat() {
+            return textFormat(this.$display.model.defaultFormat);
+        }
+        set defaultTextFormat(v) {
+            if (v === null || v === undefined) {
+                throw s.rt.error("TypeError", 2007, "format");
+            }
+            const model = this.$display.model;
+            model.defaultFormat = applied(model.defaultFormat, formatOf(v));
+        }
+        getTextFormat(begin = -1, end = -1) {
+            const field = this.$display;
+            const [b, e] = range(field, begin, end);
+            return textFormat(field.model.formatOf(b, e));
+        }
+        setTextFormat(format, begin = -1, end = -1) {
+            if (format === null || format === undefined) {
+                throw s.rt.error("TypeError", 2007, "format");
+            }
+            const field = this.$display;
+            const [b, e] = range(field, begin, end);
+            field.model.setFormat(formatOf(format), b, e);
+            changed(this);
+        }
+        get type() {
+            return this.$display.type;
+        }
+        set type(v) {
+            this.$display.type = choice(v, ["dynamic", "input"], "type");
+            changed(this);
+        }
+        get autoSize() {
+            return this.$display.autoSize;
+        }
+        set autoSize(v) {
+            this.$display.autoSize = choice(v, ["none", "left", "right", "center"], "autoSize");
+            this.$display.fit();
+        }
+        get antiAliasType() {
+            return this.$display.antiAliasType;
+        }
+        // An unknown one is left as it was, as adl leaves it.
+        set antiAliasType(v) {
+            const value = s.rt.toString(v);
+            if ((value === "normal" || value === "advanced") && value !== this.$display.antiAliasType) {
+                this.$display.antiAliasType = value;
+                changed(this);
+            }
+        }
+        get gridFitType() {
+            return this.$display.gridFitType;
+        }
+        // An unknown one is none, as adl makes it.
+        set gridFitType(v) {
+            const value = s.rt.toString(v);
+            this.$display.gridFitType = value === "pixel" || value === "subpixel" ? value : "none";
+            this.$display.invalidate(CONTENT);
+        }
+        get border() {
+            return this.$display.border;
+        }
+        set border(v) {
+            this.$display.border = !!v;
+            changed(this);
+        }
+        get borderColor() {
+            return this.$display.borderColor;
+        }
+        set borderColor(v) {
+            this.$display.borderColor = s.rt.toUint(v) & 0xffffff;
+            changed(this);
+        }
+        get background() {
+            return this.$display.background;
+        }
+        set background(v) {
+            this.$display.background = !!v;
+            changed(this);
+        }
+        get backgroundColor() {
+            return this.$display.backgroundColor;
+        }
+        set backgroundColor(v) {
+            this.$display.backgroundColor = s.rt.toUint(v) & 0xffffff;
+            changed(this);
+        }
+        get multiline() {
+            return this.$display.multiline;
+        }
+        set multiline(v) {
+            this.$display.multiline = !!v;
+            changed(this);
+        }
+        get wordWrap() {
+            return this.$display.wordWrap;
+        }
+        set wordWrap(v) {
+            this.$display.wordWrap = !!v;
+            changed(this);
+        }
+        get embedFonts() {
+            return this.$display.embedFonts;
+        }
+        set embedFonts(v) {
+            this.$display.embedFonts = !!v;
+            changed(this);
+        }
+        get selectable() {
+            return this.$display.selectable;
+        }
+        set selectable(v) {
+            this.$display.selectable = !!v;
+        }
+        get displayAsPassword() {
+            return this.$display.displayAsPassword;
+        }
+        set displayAsPassword(v) {
+            this.$display.displayAsPassword = !!v;
+            changed(this);
+        }
+        get condenseWhite() {
+            return this.$display.condenseWhite;
+        }
+        set condenseWhite(v) {
+            this.$display.condenseWhite = !!v;
+        }
+        get maxChars() {
+            return this.$display.maxChars;
+        }
+        set maxChars(v) {
+            this.$display.maxChars = s.rt.toInt(v);
+        }
+        get restrict() {
+            return this.$display.restrict;
+        }
+        set restrict(v) {
+            this.$display.restrict = v === null || v === undefined ? null : s.rt.toString(v);
+        }
+        get sharpness() {
+            return this.$display.sharpness;
+        }
+        set sharpness(v) {
+            this.$display.sharpness = s.rt.toNumber(v);
+            this.$display.invalidate(CONTENT);
+        }
+        get thickness() {
+            return this.$display.thickness;
+        }
+        set thickness(v) {
+            this.$display.thickness = s.rt.toNumber(v);
+            this.$display.invalidate(CONTENT);
+        }
+        get mouseWheelEnabled() {
+            return this.$display.mouseWheelEnabled;
+        }
+        set mouseWheelEnabled(v) {
+            this.$display.mouseWheelEnabled = !!v;
+        }
+        get alwaysShowSelection() {
+            return this.$display.alwaysShowSelection;
+        }
+        set alwaysShowSelection(v) {
+            this.$display.alwaysShowSelection = !!v;
+        }
+        get useRichTextClipboard() {
+            return this.$display.useRichTextClipboard;
+        }
+        set useRichTextClipboard(v) {
+            this.$display.useRichTextClipboard = !!v;
+        }
+        get textWidth() {
+            return this.$display.layout.width / 20;
+        }
+        get textHeight() {
+            return this.$display.layout.height / 20;
+        }
+        // Laid out now: adl's count can lag a relayout until the next.
+        get numLines() {
+            return this.$display.layout.lines.length;
+        }
+        getLineMetrics(lineIndex) {
+            const line = this.$display.layout.lines[lineAt(this.$display, lineIndex)];
+            return s.rt.construct(s.rt.classNamed("flash.text::TextLineMetrics"), line.x / 20, line.width / 20, (line.ascent + line.descent + line.leading) / 20, line.ascent / 20, line.descent / 20, line.leading / 20);
+        }
+        getLineLength(lineIndex) {
+            const line = this.$display.layout.lines[lineAt(this.$display, lineIndex)];
+            return line.end - line.start;
+        }
+        getLineOffset(lineIndex) {
+            return this.$display.layout.lines[lineAt(this.$display, lineIndex)].start;
+        }
+        getLineText(lineIndex) {
+            const line = this.$display.layout.lines[lineAt(this.$display, lineIndex)];
+            return this.$display.model.text.slice(line.start, line.end);
+        }
+        getLineIndexOfChar(charIndex) {
+            const i = s.rt.toInt(charIndex);
+            const field = this.$display;
+            if (i < 0 || i >= field.model.text.length) {
+                return -1;
+            }
+            return lineOf(field.layout, i);
+        }
+        /** Where a character is, in the field: null for one past the text, a newline, or one its font lacks. */
+        getCharBoundaries(charIndex) {
+            const i = s.rt.toInt(charIndex);
+            const field = this.$display;
+            if (i < 0 || i >= field.model.text.length) {
+                return null;
+            }
+            const line = field.layout.lines[lineOf(field.layout, i)];
+            const c = line.chars[i - line.start];
+            if (!c?.shown) {
+                return null;
+            }
+            return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), c.x / 20, line.y / 20, c.advance / 20, (line.ascent + line.descent) / 20);
+        }
+        getLineIndexAtPoint(x, y) {
+            return lineAtPoint(this.$display, s.rt.toNumber(x) * 20, s.rt.toNumber(y) * 20);
+        }
+        getCharIndexAtPoint(x, y) {
+            const field = this.$display;
+            const px = s.rt.toNumber(x) * 20;
+            const i = lineAtPoint(field, px, s.rt.toNumber(y) * 20);
+            if (i < 0) {
+                return -1;
+            }
+            for (const c of field.layout.lines[i].chars) {
+                if (c.shown && px >= c.x && px < c.x + c.advance) {
+                    return c.index;
+                }
+            }
+            return -1;
+        }
+        get scrollV() {
+            return this.$display.scrollV;
+        }
+        set scrollV(v) {
+            const field = this.$display;
+            field.scrollV = Math.max(1, Math.min(s.rt.toInt(v), maxScrollV(field)));
+            changed(this);
+        }
+        get maxScrollV() {
+            return maxScrollV(this.$display);
+        }
+        get bottomScrollV() {
+            const field = this.$display;
+            return field.scrollV + shownLines(field, field.scrollV - 1) - 1;
+        }
+        get scrollH() {
+            return this.$display.scrollH;
+        }
+        set scrollH(v) {
+            this.$display.scrollH = Math.max(0, s.rt.toInt(v));
+            this.$display.invalidate(CONTENT);
+        }
+        get maxScrollH() {
+            return 0;
+        }
+        get selectionBeginIndex() {
+            return this.$display.selection[0];
+        }
+        get selectionEndIndex() {
+            return this.$display.selection[1];
+        }
+        get selectedText() {
+            const [begin, end] = this.$display.selection;
+            return this.$display.model.text.slice(begin, end);
+        }
+        get caretIndex() {
+            return this.$display.caret;
+        }
+        setSelection(begin, end) {
+            this.$display.select(s.rt.toInt(begin), s.rt.toInt(end));
+        }
+        /** The selection replaced, as typing would, and the caret after what came in. */
+        replaceSelectedText(v) {
+            if (this.$display.styleSheet) {
+                throw s.rt.error("Error", 2009);
+            }
+            const field = this.$display;
+            const [begin, end] = field.selection;
+            const text = s.rt.toString(v);
+            field.model.replace(begin, end, text);
+            field.select(begin + text.length, begin + text.length);
+            changed(this);
+        }
+        /** The runs of [begin, end) in one format each, as TextRuns. */
+        getTextRuns(begin = 0, end = 0x7fffffff) {
+            const model = this.$display.model;
+            const b = Math.max(0, s.rt.toInt(begin));
+            const e = Math.min(model.text.length, s.rt.toInt(end));
+            const runs = [];
+            for (const [from, to] of model.runs(b, e)) {
+                runs.push(s.rt.construct(s.rt.classNamed("flash.text::TextRun"), from, to, textFormat(model.formatOf(from, to))));
+            }
+            return s.rt.array(runs);
+        }
+        /** The first index of the paragraph `charIndex` is in; the text's length counts as in its last. */
+        getFirstCharInParagraph(charIndex) {
+            return paragraphAt(this.$display.model.text, s.rt.toInt(charIndex))[0];
+        }
+        /** That paragraph's length, its line end in it; at the text's length, one past the last's. */
+        getParagraphLength(charIndex) {
+            return paragraphAt(this.$display.model.text, s.rt.toInt(charIndex))[1];
+        }
+        /**
+         * The object an IMG of this id loaded, or null. The player reads no
+         * IMG, as adl does not: its fields drop the tag and give null for every
+         * id, by class name or URL (Ruffle's is a stub giving null).
+         */
+        getImageReference(id) {
+            if (id === null || id === undefined) {
+                throw s.rt.error("TypeError", 2007, "name");
+            }
+            return null;
+        }
+        /**
+         * Whether a field can draw `fontName` in `fontStyle` from an embedded
+         * font: the name in any case, a CFF font never, and a style other than
+         * "bold", "italic" or "boldItalic", in that case, regular, as adl has it.
+         */
+        static isFontCompatible(fontName, fontStyle) {
+            if (fontName === null || fontName === undefined) {
+                return false;
+            }
+            const name = s.rt.toString(fontName).toLowerCase();
+            const style = fontStyle === null || fontStyle === undefined ? "" : s.rt.toString(fontStyle);
+            const bold = style === "bold" || style === "boldItalic";
+            const italic = style === "italic" || style === "boldItalic";
+            return embeddedFonts(s).some((font) => font.type === "font" &&
+                font.name.toLowerCase() === name &&
+                font.bold === bold &&
+                font.italic === italic);
+        }
+        /** A desktop player's: no touch selection. */
+        get textInteractionMode() {
+            return "normal";
+        }
+        get styleSheet() {
+            return this.$display.styleSheet;
+        }
+        /**
+         * A sheet styles the HTML set from then on, and a change to the sheet
+         * styles it again; the HTML set keeps its source for htmlText. Taken
+         * off, the text keeps the styles it had (the corpus's `edittext_stylesheet`).
+         */
+        set styleSheet(v) {
+            const field = this.$display;
+            const sheet = v ?? null;
+            field.styleSheet = sheet;
+            if (!sheet) {
+                field.htmlSource = null;
+                field.restyle = null;
+                return;
+            }
+            // adl styles the HTML again on a change to the sheet only for a field
+            // that had HTML from a sheet when given this one (`edittext_stylesheet`).
+            if (field.htmlSource === null) {
+                field.restyle = null;
+                return;
+            }
+            useSheet(sheet, field);
+            field.restyle = () => {
+                if (field.htmlSource !== null) {
+                    setStyledHtml(field, field.htmlSource);
+                    changed({ $display: field });
+                }
+            };
+        }
+    }
+    const caretAtEnd = (field) => {
+        const end = field.model.text.length;
+        field.select(end, end);
+    };
+    /**
+     * After htmlText, a field not of type input has its caret after the text.
+     * adl does the same to an input field, which here keeps its selection, as
+     * for text (no Flash Player trace says otherwise).
+     */
+    const htmlMoves = (field) => {
+        if (field.type !== "input") {
+            caretAtEnd(field);
+        }
+    };
+    /** `html` as the field's text, styled by its sheet's TextFormats by selector. */
+    const setStyledHtml = (field, html) => {
+        // Its private _styles, which StyleSheet's natives keep.
+        const styles = field.styleSheet.$styles ?? null;
+        field.htmlSource = html;
+        field.model.setHtml(html, field.multiline, s.trimTrailingHtmlBreak, (selector) => {
+            const style = styles ? s.rt.getProperty(styles, s.rt.publicName(selector)) : null;
+            return style && typeof style === "object" ? formatOf(style) : null;
+        });
+    };
+    avm2.registerNativeClass(natives, "flash.text::TextFormat", TextFormatNatives);
+    avm2.registerNativeClass(natives, "flash.text::TextField", TextFieldNatives);
+    return natives;
+}