@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,291 @@
+// E4X's trees made from values: text parsed (by parser.ts) into nodes with
+// their namespaces, the conversions ToXML and ToXMLList, and deep copies.
+//
+// Translated from avmplus' core/XMLObject.cpp, XMLListObject.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 { prefixedNamespace, prefixOf, publicNs } from "../../names.js";
+import { isSpace } from "./chars.js";
+import { hasPrefix, newPrefixedNamespace } from "./names.js";
+import { ATTRIBUTE, CDATA, COMMENT, ELEMENT, matches, PROCESSING_INSTRUCTION, TEXT, XMLNode, } from "./node.js";
+import * as P from "./parser.js";
+import { ANY, append, appendNode, BAD_QNAME, DUPLICATE_ATTRIBUTE, e4x, fixTarget, isList, isXML, MARKUP_MUST_BE_WELL_FORMED, newList, PARSE_ERRORS, PREFIX_NOT_BOUND, UNTERMINATED_ELEMENT_TAG, XML_1998, xmlOf, } from "./values.js";
+// 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;
+}
+export 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;
+}

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

@@ -0,0 +1,112 @@
+// The character classes of XML 1.0 (appendix B) that E4X names are made
+// of, as avmplus' AvmCore tables them: each a list of inclusive ranges.
+// Its isXMLName, which E4X uses for prefixes and names.
+//
+// Translated from avmplus' core/AvmCore.cpp, this file is subject to the
+// Mozilla Public License, v. 2.0: http://mozilla.org/MPL/2.0/.
+const LETTER = new Uint16Array([
+    0x0041, 0x005a, 0x0061, 0x007a, 0x00c0, 0x00d6, 0x00d8, 0x00f6, 0x00f8, 0x00ff, 0x0100, 0x0131,
+    0x0134, 0x013e, 0x0141, 0x0148, 0x014a, 0x017e, 0x0180, 0x01c3, 0x01cd, 0x01f0, 0x01f4, 0x01f5,
+    0x01fa, 0x0217, 0x0250, 0x02a8, 0x02bb, 0x02c1, 0x0386, 0x0386, 0x0388, 0x038a, 0x038c, 0x038c,
+    0x038e, 0x03a1, 0x03a3, 0x03ce, 0x03d0, 0x03d6, 0x03da, 0x03da, 0x03dc, 0x03dc, 0x03de, 0x03de,
+    0x03e0, 0x03e0, 0x03e2, 0x03f3, 0x0401, 0x040c, 0x040e, 0x044f, 0x0451, 0x045c, 0x045e, 0x0481,
+    0x0490, 0x04c4, 0x04c7, 0x04c8, 0x04cb, 0x04cc, 0x04d0, 0x04eb, 0x04ee, 0x04f5, 0x04f8, 0x04f9,
+    0x0531, 0x0556, 0x0559, 0x0559, 0x0561, 0x0586, 0x05d0, 0x05ea, 0x05f0, 0x05f2, 0x0621, 0x063a,
+    0x0641, 0x064a, 0x0671, 0x06b7, 0x06ba, 0x06be, 0x06c0, 0x06ce, 0x06d0, 0x06d3, 0x06d5, 0x06d5,
+    0x06e5, 0x06e6, 0x0905, 0x0939, 0x093d, 0x093d, 0x0958, 0x0961, 0x0985, 0x098c, 0x098f, 0x0990,
+    0x0993, 0x09a8, 0x09aa, 0x09b0, 0x09b2, 0x09b2, 0x09b6, 0x09b9, 0x09dc, 0x09dd, 0x09df, 0x09e1,
+    0x09f0, 0x09f1, 0x0a05, 0x0a0a, 0x0a0f, 0x0a10, 0x0a13, 0x0a28, 0x0a2a, 0x0a30, 0x0a32, 0x0a33,
+    0x0a35, 0x0a36, 0x0a38, 0x0a39, 0x0a59, 0x0a5c, 0x0a5e, 0x0a5e, 0x0a72, 0x0a74, 0x0a85, 0x0a8b,
+    0x0a8d, 0x0a8d, 0x0a8f, 0x0a91, 0x0a93, 0x0aa8, 0x0aaa, 0x0ab0, 0x0ab2, 0x0ab3, 0x0ab5, 0x0ab9,
+    0x0abd, 0x0abd, 0x0ae0, 0x0ae0, 0x0b05, 0x0b0c, 0x0b0f, 0x0b10, 0x0b13, 0x0b28, 0x0b2a, 0x0b30,
+    0x0b32, 0x0b33, 0x0b36, 0x0b39, 0x0b3d, 0x0b3d, 0x0b5c, 0x0b5d, 0x0b5f, 0x0b61, 0x0b85, 0x0b8a,
+    0x0b8e, 0x0b90, 0x0b92, 0x0b95, 0x0b99, 0x0b9a, 0x0b9c, 0x0b9c, 0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4,
+    0x0ba8, 0x0baa, 0x0bae, 0x0bb5, 0x0bb7, 0x0bb9, 0x0c05, 0x0c0c, 0x0c0e, 0x0c10, 0x0c12, 0x0c28,
+    0x0c2a, 0x0c33, 0x0c35, 0x0c39, 0x0c60, 0x0c61, 0x0c85, 0x0c8c, 0x0c8e, 0x0c90, 0x0c92, 0x0ca8,
+    0x0caa, 0x0cb3, 0x0cb5, 0x0cb9, 0x0cde, 0x0cde, 0x0ce0, 0x0ce1, 0x0d05, 0x0d0c, 0x0d0e, 0x0d10,
+    0x0d12, 0x0d28, 0x0d2a, 0x0d39, 0x0d60, 0x0d61, 0x0e01, 0x0e2e, 0x0e30, 0x0e30, 0x0e32, 0x0e33,
+    0x0e40, 0x0e45, 0x0e81, 0x0e82, 0x0e84, 0x0e84, 0x0e87, 0x0e88, 0x0e8a, 0x0e8a, 0x0e8d, 0x0e8d,
+    0x0e94, 0x0e97, 0x0e99, 0x0e9f, 0x0ea1, 0x0ea3, 0x0ea5, 0x0ea5, 0x0ea7, 0x0ea7, 0x0eaa, 0x0eab,
+    0x0ead, 0x0eae, 0x0eb0, 0x0eb0, 0x0eb2, 0x0eb3, 0x0ebd, 0x0ebd, 0x0ec0, 0x0ec4, 0x0f40, 0x0f47,
+    0x0f49, 0x0f69, 0x10a0, 0x10c5, 0x10d0, 0x10f6, 0x1100, 0x1100, 0x1102, 0x1103, 0x1105, 0x1107,
+    0x1109, 0x1109, 0x110b, 0x110c, 0x110e, 0x1112, 0x113c, 0x113c, 0x113e, 0x113e, 0x1140, 0x1140,
+    0x114c, 0x114c, 0x114e, 0x114e, 0x1150, 0x1150, 0x1154, 0x1155, 0x1159, 0x1159, 0x115f, 0x1161,
+    0x1163, 0x1163, 0x1165, 0x1165, 0x1167, 0x1167, 0x1169, 0x1169, 0x116d, 0x116e, 0x1172, 0x1173,
+    0x1175, 0x1175, 0x119e, 0x119e, 0x11a8, 0x11a8, 0x11ab, 0x11ab, 0x11ae, 0x11af, 0x11b7, 0x11b8,
+    0x11ba, 0x11ba, 0x11bc, 0x11c2, 0x11eb, 0x11eb, 0x11f0, 0x11f0, 0x11f9, 0x11f9, 0x1e00, 0x1e9b,
+    0x1ea0, 0x1ef9, 0x1f00, 0x1f15, 0x1f18, 0x1f1d, 0x1f20, 0x1f45, 0x1f48, 0x1f4d, 0x1f50, 0x1f57,
+    0x1f59, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f7d, 0x1f80, 0x1fb4, 0x1fb6, 0x1fbc,
+    0x1fbe, 0x1fbe, 0x1fc2, 0x1fc4, 0x1fc6, 0x1fcc, 0x1fd0, 0x1fd3, 0x1fd6, 0x1fdb, 0x1fe0, 0x1fec,
+    0x1ff2, 0x1ff4, 0x1ff6, 0x1ffc, 0x2126, 0x2126, 0x212a, 0x212b, 0x212e, 0x212e, 0x2180, 0x2182,
+    0x3041, 0x3094, 0x30a1, 0x30fa, 0x3105, 0x312c, 0xac00, 0xd7a3, 0x4e00, 0x9fa5, 0x3007, 0x3007,
+    0x3021, 0x3029,
+]);
+const COMBINING = new Uint16Array([
+    0x0300, 0x0345, 0x0360, 0x0361, 0x0483, 0x0486, 0x0591, 0x05a1, 0x05a3, 0x05b9, 0x05bb, 0x05bd,
+    0x05bf, 0x05bf, 0x05c1, 0x05c2, 0x05c4, 0x05c4, 0x064b, 0x0652, 0x0670, 0x0670, 0x06d6, 0x06dc,
+    0x06dd, 0x06df, 0x06e0, 0x06e4, 0x06e7, 0x06e8, 0x06ea, 0x06ed, 0x0901, 0x0903, 0x093c, 0x093c,
+    0x093e, 0x094c, 0x094d, 0x094d, 0x0951, 0x0954, 0x0962, 0x0963, 0x0981, 0x0983, 0x09bc, 0x09bc,
+    0x09be, 0x09be, 0x09bf, 0x09bf, 0x09c0, 0x09c4, 0x09c7, 0x09c8, 0x09cb, 0x09cd, 0x09d7, 0x09d7,
+    0x09e2, 0x09e3, 0x0a02, 0x0a02, 0x0a3c, 0x0a3c, 0x0a3e, 0x0a3e, 0x0a3f, 0x0a3f, 0x0a40, 0x0a42,
+    0x0a47, 0x0a48, 0x0a4b, 0x0a4d, 0x0a70, 0x0a71, 0x0a81, 0x0a83, 0x0abc, 0x0abc, 0x0abe, 0x0ac5,
+    0x0ac7, 0x0ac9, 0x0acb, 0x0acd, 0x0b01, 0x0b03, 0x0b3c, 0x0b3c, 0x0b3e, 0x0b43, 0x0b47, 0x0b48,
+    0x0b4b, 0x0b4d, 0x0b56, 0x0b57, 0x0b82, 0x0b83, 0x0bbe, 0x0bc2, 0x0bc6, 0x0bc8, 0x0bca, 0x0bcd,
+    0x0bd7, 0x0bd7, 0x0c01, 0x0c03, 0x0c3e, 0x0c44, 0x0c46, 0x0c48, 0x0c4a, 0x0c4d, 0x0c55, 0x0c56,
+    0x0c82, 0x0c83, 0x0cbe, 0x0cc4, 0x0cc6, 0x0cc8, 0x0cca, 0x0ccd, 0x0cd5, 0x0cd6, 0x0d02, 0x0d03,
+    0x0d3e, 0x0d43, 0x0d46, 0x0d48, 0x0d4a, 0x0d4d, 0x0d57, 0x0d57, 0x0e31, 0x0e31, 0x0e34, 0x0e3a,
+    0x0e47, 0x0e4e, 0x0eb1, 0x0eb1, 0x0eb4, 0x0eb9, 0x0ebb, 0x0ebc, 0x0ec8, 0x0ecd, 0x0f18, 0x0f19,
+    0x0f35, 0x0f35, 0x0f37, 0x0f37, 0x0f39, 0x0f39, 0x0f3e, 0x0f3e, 0x0f3f, 0x0f3f, 0x0f71, 0x0f84,
+    0x0f86, 0x0f8b, 0x0f90, 0x0f95, 0x0f97, 0x0f97, 0x0f99, 0x0fad, 0x0fb1, 0x0fb7, 0x0fb9, 0x0fb9,
+    0x20d0, 0x20dc, 0x20e1, 0x20e1, 0x302a, 0x302f, 0x3099, 0x3099, 0x309a, 0x309a,
+]);
+const DIGIT = new Uint16Array([
+    0x0030, 0x0039, 0x0660, 0x0669, 0x06f0, 0x06f9, 0x0966, 0x096f, 0x09e6, 0x09ef, 0x0a66, 0x0a6f,
+    0x0ae6, 0x0aef, 0x0b66, 0x0b6f, 0x0be7, 0x0bef, 0x0c66, 0x0c6f, 0x0ce6, 0x0cef, 0x0d66, 0x0d6f,
+    0x0e50, 0x0e59, 0x0ed0, 0x0ed9, 0x0f20, 0x0f29,
+]);
+const EXTENDER = new Uint16Array([
+    0x00b7, 0x00b7, 0x02d0, 0x02d0, 0x02d1, 0x02d1, 0x0387, 0x0387, 0x0640, 0x0640, 0x0e46, 0x0e46,
+    0x0ec6, 0x0ec6, 0x3005, 0x3005, 0x3031, 0x3035, 0x309d, 0x309e, 0x30fc, 0x30fe,
+]);
+/** Whether `c` is in one of `table`'s ranges. */
+function inTable(table, c) {
+    for (let i = 0; i < table.length; i += 2) {
+        if (c >= table[i] && c <= table[i + 1]) {
+            return true;
+        }
+    }
+    return false;
+}
+const isLetter = (c) => inTable(LETTER, c);
+/**
+ * As AvmCore::isXMLName: a letter or _, then letters, digits, ., -, _,
+ * combining characters and extenders. E4X excludes ':', as Mozilla's tests
+ * have it.
+ */
+export function isXMLName(s) {
+    if (!s.length) {
+        return false;
+    }
+    const first = s.charCodeAt(0);
+    if (!isLetter(first) && first !== 0x5f) {
+        return false;
+    }
+    for (let i = 1; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (inTable(DIGIT, c) ||
+            isLetter(c) ||
+            c === 0x2e ||
+            c === 0x2d ||
+            c === 0x5f ||
+            inTable(COMBINING, c) ||
+            inTable(EXTENDER, c)) {
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+/** As String::isSpace: space, tab, LF and CR, the XML whitespace. */
+export function isSpace(c) {
+    return c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d;
+}

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

@@ -0,0 +1,38 @@
+// How E4X writes text as XML: an element's text and an attribute's value
+// escaped, as esc_xelem and esc_xattr and XML's own toXMLString write them.
+const XML_ELEMENT = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    "\0": "&#x0;",
+};
+const XML_ATTRIBUTE = {
+    "&": "&amp;",
+    "<": "&lt;",
+    '"': "&quot;",
+    "\n": "&#xA;",
+    "\r": "&#xD;",
+    "\t": "&#x9;",
+    "\0": "&#x0;",
+};
+/** As AvmCore::EscapeElementValue: & < > escaped, and without whitespace around it if `trim`. */
+export function escapeElementValue(s, trim) {
+    let t = s;
+    if (trim) {
+        let start = 0;
+        let end = s.length;
+        while (end > 0 && isXMLSpace(s.charCodeAt(end - 1))) {
+            end--;
+        }
+        while (start < end && isXMLSpace(s.charCodeAt(start))) {
+            start++;
+        }
+        t = s.slice(start, end);
+    }
+    return t.replace(/[&<>\0]/g, (c) => XML_ELEMENT[c]);
+}
+/** As AvmCore::EscapeAttributeValue. */
+export function escapeAttributeValue(s) {
+    return s.replace(/[&<"\n\r\t\0]/g, (c) => XML_ATTRIBUTE[c]);
+}
+const isXMLSpace = (c) => c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d;

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

@@ -0,0 +1,204 @@
+// E4X's names: property names coerced to XML names, and the Namespaces
+// and QNames E4X makes and compares.
+//
+// Translated from avmplus' core/XMLObject.cpp, XMLListObject.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 { isXMLName } from "./chars.js";
+import { ATTRIBUTE, ELEMENT, matches } from "./node.js";
+import { ANY, e4x, NAMESPACE_WITH_PREFIX_AND_NO_URI } from "./values.js";
+// Names.
+/** As String::parseIndex: a name's index, or -1. */
+export 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. */
+export 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. */
+export 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. */
+export 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.
+ */
+export 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.
+ */
+export 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. */
+export function getNamespace(ns, list) {
+    for (const ns2 of list) {
+        if (ns2.uri === ns.uri) {
+            return ns2;
+        }
+    }
+    return namespace(NS_Public, ns.uri);
+}
+export const hasPrefix = (ns) => {
+    const p = prefixOf(ns);
+    return p !== undefined && p !== "";
+};