@swf2es/runtime 0.0.0-stage → 0.1.1

package/src/avm2/natives/xml/names.ts

@@ -0,0 +1,256 @@
+// 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 type { AsObject, Value } from "../../descriptors.js";
+import {
+  CONSTANT_Qname,
+  CONSTANT_QnameA,
+  type Multiname,
+  Namespace,
+  NS_Public,
+  namespace,
+  prefixedNamespace,
+  prefixOf,
+  publicNs,
+} from "../../names.js";
+import type { Runtime } from "../../runtime.js";
+import { isXMLName } from "./chars.js";
+import { ATTRIBUTE, ELEMENT, matches, type XMLNode, type XName } 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: string): number {
+  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: XName): number =>
+  n.attribute || n.local === null ? -1 : parseIndex(n.local);
+
+/** Whether `ns` is `other`, prefix, URI and kind, as CoerceE4XMultiname compares them. */
+const sameNamespace = (ns: Namespace | null, other: Namespace): boolean =>
+  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: Runtime, n: XName): XName {
+  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: Multiname): XName {
+  const qualified = mn.kind === CONSTANT_Qname || mn.kind === CONSTANT_QnameA;
+  const all = mn.namespaces;
+  let namespaces: Namespace[] | null;
+  if (qualified) {
+    namespaces = all[0] ? [all[0]] : null;
+  } else {
+    namespaces = all.some((ns) => ns === null) ? null : (all as Namespace[]);
+  }
+
+  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: Runtime, p: Value): XName {
+  if (p === null || p === undefined) {
+    throw rt.error("TypeError", 1010);
+  }
+
+  let s: string;
+  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: string | null = 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: Runtime, v: Value): XName {
+  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: XName, child: XMLNode) =>
+  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: Runtime, uri: Value): Namespace {
+  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: Runtime, prefix: Value, uri: Value): Namespace | null {
+  const u =
+    typeof uri === "object" && uri !== null && uri.$local !== undefined && uri.$ns
+      ? (uri.$ns.uri as string)
+      : 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: Runtime, args: Value[]): Namespace {
+  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: Runtime, node: XMLNode): AsObject {
+  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: Runtime, name: Value): XName {
+  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: Namespace, list: Namespace[]): Namespace {
+  for (const ns2 of list) {
+    if (ns2.uri === ns.uri) {
+      return ns2;
+    }
+  }
+
+  return namespace(NS_Public, ns.uri);
+}
+
+export const hasPrefix = (ns: Namespace) => {
+  const p = prefixOf(ns);
+  return p !== undefined && p !== "";
+};

package/src/avm2/natives/xml/node.ts

@@ -0,0 +1,339 @@
+// 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 type { AsObject, Value } from "../../descriptors.js";
+import { type Namespace, 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;
+
+/**
+ * A name as E4X matches one against a node's, as avmplus' Multiname: its
+ * local name, null for any; its namespaces, null for any; whether it names
+ * attributes; and whether it is qualified, one namespace given, as ns::*,
+ * not a set of them, as a plain *.
+ */
+export interface XName {
+  local: string | null;
+  namespaces: Namespace[] | null;
+  attribute: boolean;
+  qualified: boolean;
+}
+
+export class XMLNode {
+  parent: XMLNode | null = null;
+  /** Its local name; null for a node without one (text, CDATA, a comment). */
+  name: string | null = null;
+  /** Its name's namespace, when it has a name: public for none. */
+  ns: Namespace = publicNs;
+  /** The value of a node that is not an element. */
+  value = "";
+  /** An element's attributes, in order. */
+  readonly attributes: XMLNode[] = [];
+  /** The namespaces an element declares. */
+  readonly namespaces: Namespace[] = [];
+  /** An element's children. */
+  readonly children: XMLNode[] = [];
+  /** A function called on changes to an element, as setNotification sets it. */
+  notification: Value = null;
+  /** The XML object that stands for this node, once made. */
+  object: AsObject | null = null;
+
+  constructor(
+    readonly kind: number,
+    value = "",
+  ) {
+    this.value = value;
+  }
+
+  /** As setQName: a name in no namespace, or the public one, is kept as public. */
+  setName(name: string | null, ns: Namespace | null): void {
+    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(): XName | null {
+    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: XMLNode): void {
+    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: Namespace | null): void {
+    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: Namespace): number {
+    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(): Namespace[] {
+    const list: Namespace[] = [];
+    for (let y: XMLNode | null = 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(): boolean {
+    if (this.kind & (COMMENT | PROCESSING_INSTRUCTION)) {
+      return false;
+    }
+
+    return !this.children.some((c) => c.kind === ELEMENT);
+  }
+
+  hasComplexContent(): boolean {
+    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(): number {
+    if (!this.parent || this.kind === ATTRIBUTE) {
+      return -1;
+    }
+
+    return this.parent.children.indexOf(this);
+  }
+
+  nodeKind(): string {
+    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: number): void {
+    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: boolean, ignoreProcessingInstructions: boolean): XMLNode {
+    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: XMLNode): boolean {
+    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: XName, node: XMLNode | null): boolean {
+  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/src/avm2/natives/xml/operators.ts

@@ -0,0 +1,90 @@
+// 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 type { AsObject, Value } from "../../descriptors.js";
+import type { Runtime } from "../../runtime.js";
+import { ATTRIBUTE, CDATA, TEXT, type XMLNode } 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: Runtime, list: AsObject, v: Value): boolean {
+  const nodes: XMLNode[] = list.$nodes;
+  if (v === undefined && nodes.length === 0) {
+    return true;
+  }
+
+  if (isList(v)) {
+    const other: XMLNode[] = 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: Runtime, a: Value, b: Value): boolean | undefined {
+  if (isList(a)) {
+    return listEquals(rt, a, b);
+  }
+
+  if (isList(b)) {
+    return listEquals(rt, b, a);
+  }
+
+  if (isXML(a) && isXML(b)) {
+    const x: XMLNode = a.$node;
+    const y: XMLNode = 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: Runtime, a: Value, b: Value): Value {
+  if ((isXML(a) || isList(a)) && (isXML(b) || isList(b))) {
+    const list = newList(rt);
+    append(list, a);
+    append(list, b);
+    return list;
+  }
+
+  return undefined;
+}