@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/avm1/globals/StyleSheet.js

@@ -0,0 +1,205 @@
+// TextField.StyleSheet, AS2's, as Ruffle's (https://github.com/ruffle-rs/
+// ruffle) core/src/avm1/globals/style_sheet.rs has it: MIT OR Apache-2.0,
+// Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors. A sheet keeps
+// each style object given it, copied, in `_css`, and the TextFormat its
+// `transform` makes of it in `_styles`, both by the selector as given; and
+// natively each TextFormat's format by the selector in lower case, which
+// styles the HTML of a field the sheet is given to.
+import { avm1 } from "../../../runtime/index.js";
+import { camelCase, fontList, parseCss } from "../../text/css.js";
+import { emptyFormat } from "../../text/text.js";
+import { startLoad } from "./LoadVars.js";
+import { formatOf, newTextFormat } from "./TextFormat.js";
+const sheets = new WeakMap();
+/** The formats of a sheet by selector in lower case; null for any other value. */
+export function stylesOf(value) {
+    return value instanceof avm1.Avm1Object ? (sheets.get(value) ?? null) : null;
+}
+const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE | avm1.READ_ONLY | avm1.VERSION_7;
+/** `TextField.StyleSheet`. */
+export function styleSheetClass(host) {
+    const realm = host.realm;
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self) => {
+        sheets.set(self, new Map());
+        return self;
+    }, () => undefined);
+    const method = (name, fn) => proto.define(name, realm.method(fn), FIXED);
+    /** An object's enumerable properties on a new Object; null for anything else. */
+    const copy = (value, version) => {
+        if (!(value instanceof avm1.Avm1Object)) {
+            return null;
+        }
+        const out = new avm1.Avm1Object(realm.objectProto);
+        for (const key of avm1.keys(value, version)) {
+            avm1.set(out, key, avm1.get(value, key, version), version);
+        }
+        return out;
+    };
+    /** `self[name]` as an object, an empty one for a primitive. */
+    const stored = (self, name, version) => realm.box(avm1.get(self, name, version), version);
+    const setStyle = (self, name, style, version) => {
+        for (const key of ["_styles", "_css"]) {
+            if (!avm1.has(self, key, version)) {
+                avm1.set(self, key, realm.newArray([], version), version);
+            }
+        }
+        avm1.set(stored(self, "_css", version), name, copy(style, version), version);
+        const transform = avm1.get(self, "transform", version);
+        const format = transform instanceof avm1.Avm1Function
+            ? transform.call(self, [copy(style, version)], version)
+            : undefined;
+        avm1.set(stored(self, "_styles", version), name, format, version);
+        const change = formatOf(format);
+        if (change !== null) {
+            sheets.get(self)?.set(name.toLowerCase(), change);
+        }
+    };
+    method("setStyle", (self, args, version) => {
+        setStyle(self, avm1.stringOf(args[0], version), args[1], version);
+        return undefined;
+    });
+    method("clear", (self, _, version) => {
+        avm1.set(self, "_styles", realm.newArray([], version), version);
+        avm1.set(self, "_css", realm.newArray([], version), version);
+        return undefined;
+    });
+    method("getStyleNames", (self, _, version) => realm.newArray(avm1.keys(stored(self, "_css", version), version), version));
+    method("load", (self, args, version) => {
+        if (args.length === 0) {
+            return false;
+        }
+        // StyleSheet shares the loading state with LoadVars, but sends no HTTP status callback.
+        startLoad(host, self, { url: avm1.stringOf(args[0], version), method: "GET", headers: [], body: null }, version, false);
+        return true;
+    });
+    method("getStyle", (self, args, version) => copy(avm1.get(stored(self, "_css", version), avm1.stringOf(args[0], version), version), version));
+    method("transform", (_, args, version) => transform(realm, args, version));
+    /** Each rule of the CSS set as a style; false for CSS Flash rejects. */
+    const parse = (self, css, version) => {
+        const rules = parseCss(css);
+        if (rules === null) {
+            return false;
+        }
+        for (const [selector, properties] of rules) {
+            if (selector === "") {
+                continue;
+            }
+            const style = new avm1.Avm1Object(realm.objectProto);
+            for (const [key, value] of properties) {
+                avm1.set(style, camelCase(key), value, version);
+            }
+            setStyle(self, selector, style, version);
+        }
+        return true;
+    };
+    method("parseCSS", (self, args, version) => parse(self, avm1.stringOf(args[0], version), version));
+    method("parse", (self, args, version) => parse(self, avm1.stringOf(args[0], version), version));
+    const callbackFlags = avm1.DONT_ENUM | avm1.DONT_DELETE | avm1.VERSION_7;
+    proto.define("onLoad", realm.method(() => undefined), callbackFlags);
+    proto.define("onData", realm.method((self, args, version) => {
+        const data = args[0];
+        const result = data === null || data === undefined
+            ? false
+            : avm1.invoke(avm1.get(self, "parse", version), self, [data], version);
+        avm1.set(self, "loaded", result, version);
+        avm1.invoke(avm1.get(self, "onLoad", version), self, [result], version);
+        return undefined;
+    }), callbackFlags);
+    return constr;
+}
+/** A style object's TextFormat, by the TextFormat class `_global` has now; null for none given. */
+function transform(realm, args, version) {
+    if (args.length === 0 || args[0] === undefined || args[0] === null) {
+        return null;
+    }
+    const textFormat = avm1.get(realm.global, "TextFormat", version);
+    const proto = textFormat instanceof avm1.Avm1Object ? avm1.get(textFormat, "prototype", version) : undefined;
+    const format = emptyFormat();
+    format.kerning = false;
+    const style = args[0];
+    if (style instanceof avm1.Avm1Object) {
+        styleFormat(style, format, version);
+    }
+    return proto instanceof avm1.Avm1Object
+        ? newTextFormat(proto, format)
+        : newTextFormat(realm.objectProto, format);
+}
+/** A number as parseInt reads it, any suffix after it ignored, to an int. */
+const suffixed = (value, version) => avm1.parseIntAvm1(avm1.stringOf(value, version), undefined, false, version) | 0;
+/** What a style object's CSS properties set in `format`. */
+function styleFormat(style, format, version) {
+    const get = (name) => avm1.get(style, name, version);
+    // Some properties are read only where they convert to true.
+    const truthy = (name) => {
+        const v = get(name);
+        return avm1.toBoolean(v, version) ? v : undefined;
+    };
+    // #RRGGBB exactly, in a string.
+    const color = get("color");
+    if (typeof color === "string" && /^#[0-9a-fA-F]{6}$/.test(color)) {
+        format.color = Number.parseInt(color.slice(1), 16);
+    }
+    const display = get("display");
+    if (display !== undefined) {
+        const value = avm1.stringOf(display, version);
+        format.display = value === "none" || value === "inline" ? value : "block";
+    }
+    const family = truthy("fontFamily");
+    if (family !== undefined) {
+        format.font = fontList(avm1.stringOf(family, version));
+    }
+    const size = get("fontSize");
+    if (size !== undefined) {
+        const n = suffixed(size, version);
+        if (n > 0) {
+            format.size = n;
+        }
+    }
+    const fontStyle = avm1.stringOf(get("fontStyle"), version);
+    if (fontStyle === "normal" || fontStyle === "italic") {
+        format.italic = fontStyle === "italic";
+    }
+    const weight = avm1.stringOf(get("fontWeight"), version);
+    if (weight === "normal" || weight === "bold") {
+        format.bold = weight === "bold";
+    }
+    const kerning = get("kerning");
+    if (kerning !== undefined) {
+        format.kerning = kerning === "true" || suffixed(kerning, version) !== 0;
+    }
+    const leading = truthy("leading");
+    if (leading !== undefined) {
+        format.leading = suffixed(leading, version);
+    }
+    const spacing = truthy("letterSpacing");
+    if (spacing !== undefined) {
+        format.letterSpacing = avm1.parseIntAvm1(avm1.stringOf(spacing, version), undefined, false, version);
+    }
+    const left = truthy("marginLeft");
+    if (left !== undefined) {
+        format.leftMargin = Math.max(0, suffixed(left, version));
+    }
+    const right = truthy("marginRight");
+    if (right !== undefined) {
+        format.rightMargin = Math.max(0, suffixed(right, version));
+    }
+    const align = get("textAlign");
+    if (align !== undefined) {
+        const value = avm1.stringOf(align, version).toLowerCase();
+        if (["left", "center", "right", "justify"].includes(value)) {
+            format.align = value;
+        }
+    }
+    const decoration = get("textDecoration");
+    if (decoration !== undefined) {
+        const value = avm1.stringOf(decoration, version);
+        if (value === "none" || value === "underline") {
+            format.underline = value === "underline";
+        }
+    }
+    const indent = truthy("textIndent");
+    if (indent !== undefined) {
+        format.indent = suffixed(indent, version);
+    }
+}

package/dist/thread/player/avm1/globals/TextField.js

@@ -0,0 +1,396 @@
+// TextField, AS2's, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/text_field.rs has it: MIT OR Apache-2.0, Copyright
+// (c) 2018-2022 Ruffle LLC and Ruffle contributors. A field's AVM1 object
+// reads and writes the player's TextObject, its text and formats a
+// TextModel (text/text.ts) as AS3's TextField's are; its properties are
+// accessors on the prototype, which find the field each time, so that any
+// other object given them reads undefined.
+import { avm1 } from "../../../runtime/index.js";
+import { CONTENT, TextObject } from "../../display/display.js";
+import { maxScrollV, shownLines } from "../../text/layout.js";
+import { applied, emptyFormat } from "../../text/text.js";
+import { filtersProperty } from "./filters.js";
+import { DEPTH_BIAS } from "./MovieClip.js";
+import { stylesOf } from "./StyleSheet.js";
+import { formatOf, newTextFormat } from "./TextFormat.js";
+const states = new WeakMap();
+/** `field`'s AVM1 state, at first as its DefineEditText gives it. */
+export function stateOf(field) {
+    let state = states.get(field);
+    if (state === undefined) {
+        const edit = field.definition?.definition;
+        state = {
+            html: edit?.html ?? false,
+            variable: edit?.variable ? edit.variable : null,
+            tabIndex: undefined,
+            styleSheet: undefined,
+            selected: false,
+        };
+        states.set(field, state);
+    }
+    return state;
+}
+/** The field `self` is the AVM1 object of, where it is one's. */
+function fieldOf(self) {
+    if (!(self instanceof avm1.Avm1Object) || self.display === null) {
+        return null;
+    }
+    const d = self.display.live()?.display?.target;
+    return d instanceof TextObject ? d : null;
+}
+/** The text or the field changed: drawn again, and fitted to its text under autoSize. */
+function changed(field) {
+    field.invalidate(CONTENT);
+    field.fit();
+}
+/** Whether the field's text is read as HTML: an HTML field's, or one with a style sheet. */
+const isHtml = (field) => {
+    const state = stateOf(field);
+    return state.html || state.styleSheet !== undefined;
+};
+/**
+ * HTML read into the field: under a style sheet, styled by it, and kept,
+ * as htmlText gives it back and a new sheet styles it again.
+ */
+function parseHtml(field, html) {
+    const styles = stylesOf(stateOf(field).styleSheet);
+    if (styles === null) {
+        field.model.setHtml(html, field.multiline);
+        return;
+    }
+    field.htmlSource = html;
+    field.model.setHtml(html, field.multiline, false, (selector) => styles.get(selector) ?? null);
+}
+/**
+ * `field`'s text set: as HTML under a style sheet. The text it has already
+ * changes nothing, its formats included (Ruffle's set_text).
+ */
+function setText(field, text) {
+    if (text === field.model.text) {
+        return;
+    }
+    if (stateOf(field).styleSheet !== undefined) {
+        parseHtml(field, text);
+    }
+    else {
+        field.model.setText(text);
+    }
+    changed(field);
+}
+/**
+ * `field`'s text set as HTML, as htmlText and a bound variable set it, in
+ * a field not HTML as its text. The HTML it has already changes nothing.
+ */
+export function setHtmlText(field, html) {
+    if (html === htmlTextOf(field)) {
+        return;
+    }
+    if (!isHtml(field)) {
+        setText(field, html);
+        return;
+    }
+    parseHtml(field, html);
+    changed(field);
+}
+/** The field's text as HTML, the HTML a sheet styled as it was set, where it is HTML; else its text. */
+export function htmlTextOf(field) {
+    if (!isHtml(field)) {
+        return field.model.text;
+    }
+    return field.htmlSource ?? field.model.toHtml();
+}
+/** An index as Rust's `as usize` makes a u32 of a value: wrapped to 32 bits. */
+const indexOf = (v, version) => avm1.toNumber(v, version) >>> 0;
+/** A colour as Flash keeps one: 24 bits of a u32. */
+const rgbOf = (v, version) => (avm1.toNumber(v, version) >>> 0) & 0xffffff;
+/** `_global.TextField`. */
+export function textFieldClass(host) {
+    const realm = host.realm;
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self) => self, () => undefined);
+    /** `_global.TextFormat.prototype`, as it is now. */
+    const formatProto = (version) => {
+        const textFormat = avm1.get(realm.global, "TextFormat", version);
+        return textFormat instanceof avm1.Avm1Object
+            ? avm1.get(textFormat, "prototype", version)
+            : undefined;
+    };
+    const textFormat = (format, version) => {
+        const p = formatProto(version);
+        return p instanceof avm1.Avm1Object ? newTextFormat(p, format) : undefined;
+    };
+    const method = (name, flags, fn) => {
+        proto.define(name, realm.method((self, args, version) => {
+            const field = fieldOf(self);
+            return field === null ? undefined : fn(field, args, version);
+        }), avm1.DONT_ENUM | avm1.DONT_DELETE | flags);
+    };
+    const property = (name, get, set, flags = 0) => {
+        const p = proto.add(name, undefined, flags);
+        p.get = realm.method((self, _, version) => {
+            const field = fieldOf(self);
+            return field === null ? undefined : get(field, version);
+        });
+        if (set !== null) {
+            p.set = realm.method((self, args, version) => {
+                const field = fieldOf(self);
+                if (field !== null) {
+                    set(field, args[0], version);
+                }
+                return undefined;
+            });
+        }
+    };
+    const flag = (name, get, set) => property(name, get, (field, value, version) => {
+        set(field, avm1.toBoolean(value, version));
+        changed(field);
+    });
+    // The selection replaced, at the start where there is none, the caret after what came in.
+    method("replaceSel", avm1.VERSION_6, (field, args, version) => {
+        const text = avm1.stringOf(args[0], version);
+        const state = stateOf(field);
+        const [begin, end] = state.selected ? field.selection : [0, 0];
+        state.selected = true;
+        field.model.replace(begin, end, text);
+        field.select(begin + text.length, begin + text.length);
+        changed(field);
+        host.textChanged(field);
+        return undefined;
+    });
+    // [begin, end), one character from begin, or the whole text.
+    method("getTextFormat", avm1.VERSION_6, (field, args, version) => {
+        const length = field.model.text.length;
+        let begin = 0;
+        let end = length;
+        if (args.length > 0) {
+            begin = indexOf(args[0], version);
+            end = args.length > 1 ? indexOf(args[1], version) : begin + 1;
+        }
+        end = Math.min(end, length);
+        if (begin >= end) {
+            return textFormat(emptyFormat(), version);
+        }
+        return textFormat(field.model.formatOf(begin, end), version);
+    });
+    method("setTextFormat", avm1.VERSION_6, (field, args, version) => {
+        const length = field.model.text.length;
+        let begin = 0;
+        let end = length;
+        let format;
+        if (args.length >= 3) {
+            begin = indexOf(args[0], version);
+            end = indexOf(args[1], version);
+            format = args[2];
+        }
+        else if (args.length === 2) {
+            begin = indexOf(args[0], version);
+            end = begin + 1;
+            format = args[1];
+        }
+        else if (args.length === 1) {
+            format = args[0];
+        }
+        else {
+            return undefined;
+        }
+        const change = formatOf(format);
+        end = Math.min(end, length);
+        if (change !== null && begin < end) {
+            field.model.setFormat(change, begin, end);
+            changed(field);
+        }
+        return undefined;
+    });
+    method("removeTextField", avm1.VERSION_6, (field) => {
+        host.remove(field);
+        return undefined;
+    });
+    method("getNewTextFormat", avm1.VERSION_6, (field, _, version) => textFormat(field.model.defaultFormat, version));
+    method("setNewTextFormat", avm1.VERSION_6, (field, args) => {
+        const change = formatOf(args[0]);
+        if (change !== null) {
+            field.model.defaultFormat = applied(field.model.defaultFormat, change);
+        }
+        return undefined;
+    });
+    method("getDepth", avm1.READ_ONLY | avm1.VERSION_6, (field) => field.depth === null ? undefined : field.depth - DEPTH_BIAS);
+    // The indices as Rust casts them to usize, NaN and below 0 to 0; a range backwards is none.
+    method("replaceText", avm1.VERSION_7, (field, args, version) => {
+        const model = field.model;
+        const usize = (v) => Math.max(0, Math.trunc(avm1.toNumber(v, version)) || 0);
+        const from = usize(args[0]);
+        const to = usize(args[1]);
+        const text = avm1.stringOf(args[2], version);
+        if (to < from) {
+            return undefined;
+        }
+        model.replace(Math.min(from, model.text.length), Math.min(to, model.text.length), text);
+        changed(field);
+        return undefined;
+    });
+    // An unknown one is left as it was.
+    property("gridFitType", (field) => field.gridFitType, (field, value, version) => {
+        const type = avm1.stringOf(value, version);
+        if (type === "pixel" || type === "subpixel" || type === "none") {
+            field.gridFitType = type;
+            field.invalidate(CONTENT);
+        }
+    }, avm1.VERSION_8);
+    property("antiAliasType", (field) => field.antiAliasType, (field, value, version) => {
+        const type = avm1.stringOf(value, version);
+        if ((type === "normal" || type === "advanced") && type !== field.antiAliasType) {
+            field.antiAliasType = type;
+            changed(field);
+        }
+    }, avm1.VERSION_8);
+    property("thickness", (field) => field.thickness, (field, value, version) => {
+        field.thickness = Math.fround(avm1.toNumber(value, version));
+        field.invalidate(CONTENT);
+    }, avm1.VERSION_8);
+    property("sharpness", (field) => field.sharpness, (field, value, version) => {
+        field.sharpness = Math.fround(avm1.toNumber(value, version));
+        field.invalidate(CONTENT);
+    }, avm1.VERSION_8);
+    // No AS2 filter draws yet: a field has none, and takes none.
+    property("filters", (_, version) => realm.newArray([], version), () => { }, avm1.DONT_DELETE | avm1.VERSION_8);
+    property("scroll", (field) => field.scrollV, 
+    // NaN, a negative line and one past where Flash's count overflows are the first (Ruffle).
+    (field, value, version) => {
+        const n = avm1.toNumber(value, version);
+        const line = Number.isNaN(n) || n < 0 || n >= 767100486418433 ? 1 : Math.trunc(n);
+        field.scrollV = Math.max(1, Math.min(line, maxScrollV(field)));
+        field.invalidate(CONTENT);
+    });
+    property("maxscroll", (field) => maxScrollV(field), null);
+    property("borderColor", (field) => field.borderColor, (field, value, version) => {
+        field.borderColor = rgbOf(value, version);
+        changed(field);
+    });
+    property("backgroundColor", (field) => field.backgroundColor, (field, value, version) => {
+        field.backgroundColor = rgbOf(value, version);
+        changed(field);
+    });
+    // The new text's colour, and every character's.
+    property("textColor", (field) => field.model.defaultFormat.color, (field, value, version) => {
+        const color = rgbOf(value, version);
+        const model = field.model;
+        const change = emptyFormat();
+        change.color = color;
+        model.setFormat(change, 0, model.text.length);
+        model.defaultFormat = { ...model.defaultFormat, color };
+        changed(field);
+    });
+    // A u32, kept as an int; nothing is none.
+    property("tabIndex", (field) => {
+        const index = stateOf(field).tabIndex;
+        return index === undefined ? undefined : index >>> 0;
+    }, (field, value, version) => {
+        stateOf(field).tabIndex =
+            value === undefined || value === null ? undefined : avm1.toNumber(value, version) | 0;
+    });
+    property("autoSize", (field) => field.autoSize, (field, value, version) => {
+        let mode = "none";
+        if (typeof value === "boolean") {
+            mode = value ? "left" : "none";
+        }
+        else {
+            const name = avm1.stringOf(value, version).toLowerCase();
+            mode = name === "left" || name === "center" || name === "right" ? name : "none";
+        }
+        field.autoSize = mode;
+        field.fit();
+    });
+    property("text", (field) => field.model.text, (field, value, version) => {
+        setText(field, avm1.stringOf(value, version));
+        host.textChanged(field);
+    });
+    // Anything but input or dynamic, in any case, leaves it.
+    property("type", (field) => field.type, (field, value, version) => {
+        const type = avm1.stringOf(value, version).toLowerCase();
+        if (type === "input" || type === "dynamic") {
+            field.type = type;
+            changed(field);
+        }
+    });
+    // Read as HTML only in an HTML field; it does not change a bound variable.
+    property("htmlText", (field) => htmlTextOf(field), (field, value, version) => setHtmlText(field, avm1.stringOf(value, version)));
+    // None is null.
+    property("variable", (field) => stateOf(field).variable, (field, value, version) => {
+        const name = value === undefined || value === null ? null : avm1.stringOf(value, version);
+        stateOf(field).variable = name === "" ? null : name;
+        host.variableChanged(field);
+    });
+    property("hscroll", (field) => field.scrollH, (field, value, version) => {
+        field.scrollH = Math.max(0, avm1.toNumber(value, version) | 0);
+        field.invalidate(CONTENT);
+    });
+    property("maxhscroll", (field) => maxHScroll(field), null);
+    // None is null.
+    property("maxChars", (field) => (field.maxChars === 0 ? null : field.maxChars), (field, value, version) => {
+        field.maxChars = avm1.toNumber(value, version) | 0;
+    });
+    flag("embedFonts", (field) => field.embedFonts, (field, v) => {
+        field.embedFonts = v;
+    });
+    property("html", (field) => stateOf(field).html, (field, value, version) => {
+        stateOf(field).html = avm1.toBoolean(value, version);
+    });
+    flag("border", (field) => field.border, (field, v) => {
+        field.border = v;
+    });
+    flag("background", (field) => field.background, (field, v) => {
+        field.background = v;
+    });
+    flag("wordWrap", (field) => field.wordWrap, (field, v) => {
+        field.wordWrap = v;
+    });
+    flag("password", (field) => field.displayAsPassword, (field, v) => {
+        field.displayAsPassword = v;
+    });
+    flag("multiline", (field) => field.multiline, (field, v) => {
+        field.multiline = v;
+    });
+    flag("selectable", (field) => field.selectable, (field, v) => {
+        field.selectable = v;
+    });
+    property("length", (field) => field.model.text.length, null);
+    property("bottomScroll", (field) => field.scrollV + shownLines(field, field.scrollV - 1) - 1, null);
+    // In whole pixels, cut.
+    property("textWidth", (field) => Math.trunc(field.layout.width / 20), null);
+    property("textHeight", (field) => Math.trunc(field.layout.height / 20), null);
+    // None, and an empty one, is null.
+    property("restrict", (field) => field.restrict, (field, value, version) => {
+        const restrict = value === undefined || value === null ? "" : avm1.stringOf(value, version);
+        field.restrict = restrict === "" ? null : restrict;
+    });
+    flag("condenseWhite", (field) => field.condenseWhite, (field, v) => {
+        field.condenseWhite = v;
+    });
+    flag("mouseWheelEnabled", (field) => field.mouseWheelEnabled, (field, v) => {
+        field.mouseWheelEnabled = v;
+    });
+    // Any object but a clip, and nothing for anything else (Ruffle, whose clips are values of
+    // their own). The HTML a sheet styled is styled again by a new one, and forgotten with
+    // none (Ruffle's set_style_sheet).
+    property("styleSheet", (field) => stateOf(field).styleSheet, (field, value) => {
+        const sheet = value instanceof avm1.Avm1Object && value.typeOf() !== "movieclip";
+        stateOf(field).styleSheet = sheet ? value : undefined;
+        if (stateOf(field).styleSheet === undefined) {
+            field.htmlSource = null;
+        }
+        else if (field.htmlSource !== null) {
+            parseHtml(field, field.htmlSource);
+        }
+        changed(field);
+    });
+    filtersProperty(realm, proto, avm1.DONT_DELETE | avm1.VERSION_8, (self) => fieldOf(self), () => host.filterFaces);
+    return { constr, proto };
+}
+/** How far the text scrolls sideways: its width past the field's, in whole pixels. */
+function maxHScroll(field) {
+    if (field.wordWrap) {
+        return 0;
+    }
+    const over = field.layout.width / 20 + 4 - field.width;
+    return over > 0 ? Math.trunc(over) : 0;
+}