musicxml-io 0.2.12 → 0.3.1

package/dist/index.mjs

@@ -19,11 +19,22 @@ var xmlParser = new XMLParser({
 });
 function parse(xmlString) {
   const parsed = xmlParser.parse(xmlString);
-  const scorePartwise = findElement(parsed, "score-partwise");
+  let scorePartwiseVersion;
+  let scorePartwise;
+  for (const el of parsed) {
+    if (el["score-partwise"]) {
+      scorePartwise = el["score-partwise"];
+      const attrs = getAttributes(el);
+      if (attrs["version"]) scorePartwiseVersion = attrs["version"];
+      break;
+    }
+  }
   if (!scorePartwise) {
     throw new Error("Unsupported MusicXML format: only score-partwise is supported");
   }
-  return parseScorePartwise(scorePartwise);
+  const score = parseScorePartwise(scorePartwise);
+  if (scorePartwiseVersion) score.version = scorePartwiseVersion;
+  return score;
 }
 function findElement(elements, tagName) {
   for (const el of elements) {
@@ -241,9 +252,11 @@ function parseDefaults(elements) {
     const lineWidths = collectElements(appContent, "line-width", (c, a) => ({ type: a["type"] || "", value: parseFloat(extractText(c)) || 0 }));
     const noteSizes = collectElements(appContent, "note-size", (c, a) => ({ type: a["type"] || "", value: parseFloat(extractText(c)) || 0 }));
     const distances = collectElements(appContent, "distance", (c, a) => ({ type: a["type"] || "", value: parseFloat(extractText(c)) || 0 }));
+    const glyphs = collectElements(appContent, "glyph", (c, a) => ({ type: a["type"] || "", value: extractText(c) }));
     if (lineWidths.length > 0) appearance["line-widths"] = lineWidths;
     if (noteSizes.length > 0) appearance["note-sizes"] = noteSizes;
     if (distances.length > 0) appearance["distances"] = distances;
+    if (glyphs.length > 0) appearance["glyphs"] = glyphs;
     return Object.keys(appearance).length > 0 ? appearance : void 0;
   });
   if (appResult) defaults.appearance = appResult;
@@ -265,13 +278,25 @@ function parsePageLayout(elements) {
         m.type = attrs["type"];
       }
       const left = getElementText(content, "left-margin");
-      if (left) m.leftMargin = parseFloat(left);
+      if (left) {
+        m.leftMargin = parseFloat(left);
+        m.leftMarginRaw = left;
+      }
       const right = getElementText(content, "right-margin");
-      if (right) m.rightMargin = parseFloat(right);
+      if (right) {
+        m.rightMargin = parseFloat(right);
+        m.rightMarginRaw = right;
+      }
       const top = getElementText(content, "top-margin");
-      if (top) m.topMargin = parseFloat(top);
+      if (top) {
+        m.topMargin = parseFloat(top);
+        m.topMarginRaw = top;
+      }
       const bottom = getElementText(content, "bottom-margin");
-      if (bottom) m.bottomMargin = parseFloat(bottom);
+      if (bottom) {
+        m.bottomMargin = parseFloat(bottom);
+        m.bottomMarginRaw = bottom;
+      }
       margins.push(m);
     }
   }
@@ -284,14 +309,48 @@ function parseSystemLayout(elements) {
   if (margins) {
     layout.systemMargins = {};
     const left = getElementText(margins, "left-margin");
-    if (left) layout.systemMargins.leftMargin = parseFloat(left);
+    if (left) {
+      layout.systemMargins.leftMargin = parseFloat(left);
+      layout.systemMargins.leftMarginRaw = left;
+    }
     const right = getElementText(margins, "right-margin");
-    if (right) layout.systemMargins.rightMargin = parseFloat(right);
+    if (right) {
+      layout.systemMargins.rightMargin = parseFloat(right);
+      layout.systemMargins.rightMarginRaw = right;
+    }
   }
   const dist = getElementText(elements, "system-distance");
-  if (dist) layout.systemDistance = parseFloat(dist);
+  if (dist) {
+    layout.systemDistance = parseFloat(dist);
+    layout.systemDistanceRaw = dist;
+  }
   const topDist = getElementText(elements, "top-system-distance");
-  if (topDist) layout.topSystemDistance = parseFloat(topDist);
+  if (topDist) {
+    layout.topSystemDistance = parseFloat(topDist);
+    layout.topSystemDistanceRaw = topDist;
+  }
+  const dividers = getElementContent(elements, "system-dividers");
+  if (dividers) {
+    layout.systemDividers = {};
+    for (const el of dividers) {
+      if (el["left-divider"]) {
+        const attrs = getAttributes(el);
+        layout.systemDividers.leftDivider = {
+          printObject: attrs["print-object"] === "yes" ? true : attrs["print-object"] === "no" ? false : void 0,
+          halign: attrs["halign"],
+          valign: attrs["valign"]
+        };
+      }
+      if (el["right-divider"]) {
+        const attrs = getAttributes(el);
+        layout.systemDividers.rightDivider = {
+          printObject: attrs["print-object"] === "yes" ? true : attrs["print-object"] === "no" ? false : void 0,
+          halign: attrs["halign"],
+          valign: attrs["valign"]
+        };
+      }
+    }
+  }
   return layout;
 }
 function parseCredits(elements) {
@@ -303,6 +362,7 @@ function parseCredits(elements) {
       const cw = { text: extractText(c) };
       if (a["default-x"]) cw.defaultX = parseFloat(a["default-x"]);
       if (a["default-y"]) cw.defaultY = parseFloat(a["default-y"]);
+      if (a["font-family"]) cw.fontFamily = a["font-family"];
       if (a["font-size"]) cw.fontSize = a["font-size"];
       if (a["font-weight"]) cw.fontWeight = a["font-weight"];
       if (a["font-style"]) cw.fontStyle = a["font-style"];
@@ -526,6 +586,15 @@ function parseMeasure(elements, attrs) {
       measure.entries.push(parseFiguredBass(el["figured-bass"], getAttributes(el)));
     } else if (el["sound"]) {
       measure.entries.push(parseSound(el["sound"], getAttributes(el)));
+    } else if (el["grouping"] !== void 0) {
+      const grpAttrs = getAttributes(el);
+      const grouping = {
+        _id: generateId(),
+        type: "grouping",
+        groupingType: grpAttrs["type"] || "start"
+      };
+      if (grpAttrs["number"]) grouping.number = grpAttrs["number"];
+      measure.entries.push(grouping);
     }
   }
   if (barlines.length > 0) measure.barlines = barlines;
@@ -592,6 +661,7 @@ function parseAttributes(elements) {
       const key = parseKeySignature(keyContent);
       if (keyAttrs["number"]) key.number = parseInt(keyAttrs["number"], 10);
       if (keyAttrs["print-object"] === "no") key.printObject = false;
+      else if (keyAttrs["print-object"] === "yes") key.printObject = true;
       keys.push(key);
     }
   }
@@ -643,14 +713,15 @@ function parseTimeSignature(elements, parentElements) {
       return time2;
     }
   }
-  const beatsList = collectElements(elements, "beats", (c) => parseInt(extractText(c), 10));
+  const beatsStrList = collectElements(elements, "beats", (c) => extractText(c));
   const beatTypeList = collectElements(elements, "beat-type", (c) => parseInt(extractText(c), 10));
   const time = {
-    beats: beatsList.length > 0 ? String(beatsList[0]) : "4",
+    beats: beatsStrList.length > 0 ? beatsStrList[0] : "4",
     beatType: beatTypeList.length > 0 ? beatTypeList[0] : 4
   };
-  if (beatsList.length > 1 || beatTypeList.length > 1) {
-    time.beatsList = beatsList;
+  if (beatsStrList.length > 1 || beatTypeList.length > 1) {
+    time.beatsList = beatsStrList.map((b) => parseInt(b, 10));
+    time.beatsStrList = beatsStrList;
     time.beatTypeList = beatTypeList;
   }
   for (const el of parentElements) {
@@ -689,6 +760,7 @@ function parseKeySignature(elements) {
   const keyOctaves = collectElements(elements, "key-octave", (c, a) => {
     const ko = { number: parseInt(a["number"] || "1", 10), octave: parseInt(extractText(c), 10) };
     if (a["cancel"] === "yes") ko.cancel = true;
+    else if (a["cancel"] === "no") ko.cancel = false;
     return ko;
   });
   if (keySteps.length > 0) key.keySteps = keySteps;
@@ -698,8 +770,11 @@ function parseKeySignature(elements) {
 }
 function parseClef(elements, attrs) {
   const sign = getElementText(elements, "sign") || "G";
-  const line = parseInt(getElementText(elements, "line") || "2", 10);
-  const clef = { sign, line };
+  const lineText = getElementText(elements, "line");
+  const clef = { sign };
+  if (lineText) {
+    clef.line = parseInt(lineText, 10);
+  }
   if (attrs["number"]) {
     clef.staff = parseInt(attrs["number"], 10);
   }
@@ -709,6 +784,8 @@ function parseClef(elements, attrs) {
   }
   if (attrs["print-object"] === "no") {
     clef.printObject = false;
+  } else if (attrs["print-object"] === "yes") {
+    clef.printObject = true;
   }
   if (attrs["after-barline"] === "yes") {
     clef.afterBarline = true;
@@ -730,15 +807,20 @@ function parseNote(elements, attrs) {
   const note = {
     _id: generateId(),
     type: "note",
-    duration: getElementTextAsInt(elements, "duration", 0),
-    voice: getElementTextAsInt(elements, "voice", 1)
+    duration: getElementTextAsInt(elements, "duration", 0)
   };
+  const voiceValue = getElementTextAsInt(elements, "voice");
+  if (voiceValue !== void 0) {
+    note.voice = voiceValue;
+  }
   if (attrs["default-x"]) note.defaultX = parseFloat(attrs["default-x"]);
   if (attrs["default-y"]) note.defaultY = parseFloat(attrs["default-y"]);
   if (attrs["relative-x"]) note.relativeX = parseFloat(attrs["relative-x"]);
   if (attrs["relative-y"]) note.relativeY = parseFloat(attrs["relative-y"]);
   if (attrs["dynamics"]) note.dynamics = parseFloat(attrs["dynamics"]);
   if (attrs["print-object"] === "no") note.printObject = false;
+  if (attrs["print-dot"] === "no") note.printDot = false;
+  if (attrs["print-dot"] === "yes") note.printDot = true;
   if (attrs["print-spacing"] === "yes") note.printSpacing = true;
   if (attrs["print-spacing"] === "no") note.printSpacing = false;
   if (hasElement(elements, "cue")) {
@@ -851,6 +933,7 @@ function parseNote(elements, attrs) {
       const graceAttrs = getAttributes(el);
       note.grace = {};
       if (graceAttrs["slash"] === "yes") note.grace.slash = true;
+      else if (graceAttrs["slash"] === "no") note.grace.slash = false;
       if (graceAttrs["steal-time-previous"]) {
         note.grace.stealTimePrevious = parseFloat(graceAttrs["steal-time-previous"]);
       }
@@ -1096,6 +1179,14 @@ function parseNotations(elements, notationsIndex = 0) {
           notations.push(tremNotation);
         }
       }
+      const ornamentNotationsAdded = notations.filter((n) => n.type === "ornament" && n.notationsIndex === notationsIndex);
+      if (ornamentNotationsAdded.length === 0) {
+        notations.push({
+          type: "ornament",
+          ornament: "empty",
+          notationsIndex
+        });
+      }
     } else if (el["technical"]) {
       const techContent = el["technical"];
       const technicalWithText = ["hammer-on", "pull-off", "tap", "pluck", "fingering", "other-technical"];
@@ -1145,8 +1236,7 @@ function parseNotations(elements, notationsIndex = 0) {
           if (bendAlter) techNotation.bendAlter = parseFloat(bendAlter);
           if (hasElement(bendContent, "pre-bend")) techNotation.preBend = true;
           if (hasElement(bendContent, "release")) techNotation.release = true;
-          const withBar = getElementText(bendContent, "with-bar");
-          if (withBar) techNotation.withBar = parseFloat(withBar);
+          if (hasElement(bendContent, "with-bar")) techNotation.withBar = true;
           notations.push(techNotation);
         }
         for (const techType of technicalTypes) {
@@ -1183,6 +1273,7 @@ function parseNotations(elements, notationsIndex = 0) {
               if (typeAttr === "start" || typeAttr === "stop") {
                 notation.startStop = typeAttr;
               }
+              if (techAttrs["number"]) notation.number = parseInt(techAttrs["number"], 10);
             }
             if (techType === "fingering") {
               if (techAttrs["substitution"] === "yes") notation.fingeringSubstitution = true;
@@ -1265,11 +1356,33 @@ function parseNotations(elements, notationsIndex = 0) {
       notations.push(fermataNotation);
     } else if (el["arpeggiate"] !== void 0) {
       const arpAttrs = getAttributes(el);
-      notations.push({
+      const arpNotation = {
         type: "arpeggiate",
         direction: arpAttrs["direction"],
         number: arpAttrs["number"] ? parseInt(arpAttrs["number"], 10) : void 0,
         notationsIndex
+      };
+      if (arpAttrs["default-x"]) arpNotation.defaultX = parseFloat(arpAttrs["default-x"]);
+      if (arpAttrs["default-y"]) arpNotation.defaultY = parseFloat(arpAttrs["default-y"]);
+      notations.push(arpNotation);
+    } else if (el["non-arpeggiate"] !== void 0) {
+      const nonArpAttrs = getAttributes(el);
+      notations.push({
+        type: "non-arpeggiate",
+        nonArpeggiateType: nonArpAttrs["type"],
+        number: nonArpAttrs["number"] ? parseInt(nonArpAttrs["number"], 10) : void 0,
+        placement: nonArpAttrs["placement"],
+        notationsIndex
+      });
+    } else if (el["accidental-mark"]) {
+      const amAttrs = getAttributes(el);
+      const amContent = el["accidental-mark"];
+      const value = extractText(amContent);
+      notations.push({
+        type: "accidental-mark",
+        value,
+        placement: amAttrs["placement"],
+        notationsIndex
       });
     } else if (el["glissando"]) {
       const glissAttrs = getAttributes(el);
@@ -1291,13 +1404,17 @@ function parseNotations(elements, notationsIndex = 0) {
       });
     } else if (el["slide"]) {
       const slideAttrs = getAttributes(el);
-      notations.push({
+      const slideContent = el["slide"];
+      const slideText = extractText(slideContent);
+      const slideNotation = {
         type: "slide",
         slideType: slideAttrs["type"] === "stop" ? "stop" : "start",
         number: slideAttrs["number"] ? parseInt(slideAttrs["number"], 10) : void 0,
         lineType: slideAttrs["line-type"],
         notationsIndex
-      });
+      };
+      if (slideText) slideNotation.text = slideText;
+      notations.push(slideNotation);
     }
   }
   return notations;
@@ -1318,8 +1435,9 @@ function parseLyric(elements, attrs) {
           break;
         }
       }
-    } else if (el["text"]) {
+    } else if (el["text"] !== void 0) {
       const content = el["text"];
+      let foundText = false;
       for (const item of content) {
         if (item["#text"] !== void 0) {
           textElements.push({
@@ -1327,9 +1445,17 @@ function parseLyric(elements, attrs) {
             syllabic: currentSyllabic
           });
           currentSyllabic = void 0;
+          foundText = true;
           break;
         }
       }
+      if (!foundText) {
+        textElements.push({
+          text: "",
+          syllabic: currentSyllabic
+        });
+        currentSyllabic = void 0;
+      }
     } else if (el["elision"] !== void 0) {
       hasElision = true;
     }
@@ -1498,6 +1624,7 @@ function parseDirectionTypes(elements) {
         "pf"
       ];
       for (const dyn of dynContent) {
+        let foundStandard = false;
         for (const dv of dynamicsValues) {
           if (dyn[dv] !== void 0) {
             const result = { kind: "dynamics", value: dv };
@@ -1506,9 +1633,22 @@ function parseDirectionTypes(elements) {
             if (dynAttrs["relative-x"]) result.relativeX = parseFloat(dynAttrs["relative-x"]);
             if (dynAttrs["halign"]) result.halign = dynAttrs["halign"];
             results.push(result);
+            foundStandard = true;
             break;
           }
         }
+        if (!foundStandard && dyn["other-dynamics"] !== void 0) {
+          const otherDynContent = dyn["other-dynamics"];
+          const otherDynText = extractText(otherDynContent);
+          if (otherDynText) {
+            const result = { kind: "dynamics", otherDynamics: otherDynText };
+            if (dynAttrs["default-x"]) result.defaultX = parseFloat(dynAttrs["default-x"]);
+            if (dynAttrs["default-y"]) result.defaultY = parseFloat(dynAttrs["default-y"]);
+            if (dynAttrs["relative-x"]) result.relativeX = parseFloat(dynAttrs["relative-x"]);
+            if (dynAttrs["halign"]) result.halign = dynAttrs["halign"];
+            results.push(result);
+          }
+        }
       }
       continue;
     }
@@ -1633,11 +1773,14 @@ function parseDirectionTypes(elements) {
       for (const acc of accContent) {
         if (acc["accordion-high"] !== void 0) {
           result.high = true;
-        } else if (acc["accordion-middle"]) {
+        } else if (acc["accordion-middle"] !== void 0) {
+          result.middlePresent = true;
           const midContent = acc["accordion-middle"];
           for (const item of midContent) {
             if (item["#text"] !== void 0) {
-              result.middle = parseInt(String(item["#text"]), 10);
+              const textValue = String(item["#text"]);
+              const numValue = parseInt(textValue, 10);
+              result.middle = !isNaN(numValue) ? numValue : textValue;
               break;
             }
           }
@@ -1814,6 +1957,9 @@ function parseBarline(elements, attrs) {
         if (repeatAttrs["times"]) {
           barline.repeat.times = parseInt(repeatAttrs["times"], 10);
         }
+        if (repeatAttrs["winged"]) {
+          barline.repeat.winged = repeatAttrs["winged"];
+        }
       }
     } else if (el["ending"]) {
       const endingAttrs = getAttributes(el);
@@ -1821,6 +1967,11 @@ function parseBarline(elements, attrs) {
       const type = endingAttrs["type"];
       if (number && (type === "start" || type === "stop" || type === "discontinue")) {
         barline.ending = { number, type };
+        const endingContent = el["ending"];
+        const endingText = extractText(endingContent);
+        if (endingText) barline.ending.text = endingText;
+        if (endingAttrs["default-y"]) barline.ending.defaultY = parseFloat(endingAttrs["default-y"]);
+        if (endingAttrs["end-length"]) barline.ending.endLength = parseFloat(endingAttrs["end-length"]);
       }
     }
   }
@@ -1946,6 +2097,8 @@ function parseStaffDetails(elements, attrs) {
   if (attrs["number"]) sd.number = parseInt(attrs["number"], 10);
   if (attrs["print-object"] === "no") sd.printObject = false;
   else if (attrs["print-object"] === "yes") sd.printObject = true;
+  if (attrs["print-spacing"] === "yes") sd.printSpacing = true;
+  else if (attrs["print-spacing"] === "no") sd.printSpacing = false;
   const staffType = getElementText(elements, "staff-type");
   if (staffType && ["ossia", "cue", "editorial", "regular", "alternate"].includes(staffType)) {
     sd.staffType = staffType;
@@ -2009,7 +2162,9 @@ function parseMeasureStyle(elements, attrs) {
       const slAttrs = getAttributes(el);
       ms.slash = { type: slAttrs["type"] === "stop" ? "stop" : "start" };
       if (slAttrs["use-dots"] === "yes") ms.slash.useDots = true;
+      else if (slAttrs["use-dots"] === "no") ms.slash.useDots = false;
       if (slAttrs["use-stems"] === "yes") ms.slash.useStems = true;
+      else if (slAttrs["use-stems"] === "no") ms.slash.useStems = false;
     }
   }
   return ms;
@@ -2049,19 +2204,29 @@ function parseHarmony(elements, attrs) {
           break;
         }
       }
-      if (kindAttrs["text"]) harmony.kindText = kindAttrs["text"];
+      if (kindAttrs["text"] !== void 0) harmony.kindText = kindAttrs["text"];
+      if (kindAttrs["halign"]) harmony.kindHalign = kindAttrs["halign"];
       break;
     }
   }
-  const bass = getElementContent(elements, "bass");
-  if (bass) {
-    const bassStep = getElementText(bass, "bass-step");
-    if (bassStep) {
-      harmony.bass = { bassStep };
-      const bassAlter = getElementText(bass, "bass-alter");
-      if (bassAlter) harmony.bass.bassAlter = parseFloat(bassAlter);
+  for (const el of elements) {
+    if (el["bass"]) {
+      const bassAttrs = getAttributes(el);
+      const bassContent = el["bass"];
+      const bassStep = getElementText(bassContent, "bass-step");
+      if (bassStep) {
+        harmony.bass = { bassStep };
+        const bassAlter = getElementText(bassContent, "bass-alter");
+        if (bassAlter) harmony.bass.bassAlter = parseFloat(bassAlter);
+        if (bassAttrs["arrangement"]) harmony.bass.arrangement = bassAttrs["arrangement"];
+      }
+      break;
     }
   }
+  const inversionText = getElementText(elements, "inversion");
+  if (inversionText) {
+    harmony.inversion = parseInt(inversionText, 10);
+  }
   const degrees = [];
   for (const el of elements) {
     if (el["degree"]) {
@@ -2828,7 +2993,7 @@ function validateVoiceStaff(measure, staves, location) {
   for (let entryIndex = 0; entryIndex < measure.entries.length; entryIndex++) {
     const entry = measure.entries[entryIndex];
     if (entry.type !== "note") continue;
-    if (entry.voice <= 0) {
+    if (entry.voice !== void 0 && entry.voice <= 0) {
       errors.push({
         code: "INVALID_VOICE_NUMBER",
         level: "error",
@@ -3324,7 +3489,7 @@ function validateSlursAcrossMeasures(part) {
 
 // src/exporters/musicxml.ts
 function serialize(score, options = {}) {
-  const version = options.version || "4.0";
+  const version = options.version || score.version || "4.0";
   const indent = options.indent ?? "  ";
   if (options.validate) {
     const result = validate(score, options.validateOptions);
@@ -3339,11 +3504,7 @@ ${errorMessages}`);
   }
   const lines = [];
   lines.push('<?xml version="1.0" encoding="UTF-8"?>');
-  if (version === "4.0") {
-    lines.push('<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 4.0 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">');
-  } else {
-    lines.push('<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 3.1 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">');
-  }
+  lines.push(`<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML ${version} Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">`);
   lines.push(`<score-partwise version="${version}">`);
   lines.push(...serializeMetadata(score.metadata, indent));
   if (score.defaults) {
@@ -3477,6 +3638,11 @@ function serializeDefaults(defaults, indent) {
         lines.push(`${indent}${indent}${indent}<distance type="${escapeXml(d.type)}">${d.value}</distance>`);
       }
     }
+    if (app["glyphs"]) {
+      for (const g of app["glyphs"]) {
+        lines.push(`${indent}${indent}${indent}<glyph type="${escapeXml(g.type)}">${escapeXml(g.value)}</glyph>`);
+      }
+    }
     lines.push(`${indent}${indent}</appearance>`);
   }
   if (defaults.musicFont) {
@@ -3533,16 +3699,16 @@ function serializePageLayout(layout, indent) {
       const typeAttr = m.type ? ` type="${m.type}"` : "";
       lines.push(`${indent}  <page-margins${typeAttr}>`);
       if (m.leftMargin !== void 0) {
-        lines.push(`${indent}    <left-margin>${m.leftMargin}</left-margin>`);
+        lines.push(`${indent}    <left-margin>${m.leftMarginRaw ?? m.leftMargin}</left-margin>`);
       }
       if (m.rightMargin !== void 0) {
-        lines.push(`${indent}    <right-margin>${m.rightMargin}</right-margin>`);
+        lines.push(`${indent}    <right-margin>${m.rightMarginRaw ?? m.rightMargin}</right-margin>`);
       }
       if (m.topMargin !== void 0) {
-        lines.push(`${indent}    <top-margin>${m.topMargin}</top-margin>`);
+        lines.push(`${indent}    <top-margin>${m.topMarginRaw ?? m.topMargin}</top-margin>`);
       }
       if (m.bottomMargin !== void 0) {
-        lines.push(`${indent}    <bottom-margin>${m.bottomMargin}</bottom-margin>`);
+        lines.push(`${indent}    <bottom-margin>${m.bottomMarginRaw ?? m.bottomMargin}</bottom-margin>`);
       }
       lines.push(`${indent}  </page-margins>`);
     }
@@ -3556,18 +3722,48 @@ function serializeSystemLayout(layout, indent) {
   if (layout.systemMargins) {
     lines.push(`${indent}  <system-margins>`);
     if (layout.systemMargins.leftMargin !== void 0) {
-      lines.push(`${indent}    <left-margin>${layout.systemMargins.leftMargin}</left-margin>`);
+      lines.push(`${indent}    <left-margin>${layout.systemMargins.leftMarginRaw ?? layout.systemMargins.leftMargin}</left-margin>`);
     }
     if (layout.systemMargins.rightMargin !== void 0) {
-      lines.push(`${indent}    <right-margin>${layout.systemMargins.rightMargin}</right-margin>`);
+      lines.push(`${indent}    <right-margin>${layout.systemMargins.rightMarginRaw ?? layout.systemMargins.rightMargin}</right-margin>`);
     }
     lines.push(`${indent}  </system-margins>`);
   }
   if (layout.systemDistance !== void 0) {
-    lines.push(`${indent}  <system-distance>${layout.systemDistance}</system-distance>`);
+    lines.push(`${indent}  <system-distance>${layout.systemDistanceRaw ?? layout.systemDistance}</system-distance>`);
   }
   if (layout.topSystemDistance !== void 0) {
-    lines.push(`${indent}  <top-system-distance>${layout.topSystemDistance}</top-system-distance>`);
+    lines.push(`${indent}  <top-system-distance>${layout.topSystemDistanceRaw ?? layout.topSystemDistance}</top-system-distance>`);
+  }
+  if (layout.systemDividers) {
+    lines.push(`${indent}  <system-dividers>`);
+    if (layout.systemDividers.leftDivider) {
+      let attrs = "";
+      if (layout.systemDividers.leftDivider.printObject !== void 0) {
+        attrs += ` print-object="${layout.systemDividers.leftDivider.printObject ? "yes" : "no"}"`;
+      }
+      if (layout.systemDividers.leftDivider.halign) {
+        attrs += ` halign="${layout.systemDividers.leftDivider.halign}"`;
+      }
+      if (layout.systemDividers.leftDivider.valign) {
+        attrs += ` valign="${layout.systemDividers.leftDivider.valign}"`;
+      }
+      lines.push(`${indent}    <left-divider${attrs}/>`);
+    }
+    if (layout.systemDividers.rightDivider) {
+      let attrs = "";
+      if (layout.systemDividers.rightDivider.printObject !== void 0) {
+        attrs += ` print-object="${layout.systemDividers.rightDivider.printObject ? "yes" : "no"}"`;
+      }
+      if (layout.systemDividers.rightDivider.halign) {
+        attrs += ` halign="${layout.systemDividers.rightDivider.halign}"`;
+      }
+      if (layout.systemDividers.rightDivider.valign) {
+        attrs += ` valign="${layout.systemDividers.rightDivider.valign}"`;
+      }
+      lines.push(`${indent}    <right-divider${attrs}/>`);
+    }
+    lines.push(`${indent}  </system-dividers>`);
   }
   lines.push(`${indent}</system-layout>`);
   return lines;
@@ -3588,6 +3784,7 @@ function serializeCredit(credit, indent) {
       let attrs2 = "";
       if (cw.defaultX !== void 0) attrs2 += ` default-x="${cw.defaultX}"`;
       if (cw.defaultY !== void 0) attrs2 += ` default-y="${cw.defaultY}"`;
+      if (cw.fontFamily) attrs2 += ` font-family="${escapeXml(cw.fontFamily)}"`;
       if (cw.fontSize) attrs2 += ` font-size="${escapeXml(cw.fontSize)}"`;
       if (cw.fontWeight) attrs2 += ` font-weight="${escapeXml(cw.fontWeight)}"`;
       if (cw.fontStyle) attrs2 += ` font-style="${escapeXml(cw.fontStyle)}"`;
@@ -3882,6 +4079,7 @@ function serializeKey(key, indent) {
   let keyAttrs = "";
   if (key.number !== void 0) keyAttrs += ` number="${key.number}"`;
   if (key.printObject === false) keyAttrs += ' print-object="no"';
+  else if (key.printObject === true) keyAttrs += ' print-object="yes"';
   lines.push(`${indent}<key${keyAttrs}>`);
   if (key.cancel !== void 0) {
     const locationAttr = key.cancelLocation ? ` location="${key.cancelLocation}"` : "";
@@ -3929,7 +4127,8 @@ function serializeTime(time, indent) {
     const maxLen = Math.max(time.beatsList.length, time.beatTypeList.length);
     for (let i = 0; i < maxLen; i++) {
       if (i < time.beatsList.length) {
-        lines.push(`${indent}  <beats>${time.beatsList[i]}</beats>`);
+        const beatsValue = time.beatsStrList && i < time.beatsStrList.length ? time.beatsStrList[i] : time.beatsList[i];
+        lines.push(`${indent}  <beats>${beatsValue}</beats>`);
       }
       if (i < time.beatTypeList.length) {
         lines.push(`${indent}  <beat-type>${time.beatTypeList[i]}</beat-type>`);
@@ -3946,10 +4145,13 @@ function serializeClef(clef, indent) {
   const lines = [];
   let attrs = clef.staff ? ` number="${clef.staff}"` : "";
   if (clef.printObject === false) attrs += ' print-object="no"';
+  else if (clef.printObject === true) attrs += ' print-object="yes"';
   if (clef.afterBarline) attrs += ' after-barline="yes"';
   lines.push(`${indent}<clef${attrs}>`);
   lines.push(`${indent}  <sign>${clef.sign}</sign>`);
-  lines.push(`${indent}  <line>${clef.line}</line>`);
+  if (clef.line !== void 0) {
+    lines.push(`${indent}  <line>${clef.line}</line>`);
+  }
   if (clef.clefOctaveChange !== void 0) {
     lines.push(`${indent}  <clef-octave-change>${clef.clefOctaveChange}</clef-octave-change>`);
   }
@@ -3985,6 +4187,12 @@ function serializeEntry(entry, indent) {
       return serializeSound(entry, indent);
     case "attributes":
       return serializeAttributes(entry.attributes, indent, entry._id);
+    case "grouping": {
+      const grp = entry;
+      let grpAttrs = ` type="${grp.groupingType}"`;
+      if (grp.number) grpAttrs += ` number="${grp.number}"`;
+      return [`${indent}<grouping${grpAttrs}/>`];
+    }
     default:
       return [];
   }
@@ -3999,12 +4207,13 @@ function serializeNote(note, indent) {
     "relative-y": note.relativeY,
     "dynamics": note.dynamics,
     "print-object": note.printObject === false ? false : void 0,
+    "print-dot": note.printDot !== void 0 ? note.printDot : void 0,
     "print-spacing": note.printSpacing
   });
   lines.push(`${indent}<note${noteAttrs}>`);
   if (note.grace) {
     const graceAttrs = buildAttrs({
-      "slash": note.grace.slash || void 0,
+      "slash": note.grace.slash !== void 0 ? note.grace.slash : void 0,
       "steal-time-previous": note.grace.stealTimePrevious,
       "steal-time-following": note.grace.stealTimeFollowing
     });
@@ -4059,7 +4268,9 @@ function serializeNote(note, indent) {
   } else if (note.tie) {
     lines.push(`${indent}  <tie type="${note.tie.type}"/>`);
   }
-  lines.push(`${indent}  <voice>${note.voice}</voice>`);
+  if (note.voice !== void 0) {
+    lines.push(`${indent}  <voice>${note.voice}</voice>`);
+  }
   if (note.noteType) {
     const typeAttrs = note.noteTypeSize ? ` size="${escapeXml(note.noteTypeSize)}"` : "";
     lines.push(`${indent}  <type${typeAttrs}>${note.noteType}</type>`);
@@ -4167,154 +4378,200 @@ function serializeNotations(notations, indent) {
 function serializeNotationsGroup(notations, indent) {
   const lines = [];
   lines.push(`${indent}<notations>`);
-  const articulationsGroups = /* @__PURE__ */ new Map();
-  const ornaments = [];
-  const technicals = [];
-  const others = [];
+  const chunks = [];
   for (const notation of notations) {
     if (notation.type === "articulation") {
       const artIdx = notation.articulationsIndex ?? 0;
-      if (!articulationsGroups.has(artIdx)) {
-        articulationsGroups.set(artIdx, []);
+      const last = chunks[chunks.length - 1];
+      if (last && last.kind === "articulations" && last.articulationsIndex === artIdx) {
+        last.items.push(notation);
+      } else {
+        chunks.push({ kind: "articulations", items: [notation], articulationsIndex: artIdx });
       }
-      articulationsGroups.get(artIdx).push(notation);
     } else if (notation.type === "ornament") {
-      ornaments.push(notation);
+      const last = chunks[chunks.length - 1];
+      if (last && last.kind === "ornaments") {
+        last.items.push(notation);
+      } else {
+        chunks.push({ kind: "ornaments", items: [notation] });
+      }
     } else if (notation.type === "technical") {
-      technicals.push(notation);
+      const last = chunks[chunks.length - 1];
+      if (last && last.kind === "technical") {
+        last.items.push(notation);
+      } else {
+        chunks.push({ kind: "technical", items: [notation] });
+      }
     } else {
-      others.push(notation);
+      chunks.push({ kind: "standalone", notation });
     }
   }
-  for (const notation of others) {
-    if (notation.type === "tied") {
-      let attrs = ` type="${notation.tiedType}"`;
-      if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
-      if (notation.orientation) attrs += ` orientation="${notation.orientation}"`;
-      lines.push(`${indent}  <tied${attrs}/>`);
-    } else if (notation.type === "slur") {
-      let attrs = "";
-      if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
-      attrs += ` type="${notation.slurType}"`;
-      if (notation.lineType) attrs += ` line-type="${notation.lineType}"`;
-      if (notation.orientation) attrs += ` orientation="${notation.orientation}"`;
-      if (notation.defaultX !== void 0) attrs += ` default-x="${notation.defaultX}"`;
-      if (notation.defaultY !== void 0) attrs += ` default-y="${notation.defaultY}"`;
-      if (notation.bezierX !== void 0) attrs += ` bezier-x="${notation.bezierX}"`;
-      if (notation.bezierY !== void 0) attrs += ` bezier-y="${notation.bezierY}"`;
-      if (notation.bezierX2 !== void 0) attrs += ` bezier-x2="${notation.bezierX2}"`;
-      if (notation.bezierY2 !== void 0) attrs += ` bezier-y2="${notation.bezierY2}"`;
-      if (notation.placement) attrs += ` placement="${notation.placement}"`;
-      lines.push(`${indent}  <slur${attrs}/>`);
-    } else if (notation.type === "tuplet") {
-      let attrs = ` type="${notation.tupletType}"`;
-      if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
-      if (notation.bracket !== void 0) attrs += ` bracket="${notation.bracket ? "yes" : "no"}"`;
-      if (notation.showNumber) attrs += ` show-number="${notation.showNumber}"`;
-      if (notation.showType) attrs += ` show-type="${notation.showType}"`;
-      if (notation.lineShape) attrs += ` line-shape="${notation.lineShape}"`;
-      if (notation.placement) attrs += ` placement="${notation.placement}"`;
-      const tup = notation;
-      if (tup.tupletActual || tup.tupletNormal) {
-        lines.push(`${indent}  <tuplet${attrs}>`);
-        if (tup.tupletActual) {
-          lines.push(`${indent}    <tuplet-actual>`);
-          if (tup.tupletActual.tupletNumber !== void 0) {
-            lines.push(`${indent}      <tuplet-number>${tup.tupletActual.tupletNumber}</tuplet-number>`);
-          }
-          if (tup.tupletActual.tupletType) {
-            lines.push(`${indent}      <tuplet-type>${tup.tupletActual.tupletType}</tuplet-type>`);
-          }
-          if (tup.tupletActual.tupletDots) {
-            for (let i = 0; i < tup.tupletActual.tupletDots; i++) {
-              lines.push(`${indent}      <tuplet-dot/>`);
-            }
+  for (const chunk of chunks) {
+    if (chunk.kind === "standalone") {
+      lines.push(...serializeStandaloneNotation(chunk.notation, indent));
+    } else if (chunk.kind === "articulations") {
+      lines.push(...serializeArticulationsGroup(chunk.items, indent));
+    } else if (chunk.kind === "ornaments") {
+      lines.push(...serializeOrnamentsGroup(chunk.items, indent));
+    } else if (chunk.kind === "technical") {
+      lines.push(...serializeTechnicalGroup(chunk.items, indent));
+    }
+  }
+  lines.push(`${indent}</notations>`);
+  return lines;
+}
+function serializeStandaloneNotation(notation, indent) {
+  const lines = [];
+  if (notation.type === "tied") {
+    let attrs = ` type="${notation.tiedType}"`;
+    if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
+    if (notation.orientation) attrs += ` orientation="${notation.orientation}"`;
+    lines.push(`${indent}  <tied${attrs}/>`);
+  } else if (notation.type === "slur") {
+    let attrs = "";
+    if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
+    attrs += ` type="${notation.slurType}"`;
+    if (notation.lineType) attrs += ` line-type="${notation.lineType}"`;
+    if (notation.orientation) attrs += ` orientation="${notation.orientation}"`;
+    if (notation.defaultX !== void 0) attrs += ` default-x="${notation.defaultX}"`;
+    if (notation.defaultY !== void 0) attrs += ` default-y="${notation.defaultY}"`;
+    if (notation.bezierX !== void 0) attrs += ` bezier-x="${notation.bezierX}"`;
+    if (notation.bezierY !== void 0) attrs += ` bezier-y="${notation.bezierY}"`;
+    if (notation.bezierX2 !== void 0) attrs += ` bezier-x2="${notation.bezierX2}"`;
+    if (notation.bezierY2 !== void 0) attrs += ` bezier-y2="${notation.bezierY2}"`;
+    if (notation.placement) attrs += ` placement="${notation.placement}"`;
+    lines.push(`${indent}  <slur${attrs}/>`);
+  } else if (notation.type === "tuplet") {
+    let attrs = ` type="${notation.tupletType}"`;
+    if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
+    if (notation.bracket !== void 0) attrs += ` bracket="${notation.bracket ? "yes" : "no"}"`;
+    if (notation.showNumber) attrs += ` show-number="${notation.showNumber}"`;
+    if (notation.showType) attrs += ` show-type="${notation.showType}"`;
+    if (notation.lineShape) attrs += ` line-shape="${notation.lineShape}"`;
+    if (notation.placement) attrs += ` placement="${notation.placement}"`;
+    const tup = notation;
+    if (tup.tupletActual || tup.tupletNormal) {
+      lines.push(`${indent}  <tuplet${attrs}>`);
+      if (tup.tupletActual) {
+        lines.push(`${indent}    <tuplet-actual>`);
+        if (tup.tupletActual.tupletNumber !== void 0) {
+          lines.push(`${indent}      <tuplet-number>${tup.tupletActual.tupletNumber}</tuplet-number>`);
+        }
+        if (tup.tupletActual.tupletType) {
+          lines.push(`${indent}      <tuplet-type>${tup.tupletActual.tupletType}</tuplet-type>`);
+        }
+        if (tup.tupletActual.tupletDots) {
+          for (let i = 0; i < tup.tupletActual.tupletDots; i++) {
+            lines.push(`${indent}      <tuplet-dot/>`);
           }
-          lines.push(`${indent}    </tuplet-actual>`);
         }
-        if (tup.tupletNormal) {
-          lines.push(`${indent}    <tuplet-normal>`);
-          if (tup.tupletNormal.tupletNumber !== void 0) {
-            lines.push(`${indent}      <tuplet-number>${tup.tupletNormal.tupletNumber}</tuplet-number>`);
-          }
-          if (tup.tupletNormal.tupletType) {
-            lines.push(`${indent}      <tuplet-type>${tup.tupletNormal.tupletType}</tuplet-type>`);
-          }
-          if (tup.tupletNormal.tupletDots) {
-            for (let i = 0; i < tup.tupletNormal.tupletDots; i++) {
-              lines.push(`${indent}      <tuplet-dot/>`);
-            }
+        lines.push(`${indent}    </tuplet-actual>`);
+      }
+      if (tup.tupletNormal) {
+        lines.push(`${indent}    <tuplet-normal>`);
+        if (tup.tupletNormal.tupletNumber !== void 0) {
+          lines.push(`${indent}      <tuplet-number>${tup.tupletNormal.tupletNumber}</tuplet-number>`);
+        }
+        if (tup.tupletNormal.tupletType) {
+          lines.push(`${indent}      <tuplet-type>${tup.tupletNormal.tupletType}</tuplet-type>`);
+        }
+        if (tup.tupletNormal.tupletDots) {
+          for (let i = 0; i < tup.tupletNormal.tupletDots; i++) {
+            lines.push(`${indent}      <tuplet-dot/>`);
           }
-          lines.push(`${indent}    </tuplet-normal>`);
         }
-        lines.push(`${indent}  </tuplet>`);
-      } else {
-        lines.push(`${indent}  <tuplet${attrs}/>`);
-      }
-    } else if (notation.type === "dynamics") {
-      const placementAttr = notation.placement ? ` placement="${notation.placement}"` : "";
-      lines.push(`${indent}  <dynamics${placementAttr}>`);
-      for (const dyn of notation.dynamics) {
-        lines.push(`${indent}    <${dyn}/>`);
-      }
-      if (notation.otherDynamics) {
-        lines.push(`${indent}    <other-dynamics>${escapeXml(notation.otherDynamics)}</other-dynamics>`);
-      }
-      lines.push(`${indent}  </dynamics>`);
-    } else if (notation.type === "fermata") {
-      let attrs = "";
-      if (notation.fermataType) attrs += ` type="${notation.fermataType}"`;
-      if (notation.placement) attrs += ` placement="${notation.placement}"`;
-      if (notation.defaultX !== void 0) attrs += ` default-x="${notation.defaultX}"`;
-      if (notation.defaultY !== void 0) attrs += ` default-y="${notation.defaultY}"`;
-      if (notation.shape) {
-        lines.push(`${indent}  <fermata${attrs}>${notation.shape}</fermata>`);
-      } else {
-        lines.push(`${indent}  <fermata${attrs}/>`);
-      }
-    } else if (notation.type === "arpeggiate") {
-      let attrs = "";
-      if (notation.direction) attrs += ` direction="${notation.direction}"`;
-      if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
-      lines.push(`${indent}  <arpeggiate${attrs}/>`);
-    } else if (notation.type === "glissando") {
-      let attrs = ` type="${notation.glissandoType}"`;
-      if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
-      if (notation.lineType) attrs += ` line-type="${notation.lineType}"`;
-      if (notation.text) {
-        lines.push(`${indent}  <glissando${attrs}>${escapeXml(notation.text)}</glissando>`);
-      } else {
-        lines.push(`${indent}  <glissando${attrs}/>`);
+        lines.push(`${indent}    </tuplet-normal>`);
       }
-    } else if (notation.type === "slide") {
-      let attrs = ` type="${notation.slideType}"`;
-      if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
-      if (notation.lineType) attrs += ` line-type="${notation.lineType}"`;
+      lines.push(`${indent}  </tuplet>`);
+    } else {
+      lines.push(`${indent}  <tuplet${attrs}/>`);
+    }
+  } else if (notation.type === "dynamics") {
+    const placementAttr = notation.placement ? ` placement="${notation.placement}"` : "";
+    lines.push(`${indent}  <dynamics${placementAttr}>`);
+    for (const dyn of notation.dynamics) {
+      lines.push(`${indent}    <${dyn}/>`);
+    }
+    if (notation.otherDynamics) {
+      lines.push(`${indent}    <other-dynamics>${escapeXml(notation.otherDynamics)}</other-dynamics>`);
+    }
+    lines.push(`${indent}  </dynamics>`);
+  } else if (notation.type === "fermata") {
+    let attrs = "";
+    if (notation.fermataType) attrs += ` type="${notation.fermataType}"`;
+    if (notation.placement) attrs += ` placement="${notation.placement}"`;
+    if (notation.defaultX !== void 0) attrs += ` default-x="${notation.defaultX}"`;
+    if (notation.defaultY !== void 0) attrs += ` default-y="${notation.defaultY}"`;
+    if (notation.shape) {
+      lines.push(`${indent}  <fermata${attrs}>${notation.shape}</fermata>`);
+    } else {
+      lines.push(`${indent}  <fermata${attrs}/>`);
+    }
+  } else if (notation.type === "arpeggiate") {
+    let attrs = "";
+    if (notation.direction) attrs += ` direction="${notation.direction}"`;
+    if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
+    if (notation.defaultX !== void 0) attrs += ` default-x="${notation.defaultX}"`;
+    if (notation.defaultY !== void 0) attrs += ` default-y="${notation.defaultY}"`;
+    lines.push(`${indent}  <arpeggiate${attrs}/>`);
+  } else if (notation.type === "non-arpeggiate") {
+    let attrs = ` type="${notation.nonArpeggiateType}"`;
+    if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
+    if (notation.placement) attrs += ` placement="${notation.placement}"`;
+    lines.push(`${indent}  <non-arpeggiate${attrs}/>`);
+  } else if (notation.type === "accidental-mark") {
+    let attrs = "";
+    if (notation.placement) attrs += ` placement="${notation.placement}"`;
+    lines.push(`${indent}  <accidental-mark${attrs}>${escapeXml(notation.value)}</accidental-mark>`);
+  } else if (notation.type === "glissando") {
+    let attrs = ` type="${notation.glissandoType}"`;
+    if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
+    if (notation.lineType) attrs += ` line-type="${notation.lineType}"`;
+    if (notation.text) {
+      lines.push(`${indent}  <glissando${attrs}>${escapeXml(notation.text)}</glissando>`);
+    } else {
+      lines.push(`${indent}  <glissando${attrs}/>`);
+    }
+  } else if (notation.type === "slide") {
+    let attrs = ` type="${notation.slideType}"`;
+    if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
+    if (notation.lineType) attrs += ` line-type="${notation.lineType}"`;
+    if (notation.text) {
+      lines.push(`${indent}  <slide${attrs}>${escapeXml(notation.text)}</slide>`);
+    } else {
       lines.push(`${indent}  <slide${attrs}/>`);
     }
   }
-  const sortedArtIndices = Array.from(articulationsGroups.keys()).sort((a, b) => a - b);
-  for (const artIdx of sortedArtIndices) {
-    const artGroup = articulationsGroups.get(artIdx);
-    lines.push(`${indent}  <articulations>`);
-    for (const art of artGroup) {
-      if (art.type === "articulation") {
-        let artAttrs = art.placement ? ` placement="${art.placement}"` : "";
-        if (art.articulation === "strong-accent" && art.strongAccentType) {
-          artAttrs += ` type="${art.strongAccentType}"`;
-        }
-        if (art.defaultX !== void 0) artAttrs += ` default-x="${art.defaultX}"`;
-        if (art.defaultY !== void 0) artAttrs += ` default-y="${art.defaultY}"`;
-        lines.push(`${indent}    <${art.articulation}${artAttrs}/>`);
+  return lines;
+}
+function serializeArticulationsGroup(artGroup, indent) {
+  const lines = [];
+  lines.push(`${indent}  <articulations>`);
+  for (const art of artGroup) {
+    if (art.type === "articulation") {
+      let artAttrs = art.placement ? ` placement="${art.placement}"` : "";
+      if (art.articulation === "strong-accent" && art.strongAccentType) {
+        artAttrs += ` type="${art.strongAccentType}"`;
       }
+      if (art.defaultX !== void 0) artAttrs += ` default-x="${art.defaultX}"`;
+      if (art.defaultY !== void 0) artAttrs += ` default-y="${art.defaultY}"`;
+      lines.push(`${indent}    <${art.articulation}${artAttrs}/>`);
     }
-    lines.push(`${indent}  </articulations>`);
   }
-  if (ornaments.length > 0) {
+  lines.push(`${indent}  </articulations>`);
+  return lines;
+}
+function serializeOrnamentsGroup(ornaments, indent) {
+  const lines = [];
+  const hasOnlyEmptyMarker = ornaments.length === 1 && ornaments[0].type === "ornament" && ornaments[0].ornament === "empty";
+  if (hasOnlyEmptyMarker) {
+    lines.push(`${indent}  <ornaments/>`);
+  } else {
     lines.push(`${indent}  <ornaments>`);
     const allAccidentalMarks = [];
     for (const orn of ornaments) {
       if (orn.type === "ornament") {
+        if (orn.ornament === "empty") continue;
         const placementAttr = orn.placement ? ` placement="${orn.placement}"` : "";
         if (orn.ornament === "wavy-line") {
           let wlAttrs = "";
@@ -4350,77 +4607,80 @@ function serializeNotationsGroup(notations, indent) {
     }
     lines.push(`${indent}  </ornaments>`);
   }
-  if (technicals.length > 0) {
-    lines.push(`${indent}  <technical>`);
-    for (const tech of technicals) {
-      if (tech.type === "technical") {
-        let placementAttr = tech.placement ? ` placement="${tech.placement}"` : "";
-        const techNotation = tech;
-        if (techNotation.defaultX !== void 0) placementAttr += ` default-x="${techNotation.defaultX}"`;
-        if (techNotation.defaultY !== void 0) placementAttr += ` default-y="${techNotation.defaultY}"`;
-        if (tech.technical === "bend" && (techNotation.bendAlter !== void 0 || techNotation.preBend || techNotation.release)) {
-          lines.push(`${indent}    <bend${placementAttr}>`);
-          if (techNotation.bendAlter !== void 0) {
-            lines.push(`${indent}      <bend-alter>${techNotation.bendAlter}</bend-alter>`);
-          }
-          if (techNotation.preBend) {
-            lines.push(`${indent}      <pre-bend/>`);
-          }
-          if (techNotation.release) {
-            lines.push(`${indent}      <release/>`);
-          }
-          if (techNotation.withBar !== void 0) {
-            lines.push(`${indent}      <with-bar>${techNotation.withBar}</with-bar>`);
-          }
-          lines.push(`${indent}    </bend>`);
-        } else if (tech.technical === "harmonic") {
-          const hasChildren = techNotation.harmonicNatural || techNotation.harmonicArtificial || techNotation.basePitch || techNotation.touchingPitch || techNotation.soundingPitch;
-          if (hasChildren) {
-            lines.push(`${indent}    <harmonic${placementAttr}>`);
-            if (techNotation.harmonicNatural) lines.push(`${indent}      <natural/>`);
-            if (techNotation.harmonicArtificial) lines.push(`${indent}      <artificial/>`);
-            if (techNotation.basePitch) lines.push(`${indent}      <base-pitch/>`);
-            if (techNotation.touchingPitch) lines.push(`${indent}      <touching-pitch/>`);
-            if (techNotation.soundingPitch) lines.push(`${indent}      <sounding-pitch/>`);
-            lines.push(`${indent}    </harmonic>`);
-          } else {
-            lines.push(`${indent}    <harmonic${placementAttr}/>`);
-          }
-        } else if (tech.technical === "hammer-on" || tech.technical === "pull-off") {
-          let attrs = placementAttr;
-          if (techNotation.startStop) attrs += ` type="${techNotation.startStop}"`;
-          if (techNotation.text !== void 0) {
-            lines.push(`${indent}    <${tech.technical}${attrs}>${escapeXml(techNotation.text)}</${tech.technical}>`);
-          } else {
-            lines.push(`${indent}    <${tech.technical}${attrs}/>`);
-          }
-        } else if (tech.technical === "string" && techNotation.string !== void 0) {
-          lines.push(`${indent}    <string${placementAttr}>${techNotation.string}</string>`);
-        } else if (tech.technical === "fret" && techNotation.fret !== void 0) {
-          lines.push(`${indent}    <fret${placementAttr}>${techNotation.fret}</fret>`);
-        } else if (tech.technical === "fingering") {
-          let fAttrs = placementAttr;
-          if (techNotation.fingeringSubstitution) fAttrs += ' substitution="yes"';
-          if (techNotation.fingeringAlternate) fAttrs += ' alternate="yes"';
-          if (techNotation.text !== void 0) {
-            lines.push(`${indent}    <fingering${fAttrs}>${escapeXml(techNotation.text)}</fingering>`);
-          } else {
-            lines.push(`${indent}    <fingering${fAttrs}/>`);
-          }
-        } else if (tech.technical === "heel" || tech.technical === "toe") {
-          let htAttrs = placementAttr;
-          if (techNotation.substitution) htAttrs += ' substitution="yes"';
-          lines.push(`${indent}    <${tech.technical}${htAttrs}/>`);
-        } else if (techNotation.text !== void 0) {
-          lines.push(`${indent}    <${tech.technical}${placementAttr}>${escapeXml(techNotation.text)}</${tech.technical}>`);
+  return lines;
+}
+function serializeTechnicalGroup(technicals, indent) {
+  const lines = [];
+  lines.push(`${indent}  <technical>`);
+  for (const tech of technicals) {
+    if (tech.type === "technical") {
+      let placementAttr = tech.placement ? ` placement="${tech.placement}"` : "";
+      const techNotation = tech;
+      if (techNotation.defaultX !== void 0) placementAttr += ` default-x="${techNotation.defaultX}"`;
+      if (techNotation.defaultY !== void 0) placementAttr += ` default-y="${techNotation.defaultY}"`;
+      if (tech.technical === "bend" && (techNotation.bendAlter !== void 0 || techNotation.preBend || techNotation.release)) {
+        lines.push(`${indent}    <bend${placementAttr}>`);
+        if (techNotation.bendAlter !== void 0) {
+          lines.push(`${indent}      <bend-alter>${techNotation.bendAlter}</bend-alter>`);
+        }
+        if (techNotation.preBend) {
+          lines.push(`${indent}      <pre-bend/>`);
+        }
+        if (techNotation.release) {
+          lines.push(`${indent}      <release/>`);
+        }
+        if (techNotation.withBar) {
+          lines.push(`${indent}      <with-bar/>`);
+        }
+        lines.push(`${indent}    </bend>`);
+      } else if (tech.technical === "harmonic") {
+        const hasChildren = techNotation.harmonicNatural || techNotation.harmonicArtificial || techNotation.basePitch || techNotation.touchingPitch || techNotation.soundingPitch;
+        if (hasChildren) {
+          lines.push(`${indent}    <harmonic${placementAttr}>`);
+          if (techNotation.harmonicNatural) lines.push(`${indent}      <natural/>`);
+          if (techNotation.harmonicArtificial) lines.push(`${indent}      <artificial/>`);
+          if (techNotation.basePitch) lines.push(`${indent}      <base-pitch/>`);
+          if (techNotation.touchingPitch) lines.push(`${indent}      <touching-pitch/>`);
+          if (techNotation.soundingPitch) lines.push(`${indent}      <sounding-pitch/>`);
+          lines.push(`${indent}    </harmonic>`);
         } else {
-          lines.push(`${indent}    <${tech.technical}${placementAttr}/>`);
-        }
+          lines.push(`${indent}    <harmonic${placementAttr}/>`);
+        }
+      } else if (tech.technical === "hammer-on" || tech.technical === "pull-off") {
+        let attrs = "";
+        if (techNotation.number !== void 0) attrs += ` number="${techNotation.number}"`;
+        if (techNotation.startStop) attrs += ` type="${techNotation.startStop}"`;
+        attrs += placementAttr;
+        if (techNotation.text !== void 0) {
+          lines.push(`${indent}    <${tech.technical}${attrs}>${escapeXml(techNotation.text)}</${tech.technical}>`);
+        } else {
+          lines.push(`${indent}    <${tech.technical}${attrs}/>`);
+        }
+      } else if (tech.technical === "string" && techNotation.string !== void 0) {
+        lines.push(`${indent}    <string${placementAttr}>${techNotation.string}</string>`);
+      } else if (tech.technical === "fret" && techNotation.fret !== void 0) {
+        lines.push(`${indent}    <fret${placementAttr}>${techNotation.fret}</fret>`);
+      } else if (tech.technical === "fingering") {
+        let fAttrs = placementAttr;
+        if (techNotation.fingeringSubstitution) fAttrs += ' substitution="yes"';
+        if (techNotation.fingeringAlternate) fAttrs += ' alternate="yes"';
+        if (techNotation.text !== void 0) {
+          lines.push(`${indent}    <fingering${fAttrs}>${escapeXml(techNotation.text)}</fingering>`);
+        } else {
+          lines.push(`${indent}    <fingering${fAttrs}/>`);
+        }
+      } else if (tech.technical === "heel" || tech.technical === "toe") {
+        let htAttrs = placementAttr;
+        if (techNotation.substitution) htAttrs += ' substitution="yes"';
+        lines.push(`${indent}    <${tech.technical}${htAttrs}/>`);
+      } else if (techNotation.text !== void 0) {
+        lines.push(`${indent}    <${tech.technical}${placementAttr}>${escapeXml(techNotation.text)}</${tech.technical}>`);
+      } else {
+        lines.push(`${indent}    <${tech.technical}${placementAttr}/>`);
       }
     }
-    lines.push(`${indent}  </technical>`);
   }
-  lines.push(`${indent}</notations>`);
+  lines.push(`${indent}  </technical>`);
   return lines;
 }
 function serializeLyric(lyric, indent) {
@@ -4444,7 +4704,7 @@ function serializeLyric(lyric, indent) {
         lines.push(`${indent}  <elision/>`);
       }
     }
-  } else {
+  } else if (lyric.syllabic || lyric.text) {
     if (lyric.syllabic) {
       lines.push(`${indent}  <syllabic>${lyric.syllabic}</syllabic>`);
     }
@@ -4559,7 +4819,12 @@ function serializeDirectionType(dirType, indent) {
       if (dirType.relativeX !== void 0) dynAttrs += ` relative-x="${dirType.relativeX}"`;
       if (dirType.halign) dynAttrs += ` halign="${dirType.halign}"`;
       lines.push(`${indent}  <dynamics${dynAttrs}>`);
-      lines.push(`${indent}    <${dirType.value}/>`);
+      if (dirType.value) {
+        lines.push(`${indent}    <${dirType.value}/>`);
+      }
+      if (dirType.otherDynamics) {
+        lines.push(`${indent}    <other-dynamics>${escapeXml(dirType.otherDynamics)}</other-dynamics>`);
+      }
       lines.push(`${indent}  </dynamics>`);
       break;
     }
@@ -4646,8 +4911,12 @@ function serializeDirectionType(dirType, indent) {
       if (dirType.high) {
         lines.push(`${indent}    <accordion-high/>`);
       }
-      if (dirType.middle !== void 0) {
-        lines.push(`${indent}    <accordion-middle>${dirType.middle}</accordion-middle>`);
+      if (dirType.middlePresent || dirType.middle !== void 0) {
+        if (dirType.middle !== void 0) {
+          lines.push(`${indent}    <accordion-middle>${dirType.middle}</accordion-middle>`);
+        } else {
+          lines.push(`${indent}    <accordion-middle/>`);
+        }
       }
       if (dirType.low) {
         lines.push(`${indent}    <accordion-low/>`);
@@ -4760,11 +5029,20 @@ function serializeBarline(barline, indent) {
     lines.push(`${indent}  <bar-style>${barline.barStyle}</bar-style>`);
   }
   if (barline.ending) {
-    lines.push(`${indent}  <ending number="${barline.ending.number}" type="${barline.ending.type}"/>`);
+    let endingAttrs = ` number="${barline.ending.number}" type="${barline.ending.type}"`;
+    if (barline.ending.defaultY !== void 0) endingAttrs += ` default-y="${barline.ending.defaultY}"`;
+    if (barline.ending.endLength !== void 0) endingAttrs += ` end-length="${barline.ending.endLength}"`;
+    if (barline.ending.text) {
+      lines.push(`${indent}  <ending${endingAttrs}>${escapeXml(barline.ending.text)}</ending>`);
+    } else {
+      lines.push(`${indent}  <ending${endingAttrs}/>`);
+    }
   }
   if (barline.repeat) {
-    const timesAttr = barline.repeat.times !== void 0 ? ` times="${barline.repeat.times}"` : "";
-    lines.push(`${indent}  <repeat direction="${barline.repeat.direction}"${timesAttr}/>`);
+    let repeatAttrs = ` direction="${barline.repeat.direction}"`;
+    if (barline.repeat.times !== void 0) repeatAttrs += ` times="${barline.repeat.times}"`;
+    if (barline.repeat.winged) repeatAttrs += ` winged="${barline.repeat.winged}"`;
+    lines.push(`${indent}  <repeat${repeatAttrs}/>`);
   }
   lines.push(`${indent}</barline>`);
   return lines;
@@ -4797,7 +5075,8 @@ function serializeStaffDetails(sd, indent) {
   const attrs = buildAttrs({
     "number": sd.number,
     "show-frets": sd.showFrets,
-    "print-object": sd.printObject
+    "print-object": sd.printObject,
+    "print-spacing": sd.printSpacing
   });
   lines.push(`${indent}<staff-details${attrs}>`);
   pushOptionalElement(lines, `${indent}  `, "staff-type", sd.staffType);
@@ -4863,16 +5142,22 @@ function serializeHarmony(harmony, indent) {
   }
   lines.push(`${indent}  </root>`);
   let kindAttrs = "";
-  if (harmony.kindText) kindAttrs += ` text="${escapeXml(harmony.kindText)}"`;
+  if (harmony.kindText !== void 0) kindAttrs += ` text="${escapeXml(harmony.kindText)}"`;
+  if (harmony.kindHalign) kindAttrs += ` halign="${escapeXml(harmony.kindHalign)}"`;
   lines.push(`${indent}  <kind${kindAttrs}>${escapeXml(harmony.kind)}</kind>`);
   if (harmony.bass) {
-    lines.push(`${indent}  <bass>`);
+    let bassAttrs = "";
+    if (harmony.bass.arrangement) bassAttrs += ` arrangement="${escapeXml(harmony.bass.arrangement)}"`;
+    lines.push(`${indent}  <bass${bassAttrs}>`);
     lines.push(`${indent}    <bass-step>${harmony.bass.bassStep}</bass-step>`);
     if (harmony.bass.bassAlter !== void 0) {
       lines.push(`${indent}    <bass-alter>${harmony.bass.bassAlter}</bass-alter>`);
     }
     lines.push(`${indent}  </bass>`);
   }
+  if (harmony.inversion !== void 0) {
+    lines.push(`${indent}  <inversion>${harmony.inversion}</inversion>`);
+  }
   if (harmony.degrees) {
     for (const deg of harmony.degrees) {
       lines.push(`${indent}  <degree>`);
@@ -5558,7 +5843,7 @@ function groupByVoice(measure) {
   for (const entry of measure.entries) {
     if (entry.type !== "note") continue;
     const staff = entry.staff ?? 1;
-    const voice = entry.voice;
+    const voice = entry.voice ?? 1;
     const key = `${staff}-${voice}`;
     if (!groups.has(key)) {
       groups.set(key, { staff, voice, notes: [] });
@@ -5652,7 +5937,7 @@ function getVoices(measure) {
   const voices = /* @__PURE__ */ new Set();
   for (const entry of measure.entries) {
     if (entry.type === "note") {
-      voices.add(entry.voice);
+      voices.add(entry.voice ?? 1);
     }
   }
   return Array.from(voices).sort((a, b) => a - b);
@@ -5703,7 +5988,7 @@ function buildVoiceToStaffMap(measure) {
   const map = /* @__PURE__ */ new Map();
   for (const entry of measure.entries) {
     if (entry.type === "note" && entry.staff !== void 0) {
-      const voice = entry.voice;
+      const voice = entry.voice ?? 1;
       const staff = entry.staff;
       if (!map.has(voice)) {
         map.set(voice, staff);
@@ -5722,7 +6007,7 @@ function buildVoiceToStaffMapForPart(part) {
   for (const measure of part.measures) {
     for (const entry of measure.entries) {
       if (entry.type === "note" && entry.staff !== void 0) {
-        const voice = entry.voice;
+        const voice = entry.voice ?? 1;
         const staff = entry.staff;
         if (!map.has(voice)) {
           map.set(voice, staff);
@@ -5741,7 +6026,7 @@ function inferStaff(entry, voiceToStaffMap) {
   if (entry.staff !== void 0) {
     return entry.staff;
   }
-  const inferredStaff = voiceToStaffMap.get(entry.voice);
+  const inferredStaff = voiceToStaffMap.get(entry.voice ?? 1);
   if (inferredStaff !== void 0) {
     return inferredStaff;
   }
@@ -5784,7 +6069,7 @@ function getVoicesForStaff(measure, staff) {
     if (entry.type === "note") {
       const entryStaff = entry.staff ?? 1;
       if (entryStaff === staff) {
-        voices.add(entry.voice);
+        voices.add(entry.voice ?? 1);
       }
     }
   }
@@ -6120,6 +6405,7 @@ function getDynamics(score, options) {
             if (dirType.kind === "dynamics") {
               results.push({
                 dynamic: dirType.value,
+                otherDynamics: dirType.otherDynamics,
                 direction: entry,
                 part,
                 partIndex,
@@ -7194,14 +7480,17 @@ function hasNotesInRange(voiceEntries, startPos, endPos) {
   return { hasNotes: conflicting.length > 0, conflictingNotes: conflicting };
 }
 function createRest(duration, voice, staff) {
-  return {
+  const note = {
     _id: generateId(),
     type: "note",
     rest: { displayStep: void 0, displayOctave: void 0 },
     duration,
-    voice,
     staff
   };
+  if (voice !== void 0) {
+    note.voice = voice;
+  }
+  return note;
 }
 function rebuildMeasureWithVoice(measure, voice, newEntries, measureDuration, staff) {
   const otherEntries = [];
@@ -8755,7 +9044,7 @@ function autoBeam(score, options) {
   for (const entry of measure.entries) {
     if (entry.type === "note") {
       if (!entry.chord && !entry.rest) {
-        const voice = entry.voice;
+        const voice = entry.voice ?? 1;
         if (options.voice === void 0 || voice === options.voice) {
           if (!notesByVoice.has(voice)) {
             notesByVoice.set(voice, []);