@swf2es/runtime 0.0.0-stage → 0.1.0

package/dist/avm2/builtin/xml/xml.js

@@ -0,0 +1,1856 @@
+// E4X: XML and XMLList, as avmplus has them. An XML value stands for one
+// node of the tree (node.ts), and is the same object each time, so that XML
+// values compare by the node they are; an XMLList holds nodes, and the
+// object and name it was got from, which assignments to it write back to.
+// Names are looked up by PropertyHook in place of dynamic properties.
+//
+// Translated from avmplus' core/XMLObject.cpp, XMLListObject.cpp,
+// XMLClass.cpp, XMLListClass.cpp and E4X's parts of Toplevel.cpp and
+// AvmCore.cpp, this file is subject to the Mozilla Public License, v. 2.0:
+// http://mozilla.org/MPL/2.0/.
+import { CONSTANT_Qname, CONSTANT_QnameA, Namespace, NS_Public, namespace, prefixedNamespace, prefixOf, publicNs, } from "../../names.js";
+import { isSpace, isXMLName } from "./chars.js";
+import { escapeAttributeValue, escapeElementValue } from "./escape.js";
+import { ATTRIBUTE, CDATA, COMMENT, ELEMENT, matches, PROCESSING_INSTRUCTION, TEXT, XMLNode, } from "./node.js";
+import * as P from "./parser.js";
+// Error numbers, as avmplus' kXML* errors.
+const PREFIX_NOT_BOUND = 1083;
+const BAD_QNAME = 1084;
+const UNTERMINATED_ELEMENT_TAG = 1085;
+export const ONLY_ONE_ITEM_LISTS = 1086;
+const ASSIGNMENT_TO_INDEXED_XML = 1087;
+const MARKUP_MUST_BE_WELL_FORMED = 1088;
+const ASSIGNMENT_ONE_ITEM_LISTS = 1089;
+const NAMESPACE_WITH_PREFIX_AND_NO_URI = 1098;
+const DUPLICATE_ATTRIBUTE = 1104;
+const INVALID_NAME = 1117;
+const ILLEGAL_CYCLICAL_LOOP = 1118;
+/** What each of the parser's errors throws. */
+const PARSE_ERRORS = {
+    [P.MALFORMED_ELEMENT]: 1090,
+    [P.UNTERMINATED_CDATA]: 1091,
+    [P.UNTERMINATED_XML_DECLARATION]: 1092,
+    [P.UNTERMINATED_DOCTYPE]: 1093,
+    [P.UNTERMINATED_COMMENT]: 1094,
+    [P.UNTERMINATED_ATTRIBUTE_VALUE]: 1095,
+    [P.UNTERMINATED_PROCESSING_INSTRUCTION]: 1097,
+};
+const XML_1998 = "http://www.w3.org/XML/1998/namespace";
+/** Any name in any namespace: an XMLList's target property when it has none. */
+const ANY = { local: null, namespaces: null, attribute: false, qualified: false };
+const states = new WeakMap();
+export function e4x(rt) {
+    let state = states.get(rt);
+    if (!state) {
+        state = {
+            ignoreComments: true,
+            ignoreProcessingInstructions: true,
+            ignoreWhitespace: true,
+            prettyPrinting: true,
+            prettyIndent: 2,
+            xml: rt.builtinClass("XML").$it,
+            list: rt.builtinClass("XMLList").$it,
+            qname: rt.builtinClass("QName").$it,
+        };
+        states.set(rt, state);
+    }
+    return state;
+}
+const okToPrettyPrint = (e) => e.prettyPrinting && e.prettyIndent >= 0;
+// XML and XMLList values.
+export const isXML = (v) => typeof v === "object" && v !== null && v.$node !== undefined;
+const isList = (v) => typeof v === "object" && v !== null && v.$nodes !== undefined;
+/** The XML object that stands for `node`, the same each time. */
+export function xmlOf(rt, node) {
+    let o = node.object;
+    if (!o) {
+        o = e4x(rt).xml.instance();
+        o.$node = node;
+        node.object = o;
+    }
+    return o;
+}
+/** A new XMLList, got from `target` by `property`. */
+export function newList(rt, target = null, property = ANY) {
+    const o = e4x(rt).list.instance();
+    o.$nodes = [];
+    o.$target = target;
+    o.$targetProperty = property;
+    o.$appended = false;
+    return o;
+}
+/** As _appendNode. */
+function appendNode(list, node) {
+    list.$nodes.push(node);
+    list.$appended = true;
+}
+/** As XMLListObject::_append: an XMLList's nodes, and its target, or an XML value's node. */
+export function append(list, v) {
+    if (isList(v)) {
+        list.$target = v.$target;
+        list.$targetProperty = v.$targetProperty;
+        list.$appended = false;
+        list.$nodes.push(...v.$nodes);
+    }
+    else if (isXML(v)) {
+        list.$appended = true;
+        list.$nodes.push(v.$node);
+    }
+}
+/**
+ * As fixTargetObject: once nodes were appended, the list's target is the
+ * last one's parent, and its target property the last one's name.
+ */
+function fixTarget(rt, list) {
+    const nodes = list.$nodes;
+    if (!list.$appended || !nodes.length) {
+        return;
+    }
+    const v = nodes[nodes.length - 1];
+    if (v.parent) {
+        const target = list.$target;
+        if (isXML(target) && target.$node !== v.parent) {
+            list.$target = xmlOf(rt, v.parent);
+        }
+    }
+    else {
+        list.$target = null;
+    }
+    if (v.kind !== PROCESSING_INSTRUCTION) {
+        const name = v.xname();
+        if (name) {
+            list.$targetProperty = name;
+        }
+    }
+    list.$appended = false;
+}
+// Names.
+/** As String::parseIndex: a name's index, or -1. */
+function parseIndex(name) {
+    const c = name.charCodeAt(0);
+    if (!(c >= 0x30 && c <= 0x39)) {
+        return -1;
+    }
+    const i = Number(name);
+    return i >>> 0 === i && i !== 0xffffffff && String(i) === name ? i : -1;
+}
+/** An index name: not any name, nor an attribute's. */
+const indexOf = (n) => (n.attribute || n.local === null ? -1 : parseIndex(n.local));
+/** Whether `ns` is `other`, prefix, URI and kind, as CoerceE4XMultiname compares them. */
+const sameNamespace = (ns, other) => ns !== null && ns.uri === other.uri && ns.kind === other.kind && prefixOf(ns) === prefixOf(other);
+/**
+ * As CoerceE4XMultiname: an unqualified name in the default XML namespace
+ * too, and a name of "*" or starting with "@" as any name or an
+ * attribute's.
+ */
+export function coerce(rt, n) {
+    let namespaces = n.namespaces;
+    if (!n.qualified && namespaces !== null) {
+        const dxns = rt.defaultXmlNamespace;
+        if (!namespaces.some((ns) => sameNamespace(ns, dxns))) {
+            namespaces = [...namespaces, dxns];
+        }
+    }
+    let local = n.local;
+    let attribute = n.attribute;
+    if (local === "*") {
+        local = null;
+    }
+    else if (local !== null && local.charCodeAt(0) === 0x40 && !attribute) {
+        local = local === "@*" ? null : local.slice(1);
+        attribute = true;
+    }
+    if (namespaces === n.namespaces && local === n.local && attribute === n.attribute) {
+        return n;
+    }
+    return { local, namespaces, attribute, qualified: n.qualified };
+}
+/** A property's multiname as E4X names: a Qname is qualified, its namespace null for any. */
+function fromMultiname(mn) {
+    const qualified = mn.kind === CONSTANT_Qname || mn.kind === CONSTANT_QnameA;
+    const all = mn.namespaces;
+    let namespaces;
+    if (qualified) {
+        namespaces = all[0] ? [all[0]] : null;
+    }
+    else {
+        namespaces = all.some((ns) => ns === null) ? null : all;
+    }
+    return { local: mn.name, namespaces, attribute: mn.attribute, qualified };
+}
+/**
+ * As ToXMLName: a name for a method's argument, as XML's child() takes
+ * one. A QName is its local name, in a namespace of its URI; anything else
+ * is its string, in the public namespace: "@name" an attribute's, "*" any.
+ */
+export function toXMLName(rt, p) {
+    if (p === null || p === undefined) {
+        throw rt.error("TypeError", 1010);
+    }
+    let s;
+    if (p instanceof Namespace) {
+        s = p.uri ?? "";
+    }
+    else if (p.$local !== undefined) {
+        // avmplus makes the namespace of the URI's string: "null" for any.
+        return {
+            local: p.$local,
+            namespaces: [namespace(NS_Public, p.$ns ? p.$ns.uri : "null")],
+            attribute: p.$attr === true,
+            qualified: false,
+        };
+    }
+    else {
+        s = rt.toString(p);
+    }
+    let local = s;
+    let attribute = false;
+    if (s.charCodeAt(0) === 0x40) {
+        local = s.slice(1);
+        attribute = true;
+    }
+    if (local === "*") {
+        local = null;
+    }
+    return { local, namespaces: [publicNs], attribute, qualified: false };
+}
+/** As ToAttributeName and then ToXMLName: an attribute's name for XML's attribute(). */
+export function toAttributeName(rt, v) {
+    if (v === null || v === undefined || typeof v === "number" || typeof v === "boolean") {
+        throw rt.error("TypeError", 1010);
+    }
+    if (typeof v === "object" && !(v instanceof Namespace) && v.$local !== undefined) {
+        return { ...toXMLName(rt, v), attribute: true };
+    }
+    const s = v instanceof Namespace ? (v.uri ?? "") : rt.toString(v);
+    const uri = s === "*" ? "null" : rt.defaultXmlNamespace.uri;
+    return {
+        local: s === "*" ? null : s,
+        namespaces: [namespace(NS_Public, uri)],
+        attribute: true,
+        qualified: false,
+    };
+}
+/** Whether `n` names child `child`: only an element has a name to match. */
+const matchesChild = (n, child) => matches(n, child.kind === ELEMENT ? child : null);
+// Namespaces and QNames.
+/** As AvmCore::newNamespace(uri): a Namespace's own, a QName's URI's, or of a string. */
+export function newNamespace(rt, uri) {
+    if (uri instanceof Namespace) {
+        return uri;
+    }
+    if (typeof uri === "object" && uri !== null && uri.$local !== undefined && uri.$ns) {
+        return namespace(NS_Public, uri.$ns.uri);
+    }
+    return namespace(NS_Public, rt.toString(uri));
+}
+/**
+ * As AvmCore::newNamespace(prefix, uri): a namespace with a prefix, none
+ * if it is not an XML name, or null for a prefix of the empty URI.
+ */
+function newPrefixedNamespace(rt, prefix, uri) {
+    const u = typeof uri === "object" && uri !== null && uri.$local !== undefined && uri.$ns
+        ? uri.$ns.uri
+        : rt.toString(uri);
+    if (u === "") {
+        return prefix === undefined || rt.toString(prefix) === "" ? publicNs : null;
+    }
+    if (prefix === undefined) {
+        return namespace(NS_Public, u);
+    }
+    const p = rt.toString(prefix);
+    if (p !== "" && !isXMLName(p)) {
+        return namespace(NS_Public, u);
+    }
+    return prefixedNamespace(p, u);
+}
+/** As NamespaceClass::construct: Namespace(), Namespace(uri) or Namespace(prefix, uri). */
+export function constructNamespace(rt, args) {
+    if (args.length === 0) {
+        return publicNs;
+    }
+    if (args.length === 1) {
+        return newNamespace(rt, args[0]);
+    }
+    const p = rt.toString(args[0]);
+    if (p.length && !rt.toString(args[1]).length) {
+        throw rt.error("TypeError", NAMESPACE_WITH_PREFIX_AND_NO_URI, p);
+    }
+    return newPrefixedNamespace(rt, args[0], args[1]) ?? publicNs;
+}
+/** A QName object of a node's name, as XML's name() gives it. */
+export function qnameOf(rt, node) {
+    const q = e4x(rt).qname.instance();
+    q.$ns = node.ns;
+    q.$local = node.name;
+    q.$attr = node.kind === ATTRIBUTE;
+    return q;
+}
+/**
+ * As QNameObject(name), with no namespace: a QName's name, else any name
+ * in any namespace for "*", or the name in the default XML namespace.
+ */
+function qnameName(rt, name) {
+    if (typeof name === "object" && name !== null && name.$local !== undefined) {
+        return {
+            local: name.$local,
+            namespaces: name.$ns ? [name.$ns] : null,
+            attribute: name.$attr === true,
+            qualified: name.$ns !== null,
+        };
+    }
+    const s = name === undefined ? "" : rt.toString(name);
+    if (s === "*") {
+        return ANY;
+    }
+    return { local: s, namespaces: [rt.defaultXmlNamespace], attribute: false, qualified: true };
+}
+/** As GetNamespace: the namespace of `ns`'s URI among `list`, else one of its URI. */
+function getNamespace(ns, list) {
+    for (const ns2 of list) {
+        if (ns2.uri === ns.uri) {
+            return ns2;
+        }
+    }
+    return namespace(NS_Public, ns.uri);
+}
+const hasPrefix = (ns) => {
+    const p = prefixOf(ns);
+    return p !== undefined && p !== "";
+};
+// Parsing.
+/**
+ * As the XMLObject constructor: `text` parsed, as the children of an
+ * element for `defaultNs`, as E4X parses <parent xmlns=uri>text</parent>.
+ */
+function parse(rt, text, defaultNs) {
+    const e = e4x(rt);
+    const parser = new P.XMLParser(text);
+    parser.parse(e.ignoreWhitespace);
+    parser.setCondenseWhite(true);
+    const root = new XMLNode(ELEMENT);
+    const ns = prefixedNamespace("", defaultNs.uri ?? "");
+    root.addInScopeNamespace(ns);
+    root.setName("parent", ns);
+    let p = root;
+    const tag = new P.XMLTag();
+    for (;;) {
+        const status = parser.getNext(tag);
+        if (status === P.END) {
+            break;
+        }
+        if (status !== P.OK) {
+            throw rt.error("TypeError", PARSE_ERRORS[status]);
+        }
+        let node = null;
+        switch (tag.type) {
+            case P.TAG_ELEMENT:
+                if (tag.text.charCodeAt(0) === 0x2f) {
+                    // A closing tag: its element's, else not well formed.
+                    const parentName = p.name;
+                    const pns = p.ns;
+                    const name = tag.text.slice(1);
+                    if (!nodeNameEquals(name, parentName, pns) &&
+                        !(parentName === name && pns.uri === rt.defaultXmlNamespace.uri)) {
+                        if (p === root) {
+                            throw rt.error("TypeError", MARKUP_MUST_BE_WELL_FORMED);
+                        }
+                        throw rt.error("TypeError", UNTERMINATED_ELEMENT_TAG, parentName, parentName);
+                    }
+                    if (p === root) {
+                        throw rt.error("TypeError", MARKUP_MUST_BE_WELL_FORMED);
+                    }
+                    p = p.parent;
+                }
+                else {
+                    const element = new XMLNode(ELEMENT);
+                    p.append(element);
+                    if (!tag.empty) {
+                        p = element;
+                    }
+                    copyAttributesAndNamespaces(rt, element, tag);
+                    const [ns, local] = findNamespace(rt, element, tag.text, false);
+                    element.setName(local, ns ?? publicNs);
+                }
+                break;
+            case P.TAG_COMMENT:
+                if (!e.ignoreComments) {
+                    node = new XMLNode(COMMENT, tag.text);
+                }
+                break;
+            case P.TAG_CDATA:
+                node = new XMLNode(CDATA, tag.text);
+                break;
+            case P.TAG_TEXT:
+                node = new XMLNode(TEXT, tag.text);
+                break;
+            case P.TAG_PROCESSING_INSTRUCTION:
+                if (!e.ignoreProcessingInstructions) {
+                    const s = tag.text;
+                    let space = s.indexOf(" ");
+                    let name = s;
+                    let value = "";
+                    if (space >= 0) {
+                        name = s.slice(0, space);
+                        while (isSpace(s.charCodeAt(++space))) { }
+                        value = s.slice(space);
+                    }
+                    node = new XMLNode(PROCESSING_INSTRUCTION, value);
+                    node.setName(name, publicNs);
+                }
+                break;
+        }
+        if (node) {
+            p.append(node);
+        }
+    }
+    if (p !== root) {
+        throw rt.error("TypeError", UNTERMINATED_ELEMENT_TAG, p.name, p.name);
+    }
+    return root;
+}
+/** As NodeNameEquals: whether a closing tag's name is its element's, with the prefix it has. */
+function nodeNameEquals(name, parentName, ns) {
+    if (hasPrefix(ns)) {
+        return name === `${prefixOf(ns)}:${parentName}`;
+    }
+    return name === parentName;
+}
+/**
+ * As FindNamespace: a tag's name's namespace, by its prefix among those in
+ * scope, and its local name. An attribute without a prefix has none.
+ */
+function findNamespace(rt, node, tagName, attribute) {
+    const pos = tagName.indexOf(":");
+    if (pos === 0) {
+        throw rt.error("TypeError", BAD_QNAME, tagName);
+    }
+    let prefix = "";
+    let local = tagName;
+    if (pos > 0) {
+        prefix = tagName.slice(0, pos);
+        local = tagName.slice(pos + 1);
+    }
+    if (attribute && prefix === "") {
+        return [null, local];
+    }
+    for (let y = node; y; y = y.parent) {
+        for (const ns of y.namespaces) {
+            if ((prefix === "" && !hasPrefix(ns)) || prefixOf(ns) === prefix) {
+                return [ns, local];
+            }
+        }
+    }
+    if (prefix === "xml") {
+        return [prefixedNamespace("", XML_1998), local];
+    }
+    if (prefix !== "") {
+        throw rt.error("TypeError", PREFIX_NOT_BOUND, prefix, local);
+    }
+    return [null, local];
+}
+/** Whether an attribute's name is xmlns, or starts with xmlns: (either case). */
+function isXmlns(name) {
+    return (name.length >= 5 &&
+        name.slice(0, 5).toLowerCase() === "xmlns" &&
+        (name.length === 5 || name[5] === ":"));
+}
+/**
+ * As CopyAttributesAndNamespaces: a tag's namespace declarations first,
+ * as an attribute can be in a namespace declared after it, then its
+ * attributes; a second of one name is TypeError 1104.
+ */
+function copyAttributesAndNamespaces(rt, element, tag) {
+    const attributes = tag.attributes;
+    let count = 0;
+    for (let i = 0; i < attributes.length; i += 2) {
+        const name = attributes[i];
+        let ns = null;
+        if (isXmlns(name)) {
+            if (name.length > 5) {
+                if (name.length === 6) {
+                    throw rt.error("TypeError", BAD_QNAME, name);
+                }
+                ns = newPrefixedNamespace(rt, name.slice(6), attributes[i + 1]);
+            }
+            else {
+                ns = newPrefixedNamespace(rt, "", attributes[i + 1]);
+            }
+            if (ns) {
+                element.addInScopeNamespace(ns);
+            }
+        }
+        if (!ns) {
+            count++;
+        }
+    }
+    if (!count) {
+        return;
+    }
+    for (let i = 0; i < attributes.length; i += 2) {
+        if (isXmlns(attributes[i])) {
+            continue;
+        }
+        const attribute = new XMLNode(ATTRIBUTE, attributes[i + 1]);
+        attribute.parent = element;
+        const [ns, local] = findNamespace(rt, element, attributes[i], true);
+        attribute.setName(local, ns ?? publicNs);
+        for (const other of element.attributes) {
+            if (matches(other.xname(), attribute)) {
+                throw rt.error("TypeError", DUPLICATE_ATTRIBUTE, local, tag.text, tag.text.length);
+            }
+        }
+        element.attributes.push(attribute);
+    }
+}
+// Conversions.
+/** As ToXML: XML itself, a one-item XMLList's, or text parsed as one node. */
+export function toXML(rt, v) {
+    if (v === null || v === undefined) {
+        throw rt.error("TypeError", v === undefined ? 1010 : 1009);
+    }
+    if (isXML(v)) {
+        return v;
+    }
+    if (isList(v)) {
+        if (v.$nodes.length === 1) {
+            return xmlOf(rt, v.$nodes[0]);
+        }
+        throw rt.error("TypeError", MARKUP_MUST_BE_WELL_FORMED);
+    }
+    const root = parse(rt, rt.toString(v), rt.defaultXmlNamespace);
+    const children = root.children;
+    let node;
+    if (!children.length) {
+        node = new XMLNode(TEXT, "");
+    }
+    else if (children.length === 1) {
+        node = children[0];
+    }
+    else {
+        // One element, with comments, processing instructions and whitespace around it.
+        let element = null;
+        for (const n of children) {
+            if (n.kind === ELEMENT) {
+                if (element) {
+                    throw rt.error("TypeError", MARKUP_MUST_BE_WELL_FORMED);
+                }
+                element = n;
+            }
+            else if (n.kind === TEXT && !isWhitespace(n.value)) {
+                throw rt.error("TypeError", MARKUP_MUST_BE_WELL_FORMED);
+            }
+        }
+        if (!element) {
+            throw rt.error("TypeError", MARKUP_MUST_BE_WELL_FORMED);
+        }
+        node = element;
+    }
+    node.parent = null;
+    return xmlOf(rt, node);
+}
+/** As ToXMLList: an XMLList itself, XML as a list of it, or text parsed as nodes. */
+export function toXMLList(rt, v) {
+    if (v === null || v === undefined) {
+        throw rt.error("TypeError", v === undefined ? 1010 : 1009);
+    }
+    if (isList(v)) {
+        return v;
+    }
+    if (isXML(v)) {
+        const node = v.$node;
+        const list = newList(rt, node.parent ? xmlOf(rt, node.parent) : null, node.xname() ?? ANY);
+        append(list, v);
+        return list;
+    }
+    let s = rt.toString(v);
+    if (s.startsWith("<>") && s.endsWith("</>")) {
+        s = s.slice(2, s.length - 3);
+    }
+    const dxns = rt.defaultXmlNamespace;
+    const root = parse(rt, s, dxns);
+    const list = newList(rt);
+    for (const c of root.children) {
+        c.parent = null;
+        c.addInScopeNamespace(dxns);
+        appendNode(list, c);
+    }
+    return list;
+}
+function isWhitespace(s) {
+    for (let i = 0; i < s.length; i++) {
+        if (!isSpace(s.charCodeAt(i))) {
+            return false;
+        }
+    }
+    return true;
+}
+export function deepCopy(rt, node) {
+    const e = e4x(rt);
+    return node.deepCopy(e.ignoreComments, e.ignoreProcessingInstructions);
+}
+export function listDeepCopy(rt, list) {
+    fixTarget(rt, list);
+    const copy = newList(rt, list.$target, list.$targetProperty);
+    for (const node of list.$nodes) {
+        copy.$nodes.push(deepCopy(rt, node));
+    }
+    return copy;
+}
+// Notifications, as setNotification sets a function to call on changes.
+function notifyNeeded(node) {
+    for (let n = node; n; n = n.parent) {
+        if (n.notification) {
+            return true;
+        }
+    }
+    return false;
+}
+function issueNotifications(rt, initial, target, type, value, detail) {
+    for (let n = initial; n; n = n.parent) {
+        if (n.notification) {
+            rt.callValue(n.notification, null, [xmlOf(rt, n), type, target, value, detail], null);
+        }
+    }
+}
+export function childChanges(rt, node, type, value, prior = null) {
+    if (notifyNeeded(node) && (isXML(value) || isList(value))) {
+        const detail = prior ? xmlOf(rt, prior) : undefined;
+        issueNotifications(rt, node, xmlOf(rt, node), type, value, detail);
+    }
+}
+function nonChildChanges(rt, node, type, value, detail = undefined) {
+    if (notifyNeeded(node)) {
+        issueNotifications(rt, node, xmlOf(rt, node), type, value, detail);
+    }
+}
+// The tree changed by values, as ElementE4XNode's _insert and _replace.
+function checkCycle(rt, x, node) {
+    for (let n = x; n; n = n.parent) {
+        if (n === node) {
+            throw rt.error("TypeError", ILLEGAL_CYCLICAL_LOOP);
+        }
+    }
+}
+/** As _insert: `value` (an XMLList's nodes, else a node as _replace makes it) at `entry`. */
+export function insertAt(rt, x, entry, value) {
+    if (x.kind !== ELEMENT) {
+        return;
+    }
+    if (isList(value)) {
+        const nodes = value.$nodes;
+        for (let j = 0; j < nodes.length; j++) {
+            const child = nodes[j];
+            checkCycle(rt, x, child);
+            child.parent = x;
+            x.children.splice(entry + j, 0, child);
+        }
+        return;
+    }
+    if (isXML(value)) {
+        checkCycle(rt, x, value.$node);
+    }
+    x.children.splice(entry, 0, null);
+    replaceAt(rt, x, entry, value);
+}
+/**
+ * As _replace: child `i` (or a new last one) replaced by `v`: an XML
+ * node itself, an XMLList's nodes, or a text node of anything else's
+ * string. Gives the child it replaced.
+ */
+function replaceAt(rt, x, index, v, pastValue = undefined) {
+    if (x.kind !== ELEMENT) {
+        return null;
+    }
+    let i = index;
+    if (i >= x.children.length) {
+        i = x.children.length;
+        x.children.push(null);
+    }
+    const prior = x.children[i];
+    if (isXML(v) && v.$node.kind & (ELEMENT | COMMENT | PROCESSING_INSTRUCTION | TEXT | CDATA)) {
+        const node = v.$node;
+        if (node.kind === ELEMENT) {
+            checkCycle(rt, x, node);
+        }
+        node.parent = x;
+        if (prior) {
+            prior.parent = null;
+        }
+        x.children[i] = node;
+    }
+    else if (isList(v)) {
+        x.deleteByIndex(i);
+        insertAt(rt, x, i, v);
+    }
+    else {
+        const text = new XMLNode(TEXT, rt.toString(v));
+        text.parent = x;
+        if (prior) {
+            prior.parent = null;
+        }
+        x.children[i] = text;
+        if (notifyNeeded(text)) {
+            const detail = prior && prior.kind !== ELEMENT ? prior.value : pastValue;
+            nonChildChanges(rt, text, "textSet", text.value, detail);
+        }
+    }
+    return prior;
+}
+// XML's internal methods, E4X 9.1.1, on a node, with a name not yet coerced.
+/** [[Get]]: the attributes or children the name names, or the node itself as index 0. */
+export function getXML(rt, o, name) {
+    const n = coerce(rt, name);
+    const index = indexOf(n);
+    if (index >= 0) {
+        return index === 0 ? o : undefined;
+    }
+    const node = o.$node;
+    const list = newList(rt, o, n);
+    if (n.attribute) {
+        for (const a of node.attributes) {
+            if (matches(n, a)) {
+                appendNode(list, a);
+            }
+        }
+    }
+    else {
+        for (const child of node.children) {
+            if (matchesChild(n, child)) {
+                appendNode(list, child);
+            }
+        }
+    }
+    return list;
+}
+/** [[Put]]. */
+export function setXML(rt, o, name, value) {
+    const n = coerce(rt, name);
+    if (indexOf(n) >= 0) {
+        throw rt.error("TypeError", ASSIGNMENT_TO_INDEXED_XML);
+    }
+    const node = o.$node;
+    if (node.kind & (TEXT | CDATA | COMMENT | PROCESSING_INSTRUCTION | ATTRIBUTE)) {
+        return;
+    }
+    let c;
+    if (isList(value)) {
+        const nodes = value.$nodes;
+        c =
+            nodes.length === 1 && nodes[0].kind & (TEXT | ATTRIBUTE)
+                ? rt.toString(value)
+                : listDeepCopy(rt, value);
+    }
+    else if (isXML(value)) {
+        c =
+            value.$node.kind & (TEXT | ATTRIBUTE)
+                ? rt.toString(value)
+                : xmlOf(rt, deepCopy(rt, value.$node));
+    }
+    else {
+        c = rt.toString(value);
+    }
+    if (n.attribute) {
+        let sc;
+        if (isList(c)) {
+            sc = c.$nodes.map((x) => rt.toString(xmlOf(rt, x))).join(" ");
+        }
+        else {
+            sc = rt.toString(c);
+        }
+        let a = -1;
+        for (let j = 0; j < node.attributes.length; j++) {
+            const x = node.attributes[j];
+            if (matches(n, x)) {
+                if (a === -1) {
+                    a = j;
+                }
+                else {
+                    deleteXML(rt, o, x.xname());
+                }
+            }
+        }
+        if (a === -1) {
+            const e = new XMLNode(ATTRIBUTE, sc);
+            e.parent = node;
+            e.setName(n.local, n.namespaces?.length === 1 ? n.namespaces[0] : null);
+            node.attributes.push(e);
+            nonChildChanges(rt, node, "attributeAdded", n.local, sc);
+        }
+        else {
+            const x = node.attributes[a];
+            const prior = x.value;
+            x.value = sc;
+            nonChildChanges(rt, node, "attributeChanged", n.local, prior);
+        }
+        return;
+    }
+    if (n.local !== null && !isXMLName(n.local)) {
+        return;
+    }
+    let i = -1;
+    const primitiveAssign = !isXML(c) && !isList(c) && n.local !== null;
+    const notify = notifyNeeded(node);
+    for (let k = node.children.length - 1; k >= 0; k--) {
+        if (matchesChild(n, node.children[k])) {
+            // All but the first of those it names are removed.
+            if (i !== -1) {
+                const was = node.children[i];
+                node.deleteByIndex(i);
+                if (notify && was.kind === ELEMENT) {
+                    childChanges(rt, node, "nodeRemoved", xmlOf(rt, was));
+                }
+            }
+            i = k;
+        }
+    }
+    if (i === -1) {
+        i = node.children.length;
+        if (primitiveAssign) {
+            const e = new XMLNode(ELEMENT);
+            e.parent = node;
+            const ns = n.namespaces === null
+                ? null
+                : n.namespaces.length === 1
+                    ? n.namespaces[0]
+                    : rt.defaultXmlNamespace;
+            e.setName(n.local, ns);
+            replaceAt(rt, node, i, xmlOf(rt, e));
+            e.addInScopeNamespace(ns);
+        }
+    }
+    if (primitiveAssign) {
+        const xi = node.children[i];
+        let prior;
+        if (notifyNeeded(xi)) {
+            for (const child of xi.children) {
+                if (child.kind === ELEMENT) {
+                    childChanges(rt, xi, "nodeRemoved", xmlOf(rt, child));
+                }
+            }
+            if (xi.children.length) {
+                prior = xmlOf(rt, xi.children[0]);
+            }
+        }
+        xi.children.length = 0;
+        const s = rt.toString(c);
+        if (s.length) {
+            replaceAt(rt, xi, 0, c, prior);
+        }
+    }
+    else {
+        const prior = replaceAt(rt, node, i, c);
+        if (notifyNeeded(node) && node.children.length > i) {
+            childChanges(rt, node, prior ? "nodeChanged" : "nodeAdded", xmlOf(rt, node.children[i]), prior);
+        }
+    }
+}
+/** [[Delete]]. */
+function deleteXML(rt, o, name) {
+    const n = coerce(rt, name);
+    if (indexOf(n) >= 0) {
+        return true;
+    }
+    const node = o.$node;
+    if (n.attribute) {
+        let j = 0;
+        while (j < node.attributes.length) {
+            const x = node.attributes[j];
+            if (matches(n, x)) {
+                x.parent = null;
+                node.attributes.splice(j, 1);
+                nonChildChanges(rt, node, "attributeRemoved", x.name ?? undefined, x.value);
+            }
+            else {
+                j++;
+            }
+        }
+        return true;
+    }
+    const notify = notifyNeeded(node);
+    let q = 0;
+    while (q < node.children.length) {
+        const x = node.children[q];
+        if (matchesChild(n, x)) {
+            x.parent = null;
+            node.deleteByIndex(q);
+            if (notify && x.kind === ELEMENT) {
+                childChanges(rt, node, "nodeRemoved", xmlOf(rt, x));
+            }
+        }
+        else {
+            q++;
+        }
+    }
+    return true;
+}
+/** [[HasProperty]]. */
+export function hasXML(rt, o, name) {
+    const n = coerce(rt, name);
+    const index = indexOf(n);
+    if (index >= 0) {
+        return index === 0;
+    }
+    const node = o.$node;
+    if (n.attribute) {
+        return node.attributes.some((a) => matches(n, a));
+    }
+    return node.children.some((c) => matchesChild(n, c));
+}
+/** [[Descendants]]: the attributes or elements the name names, in each child, depth first. */
+export function descendantsOf(rt, node, name) {
+    const n = coerce(rt, name);
+    const list = newList(rt);
+    if (n.attribute) {
+        for (const a of node.attributes) {
+            if (matches(n, a)) {
+                appendNode(list, a);
+            }
+        }
+    }
+    for (const child of node.children) {
+        if (!n.attribute && matchesChild(n, child)) {
+            appendNode(list, child);
+        }
+        const dq = descendantsOf(rt, child, n);
+        if (dq.$nodes.length) {
+            append(list, dq);
+        }
+    }
+    return list;
+}
+// XMLList's internal methods, E4X 9.2.1.
+export function getList(rt, o, n) {
+    const nodes = o.$nodes;
+    const index = indexOf(n);
+    if (index >= 0) {
+        return index < nodes.length ? xmlOf(rt, nodes[index]) : undefined;
+    }
+    const list = newList(rt, o, n);
+    for (const node of nodes) {
+        if (node.kind === ELEMENT) {
+            const gq = getXML(rt, xmlOf(rt, node), n);
+            if (gq.$nodes.length) {
+                append(list, gq);
+            }
+        }
+    }
+    return list;
+}
+function setList(rt, o, n, value) {
+    const index = indexOf(n);
+    if (index >= 0) {
+        setIndex(rt, o, index, value);
+        return;
+    }
+    const nodes = o.$nodes;
+    if (nodes.length > 1) {
+        throw rt.error("TypeError", ASSIGNMENT_ONE_ITEM_LISTS);
+    }
+    if (nodes.length === 0) {
+        const r = resolveValue(rt, o);
+        if (r === null) {
+            return;
+        }
+        // As avmplus: an XML value's own length is its children's.
+        if (isXML(r) && r.$node.children.length !== 1) {
+            return;
+        }
+        if (isList(r) && r.$nodes.length !== 1) {
+            return;
+        }
+        append(o, r);
+    }
+    setXML(rt, xmlOf(rt, nodes[0]), n, value);
+}
+function deleteList(rt, o, n) {
+    const index = indexOf(n);
+    if (index >= 0) {
+        return deleteIndex(rt, o, index);
+    }
+    for (const node of o.$nodes) {
+        if (node.kind === ELEMENT) {
+            deleteXML(rt, xmlOf(rt, node), n);
+        }
+    }
+    return true;
+}
+export function hasList(rt, o, n) {
+    const nodes = o.$nodes;
+    const index = indexOf(n);
+    if (index >= 0) {
+        return index < nodes.length;
+    }
+    return nodes.some((node) => node.kind === ELEMENT && hasXML(rt, xmlOf(rt, node), n));
+}
+export function descendantsOfList(rt, o, n) {
+    const list = newList(rt);
+    for (const node of o.$nodes) {
+        if (node.kind === ELEMENT) {
+            const dq = descendantsOf(rt, node, n);
+            if (dq.$nodes.length) {
+                append(list, dq);
+            }
+        }
+    }
+    return list;
+}
+/**
+ * As _resolveValue: a list with nodes; an empty one, the property of its
+ * target it was got from, which is made, empty, if there is none, so that
+ * assigning to x.a.b makes <a>.
+ */
+function resolveValue(rt, v) {
+    if (isXML(v)) {
+        return v;
+    }
+    if (v.$nodes.length > 0) {
+        return v;
+    }
+    fixTarget(rt, v);
+    const property = v.$targetProperty;
+    if (v.$target === null || property.attribute || property.local === null) {
+        return null;
+    }
+    const base = resolveValue(rt, v.$target);
+    if (base === null) {
+        return null;
+    }
+    const get = (b) => isXML(b) ? getXML(rt, b, property) : getList(rt, b, coerce(rt, property));
+    const target = get(base);
+    if (!isList(target)) {
+        return null;
+    }
+    if (!target.$nodes.length) {
+        if (isList(base) && base.$nodes.length > 1) {
+            throw rt.error("TypeError", ASSIGNMENT_ONE_ITEM_LISTS);
+        }
+        if (isXML(base)) {
+            setXML(rt, base, property, "");
+        }
+        else {
+            setList(rt, base, coerce(rt, property), "");
+        }
+        return get(base);
+    }
+    return target;
+}
+/** As XMLListObject::setUintProperty: item i, or a new last one, set to `value`. */
+function setIndex(rt, o, index, value) {
+    const nodes = o.$nodes;
+    let i = index;
+    let v = value;
+    let r = null;
+    fixTarget(rt, o);
+    if (o.$target !== null) {
+        r = resolveValue(rt, o.$target);
+        if (r === null) {
+            return;
+        }
+    }
+    if (i >= nodes.length) {
+        if (isList(r)) {
+            if (r.$nodes.length !== 1) {
+                return;
+            }
+            r = xmlOf(rt, r.$nodes[0]);
+        }
+        const rx = isXML(r) ? r.$node : null;
+        if (rx && rx.kind !== ELEMENT) {
+            return;
+        }
+        const property = o.$targetProperty;
+        let y;
+        if (property.attribute) {
+            if (!rx) {
+                return;
+            }
+            const exists = getXML(rt, r, property);
+            if (isList(exists) && exists.$nodes.length > 0) {
+                return;
+            }
+            y = new XMLNode(ATTRIBUTE);
+            y.parent = rx;
+            y.setName(property.local, property.namespaces?.[0] ?? null);
+            nonChildChanges(rt, rx, "attributeAdded", property.local);
+        }
+        else if (property.local === null ||
+            (isXML(v) && (v.$node.kind === ATTRIBUTE || v.$node.kind === TEXT))) {
+            y = new XMLNode(TEXT);
+            y.parent = rx;
+        }
+        else {
+            y = new XMLNode(ELEMENT);
+            y.parent = rx;
+            y.setName(property.local, property.namespaces?.[0] ?? null);
+        }
+        i = nodes.length;
+        if (y.kind !== ATTRIBUTE) {
+            const parent = y.parent;
+            if (parent) {
+                // After the list's last node among the parent's children, else last.
+                let j;
+                if (i > 0) {
+                    j = 0;
+                    while (j < parent.children.length - 1 && parent.children[j] !== nodes[i - 1]) {
+                        j++;
+                    }
+                    j++;
+                }
+                else {
+                    j = parent.children.length;
+                }
+                parent.children.splice(j, 0, y);
+            }
+            if (isXML(v)) {
+                const node = v.$node;
+                if (node.name !== null) {
+                    y.setName(node.name, node.ns);
+                }
+            }
+            else if (isList(v)) {
+                const p = v.$targetProperty;
+                if (p.local !== null) {
+                    y.setName(p.local, p.namespaces?.[0] ?? null);
+                }
+            }
+        }
+        appendNode(o, y);
+    }
+    if (isList(v)) {
+        const src = v.$nodes;
+        if (src.length === 1 && src[0].kind & (TEXT | ATTRIBUTE)) {
+            v = rt.toString(v);
+        }
+    }
+    else if (isXML(v)) {
+        if (v.$node.kind & (TEXT | ATTRIBUTE)) {
+            v = rt.toString(v);
+        }
+    }
+    else {
+        v = rt.toString(v);
+    }
+    const xi = nodes[i];
+    if (xi.kind === ATTRIBUTE) {
+        if (!xi.parent) {
+            return;
+        }
+        const parent = xmlOf(rt, xi.parent);
+        const name = xi.xname();
+        setXML(rt, parent, name, v);
+        const attr = getXML(rt, parent, name);
+        nodes[i] = attr.$nodes[0];
+    }
+    else if (isList(v)) {
+        const c = newList(rt);
+        c.$nodes.push(...v.$nodes);
+        const parent = xi.parent;
+        if (parent) {
+            const q = parent.children.indexOf(xi);
+            if (q >= 0) {
+                replaceAt(rt, parent, q, c);
+                for (let j = 0; j < c.$nodes.length; j++) {
+                    c.$nodes[j] = parent.children[q + j];
+                }
+            }
+        }
+        const notify = parent !== null && notifyNeeded(parent);
+        const prior = xi;
+        nodes.splice(i, 1, ...c.$nodes);
+        if (notify && parent) {
+            for (let i2 = 0; i2 < c.$nodes.length; i2++) {
+                const node = c.$nodes[i2];
+                if (parent === node.parent) {
+                    if (i2 === 0) {
+                        if (node !== prior) {
+                            childChanges(rt, parent, "nodeChanged", xmlOf(rt, node), prior);
+                        }
+                    }
+                    else {
+                        childChanges(rt, parent, "nodeAdded", xmlOf(rt, node));
+                    }
+                }
+            }
+        }
+    }
+    else if (isXML(v) || xi.kind & (TEXT | CDATA | COMMENT | PROCESSING_INSTRUCTION)) {
+        const parent = xi.parent;
+        if (parent) {
+            const q = parent.children.indexOf(xi);
+            if (q >= 0) {
+                replaceAt(rt, parent, q, v);
+                v = xmlOf(rt, parent.children[q]);
+                if (notifyNeeded(parent)) {
+                    childChanges(rt, parent, "nodeAdded", v);
+                }
+            }
+        }
+        nodes[i] = (isXML(v) ? v : toXML(rt, v)).$node;
+    }
+    else {
+        setXML(rt, xmlOf(rt, xi), toXMLName(rt, "*"), v);
+    }
+}
+/** As XMLListObject::delUintProperty: item `index` out of the list, and out of its parent. */
+export function deleteIndex(rt, o, index) {
+    const nodes = o.$nodes;
+    if (index >= nodes.length) {
+        return true;
+    }
+    const xi = nodes[index];
+    const px = xi.parent;
+    if (px) {
+        if (xi.kind === ATTRIBUTE) {
+            deleteXML(rt, xmlOf(rt, px), xi.xname());
+        }
+        else {
+            const q = xi.childIndex();
+            const x = px.children[q];
+            px.deleteByIndex(q);
+            if (x && notifyNeeded(px) && x.kind === ELEMENT) {
+                childChanges(rt, px, "nodeRemoved", xmlOf(rt, x));
+            }
+        }
+    }
+    if (index < nodes.length) {
+        nodes.splice(index, 1);
+    }
+    return true;
+}
+// Strings.
+/** As GenerateUniquePrefix: "" if no namespace has it, else the first of aaa to zzz none has. */
+function uniquePrefix(ns, namespaces) {
+    if (!namespaces.some((n) => prefixOf(n) === "")) {
+        return prefixedNamespace("", ns.uri ?? "");
+    }
+    const a = 0x61;
+    for (let x1 = 0; x1 < 26; x1++) {
+        for (let x2 = 0; x2 < 26; x2++) {
+            for (let x3 = 0; x3 < 26; x3++) {
+                const p = String.fromCharCode(a + x1, a + x2, a + x3);
+                if (!namespaces.some((n) => prefixOf(n) === p)) {
+                    return prefixedNamespace(p, ns.uri ?? "");
+                }
+            }
+        }
+    }
+    return ns;
+}
+/** As XMLObject::__toXMLString, E4X 10.2.1: `node` as XML text, into `out`. */
+function toXMLStringOf(rt, node, ancestors, indentLevel, out) {
+    const e = e4x(rt);
+    const pretty = okToPrettyPrint(e);
+    if (pretty && indentLevel > 0) {
+        out.push(" ".repeat(indentLevel));
+    }
+    switch (node.kind) {
+        case TEXT:
+            out.push(escapeElementValue(node.value, pretty));
+            return;
+        case CDATA:
+            out.push(`<![CDATA[${node.value}]]>`);
+            return;
+        case ATTRIBUTE:
+            out.push(escapeAttributeValue(node.value));
+            return;
+        case COMMENT:
+            out.push(`<!--${node.value}-->`);
+            return;
+        case PROCESSING_INSTRUCTION:
+            out.push(`<?${node.name} ${node.value}?>`);
+            return;
+    }
+    // The namespaces in scope not already among the ancestors'.
+    const origLength = ancestors.length;
+    for (const ns of node.inScopeNamespaces()) {
+        if (!ancestors.some((ns2) => ns.uri === ns2.uri && prefixOf(ns) === prefixOf(ns2))) {
+            ancestors.push(ns);
+        }
+    }
+    // This node's namespace, and its attributes', each with a prefix.
+    let own = getNamespace(node.ns, ancestors);
+    if (prefixOf(own) === undefined) {
+        own = uniquePrefix(own, ancestors);
+        ancestors.push(own);
+    }
+    for (const a of node.attributes) {
+        if (a.name !== null) {
+            const ns = getNamespace(a.ns, ancestors);
+            if (prefixOf(ns) === undefined) {
+                ancestors.push(uniquePrefix(ns, ancestors));
+            }
+        }
+    }
+    const prefix = prefixOf(own);
+    const qualified = prefix !== "" ? `${prefix}:${node.name}` : node.name;
+    out.push("<", qualified);
+    for (const a of node.attributes) {
+        if (a.name !== null) {
+            out.push(" ");
+            const ns = getNamespace(a.ns, ancestors);
+            if (hasPrefix(ns)) {
+                out.push(prefixOf(ns), ":");
+            }
+            out.push(a.name, '="', escapeAttributeValue(a.value), '"');
+        }
+    }
+    for (let i = origLength; i < ancestors.length; i++) {
+        const ns = ancestors[i];
+        if (ns.uri !== "") {
+            const p = prefixOf(ns);
+            out.push(p !== "" ? ` xmlns:${p}="` : ' xmlns="', ns.uri ?? "", '"');
+        }
+    }
+    const children = node.children;
+    if (!children.length) {
+        out.push("/>");
+        return;
+    }
+    out.push(">");
+    const indentChildren = children.length > 1 || (children[0].kind & ~(TEXT | CDATA)) !== 0;
+    const nextIndentLevel = e.prettyPrinting && indentChildren ? indentLevel + e.prettyIndent : 0;
+    // The ancestors' namespaces less those whose prefix one here declares
+    // again, so that each is declared where it is shadowed.
+    const scope = [];
+    for (let i = 0; i < ancestors.length; i++) {
+        const first = ancestors[i];
+        if (i < origLength) {
+            let j = origLength;
+            while (j < ancestors.length && prefixOf(ancestors[j]) !== prefixOf(first)) {
+                j++;
+            }
+            if (j === ancestors.length) {
+                scope.push(first);
+            }
+        }
+        else {
+            scope.push(first);
+        }
+    }
+    const scopeLength = scope.length;
+    for (const child of children) {
+        if (pretty && indentChildren) {
+            out.push("\n");
+        }
+        toXMLStringOf(rt, child, scope, nextIndentLevel, out);
+        scope.length = scopeLength;
+    }
+    if (pretty && indentChildren) {
+        out.push("\n");
+        if (indentLevel > 0) {
+            out.push(" ".repeat(indentLevel));
+        }
+    }
+    out.push("</", qualified, ">");
+}
+export function xmlToXMLString(rt, node) {
+    const out = [];
+    toXMLStringOf(rt, node, [], 0, out);
+    return out.join("");
+}
+export function listToXMLString(rt, list) {
+    const out = [];
+    const nodes = list.$nodes;
+    for (let i = 0; i < nodes.length; i++) {
+        if (i) {
+            out.push("\n");
+        }
+        toXMLStringOf(rt, nodes[i], [], 0, out);
+    }
+    return out.join("");
+}
+/** As XMLObject::toString, E4X 10.1.1: a simple node's text, else its XML. */
+export function xmlToString(rt, node) {
+    if (node.kind & (TEXT | CDATA | ATTRIBUTE)) {
+        return node.value;
+    }
+    if (node.hasSimpleContent()) {
+        let s = "";
+        for (const child of node.children) {
+            if (child.kind !== COMMENT && child.kind !== PROCESSING_INSTRUCTION) {
+                s += xmlToString(rt, child);
+            }
+        }
+        return s;
+    }
+    return xmlToXMLString(rt, node);
+}
+export function listHasSimpleContent(nodes) {
+    if (nodes.length === 0) {
+        return true;
+    }
+    if (nodes.length === 1) {
+        return nodes[0].hasSimpleContent();
+    }
+    return !nodes.some((n) => n.kind === ELEMENT);
+}
+export function listToString(rt, list) {
+    const nodes = list.$nodes;
+    if (listHasSimpleContent(nodes)) {
+        let s = "";
+        for (const node of nodes) {
+            if (node.kind !== COMMENT && node.kind !== PROCESSING_INSTRUCTION) {
+                s += xmlToString(rt, node);
+            }
+        }
+        return s;
+    }
+    return listToXMLString(rt, list);
+}
+// Equality and +.
+/** As XMLListObject::_equals. */
+function listEquals(rt, list, v) {
+    const nodes = list.$nodes;
+    if (v === undefined && nodes.length === 0) {
+        return true;
+    }
+    if (isList(v)) {
+        const other = v.$nodes;
+        if (nodes.length !== other.length) {
+            return false;
+        }
+        for (let i = 0; i < nodes.length; i++) {
+            if (nodes[i] !== other[i] && !rt.equals(xmlOf(rt, nodes[i]), xmlOf(rt, other[i]))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (nodes.length === 1) {
+        return rt.equals(xmlOf(rt, nodes[0]), v);
+    }
+    return false;
+}
+/** E4X's == (11.5.1) where either side is XML or an XMLList, else undefined. */
+function equals(rt, a, b) {
+    if (isList(a)) {
+        return listEquals(rt, a, b);
+    }
+    if (isList(b)) {
+        return listEquals(rt, b, a);
+    }
+    if (isXML(a) && isXML(b)) {
+        const x = a.$node;
+        const y = b.$node;
+        if ((x.kind & (TEXT | CDATA | ATTRIBUTE) && y.hasSimpleContent()) ||
+            (y.kind & (TEXT | CDATA | ATTRIBUTE) && x.hasSimpleContent())) {
+            return xmlToString(rt, x) === xmlToString(rt, y);
+        }
+        return x.equals(y);
+    }
+    const xml = isXML(a) ? a : b;
+    const other = xml === a ? b : a;
+    if (other === null || other === undefined) {
+        return false;
+    }
+    if (xml.$node.hasSimpleContent() && !(typeof other === "object" && other.$traits?.properties)) {
+        return xmlToString(rt, xml.$node) === rt.toString(other);
+    }
+    return undefined;
+}
+/** E4X's + (11.4.1): XML and XMLLists into one XMLList. */
+function add(rt, a, b) {
+    if ((isXML(a) || isList(a)) && (isXML(b) || isList(b))) {
+        const list = newList(rt);
+        append(list, a);
+        append(list, b);
+        return list;
+    }
+    return undefined;
+}
+// Calls, as XMLObject::callProperty and XMLListObject::callProperty.
+/** A dynamic property of the prototype chain, or undefined. */
+function prototypeProperty(rt, o, mn) {
+    const name = mn.dynamicName();
+    if (name === null) {
+        return undefined;
+    }
+    for (let p = rt.protoOf(o); p; p = p.$p) {
+        const v = p.$d?.get(name);
+        if (v !== undefined) {
+            return v;
+        }
+    }
+    return undefined;
+}
+/** A function that calls `mn` on `receiver`, for a call E4X passes on. */
+const forward = (rt, receiver, mn) => rt.newFunctionObject((...args) => rt.callProperty(receiver, mn, ...args), null);
+// The hooks.
+export const xmlProperties = {
+    hidesMethods: true,
+    get: (rt, o, mn) => getXML(rt, o, fromMultiname(mn)),
+    set: (rt, o, mn, v) => setXML(rt, o, fromMultiname(mn), v),
+    delete: (rt, o, mn) => deleteXML(rt, o, fromMultiname(mn)),
+    has: (rt, o, mn) => hasXML(rt, o, fromMultiname(mn)),
+    callee(rt, o, mn) {
+        const f = prototypeProperty(rt, o, mn);
+        if (f !== undefined) {
+            return f;
+        }
+        const v = getXML(rt, o, fromMultiname(mn));
+        // A simple node with no such child is its string, as 11.2.2.1 has it.
+        if (isList(v) && !v.$nodes.length && o.$node.hasSimpleContent()) {
+            return forward(rt, xmlToString(rt, o.$node), mn);
+        }
+        return v;
+    },
+    descendants: (rt, o, mn) => descendantsOf(rt, o.$node, fromMultiname(mn)),
+    nextIndex: (_rt, _o, index) => (index === 0 ? 1 : 0),
+    nextName: (_rt, _o, index) => (index === 1 ? "0" : null),
+    nextValue: (_rt, o, index) => (index === 1 ? o : undefined),
+    equals,
+    add,
+    toString: (rt, o) => xmlToString(rt, o.$node),
+    toXMLString: (rt, o) => xmlToXMLString(rt, o.$node),
+};
+export const listProperties = {
+    hidesMethods: true,
+    get: (rt, o, mn) => getList(rt, o, coerce(rt, fromMultiname(mn))),
+    set: (rt, o, mn, v) => setList(rt, o, coerce(rt, fromMultiname(mn)), v),
+    delete: (rt, o, mn) => deleteList(rt, o, coerce(rt, fromMultiname(mn))),
+    has: (rt, o, mn) => hasList(rt, o, coerce(rt, fromMultiname(mn))),
+    callee(rt, o, mn) {
+        const f = prototypeProperty(rt, o, mn);
+        if (f !== undefined) {
+            return f;
+        }
+        const v = getList(rt, o, coerce(rt, fromMultiname(mn)));
+        // A list of one with no such child passes the call on to its item.
+        if (isList(v) && !v.$nodes.length && o.$nodes.length === 1) {
+            return forward(rt, xmlOf(rt, o.$nodes[0]), mn);
+        }
+        return v;
+    },
+    descendants: (rt, o, mn) => descendantsOfList(rt, o, coerce(rt, fromMultiname(mn))),
+    nextIndex: (_rt, o, index) => (index < o.$nodes.length ? index + 1 : 0),
+    nextName: (_rt, o, index) => (index <= o.$nodes.length ? String(index - 1) : null),
+    nextValue: (rt, o, index) => index <= o.$nodes.length ? xmlOf(rt, o.$nodes[index - 1]) : undefined,
+    equals,
+    add,
+    toString: (rt, o) => listToString(rt, o),
+    toXMLString: (rt, o) => listToXMLString(rt, o),
+};
+export function constructXML(rt, _cls, args) {
+    const v = args[0];
+    if (v === null || v === undefined) {
+        return toXML(rt, "");
+    }
+    const x = toXML(rt, v);
+    if (isXML(v) || isList(v)) {
+        return xmlOf(rt, deepCopy(rt, x.$node));
+    }
+    return x;
+}
+export function constructXMLList(rt, _cls, args) {
+    const v = args[0];
+    if (v === null || v === undefined) {
+        return toXMLList(rt, "");
+    }
+    if (isList(v)) {
+        const list = newList(rt);
+        append(list, v);
+        return list;
+    }
+    return toXMLList(rt, v);
+}
+// The natives.
+/**
+ * As maybeEscapeChild, with the fixes of avmshell's SWF version: a child
+ * is added as it is, a string as text, and XML already in a tree is first
+ * taken out of it.
+ */
+export function adopt(v) {
+    if (isXML(v)) {
+        const node = v.$node;
+        const i = node.childIndex();
+        if (node.parent && i !== -1) {
+            node.parent.deleteByIndex(i);
+        }
+    }
+    return v;
+}
+const NOT_ELEMENT = TEXT | COMMENT | PROCESSING_INSTRUCTION | ATTRIBUTE | CDATA;
+export function addNamespace(rt, o, node, v) {
+    const ns = newNamespace(rt, v);
+    node.addInScopeNamespace(ns);
+    nonChildChanges(rt, node, "namespaceAdded", ns);
+    return o;
+}
+export function appendChild(rt, o, node, child) {
+    const c = adopt(child);
+    const children = getXML(rt, o, toXMLName(rt, "*"));
+    setIndex(rt, children, node.children.length, c);
+    return o;
+}
+export function insertChild(rt, o, node, child1, child2, after) {
+    if (node.kind & NOT_ELEMENT) {
+        return undefined;
+    }
+    const c2 = adopt(child2);
+    if (child1 === null) {
+        insertAt(rt, node, after ? 0 : node.children.length, c2);
+        childChanges(rt, node, "nodeAdded", c2);
+        return o;
+    }
+    let c1 = isXML(child1) ? child1.$node : null;
+    if (!c1 && isList(child1) && child1.$nodes.length === 1) {
+        c1 = child1.$nodes[0];
+    }
+    if (c1) {
+        const i = node.children.indexOf(c1);
+        if (i >= 0) {
+            insertAt(rt, node, after ? i + 1 : i, c2);
+            childChanges(rt, node, "nodeAdded", c2);
+            return o;
+        }
+    }
+    return undefined;
+}
+export function namespaceOf(rt, node, argc, prefix) {
+    const inScope = node.inScopeNamespaces();
+    if (!argc) {
+        if (node.kind & (TEXT | COMMENT | CDATA | PROCESSING_INSTRUCTION)) {
+            return null;
+        }
+        return getNamespace(node.ns, inScope);
+    }
+    const p = rt.toString(prefix);
+    return inScope.find((ns) => prefixOf(ns) === p) ?? undefined;
+}
+export function namespaceDeclarations(rt, node) {
+    const result = [];
+    if (!(node.kind & NOT_ELEMENT)) {
+        const ancestors = node.parent ? node.parent.inScopeNamespaces() : [];
+        for (const ns of node.namespaces) {
+            if (!hasPrefix(ns)) {
+                if (ns.uri !== "" && !ancestors.some((ns2) => ns.uri === ns2.uri)) {
+                    result.push(ns);
+                }
+            }
+            else if (!ancestors.some((ns2) => prefixOf(ns) === prefixOf(ns2) && ns.uri === ns2.uri)) {
+                result.push(ns);
+            }
+        }
+    }
+    return rt.newArray(result);
+}
+export function normalize(rt, node) {
+    const notify = notifyNeeded(node);
+    let i = 0;
+    while (i < node.children.length) {
+        const x = node.children[i];
+        if (x.kind === ELEMENT) {
+            normalize(rt, x);
+            i++;
+        }
+        else if (x.kind & (TEXT | CDATA)) {
+            const prior = x.value;
+            while (i + 1 < node.children.length && node.children[i + 1].kind & (TEXT | CDATA)) {
+                const x2 = node.children[i + 1];
+                x.value += x2.value;
+                node.deleteByIndex(i + 1);
+                if (notify) {
+                    childChanges(rt, node, "nodeRemoved", xmlOf(rt, x2));
+                }
+            }
+            if (isWhitespace(x.value)) {
+                node.deleteByIndex(i);
+                if (notify) {
+                    childChanges(rt, node, "nodeRemoved", xmlOf(rt, x));
+                }
+            }
+            else {
+                i++;
+            }
+            if (x.value !== prior && notify) {
+                nonChildChanges(rt, x, "textSet", x.value, prior);
+            }
+        }
+        else {
+            i++;
+        }
+    }
+}
+export function removeNamespace(rt, node, v) {
+    if (node.kind & NOT_ELEMENT) {
+        return;
+    }
+    const ns = newNamespace(rt, v);
+    if (getNamespace(node.ns, node.namespaces) === ns) {
+        return;
+    }
+    for (const a of node.attributes) {
+        if (getNamespace(a.ns, node.namespaces) === ns) {
+            return;
+        }
+    }
+    const i = node.findMatchingNamespace(ns);
+    if (i !== -1) {
+        node.namespaces.splice(i, 1);
+    }
+    for (const child of node.children) {
+        if (child.kind === ELEMENT) {
+            removeNamespace(rt, child, ns);
+        }
+    }
+    nonChildChanges(rt, node, "namespaceRemoved", ns);
+}
+export function replace(rt, o, node, name, value) {
+    if (node.kind & NOT_ELEMENT) {
+        return o;
+    }
+    let c;
+    if (isXML(value)) {
+        c = xmlOf(rt, deepCopy(rt, value.$node));
+    }
+    else if (isList(value)) {
+        c = listDeepCopy(rt, value);
+    }
+    else {
+        c = rt.toString(value);
+    }
+    const index = parseIndex(rt.toString(name));
+    if (index >= 0) {
+        const prior = replaceAt(rt, node, index, c);
+        childChanges(rt, node, "nodeChanged", c, prior);
+        return o;
+    }
+    const n = qnameName(rt, name);
+    const notify = notifyNeeded(node);
+    let i = -1;
+    for (let k = node.children.length - 1; k >= 0; k--) {
+        if (matchesChild(n, node.children[k])) {
+            if (i !== -1) {
+                const was = node.children[i];
+                node.deleteByIndex(i);
+                if (notify && was.kind === ELEMENT) {
+                    childChanges(rt, node, "nodeRemoved", xmlOf(rt, was));
+                }
+            }
+            i = k;
+        }
+    }
+    if (i === -1) {
+        return o;
+    }
+    const prior = replaceAt(rt, node, i, c);
+    childChanges(rt, node, prior ? "nodeChanged" : "nodeAdded", c, prior);
+    return o;
+}
+export function setLocalName(rt, node, name) {
+    if (node.kind & (TEXT | COMMENT | CDATA)) {
+        return;
+    }
+    const newName = typeof name === "object" && name !== null && name.$local !== undefined
+        ? (name.$local ?? "*")
+        : rt.toString(name);
+    if (!isXMLName(newName)) {
+        throw rt.error("TypeError", INVALID_NAME, newName);
+    }
+    if (node.name !== null) {
+        const prior = node.name;
+        node.setName(newName, node.ns);
+        nonChildChanges(rt, node, "nameSet", newName, prior);
+    }
+}
+export function setName(rt, node, value) {
+    if (node.kind & (TEXT | COMMENT | CDATA)) {
+        return;
+    }
+    let name = value;
+    if (typeof name === "object" && name !== null && name.$local !== undefined && !name.$ns) {
+        name = name.$local ?? "*";
+    }
+    const n = qnameName(rt, name);
+    const local = n.local ?? "*";
+    if (!isXMLName(local)) {
+        throw rt.error("TypeError", INVALID_NAME, local);
+    }
+    if (node.name === null) {
+        return;
+    }
+    if (node.kind === PROCESSING_INSTRUCTION) {
+        node.setName(local, publicNs);
+    }
+    else {
+        const ns = n.namespaces?.[0] ?? null;
+        node.setName(local, ns);
+        if (ns && ns.uri !== "") {
+            if (node.kind === ATTRIBUTE && node.parent) {
+                node.parent.addInScopeNamespace(node.ns);
+            }
+            else if (node.kind === ELEMENT) {
+                node.addInScopeNamespace(node.ns);
+            }
+        }
+    }
+    nonChildChanges(rt, node, "nameSet", name, node.name);
+}
+export function setNamespace(rt, node, v) {
+    if (node.kind & (TEXT | COMMENT | PROCESSING_INSTRUCTION | CDATA)) {
+        return;
+    }
+    const ns = newNamespace(rt, v);
+    if (node.name !== null) {
+        node.setName(node.name, ns);
+    }
+    if (node.kind === ATTRIBUTE && node.parent) {
+        node.parent.addInScopeNamespace(ns);
+    }
+    else if (node.kind === ELEMENT) {
+        node.addInScopeNamespace(ns);
+    }
+    nonChildChanges(rt, node, "namespaceSet", ns);
+}
+/** A list of `node`'s children of `kinds`, got from `o`. */
+export function childrenOf(rt, o, node, kinds) {
+    const list = newList(rt, o);
+    for (const child of node.children) {
+        if (child.kind & kinds) {
+            appendNode(list, child);
+        }
+    }
+    return list;
+}
+export function elements(rt, o, node, name) {
+    const n = toXMLName(rt, name);
+    const list = newList(rt, o, n);
+    for (const child of node.children) {
+        if (child.kind === ELEMENT && matches(n, child)) {
+            appendNode(list, child);
+        }
+    }
+    return list;
+}
+export function processingInstructions(rt, o, node, name) {
+    const n = toXMLName(rt, name);
+    const list = newList(rt, o);
+    if (n.attribute) {
+        return list;
+    }
+    for (const child of node.children) {
+        if (child.kind === PROCESSING_INSTRUCTION && matches(n, child)) {
+            appendNode(list, child);
+        }
+    }
+    return list;
+}
+export function child(rt, o, node, name) {
+    const index = parseIndex(rt.toString(name));
+    if (index >= 0) {
+        const list = newList(rt);
+        if (index < node.children.length) {
+            appendNode(list, node.children[index]);
+        }
+        return list;
+    }
+    return getXML(rt, o, toXMLName(rt, name));
+}
+/** A name given, or "*" for none. */
+export const star = (v) => (v === undefined ? "*" : v);
+/** The global isXMLName, the E4X native that is not a class's. */
+export const xmlNatives = {
+    isXMLName: (rt) => (v) => v !== null && v !== undefined && isXMLName(rt.toString(v)),
+};
+//# sourceMappingURL=xml.js.map