@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,194 @@
+// TextFormat, AS2's, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/text_format.rs has it: MIT OR Apache-2.0,
+// Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors. A TextFormat
+// holds a PartialFormat (text/text.ts) natively, null for each value it
+// does not set, which its properties read and write as Flash converts them.
+import { avm1 } from "../../../runtime/index.js";
+import { TextObject } from "../../display/display.js";
+import { applied, emptyFormat } from "../../text/text.js";
+const formats = new WeakMap();
+/** The format a TextFormat holds; null for any other object. */
+export function formatOf(value) {
+    return value instanceof avm1.Avm1Object ? (formats.get(value) ?? null) : null;
+}
+/** A number as Ruffle's round_to_even makes it an int: a half to even, what does not fit -2^31. */
+function roundToEven(n) {
+    const r = Math.round(n);
+    const even = Math.abs(n % 1) === 0.5 && r % 2 !== 0 ? r - 1 : r;
+    return Number.isFinite(even) && even <= 0x7fffffff && even >= -0x80000000 ? even : -0x80000000;
+}
+const unset = (v) => v === undefined || v === null;
+/** The most tab stops a TextFormat reads of an object. */
+const MAX_TAB_STOPS = 0x10000;
+/** A value of the integer kind as a SWF of `version` keeps it: to an int, wrapping, before 8; rounded from 8. */
+function integer(v, version, min) {
+    const n = avm1.toNumber(v, version);
+    if (version < 8) {
+        const i = n | 0;
+        return min === null ? i : Math.max(min, i);
+    }
+    // Rust's max, which takes the other for NaN.
+    return roundToEven(min === null ? n : Number.isNaN(n) ? min : Math.max(min, n));
+}
+/** Each property, and what it stores of a value set: undefined to leave it as it is. */
+const PROPERTIES = [
+    // Up to 64 characters of the name.
+    ["font", (v, version) => (unset(v) ? null : avm1.stringOf(v, version).slice(0, 64))],
+    ["size", (v, version) => (unset(v) ? null : integer(v, version, null))],
+    ["color", (v, version) => (unset(v) ? null : avm1.toNumber(v, version) >>> 0)],
+    ["url", (v, version) => (unset(v) ? null : avm1.stringOf(v, version))],
+    ["target", (v, version) => (unset(v) ? null : avm1.stringOf(v, version))],
+    ["bold", (v, version) => (unset(v) ? null : avm1.toBoolean(v, version))],
+    ["italic", (v, version) => (unset(v) ? null : avm1.toBoolean(v, version))],
+    ["underline", (v, version) => (unset(v) ? null : avm1.toBoolean(v, version))],
+    // Neither nothing nor an unknown alignment changes it.
+    [
+        "align",
+        (v, version) => {
+            if (unset(v)) {
+                return undefined;
+            }
+            const align = avm1.stringOf(v, version).toLowerCase();
+            return ["left", "center", "right", "justify"].includes(align) ? align : undefined;
+        },
+    ],
+    ["leftMargin", (v, version) => (unset(v) ? null : integer(v, version, 0))],
+    ["rightMargin", (v, version) => (unset(v) ? null : integer(v, version, 0))],
+    [
+        "indent",
+        (v, version) => unset(v) ? null : version < 8 ? integer(v, version, 0) : integer(v, version, null),
+    ],
+    [
+        "leading",
+        (v, version) => unset(v) ? null : version < 8 ? integer(v, version, 0) : integer(v, version, null),
+    ],
+    [
+        "blockIndent",
+        (v, version) => unset(v) ? null : version < 8 ? integer(v, version, 0) : integer(v, version, null),
+    ],
+    // Any object's elements, by its length, at most 2^16 of them: a length a
+    // script made up must not keep a native loop from the script timeout.
+    [
+        "tabStops",
+        (v, version) => {
+            if (!(v instanceof avm1.Avm1Object)) {
+                return null;
+            }
+            const length = Math.min(avm1.toNumber(avm1.get(v, "length", version), version) | 0, MAX_TAB_STOPS);
+            const stops = [];
+            for (let i = 0; i < length; i++) {
+                stops.push(roundToEven(avm1.toNumber(avm1.get(v, String(i), version), version)));
+            }
+            return stops;
+        },
+    ],
+    ["bullet", (v, version) => (unset(v) ? null : avm1.toBoolean(v, version))],
+    // Nothing, or anything unknown, is a block.
+    [
+        "display",
+        (v, version) => {
+            const display = unset(v) ? "block" : avm1.stringOf(v, version);
+            return display === "inline" || display === "none" ? display : "block";
+        },
+    ],
+    ["kerning", (v, version) => (unset(v) ? null : avm1.toBoolean(v, version))],
+    ["letterSpacing", (v, version) => (unset(v) ? null : avm1.toNumber(v, version))],
+];
+const STORES = new Map(PROPERTIES);
+/** The constructor's parameters, in order: from size, the numbers are ints whatever the version. */
+const PARAMETERS = [
+    "font",
+    "size",
+    "color",
+    "bold",
+    "italic",
+    "underline",
+    "url",
+    "target",
+    "align",
+    "leftMargin",
+    "rightMargin",
+    "indent",
+    "leading",
+];
+/** A value of a format as a property gives it: null where it sets none, an array of tab stops. */
+function propertyValue(format, key, realm, version) {
+    const v = format[key];
+    if (v === null) {
+        return null;
+    }
+    return Array.isArray(v) ? realm.newArray([...v], version) : v;
+}
+/** `_global.TextFormat`, and how to make one of a format. */
+export function textFormatClass(host) {
+    const realm = host.realm;
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, (self, args, version) => {
+        const format = emptyFormat();
+        for (const [i, key] of PARAMETERS.entries()) {
+            const v = args[i];
+            const integral = i === 1 || i >= 9;
+            const asInt = unset(v) ? null : avm1.toNumber(v, version) | 0;
+            const stored = integral ? asInt : STORES.get(key)?.(v, version);
+            if (stored !== undefined) {
+                format[key] = stored;
+            }
+        }
+        formats.set(self, format);
+        return self;
+    }, () => undefined);
+    for (const [key, store] of PROPERTIES) {
+        const p = proto.add(key, undefined, 0);
+        p.get = realm.method((self, _, version) => {
+            const format = formats.get(self);
+            return format === undefined ? undefined : propertyValue(format, key, realm, version);
+        });
+        p.set = realm.method((self, args, version) => {
+            const format = formats.get(self);
+            if (format !== undefined) {
+                const stored = store(args[0], version);
+                if (stored !== undefined) {
+                    format[key] = stored;
+                }
+            }
+            return undefined;
+        });
+    }
+    proto.define("getTextExtent", realm.method((self, args, version) => {
+        const format = formats.get(self);
+        return format === undefined ? undefined : textExtent(format, args, version);
+    }), avm1.DONT_ENUM | avm1.DONT_DELETE);
+    return { constr, proto };
+}
+/** A TextFormat of `format`, of prototype `proto`, as a field's methods make one. */
+export function newTextFormat(proto, format) {
+    const o = new avm1.Avm1Object(proto);
+    formats.set(o, { ...format, tabStops: format.tabStops === null ? null : [...format.tabStops] });
+    return o;
+}
+/**
+ * getTextExtent: `text` laid out in the format, in a field that fits it,
+ * wrapped at a width where one is given: its first line's ascent and
+ * descent, the text's width and height, and the field's.
+ */
+function textExtent(format, args, version) {
+    const text = avm1.stringOf(args[0], version);
+    const width = args.length > 1 && args[1] !== undefined ? avm1.toNumber(args[1], version) : null;
+    const field = new TextObject(null);
+    field.width = width ?? 0;
+    field.wordWrap = width !== null;
+    field.autoSize = "left";
+    field.model.defaultFormat = applied(field.model.defaultFormat, format);
+    field.model.setText(text);
+    field.fit();
+    const layout = field.layout;
+    const first = layout.lines[0];
+    const out = new avm1.Avm1Object();
+    avm1.set(out, "ascent", (first?.ascent ?? 0) / 20, version);
+    avm1.set(out, "descent", (first?.descent ?? 0) / 20, version);
+    avm1.set(out, "width", layout.width / 20, version);
+    avm1.set(out, "height", layout.height / 20, version);
+    avm1.set(out, "textFieldHeight", field.height, version);
+    avm1.set(out, "textFieldWidth", field.width, version);
+    return out;
+}

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

@@ -0,0 +1,88 @@
+// TextSnapshot's AS2 face, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/text_snapshot.rs and display_object/text.rs's
+// TextSnapshot have it: MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle
+// LLC and Ruffle contributors. A snapshot is a clip's static texts' text,
+// its direct children's in the order they are drawn, as it was when made:
+// dynamic and input fields are not in it, nor the clip's grandchildren.
+// Selection, hit tests, the select colour and the run info do nothing yet,
+// as in Ruffle.
+import { avm1 } from "../../../runtime/index.js";
+import { MovieClip, StaticTextObject } from "../../display/display.js";
+import { asciiLower } from "../paths.js";
+/** A clip's static texts' text, as they were when the snapshot was made. */
+class Snapshot {
+    chunks = [];
+    count;
+    constructor(clip) {
+        let start = 0;
+        for (const child of clip.children) {
+            const text = child instanceof StaticTextObject ? child.glyphs.text : null;
+            if (text !== null && text !== "") {
+                this.chunks.push({ text, start });
+                start += text.length;
+            }
+        }
+        this.count = start;
+    }
+    /** Each chunk's part from `from` to `to`, the indices the whole's. */
+    parts(from, to) {
+        return this.chunks
+            .filter((c) => c.start < to && c.start + c.text.length > from)
+            .map((c) => c.text.slice(Math.max(0, from - c.start), Math.max(0, to - c.start)));
+    }
+    /**
+     * The text from `from` to `to`, at least one character, both clamped to
+     * the text, a negative index 0; with `newlines`, a "\n" between texts.
+     */
+    getText(from, to, newlines) {
+        if (this.count === 0) {
+            return "";
+        }
+        const start = Math.min(Math.max(0, from), this.count - 1);
+        const end = Math.max(Math.min(Math.max(0, to), this.count), start + 1);
+        return this.parts(start, end).join(newlines ? "\n" : "");
+    }
+    /** Where `text` is first found from `from` on, ASCII's case aside unless `caseSensitive`; -1 for none. */
+    findText(from, text, caseSensitive) {
+        if (text === "" || from < 0) {
+            return -1;
+        }
+        const whole = this.parts(from, this.count).join("");
+        const index = caseSensitive ? whole.indexOf(text) : asciiLower(whole).indexOf(asciiLower(text));
+        return index < 0 ? -1 : from + index;
+    }
+}
+/** `TextSnapshot`. */
+export function textSnapshotClass(realm) {
+    const snapshots = new WeakMap();
+    const proto = new avm1.Avm1Object(realm.objectProto);
+    const constr = realm.classOf(proto, 
+    // Of a clip given alone; anything else makes a snapshot of nothing, whose methods give undefined.
+    (self, args) => {
+        const target = args.length === 1 ? args[0] : undefined;
+        const clip = target instanceof avm1.Avm1Object ? target.display?.target : undefined;
+        if (clip instanceof MovieClip) {
+            snapshots.set(self, new Snapshot(clip));
+        }
+        return self;
+    }, () => undefined);
+    const method = (name, f) => proto.define(name, realm.method((self, args, v) => {
+        const s = snapshots.get(self);
+        return s === undefined ? undefined : f(s, args, v);
+    }), avm1.VERSION_6);
+    const none = () => undefined;
+    method("getCount", (s, args) => (args.length === 0 ? s.count : undefined));
+    method("setSelected", none);
+    method("getSelected", none);
+    method("getText", (s, args, v) => args.length < 2 || args.length > 3
+        ? undefined
+        : s.getText(avm1.toNumber(args[0], v) | 0, avm1.toNumber(args[1], v) | 0, avm1.toBoolean(args[2], v)));
+    method("getSelectedText", none);
+    method("hitTestTextNearPos", none);
+    method("findText", (s, args, v) => args.length !== 3
+        ? undefined
+        : s.findText(avm1.toNumber(args[0], v) | 0, avm1.stringOf(args[1], v), avm1.toBoolean(args[2], v)));
+    method("setSelectColor", none);
+    method("getTextRunInfo", none);
+    return constr;
+}

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

@@ -0,0 +1,396 @@
+// XML, AS1 and AS2's document, as Ruffle's (https://github.com/ruffle-rs/
+// ruffle) core/src/avm1/globals/xml.rs has it: MIT OR Apache-2.0, Copyright
+// (c) 2018-2022 Ruffle LLC and Ruffle contributors; where adl parts from
+// Ruffle, as adl has it. An XML is an XMLNode, its document's root, with no
+// name; parseXML replaces the root's children with what it reads, and on
+// an error keeps what it read before, `status` the error's number. load
+// and sendAndLoad go as LoadVars' do.
+import { avm1 } from "../../../runtime/index.js";
+import { bytesFor } from "../net.js";
+import { addRequestHeader, headersOf, startLoad } from "./LoadVars.js";
+import { ELEMENT_NODE, serialize, TEXT_NODE, XmlNode, } from "./XMLNode.js";
+// parseXML's statuses, as Flash 8 lists them.
+const OK = 0;
+const CDATA_NOT_TERMINATED = -2;
+const DECL_NOT_TERMINATED = -3;
+const DOCTYPE_NOT_TERMINATED = -4;
+const COMMENT_NOT_TERMINATED = -5;
+const ELEMENT_MALFORMED = -6;
+const ATTRIBUTE_NOT_TERMINATED = -8;
+const MISMATCHED_START = -9;
+const MISMATCHED_END = -10;
+/** The entities Flash knows by name, nbsp among them (adl). */
+const NAMED = {
+    lt: "<",
+    gt: ">",
+    amp: "&",
+    apos: "'",
+    quot: '"',
+    nbsp: " ",
+};
+/** An entity, `&...;`, decoded; null for one that is none, which is kept as it is. */
+function entity(text) {
+    const body = text.slice(1, -1);
+    if (Object.hasOwn(NAMED, body)) {
+        return NAMED[body];
+    }
+    let digits;
+    let radix;
+    if (body.startsWith("#x")) {
+        digits = body.slice(2);
+        radix = 16;
+    }
+    else if (body.startsWith("#")) {
+        digits = body.slice(1);
+        radix = 10;
+    }
+    else {
+        return null;
+    }
+    if (!(radix === 16 ? /^[0-9a-fA-F]+$/ : /^[0-9]+$/).test(digits)) {
+        return null;
+    }
+    // &#0; is nothing (adl).
+    const code = Number.parseInt(digits, radix);
+    if (code === 0) {
+        return "";
+    }
+    return code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff) ? null : String.fromCodePoint(code);
+}
+/**
+ * Text or an attribute's value with its entities decoded, each alone: a
+ * bare `&` before one is kept, and `&&amp;` is `&&`, as Flash has them
+ * (Ruffle's avm1_unescape); `&#X41;`, an unknown name, are kept as written.
+ */
+function unescapeXml(text) {
+    return text.includes("&") ? text.replace(/&[^;&]*;/g, (e) => entity(e) ?? e) : text;
+}
+const isWhite = (c) => c === " " || c === "\t" || c === "\n" || c === "\r";
+const allWhite = (text) => /^[ \t\n\r]*$/.test(text);
+/**
+ * `text` read into `root`'s children as Flash reads it (adl): elements,
+ * text, and CDATA as text; the XML declaration and DOCTYPE, in any case,
+ * kept aside; comments dropped; whitespace-only text too where
+ * `ignoreWhite`. Any other `<?` is malformed, and any other `<!` an
+ * element whose name starts with `!`. Attributes need no space between
+ * them, and a name's first value is kept. An end tag of an element further
+ * up closes those within it as unmatched starts; one of none is an error.
+ * It stops at the first error, what it read before kept. `id` gets each
+ * element with an `id` attribute.
+ */
+function parseXml(text, root, ignoreWhite, id, version) {
+    const parsed = { status: OK, xmlDecl: null, docTypeDecl: null };
+    const open = [root];
+    const top = () => open[open.length - 1];
+    const addText = (value) => {
+        if (value !== "" && !(ignoreWhite && allWhite(value))) {
+            top().adopt(new XmlNode(TEXT_NODE, value), version);
+        }
+    };
+    const fail = (status) => {
+        parsed.status = status;
+        return parsed;
+    };
+    const startsCaseless = (s, at) => text.slice(at, at + s.length).toLowerCase() === s.toLowerCase();
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] !== "<") {
+            let next = text.indexOf("<", i);
+            if (next < 0) {
+                next = text.length;
+            }
+            addText(unescapeXml(text.slice(i, next)));
+            i = next;
+            continue;
+        }
+        if (text.startsWith("<!--", i)) {
+            const end = text.indexOf("-->", i + 4);
+            if (end < 0) {
+                return fail(COMMENT_NOT_TERMINATED);
+            }
+            i = end + 3;
+            continue;
+        }
+        if (text.startsWith("<![CDATA[", i)) {
+            const end = text.indexOf("]]>", i + 9);
+            if (end < 0) {
+                return fail(CDATA_NOT_TERMINATED);
+            }
+            addText(text.slice(i + 9, end));
+            i = end + 3;
+            continue;
+        }
+        if (startsCaseless("<!DOCTYPE", i)) {
+            // Up to its >, past any <...> within it.
+            let depth = 0;
+            let end = -1;
+            for (let j = i + 9; j < text.length && end < 0; j++) {
+                if (text[j] === "<") {
+                    depth++;
+                }
+                else if (text[j] === ">") {
+                    if (depth === 0) {
+                        end = j;
+                    }
+                    depth--;
+                }
+            }
+            if (end < 0) {
+                return fail(DOCTYPE_NOT_TERMINATED);
+            }
+            parsed.docTypeDecl = text.slice(i, end + 1);
+            i = end + 1;
+            continue;
+        }
+        if (text.startsWith("<?", i)) {
+            if (!startsCaseless("<?xml", i) || !isWhite(text[i + 5])) {
+                return fail(ELEMENT_MALFORMED);
+            }
+            const end = text.indexOf("?>", i + 5);
+            if (end < 0) {
+                return fail(DECL_NOT_TERMINATED);
+            }
+            parsed.xmlDecl = text.slice(i, end + 2);
+            i = end + 2;
+            continue;
+        }
+        if (text.startsWith("</", i)) {
+            const end = text.indexOf(">", i + 2);
+            if (end < 0) {
+                return fail(ELEMENT_MALFORMED);
+            }
+            const name = text.slice(i + 2, end).replace(/[ \t\n\r]+$/, "");
+            let at = open.length - 1;
+            while (at > 0 && open[at].value !== name) {
+                at--;
+            }
+            if (at === 0) {
+                return fail(MISMATCHED_END);
+            }
+            if (at < open.length - 1) {
+                parsed.status = MISMATCHED_START;
+            }
+            open.length = at;
+            i = end + 1;
+            continue;
+        }
+        // An element: its name, up to whitespace, > or />, then its attributes.
+        let j = i + 1;
+        while (j < text.length && !isWhite(text[j]) && text[j] !== ">" && !text.startsWith("/>", j)) {
+            j++;
+        }
+        if (j === i + 1 || j >= text.length) {
+            return fail(ELEMENT_MALFORMED);
+        }
+        const element = new XmlNode(ELEMENT_NODE, text.slice(i + 1, j));
+        const names = [];
+        const seen = new Set();
+        const values = [];
+        let empty = false;
+        for (;;) {
+            while (isWhite(text[j])) {
+                j++;
+            }
+            if (j >= text.length) {
+                return fail(ELEMENT_MALFORMED);
+            }
+            if (text[j] === ">") {
+                j++;
+                break;
+            }
+            if (text.startsWith("/>", j)) {
+                empty = true;
+                j += 2;
+                break;
+            }
+            const start = j;
+            while (j < text.length && !isWhite(text[j]) && text[j] !== "=" && text[j] !== ">") {
+                j++;
+            }
+            const name = text.slice(start, j);
+            while (isWhite(text[j])) {
+                j++;
+            }
+            if (name === "" || text[j] !== "=") {
+                return fail(ELEMENT_MALFORMED);
+            }
+            j++;
+            while (isWhite(text[j])) {
+                j++;
+            }
+            const quote = text[j];
+            if (quote !== '"' && quote !== "'") {
+                return fail(ELEMENT_MALFORMED);
+            }
+            const close = text.indexOf(quote, j + 1);
+            if (close < 0) {
+                return fail(ATTRIBUTE_NOT_TERMINATED);
+            }
+            if (!seen.has(name)) {
+                seen.add(name);
+                names.push(name);
+                values.push(unescapeXml(text.slice(j + 1, close)));
+            }
+            j = close + 1;
+        }
+        // Added last first, so that for..in, which lists the newest first, has them as written.
+        for (let a = names.length - 1; a >= 0; a--) {
+            element.attributes.define(names[a], values[a], 0);
+        }
+        for (let a = 0; a < names.length; a++) {
+            if (names[a] === "id") {
+                id(values[a], element);
+            }
+        }
+        top().adopt(element, version);
+        if (!empty) {
+            open.push(element);
+        }
+        i = j;
+    }
+    return open.length > 1 ? fail(MISMATCHED_START) : parsed;
+}
+/** `_global.XML`, given XMLNode's class, and its native side. */
+export function xmlClass(host, nodes) {
+    const realm = host.realm;
+    const documents = new WeakMap();
+    const proto = new avm1.Avm1Object(nodes.proto);
+    /** `text` read into the document of `self`, by its ignoreWhite. */
+    const parse = (self, doc, text, v) => {
+        const ignoreWhite = avm1.toBoolean(avm1.get(self, "ignoreWhite", v), v);
+        const parsed = parseXml(text, doc.root, ignoreWhite, (value, node) => doc.idMap.define(value, nodes.objectOf(node, v), 0), v);
+        doc.status = parsed.status;
+        if (parsed.xmlDecl !== null) {
+            doc.root.xmlDecl = parsed.xmlDecl;
+        }
+        if (parsed.docTypeDecl !== null) {
+            doc.root.docTypeDecl = parsed.docTypeDecl;
+        }
+    };
+    const constr = realm.classOf(proto, (self, args, v) => {
+        const doc = {
+            root: new XmlNode(ELEMENT_NODE, null),
+            idMap: new avm1.Avm1Object(),
+            status: OK,
+        };
+        nodes.bind(self, doc.root);
+        documents.set(self, doc);
+        // No text, undefined or null, is no parse (adl: new XML(undefined) is empty).
+        if (args[0] !== undefined && args[0] !== null) {
+            parse(self, doc, avm1.stringOf(args[0], v), v);
+        }
+        return self;
+    }, () => undefined);
+    // In Flash's order, which for..in lists reversed (adl).
+    const method = (name, fn) => proto.define(name, realm.method(fn), 0);
+    const property = (name, get, set, flags = 0) => {
+        const p = proto.add(name, undefined, flags);
+        p.get = realm.method((self) => {
+            const doc = documents.get(self);
+            return doc === undefined ? undefined : get(doc);
+        });
+        if (set !== null) {
+            p.set = realm.method((self, args, v) => {
+                const doc = documents.get(self);
+                if (doc !== undefined) {
+                    set(doc, args[0], v);
+                }
+                return undefined;
+            });
+        }
+    };
+    /** A declaration as set: none for undefined or null. */
+    const declaration = (value, v) => value === undefined || value === null ? null : avm1.stringOf(value, v);
+    method("createElement", (self, args, v) => {
+        if (!documents.has(self) || args.length === 0) {
+            return undefined;
+        }
+        return nodes.objectOf(new XmlNode(ELEMENT_NODE, avm1.stringOf(args[0], v)), v);
+    });
+    method("createTextNode", (self, args, v) => {
+        if (!documents.has(self) || args.length === 0) {
+            return undefined;
+        }
+        return nodes.objectOf(new XmlNode(TEXT_NODE, avm1.stringOf(args[0], v)), v);
+    });
+    method("parseXML", (self, args, v) => {
+        const doc = documents.get(self);
+        if (doc === undefined) {
+            return undefined;
+        }
+        doc.root.clear(v);
+        if (args.length > 0) {
+            parse(self, doc, avm1.stringOf(args[0], v), v);
+        }
+        return undefined;
+    });
+    method("load", (self, args, v) => {
+        if (args[0] === null || !documents.has(self)) {
+            return false;
+        }
+        const url = avm1.stringOf(args[0], v);
+        startLoad(host, self, { url, method: "GET", headers: [], body: null }, v);
+        return true;
+    });
+    // Flash 8's send: the document posted, its answer dropped; no window shows it.
+    method("send", (self, args, v) => {
+        const doc = documents.get(self);
+        if (args.length === 0 || doc === undefined) {
+            return false;
+        }
+        return host.net.send(postOf(self, args[0], doc.root, v));
+    });
+    method("sendAndLoad", (self, args, v) => {
+        const doc = documents.get(self);
+        const target = args[1];
+        if (args[0] === null || doc === undefined || !(target instanceof avm1.Avm1Object)) {
+            return undefined;
+        }
+        startLoad(host, target, postOf(self, args[0], doc.root, v), v);
+        return undefined;
+    });
+    method("onLoad", () => undefined);
+    method("onData", (self, args, v) => {
+        const src = args[0];
+        if (src === undefined) {
+            call(self, "onLoad", [false], v);
+        }
+        else {
+            call(self, "parseXML", [avm1.stringOf(src, v)], v);
+            avm1.set(self, "loaded", true, v);
+            call(self, "onLoad", [true], v);
+        }
+        return undefined;
+    });
+    method("getBytesLoaded", (self, _, v) => avm1.get(self, "_bytesLoaded", v));
+    method("getBytesTotal", (self, _, v) => avm1.get(self, "_bytesTotal", v));
+    method("addRequestHeader", (self, args, v) => addRequestHeader(self, args, v));
+    proto.define("contentType", "application/x-www-form-urlencoded", 0);
+    property("docTypeDecl", (doc) => doc.root.docTypeDecl ?? undefined, (doc, value, v) => {
+        doc.root.docTypeDecl = declaration(value, v);
+    });
+    proto.define("ignoreWhite", false, 0);
+    proto.define("loaded", undefined, 0);
+    property("status", (doc) => doc.status, (doc, value) => {
+        doc.status = value;
+    });
+    property("xmlDecl", (doc) => doc.root.xmlDecl ?? undefined, (doc, value, v) => {
+        doc.root.xmlDecl = declaration(value, v);
+    });
+    property("idMap", (doc) => doc.idMap, null, avm1.DONT_ENUM | avm1.DONT_DELETE);
+    /** `self`'s document posted to `url` as its contentType, with its request headers. */
+    const postOf = (self, url, root, v) => {
+        const type = avm1.stringOf(avm1.get(self, "contentType", v), v);
+        return {
+            url: avm1.stringOf(url, v),
+            method: "POST",
+            headers: [...headersOf(self), ["Content-Type", type]],
+            body: bytesFor(serialize(root, v), v),
+        };
+    };
+    return constr;
+}
+/** `self[name](...args)` where it is a function. */
+function call(self, name, args, v) {
+    return avm1.invoke(avm1.get(self, name, v), self, args, v);
+}