@hosanna/chordpro 1.1.0

package/dist/parser/index.js

@@ -0,0 +1,1567 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/parser/index.ts
+var parser_exports = {};
+__export(parser_exports, {
+  DefaultChordDictionary: () => DefaultChordDictionary,
+  buildChordProText: () => buildChordProText,
+  chordDictionary: () => chordDictionary,
+  convertToChordProDetailed: () => convertToChordProDetailed,
+  detectSourceFormat: () => detectSourceFormat,
+  getNoteValue: () => getNoteValue,
+  getSuggestedCapo: () => getSuggestedCapo,
+  parseChordPro: () => parseChordPro,
+  parseLineSegments: () => parseLineSegments,
+  slugifyTitle: () => slugifyTitle,
+  toChordPro: () => toChordPro,
+  transposeChord: () => transposeChord,
+  transposeNote: () => transposeNote
+});
+module.exports = __toCommonJS(parser_exports);
+
+// src/parser/parser.ts
+var TIMING_REGEX = /^(.+?)@([0-9]*\.?[0-9]+)x$/;
+function parseChordTiming(rawChord) {
+  const match = rawChord.match(TIMING_REGEX);
+  if (match) return { chord: match[1], timing: parseFloat(match[2]) };
+  return { chord: rawChord };
+}
+function parseLineSegments(lineText) {
+  const segments = [];
+  const regex = /\[([^\]]+)\]/g;
+  let match;
+  let lastIndex = 0;
+  let currentChord = "";
+  let currentTiming;
+  while ((match = regex.exec(lineText)) !== null) {
+    const rawChord = match[1];
+    const { chord, timing } = parseChordTiming(rawChord);
+    const textBefore = lineText.slice(lastIndex, match.index);
+    if (lastIndex === 0 && textBefore === "") {
+      currentChord = chord;
+      currentTiming = timing;
+    } else {
+      segments.push({
+        chord: currentChord,
+        text: textBefore,
+        timing: currentTiming
+      });
+      currentChord = chord;
+      currentTiming = timing;
+    }
+    lastIndex = regex.lastIndex;
+  }
+  const remainingText = lineText.slice(lastIndex);
+  segments.push({
+    chord: currentChord,
+    text: remainingText,
+    timing: currentTiming
+  });
+  return segments;
+}
+function parseChordPro(content) {
+  const lines = content.split(/\r?\n/);
+  const metadata = {};
+  const sections = [];
+  let currentSection = null;
+  let isTab = false;
+  let isGrid = false;
+  let lastChorusLines = [];
+  const commitSection = () => {
+    if (currentSection) {
+      sections.push(currentSection);
+      if (currentSection.type === "chorus") {
+        lastChorusLines = [...currentSection.lines];
+      }
+      currentSection = null;
+    }
+  };
+  const aliasMap = {
+    t: "title",
+    st: "subtitle",
+    a: "artist",
+    k: "key",
+    c: "comment",
+    ci: "comment_italic",
+    cb: "comment_box",
+    soc: "start_of_chorus",
+    eoc: "end_of_chorus",
+    sov: "start_of_verse",
+    eov: "end_of_verse",
+    sob: "start_of_bridge",
+    eob: "end_of_bridge",
+    sot: "start_of_tab",
+    eot: "end_of_tab",
+    sog: "start_of_grid",
+    eog: "end_of_grid",
+    ch: "chorus",
+    v: "verse",
+    b: "bridge",
+    re: "repeat",
+    ns: "new_song",
+    time_signature: "time",
+    timesignature: "time",
+    "time signature": "time",
+    original_key: "original_key",
+    "original key": "original_key"
+  };
+  for (let line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      const directive = trimmed.slice(1, -1).trim();
+      const colonIndex = directive.indexOf(":");
+      let rawName = directive;
+      let value = "";
+      if (colonIndex !== -1) {
+        rawName = directive.substring(0, colonIndex).trim();
+        value = directive.substring(colonIndex + 1).trim();
+      }
+      const lowerName = rawName.toLowerCase();
+      const name = aliasMap[lowerName] || lowerName;
+      switch (name) {
+        case "start_of_chorus":
+          commitSection();
+          currentSection = {
+            type: "chorus",
+            label: value || "Refr\xE3o",
+            lines: []
+          };
+          break;
+        case "start_of_verse":
+          commitSection();
+          currentSection = {
+            type: "verse",
+            label: value || "Verso",
+            lines: []
+          };
+          break;
+        case "start_of_bridge":
+          commitSection();
+          currentSection = {
+            type: "bridge",
+            label: value || "Ponte",
+            lines: []
+          };
+          break;
+        case "start_of_tab":
+          commitSection();
+          isTab = true;
+          currentSection = {
+            type: "tab",
+            label: value || "Tablatura",
+            lines: []
+          };
+          break;
+        case "start_of_grid":
+          commitSection();
+          isGrid = true;
+          currentSection = { type: "grid", label: value || "Grid", lines: [] };
+          break;
+        case "end_of_chorus":
+          if (currentSection?.type === "chorus") commitSection();
+          break;
+        case "end_of_verse":
+          if (currentSection?.type === "verse") commitSection();
+          break;
+        case "end_of_bridge":
+          if (currentSection?.type === "bridge") commitSection();
+          break;
+        case "end_of_tab":
+          isTab = false;
+          if (currentSection?.type === "tab") commitSection();
+          break;
+        case "end_of_grid":
+          isGrid = false;
+          if (currentSection?.type === "grid") commitSection();
+          break;
+        case "chorus":
+          commitSection();
+          sections.push({
+            type: "chorus",
+            label: value || "Refr\xE3o",
+            lines: [...lastChorusLines]
+          });
+          break;
+        case "verse":
+          commitSection();
+          currentSection = {
+            type: "verse",
+            label: value || "Verso",
+            lines: []
+          };
+          break;
+        case "bridge":
+          commitSection();
+          currentSection = {
+            type: "bridge",
+            label: value || "Ponte",
+            lines: []
+          };
+          break;
+        case "comment":
+        case "comment_italic":
+          const commentLine = { type: "comment", text: value };
+          if (currentSection) currentSection.lines.push(commentLine);
+          else sections.push({ type: "comment", lines: [commentLine] });
+          break;
+        case "comment_box":
+          const cbLine = { type: "comment_box", text: value };
+          if (currentSection) currentSection.lines.push(cbLine);
+          else sections.push({ type: "comment", lines: [cbLine] });
+          break;
+        case "repeat":
+          if (currentSection) {
+            currentSection.repeat = value || "2";
+          } else {
+            sections.push({
+              type: "comment",
+              lines: [
+                { type: "comment_box", text: `Repetir: ${value || "2"}` }
+              ]
+            });
+          }
+          break;
+        case "new_song":
+          commitSection();
+          sections.push({ type: "new_song", lines: [] });
+          break;
+        case "duration":
+          if (/^\d{1,2}:\d{2}$/.test(value)) {
+            const [minutes, seconds] = value.split(":").map(Number);
+            metadata["duration"] = (minutes * 60 + seconds).toString();
+          } else {
+            metadata["duration"] = value;
+          }
+          break;
+        default:
+          if (value) {
+            const metaKey = name.replace(
+              /[-_\s]+([a-zA-Z])/g,
+              (_, letter) => letter.toUpperCase()
+            ).replace(/\s+/g, "");
+            metadata[metaKey] = value;
+          }
+          break;
+      }
+      continue;
+    }
+    if (trimmed === "") {
+      if (currentSection) currentSection.lines.push({ type: "empty" });
+      continue;
+    }
+    if (trimmed.startsWith("#") && !isTab) continue;
+    let lineType = "lyrics";
+    let parsedSegments = [];
+    if (isTab) {
+      lineType = "tab";
+    } else {
+      parsedSegments = parseLineSegments(line);
+      const textContent = parsedSegments.map((s) => s.text).join("");
+      const onlyBarsAndSpaces = /^[\s|:\-.%]*$/.test(textContent);
+      const hasBars = textContent.includes("|");
+      if (isGrid || onlyBarsAndSpaces && hasBars) {
+        lineType = "chord-section";
+      }
+    }
+    const parsedLine = { type: lineType };
+    if (lineType === "tab") {
+      parsedLine.text = line;
+    } else if (lineType === "lyrics") {
+      parsedLine.segments = parsedSegments;
+    } else if (lineType === "chord-section") {
+      parsedLine.segments = parsedSegments;
+      const measures = [];
+      let currentChords = [];
+      let startBarline = "";
+      let hasSeenChord = false;
+      let startBarlineFound = false;
+      for (let i = 0; i < parsedSegments.length; i++) {
+        const seg = parsedSegments[i];
+        if (seg.chord) {
+          currentChords.push({
+            chord: seg.chord,
+            text: "",
+            timing: seg.timing
+          });
+          hasSeenChord = true;
+        }
+        const barlineMatches = seg.text.match(/\|\||:\||\|:|\|/g);
+        if (barlineMatches) {
+          for (let j = 0; j < barlineMatches.length; j++) {
+            const b = barlineMatches[j];
+            if (!hasSeenChord && !startBarlineFound) {
+              startBarline = b;
+              startBarlineFound = true;
+            } else {
+              measures.push({ chords: currentChords, endBarline: b });
+              currentChords = [];
+            }
+          }
+        }
+      }
+      if (currentChords.length > 0) {
+        measures.push({ chords: currentChords, endBarline: "" });
+      }
+      parsedLine.measures = measures;
+      parsedLine.startBarline = startBarline;
+    }
+    if (!currentSection) currentSection = { type: "verse", lines: [] };
+    currentSection.lines.push(parsedLine);
+  }
+  commitSection();
+  if (!metadata.title) metadata.title = "Sem T\xEDtulo";
+  return { metadata, sections };
+}
+function buildChordProText(metadata, bodyContent) {
+  const lines = [];
+  const primaryKeys = [
+    "title",
+    "subtitle",
+    "artist",
+    "composer",
+    "album",
+    "copyright",
+    "key",
+    "originalKey",
+    "capo",
+    "tempo",
+    "time",
+    "duration",
+    "songNumber",
+    "ccli",
+    "youtube"
+  ];
+  for (const k of primaryKeys) {
+    if (metadata[k]) {
+      const directiveName = k.replace(/[A-Z]/g, (m) => "_" + m.toLowerCase());
+      lines.push(`{${directiveName}: ${metadata[k]}}`);
+    }
+  }
+  for (const k in metadata) {
+    if (!primaryKeys.includes(k) && metadata[k] && k !== "title") {
+      const directiveName = k.replace(/[A-Z]/g, (m) => "_" + m.toLowerCase());
+      lines.push(`{${directiveName}: ${metadata[k]}}`);
+    }
+  }
+  lines.push("");
+  lines.push(bodyContent.trim());
+  return lines.join("\n");
+}
+
+// src/parser/transpose.ts
+var NOTE_TO_VAL = {
+  C: 0,
+  "C#": 1,
+  DB: 1,
+  D: 2,
+  "D#": 3,
+  EB: 3,
+  E: 4,
+  F: 5,
+  "F#": 6,
+  GB: 6,
+  G: 7,
+  "G#": 8,
+  AB: 8,
+  A: 9,
+  "A#": 10,
+  BB: 10,
+  B: 11,
+  DO: 0,
+  RE: 2,
+  R\u00C9: 2,
+  MI: 4,
+  FA: 5,
+  F\u00C1: 5,
+  SOL: 7,
+  LA: 9,
+  L\u00C1: 9,
+  SI: 11
+};
+var SHARPS = [
+  "C",
+  "C#",
+  "D",
+  "D#",
+  "E",
+  "F",
+  "F#",
+  "G",
+  "G#",
+  "A",
+  "A#",
+  "B"
+];
+var FLATS = ["C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B"];
+function getNoteValue(note) {
+  if (!note) return void 0;
+  const match = note.match(
+    /^([A-G][#b]?|Do|Ré|Mi|Fá|Sol|Lá|Si|DO|RE|RÉ|MI|FA|FÁ|SOL|LA|LÁ|SI)/i
+  );
+  if (!match) return void 0;
+  return NOTE_TO_VAL[match[1].toUpperCase()];
+}
+function getSuggestedCapo(originalKey, transposeVal) {
+  const baseKeyVal = originalKey ? getNoteValue(originalKey) : 0;
+  const keyVal = baseKeyVal !== void 0 ? baseKeyVal : 0;
+  const soundingVal = (keyVal + transposeVal + 240) % 12;
+  const EASY_SHAPES = {
+    0: "C",
+    7: "G",
+    2: "D",
+    9: "A",
+    4: "E"
+  };
+  const PREFERRED_OPEN_VALS = [0, 7, 2, 9, 4];
+  for (const targetShapeVal of PREFERRED_OPEN_VALS) {
+    const neededCapo = (soundingVal - targetShapeVal + 12) % 12;
+    if (neededCapo >= 1 && neededCapo <= 7) {
+      return {
+        capo: neededCapo,
+        chordShape: EASY_SHAPES[targetShapeVal]
+      };
+    }
+  }
+  return null;
+}
+function transposeNote(note, semitones, preferFlats = false) {
+  const upper = note.toUpperCase();
+  if (NOTE_TO_VAL[upper] === void 0) return note;
+  const val = NOTE_TO_VAL[upper];
+  const newVal = (val + semitones + 24) % 12;
+  const targetScale = preferFlats ? FLATS : SHARPS;
+  let transposed = targetScale[newVal];
+  if (note[0] === note[0].toLowerCase()) {
+    transposed = transposed.toLowerCase();
+  }
+  return transposed;
+}
+function transposeChord(chord, semitones) {
+  if (!chord || semitones === 0) return chord;
+  if (chord.includes("/")) {
+    return chord.split("/").map((part) => transposeChord(part.trim(), semitones)).join("/");
+  }
+  const noteRegex = /^([A-G][#b]?|Do|Ré|Mi|Fá|Sol|Lá|Si|DO|RE|RÉ|MI|FA|FÁ|SOL|LA|LÁ|SI)/;
+  const match = chord.match(noteRegex);
+  if (!match) return chord;
+  const note = match[1];
+  const suffix = chord.slice(note.length);
+  const preferFlats = chord.includes("b") || chord.includes("B");
+  const transposedNote = transposeNote(note, semitones, preferFlats);
+  return transposedNote + suffix;
+}
+
+// src/parser/chordDictionary.ts
+var NOTE_ALIASES = {
+  C: 0,
+  "B#": 0,
+  Do: 0,
+  DO: 0,
+  "C#": 1,
+  Db: 1,
+  D: 2,
+  Re: 2,
+  RE: 2,
+  R\u00E9: 2,
+  R\u00C9: 2,
+  "D#": 3,
+  Eb: 3,
+  E: 4,
+  Fb: 4,
+  Mi: 4,
+  MI: 4,
+  F: 5,
+  "E#": 5,
+  Fa: 5,
+  FA: 5,
+  F\u00E1: 5,
+  F\u00C1: 5,
+  "F#": 6,
+  Gb: 6,
+  G: 7,
+  Sol: 7,
+  SOL: 7,
+  "G#": 8,
+  Ab: 8,
+  A: 9,
+  La: 9,
+  LA: 9,
+  L\u00E1: 9,
+  L\u00C1: 9,
+  "A#": 10,
+  Bb: 10,
+  B: 11,
+  Cb: 11,
+  Si: 11,
+  SI: 11
+};
+var ROOT_KEYS = Object.keys(NOTE_ALIASES).sort((a, b) => b.length - a.length);
+var ROOT_PATTERN = new RegExp(`^(${ROOT_KEYS.join("|")})`, "i");
+var SEMITONE_NAMES = [
+  "C",
+  "C#",
+  "D",
+  "D#",
+  "E",
+  "F",
+  "F#",
+  "G",
+  "G#",
+  "A",
+  "A#",
+  "B"
+];
+function resolveRootSemitone(raw) {
+  if (raw in NOTE_ALIASES) return NOTE_ALIASES[raw];
+  const titleCase = raw.charAt(0).toUpperCase() + raw.slice(1).toLowerCase();
+  if (titleCase in NOTE_ALIASES) return NOTE_ALIASES[titleCase];
+  const upper = raw.toUpperCase();
+  if (upper in NOTE_ALIASES) return NOTE_ALIASES[upper];
+  return null;
+}
+function pitchClassName(semitone) {
+  return SEMITONE_NAMES[(semitone % 12 + 12) % 12];
+}
+var CHORD_QUALITIES = [
+  {
+    id: "major",
+    label: "Major",
+    intervals: [0, 4, 7],
+    aliases: ["", "M", "maj", "Maj", "MAJ"]
+  },
+  {
+    id: "minor",
+    label: "Minor",
+    intervals: [0, 3, 7],
+    aliases: ["m", "min", "Min", "MIN", "-"]
+  },
+  {
+    id: "dim",
+    label: "Diminished",
+    intervals: [0, 3, 6],
+    aliases: ["dim", "o", "\xB0"]
+  },
+  {
+    id: "aug",
+    label: "Augmented",
+    intervals: [0, 4, 8],
+    aliases: ["aug", "+"]
+  },
+  {
+    id: "sus2",
+    label: "Suspended 2nd",
+    intervals: [0, 2, 7],
+    aliases: ["sus2"]
+  },
+  {
+    id: "sus4",
+    label: "Suspended 4th",
+    intervals: [0, 5, 7],
+    aliases: ["sus4", "sus"]
+  },
+  { id: "five", label: "Power chord", intervals: [0, 7], aliases: ["5"] },
+  { id: "six", label: "6th", intervals: [0, 4, 7, 9], aliases: ["6"] },
+  {
+    id: "m6",
+    label: "Minor 6th",
+    intervals: [0, 3, 7, 9],
+    aliases: ["m6", "min6"]
+  },
+  {
+    id: "six9",
+    label: "6/9",
+    intervals: [0, 4, 7, 9, 14],
+    aliases: ["6/9", "69"]
+  },
+  {
+    id: "dom7",
+    label: "Dominant 7th",
+    intervals: [0, 4, 7, 10],
+    aliases: ["7"]
+  },
+  {
+    id: "maj7",
+    label: "Major 7th",
+    intervals: [0, 4, 7, 11],
+    aliases: ["maj7", "Maj7", "MAJ7", "M7", "\u0394", "\u03947"]
+  },
+  {
+    id: "m7",
+    label: "Minor 7th",
+    intervals: [0, 3, 7, 10],
+    aliases: ["m7", "min7", "Min7"]
+  },
+  {
+    id: "mMaj7",
+    label: "Minor Major 7th",
+    intervals: [0, 3, 7, 11],
+    aliases: ["mMaj7", "m(maj7)", "mM7", "minMaj7"]
+  },
+  {
+    id: "m7b5",
+    label: "Half-diminished 7th",
+    intervals: [0, 3, 6, 10],
+    aliases: ["m7b5", "m7-5", "\xF8", "\xF87"]
+  },
+  {
+    id: "dim7",
+    label: "Diminished 7th",
+    intervals: [0, 3, 6, 9],
+    aliases: ["dim7", "o7", "\xB07"]
+  },
+  {
+    id: "aug7",
+    label: "7#5",
+    intervals: [0, 4, 8, 10],
+    aliases: ["7#5", "aug7"]
+  },
+  { id: "dom7b5", label: "7b5", intervals: [0, 4, 6, 10], aliases: ["7b5"] },
+  {
+    id: "dom7sus4",
+    label: "7sus4",
+    intervals: [0, 5, 7, 10],
+    aliases: ["7sus4"]
+  },
+  {
+    id: "dom7sus2",
+    label: "7sus2",
+    intervals: [0, 2, 7, 10],
+    aliases: ["7sus2"]
+  },
+  { id: "nine", label: "9th", intervals: [0, 4, 7, 10, 14], aliases: ["9"] },
+  {
+    id: "maj9",
+    label: "Major 9th",
+    intervals: [0, 4, 7, 11, 14],
+    aliases: ["maj9", "Maj9", "M9"]
+  },
+  {
+    id: "m9",
+    label: "Minor 9th",
+    intervals: [0, 3, 7, 10, 14],
+    aliases: ["m9", "min9"]
+  },
+  { id: "add9", label: "Add 9", intervals: [0, 4, 7, 14], aliases: ["add9"] },
+  {
+    id: "madd9",
+    label: "Minor Add 9",
+    intervals: [0, 3, 7, 14],
+    aliases: ["madd9", "minAdd9"]
+  },
+  {
+    id: "eleven",
+    label: "11th",
+    intervals: [0, 4, 7, 10, 14, 17],
+    aliases: ["11"]
+  },
+  {
+    id: "m11",
+    label: "Minor 11th",
+    intervals: [0, 3, 7, 10, 14, 17],
+    aliases: ["m11"]
+  },
+  {
+    id: "thirteen",
+    label: "13th",
+    intervals: [0, 4, 7, 10, 14, 17, 21],
+    aliases: ["13"]
+  },
+  {
+    id: "m13",
+    label: "Minor 13th",
+    intervals: [0, 3, 7, 10, 14, 17, 21],
+    aliases: ["m13"]
+  },
+  {
+    id: "dom7sharp9",
+    label: "7#9",
+    intervals: [0, 4, 7, 10, 15],
+    aliases: ["7#9"]
+  },
+  {
+    id: "dom7flat9",
+    label: "7b9",
+    intervals: [0, 4, 7, 10, 13],
+    aliases: ["7b9"]
+  },
+  {
+    id: "maj7sharp5",
+    label: "maj7#5",
+    intervals: [0, 4, 8, 11],
+    aliases: ["maj7#5"]
+  },
+  {
+    id: "maj7flat5",
+    label: "maj7b5",
+    intervals: [0, 4, 6, 11],
+    aliases: ["maj7b5"]
+  }
+];
+var QUALITY_BY_ID = Object.fromEntries(
+  CHORD_QUALITIES.map((q) => [q.id, q])
+);
+var QUALITY_ALIAS_TABLE = CHORD_QUALITIES.flatMap(
+  (quality) => quality.aliases.map((alias) => ({ alias, quality }))
+).sort((a, b) => b.alias.length - a.alias.length);
+function resolveQuality(qualitySymbol) {
+  if (qualitySymbol === "") return QUALITY_BY_ID.major;
+  const exact = QUALITY_ALIAS_TABLE.find(
+    (e) => e.alias !== "" && e.alias === qualitySymbol
+  );
+  if (exact) return exact.quality;
+  const lower = qualitySymbol.toLowerCase();
+  const loose = QUALITY_ALIAS_TABLE.find(
+    (e) => e.alias !== "" && e.alias.toLowerCase() === lower
+  );
+  if (loose) return loose.quality;
+  return QUALITY_BY_ID.major;
+}
+var QUALITY_SIMPLIFICATION = {
+  dim: "minor",
+  dim7: "minor",
+  aug: "major",
+  six: "major",
+  m6: "minor",
+  six9: "major",
+  mMaj7: "m7",
+  m7b5: "m7",
+  aug7: "dom7",
+  dom7b5: "dom7",
+  dom7sus4: "sus4",
+  dom7sus2: "sus2",
+  nine: "dom7",
+  maj9: "maj7",
+  m9: "m7",
+  add9: "major",
+  madd9: "minor",
+  eleven: "dom7",
+  m11: "m7",
+  thirteen: "dom7",
+  m13: "m7",
+  dom7sharp9: "dom7",
+  dom7flat9: "dom7",
+  maj7sharp5: "maj7",
+  maj7flat5: "maj7"
+};
+var SLASH_CONTAINING_ALIASES = QUALITY_ALIAS_TABLE.filter(
+  (e) => e.alias.includes("/")
+).sort((a, b) => b.alias.length - a.alias.length);
+function parseChordSymbol(chord) {
+  const cleaned = chord.replace(/[()]/g, "").trim();
+  if (!cleaned) return null;
+  const rootMatch = cleaned.match(ROOT_PATTERN);
+  if (!rootMatch) return null;
+  const rootText = rootMatch[1];
+  const rootSemitone = resolveRootSemitone(rootText);
+  if (rootSemitone === null) return null;
+  const remainder = cleaned.slice(rootText.length);
+  const slashAlias = SLASH_CONTAINING_ALIASES.find(
+    (e) => remainder.startsWith(e.alias)
+  );
+  let qualitySymbol;
+  let bassPart;
+  if (slashAlias) {
+    qualitySymbol = slashAlias.alias;
+    const rest = remainder.slice(slashAlias.alias.length);
+    bassPart = rest.startsWith("/") ? rest.slice(1).trim() : void 0;
+  } else {
+    const slashIndex = remainder.indexOf("/");
+    if (slashIndex === -1) {
+      qualitySymbol = remainder;
+    } else {
+      qualitySymbol = remainder.slice(0, slashIndex);
+      bassPart = remainder.slice(slashIndex + 1).trim();
+    }
+  }
+  const quality = resolveQuality(qualitySymbol);
+  let bassSemitone;
+  if (bassPart) {
+    const bassMatch = bassPart.match(ROOT_PATTERN);
+    if (bassMatch) {
+      const resolved = resolveRootSemitone(bassMatch[1]);
+      if (resolved !== null) bassSemitone = resolved;
+    }
+  }
+  return {
+    raw: cleaned,
+    rootSemitone,
+    rootDisplay: pitchClassName(rootSemitone),
+    quality,
+    bassSemitone
+  };
+}
+function computePianoVoicing(rootSemitone, intervals, bassSemitone) {
+  const rootPc = (rootSemitone % 12 + 12) % 12;
+  if (bassSemitone !== void 0) {
+    const bassPc = (bassSemitone % 12 + 12) % 12;
+    const notes2 = [pitchClassName(bassPc)];
+    const highlightKeys2 = [bassPc];
+    for (const iv of intervals) {
+      const key = (rootPc + iv) % 12 + 12;
+      const name = pitchClassName(rootPc + iv);
+      highlightKeys2.push(key);
+      if (!notes2.includes(name)) notes2.push(name);
+    }
+    return { notes: notes2, highlightKeys: highlightKeys2 };
+  }
+  const notes = intervals.map((iv) => pitchClassName(rootPc + iv));
+  const highlightKeys = intervals.map((iv) => (rootPc + iv) % 24);
+  return { notes, highlightKeys };
+}
+var OPEN_CHORD_SHAPES = {
+  C: { frets: [-1, 3, 2, 0, 1, 0], fingers: [0, 3, 2, 0, 1, 0] },
+  Cm: { frets: [-1, 3, 5, 5, 4, 3], fingers: [0, 1, 3, 4, 2, 1], barre: 3 },
+  C7: { frets: [-1, 3, 2, 3, 1, 0], fingers: [0, 3, 2, 4, 1, 0] },
+  Cmaj7: { frets: [-1, 3, 2, 0, 0, 0], fingers: [0, 3, 2, 0, 0, 0] },
+  Cm7: { frets: [-1, 3, 5, 3, 4, 3], fingers: [0, 1, 3, 1, 2, 1], barre: 3 },
+  Csus4: { frets: [-1, 3, 3, 0, 1, 1], fingers: [0, 3, 4, 0, 1, 1] },
+  Csus2: { frets: [-1, 3, 0, 0, 1, 3], fingers: [0, 2, 0, 0, 1, 4] },
+  Cadd9: { frets: [-1, 3, 2, 0, 3, 0], fingers: [0, 2, 1, 0, 3, 0] },
+  C9: { frets: [-1, 3, 2, 3, 3, 3], fingers: [0, 2, 1, 3, 3, 3], barre: 3 },
+  C6: { frets: [-1, 3, 2, 2, 1, 0], fingers: [0, 4, 2, 3, 1, 0] },
+  "C#": { frets: [-1, 4, 6, 6, 6, 4], fingers: [0, 1, 2, 3, 4, 1], barre: 4 },
+  "C#m": {
+    frets: [-1, 4, 6, 6, 5, 4],
+    fingers: [0, 1, 3, 4, 2, 1],
+    barre: 4
+  },
+  "C#7": { frets: [-1, 4, 3, 4, 2, -1], fingers: [0, 3, 2, 4, 1, 0] },
+  "C#maj7": {
+    frets: [-1, 4, 6, 5, 6, 4],
+    fingers: [0, 1, 3, 2, 4, 1],
+    barre: 4
+  },
+  "C#m7": {
+    frets: [-1, 4, 6, 4, 5, 4],
+    fingers: [0, 1, 3, 1, 2, 1],
+    barre: 4
+  },
+  D: { frets: [-1, -1, 0, 2, 3, 2], fingers: [0, 0, 0, 1, 3, 2] },
+  Dm: { frets: [-1, -1, 0, 2, 3, 1], fingers: [0, 0, 0, 2, 3, 1] },
+  D7: { frets: [-1, -1, 0, 2, 1, 2], fingers: [0, 0, 0, 2, 1, 3] },
+  Dmaj7: {
+    frets: [-1, -1, 0, 2, 2, 2],
+    fingers: [0, 0, 0, 1, 1, 1],
+    barre: 2
+  },
+  Dm7: { frets: [-1, -1, 0, 2, 1, 1], fingers: [0, 0, 0, 2, 1, 1], barre: 1 },
+  Dsus4: { frets: [-1, -1, 0, 2, 3, 3], fingers: [0, 0, 0, 1, 2, 3] },
+  Dsus2: { frets: [-1, -1, 0, 2, 3, 0], fingers: [0, 0, 0, 1, 2, 0] },
+  Dadd9: { frets: [-1, -1, 0, 2, 5, 2], fingers: [0, 0, 0, 1, 4, 2] },
+  D6: { frets: [-1, -1, 0, 2, 0, 2], fingers: [0, 0, 0, 2, 0, 3] },
+  D9: { frets: [-1, -1, 0, 2, 1, 0], fingers: [0, 0, 0, 2, 1, 0] },
+  Eb: { frets: [-1, 6, 8, 8, 8, 6], fingers: [0, 1, 2, 3, 4, 1], barre: 6 },
+  Ebm: { frets: [-1, 6, 8, 8, 7, 6], fingers: [0, 1, 3, 4, 2, 1], barre: 6 },
+  Eb7: { frets: [-1, 6, 5, 6, 4, -1], fingers: [0, 3, 2, 4, 1, 0] },
+  E: { frets: [0, 2, 2, 1, 0, 0], fingers: [0, 2, 3, 1, 0, 0] },
+  Em: { frets: [0, 2, 2, 0, 0, 0], fingers: [0, 2, 3, 0, 0, 0] },
+  E7: { frets: [0, 2, 0, 1, 0, 0], fingers: [0, 2, 0, 1, 0, 0] },
+  Emaj7: { frets: [0, 2, 1, 1, 0, 0], fingers: [0, 3, 1, 2, 0, 0] },
+  Em7: { frets: [0, 2, 0, 0, 0, 0], fingers: [0, 2, 0, 0, 0, 0] },
+  Esus4: { frets: [0, 2, 2, 2, 0, 0], fingers: [0, 2, 3, 4, 0, 0] },
+  Eadd9: { frets: [0, 2, 4, 1, 0, 0], fingers: [0, 2, 4, 1, 0, 0] },
+  E6: { frets: [0, 2, 2, 1, 2, 0], fingers: [0, 2, 3, 1, 4, 0] },
+  E9: { frets: [0, 2, 0, 1, 3, 0], fingers: [0, 2, 0, 1, 4, 0] },
+  F: { frets: [1, 3, 3, 2, 1, 1], fingers: [1, 3, 4, 2, 1, 1], barre: 1 },
+  Fm: { frets: [1, 3, 3, 1, 1, 1], fingers: [1, 3, 4, 1, 1, 1], barre: 1 },
+  F7: { frets: [1, 3, 1, 2, 1, 1], fingers: [1, 3, 1, 2, 1, 1], barre: 1 },
+  Fmaj7: { frets: [-1, 3, 3, 2, 1, 0], fingers: [0, 3, 4, 2, 1, 0] },
+  Fm7: { frets: [1, 3, 1, 1, 1, 1], fingers: [1, 3, 1, 1, 1, 1], barre: 1 },
+  "F#": { frets: [2, 4, 4, 3, 2, 2], fingers: [1, 3, 4, 2, 1, 1], barre: 2 },
+  "F#m": { frets: [2, 4, 4, 2, 2, 2], fingers: [1, 3, 4, 1, 1, 1], barre: 2 },
+  "F#7": { frets: [2, 4, 2, 3, 2, 2], fingers: [1, 3, 1, 2, 1, 1], barre: 2 },
+  "F#m7": {
+    frets: [2, 4, 2, 2, 2, 2],
+    fingers: [1, 3, 1, 1, 1, 1],
+    barre: 2
+  },
+  G: { frets: [3, 2, 0, 0, 3, 3], fingers: [2, 1, 0, 0, 3, 4] },
+  Gm: { frets: [3, 5, 5, 3, 3, 3], fingers: [1, 3, 4, 1, 1, 1], barre: 3 },
+  G7: { frets: [3, 2, 0, 0, 0, 1], fingers: [3, 2, 0, 0, 0, 1] },
+  Gmaj7: { frets: [3, 2, 0, 0, 0, 2], fingers: [2, 1, 0, 0, 0, 3] },
+  Gm7: { frets: [3, 5, 3, 3, 3, 3], fingers: [1, 3, 1, 1, 1, 1], barre: 3 },
+  Gsus4: { frets: [3, 3, 0, 0, 3, 3], fingers: [2, 3, 0, 0, 1, 4] },
+  Gadd9: { frets: [3, 2, 0, 2, 0, 3], fingers: [2, 1, 0, 3, 0, 4] },
+  G6: { frets: [3, 2, 0, 0, 0, 0], fingers: [3, 2, 0, 0, 0, 0] },
+  Ab: { frets: [4, 6, 6, 5, 4, 4], fingers: [1, 3, 4, 2, 1, 1], barre: 4 },
+  Abm: { frets: [4, 6, 6, 4, 4, 4], fingers: [1, 3, 4, 1, 1, 1], barre: 4 },
+  A: { frets: [-1, 0, 2, 2, 2, 0], fingers: [0, 0, 1, 2, 3, 0] },
+  Am: { frets: [-1, 0, 2, 2, 1, 0], fingers: [0, 0, 2, 3, 1, 0] },
+  A7: { frets: [-1, 0, 2, 0, 2, 0], fingers: [0, 0, 1, 0, 2, 0] },
+  Amaj7: { frets: [-1, 0, 2, 1, 2, 0], fingers: [0, 0, 2, 1, 3, 0] },
+  Am7: { frets: [-1, 0, 2, 0, 1, 0], fingers: [0, 0, 2, 0, 1, 0] },
+  Asus4: { frets: [-1, 0, 2, 2, 3, 0], fingers: [0, 0, 1, 2, 4, 0] },
+  Asus2: { frets: [-1, 0, 2, 2, 0, 0], fingers: [0, 0, 1, 2, 0, 0] },
+  Aadd9: { frets: [-1, 0, 2, 4, 2, 0], fingers: [0, 0, 1, 3, 2, 0] },
+  A6: { frets: [-1, 0, 2, 2, 2, 2], fingers: [0, 0, 1, 1, 1, 1], barre: 2 },
+  A9: { frets: [-1, 0, 2, 4, 2, 3], fingers: [0, 0, 1, 3, 2, 4] },
+  Bb: { frets: [-1, 1, 3, 3, 3, 1], fingers: [0, 1, 2, 3, 4, 1], barre: 1 },
+  Bbm: { frets: [-1, 1, 3, 3, 2, 1], fingers: [0, 1, 3, 4, 2, 1], barre: 1 },
+  Bb7: { frets: [-1, 1, 3, 1, 3, 1], fingers: [0, 1, 3, 1, 4, 1], barre: 1 },
+  B: { frets: [-1, 2, 4, 4, 4, 2], fingers: [0, 1, 2, 3, 4, 1], barre: 2 },
+  Bm: { frets: [-1, 2, 4, 4, 3, 2], fingers: [0, 1, 3, 4, 2, 1], barre: 2 },
+  B7: { frets: [-1, 2, 1, 2, 0, 2], fingers: [0, 2, 1, 3, 0, 4] },
+  Bmaj7: {
+    frets: [-1, 2, 4, 3, 4, 2],
+    fingers: [0, 1, 3, 2, 4, 1],
+    barre: 2
+  },
+  Bm7: { frets: [-1, 2, 4, 2, 3, 2], fingers: [0, 1, 3, 1, 2, 1], barre: 2 }
+};
+var SLASH_CHORD_SHAPES = {
+  "C/E": { frets: [0, 3, 2, 0, 1, 0], fingers: [0, 3, 2, 0, 1, 0] },
+  "C/G": { frets: [3, 3, 2, 0, 1, 0], fingers: [3, 4, 2, 0, 1, 0] },
+  "C/Bb": { frets: [-1, 3, 2, 3, 1, 0], fingers: [0, 3, 2, 4, 1, 0] },
+  "D/F#": { frets: [2, 0, 0, 2, 3, 2], fingers: [1, 0, 0, 2, 4, 3] },
+  "D/A": { frets: [-1, 0, 0, 2, 3, 2], fingers: [0, 0, 0, 1, 3, 2] },
+  "E/G#": { frets: [4, 2, 2, 1, 0, 0], fingers: [4, 2, 3, 1, 0, 0] },
+  "E/B": { frets: [0, 2, 2, 1, 0, 0], fingers: [0, 2, 3, 1, 0, 0] },
+  "F/A": { frets: [-1, 0, 3, 2, 1, 1], fingers: [0, 0, 3, 2, 1, 1] },
+  "F/C": {
+    frets: [8, 8, 10, 10, 10, 8],
+    fingers: [1, 1, 2, 3, 4, 1],
+    barre: 8
+  },
+  "G/B": { frets: [-1, 2, 0, 0, 3, 3], fingers: [0, 1, 0, 0, 3, 4] },
+  "G/D": { frets: [-1, -1, 0, 0, 3, 3], fingers: [0, 0, 0, 0, 3, 4] },
+  "G/F": { frets: [3, 2, 0, 0, 0, 1], fingers: [3, 2, 0, 0, 0, 1] },
+  "A/C#": { frets: [-1, 4, 2, 2, 2, -1], fingers: [0, 4, 1, 1, 1, 0] },
+  "A/E": { frets: [0, 0, 2, 2, 2, 0], fingers: [0, 0, 1, 2, 3, 0] },
+  "A/G": { frets: [3, 0, 2, 2, 2, 0], fingers: [4, 0, 1, 2, 3, 0] },
+  "B/D#": { frets: [-1, 6, 4, 4, 4, -1], fingers: [0, 3, 1, 1, 1, 0] },
+  "B/F#": {
+    frets: [2, 2, 4, 4, 4, 2],
+    fingers: [1, 1, 2, 3, 4, 1],
+    barre: 2
+  },
+  "Am/G": { frets: [3, 0, 2, 2, 1, 0], fingers: [4, 0, 2, 3, 1, 0] },
+  "Am/F#": { frets: [2, 0, 2, 2, 1, 0], fingers: [2, 0, 3, 4, 1, 0] },
+  "Am/E": { frets: [0, 0, 2, 2, 1, 0], fingers: [0, 0, 2, 3, 1, 0] },
+  "Dm/C": { frets: [-1, 3, 0, 2, 3, 1], fingers: [0, 3, 0, 2, 4, 1] },
+  "Dm/B": { frets: [-1, 2, 0, 2, 3, 1], fingers: [0, 2, 0, 3, 4, 1] },
+  "Dm/A": { frets: [-1, 0, 0, 2, 3, 1], fingers: [0, 0, 0, 2, 3, 1] },
+  "Dm/F": { frets: [1, -1, 0, 2, 3, 1], fingers: [1, 0, 0, 2, 4, 3] },
+  "Em/D": { frets: [0, 2, 0, 0, 0, 0], fingers: [0, 2, 0, 0, 0, 0] },
+  "Em/C#": { frets: [0, 4, 2, 0, 0, 0], fingers: [0, 3, 1, 0, 0, 0] },
+  "Em/B": {
+    frets: [7, 7, 9, 9, 8, 7],
+    fingers: [1, 1, 3, 4, 2, 1],
+    barre: 7
+  },
+  "Em/G": { frets: [3, 2, 2, 0, 0, 0], fingers: [3, 1, 2, 0, 0, 0] },
+  "Fm/Eb": { frets: [-1, 6, 6, 5, 6, -1], fingers: [0, 2, 3, 1, 4, 0] },
+  "Gm/F": {
+    frets: [3, 5, 3, 3, 3, 3],
+    fingers: [1, 3, 1, 1, 1, 1],
+    barre: 3
+  },
+  "Bm/A": { frets: [-1, 0, 4, 4, 3, 2], fingers: [0, 0, 3, 4, 2, 1] }
+};
+var CANONICAL_SUFFIX = {
+  major: "",
+  minor: "m",
+  dom7: "7",
+  maj7: "maj7",
+  m7: "m7",
+  sus4: "sus4",
+  sus2: "sus2",
+  six: "6",
+  add9: "add9",
+  nine: "9"
+};
+var E_FORM = {
+  major: {
+    formRootSemitone: 4,
+    frets: [0, 2, 2, 1, 0, 0],
+    openFingers: [0, 2, 3, 1, 0, 0],
+    barreFingers: [1, 3, 4, 2, 1, 1]
+  },
+  minor: {
+    formRootSemitone: 4,
+    frets: [0, 2, 2, 0, 0, 0],
+    openFingers: [0, 2, 3, 0, 0, 0],
+    barreFingers: [1, 3, 4, 1, 1, 1]
+  },
+  dom7: {
+    formRootSemitone: 4,
+    frets: [0, 2, 0, 1, 0, 0],
+    openFingers: [0, 2, 0, 1, 0, 0],
+    barreFingers: [1, 3, 1, 2, 1, 1]
+  },
+  m7: {
+    formRootSemitone: 4,
+    frets: [0, 2, 0, 0, 0, 0],
+    openFingers: [0, 2, 0, 0, 0, 0],
+    barreFingers: [1, 3, 1, 1, 1, 1]
+  },
+  maj7: {
+    formRootSemitone: 4,
+    frets: [0, 2, 1, 1, 0, 0],
+    openFingers: [0, 3, 1, 2, 0, 0],
+    barreFingers: [1, 3, 2, 2, 1, 1]
+  },
+  sus4: {
+    formRootSemitone: 4,
+    frets: [0, 2, 2, 2, 0, 0],
+    openFingers: [0, 2, 3, 4, 0, 0],
+    barreFingers: [1, 3, 4, 4, 1, 1]
+  }
+};
+var A_FORM = {
+  major: {
+    formRootSemitone: 9,
+    frets: [-1, 0, 2, 2, 2, 0],
+    openFingers: [0, 0, 1, 2, 3, 0],
+    barreFingers: [0, 1, 3, 4, 4, 1]
+  },
+  minor: {
+    formRootSemitone: 9,
+    frets: [-1, 0, 2, 2, 1, 0],
+    openFingers: [0, 0, 2, 3, 1, 0],
+    barreFingers: [0, 1, 3, 4, 2, 1]
+  },
+  dom7: {
+    formRootSemitone: 9,
+    frets: [-1, 0, 2, 0, 2, 0],
+    openFingers: [0, 0, 1, 0, 2, 0],
+    barreFingers: [0, 1, 3, 1, 4, 1]
+  },
+  m7: {
+    formRootSemitone: 9,
+    frets: [-1, 0, 2, 0, 1, 0],
+    openFingers: [0, 0, 2, 0, 1, 0],
+    barreFingers: [0, 1, 3, 1, 2, 1]
+  },
+  maj7: {
+    formRootSemitone: 9,
+    frets: [-1, 0, 2, 1, 2, 0],
+    openFingers: [0, 0, 2, 1, 3, 0],
+    barreFingers: [0, 1, 3, 2, 4, 1]
+  },
+  sus4: {
+    formRootSemitone: 9,
+    frets: [-1, 0, 2, 2, 3, 0],
+    openFingers: [0, 0, 1, 2, 4, 0],
+    barreFingers: [0, 1, 3, 3, 4, 1]
+  },
+  sus2: {
+    formRootSemitone: 9,
+    frets: [-1, 0, 2, 2, 0, 0],
+    openFingers: [0, 0, 1, 2, 0, 0],
+    barreFingers: [0, 1, 3, 4, 1, 1]
+  }
+};
+function realizeTemplate(t, targetSemitone) {
+  const shift = ((targetSemitone - t.formRootSemitone) % 12 + 12) % 12;
+  const frets = t.frets.map((f) => f < 0 ? f : f + shift);
+  if (shift === 0) return { frets, fingers: t.openFingers ?? t.barreFingers };
+  return { frets, fingers: t.barreFingers, barre: shift };
+}
+function maxFret(shape) {
+  return Math.max(0, ...shape.frets.filter((f) => f >= 0));
+}
+function templateFingering(qualityId, targetSemitone) {
+  const e = E_FORM[qualityId];
+  const a = A_FORM[qualityId];
+  if (!e && !a) return null;
+  if (e && !a) return realizeTemplate(e, targetSemitone);
+  if (a && !e) return realizeTemplate(a, targetSemitone);
+  const eShape = realizeTemplate(e, targetSemitone);
+  const aShape = realizeTemplate(a, targetSemitone);
+  return maxFret(aShape) <= maxFret(eShape) ? aShape : eShape;
+}
+function powerChordShape(targetSemitone) {
+  const shift = ((targetSemitone - 4) % 12 + 12) % 12;
+  return {
+    frets: [shift, shift + 2, shift + 2, -1, -1, -1],
+    fingers: [1, 3, 4, 0, 0, 0]
+  };
+}
+var TEMPLATE_QUALITIES = /* @__PURE__ */ new Set([
+  "major",
+  "minor",
+  "dom7",
+  "m7",
+  "maj7",
+  "sus4",
+  "sus2"
+]);
+function getGuitarFingering(parsed) {
+  const { rootSemitone, quality, raw, rootDisplay } = parsed;
+  if (SLASH_CHORD_SHAPES[raw])
+    return { shape: SLASH_CHORD_SHAPES[raw], approximate: false };
+  if (OPEN_CHORD_SHAPES[raw])
+    return { shape: OPEN_CHORD_SHAPES[raw], approximate: false };
+  const suffix = CANONICAL_SUFFIX[quality.id];
+  if (suffix !== void 0) {
+    const canonical = rootDisplay + suffix;
+    if (OPEN_CHORD_SHAPES[canonical])
+      return { shape: OPEN_CHORD_SHAPES[canonical], approximate: false };
+  }
+  if (quality.id === "five")
+    return { shape: powerChordShape(rootSemitone), approximate: false };
+  if (TEMPLATE_QUALITIES.has(quality.id)) {
+    const shape = templateFingering(quality.id, rootSemitone);
+    if (shape) return { shape, approximate: false };
+  }
+  let fallbackId = QUALITY_SIMPLIFICATION[quality.id];
+  let hops = 0;
+  while (fallbackId && hops < 4) {
+    if (TEMPLATE_QUALITIES.has(fallbackId)) {
+      const shape = templateFingering(fallbackId, rootSemitone);
+      if (shape) return { shape, approximate: true };
+    }
+    const suf = CANONICAL_SUFFIX[fallbackId];
+    if (suf !== void 0) {
+      const canonical = rootDisplay + suf;
+      if (OPEN_CHORD_SHAPES[canonical])
+        return {
+          shape: OPEN_CHORD_SHAPES[canonical],
+          approximate: true
+        };
+    }
+    fallbackId = QUALITY_SIMPLIFICATION[fallbackId];
+    hops += 1;
+  }
+  return null;
+}
+var DefaultChordDictionary = class {
+  getFingering(chord) {
+    const parsed = parseChordSymbol(chord);
+    if (!parsed) return null;
+    const piano = computePianoVoicing(
+      parsed.rootSemitone,
+      parsed.quality.intervals,
+      parsed.bassSemitone
+    );
+    const guitar = getGuitarFingering(parsed);
+    return {
+      chord: parsed.raw,
+      qualityId: parsed.quality.id,
+      qualityLabel: parsed.quality.label,
+      piano,
+      guitar: guitar ? {
+        frets: guitar.shape.frets,
+        fingers: guitar.shape.fingers,
+        barre: guitar.shape.barre,
+        approximate: guitar.approximate || void 0
+      } : void 0
+    };
+  }
+};
+var chordDictionary = new DefaultChordDictionary();
+
+// src/parser/txt-to-chordpro.ts
+var DEFAULT_OPTIONS = {
+  source: "auto",
+  detectSections: true,
+  strictChordDetection: true,
+  dehyphenateSyllables: "auto",
+  keepRepeatMarkers: true,
+  partTagNames: { start: "start_of_part", end: "end_of_part" }
+};
+var CHORD_ROOT = "(?:[A-G]|D[o\xF3]|R[e\xE9]|Mi|F[a\xE1]|Sol|L[a\xE1]|Si)";
+var CHORD_BODY = CHORD_ROOT + "(?:#|b)?(?:maj|min|m\\(maj7\\)|mM|m7b5|dim|aug|alt|\u0394|\xB0|\xF8|M|m|\\+|-)?(?:2|4|5|6\\/9|6|7|9|11|13)?(?:[Mm+])?(?:sus(?:2|4)?)?(?:add(?:2|4|6|9|11|13))?(?:(?:omit|no)(?:3|5))?(?:\\((?:[#b]?(?:5|9|11|13)|sus(?:2|4)?|add(?:2|4|9|11|13)|alt|omit(?:3|5)|no(?:3|5))(?:[,/]\\s*[#b]?(?:5|9|11|13))*\\))*(?:[#b](?:5|9|11|13))*(?:\\/" + CHORD_ROOT + "(?:#|b)?)?";
+var CHORD_TOKEN_REGEX = new RegExp(`^${CHORD_BODY}$`, "i");
+var NO_CHORD_TOKEN_REGEX = /^N\.?C\.?$/i;
+var CHORD_SCAN_REGEX = new RegExp(
+  `(?<=^|\\s)(${CHORD_BODY}|N\\.?C\\.?)(?=\\s|$)`,
+  "gi"
+);
+var PUNCTUATION_TOKENS = /* @__PURE__ */ new Set([
+  "|",
+  "%",
+  "-",
+  ".",
+  "...",
+  "/",
+  "x2",
+  "x3",
+  "x4",
+  "x5",
+  "x6",
+  "x7",
+  "x8",
+  "2x",
+  "3x",
+  "4x",
+  "5x",
+  "6x",
+  "7x",
+  "8x"
+]);
+function isValidChordToken(token) {
+  const clean = token.replace(/^[(]/, "").replace(/[)]$/, "");
+  return CHORD_TOKEN_REGEX.test(clean) || NO_CHORD_TOKEN_REGEX.test(clean);
+}
+function isChordLine(line, strict) {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+  const tokens = trimmed.split(/\s+/).filter((t) => !PUNCTUATION_TOKENS.has(t.toLowerCase()));
+  if (tokens.length === 0) return false;
+  const validCount = tokens.filter(isValidChordToken).length;
+  return strict ? validCount === tokens.length : validCount / tokens.length >= 0.8;
+}
+function isAlreadyInlineChordPro(line) {
+  const matches = [...line.matchAll(/\[([^\]]+)\]/g)];
+  if (matches.length === 0) return false;
+  return matches.every((m) => isValidChordToken(m[1]));
+}
+var METADATA_MAP = {
+  title: "title",
+  t: "title",
+  titulo: "title",
+  t\u00EDtulo: "title",
+  subtitle: "subtitle",
+  st: "subtitle",
+  artist: "artist",
+  a: "artist",
+  artista: "artist",
+  interprete: "artist",
+  int\u00E9rprete: "artist",
+  composer: "composer",
+  music: "composer",
+  compositor: "composer",
+  lyricist: "lyricist",
+  words: "lyricist",
+  letra: "lyricist",
+  letrista: "lyricist",
+  album: "album",
+  \u00E1lbum: "album",
+  key: "key",
+  tom: "key",
+  capo: "capo",
+  capotraste: "capo",
+  capodastro: "capo",
+  tuning: "tuning",
+  afinacao: "tuning",
+  afina\u00E7\u00E3o: "tuning",
+  tempo: "tempo",
+  andamento: "tempo",
+  bpm: "tempo",
+  time: "time",
+  compasso: "time",
+  year: "year",
+  ano: "year",
+  copyright: "copyright",
+  duration: "duration",
+  duracao: "duration",
+  dura\u00E7\u00E3o: "duration"
+};
+function stripAccents(s) {
+  return s.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+var SECTION_KEYWORDS = {
+  verse: ["verso", "verse"],
+  chorus: ["refrao", "chorus", "coro"],
+  bridge: [
+    "ponte",
+    "bridge",
+    "pre-refrao",
+    "prerefrao",
+    "prechorus",
+    "pre chorus",
+    "pre-chorus"
+  ],
+  part: [
+    "intro",
+    "introducao",
+    "introducao1",
+    "outro",
+    "final",
+    "coda",
+    "instrumental",
+    "interlude",
+    "interludio",
+    "solo",
+    "solo de guitarra",
+    "solo de violao",
+    "riff"
+  ]
+};
+var SECTION_TAGS = {
+  verse: { start: "start_of_verse", end: "end_of_verse" },
+  chorus: { start: "start_of_chorus", end: "end_of_chorus" },
+  bridge: { start: "start_of_bridge", end: "end_of_bridge" },
+  // 'part' tag names are configurable via options.partTagNames
+  part: { start: "start_of_part", end: "end_of_part" }
+};
+var BRACKET_HEADER_REGEX = /^\[([^\]]+)]$/;
+function classifySectionLabel(rawLabel) {
+  let s = rawLabel.trim().replace(/:$/, "").trim();
+  const base = s.replace(/\s*\d+\s*$/, "").trim();
+  const normalized = stripAccents(base).toLowerCase();
+  for (const kind of Object.keys(SECTION_KEYWORDS)) {
+    if (SECTION_KEYWORDS[kind].some(
+      (kw) => normalized === kw || normalized.startsWith(kw)
+    )) {
+      return { kind, label: s };
+    }
+  }
+  return null;
+}
+var REPEAT_NOTATION_REGEX = /\s*\(?\b(\d+)\s*[xX]\b\)?\s*$|\s+[xX](\d+)\s*$/;
+function extractRepeatNotation(line) {
+  const match = line.match(REPEAT_NOTATION_REGEX);
+  if (match) {
+    return {
+      cleanLine: line.slice(0, match.index).replace(/\s+$/, ""),
+      marker: match[0].trim()
+    };
+  }
+  return { cleanLine: line, marker: null };
+}
+function countSyllableHyphens(line) {
+  const matches = line.match(/[^\s-]-[^\s-]/g);
+  return matches ? matches.length : 0;
+}
+function dehyphenate(line) {
+  return line.replace(/([^\s-])-([^\s-])/g, "$1 $2");
+}
+function detectSourceFormat(input) {
+  const lines = input.split("\n");
+  let ugScore = 0;
+  let ccScore = 0;
+  let sawChordLine = false;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (BRACKET_HEADER_REGEX.test(line)) ugScore += 2;
+    if (/^(capo|tuning|key)\s*:/i.test(line)) ugScore += 2;
+    if (/\s[xX]\d+\s*$/.test(raw)) ugScore += 1;
+    if (/^(tom|capotraste|capodastro|int[ée]rprete|compositor|letrista)\s*:/i.test(
+      line
+    ))
+      ccScore += 2;
+    if (/^\(?\d+x\)?\s*$/i.test(line)) ccScore += 1;
+    if (isChordLine(line, true)) {
+      sawChordLine = true;
+      if (countSyllableHyphens(line) === 0) {
+      }
+    } else if (countSyllableHyphens(line) >= 2) {
+      ccScore += 2;
+    }
+  }
+  if (!sawChordLine) return "plain";
+  if (ccScore > ugScore) return "cifraclub";
+  if (ugScore > 0) return "ultimate-guitar";
+  return "plain";
+}
+function mergeChordsIntoLyric(chordLine, lyricLine, trailingMarker) {
+  const matches = [...chordLine.matchAll(CHORD_SCAN_REGEX)];
+  let combined = "";
+  let lastIndex = 0;
+  for (const match of matches) {
+    const token = match[0];
+    const index = match.index ?? 0;
+    const rendered = NO_CHORD_TOKEN_REGEX.test(token) ? token.toUpperCase() : token;
+    combined += lyricLine.substring(lastIndex, index);
+    combined += `[${rendered}]`;
+    lastIndex = index;
+  }
+  combined += lyricLine.substring(lastIndex);
+  if (trailingMarker) {
+    combined += ` ${trailingMarker}`;
+  }
+  return combined;
+}
+function classify(lines, opts, effectiveSource) {
+  const result = [];
+  const shouldDehyphenateGlobally = opts.dehyphenateSyllables === true || opts.dehyphenateSyllables === "auto" && effectiveSource === "cifraclub";
+  const hyphenThreshold = effectiveSource === "cifraclub" ? 1 : 2;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i].replace(/\r$/, "");
+    const trimmed = raw.trim();
+    if (trimmed === "") {
+      result.push({ kind: "blank" });
+      continue;
+    }
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      result.push({ kind: "directive", rendered: trimmed });
+      continue;
+    }
+    if (isAlreadyInlineChordPro(trimmed)) {
+      result.push({ kind: "inline-chordpro", rendered: raw });
+      continue;
+    }
+    const bracketMatch = trimmed.match(BRACKET_HEADER_REGEX);
+    if (bracketMatch) {
+      const classified = classifySectionLabel(bracketMatch[1]);
+      if (classified) {
+        result.push({ kind: "section-header", section: classified });
+        continue;
+      }
+    }
+    const metaMatch = trimmed.match(/^([A-Za-zÀ-ÿ ]+):\s*(.*)/);
+    if (metaMatch) {
+      const key = stripAccents(metaMatch[1].toLowerCase().trim());
+      const value = metaMatch[2];
+      if (METADATA_MAP[key]) {
+        result.push({
+          kind: "metadata",
+          rendered: `{${METADATA_MAP[key]}: ${value}}`
+        });
+        continue;
+      }
+    }
+    if (trimmed.startsWith("#")) {
+      result.push({
+        kind: "comment",
+        rendered: `{comment: ${trimmed.slice(1).trim()}}`
+      });
+      continue;
+    }
+    if (trimmed.length <= 28 && !isChordLine(trimmed, opts.strictChordDetection)) {
+      const classified = classifySectionLabel(trimmed);
+      if (classified) {
+        result.push({ kind: "section-header", section: classified });
+        continue;
+      }
+    }
+    if (isChordLine(trimmed, opts.strictChordDetection)) {
+      const nextRaw = i + 1 < lines.length ? lines[i + 1].replace(/\r$/, "") : null;
+      const nextIsChord = nextRaw !== null && isChordLine(nextRaw.trim(), opts.strictChordDetection);
+      const nextIsBlank = nextRaw !== null && nextRaw.trim() === "";
+      if (nextRaw === null || nextIsChord || nextIsBlank) {
+        const tokens = trimmed.split(/\s+/);
+        result.push({
+          kind: "chord-only",
+          rendered: tokens.map(
+            (t) => NO_CHORD_TOKEN_REGEX.test(t) ? `[${t.toUpperCase()}]` : `[${t}]`
+          ).join(" ")
+        });
+        continue;
+      }
+      let lyricLine = nextRaw;
+      let marker = null;
+      if (opts.keepRepeatMarkers) {
+        const extracted = extractRepeatNotation(lyricLine);
+        lyricLine = extracted.cleanLine;
+        marker = extracted.marker;
+      }
+      const hyphenCount = countSyllableHyphens(lyricLine);
+      if (shouldDehyphenateGlobally && hyphenCount >= hyphenThreshold) {
+        lyricLine = dehyphenate(lyricLine);
+      } else if (hyphenCount >= 2 && effectiveSource !== "ultimate-guitar") {
+        lyricLine = dehyphenate(lyricLine);
+      }
+      const merged = mergeChordsIntoLyric(raw, lyricLine, marker);
+      result.push({ kind: "chord-lyric", rendered: merged });
+      i++;
+      continue;
+    }
+    result.push({ kind: "lyric", rendered: raw });
+  }
+  return result;
+}
+function render(lines, opts) {
+  const out = [];
+  let openSection = null;
+  const tagsFor = (kind) => kind === "part" ? opts.partTagNames : SECTION_TAGS[kind];
+  const closeSection = () => {
+    if (openSection) {
+      out.push(`{${tagsFor(openSection.kind).end}}`);
+      openSection = null;
+    }
+  };
+  for (const line of lines) {
+    if (line.kind === "section-header" && line.section) {
+      if (opts.detectSections) {
+        closeSection();
+        const tags = tagsFor(line.section.kind);
+        out.push(`{${tags.start}: ${line.section.label}}`);
+        openSection = line.section;
+      } else {
+        out.push(`{comment: ${line.section.label}}`);
+      }
+      continue;
+    }
+    if (line.kind === "blank") {
+      if (opts.detectSections) closeSection();
+      out.push("");
+      continue;
+    }
+    out.push(line.rendered ?? "");
+  }
+  if (opts.detectSections) closeSection();
+  return out.join("\n").replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+function extractTitle(chordpro) {
+  const match = chordpro.match(/\{title:\s*(.*)\}/i);
+  return match ? match[1].trim() : null;
+}
+function slugifyTitle(title) {
+  if (!title) return "cifra_convertida";
+  return stripAccents(title).trim().replace(/\s+/g, "_").replace(/[^a-zA-Z0-9_]/g, "") || "cifra";
+}
+function convertToChordProDetailed(input, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const warnings = [];
+  if (!input || !input.trim()) {
+    return {
+      chordpro: "",
+      title: null,
+      detectedSource: "plain",
+      warnings: ["Empty input."]
+    };
+  }
+  const detectedSource = opts.source === "auto" ? detectSourceFormat(input) : opts.source;
+  const lines = input.split("\n");
+  const parsed = classify(lines, opts, detectedSource);
+  const chordpro = render(parsed, opts);
+  const title = extractTitle(chordpro);
+  if (!title)
+    warnings.push("No {title: ...} directive was detected in the input.");
+  const shorthandTokens = /* @__PURE__ */ new Set();
+  for (const raw of lines) {
+    if (isChordLine(raw.trim(), opts.strictChordDetection)) {
+      for (const m of raw.matchAll(CHORD_SCAN_REGEX)) {
+        if (/^[A-G][#b]?4$/i.test(m[0]) || /^[A-G][#b]?9$/i.test(m[0])) {
+          shorthandTokens.add(m[0]);
+        }
+      }
+    }
+  }
+  if (shorthandTokens.size > 0) {
+    warnings.push(
+      `Ambiguous bare-number chords passed through as-is (not reinterpreted as sus/add): ${[...shorthandTokens].join(", ")}. On Brazilian/Portuguese sheets "G4" usually means Gsus4 - convert manually if your chord engine expects that spelling.`
+    );
+  }
+  return { chordpro, title, detectedSource, warnings };
+}
+function toChordPro(input, options) {
+  return convertToChordProDetailed(input, options).chordpro;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultChordDictionary,
+  buildChordProText,
+  chordDictionary,
+  convertToChordProDetailed,
+  detectSourceFormat,
+  getNoteValue,
+  getSuggestedCapo,
+  parseChordPro,
+  parseLineSegments,
+  slugifyTitle,
+  toChordPro,
+  transposeChord,
+  transposeNote
+});