@swf2es/runtime 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,381 @@
+// 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 type { AsObject, Value } from "../../descriptors.js";
+import { type Namespace, prefixedNamespace, prefixOf, publicNs } from "../../names.js";
+import type { Runtime } from "../../runtime.js";
+import { isSpace } from "./chars.js";
+import { hasPrefix, newPrefixedNamespace } from "./names.js";
+import {
+  ATTRIBUTE,
+  CDATA,
+  COMMENT,
+  ELEMENT,
+  matches,
+  PROCESSING_INSTRUCTION,
+  TEXT,
+  XMLNode,
+  type XName,
+} 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: Runtime, text: string, defaultNs: Namespace): XMLNode {
+  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: XMLNode | null = 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 as string;
+          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 as XMLNode;
+        } 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: string, parentName: string, ns: Namespace): boolean {
+  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: Runtime,
+  node: XMLNode,
+  tagName: string,
+  attribute: boolean,
+): [Namespace | null, string] {
+  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: XMLNode | null = 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: string): boolean {
+  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: Runtime, element: XMLNode, tag: P.XMLTag): void {
+  const attributes = tag.attributes;
+  let count = 0;
+  for (let i = 0; i < attributes.length; i += 2) {
+    const name = attributes[i];
+    let ns: Namespace | null = 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() as 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: Runtime, v: Value): AsObject {
+  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: XMLNode;
+  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: XMLNode | null = 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: Runtime, v: Value): AsObject {
+  if (v === null || v === undefined) {
+    throw rt.error("TypeError", v === undefined ? 1010 : 1009);
+  }
+
+  if (isList(v)) {
+    return v;
+  }
+
+  if (isXML(v)) {
+    const node: XMLNode = 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: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    if (!isSpace(s.charCodeAt(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function deepCopy(rt: Runtime, node: XMLNode): XMLNode {
+  const e = e4x(rt);
+  return node.deepCopy(e.ignoreComments, e.ignoreProcessingInstructions);
+}
+
+export function listDeepCopy(rt: Runtime, list: AsObject): AsObject {
+  fixTarget(rt, list);
+  const copy = newList(rt, list.$target, list.$targetProperty);
+  for (const node of list.$nodes as XMLNode[]) {
+    copy.$nodes.push(deepCopy(rt, node));
+  }
+
+  return copy;
+}

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

@@ -0,0 +1,127 @@
+// 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: Uint16Array, c: number): boolean {
+  for (let i = 0; i < table.length; i += 2) {
+    if (c >= table[i] && c <= table[i + 1]) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+const isLetter = (c: number): boolean => 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: string): boolean {
+  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: number): boolean {
+  return c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d;
+}

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

@@ -0,0 +1,46 @@
+// 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: Record<string, string> = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  "\0": "&#x0;",
+};
+
+const XML_ATTRIBUTE: Record<string, string> = {
+  "&": "&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: string, trim: boolean): string {
+  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: string): string {
+  return s.replace(/[&<"\n\r\t\0]/g, (c) => XML_ATTRIBUTE[c]);
+}
+
+const isXMLSpace = (c: number) => c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d;