musicxml-io 0.8.2 → 0.9.1

package/dist/{chunk-53J57HX6.mjs → chunk-M3DUMRQ6.mjs}

@@ -6,7 +6,7 @@ import {
   ValidationException,
   generateId,
   validate
-} from "./chunk-CLONJVWZ.mjs";
+} from "./chunk-T6KNPR45.mjs";
 import {
   bpmToUsPerQuarter,
   buildGridTimeline,
@@ -16,39 +16,168 @@ import {
 } from "./chunk-UMEH3ENQ.mjs";
 
 // src/importers/musicxml.ts
-import { parse as txmlParse } from "txml/txml";
 var _entityMap = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
 var _entityRegex = /&(?:(amp|lt|gt|quot|apos)|#(\d+)|#x([0-9a-fA-F]+));/g;
+var INVALID_XML_CHARS_RE = /[\x00-\x08\x0B\x0C\x0E-\x1F\uFFFE\uFFFF]/g;
+var INVALID_XML_CHARS_TEST = /[\x00-\x08\x0B\x0C\x0E-\x1F\uFFFE\uFFFF]/;
+function decodeCharRef(match, codePoint) {
+  if (codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343) return match;
+  return String.fromCodePoint(codePoint);
+}
 function decodeXmlEntities(s) {
   if (s.indexOf("&") === -1) return s;
-  return s.replace(
+  const decoded = s.replace(
     _entityRegex,
-    (_, named, dec, hex) => named ? _entityMap[named] : dec ? String.fromCharCode(parseInt(dec, 10)) : String.fromCharCode(parseInt(hex, 16))
+    (match, named, dec, hex) => named ? _entityMap[named] : decodeCharRef(match, parseInt(dec ?? hex, dec ? 10 : 16))
   );
-}
-var INVALID_XML_CHARS_RE = /[\x00-\x08\x0B\x0C\x0E-\x1F\uFFFE\uFFFF]/g;
-function decodeTree(nodes) {
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    if (typeof node === "string") {
-      let s = node;
-      if (s.indexOf("&") !== -1) {
-        s = decodeXmlEntities(s);
-      }
-      nodes[i] = s.replace(INVALID_XML_CHARS_RE, "");
+  return INVALID_XML_CHARS_TEST.test(decoded) ? decoded.replace(INVALID_XML_CHARS_RE, "") : decoded;
+}
+var EMPTY_ATTRS = Object.freeze({});
+var GT = 62;
+var SLASH = 47;
+var BANG = 33;
+var QUESTION = 63;
+var EQUALS = 61;
+var DQUOTE = 34;
+var SQUOTE = 39;
+var LBRACKET = 91;
+var RBRACKET = 93;
+function isXmlWhitespace(code) {
+  return code === 32 || code === 10 || code === 9 || code === 13;
+}
+function isWhitespaceOnly(s) {
+  for (let i = 0; i < s.length; i++) {
+    if (!isXmlWhitespace(s.charCodeAt(i))) return false;
+  }
+  return true;
+}
+function parseXml(xml) {
+  const root = [];
+  const stack = [];
+  let children = root;
+  const len = xml.length;
+  let pos = 0;
+  while (pos < len) {
+    const lt = xml.indexOf("<", pos);
+    if (lt === -1) break;
+    if (lt > pos) {
+      let text = xml.slice(pos, lt);
+      if (!isWhitespaceOnly(text)) {
+        text = decodeXmlEntities(text);
+        children.push(
+          INVALID_XML_CHARS_TEST.test(text) ? text.replace(INVALID_XML_CHARS_RE, "") : text
+        );
+      } else if (children.length === 0 && xml.charCodeAt(lt + 1) === SLASH) {
+        children.push(text);
+      }
+    }
+    const c = xml.charCodeAt(lt + 1);
+    if (c === SLASH) {
+      const gt = xml.indexOf(">", lt + 2);
+      if (gt === -1) break;
+      let end = gt;
+      while (end > lt + 2 && isXmlWhitespace(xml.charCodeAt(end - 1))) end--;
+      const name = xml.slice(lt + 2, end);
+      for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i].tagName === name) {
+          stack.length = i;
+          break;
+        }
+      }
+      children = stack.length > 0 ? stack[stack.length - 1].children : root;
+      pos = gt + 1;
+    } else if (c === QUESTION) {
+      const end = xml.indexOf("?>", lt + 2);
+      pos = end === -1 ? len : end + 2;
+    } else if (c === BANG) {
+      if (xml.startsWith("<!--", lt)) {
+        const end = xml.indexOf("-->", lt + 4);
+        pos = end === -1 ? len : end + 3;
+      } else if (xml.startsWith("<![CDATA[", lt)) {
+        const end = xml.indexOf("]]>", lt + 9);
+        let text = xml.slice(lt + 9, end === -1 ? len : end);
+        if (INVALID_XML_CHARS_TEST.test(text)) text = text.replace(INVALID_XML_CHARS_RE, "");
+        children.push(text);
+        pos = end === -1 ? len : end + 3;
+      } else {
+        let i = lt + 2;
+        let depth = 0;
+        while (i < len) {
+          const ch = xml.charCodeAt(i);
+          if (ch === LBRACKET) depth++;
+          else if (ch === RBRACKET) depth--;
+          else if (ch === GT && depth <= 0) break;
+          i++;
+        }
+        pos = i + 1;
+      }
     } else {
-      const attrs = node.attributes;
-      for (const key in attrs) {
-        const v = attrs[key];
-        if (v.indexOf("&") !== -1) {
-          attrs[key] = decodeXmlEntities(v);
+      let i = lt + 1;
+      while (i < len) {
+        const ch = xml.charCodeAt(i);
+        if (ch === GT || ch === SLASH || isXmlWhitespace(ch)) break;
+        i++;
+      }
+      const tagName = xml.slice(lt + 1, i);
+      let attributes = EMPTY_ATTRS;
+      let selfClosing = false;
+      while (i < len) {
+        let ch = xml.charCodeAt(i);
+        while (isXmlWhitespace(ch)) ch = xml.charCodeAt(++i);
+        if (ch === GT) {
+          i++;
+          break;
+        }
+        if (ch === SLASH) {
+          selfClosing = true;
+          i++;
+          continue;
+        }
+        const nameStart = i;
+        while (i < len) {
+          ch = xml.charCodeAt(i);
+          if (ch === EQUALS || ch === GT || ch === SLASH || isXmlWhitespace(ch)) break;
+          i++;
+        }
+        const attrName = xml.slice(nameStart, i);
+        while (isXmlWhitespace(xml.charCodeAt(i))) i++;
+        if (xml.charCodeAt(i) === EQUALS) {
+          i++;
+          while (isXmlWhitespace(xml.charCodeAt(i))) i++;
+          ch = xml.charCodeAt(i);
+          let value;
+          if (ch === DQUOTE || ch === SQUOTE) {
+            const valStart = ++i;
+            while (i < len && xml.charCodeAt(i) !== ch) i++;
+            value = xml.slice(valStart, i);
+            i++;
+          } else {
+            const valStart = i;
+            while (i < len) {
+              ch = xml.charCodeAt(i);
+              if (ch === GT || isXmlWhitespace(ch)) break;
+              i++;
+            }
+            value = xml.slice(valStart, i);
+          }
+          if (attributes === EMPTY_ATTRS) attributes = {};
+          attributes[attrName] = decodeXmlEntities(value);
+        } else if (attrName.length > 0) {
+          if (attributes === EMPTY_ATTRS) attributes = {};
+          attributes[attrName] = "";
         }
       }
-      decodeTree(node.children);
+      const node = { tagName, attributes, children: [] };
+      children.push(node);
+      if (!selfClosing) {
+        stack.push(node);
+        children = node.children;
+      }
+      pos = i;
     }
   }
+  return root;
 }
-var TXML_OPTIONS = { noChildNodes: [] };
 function decodeXmlBytes(data) {
   if (data.length >= 2 && data[0] === 254 && data[1] === 255) {
     return new TextDecoder("utf-16be").decode(data);
@@ -56,6 +185,10 @@ function decodeXmlBytes(data) {
   if (data.length >= 2 && data[0] === 255 && data[1] === 254) {
     return new TextDecoder("utf-16le").decode(data);
   }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+    const hasBom = data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191;
+    return data.toString("utf8", hasBom ? 3 : 0);
+  }
   return new TextDecoder("utf-8").decode(data);
 }
 function parse(input) {
@@ -69,9 +202,10 @@ function parse(input) {
   } else {
     xmlString = input;
   }
-  const cleanedXml = xmlString.replace(/<\?(?!xml\s)[^?]*\?>/g, "");
-  const parsed = txmlParse(cleanedXml, TXML_OPTIONS);
-  decodeTree(parsed);
+  if (INVALID_XML_CHARS_TEST.test(xmlString)) {
+    xmlString = xmlString.replace(INVALID_XML_CHARS_RE, "");
+  }
+  const parsed = parseXml(xmlString);
   let scorePartwiseVersion;
   let scorePartwise;
   for (const el of parsed) {
@@ -431,8 +565,21 @@ function parseCredits(elements) {
       if (a["xml:space"]) cw.xmlSpace = a["xml:space"];
       return cw;
     });
+    const images = collectElements(content, "credit-image", (_c, a) => {
+      const ci = { source: a["source"] || "", type: a["type"] || "" };
+      if (a["height"]) ci.height = parseFloat(a["height"]);
+      if (a["width"]) ci.width = parseFloat(a["width"]);
+      if (a["default-x"]) ci.defaultX = parseFloat(a["default-x"]);
+      if (a["default-y"]) ci.defaultY = parseFloat(a["default-y"]);
+      if (a["relative-x"]) ci.relativeX = parseFloat(a["relative-x"]);
+      if (a["relative-y"]) ci.relativeY = parseFloat(a["relative-y"]);
+      if (a["halign"]) ci.halign = a["halign"];
+      if (a["valign"]) ci.valign = a["valign"];
+      return ci;
+    });
     if (types.length > 0) credit.creditType = types;
     if (words.length > 0) credit.creditWords = words;
+    if (images.length > 0) credit.creditImage = images[0];
     return credit;
   });
   return credits.length > 0 ? credits : void 0;
@@ -4644,6 +4791,19 @@ function serializeCredit(credit, indent, out) {
       out.push(`${indent}${indent}<credit-type>${escapeXml(ct)}</credit-type>`);
     }
   }
+  if (credit.creditImage) {
+    const ci = credit.creditImage;
+    let attrs2 = ` source="${escapeXml(ci.source)}" type="${escapeXml(ci.type)}"`;
+    if (ci.height !== void 0) attrs2 += ` height="${ci.height}"`;
+    if (ci.width !== void 0) attrs2 += ` width="${ci.width}"`;
+    if (ci.defaultX !== void 0) attrs2 += ` default-x="${ci.defaultX}"`;
+    if (ci.defaultY !== void 0) attrs2 += ` default-y="${ci.defaultY}"`;
+    if (ci.relativeX !== void 0) attrs2 += ` relative-x="${ci.relativeX}"`;
+    if (ci.relativeY !== void 0) attrs2 += ` relative-y="${ci.relativeY}"`;
+    if (ci.halign) attrs2 += ` halign="${escapeXml(ci.halign)}"`;
+    if (ci.valign) attrs2 += ` valign="${escapeXml(ci.valign)}"`;
+    out.push(`${indent}${indent}<credit-image${attrs2}/>`);
+  }
   if (credit.creditWords) {
     for (const cw of credit.creditWords) {
       let attrs2 = "";