@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,272 @@
+// E4X's tree, as avmplus' E4XNode: elements with their attributes, the
+// namespaces they declare and their children; text, CDATA, comments,
+// processing instructions and attributes with their values. Each node has
+// its parent, and one XML object stands for it (see values.ts), so that XML
+// values compare by the node they are.
+//
+// Translated from avmplus' core/E4XNode.cpp, this file is subject to the
+// Mozilla Public License, v. 2.0: http://mozilla.org/MPL/2.0/.
+import { NS_Public, prefixedNamespace, prefixOf, publicNs } from "../../names.js";
+// The node kinds, as E4XNode's NodeTypes: bits, so a set of them is a mask.
+export const ATTRIBUTE = 0x02;
+export const TEXT = 0x04;
+/** Text, written back as CDATA. */
+export const CDATA = 0x08;
+export const COMMENT = 0x10;
+export const PROCESSING_INSTRUCTION = 0x20;
+export const ELEMENT = 0x40;
+export class XMLNode {
+    kind;
+    parent = null;
+    /** Its local name; null for a node without one (text, CDATA, a comment). */
+    name = null;
+    /** Its name's namespace, when it has a name: public for none. */
+    ns = publicNs;
+    /** The value of a node that is not an element. */
+    value = "";
+    /** An element's attributes, in order. */
+    attributes = [];
+    /** The namespaces an element declares. */
+    namespaces = [];
+    /** An element's children. */
+    children = [];
+    /** A function called on changes to an element, as setNotification sets it. */
+    notification = null;
+    /** The XML object that stands for this node, once made. */
+    object = null;
+    constructor(kind, value = "") {
+        this.kind = kind;
+        this.value = value;
+    }
+    /** As setQName: a name in no namespace, or the public one, is kept as public. */
+    setName(name, ns) {
+        this.name = name;
+        if (!ns || (ns.kind === NS_Public && ns.uri === "")) {
+            this.ns = publicNs;
+        }
+        else {
+            this.ns = ns;
+        }
+    }
+    /**
+     * As getQName: its name, if it has one; qualified unless public, which
+     * E4X then looks up in the default namespace too.
+     */
+    xname() {
+        if (this.name === null) {
+            return null;
+        }
+        return {
+            local: this.name,
+            namespaces: [this.ns],
+            attribute: this.kind === ATTRIBUTE,
+            qualified: this.ns !== publicNs,
+        };
+    }
+    /** As _append: `child` its last child. */
+    append(child) {
+        child.parent = this;
+        this.children.push(child);
+    }
+    /**
+     * As ElementE4XNode::_addInScopeNamespace: declare `ns` here, replacing
+     * one with its prefix but another URI; the name, and attributes', in a
+     * namespace with its prefix lose the prefix.
+     */
+    addInScopeNamespace(ns) {
+        if (this.kind !== ELEMENT || !ns || prefixOf(ns) === undefined) {
+            return;
+        }
+        const prefix = prefixOf(ns);
+        if (prefix === "" && this.name !== null && this.ns.uri === "") {
+            return;
+        }
+        let index = -1;
+        for (let i = 0; i < this.namespaces.length; i++) {
+            if (prefixOf(this.namespaces[i]) === prefix) {
+                index = i;
+            }
+        }
+        if (index !== -1 && this.namespaces[index].uri !== ns.uri) {
+            this.namespaces.splice(index, 1);
+        }
+        this.namespaces.push(ns);
+        if (this.name !== null && prefixOf(this.ns) === prefix) {
+            this.setName(this.name, prefixedNamespace(undefined, this.ns.uri ?? ""));
+        }
+        for (const attribute of this.attributes) {
+            if (attribute.name !== null && prefixOf(attribute.ns) === prefix) {
+                attribute.setName(attribute.name, prefixedNamespace(undefined, attribute.ns.uri ?? ""));
+            }
+        }
+    }
+    /**
+     * As FindMatchingNamespace: the index of a declared namespace with `ns`'s
+     * URI and, if it has one, its prefix; -1 if none, or if one with its URI
+     * has the empty prefix.
+     */
+    findMatchingNamespace(ns) {
+        for (let i = 0; i < this.namespaces.length; i++) {
+            const ns2 = this.namespaces[i];
+            if (ns2.uri === ns.uri) {
+                if (prefixOf(ns) === undefined) {
+                    return i;
+                }
+                if (prefixOf(ns2) === "") {
+                    return -1;
+                }
+                if (prefixOf(ns2) === prefixOf(ns)) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+    /**
+     * As BuildInScopeNamespaceList: the namespaces declared here and up the
+     * ancestors, the nearest first, each prefix (or, without one, URI) once.
+     */
+    inScopeNamespaces() {
+        const list = [];
+        for (let y = this; y; y = y.parent) {
+            for (const ns1 of y.namespaces) {
+                const p1 = prefixOf(ns1);
+                const seen = list.some((ns2) => p1 === undefined ? ns1.uri === ns2.uri : p1 === prefixOf(ns2));
+                if (!seen) {
+                    list.push(ns1);
+                }
+            }
+        }
+        return list;
+    }
+    hasSimpleContent() {
+        if (this.kind & (COMMENT | PROCESSING_INSTRUCTION)) {
+            return false;
+        }
+        return !this.children.some((c) => c.kind === ELEMENT);
+    }
+    hasComplexContent() {
+        if (this.kind & (TEXT | COMMENT | PROCESSING_INSTRUCTION | ATTRIBUTE | CDATA)) {
+            return false;
+        }
+        return this.children.some((c) => c.kind === ELEMENT);
+    }
+    /** Its index among its parent's children, or -1 for none or an attribute. */
+    childIndex() {
+        if (!this.parent || this.kind === ATTRIBUTE) {
+            return -1;
+        }
+        return this.parent.children.indexOf(this);
+    }
+    nodeKind() {
+        switch (this.kind) {
+            case ATTRIBUTE:
+                return "attribute";
+            case TEXT:
+            case CDATA:
+                return "text";
+            case COMMENT:
+                return "comment";
+            case PROCESSING_INSTRUCTION:
+                return "processing-instruction";
+            default:
+                return "element";
+        }
+    }
+    /** As _deleteByIndex: child i removed, no longer its child. */
+    deleteByIndex(i) {
+        if (i >= 0 && i < this.children.length) {
+            const child = this.children[i];
+            if (child) {
+                child.parent = null;
+            }
+            this.children.splice(i, 1);
+        }
+    }
+    /**
+     * As _deepCopy: a copy of this node and all below it, with no parent;
+     * comments and processing instructions the settings ignore left out.
+     */
+    deepCopy(ignoreComments, ignoreProcessingInstructions) {
+        const x = new XMLNode(this.kind, this.value);
+        if (this.name !== null) {
+            x.setName(this.name, this.ns);
+        }
+        if (this.kind === ELEMENT) {
+            x.namespaces.push(...this.namespaces);
+            for (const a of this.attributes) {
+                const b = a.deepCopy(ignoreComments, ignoreProcessingInstructions);
+                b.parent = x;
+                x.attributes.push(b);
+            }
+            for (const child of this.children) {
+                if ((child.kind === COMMENT && ignoreComments) ||
+                    (child.kind === PROCESSING_INSTRUCTION && ignoreProcessingInstructions)) {
+                    continue;
+                }
+                const c = child.deepCopy(ignoreComments, ignoreProcessingInstructions);
+                c.parent = x;
+                x.children.push(c);
+            }
+        }
+        return x;
+    }
+    /**
+     * As _equals: the same kind, name, attributes, value and children. The
+     * namespaces declared are not compared: those that matter are in names.
+     */
+    equals(v) {
+        if (this === v) {
+            return true;
+        }
+        if (this.kind !== v.kind) {
+            return false;
+        }
+        const name = this.xname();
+        if (name ? v.name === null || !matches(name, v) : v.name !== null) {
+            return false;
+        }
+        if (this.attributes.length !== v.attributes.length ||
+            this.children.length !== v.children.length ||
+            this.value !== v.value) {
+            return false;
+        }
+        for (const a1 of this.attributes) {
+            if (!v.attributes.some((a2) => a1.equals(a2))) {
+                return false;
+            }
+        }
+        for (let i = 0; i < this.children.length; i++) {
+            if (!this.children[i].equals(v.children[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+/**
+ * As Multiname::matches: whether `name` names `node`. With a name, the
+ * node is an attribute if the name names attributes; an unqualified any
+ * name matches every node, one without a name too; otherwise the local
+ * names are the same, and the node's namespace is one of the name's, by
+ * URI and kind, if the name is not in any namespace.
+ */
+export function matches(name, node) {
+    const named = node !== null && node.name !== null;
+    if (named && name.attribute !== (node.kind === ATTRIBUTE)) {
+        return false;
+    }
+    if (name.local === null && !name.qualified) {
+        return true;
+    }
+    if (!named) {
+        return false;
+    }
+    if (name.local !== null && name.local !== node.name) {
+        return false;
+    }
+    if (name.namespaces === null) {
+        return true;
+    }
+    return name.namespaces.some((ns) => ns.uri === node.ns.uri && ns.kind === node.ns.kind);
+}

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

@@ -0,0 +1,69 @@
+// E4X's operators on XML and XMLList: == and +.
+//
+// Translated from avmplus' core/XMLObject.cpp, XMLListObject.cpp and E4X's
+// parts of AvmCore.cpp, this file is subject to the Mozilla Public License,
+// v. 2.0: http://mozilla.org/MPL/2.0/.
+import { ATTRIBUTE, CDATA, TEXT } from "./node.js";
+import { xmlToString } from "./strings.js";
+import { append, isList, isXML, newList, xmlOf } from "./values.js";
+// 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. */
+export 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. */
+export 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;
+}

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

@@ -0,0 +1,356 @@
+// XML text into tags, as avmplus' XMLParser: a tokenizer, not a validating
+// parser, whose leniency and errors are avmplus', which E4X's are. The tree
+// is made from its tags in build.ts.
+//
+// Translated from avmplus' core/XMLParser16.cpp, this file is subject to the
+// Mozilla Public License, v. 2.0: http://mozilla.org/MPL/2.0/.
+import { isSpace } from "./chars.js";
+// The tags, as XMLTag's node types.
+export const TAG_ELEMENT = 1;
+export const TAG_TEXT = 3;
+export const TAG_CDATA = 4;
+export const TAG_PROCESSING_INSTRUCTION = 7;
+export const TAG_COMMENT = 8;
+export const TAG_DOCTYPE = 10;
+export const TAG_XML_DECLARATION = 13;
+// What getNext gives, as XMLParser's status codes: a tag, the end, or the
+// error E4X throws for each (see PARSE_ERRORS in values.ts).
+export const OK = 0;
+export const END = -1;
+export const UNTERMINATED_CDATA = -2;
+export const UNTERMINATED_XML_DECLARATION = -3;
+export const UNTERMINATED_DOCTYPE = -4;
+export const UNTERMINATED_COMMENT = -5;
+export const MALFORMED_ELEMENT = -6;
+export const UNTERMINATED_ATTRIBUTE_VALUE = -8;
+export const UNTERMINATED_PROCESSING_INSTRUCTION = -10;
+export class XMLTag {
+    type = 0;
+    /** An element's name (with "/" first for an end tag), or the text of any other tag. */
+    text = "";
+    /** Whether an element closed itself, as <a/>. */
+    empty = false;
+    /** An element's attributes, name then value. */
+    attributes = [];
+    reset() {
+        this.type = 0;
+        this.text = "";
+        this.empty = false;
+        this.attributes = [];
+    }
+}
+/** The entities XMLParser knows: the XML ones, and nbsp. */
+const ENTITIES = {
+    amp: "&",
+    quot: '"',
+    apos: "'",
+    lt: "<",
+    gt: ">",
+    nbsp: "\u00a0",
+};
+export class XMLParser {
+    pos = 0;
+    ignoreWhite = false;
+    condenseWhite = false;
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    /** As XMLParser::parse: from the start, whitespace-only text left out if `ignoreWhite`. */
+    parse(ignoreWhite) {
+        this.pos = 0;
+        this.ignoreWhite = ignoreWhite;
+    }
+    setCondenseWhite(condense) {
+        this.condenseWhite = condense;
+    }
+    atEnd() {
+        return this.pos >= this.text.length;
+    }
+    /** Past whitespace: false at the end. */
+    skipWhiteSpace() {
+        while (!this.atEnd() && isSpace(this.text.charCodeAt(this.pos))) {
+            this.pos++;
+        }
+        return !this.atEnd();
+    }
+    /** Whether the text at `at` starts with `s`, ignoring ASCII case, as matchesLatin1_caseless. */
+    matchesCaseless(s, at) {
+        return this.text.slice(at, at + s.length).toLowerCase() === s.toLowerCase();
+    }
+    /** The next tag into `tag`: OK, END, or an error. */
+    getNext(tag) {
+        const str = this.text;
+        tag.reset();
+        if (this.atEnd()) {
+            return END;
+        }
+        // With ignoreWhite, no text nodes of whitespace alone.
+        if (this.ignoreWhite && !this.skipWhiteSpace()) {
+            return END;
+        }
+        let start = this.pos;
+        if (str[this.pos] !== "<") {
+            // Text, up to the next < or the end.
+            let next = str.indexOf("<", this.pos + 1);
+            if (next < 0) {
+                next = str.length;
+            }
+            this.pos = next;
+            tag.text = this.unescape(start, next);
+            if (this.ignoreWhite && this.condenseWhite) {
+                tag.text = trimWhitespace(tag.text);
+            }
+            tag.type = TAG_TEXT;
+            return OK;
+        }
+        if (this.matchesCaseless("<?xml ", start)) {
+            const end = str.indexOf("?>", start + 6);
+            if (end >= 0) {
+                tag.text = str.slice(start + 2, end);
+                this.pos = end + 2;
+                tag.type = TAG_XML_DECLARATION;
+                return OK;
+            }
+            return UNTERMINATED_XML_DECLARATION;
+        }
+        if (this.matchesCaseless("<!DOCTYPE", start)) {
+            // Up to its >, past any <...> within it.
+            let depth = 0;
+            let end = start + 1;
+            while (!this.atEnd()) {
+                const ch = str[end++];
+                if (ch === "<") {
+                    depth++;
+                }
+                else if (ch === ">") {
+                    if (!depth) {
+                        tag.text = str.slice(start, end);
+                        tag.type = TAG_DOCTYPE;
+                        this.pos = end;
+                        return OK;
+                    }
+                    depth--;
+                }
+                this.pos = end;
+            }
+            return UNTERMINATED_DOCTYPE;
+        }
+        if (this.matchesCaseless("<![CDATA[", start)) {
+            start += 9;
+            const end = str.indexOf("]]>", start);
+            if (end >= 0) {
+                tag.text = str.slice(start, end);
+                tag.type = TAG_CDATA;
+                this.pos = end + 3;
+                return OK;
+            }
+            return UNTERMINATED_CDATA;
+        }
+        if (str.startsWith("<?", start)) {
+            start += 2;
+            const end = str.indexOf("?>", start);
+            if (end >= 0) {
+                tag.text = str.slice(start, end);
+                tag.type = TAG_PROCESSING_INSTRUCTION;
+                this.pos = end + 2;
+                return OK;
+            }
+            return UNTERMINATED_PROCESSING_INSTRUCTION;
+        }
+        start = ++this.pos;
+        if (str.startsWith("!--", start)) {
+            start += 3;
+            const end = str.indexOf("-->", start);
+            if (end >= 0) {
+                tag.text = str.slice(start, end);
+                tag.type = TAG_COMMENT;
+                this.pos = end + 3;
+                return OK;
+            }
+            return UNTERMINATED_COMMENT;
+        }
+        // An element: its name, up to >, whitespace or />.
+        start = this.pos;
+        while (!this.atEnd()) {
+            const ch = str[this.pos];
+            if (ch === ">" || isSpace(ch.charCodeAt(0))) {
+                break;
+            }
+            if (ch === "/" && this.pos < str.length - 1 && str[this.pos + 1] === ">") {
+                break;
+            }
+            this.pos++;
+        }
+        if (this.atEnd() || this.pos === start) {
+            return MALFORMED_ELEMENT;
+        }
+        tag.text = this.unescape(start, this.pos);
+        tag.type = TAG_ELEMENT;
+        // Its attributes.
+        let ch = "";
+        for (;;) {
+            if (!this.skipWhiteSpace()) {
+                return MALFORMED_ELEMENT;
+            }
+            ch = str[this.pos];
+            if (ch === ">") {
+                break;
+            }
+            if (ch === "/" && this.pos < str.length - 1 && str[this.pos + 1] === ">") {
+                tag.empty = true;
+                ch = str[++this.pos];
+                break;
+            }
+            start = this.pos;
+            while (!isSpace(ch.charCodeAt(0)) && ch !== "=" && ch !== ">") {
+                this.pos++;
+                if (this.atEnd()) {
+                    return MALFORMED_ELEMENT;
+                }
+                ch = str[this.pos];
+            }
+            if (start === this.pos) {
+                return MALFORMED_ELEMENT;
+            }
+            const name = this.unescape(start, this.pos);
+            if (!this.skipWhiteSpace()) {
+                return MALFORMED_ELEMENT;
+            }
+            if (str[this.pos++] !== "=") {
+                return MALFORMED_ELEMENT;
+            }
+            if (!this.skipWhiteSpace()) {
+                return MALFORMED_ELEMENT;
+            }
+            const delimiter = str[this.pos++];
+            if (delimiter !== '"' && delimiter !== "'") {
+                return MALFORMED_ELEMENT;
+            }
+            // Up to the closing quote; < is not allowed within.
+            start = this.pos;
+            ch = "";
+            while (ch !== delimiter) {
+                if (this.atEnd() || ch === "<") {
+                    return UNTERMINATED_ATTRIBUTE_VALUE;
+                }
+                ch = str[this.pos++];
+            }
+            tag.attributes.push(name, this.unescape(start, this.pos - 1));
+        }
+        if (ch === ">") {
+            this.pos++;
+        }
+        return OK;
+    }
+    /**
+     * As XMLParser::unescape: [start, last) with its entity and character
+     * references decoded: &#dd; and &#xhh; up to 0xFFFF, and ENTITIES. An &
+     * without a ; ends the decoding; one that is not a known reference is
+     * kept as it is.
+     */
+    unescape(start, last) {
+        const str = this.text;
+        if (start === last) {
+            return "";
+        }
+        let bgn = str.indexOf("&", start);
+        if (bgn < 0 || bgn >= last) {
+            return str.slice(start, last);
+        }
+        let dest = "";
+        let end = start;
+        while (bgn >= start && bgn < last) {
+            const ampBgn = bgn;
+            const ampEnd = str.indexOf(";", ++bgn);
+            if (ampEnd < 0 || ampEnd >= last) {
+                break;
+            }
+            dest += str.slice(end, bgn - 1);
+            end = ampEnd;
+            let len = end - bgn;
+            let ok = true;
+            if (len >= 2) {
+                if (str[bgn] === "#") {
+                    let ch = str.charCodeAt(++bgn);
+                    len--;
+                    let base = 10;
+                    if (len >= 2 && ch === 0x78) {
+                        base = 16;
+                        bgn++;
+                        len--;
+                    }
+                    if (len > 0) {
+                        let value = 0;
+                        while (len-- && ok) {
+                            ch = str.charCodeAt(bgn++);
+                            if (ch >= 0x41 && ch <= 0x46) {
+                                ch -= 7;
+                            }
+                            else if (ch >= 0x61 && ch <= 0x66) {
+                                ch -= 0x61 - 0x41 + 7;
+                            }
+                            ch -= 0x30;
+                            if (ch >= 0 && ch < base) {
+                                value = value * base + ch;
+                            }
+                            else {
+                                ok = false;
+                            }
+                            if (value > 0xffff) {
+                                ok = false;
+                            }
+                        }
+                        if (ok) {
+                            dest += String.fromCharCode(value);
+                            bgn = ++end;
+                        }
+                    }
+                }
+                else if (len <= 4) {
+                    const entity = ENTITIES[str.slice(bgn, end)];
+                    if (entity !== undefined && Object.hasOwn(ENTITIES, str.slice(bgn, end))) {
+                        dest += entity;
+                        bgn = ++end;
+                    }
+                    else {
+                        ok = false;
+                    }
+                }
+                else {
+                    ok = false;
+                }
+            }
+            else {
+                ok = false;
+            }
+            if (!ok) {
+                // Kept as it is, rather than dropped, which would break content.
+                bgn = end + 1;
+                if (ampBgn < end) {
+                    dest += str.slice(ampBgn, end);
+                }
+            }
+            bgn = str.indexOf("&", bgn);
+            if (bgn >= last) {
+                bgn = -1;
+            }
+        }
+        if (end < last) {
+            dest += str.slice(end, last);
+        }
+        return dest;
+    }
+}
+/** As _condenseWhitespace: `s` without leading and trailing whitespace. */
+function trimWhitespace(s) {
+    let start = 0;
+    while (start < s.length && isSpace(s.charCodeAt(start))) {
+        start++;
+    }
+    let end = s.length - 1;
+    while (end > start && isSpace(s.charCodeAt(end))) {
+        end--;
+    }
+    return s.slice(start, end + 1);
+}