musicxml-io 0.3.2 → 0.3.3

package/dist/index.mjs

@@ -2459,6 +2459,1750 @@ function parseAuto(data) {
   return parse(xmlString);
 }
 
+// src/importers/abc.ts
+var DIVISIONS = 960;
+var NOTE_TYPE_MAP = {
+  // duration in terms of quarter notes
+  16: "long",
+  8: "breve",
+  4: "whole",
+  2: "half",
+  1: "quarter",
+  0.5: "eighth",
+  0.25: "16th",
+  0.125: "32nd",
+  0.0625: "64th"
+};
+var KEY_FIFTHS = {
+  "Cb": -7,
+  "Gb": -6,
+  "Db": -5,
+  "Ab": -4,
+  "Eb": -3,
+  "Bb": -2,
+  "F": -1,
+  "C": 0,
+  "G": 1,
+  "D": 2,
+  "A": 3,
+  "E": 4,
+  "B": 5,
+  "F#": 6,
+  "C#": 7
+};
+var MODE_OFFSET = {
+  "major": 0,
+  "maj": 0,
+  "ion": 0,
+  "ionian": 0,
+  "": 0,
+  "minor": -3,
+  "min": -3,
+  "m": -3,
+  "dorian": -2,
+  "dor": -2,
+  "phrygian": -4,
+  "phr": -4,
+  "lydian": 1,
+  "lyd": 1,
+  "mixolydian": -1,
+  "mix": -1,
+  "aeolian": -3,
+  "aeo": -3,
+  "locrian": -5,
+  "loc": -5
+};
+var MODE_NAME = {
+  "major": "major",
+  "maj": "major",
+  "ion": "ionian",
+  "ionian": "ionian",
+  "": "major",
+  "minor": "minor",
+  "min": "minor",
+  "m": "minor",
+  "dorian": "dorian",
+  "dor": "dorian",
+  "phrygian": "phrygian",
+  "phr": "phrygian",
+  "lydian": "lydian",
+  "lyd": "lydian",
+  "mixolydian": "mixolydian",
+  "mix": "mixolydian",
+  "aeolian": "aeolian",
+  "aeo": "aeolian",
+  "locrian": "locrian",
+  "loc": "locrian"
+};
+var DYNAMICS_VALUES = /* @__PURE__ */ new Set([
+  "pppppp",
+  "ppppp",
+  "pppp",
+  "ppp",
+  "pp",
+  "p",
+  "mp",
+  "mf",
+  "f",
+  "ff",
+  "fff",
+  "ffff",
+  "fffff",
+  "ffffff",
+  "sf",
+  "sfz",
+  "sffz",
+  "sfp",
+  "sfpp",
+  "fp",
+  "rf",
+  "rfz",
+  "fz",
+  "pf"
+]);
+function parseHeader(lines) {
+  const header = { voices: [], extraFields: [], directives: [] };
+  let bodyStartIndex = 0;
+  let foundKey = false;
+  let postKHeaderDone = false;
+  const headerFieldOrder = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "") continue;
+    if (line.startsWith("%%")) {
+      if (!foundKey) {
+        header.directives.push(line);
+        headerFieldOrder.push(line);
+      } else if (!postKHeaderDone) {
+        header.directives.push(line);
+        headerFieldOrder.push(line);
+        bodyStartIndex = i + 1;
+      }
+      continue;
+    }
+    if (line.startsWith("%")) {
+      if (!foundKey) {
+        headerFieldOrder.push(lines[i]);
+      } else if (!postKHeaderDone) {
+        headerFieldOrder.push(lines[i]);
+        bodyStartIndex = i + 1;
+      }
+      continue;
+    }
+    const fieldMatch = line.match(/^([A-Za-z]):\s*(.*)/);
+    const postKFields = /* @__PURE__ */ new Set(["I", "N"]);
+    if (fieldMatch && (!foundKey || fieldMatch[1] === "V" || foundKey && postKFields.has(fieldMatch[1]))) {
+      const [, field, value] = fieldMatch;
+      if (foundKey && field !== "V") {
+        if (!postKHeaderDone) {
+          header.extraFields.push({ field, value: value.trim() });
+          headerFieldOrder.push(line);
+          bodyStartIndex = i + 1;
+        }
+        continue;
+      }
+      switch (field) {
+        case "X":
+          header.referenceNumber = parseInt(value, 10);
+          headerFieldOrder.push(line);
+          break;
+        case "T":
+          header.title = value.trim();
+          headerFieldOrder.push(line);
+          break;
+        case "C":
+          header.composer = value.trim();
+          headerFieldOrder.push(line);
+          break;
+        case "M":
+          header.meter = value.trim();
+          headerFieldOrder.push(line);
+          break;
+        case "L":
+          header.unitNoteLength = value.trim();
+          headerFieldOrder.push(line);
+          break;
+        case "Q":
+          header.tempo = value.trim();
+          headerFieldOrder.push(line);
+          break;
+        case "K":
+          header.key = value.trim();
+          foundKey = true;
+          bodyStartIndex = i + 1;
+          headerFieldOrder.push(line);
+          break;
+        case "V": {
+          const voiceValue = value.trim();
+          const voiceId = voiceValue.split(/\s+/)[0];
+          const nameMatch = voiceValue.match(/name=["']?([^"'\s]+)["']?/i);
+          const nmMatch = voiceValue.match(/nm=["']([^"']*)["']/i);
+          const clefMatch = voiceValue.match(/clef=(\S+)/i);
+          const displayName = nameMatch ? nameMatch[1] : nmMatch ? nmMatch[1] : voiceId;
+          const hasParams = clefMatch || nameMatch || nmMatch || /\b(Program|merge|up|down|bass|treble|alto|tenor|soprano|octave|snm|stem)\b/i.test(voiceValue);
+          const isBodyVoiceSwitch = foundKey && !hasParams;
+          if (isBodyVoiceSwitch) {
+            postKHeaderDone = true;
+          }
+          const existingVoice = header.voices.find((v) => v.id === voiceId);
+          if (existingVoice) {
+            if (nameMatch || nmMatch) existingVoice.name = displayName;
+            if (clefMatch) existingVoice.clef = clefMatch[1];
+            if (foundKey && !isBodyVoiceSwitch) existingVoice.fullLine = lines[i];
+          } else {
+            header.voices.push({
+              id: voiceId,
+              name: displayName,
+              clef: clefMatch ? clefMatch[1] : void 0,
+              fullLine: lines[i]
+            });
+          }
+          if (!foundKey) {
+            headerFieldOrder.push(lines[i]);
+          } else if (!isBodyVoiceSwitch && !postKHeaderDone) {
+            headerFieldOrder.push(lines[i]);
+            bodyStartIndex = i + 1;
+          }
+          break;
+        }
+        default:
+          header.extraFields.push({ field, value: value.trim() });
+          headerFieldOrder.push(line);
+          break;
+      }
+    } else if (!foundKey) {
+      continue;
+    } else {
+      postKHeaderDone = true;
+      break;
+    }
+  }
+  return { header, bodyStartIndex, headerFieldOrder };
+}
+function parseKeySignature2(keyStr) {
+  if (!keyStr || keyStr.trim() === "" || keyStr.trim().toLowerCase() === "none") {
+    return { fifths: 0, mode: "major" };
+  }
+  const trimmed = keyStr.trim();
+  const keyMatch = trimmed.match(/^([A-Ga-g])(#|b)?/);
+  if (!keyMatch) {
+    return { fifths: 0, mode: "major" };
+  }
+  const keyNote = keyMatch[1].toUpperCase();
+  const keyAccidental = keyMatch[2] || "";
+  const keyName = keyNote + keyAccidental;
+  const remainder = trimmed.slice(keyMatch[0].length).trim().toLowerCase();
+  let mode = "";
+  for (const m of Object.keys(MODE_OFFSET)) {
+    if (m && remainder.startsWith(m)) {
+      mode = m;
+      break;
+    }
+  }
+  const baseFifths = KEY_FIFTHS[keyName];
+  if (baseFifths === void 0) {
+    return { fifths: 0, mode: "major" };
+  }
+  const modeOffset = MODE_OFFSET[mode] ?? 0;
+  const fifths = baseFifths + modeOffset;
+  const modeValue = MODE_NAME[mode] ?? "major";
+  return { fifths, mode: modeValue };
+}
+function parseTimeSignature2(meterStr) {
+  if (!meterStr || meterStr.trim() === "") {
+    return { beats: "4", beatType: 4 };
+  }
+  const trimmed = meterStr.trim();
+  if (trimmed === "C" || trimmed.toLowerCase() === "common") {
+    return { beats: "4", beatType: 4, symbol: "common" };
+  }
+  if (trimmed === "C|" || trimmed.toLowerCase() === "cut") {
+    return { beats: "2", beatType: 2, symbol: "cut" };
+  }
+  const match = trimmed.match(/^(\d+)\/(\d+)$/);
+  if (match) {
+    return { beats: match[1], beatType: parseInt(match[2], 10) };
+  }
+  return { beats: "4", beatType: 4 };
+}
+function parseUnitNoteLength(lengthStr, meterStr) {
+  if (lengthStr) {
+    const match = lengthStr.trim().match(/^(\d+)\/(\d+)$/);
+    if (match) {
+      return { num: parseInt(match[1], 10), den: parseInt(match[2], 10) };
+    }
+  }
+  if (meterStr) {
+    const mMatch = meterStr.trim().match(/^(\d+)\/(\d+)$/);
+    if (mMatch) {
+      const ratio = parseInt(mMatch[1], 10) / parseInt(mMatch[2], 10);
+      return ratio >= 0.75 ? { num: 1, den: 8 } : { num: 1, den: 16 };
+    }
+  }
+  return { num: 1, den: 8 };
+}
+function lengthToDuration(num, den, unitNote) {
+  const fractionOfWhole = num * unitNote.num / (den * unitNote.den);
+  return Math.round(fractionOfWhole * 4 * DIVISIONS);
+}
+function durationToNoteType(duration) {
+  const quarterNotes = duration / DIVISIONS;
+  for (const [qnStr, type] of Object.entries(NOTE_TYPE_MAP)) {
+    const qn = parseFloat(qnStr);
+    if (Math.abs(quarterNotes - qn) < 1e-3) {
+      return { noteType: type, dots: 0 };
+    }
+    if (Math.abs(quarterNotes - qn * 1.5) < 1e-3) {
+      return { noteType: type, dots: 1 };
+    }
+    if (Math.abs(quarterNotes - qn * 1.75) < 1e-3) {
+      return { noteType: type, dots: 2 };
+    }
+  }
+  let bestType = "quarter";
+  let bestDiff = Infinity;
+  for (const [qnStr, type] of Object.entries(NOTE_TYPE_MAP)) {
+    const diff = Math.abs(quarterNotes - parseFloat(qnStr));
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestType = type;
+    }
+  }
+  return { noteType: bestType, dots: 0 };
+}
+function tokenizeBody(bodyLines) {
+  const voiceTokens = /* @__PURE__ */ new Map();
+  let currentVoice = "1";
+  voiceTokens.set(currentVoice, []);
+  let isContinuation = false;
+  const inlineVoiceMarkers = /* @__PURE__ */ new Map();
+  const voiceDeclarationLines = [];
+  const bodyComments = [];
+  const bodyDirectives = [];
+  const wFields = [];
+  const voiceInterleavePattern = [];
+  let currentGroup = [];
+  let lastVoiceInGroup = null;
+  const groupBarCounts = [];
+  let currentGroupBarCounts = [];
+  let currentVoiceBarCount = 0;
+  const voiceBarCounts = /* @__PURE__ */ new Map();
+  const voiceCommentsMap = /* @__PURE__ */ new Map();
+  const preVoiceComments = [];
+  let pendingComments = [];
+  function flushPendingToVoice(voiceId) {
+    if (pendingComments.length === 0) return;
+    if (!voiceCommentsMap.has(voiceId)) {
+      voiceCommentsMap.set(voiceId, []);
+    }
+    const barCount = voiceBarCounts.get(voiceId) || 0;
+    for (const comment of pendingComments) {
+      voiceCommentsMap.get(voiceId).push({ barIndex: barCount, comment });
+    }
+    pendingComments = [];
+  }
+  for (const rawLine of bodyLines) {
+    const trimmedEnd = rawLine.trimEnd();
+    const hasLineContinuation = trimmedEnd.endsWith("\\");
+    const lineContent = hasLineContinuation ? trimmedEnd.slice(0, -1) : rawLine;
+    const line = lineContent.trim();
+    const wFieldMatch = line.match(/^W:(.*)/);
+    if (wFieldMatch) {
+      wFields.push(rawLine);
+      isContinuation = false;
+      continue;
+    }
+    if (line === "") {
+      isContinuation = false;
+      continue;
+    }
+    const isRealDirective = line.startsWith("%%") && /^%%[A-Za-z]/.test(line);
+    const isComment = line.startsWith("%") && !isRealDirective;
+    if (isComment) {
+      pendingComments.push(rawLine);
+      isContinuation = false;
+      continue;
+    }
+    if (isRealDirective) {
+      bodyDirectives.push(rawLine);
+      isContinuation = false;
+      continue;
+    }
+    const voiceMatch = line.match(/^V:\s*(\S+)/);
+    if (voiceMatch) {
+      const newVoice = voiceMatch[1];
+      if (currentGroup.includes(newVoice)) {
+        if (lastVoiceInGroup !== null) {
+          currentGroupBarCounts.push(currentVoiceBarCount);
+          currentVoiceBarCount = 0;
+        }
+        groupBarCounts.push(currentGroupBarCounts);
+        currentGroupBarCounts = [];
+        voiceInterleavePattern.push(currentGroup);
+        currentGroup = [];
+        lastVoiceInGroup = null;
+        for (const c of pendingComments) {
+          bodyComments.push(c);
+        }
+        pendingComments = [];
+      }
+      preVoiceComments.push([...pendingComments]);
+      pendingComments = [];
+      currentVoice = newVoice;
+      if (!voiceTokens.has(currentVoice)) {
+        voiceTokens.set(currentVoice, []);
+      }
+      voiceDeclarationLines.push(rawLine);
+      if (lastVoiceInGroup !== currentVoice) {
+        if (lastVoiceInGroup !== null) {
+          currentGroupBarCounts.push(currentVoiceBarCount);
+          currentVoiceBarCount = 0;
+        }
+        currentGroup.push(currentVoice);
+        lastVoiceInGroup = currentVoice;
+      }
+      isContinuation = false;
+      continue;
+    }
+    const lyricsMatch = line.match(/^w:\s*(.*)/);
+    if (lyricsMatch) {
+      const syllables = parseLyricLine(lyricsMatch[1]);
+      voiceTokens.get(currentVoice).push({
+        type: "lyrics",
+        value: lyricsMatch[1],
+        syllables
+      });
+      isContinuation = false;
+      continue;
+    }
+    const bodyKeyMatch = line.match(/^K:\s*(.*)/);
+    if (bodyKeyMatch) {
+      const currentTokens2 = voiceTokens.get(currentVoice);
+      if (currentTokens2.length > 0) {
+        const lastToken = currentTokens2[currentTokens2.length - 1];
+        if (lastToken.type !== "line_break") {
+          currentTokens2.push({ type: "line_break", value: "\n" });
+        }
+      }
+      currentTokens2.push({ type: "inline_field", value: `K:${bodyKeyMatch[1]}` });
+      currentTokens2.push({ type: "line_break", value: "\n" });
+      isContinuation = false;
+      continue;
+    }
+    if (/^[A-Za-z]:\s*/.test(line) && !/^\[/.test(line)) {
+      isContinuation = false;
+      continue;
+    }
+    flushPendingToVoice(currentVoice);
+    if (!currentGroup.includes(currentVoice)) {
+      if (lastVoiceInGroup !== null) {
+        currentGroupBarCounts.push(currentVoiceBarCount);
+        currentVoiceBarCount = 0;
+      }
+      currentGroup.push(currentVoice);
+      lastVoiceInGroup = currentVoice;
+    }
+    const tokens = tokenizeMusicLine(lineContent);
+    const currentTokens = voiceTokens.get(currentVoice);
+    if (currentTokens.length > 0 && !isContinuation) {
+      const lastToken = currentTokens[currentTokens.length - 1];
+      if (lastToken.type !== "line_break") {
+        currentTokens.push({ type: "line_break", value: "\n" });
+      }
+    }
+    for (const token of tokens) {
+      if (token.type === "inline_field") {
+        const fieldMatch = token.value.match(/^V:\s*(.+)/);
+        if (fieldMatch) {
+          const voiceId = fieldMatch[1].trim().split(/\s+/)[0];
+          currentVoice = voiceId;
+          if (!voiceTokens.has(currentVoice)) {
+            voiceTokens.set(currentVoice, []);
+          }
+          if (!inlineVoiceMarkers.has(voiceId)) {
+            inlineVoiceMarkers.set(voiceId, `[${token.value}]`);
+          }
+          continue;
+        }
+      }
+      voiceTokens.get(currentVoice).push(token);
+      if (token.type === "bar") {
+        currentVoiceBarCount++;
+        voiceBarCounts.set(currentVoice, (voiceBarCounts.get(currentVoice) || 0) + 1);
+      }
+    }
+    if (hasLineContinuation) {
+      voiceTokens.get(currentVoice).push({ type: "line_break", value: "\\\n" });
+      isContinuation = true;
+    } else {
+      isContinuation = false;
+    }
+  }
+  const result = [];
+  const voiceIds = [];
+  for (const [voiceId, tokens] of voiceTokens) {
+    if (tokens.length > 0) {
+      result.push(tokens);
+      voiceIds.push(voiceId);
+    }
+  }
+  const trailingComments = [...pendingComments];
+  pendingComments = [];
+  if (currentGroup.length > 0) {
+    currentGroupBarCounts.push(currentVoiceBarCount);
+    groupBarCounts.push(currentGroupBarCounts);
+    voiceInterleavePattern.push(currentGroup);
+  }
+  const voiceComments = {};
+  for (const [voiceId, comments] of voiceCommentsMap) {
+    voiceComments[voiceId] = comments;
+  }
+  return { tokens: result.length > 0 ? result : [[]], voiceIds, inlineVoiceMarkers, voiceDeclarationLines, bodyComments, bodyDirectives, wFields, voiceInterleavePattern, groupBarCounts, voiceComments, preVoiceComments, trailingComments };
+}
+function parseLyricLine(text) {
+  const parts = [];
+  const tokens = text.split(/\s+/);
+  for (const token of tokens) {
+    if (token === "") continue;
+    const syllables = token.split("-");
+    for (let i = 0; i < syllables.length; i++) {
+      if (syllables[i] === "" && i > 0) continue;
+      parts.push(syllables[i] + (i < syllables.length - 1 ? "-" : ""));
+    }
+  }
+  return parts;
+}
+function tokenizeMusicLine(line) {
+  const tokens = [];
+  let i = 0;
+  while (i < line.length) {
+    const ch = line[i];
+    if (ch === " " || ch === "	") {
+      tokens.push({ type: "space", value: " " });
+      while (i < line.length && (line[i] === " " || line[i] === "	")) i++;
+      continue;
+    }
+    if (ch === "%") break;
+    if (ch === '"') {
+      const end = line.indexOf('"', i + 1);
+      if (end !== -1) {
+        tokens.push({ type: "chord_symbol", value: line.slice(i + 1, end) });
+        i = end + 1;
+        continue;
+      }
+    }
+    if (ch === "!") {
+      const end = line.indexOf("!", i + 1);
+      if (end !== -1) {
+        tokens.push({ type: "decoration", value: line.slice(i + 1, end) });
+        i = end + 1;
+        continue;
+      }
+    }
+    if (ch === "{") {
+      tokens.push({ type: "grace_start", value: "{" });
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      tokens.push({ type: "grace_end", value: "}" });
+      i++;
+      continue;
+    }
+    if (ch === "(" && i + 1 < line.length && /\d/.test(line[i + 1])) {
+      const tupletResult = parseTuplet(line, i);
+      if (tupletResult) {
+        tokens.push(tupletResult.token);
+        i = tupletResult.nextIndex;
+        continue;
+      }
+    }
+    if (ch === "(") {
+      tokens.push({ type: "slur_start", value: "(" });
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ type: "slur_end", value: ")" });
+      i++;
+      continue;
+    }
+    if (ch === "-") {
+      tokens.push({ type: "tie", value: "-" });
+      i++;
+      continue;
+    }
+    if (ch === "|" || ch === ":" || ch === "[" && (i + 1 < line.length && line[i + 1] === "|")) {
+      const barResult = parseBarLine(line, i);
+      if (barResult) {
+        tokens.push(barResult.token);
+        i = barResult.nextIndex;
+        if (i < line.length && /\d/.test(line[i])) {
+          const numMatch = line.slice(i).match(/^(\d+)/);
+          if (numMatch) {
+            tokens.push({ type: "ending", value: numMatch[1] });
+            i += numMatch[1].length;
+            if (i < line.length && line[i] === " ") i++;
+          }
+        }
+        continue;
+      }
+    }
+    if (ch === "[" && i + 1 < line.length && /\d/.test(line[i + 1])) {
+      const numMatch = line.slice(i + 1).match(/^(\d+)/);
+      if (numMatch) {
+        tokens.push({ type: "ending", value: numMatch[1], bracket: true });
+        i += 1 + numMatch[1].length;
+        if (i < line.length && line[i] === " ") i++;
+        continue;
+      }
+    }
+    if (ch === "[" && i + 1 < line.length && /[A-Za-z]/.test(line[i + 1])) {
+      const colonIdx = line.indexOf(":", i + 2);
+      if (colonIdx !== -1 && colonIdx <= i + 3) {
+        const end = line.indexOf("]", colonIdx);
+        if (end !== -1) {
+          tokens.push({ type: "inline_field", value: line.slice(i + 1, end) });
+          i = end + 1;
+          continue;
+        }
+      }
+    }
+    if (ch === ">" || ch === "<") {
+      let val = ch;
+      let j = i + 1;
+      while (j < line.length && line[j] === ch) {
+        val += line[j];
+        j++;
+      }
+      tokens.push({ type: "broken_rhythm", value: val });
+      i = j;
+      continue;
+    }
+    if (ch === "&") {
+      tokens.push({ type: "overlay", value: "&" });
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      tokens.push({ type: "chord_start", value: "[" });
+      i++;
+      continue;
+    }
+    if (ch === "]") {
+      i++;
+      const dur = parseDuration(line, i);
+      i = dur.nextIndex;
+      tokens.push({ type: "chord_end", value: "]", durationNum: dur.num, durationDen: dur.den });
+      continue;
+    }
+    if ((ch === "v" || ch === "u" || ch === "T" || ch === "M") && i + 1 < line.length) {
+      const nextCh = line[i + 1];
+      if (isNoteStart(nextCh) || nextCh === "[" || nextCh === "z" || nextCh === "x" || nextCh === "v" || nextCh === "u" || nextCh === "T" || nextCh === "M" || nextCh === "(" || nextCh === "!" || nextCh === '"') {
+        tokens.push({ type: "decoration", value: ch });
+        i++;
+        continue;
+      }
+    }
+    if (isNoteStart(ch) || ch === "z" || ch === "Z" || ch === "x" || ch === "X") {
+      const noteResult = parseNoteToken(line, i);
+      if (noteResult) {
+        tokens.push(noteResult.token);
+        i = noteResult.nextIndex;
+        continue;
+      }
+    }
+    i++;
+  }
+  return tokens;
+}
+function isNoteStart(ch) {
+  return /[A-Ga-g^_=]/.test(ch);
+}
+function parseTuplet(line, i) {
+  const match = line.slice(i).match(/^\((\d+)(?::(\d*)(?::(\d*))?)?/);
+  if (!match) return null;
+  const p = parseInt(match[1], 10);
+  let q;
+  let r;
+  if (match[2] !== void 0 && match[2] !== "") {
+    q = parseInt(match[2], 10);
+  }
+  if (match[3] !== void 0 && match[3] !== "") {
+    r = parseInt(match[3], 10);
+  }
+  if (q === void 0) {
+    if (p === 2) q = 3;
+    else if (p === 3) q = 2;
+    else if (p === 4) q = 3;
+    else if (p === 5 || p === 6) q = 2;
+    else if (p === 7 || p === 8 || p === 9) q = 2;
+    else q = 2;
+  }
+  if (r === void 0) {
+    r = p;
+  }
+  return {
+    token: { type: "tuplet", value: match[0], tupletP: p, tupletQ: q, tupletR: r },
+    nextIndex: i + match[0].length
+  };
+}
+function parseBarLine(line, i) {
+  const patterns = [
+    [":|]", "end-repeat-final"],
+    [":||:", "double-repeat"],
+    ["::", "double-repeat"],
+    [":|:", "double-repeat"],
+    ["|>|", "thick-thin"],
+    ["|:", "start-repeat"],
+    [":|", "end-repeat"],
+    ["||", "double"],
+    ["|]", "final"],
+    ["[|", "heavy-light"],
+    ["|", "regular"]
+  ];
+  for (const [pat, type] of patterns) {
+    if (line.slice(i).startsWith(pat)) {
+      return {
+        token: { type: "bar", value: pat, barType: type },
+        nextIndex: i + pat.length
+      };
+    }
+  }
+  if (line[i] === ":" && i + 1 < line.length && line[i + 1] === "|") {
+    return {
+      token: { type: "bar", value: ":|", barType: "end-repeat" },
+      nextIndex: i + 2
+    };
+  }
+  return null;
+}
+function parseNoteToken(line, i) {
+  const start = i;
+  if (line[i] === "z" || line[i] === "Z" || line[i] === "x" || line[i] === "X") {
+    i++;
+    const dur2 = parseDuration(line, i);
+    i = dur2.nextIndex;
+    return {
+      token: {
+        type: "rest",
+        value: line.slice(start, i),
+        durationNum: dur2.num,
+        durationDen: dur2.den
+      },
+      nextIndex: i
+    };
+  }
+  let accidental = 0;
+  let explicitNatural = false;
+  if (line[i] === "^") {
+    accidental = 1;
+    i++;
+    if (i < line.length && line[i] === "^") {
+      accidental = 2;
+      i++;
+    }
+  } else if (line[i] === "_") {
+    accidental = -1;
+    i++;
+    if (i < line.length && line[i] === "_") {
+      accidental = -2;
+      i++;
+    }
+  } else if (line[i] === "=") {
+    accidental = 0;
+    explicitNatural = true;
+    i++;
+  }
+  if (i >= line.length || !/[A-Ga-g]/.test(line[i])) {
+    return null;
+  }
+  const noteLetter = line[i];
+  i++;
+  const pitch = abcNoteToPitch(noteLetter, accidental);
+  while (i < line.length && (line[i] === "'" || line[i] === ",")) {
+    if (line[i] === "'") {
+      pitch.octave++;
+    } else {
+      pitch.octave--;
+    }
+    i++;
+  }
+  const dur = parseDuration(line, i);
+  i = dur.nextIndex;
+  const token = {
+    type: "note",
+    value: line.slice(start, i),
+    pitch,
+    durationNum: dur.num,
+    durationDen: dur.den,
+    accidental: accidental !== 0 || explicitNatural ? accidental : void 0
+  };
+  if (explicitNatural) {
+    token.explicitNatural = true;
+  }
+  return {
+    token,
+    nextIndex: i
+  };
+}
+function abcNoteToPitch(letter, accidental) {
+  const isLower = letter === letter.toLowerCase();
+  const step = letter.toUpperCase();
+  const octave = isLower ? 5 : 4;
+  const pitch = { step, octave };
+  if (accidental !== 0) {
+    pitch.alter = accidental;
+  }
+  return pitch;
+}
+function parseDuration(line, i) {
+  let num = 1;
+  let den = 1;
+  const numMatch = line.slice(i).match(/^(\d+)/);
+  if (numMatch) {
+    num = parseInt(numMatch[1], 10);
+    i += numMatch[1].length;
+  }
+  if (i < line.length && line[i] === "/") {
+    i++;
+    const denMatch = line.slice(i).match(/^(\d+)/);
+    if (denMatch) {
+      den = parseInt(denMatch[1], 10);
+      i += denMatch[1].length;
+    } else {
+      den = 2;
+      while (i < line.length && line[i] === "/") {
+        den *= 2;
+        i++;
+      }
+    }
+  }
+  return { num, den, nextIndex: i };
+}
+function buildScore(header, voiceTokensList, voiceIds, headerFieldOrder, inlineVoiceMarkers = /* @__PURE__ */ new Map(), voiceDeclarationLines = [], bodyComments = [], bodyDirectives = [], wFields = [], voiceInterleavePattern = [], groupBarCounts = [], voiceComments = {}, preVoiceComments = [], trailingComments = []) {
+  const unitNote = parseUnitNoteLength(header.unitNoteLength, header.meter);
+  const timeSignature = parseTimeSignature2(header.meter || "4/4");
+  const keySignature = parseKeySignature2(header.key || "C");
+  const beatsNum = parseInt(timeSignature.beats, 10);
+  const beatType = timeSignature.beatType;
+  const measureDuration = Math.round(beatsNum / beatType * 4 * DIVISIONS);
+  const parts = [];
+  const partListEntries = [];
+  const miscellaneous = [];
+  if (header.referenceNumber !== void 0) {
+    miscellaneous.push({ name: "abc-reference-number", value: String(header.referenceNumber) });
+  }
+  if (header.unitNoteLength) {
+    miscellaneous.push({ name: "abc-unit-note-length", value: header.unitNoteLength });
+  }
+  if (header.tempo) {
+    miscellaneous.push({ name: "abc-tempo", value: header.tempo });
+  }
+  const extraCreators = [];
+  let sourceValue;
+  const encoderValues = [];
+  if (header.extraFields && header.extraFields.length > 0) {
+    for (const ef of header.extraFields) {
+      switch (ef.field) {
+        case "S":
+          sourceValue = ef.value;
+          break;
+        case "Z":
+          encoderValues.push(ef.value);
+          break;
+        case "O":
+          extraCreators.push({ type: "origin", value: ef.value });
+          break;
+        default:
+          miscellaneous.push({ name: `abc-${ef.field}`, value: ef.value });
+          break;
+      }
+    }
+  }
+  if (header.directives && header.directives.length > 0) {
+    miscellaneous.push({ name: "abc-directives", value: JSON.stringify(header.directives) });
+  }
+  if (headerFieldOrder.length > 0) {
+    miscellaneous.push({ name: "abc-header-order", value: JSON.stringify(headerFieldOrder) });
+  }
+  if (voiceIds.length > 0) {
+    miscellaneous.push({ name: "abc-voice-ids", value: JSON.stringify(voiceIds) });
+  }
+  if (inlineVoiceMarkers.size > 0) {
+    const markersObj = {};
+    for (const [id, marker] of inlineVoiceMarkers) {
+      markersObj[id] = marker;
+    }
+    miscellaneous.push({ name: "abc-inline-voice-markers", value: JSON.stringify(markersObj) });
+  }
+  if (voiceDeclarationLines.length > 0 && inlineVoiceMarkers.size > 0) {
+    miscellaneous.push({ name: "abc-voice-declaration-lines", value: JSON.stringify(voiceDeclarationLines) });
+  }
+  if (voiceDeclarationLines.length > 0) {
+    miscellaneous.push({ name: "abc-body-voice-lines", value: JSON.stringify(voiceDeclarationLines) });
+  }
+  if (bodyComments.length > 0) {
+    miscellaneous.push({ name: "abc-body-comments", value: JSON.stringify(bodyComments) });
+  }
+  if (bodyDirectives.length > 0) {
+    miscellaneous.push({ name: "abc-body-directives", value: JSON.stringify(bodyDirectives) });
+  }
+  if (wFields.length > 0) {
+    miscellaneous.push({ name: "abc-w-fields", value: JSON.stringify(wFields) });
+  }
+  if (voiceInterleavePattern.length > 0) {
+    miscellaneous.push({ name: "abc-voice-interleave", value: JSON.stringify(voiceInterleavePattern) });
+  }
+  if (groupBarCounts.length > 0) {
+    miscellaneous.push({ name: "abc-group-bar-counts", value: JSON.stringify(groupBarCounts) });
+  }
+  if (Object.keys(voiceComments).length > 0) {
+    miscellaneous.push({ name: "abc-voice-comments", value: JSON.stringify(voiceComments) });
+  }
+  if (preVoiceComments.length > 0) {
+    miscellaneous.push({ name: "abc-pre-voice-comments", value: JSON.stringify(preVoiceComments) });
+  }
+  if (trailingComments.length > 0) {
+    miscellaneous.push({ name: "abc-trailing-comments", value: JSON.stringify(trailingComments) });
+  }
+  const voiceFullLines = {};
+  for (const voice of header.voices || []) {
+    if (voice.fullLine) {
+      voiceFullLines[voice.id] = voice.fullLine;
+    }
+  }
+  if (Object.keys(voiceFullLines).length > 0) {
+    miscellaneous.push({ name: "abc-voice-full-lines", value: JSON.stringify(voiceFullLines) });
+  }
+  for (let voiceIndex = 0; voiceIndex < voiceTokensList.length; voiceIndex++) {
+    const tokens = voiceTokensList[voiceIndex];
+    const partId = `P${voiceIndex + 1}`;
+    const voiceId = voiceIds[voiceIndex];
+    const headerVoice = header.voices?.find((v) => v.id === voiceId) || header.voices && header.voices[voiceIndex];
+    const voiceName = headerVoice ? headerVoice.name || `Voice ${voiceIndex + 1}` : voiceTokensList.length > 1 ? `Voice ${voiceIndex + 1}` : "Music";
+    partListEntries.push({
+      _id: generateId(),
+      type: "score-part",
+      id: partId,
+      name: voiceName
+    });
+    const voiceClef = headerVoice ? abcClefToMusicXml(headerVoice.clef) : void 0;
+    const buildResult = buildMeasures(tokens, unitNote, keySignature, timeSignature, measureDuration, voiceClef);
+    parts.push({
+      _id: generateId(),
+      id: partId,
+      measures: buildResult.measures
+    });
+    if (buildResult.lineBreaks.length > 0) {
+      if (voiceIndex === 0) {
+        miscellaneous.push({ name: "abc-line-breaks", value: JSON.stringify(buildResult.lineBreaks) });
+      }
+      miscellaneous.push({ name: `abc-line-breaks-${voiceIndex}`, value: JSON.stringify(buildResult.lineBreaks) });
+    }
+    if (buildResult.hasIndividualChordDurations) {
+      miscellaneous.push({ name: "abc-chord-individual-durations", value: "true" });
+    }
+    if (voiceIndex === 0) {
+      let hasLyrics2 = false;
+      let lyricsAfterAll = true;
+      let seenLyrics = false;
+      const lyricLineCounts = [];
+      for (const token of tokens) {
+        if (token.type === "lyrics") {
+          hasLyrics2 = true;
+          seenLyrics = true;
+          lyricLineCounts.push(token.syllables?.length || 0);
+        } else if (seenLyrics && (token.type === "note" || token.type === "rest" || token.type === "bar")) {
+          lyricsAfterAll = false;
+        }
+      }
+      if (hasLyrics2 && lyricsAfterAll) {
+        miscellaneous.push({ name: "abc-lyrics-after-all", value: "true" });
+      }
+      if (hasLyrics2 && lyricLineCounts.length > 0) {
+        miscellaneous.push({ name: "abc-lyrics-line-counts", value: JSON.stringify(lyricLineCounts) });
+      }
+    }
+  }
+  if (header.tempo && parts.length > 0 && parts[0].measures.length > 0) {
+    const tempoDirection = parseTempoToDirection(header.tempo);
+    if (tempoDirection) {
+      parts[0].measures[0].entries.unshift(tempoDirection);
+    }
+  }
+  const creators = [];
+  if (header.composer) {
+    creators.push({ type: "composer", value: header.composer });
+  }
+  creators.push(...extraCreators);
+  const encoding = {
+    software: ["musicxml-io (ABC import)"]
+  };
+  if (encoderValues.length > 0) {
+    encoding.encoder = encoderValues;
+  }
+  return {
+    _id: generateId(),
+    metadata: {
+      movementTitle: header.title,
+      creators: creators.length > 0 ? creators : void 0,
+      source: sourceValue,
+      encoding,
+      miscellaneous: miscellaneous.length > 0 ? miscellaneous : void 0
+    },
+    partList: partListEntries,
+    parts,
+    version: "4.0"
+  };
+}
+function parseTempoToDirection(tempoStr) {
+  const match = tempoStr.match(/(?:(\d+)\/(\d+)\s*=\s*)?(\d+)/);
+  if (!match) return null;
+  const perMinute = parseInt(match[3], 10);
+  let beatUnit = "quarter";
+  if (match[1] && match[2]) {
+    const num = parseInt(match[1], 10);
+    const den = parseInt(match[2], 10);
+    const quarterNotes = num / den * 4;
+    const found = NOTE_TYPE_MAP[quarterNotes];
+    if (found) beatUnit = found;
+  }
+  return {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{ kind: "metronome", beatUnit, perMinute }],
+    placement: "above",
+    sound: { tempo: perMinute }
+  };
+}
+function abcClefToMusicXml(abcClef) {
+  if (!abcClef) return { sign: "G", line: 2 };
+  const c = abcClef.toLowerCase();
+  if (c === "treble" || c === "treble-8va" || c === "treble+8") return { sign: "G", line: 2 };
+  if (c === "bass" || c === "bass3") return { sign: "F", line: 4 };
+  if (c === "alto") return { sign: "C", line: 3 };
+  if (c === "tenor") return { sign: "C", line: 4 };
+  if (c === "soprano") return { sign: "C", line: 1 };
+  if (c === "mezzo" || c === "mezzo-soprano") return { sign: "C", line: 2 };
+  if (c === "baritone") return { sign: "C", line: 5 };
+  if (c === "perc" || c === "percussion") return { sign: "percussion" };
+  return { sign: "G", line: 2 };
+}
+function buildMeasures(tokens, unitNote, keySignature, timeSignature, measureDuration, clef) {
+  const measures = [];
+  let currentEntries = [];
+  let hasIndividualChordDurations = false;
+  let currentBarlines = [];
+  let currentPosition = 0;
+  let measureNumber = 1;
+  let isFirstMeasure = true;
+  let pendingTie = false;
+  let slurDepth = 0;
+  let pendingSlurStarts = 0;
+  let slurStartNotes = [];
+  let inGrace = false;
+  let pendingBrokenRhythm = null;
+  let tupletState = null;
+  const pendingPreNoteItems = [];
+  let pendingEndingNumber = null;
+  let currentLyrics = [];
+  let noteCountForLyrics = 0;
+  let inChord = false;
+  let chordNotes = [];
+  let chordNoteTies = [];
+  let currentUnitNote = { ...unitNote };
+  let pendingTupletStart = false;
+  let pendingKeyChange = null;
+  const lineBreaks = [];
+  function flushPendingPreNoteItems() {
+    for (const item of pendingPreNoteItems) {
+      if (item.kind === "harmony") {
+        const harmony = createHarmonyEntry(item.value);
+        if (harmony) currentEntries.push(harmony);
+      } else if (item.kind === "dynamic") {
+        const dynDir = createDynamicsDirection(item.value);
+        if (dynDir) currentEntries.push(dynDir);
+      } else if (item.kind === "decoration") {
+        const decoDir = {
+          _id: generateId(),
+          type: "direction",
+          directionTypes: [{ kind: "words", text: item.value }]
+        };
+        currentEntries.push(decoDir);
+      }
+    }
+    pendingPreNoteItems.length = 0;
+  }
+  function finalizeMeasure(endBarType) {
+    const measure = {
+      _id: generateId(),
+      number: String(measureNumber),
+      entries: currentEntries
+    };
+    if (isFirstMeasure) {
+      measure.attributes = {
+        divisions: DIVISIONS,
+        time: timeSignature,
+        key: keySignature,
+        clef: [clef || { sign: "G", line: 2 }]
+      };
+      isFirstMeasure = false;
+    }
+    if (pendingKeyChange) {
+      if (!measure.attributes) {
+        measure.attributes = {};
+      }
+      const kValue = pendingKeyChange.replace(/^K:\s*/, "");
+      measure.attributes.key = parseKeySignature2(kValue);
+      pendingKeyChange = null;
+    }
+    if (endBarType || currentBarlines.length > 0) {
+      measure.barlines = [...currentBarlines];
+      if (endBarType) {
+        const barline = createBarline(endBarType, "right", pendingEndingNumber);
+        if (barline) {
+          measure.barlines.push(barline);
+        }
+        pendingEndingNumber = null;
+      }
+    }
+    measures.push(measure);
+    currentEntries = [];
+    currentBarlines = [];
+    currentPosition = 0;
+    measureNumber++;
+  }
+  for (let ti = 0; ti < tokens.length; ti++) {
+    const token = tokens[ti];
+    switch (token.type) {
+      case "note": {
+        if (inChord) {
+          chordNotes.push(token);
+          break;
+        }
+        const entry = createNoteEntry(token, currentUnitNote, pendingTie, inGrace, tupletState);
+        pendingTie = false;
+        if (pendingBrokenRhythm) {
+          const n = pendingBrokenRhythm.length;
+          const divisor = Math.pow(2, n);
+          if (pendingBrokenRhythm[0] === ">") {
+            entry.duration = Math.round(entry.duration / divisor);
+          } else {
+            entry.duration = Math.round(entry.duration * (2 * divisor - 1) / divisor);
+          }
+          pendingBrokenRhythm = null;
+        }
+        if (pendingTupletStart && !inGrace) {
+          pendingTupletStart = false;
+        }
+        flushPendingPreNoteItems();
+        while (pendingSlurStarts > 0) {
+          if (!entry.notations) entry.notations = [];
+          entry.notations.push({ type: "slur", slurType: "start", number: slurDepth - pendingSlurStarts + 1 });
+          slurStartNotes.push(entry);
+          pendingSlurStarts--;
+        }
+        if (currentLyrics.length > noteCountForLyrics && !entry.rest && !entry.grace) {
+          const syllable = currentLyrics[noteCountForLyrics];
+          if (syllable && syllable !== "" && syllable !== "*") {
+            const isHyphenated = syllable.endsWith("-");
+            const text = isHyphenated ? syllable.slice(0, -1) : syllable;
+            entry.lyrics = [{
+              number: 1,
+              text,
+              syllabic: isHyphenated ? "begin" : "single"
+            }];
+            if (isHyphenated && noteCountForLyrics + 1 < currentLyrics.length) {
+              const nextSyllable = currentLyrics[noteCountForLyrics + 1];
+              if (nextSyllable && !nextSyllable.endsWith("-")) {
+              }
+            }
+            if (noteCountForLyrics > 0) {
+              const prevSyllable = currentLyrics[noteCountForLyrics - 1];
+              if (prevSyllable && prevSyllable.endsWith("-")) {
+                entry.lyrics[0].syllabic = isHyphenated ? "middle" : "end";
+              }
+            }
+          }
+          noteCountForLyrics++;
+        }
+        if (!inGrace) {
+          currentEntries.push(entry);
+          currentPosition += entry.duration;
+          if (tupletState) {
+            tupletState.remaining--;
+            if (tupletState.remaining <= 0) {
+              tupletState = null;
+            }
+          }
+        } else {
+          currentEntries.push(entry);
+        }
+        break;
+      }
+      case "rest": {
+        if (inChord) break;
+        const restEntry = createRestEntry(token, currentUnitNote, tupletState, measureDuration);
+        flushPendingPreNoteItems();
+        currentEntries.push(restEntry);
+        currentPosition += restEntry.duration;
+        if (tupletState) {
+          tupletState.remaining--;
+          if (tupletState.remaining <= 0) {
+            tupletState = null;
+          }
+        }
+        break;
+      }
+      case "chord_start":
+        inChord = true;
+        chordNotes = [];
+        chordNoteTies = [];
+        break;
+      case "chord_end": {
+        inChord = false;
+        if (chordNotes.length > 0) {
+          for (const item of pendingPreNoteItems) {
+            if (item.kind === "harmony") {
+              const harmony = createHarmonyEntry(item.value);
+              if (harmony) currentEntries.push(harmony);
+            } else if (item.kind === "dynamic") {
+              const dynDir = createDynamicsDirection(item.value);
+              if (dynDir) currentEntries.push(dynDir);
+            }
+          }
+          pendingPreNoteItems.length = 0;
+          const chordDurNum = token.durationNum || 1;
+          const chordDurDen = token.durationDen || 1;
+          const hasIndividualDurations = chordNotes.some(
+            (cn) => cn.durationNum !== void 0 && cn.durationNum !== 1 || cn.durationDen !== void 0 && cn.durationDen !== 1
+          );
+          const useIndividualDurations = hasIndividualDurations && chordDurNum === 1 && chordDurDen === 1;
+          if (useIndividualDurations) hasIndividualChordDurations = true;
+          for (let ci = 0; ci < chordNotes.length; ci++) {
+            const chordToken = chordNotes[ci];
+            const originalNum = chordToken.durationNum;
+            const originalDen = chordToken.durationDen;
+            if (!useIndividualDurations) {
+              chordToken.durationNum = chordDurNum;
+              chordToken.durationDen = chordDurDen;
+            }
+            const entry = createNoteEntry(chordToken, currentUnitNote, false, inGrace, tupletState);
+            chordToken.durationNum = originalNum;
+            chordToken.durationDen = originalDen;
+            if (ci === 0) {
+              while (pendingSlurStarts > 0) {
+                if (!entry.notations) entry.notations = [];
+                entry.notations.push({ type: "slur", slurType: "start", number: slurDepth - pendingSlurStarts + 1 });
+                slurStartNotes.push(entry);
+                pendingSlurStarts--;
+              }
+              if (useIndividualDurations) {
+                entry._abcIndividualChordDurations = true;
+              }
+            } else {
+              entry.chord = true;
+            }
+            if (chordNoteTies[ci]) {
+              entry.tie = { type: "start" };
+              entry.ties = [{ type: "start" }];
+              if (!entry.notations) entry.notations = [];
+              entry.notations.push({ type: "tied", tiedType: "start" });
+            }
+            currentEntries.push(entry);
+            if (ci === 0) {
+              currentPosition += entry.duration;
+            }
+          }
+        }
+        chordNotes = [];
+        break;
+      }
+      case "bar": {
+        flushPendingPreNoteItems();
+        const barType = token.barType || "regular";
+        if (barType === "double-repeat") {
+          finalizeMeasure("end-repeat");
+          currentBarlines.push(createBarline("start-repeat", "left", null));
+        } else if (barType === "end-repeat") {
+          finalizeMeasure("end-repeat");
+        } else if (barType === "start-repeat") {
+          if (currentEntries.length > 0) {
+            finalizeMeasure("regular");
+          }
+          currentBarlines.push(createBarline("start-repeat", "left", null));
+        } else if (barType === "final") {
+          finalizeMeasure("final");
+        } else if (barType === "end-repeat-final") {
+          finalizeMeasure("end-repeat");
+        } else {
+          if (currentEntries.length > 0 || currentBarlines.length > 0) {
+            finalizeMeasure(barType !== "regular" ? barType : void 0);
+          }
+        }
+        break;
+      }
+      case "ending": {
+        const prevTok = ti > 0 ? tokens[ti - 1] : null;
+        const prevBarType = prevTok?.barType || "regular";
+        if (!token.bracket && prevTok?.type === "bar" && prevBarType !== "regular" && measures.length > 0) {
+          const lastMeasure = measures[measures.length - 1];
+          const rightBl = lastMeasure.barlines?.find((b) => b.location === "right");
+          if (rightBl) {
+            const endingBarline2 = {
+              _id: generateId(),
+              location: "left",
+              barStyle: rightBl.barStyle,
+              repeat: rightBl.repeat,
+              ending: { number: token.value, type: "start" }
+            };
+            lastMeasure.barlines = lastMeasure.barlines.filter((b) => b !== rightBl);
+            currentBarlines.push(endingBarline2);
+            break;
+          }
+        }
+        const endingBarline = {
+          _id: generateId(),
+          location: "left",
+          ending: {
+            number: token.value,
+            type: "start"
+          }
+        };
+        if (ti > 0 && tokens[ti - 1].type === "bar" && (!tokens[ti - 1].barType || tokens[ti - 1].barType === "regular") && currentEntries.length === 0) {
+          endingBarline.barStyle = "regular";
+        }
+        currentBarlines.push(endingBarline);
+        break;
+      }
+      case "tie":
+        if (inChord) {
+          if (chordNotes.length > 0) {
+            chordNoteTies[chordNotes.length - 1] = true;
+          }
+        } else {
+          pendingTie = true;
+          for (let ei = currentEntries.length - 1; ei >= 0; ei--) {
+            const e = currentEntries[ei];
+            if (e.type === "note" && !e.rest) {
+              e.tie = { type: "start" };
+              e.ties = [{ type: "start" }];
+              if (!e.notations) e.notations = [];
+              e.notations.push({ type: "tied", tiedType: "start" });
+              break;
+            }
+          }
+        }
+        break;
+      case "slur_start":
+        slurDepth++;
+        pendingSlurStarts++;
+        break;
+      case "slur_end":
+        if (slurDepth > 0) {
+          slurDepth--;
+          for (let ei = currentEntries.length - 1; ei >= 0; ei--) {
+            const e = currentEntries[ei];
+            if (e.type === "note") {
+              if (!e.notations) e.notations = [];
+              e.notations.push({ type: "slur", slurType: "stop", number: slurDepth + 1 });
+              break;
+            }
+          }
+        }
+        break;
+      case "grace_start":
+        inGrace = true;
+        break;
+      case "grace_end":
+        inGrace = false;
+        break;
+      case "broken_rhythm": {
+        const brokenN = token.value.length;
+        const brokenDivisor = Math.pow(2, brokenN);
+        for (let ei = currentEntries.length - 1; ei >= 0; ei--) {
+          const e = currentEntries[ei];
+          if (e.type === "note") {
+            if (token.value[0] === ">") {
+              e.duration = Math.round(e.duration * (2 * brokenDivisor - 1) / brokenDivisor);
+            } else {
+              e.duration = Math.round(e.duration / brokenDivisor);
+            }
+            break;
+          }
+        }
+        pendingBrokenRhythm = token.value;
+        break;
+      }
+      case "tuplet":
+        tupletState = {
+          p: token.tupletP,
+          q: token.tupletQ,
+          remaining: token.tupletR || token.tupletP
+        };
+        pendingTupletStart = true;
+        break;
+      case "chord_symbol":
+        pendingPreNoteItems.push({ kind: "harmony", value: token.value });
+        break;
+      case "decoration":
+        if (DYNAMICS_VALUES.has(token.value)) {
+          pendingPreNoteItems.push({ kind: "dynamic", value: token.value });
+        } else {
+          const isShorthand = token.value.length === 1 && /^[vuTM]$/.test(token.value);
+          const decoText = isShorthand ? token.value : `!${token.value}!`;
+          pendingPreNoteItems.push({ kind: "decoration", value: decoText });
+        }
+        break;
+      case "lyrics": {
+        const syllables = token.syllables || [];
+        applyLyricsToExistingNotes(measures, currentEntries, syllables);
+        break;
+      }
+      case "overlay": {
+        if (currentPosition > 0) {
+          const backupEntry = {
+            _id: generateId(),
+            type: "backup",
+            duration: currentPosition
+          };
+          currentEntries.push(backupEntry);
+          currentPosition = 0;
+        }
+        break;
+      }
+      case "inline_field": {
+        const lMatch = token.value.match(/^L:\s*(\d+)\/(\d+)/);
+        if (lMatch) {
+          currentUnitNote = { num: parseInt(lMatch[1], 10), den: parseInt(lMatch[2], 10) };
+          const inlineEntry = {
+            _id: generateId(),
+            type: "direction",
+            directionTypes: [{ kind: "words", text: `[L:${lMatch[1]}/${lMatch[2]}]` }]
+          };
+          currentEntries.push(inlineEntry);
+        }
+        const kMatch = token.value.match(/^K:\s*(.*)/);
+        if (kMatch) {
+          pendingKeyChange = `K:${kMatch[1]}`;
+        }
+        break;
+      }
+      case "space":
+        break;
+      case "line_break":
+        flushPendingPreNoteItems();
+        if (currentEntries.length > 0) {
+          const breakText = token.value === "\\\n" ? "__abc_line_cont__" : "__abc_line_break__";
+          const lineBreakDir = {
+            _id: generateId(),
+            type: "direction",
+            directionTypes: [{ kind: "words", text: breakText }]
+          };
+          currentEntries.push(lineBreakDir);
+        }
+        if (measures.length > 0) {
+          if (token.value === "\\\n") {
+            lineBreaks.push(-measures.length);
+          } else {
+            lineBreaks.push(measures.length);
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  if (currentEntries.length > 0) {
+    finalizeMeasure();
+  }
+  applyTieStops(measures);
+  return { measures, lineBreaks, hasIndividualChordDurations };
+}
+function applyLyricsToExistingNotes(finalizedMeasures, currentEntries, syllables) {
+  const allNotes = [];
+  for (const measure of finalizedMeasures) {
+    for (const entry of measure.entries) {
+      if (entry.type === "note" && !entry.rest && !entry.grace && !entry.chord) {
+        allNotes.push(entry);
+      }
+    }
+  }
+  for (const entry of currentEntries) {
+    if (entry.type === "note" && !entry.rest && !entry.grace && !entry.chord) {
+      allNotes.push(entry);
+    }
+  }
+  const unlyricedNotes = allNotes.filter((n) => !n.lyrics || n.lyrics.length === 0);
+  const targetNotes = unlyricedNotes.slice(0, syllables.length);
+  for (let si = 0; si < syllables.length && si < targetNotes.length; si++) {
+    const syllable = syllables[si];
+    if (!syllable || syllable === "" || syllable === "*") continue;
+    const note = targetNotes[si];
+    const isHyphenated = syllable.endsWith("-");
+    const text = isHyphenated ? syllable.slice(0, -1) : syllable;
+    let syllabic = isHyphenated ? "begin" : "single";
+    if (si > 0) {
+      const prevSyllable = syllables[si - 1];
+      if (prevSyllable && prevSyllable.endsWith("-")) {
+        syllabic = isHyphenated ? "middle" : "end";
+      }
+    }
+    note.lyrics = [{
+      number: 1,
+      text,
+      syllabic
+    }];
+  }
+}
+function applyTieStops(measures) {
+  const allNotes = [];
+  for (const measure of measures) {
+    for (const entry of measure.entries) {
+      if (entry.type === "note" && !entry.grace) {
+        allNotes.push(entry);
+      }
+    }
+  }
+  for (let i = 0; i < allNotes.length - 1; i++) {
+    const note = allNotes[i];
+    if (note.tie?.type === "start" && note.pitch) {
+      for (let j = i + 1; j < allNotes.length; j++) {
+        const next = allNotes[j];
+        if (next.pitch && next.pitch.step === note.pitch.step && next.pitch.octave === note.pitch.octave) {
+          if (next.tie?.type === "start") {
+            next.tie = { type: "stop" };
+            next.ties = [{ type: "stop" }, { type: "start" }];
+          } else {
+            next.tie = { type: "stop" };
+            next.ties = [{ type: "stop" }];
+          }
+          if (!next.notations) next.notations = [];
+          next.notations.push({ type: "tied", tiedType: "stop" });
+          break;
+        }
+      }
+    }
+  }
+}
+function createNoteEntry(token, unitNote, _hasTieStop, isGrace, tupletState) {
+  const num = token.durationNum || 1;
+  const den = token.durationDen || 1;
+  let duration;
+  if (isGrace) {
+    duration = 0;
+  } else {
+    duration = lengthToDuration(num, den, unitNote);
+    if (tupletState) {
+      duration = Math.round(duration * tupletState.q / tupletState.p);
+    }
+  }
+  const { noteType, dots } = durationToNoteType(isGrace ? lengthToDuration(num, den, unitNote) : duration);
+  const entry = {
+    _id: generateId(),
+    type: "note",
+    pitch: token.pitch,
+    duration,
+    voice: 1,
+    noteType,
+    dots: dots > 0 ? dots : void 0
+  };
+  if (isGrace) {
+    entry.grace = { slash: true };
+    entry.noteType = "eighth";
+  }
+  if (tupletState && !isGrace) {
+    entry.timeModification = {
+      actualNotes: tupletState.p,
+      normalNotes: tupletState.q
+    };
+  }
+  if (token.explicitNatural) {
+    entry.accidental = { value: "natural" };
+  } else if (token.accidental !== void 0 && token.accidental !== 0) {
+    switch (token.accidental) {
+      case 1:
+        entry.accidental = { value: "sharp" };
+        break;
+      case 2:
+        entry.accidental = { value: "double-sharp" };
+        break;
+      case -1:
+        entry.accidental = { value: "flat" };
+        break;
+      case -2:
+        entry.accidental = { value: "double-flat" };
+        break;
+    }
+  }
+  return entry;
+}
+function createRestEntry(token, unitNote, tupletState, measureDuration) {
+  const num = token.durationNum || 1;
+  const den = token.durationDen || 1;
+  const isWholeMeasure = token.value.startsWith("Z");
+  const isInvisible = token.value.startsWith("x") || token.value.startsWith("X");
+  let duration;
+  if (isWholeMeasure) {
+    duration = measureDuration;
+  } else {
+    duration = lengthToDuration(num, den, unitNote);
+    if (tupletState) {
+      duration = Math.round(duration * tupletState.q / tupletState.p);
+    }
+  }
+  const { noteType, dots } = durationToNoteType(duration);
+  const entry = {
+    _id: generateId(),
+    type: "note",
+    rest: isWholeMeasure ? { measure: true } : {},
+    duration,
+    voice: 1,
+    noteType,
+    dots: dots > 0 ? dots : void 0
+  };
+  if (isInvisible) {
+    entry.printObject = false;
+  }
+  return entry;
+}
+function createBarline(barType, location, endingNumber) {
+  const barline = {
+    _id: generateId(),
+    location
+  };
+  switch (barType) {
+    case "start-repeat":
+      barline.barStyle = "heavy-light";
+      barline.repeat = { direction: "forward" };
+      break;
+    case "end-repeat":
+      barline.barStyle = "light-heavy";
+      barline.repeat = { direction: "backward" };
+      break;
+    case "final":
+      barline.barStyle = "light-heavy";
+      break;
+    case "double":
+      barline.barStyle = "light-light";
+      break;
+    case "heavy-light":
+      barline.barStyle = "heavy-light";
+      break;
+    case "thick-thin":
+      barline.barStyle = "heavy-light";
+      break;
+    default:
+      return null;
+  }
+  if (endingNumber) {
+    barline.ending = {
+      number: endingNumber,
+      type: location === "left" ? "start" : "stop"
+    };
+  }
+  return barline;
+}
+function createHarmonyEntry(chordStr) {
+  const match = chordStr.match(/^([A-G])(#|b)?(min7|m7|maj7|M7|dim7|aug7|m6|m9|min|maj|dim|aug|sus4|sus2|add9|add11|add|7|9|11|13|6|m)?(\/([A-G](#|b)?))?/);
+  if (!match) return null;
+  const rootStep = match[1];
+  const rootAlter = match[2] === "#" ? 1 : match[2] === "b" ? -1 : void 0;
+  const quality = match[3] || "";
+  const bassNote = match[5];
+  let kind = "major";
+  switch (quality) {
+    case "m":
+    case "min":
+      kind = "minor";
+      break;
+    case "7":
+      kind = "dominant";
+      break;
+    case "maj7":
+    case "M7":
+      kind = "major-seventh";
+      break;
+    case "m7":
+    case "min7":
+      kind = "minor-seventh";
+      break;
+    case "dim":
+      kind = "diminished";
+      break;
+    case "dim7":
+      kind = "diminished-seventh";
+      break;
+    case "aug":
+      kind = "augmented";
+      break;
+    case "aug7":
+      kind = "augmented-seventh";
+      break;
+    case "6":
+      kind = "major-sixth";
+      break;
+    case "m6":
+      kind = "minor-sixth";
+      break;
+    case "9":
+      kind = "dominant-ninth";
+      break;
+    case "m9":
+      kind = "minor-ninth";
+      break;
+    case "sus4":
+      kind = "suspended-fourth";
+      break;
+    case "sus2":
+      kind = "suspended-second";
+      break;
+  }
+  const entry = {
+    _id: generateId(),
+    type: "harmony",
+    root: { rootStep, rootAlter: rootAlter !== void 0 ? rootAlter : void 0 },
+    kind
+  };
+  if (bassNote) {
+    const bassMatch = bassNote.match(/^([A-G])(#|b)?/);
+    if (bassMatch) {
+      entry.bass = {
+        bassStep: bassMatch[1],
+        bassAlter: bassMatch[2] === "#" ? 1 : bassMatch[2] === "b" ? -1 : void 0
+      };
+    }
+  }
+  return entry;
+}
+function createDynamicsDirection(dynamic) {
+  if (!DYNAMICS_VALUES.has(dynamic)) return null;
+  return {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{
+      kind: "dynamics",
+      value: dynamic
+    }],
+    placement: "below"
+  };
+}
+function parseAbc(abcString) {
+  const lines = abcString.split("\n");
+  const { header, bodyStartIndex, headerFieldOrder } = parseHeader(lines);
+  const bodyLines = lines.slice(bodyStartIndex);
+  const { tokens: voiceTokensList, voiceIds, inlineVoiceMarkers, voiceDeclarationLines, bodyComments, bodyDirectives, wFields, voiceInterleavePattern, groupBarCounts, voiceComments, preVoiceComments, trailingComments } = tokenizeBody(bodyLines);
+  const score = buildScore(header, voiceTokensList, voiceIds, headerFieldOrder, inlineVoiceMarkers, voiceDeclarationLines, bodyComments, bodyDirectives, wFields, voiceInterleavePattern, groupBarCounts, voiceComments, preVoiceComments, trailingComments);
+  const bodyText = bodyLines.join("\n");
+  const hasExplicitHalf = /[A-Ga-gzx]\/2/.test(bodyText);
+  if (hasExplicitHalf) {
+    if (!score.metadata.miscellaneous) score.metadata.miscellaneous = [];
+    score.metadata.miscellaneous.push({ name: "abc-explicit-half", value: "true" });
+  }
+  return score;
+}
+
 // src/validator/index.ts
 var DEFAULT_OPTIONS = {
   checkDivisions: true,
@@ -5759,6 +7503,1123 @@ function buildMidiFile(tracks, ticksPerQuarterNote) {
   return new Uint8Array(chunks);
 }
 
+// src/exporters/abc.ts
+var DIVISIONS_PER_QUARTER = 960;
+var useExplicitHalf = false;
+var useIndividualChordDurations = false;
+var FIFTHS_TO_KEY_MAJOR = {
+  [-7]: "Cb",
+  [-6]: "Gb",
+  [-5]: "Db",
+  [-4]: "Ab",
+  [-3]: "Eb",
+  [-2]: "Bb",
+  [-1]: "F",
+  0: "C",
+  1: "G",
+  2: "D",
+  3: "A",
+  4: "E",
+  5: "B",
+  6: "F#",
+  7: "C#"
+};
+var FIFTHS_TO_KEY_MINOR = {
+  [-7]: "Ab",
+  [-6]: "Eb",
+  [-5]: "Bb",
+  [-4]: "F",
+  [-3]: "C",
+  [-2]: "G",
+  [-1]: "D",
+  0: "A",
+  1: "E",
+  2: "B",
+  3: "F#",
+  4: "C#",
+  5: "G#",
+  6: "D#",
+  7: "A#"
+};
+var MODE_FIFTHS_OFFSET = {
+  "major": 0,
+  "ionian": 0,
+  "minor": 3,
+  "aeolian": 3,
+  "dorian": 2,
+  "phrygian": 4,
+  "lydian": -1,
+  "mixolydian": 1,
+  "locrian": 5
+};
+var NOTE_TYPE_TO_QUARTER_LENGTH = {
+  "long": 16,
+  "breve": 8,
+  "whole": 4,
+  "half": 2,
+  "quarter": 1,
+  "eighth": 0.5,
+  "16th": 0.25,
+  "32nd": 0.125,
+  "64th": 0.0625,
+  "128th": 0.03125
+};
+function musicXmlClefToAbc(clef) {
+  if (clef.sign === "G" && (clef.line === 2 || clef.line === void 0)) return "treble";
+  if (clef.sign === "F" && (clef.line === 4 || clef.line === void 0)) return "bass";
+  if (clef.sign === "C" && clef.line === 3) return "alto";
+  if (clef.sign === "C" && clef.line === 4) return "tenor";
+  if (clef.sign === "C" && clef.line === 1) return "soprano";
+  if (clef.sign === "C" && clef.line === 2) return "mezzo-soprano";
+  if (clef.sign === "C" && clef.line === 5) return "baritone";
+  if (clef.sign === "percussion") return "perc";
+  return null;
+}
+function serializeKey2(key) {
+  const mode = key.mode || "major";
+  const modeOffset = MODE_FIFTHS_OFFSET[mode] ?? 0;
+  const majorFifths = key.fifths + modeOffset;
+  let keyNote;
+  if (mode === "minor" || mode === "aeolian") {
+    keyNote = FIFTHS_TO_KEY_MINOR[key.fifths] || "A";
+    return keyNote + "m";
+  }
+  keyNote = FIFTHS_TO_KEY_MAJOR[majorFifths] || "C";
+  const modeStr = modeToAbcString(mode);
+  return keyNote + modeStr;
+}
+function modeToAbcString(mode) {
+  switch (mode) {
+    case "major":
+    case "ionian":
+      return "";
+    case "minor":
+    case "aeolian":
+      return "m";
+    case "dorian":
+      return "dor";
+    case "phrygian":
+      return "phr";
+    case "lydian":
+      return "lyd";
+    case "mixolydian":
+      return "mix";
+    case "locrian":
+      return "loc";
+    default:
+      return "";
+  }
+}
+function serializeTimeSignature(time) {
+  if (time.symbol === "common") return "C";
+  if (time.symbol === "cut") return "C|";
+  return `${time.beats}/${time.beatType}`;
+}
+function computeUnitNoteLength(score) {
+  const firstMeasure = score.parts[0]?.measures[0];
+  const time = firstMeasure?.attributes?.time;
+  if (time) {
+    const beats = parseInt(time.beats, 10);
+    const beatType = time.beatType;
+    const ratio = beats / beatType;
+    if (ratio < 0.75) {
+      return { num: 1, den: 16 };
+    }
+  }
+  return { num: 1, den: 8 };
+}
+function durationToAbcFraction(duration, divisions, unitNote) {
+  const abcNum = duration * unitNote.den;
+  const abcDen = divisions * 4 * unitNote.num;
+  const g = gcd(abcNum, abcDen);
+  return { num: abcNum / g, den: abcDen / g };
+}
+function gcd(a, b) {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+}
+function formatAbcDuration(num, den) {
+  if (num === 1 && den === 1) return "";
+  if (den === 1) return String(num);
+  if (num === 1) {
+    if (den === 2 && !useExplicitHalf) return "/";
+    return `/${den}`;
+  }
+  return `${num}/${den}`;
+}
+function serializePitch2(pitch, explicitNatural) {
+  let result = "";
+  if (explicitNatural) {
+    result += "=";
+  } else if (pitch.alter !== void 0 && pitch.alter !== 0) {
+    if (pitch.alter === 1) result += "^";
+    else if (pitch.alter === 2) result += "^^";
+    else if (pitch.alter === -1) result += "_";
+    else if (pitch.alter === -2) result += "__";
+  }
+  const step = pitch.step;
+  const octave = pitch.octave;
+  if (octave >= 5) {
+    result += step.toLowerCase();
+    for (let o = 6; o <= octave; o++) {
+      result += "'";
+    }
+  } else {
+    result += step;
+    for (let o = 3; o >= octave; o--) {
+      result += ",";
+    }
+  }
+  return result;
+}
+function serializeHarmony2(harmony) {
+  let result = harmony.root.rootStep;
+  if (harmony.root.rootAlter === 1) result += "#";
+  else if (harmony.root.rootAlter === -1) result += "b";
+  switch (harmony.kind) {
+    case "major":
+      break;
+    // no suffix
+    case "minor":
+      result += "m";
+      break;
+    case "dominant":
+      result += "7";
+      break;
+    case "major-seventh":
+      result += "maj7";
+      break;
+    case "minor-seventh":
+      result += "m7";
+      break;
+    case "diminished":
+      result += "dim";
+      break;
+    case "diminished-seventh":
+      result += "dim7";
+      break;
+    case "augmented":
+      result += "aug";
+      break;
+    case "augmented-seventh":
+      result += "aug7";
+      break;
+    case "major-sixth":
+      result += "6";
+      break;
+    case "minor-sixth":
+      result += "m6";
+      break;
+    case "dominant-ninth":
+      result += "9";
+      break;
+    case "minor-ninth":
+      result += "m9";
+      break;
+    case "suspended-fourth":
+      result += "sus4";
+      break;
+    case "suspended-second":
+      result += "sus2";
+      break;
+    default:
+      if (harmony.kindText) result += harmony.kindText;
+      break;
+  }
+  if (harmony.bass) {
+    result += "/" + harmony.bass.bassStep;
+    if (harmony.bass.bassAlter === 1) result += "#";
+    else if (harmony.bass.bassAlter === -1) result += "b";
+  }
+  return '"' + result + '"';
+}
+function serializeDynamics(direction) {
+  for (const dt of direction.directionTypes) {
+    if (dt.kind === "dynamics" && dt.value) {
+      return `!${dt.value}!`;
+    }
+  }
+  return null;
+}
+function serializeTempo(direction) {
+  for (const dt of direction.directionTypes) {
+    if (dt.kind === "metronome") {
+      const beatUnit = dt.beatUnit;
+      const perMinute = dt.perMinute;
+      if (!perMinute) return null;
+      const quarterLen = NOTE_TYPE_TO_QUARTER_LENGTH[beatUnit] ?? 1;
+      const den = Math.round(4 / quarterLen);
+      return `1/${den}=${perMinute}`;
+    }
+  }
+  return null;
+}
+function serializeAbc(score, options) {
+  const opts = {
+    referenceNumber: options?.referenceNumber ?? 1,
+    notesPerLine: options?.notesPerLine ?? 0,
+    includeChordSymbols: options?.includeChordSymbols ?? true,
+    includeDynamics: options?.includeDynamics ?? true,
+    includeLyrics: options?.includeLyrics ?? true
+  };
+  useExplicitHalf = score.metadata.miscellaneous?.find((m) => m.name === "abc-explicit-half")?.value === "true";
+  useIndividualChordDurations = score.metadata.miscellaneous?.some((m) => m.name === "abc-chord-individual-durations" && m.value === "true") ?? false;
+  const storedUnitNote = score.metadata.miscellaneous?.find((m) => m.name === "abc-unit-note-length")?.value;
+  let unitNote;
+  if (storedUnitNote) {
+    const match = storedUnitNote.match(/^(\d+)\/(\d+)$/);
+    if (match) {
+      unitNote = { num: parseInt(match[1], 10), den: parseInt(match[2], 10) };
+    } else {
+      unitNote = computeUnitNoteLength(score);
+    }
+  } else {
+    unitNote = computeUnitNoteLength(score);
+  }
+  const lines = [];
+  const firstPart = score.parts[0];
+  const firstMeasure = firstPart?.measures[0];
+  const attrs = firstMeasure?.attributes;
+  const storedHeaderOrder = score.metadata.miscellaneous?.find((m) => m.name === "abc-header-order")?.value;
+  if (storedHeaderOrder) {
+    const headerOrder = JSON.parse(storedHeaderOrder);
+    for (const field of headerOrder) {
+      lines.push(field);
+    }
+  } else {
+    const storedRefNum = score.metadata.miscellaneous?.find((m) => m.name === "abc-reference-number")?.value;
+    const refNum = storedRefNum ? parseInt(storedRefNum, 10) : opts.referenceNumber;
+    lines.push(`X:${refNum}`);
+    if (score.metadata.movementTitle) {
+      lines.push(`T:${score.metadata.movementTitle}`);
+    }
+    const composer = score.metadata.creators?.find((c) => c.type === "composer");
+    if (composer) {
+      lines.push(`C:${composer.value}`);
+    }
+    const rhythmFields = score.metadata.miscellaneous?.filter((m) => m.name === "abc-R");
+    if (rhythmFields) {
+      for (const rf of rhythmFields) lines.push(`R:${rf.value}`);
+    }
+    const originCreators = score.metadata.creators?.filter((c) => c.type === "origin");
+    if (originCreators) {
+      for (const oc of originCreators) lines.push(`O:${oc.value}`);
+    }
+    if (score.metadata.source) {
+      lines.push(`S:${score.metadata.source}`);
+    }
+    const noteFields = score.metadata.miscellaneous?.filter((m) => m.name === "abc-N");
+    if (noteFields) {
+      for (const nf of noteFields) lines.push(`N:${nf.value}`);
+    }
+    if (score.metadata.encoding?.encoder) {
+      for (const enc of score.metadata.encoding.encoder) lines.push(`Z:${enc}`);
+    }
+    const instrFields = score.metadata.miscellaneous?.filter((m) => m.name === "abc-I");
+    if (instrFields) {
+      for (const inf of instrFields) lines.push(`I:${inf.value}`);
+    }
+    const fileFields = score.metadata.miscellaneous?.filter((m) => m.name === "abc-F");
+    if (fileFields) {
+      for (const ff of fileFields) lines.push(`F:${ff.value}`);
+    }
+    if (attrs?.time) {
+      lines.push(`M:${serializeTimeSignature(attrs.time)}`);
+    }
+    lines.push(`L:${unitNote.num}/${unitNote.den}`);
+    const storedTempo = score.metadata.miscellaneous?.find((m) => m.name === "abc-tempo")?.value;
+    if (storedTempo) {
+      lines.push(`Q:${storedTempo}`);
+    } else {
+      const tempoStr = findTempoInMeasure(firstMeasure);
+      if (tempoStr) {
+        lines.push(`Q:${tempoStr}`);
+      }
+    }
+    if (attrs?.key) {
+      lines.push(`K:${serializeKey2(attrs.key)}`);
+    } else {
+      lines.push("K:C");
+    }
+  }
+  const lineBreaksStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-line-breaks")?.value;
+  const lineBreaks = lineBreaksStr ? JSON.parse(lineBreaksStr) : [];
+  const storedVoiceIdsStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-voice-ids")?.value;
+  const storedVoiceIds = storedVoiceIdsStr ? JSON.parse(storedVoiceIdsStr) : [];
+  const lyricsAfterAll = score.metadata.miscellaneous?.find((m) => m.name === "abc-lyrics-after-all")?.value === "true";
+  const lyricsLineCountsStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-lyrics-line-counts")?.value;
+  const lyricsLineCounts = lyricsLineCountsStr ? JSON.parse(lyricsLineCountsStr) : [];
+  const inlineVoiceMarkersStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-inline-voice-markers")?.value;
+  const inlineVoiceMarkers = inlineVoiceMarkersStr ? JSON.parse(inlineVoiceMarkersStr) : {};
+  const useInlineVoiceMarkers = Object.keys(inlineVoiceMarkers).length > 0;
+  if (useInlineVoiceMarkers) {
+    const voiceDeclStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-voice-declaration-lines")?.value;
+    if (voiceDeclStr) {
+      const voiceDeclLines = JSON.parse(voiceDeclStr);
+      for (const vl of voiceDeclLines) {
+        lines.push(vl);
+      }
+    }
+  }
+  const bodyCommentsStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-body-comments")?.value;
+  const bodyComments = bodyCommentsStr ? JSON.parse(bodyCommentsStr) : [];
+  const bodyDirectivesStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-body-directives")?.value;
+  const bodyDirectives = bodyDirectivesStr ? JSON.parse(bodyDirectivesStr) : [];
+  const wFieldsStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-w-fields")?.value;
+  const wFieldsList = wFieldsStr ? JSON.parse(wFieldsStr) : [];
+  const voiceInterleaveStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-voice-interleave")?.value;
+  const voiceInterleavePattern = voiceInterleaveStr ? JSON.parse(voiceInterleaveStr) : [];
+  const groupBarCountsStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-group-bar-counts")?.value;
+  const groupBarCounts = groupBarCountsStr ? JSON.parse(groupBarCountsStr) : [];
+  const bodyVoiceLinesStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-body-voice-lines")?.value;
+  const bodyVoiceLines = bodyVoiceLinesStr ? JSON.parse(bodyVoiceLinesStr) : [];
+  const voiceFullLinesStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-voice-full-lines")?.value;
+  const voiceFullLines = voiceFullLinesStr ? JSON.parse(voiceFullLinesStr) : {};
+  const voiceCommentsStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-voice-comments")?.value;
+  const voiceCommentsData = voiceCommentsStr ? JSON.parse(voiceCommentsStr) : {};
+  const preVoiceCommentsStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-pre-voice-comments")?.value;
+  const preVoiceComments = preVoiceCommentsStr ? JSON.parse(preVoiceCommentsStr) : [];
+  const multiVoice = score.parts.length > 1;
+  const partMeasureStrings = [];
+  const partDivisions = [];
+  for (let partIdx = 0; partIdx < score.parts.length; partIdx++) {
+    const part = score.parts[partIdx];
+    const divisions = getPartDivisions(part);
+    partDivisions.push(divisions);
+    const measStrings = [];
+    let currentUnitNote = { ...unitNote };
+    let currentKey = part.measures[0]?.attributes?.key;
+    for (let mi = 0; mi < part.measures.length; mi++) {
+      const measure = part.measures[mi];
+      const measDivisions = measure.attributes?.divisions ?? divisions;
+      let measureStr = "";
+      if (mi > 0 && measure.attributes?.key) {
+        const newKey = measure.attributes.key;
+        if (currentKey === void 0 || newKey.fifths !== currentKey.fifths || (newKey.mode || "major") !== (currentKey.mode || "major")) {
+          measureStr += "\nK:" + serializeKey2(newKey) + "\n";
+          currentKey = newKey;
+        }
+      }
+      const leftBarline = measure.barlines?.find((b) => b.location === "left");
+      if (leftBarline) {
+        measureStr += serializeBarline2(leftBarline);
+      }
+      const { noteStr, updatedUnitNote } = serializeMeasureEntries(measure, measDivisions, currentUnitNote, opts);
+      if (updatedUnitNote) currentUnitNote = updatedUnitNote;
+      measureStr += noteStr;
+      const rightBarline = measure.barlines?.find((b) => b.location === "right");
+      if (rightBarline) {
+        measureStr += serializeBarline2(rightBarline);
+      } else if (mi < part.measures.length - 1) {
+        const nextMeasure = part.measures[mi + 1];
+        const nextLeftBarline = nextMeasure?.barlines?.find((b) => b.location === "left" && (b.barStyle || b.repeat));
+        if (!nextLeftBarline) {
+          measureStr += "|";
+        }
+      } else {
+        const prevMeas = mi > 0 ? part.measures[mi - 1] : null;
+        const prevRightBl = prevMeas?.barlines?.find((b) => b.location === "right");
+        const prevWasFinal = prevRightBl?.barStyle === "light-heavy" && !prevRightBl.repeat;
+        if (!prevWasFinal) {
+          measureStr += "|";
+        }
+      }
+      measStrings.push(measureStr);
+    }
+    partMeasureStrings.push(measStrings);
+  }
+  const hasInterleave = voiceInterleavePattern.length > 0 && multiVoice;
+  if (hasInterleave && !useInlineVoiceMarkers) {
+    const voiceMeasureCursor = {};
+    for (const voiceId of storedVoiceIds) {
+      voiceMeasureCursor[voiceId] = 0;
+    }
+    const voiceIdToPartIdx = {};
+    for (let i = 0; i < storedVoiceIds.length; i++) {
+      voiceIdToPartIdx[storedVoiceIds[i]] = i;
+    }
+    let voiceDeclIdx = 0;
+    let commentIdx = 0;
+    for (let gi = 0; gi < voiceInterleavePattern.length; gi++) {
+      const group = voiceInterleavePattern[gi];
+      for (const voiceId of group) {
+        const partIdx = voiceIdToPartIdx[voiceId];
+        if (partIdx === void 0) continue;
+        const measStrings = partMeasureStrings[partIdx];
+        const bodyVoiceLineIdx = bodyVoiceLines.findIndex((l, idx) => {
+          const m = l.match(/^V:\s*(\S+)/);
+          return m && m[1] === voiceId && idx >= voiceDeclIdx;
+        });
+        if (bodyVoiceLineIdx >= 0) {
+          if (bodyVoiceLineIdx < preVoiceComments.length) {
+            for (const c of preVoiceComments[bodyVoiceLineIdx]) {
+              lines.push(c);
+            }
+          }
+          lines.push(bodyVoiceLines[bodyVoiceLineIdx]);
+          voiceDeclIdx = bodyVoiceLineIdx + 1;
+        } else if (voiceFullLines[voiceId]) {
+        } else {
+          let voiceLine = `V:${voiceId}`;
+          const partClef = score.parts[partIdx]?.measures[0]?.attributes?.clef?.[0];
+          if (partClef) {
+            const clefName = musicXmlClefToAbc(partClef);
+            if (clefName && clefName !== "treble") {
+              voiceLine += ` clef=${clefName}`;
+            }
+          }
+          lines.push(voiceLine);
+        }
+        const voiceIdxInGroup = group.indexOf(voiceId);
+        const barCount = groupBarCounts[gi]?.[voiceIdxInGroup] ?? 0;
+        const measuresInGroup = barCount > 0 ? barCount : Math.ceil((partMeasureStrings[0]?.length || 0) / voiceInterleavePattern.length);
+        const startMeasure = voiceMeasureCursor[voiceId] || 0;
+        const endMeasure = Math.min(startMeasure + measuresInGroup, measStrings.length);
+        const voiceLineBreaksStr = score.metadata.miscellaneous?.find((m) => m.name === `abc-line-breaks-${partIdx}`)?.value;
+        const voiceLineBreaks = voiceLineBreaksStr ? JSON.parse(voiceLineBreaksStr) : lineBreaks;
+        const voiceLineBreakSet = new Set(voiceLineBreaks.map((v) => Math.abs(v)));
+        const voiceLineContinuationSet = new Set(voiceLineBreaks.filter((v) => v < 0).map((v) => Math.abs(v)));
+        const thisVoiceComments = voiceCommentsData[voiceId] || [];
+        let groupMusic = "";
+        for (let mi = startMeasure; mi < endMeasure; mi++) {
+          for (const vc of thisVoiceComments) {
+            if (vc.barIndex === mi) {
+              groupMusic += vc.comment + "\n";
+            }
+          }
+          groupMusic += measStrings[mi];
+          if (mi < endMeasure - 1) {
+            const absMeasureNum = mi + 1;
+            if (voiceLineContinuationSet.has(absMeasureNum)) {
+              groupMusic += "\\\n";
+            } else if (voiceLineBreakSet.has(absMeasureNum)) {
+              groupMusic += "\n";
+            }
+          }
+        }
+        voiceMeasureCursor[voiceId] = endMeasure;
+        lines.push(groupMusic);
+      }
+      if (gi < voiceInterleavePattern.length - 1 && commentIdx < bodyComments.length) {
+        lines.push(bodyComments[commentIdx]);
+        commentIdx++;
+      }
+    }
+  } else {
+    for (let partIdx = 0; partIdx < score.parts.length; partIdx++) {
+      const part = score.parts[partIdx];
+      if (multiVoice && !useInlineVoiceMarkers) {
+        const voiceId = storedVoiceIds[partIdx] || String(partIdx + 1);
+        if (voiceFullLines[voiceId]) {
+          lines.push(voiceFullLines[voiceId]);
+        } else {
+          let voiceLine = `V:${voiceId}`;
+          const partClef = part.measures[0]?.attributes?.clef?.[0];
+          if (partClef) {
+            const clefName = musicXmlClefToAbc(partClef);
+            if (clefName && clefName !== "treble") {
+              voiceLine += ` clef=${clefName}`;
+            }
+          }
+          lines.push(voiceLine);
+        }
+      }
+      const divisions = partDivisions[partIdx];
+      const bodyResult = serializePartBody(part, divisions, unitNote, opts, lineBreaks, lyricsAfterAll, lyricsLineCounts);
+      let musicLine = bodyResult.music;
+      if (multiVoice && useInlineVoiceMarkers) {
+        const voiceId = storedVoiceIds[partIdx] || String(partIdx + 1);
+        const marker = inlineVoiceMarkers[voiceId] || `[V:${voiceId}]`;
+        musicLine = marker + musicLine;
+      }
+      lines.push(musicLine);
+      if (opts.includeLyrics && bodyResult.lyrics) {
+        lines.push(bodyResult.lyrics);
+      }
+    }
+  }
+  for (const directive of bodyDirectives) {
+    lines.push(directive);
+  }
+  for (const wField of wFieldsList) {
+    lines.push(wField);
+  }
+  const trailingCommentsStr = score.metadata.miscellaneous?.find((m) => m.name === "abc-trailing-comments")?.value;
+  const trailingComments = trailingCommentsStr ? JSON.parse(trailingCommentsStr) : [];
+  for (const comment of trailingComments) {
+    lines.push(comment);
+  }
+  return lines.join("\n") + "\n";
+}
+function findTempoInMeasure(measure) {
+  if (!measure) return null;
+  for (const entry of measure.entries) {
+    if (entry.type === "direction") {
+      const tempo = serializeTempo(entry);
+      if (tempo) return tempo;
+    }
+  }
+  return null;
+}
+function getPartDivisions(part) {
+  for (const measure of part.measures) {
+    if (measure.attributes?.divisions) {
+      return measure.attributes.divisions;
+    }
+    for (const entry of measure.entries) {
+      if (entry.type === "attributes" && entry.attributes.divisions) {
+        return entry.attributes.divisions;
+      }
+    }
+  }
+  return DIVISIONS_PER_QUARTER;
+}
+function serializePartBody(part, divisions, initialUnitNote, opts, lineBreaks = [], lyricsAfterAll = false, lyricsLineCounts = []) {
+  let unitNote = { ...initialUnitNote };
+  const musicParts = [];
+  const allLyrics = /* @__PURE__ */ new Map();
+  let currentKey = part.measures[0]?.attributes?.key;
+  for (let mi = 0; mi < part.measures.length; mi++) {
+    const measure = part.measures[mi];
+    const measDivisions = measure.attributes?.divisions ?? divisions;
+    if (mi > 0 && measure.attributes?.key) {
+      const newKey = measure.attributes.key;
+      if (currentKey === void 0 || newKey.fifths !== currentKey.fifths || (newKey.mode || "major") !== (currentKey.mode || "major")) {
+        musicParts.push("\nK:" + serializeKey2(newKey) + "\n");
+        currentKey = newKey;
+      }
+    }
+    const leftBarline = measure.barlines?.find((b) => b.location === "left");
+    if (leftBarline) {
+      musicParts.push(serializeBarline2(leftBarline));
+    }
+    const { noteStr, lyrics, updatedUnitNote } = serializeMeasureEntries(
+      measure,
+      measDivisions,
+      unitNote,
+      opts
+    );
+    if (updatedUnitNote) {
+      unitNote = updatedUnitNote;
+    }
+    musicParts.push(noteStr);
+    if (lyrics.length > 0) {
+      allLyrics.set(mi, lyrics);
+    }
+    const rightBarline = measure.barlines?.find((b) => b.location === "right");
+    if (rightBarline) {
+      musicParts.push(serializeBarline2(rightBarline));
+    } else if (mi < part.measures.length - 1) {
+      const nextMeas = part.measures[mi + 1];
+      const nextLeftBar = nextMeas?.barlines?.find((b) => b.location === "left" && (b.barStyle || b.repeat));
+      if (!nextLeftBar) {
+        musicParts.push("|");
+      }
+    } else {
+      const prevMeas = mi > 0 ? part.measures[mi - 1] : null;
+      const prevRightBl = prevMeas?.barlines?.find((b) => b.location === "right");
+      const prevWasFinal = prevRightBl?.barStyle === "light-heavy" && !prevRightBl.repeat;
+      if (!prevWasFinal) {
+        musicParts.push("|");
+      }
+    }
+    if (mi < part.measures.length - 1) {
+      if (lineBreaks.includes(mi + 1)) {
+        musicParts.push("\n");
+      } else if (lineBreaks.includes(-(mi + 1))) {
+        musicParts.push("\\\n");
+      }
+    }
+  }
+  const musicStr = musicParts.join("");
+  if (allLyrics.size === 0) {
+    return { music: musicStr, lyrics: null };
+  }
+  const lineBreakSet = new Set(lineBreaks.map((v) => Math.abs(v)));
+  const lyricsByLine = [];
+  let lineStart = 0;
+  for (let mi = 0; mi < part.measures.length; mi++) {
+    if (lineBreakSet.has(mi + 1) || mi === part.measures.length - 1) {
+      const syllables = [];
+      for (let m = lineStart; m <= mi; m++) {
+        const ls = allLyrics.get(m);
+        if (ls) syllables.push(...ls);
+      }
+      if (syllables.length > 0) {
+        lyricsByLine.push({ startMeasure: lineStart, endMeasure: mi, syllables });
+      }
+      lineStart = mi + 1;
+    }
+  }
+  function formatLyrics(syllables) {
+    let result = "w:";
+    for (let i = 0; i < syllables.length; i++) {
+      const syllable = syllables[i];
+      if (i > 0) {
+        const prev = syllables[i - 1];
+        if (prev.endsWith("-")) {
+        } else {
+          result += " ";
+        }
+      }
+      result += syllable;
+    }
+    return result;
+  }
+  if (lyricsAfterAll) {
+    const allSyllables2 = [];
+    const sortedMeasures2 = Array.from(allLyrics.keys()).sort((a, b) => a - b);
+    for (const mi of sortedMeasures2) {
+      allSyllables2.push(...allLyrics.get(mi));
+    }
+    if (lyricsLineCounts.length > 0) {
+      const lyricsLines = [];
+      let offset = 0;
+      for (const count of lyricsLineCounts) {
+        const chunk = allSyllables2.slice(offset, offset + count);
+        if (chunk.length > 0) {
+          lyricsLines.push(formatLyrics(chunk));
+        }
+        offset += count;
+      }
+      if (offset < allSyllables2.length) {
+        lyricsLines.push(formatLyrics(allSyllables2.slice(offset)));
+      }
+      return { music: musicStr, lyrics: lyricsLines.join("\n") };
+    }
+    return { music: musicStr, lyrics: formatLyrics(allSyllables2) };
+  }
+  if (lyricsByLine.length > 0 && lineBreaks.length > 0) {
+    const musicLines = musicStr.split("\n");
+    const resultLines = [];
+    let lyricIdx = 0;
+    for (let li = 0; li < musicLines.length; li++) {
+      resultLines.push(musicLines[li]);
+      if (lyricIdx < lyricsByLine.length) {
+        const lyricGroup = lyricsByLine[lyricIdx];
+        resultLines.push(formatLyrics(lyricGroup.syllables));
+        lyricIdx++;
+      }
+    }
+    while (lyricIdx < lyricsByLine.length) {
+      resultLines.push(formatLyrics(lyricsByLine[lyricIdx].syllables));
+      lyricIdx++;
+    }
+    return { music: resultLines.join("\n"), lyrics: null };
+  }
+  const allSyllables = [];
+  const sortedMeasures = Array.from(allLyrics.keys()).sort((a, b) => a - b);
+  for (const mi of sortedMeasures) {
+    allSyllables.push(...allLyrics.get(mi));
+  }
+  return { music: musicStr, lyrics: formatLyrics(allSyllables) };
+}
+function serializeMeasureEntries(measure, divisions, unitNote, opts) {
+  const parts = [];
+  const lyrics = [];
+  let currentUnitNote = { ...unitNote };
+  let chordPitches = [];
+  let chordDurationStr = "";
+  let chordTieStr = "";
+  let chordSlurStart = "";
+  let chordSlurEnd = "";
+  let inChord = false;
+  let chordHasIndividualDurations = false;
+  let tupletRemaining = 0;
+  for (let ei = 0; ei < measure.entries.length; ei++) {
+    const entry = measure.entries[ei];
+    switch (entry.type) {
+      case "note": {
+        const note = entry;
+        if (note.grace) {
+          const graceNotes = [];
+          let gi = ei;
+          while (gi < measure.entries.length) {
+            const ge = measure.entries[gi];
+            if (ge.type === "note" && ge.grace) {
+              const gs = serializeNote2(ge, divisions, currentUnitNote, false);
+              graceNotes.push(gs.pitch);
+              gi++;
+            } else {
+              break;
+            }
+          }
+          parts.push("{" + graceNotes.join("") + "}");
+          ei = gi - 1;
+          break;
+        }
+        const serialized = serializeNote2(note, divisions, currentUnitNote, false);
+        if (note.chord) {
+          if (!inChord) {
+            inChord = true;
+          }
+          let chordNoteStr = serialized.pitch;
+          if (chordHasIndividualDurations) {
+            chordNoteStr += serialized.duration;
+          }
+          if (note.tie?.type === "start" || note.ties?.some((t) => t.type === "start")) {
+            chordNoteStr += "-";
+          }
+          chordPitches.push(chordNoteStr);
+          break;
+        }
+        if (inChord) {
+          parts.push("[" + chordPitches.join("") + "]" + chordDurationStr + chordTieStr + chordSlurEnd);
+          inChord = false;
+          chordHasIndividualDurations = false;
+          chordPitches = [];
+          chordDurationStr = "";
+          chordTieStr = "";
+          chordSlurStart = "";
+          chordSlurEnd = "";
+        }
+        if (note.lyrics && note.lyrics.length > 0 && opts.includeLyrics) {
+          const lyric = note.lyrics[0];
+          if (lyric.text) {
+            const syllabic = lyric.syllabic || "single";
+            const suffix = syllabic === "begin" || syllabic === "middle" ? "-" : "";
+            lyrics.push(lyric.text + suffix);
+          }
+        }
+        let tupletPrefix = "";
+        if (note.timeModification && !note.chord && !note.grace && tupletRemaining <= 0) {
+          const p = note.timeModification.actualNotes;
+          tupletRemaining = p;
+          tupletPrefix = `(${p}`;
+        }
+        if (note.timeModification && !note.chord && !note.grace) {
+          tupletRemaining--;
+        }
+        let effectiveSerialized = serialized;
+        if (note.timeModification && note.pitch) {
+          const baseDuration = Math.round(note.duration * note.timeModification.actualNotes / note.timeModification.normalNotes);
+          const { num, den } = durationToAbcFraction(baseDuration, divisions, currentUnitNote);
+          const baseDurationStr = formatAbcDuration(num, den);
+          const pitchStr = serializePitch2(note.pitch, note.accidental?.value === "natural");
+          let tieStr = "";
+          if (note.tie?.type === "start" || note.ties?.some((t) => t.type === "start")) {
+            tieStr = "-";
+          }
+          let slurStart = "";
+          let slurEnd = "";
+          if (note.notations) {
+            for (const notation of note.notations) {
+              if (notation.type === "slur") {
+                if (notation.slurType === "start") slurStart += "(";
+                if (notation.slurType === "stop") slurEnd += ")";
+              }
+            }
+          }
+          effectiveSerialized = {
+            full: slurStart + pitchStr + baseDurationStr + tieStr + slurEnd,
+            pitch: pitchStr,
+            duration: baseDurationStr,
+            slurStart,
+            slurEnd,
+            tieStr
+          };
+        }
+        const nextEntry = ei + 1 < measure.entries.length ? measure.entries[ei + 1] : null;
+        if (nextEntry && nextEntry.type === "note" && nextEntry.chord) {
+          inChord = true;
+          const hasIndividualDur = detectChordIndividualDurations(measure.entries, ei);
+          chordHasIndividualDurations = hasIndividualDur;
+          const hasPerNoteTies = detectChordPerNoteTies(measure.entries, ei);
+          const firstNoteTie = note.tie?.type === "start" || note.ties?.some((t) => t.type === "start");
+          let firstNoteStr = hasIndividualDur ? effectiveSerialized.pitch + effectiveSerialized.duration : effectiveSerialized.pitch;
+          if (hasPerNoteTies && firstNoteTie) {
+            firstNoteStr += "-";
+          }
+          chordPitches = [firstNoteStr];
+          chordDurationStr = hasIndividualDur ? "" : effectiveSerialized.duration;
+          chordTieStr = "";
+          chordSlurStart = "";
+          chordSlurEnd = "";
+          if (firstNoteTie && !hasPerNoteTies) {
+            chordTieStr = "-";
+          }
+          if (note.notations) {
+            for (const notation of note.notations) {
+              if (notation.type === "slur") {
+                if (notation.slurType === "start") chordSlurStart = "(";
+                if (notation.slurType === "stop") chordSlurEnd = ")";
+              }
+            }
+          }
+          if (chordSlurStart) {
+            let insertIdx = parts.length;
+            for (let pi = parts.length - 1; pi >= 0; pi--) {
+              const p = parts[pi];
+              if (/^[vuTM]$/.test(p) || /^![^!]+!$/.test(p) || /^"[^"]*"$/.test(p)) {
+                insertIdx = pi;
+              } else {
+                break;
+              }
+            }
+            if (insertIdx < parts.length) {
+              parts.splice(insertIdx, 0, chordSlurStart);
+              parts.push(tupletPrefix);
+              break;
+            }
+          }
+          parts.push(tupletPrefix + chordSlurStart);
+          break;
+        }
+        if (effectiveSerialized.slurStart) {
+          let insertIdx = parts.length;
+          for (let pi = parts.length - 1; pi >= 0; pi--) {
+            const p = parts[pi];
+            if (/^[vuTM]$/.test(p) || /^![^!]+!$/.test(p) || /^"[^"]*"$/.test(p)) {
+              insertIdx = pi;
+            } else {
+              break;
+            }
+          }
+          if (insertIdx < parts.length) {
+            parts.splice(insertIdx, 0, effectiveSerialized.slurStart);
+            const noteOnly = effectiveSerialized.pitch + effectiveSerialized.duration + effectiveSerialized.tieStr + effectiveSerialized.slurEnd;
+            parts.push(tupletPrefix + noteOnly);
+            break;
+          }
+        }
+        const brokenResult = detectBrokenRhythm(measure.entries, ei, note, divisions, currentUnitNote);
+        if (brokenResult && !note.chord && !note.grace && !note.timeModification) {
+          const baseDurStr1 = formatAbcDuration(brokenResult.baseFrac.num, brokenResult.baseFrac.den);
+          const pitchStr1 = effectiveSerialized.pitch;
+          const tie1 = effectiveSerialized.tieStr;
+          const slurS1 = effectiveSerialized.slurStart;
+          const slurE1 = effectiveSerialized.slurEnd;
+          parts.push(tupletPrefix + slurS1 + pitchStr1 + baseDurStr1 + tie1 + brokenResult.marker);
+          const note2 = brokenResult.nextNote;
+          const pitchStr2 = serializePitch2(note2.pitch, note2.accidental?.value === "natural");
+          let tieStr2 = "";
+          if (note2.tie?.type === "start" || note2.ties?.some((t) => t.type === "start")) tieStr2 = "-";
+          let slurEnd2 = "";
+          if (note2.notations) {
+            for (const notation of note2.notations) {
+              if (notation.type === "slur" && notation.slurType === "stop") slurEnd2 += ")";
+            }
+          }
+          parts.push(pitchStr2 + baseDurStr1 + tieStr2 + slurEnd2 + slurE1);
+          ei = brokenResult.nextIndex;
+          break;
+        }
+        parts.push(tupletPrefix + effectiveSerialized.full);
+        break;
+      }
+      case "harmony": {
+        if (opts.includeChordSymbols) {
+          parts.push(serializeHarmony2(entry));
+        }
+        break;
+      }
+      case "direction": {
+        let handledAsSpecial = false;
+        for (const dt of entry.directionTypes) {
+          if (dt.kind === "words") {
+            if (dt.text === "__abc_line_cont__") {
+              parts.push("\\\n");
+              handledAsSpecial = true;
+              break;
+            }
+            if (dt.text === "__abc_line_break__") {
+              parts.push("\n");
+              handledAsSpecial = true;
+              break;
+            }
+            const lMatch = dt.text.match(/^\[L:\s*(\d+)\/(\d+)\]$/);
+            if (lMatch) {
+              parts.push(dt.text);
+              currentUnitNote = { num: parseInt(lMatch[1], 10), den: parseInt(lMatch[2], 10) };
+              handledAsSpecial = true;
+              break;
+            }
+            const decoMatch = dt.text.match(/^!([^!]+)!$/);
+            if (decoMatch) {
+              parts.push(dt.text);
+              handledAsSpecial = true;
+              break;
+            }
+            if (dt.text.length === 1 && /^[vuTM]$/.test(dt.text)) {
+              parts.push(dt.text);
+              handledAsSpecial = true;
+              break;
+            }
+          }
+        }
+        if (handledAsSpecial) break;
+        if (opts.includeDynamics) {
+          const dynStr = serializeDynamics(entry);
+          if (dynStr) {
+            parts.push(dynStr);
+          }
+        }
+        break;
+      }
+      case "backup":
+        parts.push(" & ");
+        break;
+      case "forward":
+        break;
+      default:
+        break;
+    }
+  }
+  if (inChord && chordPitches.length > 0) {
+    parts.push("[" + chordPitches.join("") + "]" + chordDurationStr + chordTieStr + chordSlurEnd);
+  }
+  const unitNoteChanged = currentUnitNote.num !== unitNote.num || currentUnitNote.den !== unitNote.den;
+  return { noteStr: parts.join(""), lyrics, updatedUnitNote: unitNoteChanged ? currentUnitNote : void 0 };
+}
+function detectBrokenRhythm(entries, currentIdx, currentNote, divisions, unitNote) {
+  if (currentNote.chord || currentNote.grace || currentNote.rest || currentNote.timeModification) return null;
+  let nextIdx = currentIdx + 1;
+  while (nextIdx < entries.length && entries[nextIdx].type === "note" && entries[nextIdx].chord) {
+    nextIdx++;
+  }
+  while (nextIdx < entries.length && entries[nextIdx].type !== "note") {
+    nextIdx++;
+  }
+  if (nextIdx >= entries.length) return null;
+  const nextEntry = entries[nextIdx];
+  if (nextEntry.type !== "note") return null;
+  const nextNote = nextEntry;
+  if (nextNote.chord || nextNote.grace || nextNote.rest || nextNote.timeModification) return null;
+  const d1 = currentNote.duration;
+  const d2 = nextNote.duration;
+  if (d1 <= 0 || d2 <= 0) return null;
+  const sum = d1 + d2;
+  if (sum % 2 !== 0) return null;
+  const base = sum / 2;
+  const baseFrac = durationToAbcFraction(base, divisions, unitNote);
+  if (baseFrac.den > 16 || baseFrac.num > 16) return null;
+  const frac1 = durationToAbcFraction(d1, divisions, unitNote);
+  const frac2 = durationToAbcFraction(d2, divisions, unitNote);
+  if (frac1.den === 1 && frac2.den === 1) return null;
+  let marker = null;
+  if (d1 * 1 === d2 * 3) {
+    marker = ">";
+  } else if (d1 * 3 === d2 * 1) {
+    marker = "<";
+  } else if (d1 * 1 === d2 * 7) {
+    marker = ">>";
+  } else if (d1 * 7 === d2 * 1) {
+    marker = "<<";
+  }
+  if (!marker) return null;
+  return { marker, nextNote, nextIndex: nextIdx, baseFrac };
+}
+function detectChordPerNoteTies(entries, startIdx) {
+  let tiedCount = 0;
+  let totalCount = 1;
+  const firstNote = entries[startIdx];
+  if (firstNote.type === "note") {
+    const hasTieStart2 = firstNote.tie?.type === "start" || firstNote.ties?.some((t) => t.type === "start");
+    if (hasTieStart2) tiedCount++;
+  }
+  for (let i = startIdx + 1; i < entries.length; i++) {
+    const e = entries[i];
+    if (e.type !== "note" || !e.chord) break;
+    totalCount++;
+    const hasTieStart2 = e.tie?.type === "start" || e.ties?.some((t) => t.type === "start");
+    if (hasTieStart2) tiedCount++;
+  }
+  return tiedCount > 1 || tiedCount > 0 && totalCount > 1;
+}
+function detectChordIndividualDurations(entries, startIdx) {
+  const firstNote = entries[startIdx];
+  if (firstNote.type !== "note") return false;
+  if (firstNote._abcIndividualChordDurations) return true;
+  if (useIndividualChordDurations) return true;
+  const baseDuration = firstNote.duration;
+  for (let i = startIdx + 1; i < entries.length; i++) {
+    const e = entries[i];
+    if (e.type !== "note" || !e.chord) break;
+    if (e.duration !== baseDuration) return true;
+  }
+  return false;
+}
+function serializeNote2(note, divisions, unitNote, _inChord) {
+  let pitchStr = "";
+  let durationStr = "";
+  if (note.rest) {
+    if (note.rest.measure) {
+      pitchStr = "Z";
+      durationStr = "";
+    } else {
+      const isInvisible = note.printObject === false;
+      pitchStr = isInvisible ? "x" : "z";
+      const { num, den } = durationToAbcFraction(note.duration, divisions, unitNote);
+      durationStr = formatAbcDuration(num, den);
+    }
+  } else if (note.grace) {
+    if (note.pitch) {
+      pitchStr = serializePitch2(note.pitch, note.accidental?.value === "natural");
+    }
+    durationStr = "";
+  } else if (note.pitch) {
+    pitchStr = serializePitch2(note.pitch, note.accidental?.value === "natural");
+    const effectiveDuration = note.duration;
+    const { num, den } = durationToAbcFraction(effectiveDuration, divisions, unitNote);
+    durationStr = formatAbcDuration(num, den);
+  }
+  let tieStr = "";
+  if (note.tie?.type === "start" || note.ties?.some((t) => t.type === "start")) {
+    tieStr = "-";
+  }
+  let slurStart = "";
+  let slurEnd = "";
+  if (note.notations) {
+    for (const notation of note.notations) {
+      if (notation.type === "slur") {
+        if (notation.slurType === "start") slurStart += "(";
+        if (notation.slurType === "stop") slurEnd += ")";
+      }
+    }
+  }
+  const full = slurStart + pitchStr + durationStr + tieStr + slurEnd;
+  return { full, pitch: pitchStr, duration: durationStr, slurStart, slurEnd, tieStr };
+}
+function serializeBarline2(barline) {
+  const hasRepeatForward = barline.repeat?.direction === "forward";
+  const hasRepeatBackward = barline.repeat?.direction === "backward";
+  const hasEnding = barline.ending;
+  let result = "";
+  if (hasRepeatForward) {
+    result += "|:";
+  } else if (hasRepeatBackward) {
+    result += ":|";
+  } else if (hasEnding && !barline.barStyle) {
+  } else {
+    switch (barline.barStyle) {
+      case "light-light":
+        result += "||";
+        break;
+      case "light-heavy":
+        result += "|]";
+        break;
+      case "heavy-light":
+        result += "[|";
+        break;
+      default:
+        result += "|";
+        break;
+    }
+  }
+  if (hasEnding && hasEnding.type === "start") {
+    if (result) {
+      result += hasEnding.number;
+    } else {
+      result += `[${hasEnding.number} `;
+    }
+  }
+  return result;
+}
+
 // src/utils/index.ts
 var STEPS = ["C", "D", "E", "F", "G", "A", "B"];
 var STEP_SEMITONES = {
@@ -11252,6 +14113,11 @@ var removeRepeat = removeRepeatBarline;
 // src/file.ts
 import { readFile, writeFile } from "fs/promises";
 async function parseFile(filePath) {
+  const lowerPath = filePath.toLowerCase();
+  if (lowerPath.endsWith(".abc")) {
+    const data2 = await readFile(filePath, "utf-8");
+    return parseAbc(data2);
+  }
   const data = await readFile(filePath);
   if (isCompressed(data)) {
     return parseCompressed(data);
@@ -11273,7 +14139,10 @@ function decodeBuffer(buffer) {
 }
 async function serializeToFile(score, filePath, options = {}) {
   const lowerPath = filePath.toLowerCase();
-  if (lowerPath.endsWith(".mxl")) {
+  if (lowerPath.endsWith(".abc")) {
+    const abcString = serializeAbc(score);
+    await writeFile(filePath, abcString, "utf-8");
+  } else if (lowerPath.endsWith(".mxl")) {
     const data = serializeCompressed(score, options);
     await writeFile(filePath, data);
   } else if (lowerPath.endsWith(".mid") || lowerPath.endsWith(".midi")) {
@@ -11466,6 +14335,7 @@ export {
   modifyTempo,
   moveNoteToStaff,
   parse,
+  parseAbc,
   parseAuto,
   parseCompressed,
   parseFile,
@@ -11501,6 +14371,7 @@ export {
   removeWedge,
   scoresEqual,
   serialize,
+  serializeAbc,
   serializeCompressed,
   serializeToFile,
   setBarline,