@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,633 @@
+// E4X's internal methods, E4X 9.1.1 and 9.2.1: XML's and XMLList's get,
+// put, delete, has and descendants, the tree changes they make, and the
+// notifications those send.
+//
+// Translated from avmplus' core/XMLObject.cpp, XMLListObject.cpp and
+// E4XNode.cpp, this file is subject to the Mozilla Public License, v. 2.0:
+// http://mozilla.org/MPL/2.0/.
+import { deepCopy, listDeepCopy, toXML } from "./build.js";
+import { isXMLName } from "./chars.js";
+import { coerce, indexOf, matchesChild, toXMLName } from "./names.js";
+import { ATTRIBUTE, CDATA, COMMENT, ELEMENT, matches, PROCESSING_INSTRUCTION, TEXT, XMLNode, } from "./node.js";
+import { ASSIGNMENT_ONE_ITEM_LISTS, ASSIGNMENT_TO_INDEXED_XML, append, appendNode, fixTarget, ILLEGAL_CYCLICAL_LOOP, isList, isXML, newList, xmlOf, } from "./values.js";
+// Notifications, as setNotification sets a function to call on changes.
+export 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);
+    }
+}
+export 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.
+ */
+export 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]]. */
+export 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;
+}
+export 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);
+}
+export 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`. */
+export 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;
+}