@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/runtime/avm2/natives/xml/xml.js

@@ -0,0 +1,645 @@
+// E4X: the XML and XMLList classes, as avmplus has them. Names on them are
+// looked up by PropertyHook in place of dynamic properties (access.ts);
+// here are the hooks, the constructors and the natives. The values are in
+// values.ts, names in names.ts, parsing and conversions in build.ts,
+// strings in strings.ts and == and + in operators.ts.
+//
+// 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 { prefixOf, publicNs } from "../../names.js";
+import { AS3 } from "../define.js";
+import { childChanges, deleteIndex, deleteList, deleteXML, descendantsOf, descendantsOfList, getList, getXML, hasList, hasXML, insertAt, nonChildChanges, notifyNeeded, replaceAt, setIndex, setList, setXML, } from "./access.js";
+import { deepCopy, isWhitespace, listDeepCopy, toXML, toXMLList } from "./build.js";
+import { isXMLName } from "./chars.js";
+import { coerce, fromMultiname, getNamespace, hasPrefix, matchesChild, newNamespace, parseIndex, qnameName, qnameOf, toAttributeName, toXMLName, } from "./names.js";
+import { ATTRIBUTE, CDATA, COMMENT, ELEMENT, matches, PROCESSING_INSTRUCTION, TEXT, } from "./node.js";
+import { add, equals } from "./operators.js";
+import { listHasSimpleContent, listToString, listToXMLString, xmlToString, xmlToXMLString, } from "./strings.js";
+import { append, appendNode, e4x, INVALID_NAME, isList, isXML, newList, ONLY_ONE_ITEM_LISTS, xmlOf, } from "./values.js";
+// 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.
+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),
+};
+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),
+};
+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;
+}
+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);
+}
+export const xmlHooks = {
+    XML: {
+        properties: xmlProperties,
+        construct: constructXML,
+        call: (rt, _cls, args) => args[0] === null || args[0] === undefined ? toXML(rt, "") : toXML(rt, args[0]),
+    },
+    XMLList: {
+        properties: listProperties,
+        construct: constructXMLList,
+        call: (rt, _cls, args) => args[0] === null || args[0] === undefined ? toXMLList(rt, "") : toXMLList(rt, args[0]),
+    },
+};
+// The natives.
+/** An XML method: `f` with the runtime, on the node. */
+const onXML = (f) => (rt) => function (...args) {
+    return f(rt, this, this.$node, ...args);
+};
+/** An XMLList method: `f` with the runtime, on the list and its nodes. */
+const onList = (f) => (rt) => function (...args) {
+    return f(rt, this, this.$nodes, ...args);
+};
+/** An XMLList method that only a list of one has: its item's. */
+const onlyOne = (name, f) => onList((rt, _o, nodes, ...args) => {
+    if (nodes.length !== 1) {
+        throw rt.error("TypeError", ONLY_ONE_ITEM_LISTS, name);
+    }
+    return f(rt, xmlOf(rt, nodes[0]), ...args);
+});
+/** An XMLList method: the XMLList of each element's results, together. */
+const eachElement = (f) => onList((rt, o, nodes, ...args) => {
+    const list = newList(rt, o);
+    for (const node of nodes) {
+        if (node.kind === ELEMENT) {
+            const r = f(rt, xmlOf(rt, node), ...args);
+            if (r.$nodes.length) {
+                append(list, r);
+            }
+        }
+    }
+    return list;
+});
+/**
+ * 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.
+ */
+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;
+function addNamespace(rt, o, node, v) {
+    const ns = newNamespace(rt, v);
+    node.addInScopeNamespace(ns);
+    nonChildChanges(rt, node, "namespaceAdded", ns);
+    return o;
+}
+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;
+}
+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;
+}
+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;
+}
+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);
+}
+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++;
+        }
+    }
+}
+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);
+}
+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;
+}
+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);
+    }
+}
+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);
+}
+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`. */
+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;
+}
+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;
+}
+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;
+}
+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));
+}
+const x = (name) => `XML#${AS3}::${name}`;
+const l = (name) => `XMLList#${AS3}::${name}`;
+const star = (v) => (v === undefined ? "*" : v);
+/** XML's settings, as its static accessors. */
+const setting = (key, set) => ({
+    [`XML.get:${key}`]: (rt) => () => e4x(rt)[key],
+    [`XML.set:${key}`]: (rt) => (v) => {
+        e4x(rt)[key] = set(rt, v);
+    },
+});
+const toBoolean = (_rt, v) => Boolean(v);
+export const xmlNatives = {
+    ...setting("ignoreComments", toBoolean),
+    ...setting("ignoreProcessingInstructions", toBoolean),
+    ...setting("ignoreWhitespace", toBoolean),
+    ...setting("prettyPrinting", toBoolean),
+    ...setting("prettyIndent", (rt, v) => rt.toInt(v)),
+    [x("toString")]: onXML((rt, _o, node) => xmlToString(rt, node)),
+    [x("toXMLString")]: onXML((rt, _o, node) => xmlToXMLString(rt, node)),
+    [x("hasOwnProperty")]: onXML((rt, o, _node, p) => hasXML(rt, o, toXMLName(rt, p))),
+    [x("propertyIsEnumerable")]: onXML((rt, _o, _node, p) => rt.toString(p) === "0"),
+    [x("addNamespace")]: onXML((rt, o, node, v) => addNamespace(rt, o, node, v)),
+    [x("appendChild")]: onXML((rt, o, node, c) => appendChild(rt, o, node, c)),
+    [x("attribute")]: onXML((rt, o, _node, name) => getXML(rt, o, toAttributeName(rt, name))),
+    [x("attributes")]: onXML((rt, o) => getXML(rt, o, toAttributeName(rt, "*"))),
+    [x("child")]: onXML((rt, o, node, name) => child(rt, o, node, name)),
+    [x("childIndex")]: onXML((_rt, _o, node) => node.childIndex()),
+    [x("children")]: onXML((rt, o) => getXML(rt, o, toXMLName(rt, "*"))),
+    [x("comments")]: onXML((rt, o, node) => childrenOf(rt, o, node, COMMENT)),
+    [x("contains")]: onXML((_rt, o, node, v) => o === v || (isXML(v) && node.equals(v.$node))),
+    [x("copy")]: onXML((rt, _o, node) => xmlOf(rt, deepCopy(rt, node))),
+    [x("descendants")]: onXML((rt, _o, node, name) => descendantsOf(rt, node, toXMLName(rt, star(name)))),
+    [x("elements")]: onXML((rt, o, node, name) => elements(rt, o, node, star(name))),
+    [x("hasComplexContent")]: onXML((_rt, _o, node) => node.hasComplexContent()),
+    [x("hasSimpleContent")]: onXML((_rt, _o, node) => node.hasSimpleContent()),
+    [x("inScopeNamespaces")]: onXML((rt, _o, node) => {
+        const list = node.inScopeNamespaces();
+        return rt.newArray(list.length ? list : [publicNs]);
+    }),
+    [x("insertChildAfter")]: onXML((rt, o, node, c1, c2) => insertChild(rt, o, node, c1, c2, true)),
+    [x("insertChildBefore")]: onXML((rt, o, node, c1, c2) => insertChild(rt, o, node, c1, c2, false)),
+    [x("localName")]: onXML((_rt, _o, node) => node.name),
+    [x("name")]: onXML((rt, _o, node) => (node.name === null ? null : qnameOf(rt, node))),
+    "XML#XML::_namespace": onXML((rt, _o, node, prefix, argc) => namespaceOf(rt, node, argc, prefix)),
+    [x("namespaceDeclarations")]: onXML((rt, _o, node) => namespaceDeclarations(rt, node)),
+    [x("nodeKind")]: onXML((_rt, _o, node) => node.nodeKind()),
+    [x("normalize")]: onXML((rt, o, node) => {
+        normalize(rt, node);
+        return o;
+    }),
+    [x("parent")]: onXML((rt, _o, node) => (node.parent ? xmlOf(rt, node.parent) : undefined)),
+    [x("processingInstructions")]: onXML((rt, o, node, name) => processingInstructions(rt, o, node, star(name))),
+    [x("prependChild")]: onXML((rt, o, node, v) => {
+        const c = adopt(v);
+        insertAt(rt, node, 0, c);
+        childChanges(rt, node, "nodeAdded", c);
+        return o;
+    }),
+    [x("removeNamespace")]: onXML((rt, o, node, v) => {
+        removeNamespace(rt, node, v);
+        return o;
+    }),
+    [x("replace")]: onXML((rt, o, node, name, v) => replace(rt, o, node, name, v)),
+    [x("setChildren")]: onXML((rt, o, _node, v) => {
+        setXML(rt, o, toXMLName(rt, "*"), v);
+        return o;
+    }),
+    [x("setLocalName")]: onXML((rt, _o, node, name) => setLocalName(rt, node, name)),
+    [x("setName")]: onXML((rt, _o, node, name) => setName(rt, node, name)),
+    [x("setNamespace")]: onXML((rt, _o, node, ns) => setNamespace(rt, node, ns)),
+    [x("text")]: onXML((rt, o, node) => childrenOf(rt, o, node, TEXT | CDATA)),
+    [x("notification")]: onXML((_rt, _o, node) => node.notification ?? null),
+    [x("setNotification")]: onXML((rt, _o, node, f) => {
+        if (f !== null && f !== undefined && !f.$f) {
+            throw rt.error("ArgumentError", 1508, "f");
+        }
+        if (node.kind === ELEMENT) {
+            node.notification = f ?? null;
+        }
+        return undefined;
+    }),
+    [l("toString")]: onList((rt, o) => listToString(rt, o)),
+    [l("toXMLString")]: onList((rt, o) => listToXMLString(rt, o)),
+    [l("hasOwnProperty")]: onList((rt, o, _nodes, p) => hasList(rt, o, coerce(rt, toXMLName(rt, p)))),
+    [l("propertyIsEnumerable")]: onList((rt, _o, nodes, p) => {
+        const index = rt.toNumber(p);
+        return index >= 0 && index < nodes.length;
+    }),
+    [l("attribute")]: onList((rt, o, _nodes, name) => getList(rt, o, coerce(rt, toAttributeName(rt, name)))),
+    [l("attributes")]: onList((rt, o) => getList(rt, o, coerce(rt, toAttributeName(rt, "*")))),
+    [l("child")]: onList((rt, o, nodes, name) => {
+        const list = newList(rt, o);
+        for (const node of nodes) {
+            const r = child(rt, xmlOf(rt, node), node, name);
+            if (r.$nodes.length) {
+                append(list, r);
+            }
+        }
+        return list;
+    }),
+    [l("children")]: onList((rt, o) => getList(rt, o, coerce(rt, toXMLName(rt, "*")))),
+    [l("comments")]: eachElement((rt, x) => childrenOf(rt, x, x.$node, COMMENT)),
+    [l("contains")]: onList((rt, _o, nodes, v) => nodes.some((node) => rt.equals(xmlOf(rt, node), v))),
+    [l("copy")]: onList((rt, o) => listDeepCopy(rt, o)),
+    [l("descendants")]: onList((rt, o, _nodes, name) => descendantsOfList(rt, o, toXMLName(rt, star(name)))),
+    [l("elements")]: onList((rt, o, nodes, name) => {
+        const list = newList(rt, o, toXMLName(rt, star(name)));
+        for (const node of nodes) {
+            if (node.kind === ELEMENT) {
+                const r = elements(rt, xmlOf(rt, node), node, star(name));
+                if (r.$nodes.length) {
+                    append(list, r);
+                }
+            }
+        }
+        return list;
+    }),
+    [l("hasComplexContent")]: onList((_rt, _o, nodes) => {
+        if (nodes.length === 1) {
+            return nodes[0].hasComplexContent();
+        }
+        return nodes.some((n) => n.kind === ELEMENT);
+    }),
+    [l("hasSimpleContent")]: onList((_rt, _o, nodes) => listHasSimpleContent(nodes)),
+    [l("length")]: onList((_rt, _o, nodes) => nodes.length),
+    [l("name")]: onlyOne("name", (rt, x) => (x.$node.name === null ? null : qnameOf(rt, x.$node))),
+    [l("normalize")]: onList((rt, o, nodes) => {
+        let i = 0;
+        while (i < nodes.length) {
+            const xn = nodes[i];
+            if (xn.kind === ELEMENT) {
+                normalize(rt, xn);
+                i++;
+            }
+            else if (xn.kind & (TEXT | CDATA)) {
+                while (i + 1 < nodes.length && nodes[i + 1].kind & (TEXT | CDATA)) {
+                    xn.value += nodes[i + 1].value;
+                    deleteIndex(rt, o, i + 1);
+                }
+                if (xn.value.length === 0) {
+                    deleteIndex(rt, o, i);
+                }
+                else {
+                    i++;
+                }
+            }
+            else {
+                i++;
+            }
+        }
+        return o;
+    }),
+    [l("parent")]: onList((rt, _o, nodes) => {
+        if (!nodes.length) {
+            return undefined;
+        }
+        const parent = nodes[0].parent;
+        if (!parent || nodes.some((n) => n.parent !== parent)) {
+            return undefined;
+        }
+        return xmlOf(rt, parent);
+    }),
+    [l("processingInstructions")]: eachElement((rt, x, name) => processingInstructions(rt, x, x.$node, star(name))),
+    [l("text")]: eachElement((rt, x) => childrenOf(rt, x, x.$node, TEXT | CDATA)),
+    [l("addNamespace")]: onlyOne("addNamespace", (rt, x, v) => addNamespace(rt, x, x.$node, v)),
+    [l("appendChild")]: onlyOne("appendChild", (rt, x, c) => appendChild(rt, x, x.$node, c)),
+    [l("childIndex")]: onlyOne("childIndex", (_rt, x) => x.$node.childIndex()),
+    [l("inScopeNamespaces")]: onlyOne("inScopeNamespaces", (rt, x) => {
+        const list = x.$node.inScopeNamespaces();
+        return rt.newArray(list.length ? list : [publicNs]);
+    }),
+    [l("insertChildAfter")]: onlyOne("insertChildAfter", (rt, x, c1, c2) => insertChild(rt, x, x.$node, c1, c2, true)),
+    [l("insertChildBefore")]: onlyOne("insertChildBefore", (rt, x, c1, c2) => insertChild(rt, x, x.$node, c1, c2, false)),
+    [l("nodeKind")]: onlyOne("nodeKind", (_rt, x) => x.$node.nodeKind()),
+    "XMLList#XMLList::_namespace": onlyOne("namespace", (rt, x, prefix, argc) => namespaceOf(rt, x.$node, argc, prefix)),
+    [l("localName")]: onlyOne("localName", (_rt, x) => x.$node.name),
+    [l("namespaceDeclarations")]: onlyOne("namespaceDeclarations", (rt, x) => namespaceDeclarations(rt, x.$node)),
+    [l("prependChild")]: onlyOne("prependChild", (rt, x, v) => {
+        const c = adopt(v);
+        insertAt(rt, x.$node, 0, c);
+        childChanges(rt, x.$node, "nodeAdded", c);
+        return x;
+    }),
+    [l("removeNamespace")]: onlyOne("removeNamespace", (rt, x, v) => {
+        removeNamespace(rt, x.$node, v);
+        return x;
+    }),
+    [l("replace")]: onlyOne("replace", (rt, x, name, v) => replace(rt, x, x.$node, name, v)),
+    [l("setChildren")]: onlyOne("setChildren", (rt, x, v) => {
+        setXML(rt, x, toXMLName(rt, "*"), v);
+        return x;
+    }),
+    [l("setLocalName")]: onlyOne("setLocalName", (rt, x, name) => setLocalName(rt, x.$node, name)),
+    [l("setName")]: onlyOne("setName", (rt, x, name) => setName(rt, x.$node, name)),
+    [l("setNamespace")]: onlyOne("setNamespace", (rt, x, ns) => setNamespace(rt, x.$node, ns)),
+    isXMLName: (rt) => (v) => v !== null && v !== undefined && isXMLName(rt.toString(v)),
+};