@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,191 @@
+// E4X's strings: XML and XMLList as toString and toXMLString write them,
+// pretty printed or not.
+//
+// Translated from avmplus' core/XMLObject.cpp and XMLListObject.cpp, this
+// file is subject to the Mozilla Public License, v. 2.0:
+// http://mozilla.org/MPL/2.0/.
+import { prefixedNamespace, prefixOf } from "../../names.js";
+import { escapeAttributeValue, escapeElementValue } from "./escape.js";
+import { getNamespace, hasPrefix } from "./names.js";
+import { ATTRIBUTE, CDATA, COMMENT, ELEMENT, PROCESSING_INSTRUCTION, TEXT, } from "./node.js";
+import { e4x, okToPrettyPrint } from "./values.js";
+// Strings.
+/** As GenerateUniquePrefix: "" if no namespace has it, else the first of aaa to zzz none has. */
+function uniquePrefix(ns, namespaces) {
+    if (!namespaces.some((n) => prefixOf(n) === "")) {
+        return prefixedNamespace("", ns.uri ?? "");
+    }
+    const a = 0x61;
+    for (let x1 = 0; x1 < 26; x1++) {
+        for (let x2 = 0; x2 < 26; x2++) {
+            for (let x3 = 0; x3 < 26; x3++) {
+                const p = String.fromCharCode(a + x1, a + x2, a + x3);
+                if (!namespaces.some((n) => prefixOf(n) === p)) {
+                    return prefixedNamespace(p, ns.uri ?? "");
+                }
+            }
+        }
+    }
+    return ns;
+}
+/** As XMLObject::__toXMLString, E4X 10.2.1: `node` as XML text, into `out`. */
+function toXMLStringOf(rt, node, ancestors, indentLevel, out) {
+    const e = e4x(rt);
+    const pretty = okToPrettyPrint(e);
+    if (pretty && indentLevel > 0) {
+        out.push(" ".repeat(indentLevel));
+    }
+    switch (node.kind) {
+        case TEXT:
+            out.push(escapeElementValue(node.value, pretty));
+            return;
+        case CDATA:
+            out.push(`<![CDATA[${node.value}]]>`);
+            return;
+        case ATTRIBUTE:
+            out.push(escapeAttributeValue(node.value));
+            return;
+        case COMMENT:
+            out.push(`<!--${node.value}-->`);
+            return;
+        case PROCESSING_INSTRUCTION:
+            out.push(`<?${node.name} ${node.value}?>`);
+            return;
+    }
+    // The namespaces in scope not already among the ancestors'.
+    const origLength = ancestors.length;
+    for (const ns of node.inScopeNamespaces()) {
+        if (!ancestors.some((ns2) => ns.uri === ns2.uri && prefixOf(ns) === prefixOf(ns2))) {
+            ancestors.push(ns);
+        }
+    }
+    // This node's namespace, and its attributes', each with a prefix.
+    let own = getNamespace(node.ns, ancestors);
+    if (prefixOf(own) === undefined) {
+        own = uniquePrefix(own, ancestors);
+        ancestors.push(own);
+    }
+    for (const a of node.attributes) {
+        if (a.name !== null) {
+            const ns = getNamespace(a.ns, ancestors);
+            if (prefixOf(ns) === undefined) {
+                ancestors.push(uniquePrefix(ns, ancestors));
+            }
+        }
+    }
+    const prefix = prefixOf(own);
+    const qualified = prefix !== "" ? `${prefix}:${node.name}` : node.name;
+    out.push("<", qualified);
+    for (const a of node.attributes) {
+        if (a.name !== null) {
+            out.push(" ");
+            const ns = getNamespace(a.ns, ancestors);
+            if (hasPrefix(ns)) {
+                out.push(prefixOf(ns), ":");
+            }
+            out.push(a.name, '="', escapeAttributeValue(a.value), '"');
+        }
+    }
+    for (let i = origLength; i < ancestors.length; i++) {
+        const ns = ancestors[i];
+        if (ns.uri !== "") {
+            const p = prefixOf(ns);
+            out.push(p !== "" ? ` xmlns:${p}="` : ' xmlns="', ns.uri ?? "", '"');
+        }
+    }
+    const children = node.children;
+    if (!children.length) {
+        out.push("/>");
+        return;
+    }
+    out.push(">");
+    const indentChildren = children.length > 1 || (children[0].kind & ~(TEXT | CDATA)) !== 0;
+    const nextIndentLevel = e.prettyPrinting && indentChildren ? indentLevel + e.prettyIndent : 0;
+    // The ancestors' namespaces less those whose prefix one here declares
+    // again, so that each is declared where it is shadowed.
+    const scope = [];
+    for (let i = 0; i < ancestors.length; i++) {
+        const first = ancestors[i];
+        if (i < origLength) {
+            let j = origLength;
+            while (j < ancestors.length && prefixOf(ancestors[j]) !== prefixOf(first)) {
+                j++;
+            }
+            if (j === ancestors.length) {
+                scope.push(first);
+            }
+        }
+        else {
+            scope.push(first);
+        }
+    }
+    const scopeLength = scope.length;
+    for (const child of children) {
+        if (pretty && indentChildren) {
+            out.push("\n");
+        }
+        toXMLStringOf(rt, child, scope, nextIndentLevel, out);
+        scope.length = scopeLength;
+    }
+    if (pretty && indentChildren) {
+        out.push("\n");
+        if (indentLevel > 0) {
+            out.push(" ".repeat(indentLevel));
+        }
+    }
+    out.push("</", qualified, ">");
+}
+export function xmlToXMLString(rt, node) {
+    const out = [];
+    toXMLStringOf(rt, node, [], 0, out);
+    return out.join("");
+}
+export function listToXMLString(rt, list) {
+    const out = [];
+    const nodes = list.$nodes;
+    for (let i = 0; i < nodes.length; i++) {
+        if (i) {
+            out.push("\n");
+        }
+        toXMLStringOf(rt, nodes[i], [], 0, out);
+    }
+    return out.join("");
+}
+/** As XMLObject::toString, E4X 10.1.1: a simple node's text, else its XML. */
+export function xmlToString(rt, node) {
+    if (node.kind & (TEXT | CDATA | ATTRIBUTE)) {
+        return node.value;
+    }
+    if (node.hasSimpleContent()) {
+        let s = "";
+        for (const child of node.children) {
+            if (child.kind !== COMMENT && child.kind !== PROCESSING_INSTRUCTION) {
+                s += xmlToString(rt, child);
+            }
+        }
+        return s;
+    }
+    return xmlToXMLString(rt, node);
+}
+export function listHasSimpleContent(nodes) {
+    if (nodes.length === 0) {
+        return true;
+    }
+    if (nodes.length === 1) {
+        return nodes[0].hasSimpleContent();
+    }
+    return !nodes.some((n) => n.kind === ELEMENT);
+}
+export function listToString(rt, list) {
+    const nodes = list.$nodes;
+    if (listHasSimpleContent(nodes)) {
+        let s = "";
+        for (const node of nodes) {
+            if (node.kind !== COMMENT && node.kind !== PROCESSING_INSTRUCTION) {
+                s += xmlToString(rt, node);
+            }
+        }
+        return s;
+    }
+    return listToXMLString(rt, list);
+}

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

@@ -0,0 +1,122 @@
+// E4X's values: XML and XMLList objects over the tree's nodes (node.ts),
+// each runtime's XML settings, and the errors E4X throws. An XML value
+// stands for one node, and is the same object each time, so that XML
+// values compare by the node they are; an XMLList holds nodes, and the
+// object and name it was got from, which assignments to it write back to.
+//
+// Translated from avmplus' core/XMLObject.cpp, XMLListObject.cpp and
+// XMLClass.cpp, this file is subject to the Mozilla Public License, v. 2.0:
+// http://mozilla.org/MPL/2.0/.
+import { PROCESSING_INSTRUCTION } from "./node.js";
+import * as P from "./parser.js";
+// Error numbers, as avmplus' kXML* errors.
+export const PREFIX_NOT_BOUND = 1083;
+export const BAD_QNAME = 1084;
+export const UNTERMINATED_ELEMENT_TAG = 1085;
+export const ONLY_ONE_ITEM_LISTS = 1086;
+export const ASSIGNMENT_TO_INDEXED_XML = 1087;
+export const MARKUP_MUST_BE_WELL_FORMED = 1088;
+export const ASSIGNMENT_ONE_ITEM_LISTS = 1089;
+export const NAMESPACE_WITH_PREFIX_AND_NO_URI = 1098;
+export const DUPLICATE_ATTRIBUTE = 1104;
+export const INVALID_NAME = 1117;
+export const ILLEGAL_CYCLICAL_LOOP = 1118;
+/** What each of the parser's errors throws. */
+export const PARSE_ERRORS = {
+    [P.MALFORMED_ELEMENT]: 1090,
+    [P.UNTERMINATED_CDATA]: 1091,
+    [P.UNTERMINATED_XML_DECLARATION]: 1092,
+    [P.UNTERMINATED_DOCTYPE]: 1093,
+    [P.UNTERMINATED_COMMENT]: 1094,
+    [P.UNTERMINATED_ATTRIBUTE_VALUE]: 1095,
+    [P.UNTERMINATED_PROCESSING_INSTRUCTION]: 1097,
+};
+export const XML_1998 = "http://www.w3.org/XML/1998/namespace";
+/** Any name in any namespace: an XMLList's target property when it has none. */
+export const ANY = { local: null, namespaces: null, attribute: false, qualified: false };
+const states = new WeakMap();
+export function e4x(rt) {
+    let state = states.get(rt);
+    if (!state) {
+        state = {
+            ignoreComments: true,
+            ignoreProcessingInstructions: true,
+            ignoreWhitespace: true,
+            prettyPrinting: true,
+            prettyIndent: 2,
+            xml: rt.builtinClass("XML").$it,
+            list: rt.builtinClass("XMLList").$it,
+            qname: rt.builtinClass("QName").$it,
+        };
+        states.set(rt, state);
+    }
+    return state;
+}
+export const okToPrettyPrint = (e) => e.prettyPrinting && e.prettyIndent >= 0;
+// XML and XMLList values.
+export const isXML = (v) => typeof v === "object" && v !== null && v.$node !== undefined;
+export const isList = (v) => typeof v === "object" && v !== null && v.$nodes !== undefined;
+/** The XML object that stands for `node`, the same each time. */
+export function xmlOf(rt, node) {
+    let o = node.object;
+    if (!o) {
+        o = e4x(rt).xml.instance();
+        o.$node = node;
+        node.object = o;
+    }
+    return o;
+}
+/** A new XMLList, got from `target` by `property`. */
+export function newList(rt, target = null, property = ANY) {
+    const o = e4x(rt).list.instance();
+    o.$nodes = [];
+    o.$target = target;
+    o.$targetProperty = property;
+    o.$appended = false;
+    return o;
+}
+/** As _appendNode. */
+export function appendNode(list, node) {
+    list.$nodes.push(node);
+    list.$appended = true;
+}
+/** As XMLListObject::_append: an XMLList's nodes, and its target, or an XML value's node. */
+export function append(list, v) {
+    if (isList(v)) {
+        list.$target = v.$target;
+        list.$targetProperty = v.$targetProperty;
+        list.$appended = false;
+        list.$nodes.push(...v.$nodes);
+    }
+    else if (isXML(v)) {
+        list.$appended = true;
+        list.$nodes.push(v.$node);
+    }
+}
+/**
+ * As fixTargetObject: once nodes were appended, the list's target is the
+ * last one's parent, and its target property the last one's name.
+ */
+export function fixTarget(rt, list) {
+    const nodes = list.$nodes;
+    if (!list.$appended || !nodes.length) {
+        return;
+    }
+    const v = nodes[nodes.length - 1];
+    if (v.parent) {
+        const target = list.$target;
+        if (isXML(target) && target.$node !== v.parent) {
+            list.$target = xmlOf(rt, v.parent);
+        }
+    }
+    else {
+        list.$target = null;
+    }
+    if (v.kind !== PROCESSING_INSTRUCTION) {
+        const name = v.xname();
+        if (name) {
+            list.$targetProperty = name;
+        }
+    }
+    list.$appended = false;
+}