@hosanna/chordpro 1.1.0

package/dist/chunk-PENNIH4J.mjs

@@ -0,0 +1,1143 @@
+// 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();
+
+export {
+  parseLineSegments,
+  parseChordPro,
+  buildChordProText,
+  getNoteValue,
+  getSuggestedCapo,
+  transposeNote,
+  transposeChord,
+  DefaultChordDictionary,
+  chordDictionary
+};