@hosanna/chordpro 1.1.0

package/dist/index.js

@@ -0,0 +1,3459 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChordFinder: () => ChordFinder,
+  ChordProRenderer: () => ChordProRenderer,
+  ChordRoll: () => ChordRoll,
+  DefaultChordDictionary: () => DefaultChordDictionary,
+  Editor: () => Editor,
+  GuitarDiagram: () => GuitarDiagram,
+  PianoDiagram: () => PianoDiagram,
+  buildChordProText: () => buildChordProText,
+  chordDictionary: () => chordDictionary,
+  convertToChordProDetailed: () => convertToChordProDetailed,
+  detectSourceFormat: () => detectSourceFormat,
+  getNoteValue: () => getNoteValue,
+  getSuggestedCapo: () => getSuggestedCapo,
+  parseChordPro: () => parseChordPro,
+  parseLineSegments: () => parseLineSegments,
+  preloadEditor: () => preloadEditor,
+  registerChordproMode: () => registerChordproMode,
+  registerChordproSnippets: () => registerChordproSnippets,
+  slugifyTitle: () => slugifyTitle,
+  toChordPro: () => toChordPro,
+  transposeChord: () => transposeChord,
+  transposeNote: () => transposeNote
+});
+module.exports = __toCommonJS(index_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;
+}
+
+// src/renderer/ChordProRenderer.tsx
+var import_lucide_react = require("lucide-react");
+var import_react2 = __toESM(require("react"));
+var import_react_youtube = __toESM(require("react-youtube"));
+
+// src/renderer/ChordRoll.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+function GuitarDiagram({
+  frets,
+  fingers,
+  barre
+}) {
+  const maxFret2 = Math.max(...frets);
+  let startFret = 1;
+  if (maxFret2 > 4) {
+    const minFret = Math.min(...frets.filter((f) => f > 0));
+    startFret = minFret;
+  }
+  const numFrets = 4;
+  const width = 100;
+  const height = 110;
+  const getStringX = (index) => 14 + index * 14;
+  const getFretY = (index) => 22 + index * 20;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "svg",
+    {
+      width,
+      height,
+      className: "text-m3-text dark:text-m3-dark-text select-none",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "line",
+          {
+            x1: getStringX(0),
+            y1: getFretY(0) - (startFret === 1 ? 3 : 0),
+            x2: getStringX(5),
+            y2: getFretY(0) - (startFret === 1 ? 3 : 0),
+            className: "stroke-zinc-800 dark:stroke-zinc-200",
+            strokeWidth: startFret === 1 ? 3.5 : 1.5
+          }
+        ),
+        startFret > 1 && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          "text",
+          {
+            x: getStringX(0) - 4,
+            y: getFretY(0) + 12,
+            fontSize: "8",
+            className: "font-mono font-black fill-m3-primary dark:fill-m3-dark-primary",
+            textAnchor: "end",
+            children: [
+              startFret,
+              "\xAA"
+            ]
+          }
+        ),
+        [0, 1, 2, 3, 4, 5].map((idx) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "line",
+          {
+            x1: getStringX(idx),
+            y1: getFretY(0),
+            x2: getStringX(idx),
+            y2: getFretY(numFrets),
+            className: "stroke-zinc-400 dark:stroke-zinc-600",
+            strokeOpacity: "0.5",
+            strokeWidth: "1.2"
+          },
+          idx
+        )),
+        [0, 1, 2, 3, 4].map((idx) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "line",
+          {
+            x1: getStringX(0),
+            y1: getFretY(idx),
+            x2: getStringX(5),
+            y2: getFretY(idx),
+            className: "stroke-zinc-400 dark:stroke-zinc-600",
+            strokeOpacity: "0.4",
+            strokeWidth: "1"
+          },
+          idx
+        )),
+        barre !== void 0 && (() => {
+          const barreFretInWindow = barre - startFret;
+          if (barreFretInWindow >= 0 && barreFretInWindow < numFrets) {
+            const y = getFretY(barreFretInWindow) + 10;
+            const startStr = frets.findIndex((f) => f === barre);
+            const endStr = 5;
+            if (startStr !== -1) {
+              return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                "rect",
+                {
+                  x: getStringX(startStr) - 4,
+                  y: y - 4,
+                  width: getStringX(endStr) - getStringX(startStr) + 8,
+                  height: 8,
+                  rx: 4,
+                  className: "fill-m3-primary dark:fill-m3-dark-primary opacity-80"
+                }
+              );
+            }
+          }
+          return null;
+        })(),
+        frets.map((fret, stringIdx) => {
+          if (fret === -1) {
+            return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "text",
+              {
+                x: getStringX(stringIdx),
+                y: 12,
+                fontSize: "10",
+                fontWeight: "bold",
+                className: "fill-red-500 font-black",
+                textAnchor: "middle",
+                children: "\xD7"
+              },
+              stringIdx
+            );
+          }
+          if (fret === 0) {
+            return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "circle",
+              {
+                cx: getStringX(stringIdx),
+                cy: 10,
+                r: 2,
+                fill: "none",
+                className: "stroke-emerald-500",
+                strokeWidth: "1.2"
+              },
+              stringIdx
+            );
+          }
+          const fretInWindow = fret - startFret;
+          if (fretInWindow >= 0 && fretInWindow < numFrets) {
+            const cx = getStringX(stringIdx);
+            const cy = getFretY(fretInWindow) + 10;
+            const finger = fingers ? fingers[stringIdx] : 0;
+            return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("g", { children: [
+              !(barre !== void 0 && fret === barre && stringIdx >= frets.findIndex((f) => f === barre)) && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                "circle",
+                {
+                  cx,
+                  cy,
+                  r: 5,
+                  className: "fill-m3-primary dark:fill-m3-dark-primary"
+                }
+              ),
+              finger > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                "text",
+                {
+                  x: cx,
+                  y: cy + 2.5,
+                  fontSize: "6.5",
+                  fontWeight: "bold",
+                  fill: "white",
+                  textAnchor: "middle",
+                  className: "font-bold fill-white",
+                  children: finger
+                }
+              )
+            ] }, stringIdx);
+          }
+          return null;
+        })
+      ]
+    }
+  );
+}
+function PianoDiagram({ highlightKeys }) {
+  const whiteKeySemitones = [
+    0,
+    2,
+    4,
+    5,
+    7,
+    9,
+    11,
+    // Octave 1
+    12,
+    14,
+    16,
+    17,
+    19,
+    21,
+    23
+    // Octave 2
+  ];
+  const keyWidth = 14;
+  const keyHeight = 56;
+  const blackWidth = 9;
+  const blackHeight = 34;
+  const blackKeySemitones = [1, 3, 6, 8, 10, 13, 15, 18, 20, 22];
+  const getBlackKeyX = (semitone) => {
+    const octave = Math.floor(semitone / 12);
+    const semitoneInOctave = semitone % 12;
+    let whiteIndexBefore = 0;
+    if (semitoneInOctave === 1) whiteIndexBefore = 1;
+    else if (semitoneInOctave === 3) whiteIndexBefore = 2;
+    else if (semitoneInOctave === 6) whiteIndexBefore = 4;
+    else if (semitoneInOctave === 8) whiteIndexBefore = 5;
+    else if (semitoneInOctave === 10) whiteIndexBefore = 6;
+    const absoluteWhiteIndex = octave * 7 + whiteIndexBefore;
+    return absoluteWhiteIndex * keyWidth - blackWidth / 2;
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "svg",
+    {
+      width: 14 * keyWidth + 2,
+      height: keyHeight + 4,
+      className: "text-m3-text dark:text-m3-dark-text p-1 rounded-lg bg-zinc-100 dark:bg-zinc-900 border border-m3-border dark:border-m3-dark-border select-none",
+      children: [
+        whiteKeySemitones.map((st, idx) => {
+          const isHighlighted = highlightKeys.includes(st);
+          const x = idx * keyWidth + 1;
+          return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("g", { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "rect",
+              {
+                x,
+                y: 2,
+                width: keyWidth - 1,
+                height: keyHeight,
+                rx: 1.5,
+                className: `${isHighlighted ? "fill-m3-primary dark:fill-m3-dark-primary" : "fill-white dark:fill-zinc-800"} stroke-zinc-300 dark:stroke-zinc-700`,
+                strokeWidth: "0.8"
+              }
+            ),
+            isHighlighted && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "circle",
+              {
+                cx: x + (keyWidth - 1) / 2,
+                cy: keyHeight - 8,
+                r: 2,
+                className: "fill-white dark:fill-zinc-900"
+              }
+            )
+          ] }, st);
+        }),
+        blackKeySemitones.map((st) => {
+          const isHighlighted = highlightKeys.includes(st);
+          const x = getBlackKeyX(st) + 1;
+          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("g", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "rect",
+            {
+              x,
+              y: 2,
+              width: blackWidth,
+              height: blackHeight,
+              rx: 1,
+              className: `${isHighlighted ? "fill-m3-primary dark:fill-m3-dark-primary" : "fill-zinc-800 dark:fill-zinc-950"} stroke-zinc-900 dark:stroke-black`,
+              strokeWidth: "0.8"
+            }
+          ) }, st);
+        })
+      ]
+    }
+  );
+}
+function ChordRoll({
+  uniqueChords,
+  transposeVal,
+  capoVal = 0,
+  onChordClick,
+  instrument,
+  showDiagrams,
+  showChords
+}) {
+  const isGuitar = instrument === "guitar";
+  const effectiveTranspose = transposeVal - (isGuitar ? capoVal : 0);
+  const chordItems = (0, import_react.useMemo)(() => {
+    return uniqueChords.map((chord) => {
+      const transposed = transposeChord(chord, effectiveTranspose);
+      const fingering = chordDictionary.getFingering(transposed);
+      return {
+        original: chord,
+        transposed,
+        fingering
+      };
+    });
+  }, [uniqueChords, effectiveTranspose]);
+  if (uniqueChords.length === 0 || !showDiagrams || !showChords) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "div",
+    {
+      className: "w-full select-none mb-6",
+      onTouchStart: (e) => e.stopPropagation(),
+      onTouchMove: (e) => e.stopPropagation(),
+      onTouchEnd: (e) => e.stopPropagation(),
+      children: [
+        isGuitar && capoVal > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "px-4 mb-2 flex items-center justify-between", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "text-[11px] font-bold text-amber-700 dark:text-amber-400 bg-amber-50 dark:bg-amber-950/50 px-2.5 py-0.5 rounded-md border border-amber-200 dark:border-amber-900/40", children: [
+          "Capo na ",
+          capoVal,
+          "\xAA casa \u2014 acordes em formato relativo"
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "flex flex-row overflow-x-auto gap-6 py-2 px-4 no-scrollbar scroll-smooth", children: chordItems.map((item, idx) => {
+          const isPiano = instrument === "piano";
+          return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+            "div",
+            {
+              onClick: () => onChordClick?.(item.transposed),
+              className: `flex flex-col items-center p-2 transition-all cursor-pointer hover:opacity-85 shrink-0 ${isPiano ? "w-48" : "w-24"}`,
+              title: "Clique para ver detalhes do acorde",
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "text-xs font-black text-m3-primary dark:text-m3-dark-primary font-mono mb-1.5", children: item.transposed }),
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "flex items-center justify-center flex-1 min-h-17.5", children: item.fingering ? isPiano && item.fingering.piano ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  PianoDiagram,
+                  {
+                    highlightKeys: item.fingering.piano.highlightKeys
+                  }
+                ) : !isPiano && item.fingering.guitar ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  GuitarDiagram,
+                  {
+                    frets: item.fingering.guitar.frets,
+                    fingers: item.fingering.guitar.fingers,
+                    barre: item.fingering.guitar.barre
+                  }
+                ) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "text-[10px] text-zinc-400 font-mono italic", children: "Sem visual" }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "text-[10px] text-zinc-400 font-mono italic", children: "N\xE3o registado" }) }),
+                item.fingering?.piano && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "text-[9px] font-bold text-m3-secondary dark:text-m3-dark-secondary mt-1.5 font-mono whitespace-nowrap overflow-hidden text-ellipsis max-w-full", children: item.fingering.piano.notes.join(" - ") })
+              ]
+            },
+            idx
+          );
+        }) })
+      ]
+    }
+  );
+}
+
+// src/renderer/ChordProRenderer.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var YT_ID_REGEX = /(?:youtu\.be\/|youtube\.com\/(?:embed\/|v\/|watch\?v=|watch\?.+&v=))([^&?]+)/;
+function extractYoutubeId(urlOrId) {
+  const match = urlOrId.match(YT_ID_REGEX);
+  return match?.[1] || urlOrId;
+}
+function getDuration(duration) {
+  const seconds = Number(duration);
+  if (isNaN(seconds)) {
+    return "00:00";
+  } else {
+    return `${Math.trunc(seconds / 60)}:${seconds % 60}`;
+  }
+}
+var ChordProRenderer = import_react2.default.memo(
+  ({
+    content,
+    showChords,
+    transposeVal = 0,
+    capoVal = 0,
+    onTransposeChange,
+    onCapoChange,
+    twoColumnLayout = false,
+    fontSize,
+    instrument = "guitar",
+    showDiagrams = false,
+    fileName,
+    showYoutubePlayer: showYoutubePlayerProp,
+    onShowYoutubePlayerChange,
+    scrollContainerRef
+  }) => {
+    const [ytPlayerRef, setYtPlayerRef] = (0, import_react2.useState)(null);
+    const [isPlayingYoutube, setIsPlayingYoutube] = (0, import_react2.useState)(false);
+    const [isYoutubeRepeat, setIsYoutubeRepeat] = (0, import_react2.useState)(false);
+    const [showYoutubeInternal, setShowYoutubeInternal] = (0, import_react2.useState)(false);
+    const showYoutubePlayer = showYoutubePlayerProp ?? showYoutubeInternal;
+    const setShowYoutubePlayer = (0, import_react2.useCallback)(
+      (val) => {
+        setShowYoutubeInternal(val);
+        onShowYoutubePlayerChange?.(val);
+      },
+      [onShowYoutubePlayerChange]
+    );
+    const isYoutubeRepeatRef = (0, import_react2.useRef)(isYoutubeRepeat);
+    isYoutubeRepeatRef.current = isYoutubeRepeat;
+    const parsedSong = (0, import_react2.useMemo)(() => {
+      return parseChordPro(content);
+    }, [content]);
+    const { metadata } = parsedSong;
+    const isGuitar = instrument === "guitar";
+    const effectiveCapo = isGuitar ? capoVal : 0;
+    const effectiveTranspose = transposeVal - effectiveCapo;
+    const soundingKey = (0, import_react2.useMemo)(() => {
+      return transposeChord(metadata.key || "C", transposeVal);
+    }, [metadata.key, transposeVal]);
+    const renderedKey = (0, import_react2.useMemo)(() => {
+      return transposeChord(metadata.key || "C", effectiveTranspose);
+    }, [metadata.key, effectiveTranspose]);
+    const resolvedUniqueChords = (0, import_react2.useMemo)(() => {
+      const chords = /* @__PURE__ */ new Set();
+      for (const section of parsedSong.sections) {
+        for (const line of section.lines) {
+          if (line.segments) {
+            for (const seg of line.segments) {
+              if (seg.chord) chords.add(seg.chord);
+            }
+          }
+          if (line.measures) {
+            for (const m of line.measures) {
+              for (const c of m.chords) {
+                if (c.chord) chords.add(c.chord);
+              }
+            }
+          }
+        }
+      }
+      return Array.from(chords);
+    }, [parsedSong]);
+    const [selectedChord, setSelectedChord] = (0, import_react2.useState)(null);
+    const [modalInstrument, setModalInstrument] = (0, import_react2.useState)(
+      instrument
+    );
+    const chordFingering = (0, import_react2.useMemo)(() => {
+      if (!selectedChord) return null;
+      return chordDictionary.getFingering(selectedChord);
+    }, [selectedChord]);
+    const handleChordClick = (chord) => {
+      setModalInstrument(instrument);
+      setSelectedChord(chord);
+    };
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "relative flex flex-col flex-1 overflow-hidden h-full", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        "div",
+        {
+          ref: scrollContainerRef,
+          className: "flex-1 overflow-y-auto px-4 py-4 sm:px-6 bg-slate-50 dark:bg-slate-950 print-page select-text leading-relaxed no-scrollbar relative",
+          children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "max-w-3xl mx-auto print-song-card", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "mb-6 border-b border-neutral-100 dark:border-slate-800 pb-5 select-none", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-start justify-between gap-4 flex-wrap", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("h2", { className: "text-2xl font-bold tracking-tight text-neutral-900 dark:text-white", children: metadata.title }),
+                  metadata.subtitle && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("h3", { className: "text-[15px] font-medium text-neutral-600 dark:text-neutral-400 mt-1", children: metadata.subtitle }),
+                  (metadata.artist || metadata.composer) && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-1.5 text-xs text-neutral-500 mt-2 font-medium flex-wrap", children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.User, { className: "w-3.5 h-3.5 text-[#0284c7]" }),
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { children: [
+                      "Por:",
+                      " ",
+                      [metadata.artist, metadata.composer].filter(Boolean).join(" / ")
+                    ] })
+                  ] }),
+                  metadata.translator && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-1.5 text-xs text-neutral-500 mt-2 font-medium flex-wrap", children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.User, { className: "w-3.5 h-3.5 text-[#0284c7]" }),
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { children: [
+                      "Traduzido por: ",
+                      metadata.translator
+                    ] })
+                  ] }),
+                  metadata.album && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-1.5 text-xs text-neutral-500 mt-1 font-medium", children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Disc, { className: "w-3.5 h-3.5 text-[#0284c7]" }),
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { children: [
+                      "\xC1lbum: ",
+                      metadata.album
+                    ] })
+                  ] })
+                ] }),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex flex-wrap items-center gap-1.5 justify-end", children: [
+                  metadata.songNumber && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-[10px] font-bold bg-neutral-100 dark:bg-slate-800 text-neutral-600 dark:text-neutral-400 px-2 py-1 rounded-lg border border-neutral-200 dark:border-slate-700", children: [
+                    "N\xBA ",
+                    metadata.songNumber
+                  ] }),
+                  (metadata.key || transposeVal !== 0) && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-[10px] font-bold bg-indigo-50 dark:bg-indigo-950/40 text-indigo-700 dark:text-indigo-300 px-2.5 py-1 rounded-lg border border-indigo-100 dark:border-indigo-950/50 flex items-center gap-1", children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Key, { className: "w-3 h-3" }),
+                    "Tom: ",
+                    soundingKey
+                  ] }),
+                  effectiveCapo > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-[10px] font-bold bg-amber-50 dark:bg-amber-950/40 text-amber-700 dark:text-amber-300 px-2.5 py-1 rounded-lg border border-amber-100 dark:border-amber-950/50", children: [
+                    "Capo: ",
+                    effectiveCapo,
+                    "\xAA casa"
+                  ] }),
+                  effectiveCapo > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-[10px] font-bold bg-emerald-50 dark:bg-emerald-950/40 text-emerald-700 dark:text-emerald-300 px-2.5 py-1 rounded-lg border border-emerald-100 dark:border-emerald-950/50", children: [
+                    "Formato: ",
+                    renderedKey
+                  ] }),
+                  metadata.originalKey && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-[10px] font-bold bg-purple-50 dark:bg-purple-950/40 text-purple-700 dark:text-purple-300 px-2.5 py-1 rounded-lg border border-purple-100 dark:border-purple-950/50", children: [
+                    "Tom Orig: ",
+                    metadata.originalKey
+                  ] }),
+                  metadata.capo && metadata.capo !== "0" && effectiveCapo === 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-[10px] font-bold bg-amber-50 dark:bg-amber-950/40 text-amber-700 dark:text-amber-300 px-2.5 py-1 rounded-lg border border-amber-100 dark:border-amber-950/50", children: [
+                    "Capo Orig: ",
+                    metadata.capo,
+                    "\xAA casa"
+                  ] }),
+                  metadata.tempo && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-[10px] font-bold bg-emerald-50 dark:bg-emerald-950/40 text-emerald-700 dark:text-emerald-300 px-2.5 py-1 rounded-lg border border-emerald-100 dark:border-emerald-950/50 flex items-center gap-1", children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Flame, { className: "w-3 h-3" }),
+                    metadata.tempo,
+                    " BPM"
+                  ] }),
+                  metadata.time && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "text-[10px] font-bold bg-cyan-50 dark:bg-cyan-950/40 text-cyan-700 dark:text-cyan-300 px-2.5 py-1 rounded-lg border border-cyan-100 dark:border-cyan-950/50", children: metadata.time }),
+                  metadata.ccli && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-[10px] font-bold bg-slate-100 dark:bg-slate-800 text-slate-500 dark:text-slate-400 px-2.5 py-1 rounded-lg border border-slate-200 dark:border-slate-700", children: [
+                    "CCLI: ",
+                    metadata.ccli
+                  ] })
+                ] })
+              ] }),
+              (metadata.copyright || metadata.duration) && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-4 text-[10px] text-neutral-400 dark:text-neutral-500 mt-3 pt-3 border-t border-neutral-100 dark:border-slate-800/50", children: [
+                metadata.copyright && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { children: [
+                  "\xA9 ",
+                  metadata.copyright
+                ] }),
+                metadata.duration && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { children: [
+                  "Dura\xE7\xE3o: ",
+                  getDuration(metadata.duration)
+                ] })
+              ] }),
+              (transposeVal !== 0 || effectiveCapo !== 0) && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "mt-4 bg-indigo-50 dark:bg-indigo-950/40 text-xs px-3 py-2 rounded-xl text-indigo-700 dark:text-indigo-300 flex items-center justify-between border border-indigo-100 dark:border-indigo-950/50 flex-wrap gap-2", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-2 flex-wrap", children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "font-semibold", children: [
+                    "Tom:",
+                    " ",
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "text-indigo-600 dark:text-indigo-400 font-bold bg-white dark:bg-zinc-900 px-2 py-0.5 rounded border ml-0.5 text-xs", children: soundingKey })
+                  ] }),
+                  effectiveCapo > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "font-semibold text-amber-700 dark:text-amber-300", children: [
+                    "\u2022 Capo:",
+                    " ",
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-amber-700 dark:text-amber-300 font-bold bg-amber-100 dark:bg-amber-900/60 px-2 py-0.5 rounded border border-amber-300 dark:border-amber-800 text-xs ml-0.5", children: [
+                      effectiveCapo,
+                      "\xAA casa (",
+                      renderedKey,
+                      ")"
+                    ] })
+                  ] })
+                ] }),
+                (onTransposeChange || onCapoChange) && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: () => {
+                      onTransposeChange?.(0);
+                      onCapoChange?.(0);
+                    },
+                    className: "text-[10px] font-bold hover:underline underline-offset-2 uppercase text-indigo-600 dark:text-indigo-400 cursor-pointer",
+                    children: "Repor Tom / Capo"
+                  }
+                )
+              ] })
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              ChordRoll,
+              {
+                uniqueChords: resolvedUniqueChords,
+                transposeVal,
+                capoVal: effectiveCapo,
+                onChordClick: handleChordClick,
+                instrument,
+                showDiagrams,
+                showChords
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              "div",
+              {
+                className: `font-sans leading-relaxed text-sm select-text ${twoColumnLayout ? "columns-1 sm:columns-2 gap-8 space-y-6 [column-fill:_balance]" : "space-y-6"}`,
+                style: fontSize ? { fontSize: `${fontSize}px` } : void 0,
+                children: parsedSong.sections.map((section, secIdx) => {
+                  const isChorus = section.type === "chorus";
+                  const isBridge = section.type === "bridge";
+                  if (section.type === "new_song") {
+                    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                      "div",
+                      {
+                        className: "w-full my-12 flex items-center justify-center select-none break-before-column",
+                        children: [
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flex-1 border-t-2 border-slate-200 dark:border-slate-800 border-dashed" }),
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Music, { className: "w-5 h-5 mx-4 text-slate-300 dark:text-slate-700" }),
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flex-1 border-t-2 border-slate-200 dark:border-slate-800 border-dashed" })
+                        ]
+                      },
+                      secIdx
+                    );
+                  }
+                  if (section.type === "grid") {
+                    const maxMeasures = Math.max(
+                      1,
+                      ...section.lines.map((l) => l.measures?.length || 1)
+                    );
+                    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                      "div",
+                      {
+                        className: `bg-slate-100/60 dark:bg-slate-900/40 p-4 rounded-xl border border-slate-200/80 dark:border-slate-800/60 my-6 ${twoColumnLayout ? "break-inside-avoid-column inline-block w-full" : ""}`,
+                        children: [
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center justify-between mb-3", children: [
+                            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-1.5 text-[11px] font-bold text-slate-500 dark:text-slate-400 uppercase tracking-wider select-none", children: [
+                              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.LayoutGrid, { className: "w-3.5 h-3.5" }),
+                              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: section.label || "Instrumental" })
+                            ] }),
+                            section.repeat && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-[10px] font-black bg-indigo-100 dark:bg-indigo-900/50 text-indigo-700 dark:text-indigo-300 px-2 py-0.5 rounded uppercase border border-indigo-200 dark:border-indigo-800/50", children: [
+                              "Repetir ",
+                              section.repeat,
+                              "x"
+                            ] })
+                          ] }),
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "space-y-1.5 font-medium", children: section.lines.map((line, lineIdx) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                            LineRenderer,
+                            {
+                              line,
+                              showChords,
+                              transpose: effectiveTranspose,
+                              onChordClick: handleChordClick,
+                              maxGridMeasures: maxMeasures
+                            },
+                            lineIdx
+                          )) })
+                        ]
+                      },
+                      secIdx
+                    );
+                  }
+                  if (isChorus || isBridge) {
+                    const borderColor = isChorus ? "border-m3-primary/30 dark:border-m3-dark-primary/30" : "border-amber-500/30 dark:border-amber-400/30";
+                    const labelColor = isChorus ? "text-m3-text dark:text-m3-dark-text" : "text-amber-700 dark:text-amber-400";
+                    const iconColor = isChorus ? "text-m3-secondary" : "text-amber-500";
+                    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                      "div",
+                      {
+                        className: `pl-4 md:pl-6 border-l-2 my-6 ${borderColor} ${twoColumnLayout ? "break-inside-avoid-column inline-block w-full" : ""}`,
+                        children: [
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                            "div",
+                            {
+                              className: `flex items-center gap-1.5 text-[11px] font-bold uppercase tracking-wider mb-3 select-none ${labelColor}`,
+                              children: [
+                                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                                  import_lucide_react.Music,
+                                  {
+                                    className: `w-3.5 h-3.5 shrink-0 ${iconColor}`
+                                  }
+                                ),
+                                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: section.label || (isChorus ? "Refr\xE3o" : "Ponte") }),
+                                section.repeat && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                                  "span",
+                                  {
+                                    className: `ml-2 px-2 py-0.5 rounded text-[10px] font-black border ${isChorus ? "bg-blue-100/50 border-blue-200 text-blue-700 dark:bg-blue-900/30 dark:border-blue-800 dark:text-blue-300" : "bg-amber-100/50 border-amber-200 text-amber-700 dark:bg-amber-900/30 dark:border-amber-800 dark:text-amber-300"}`,
+                                    children: [
+                                      section.repeat,
+                                      "x"
+                                    ]
+                                  }
+                                )
+                              ]
+                            }
+                          ),
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "space-y-4 font-medium", children: section.lines.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                            "div",
+                            {
+                              className: `text-xs italic my-1 opacity-70 ${labelColor}`,
+                              children: "(Repete o refr\xE3o)"
+                            }
+                          ) : section.lines.map((line, lineIdx) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                            LineRenderer,
+                            {
+                              line,
+                              showChords,
+                              transpose: effectiveTranspose,
+                              onChordClick: handleChordClick
+                            },
+                            lineIdx
+                          )) })
+                        ]
+                      },
+                      secIdx
+                    );
+                  }
+                  if (section.type === "tab") {
+                    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                      "div",
+                      {
+                        className: `bg-slate-900 p-4 pt-6 rounded-xl shadow-inner border border-slate-800 my-6 select-text relative group ${twoColumnLayout ? "break-inside-avoid-column inline-block w-full" : ""}`,
+                        children: [
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "absolute top-0 left-4 -translate-y-1/2 bg-slate-800 text-[10px] font-bold text-slate-300 uppercase tracking-widest px-2 py-0.5 rounded border border-slate-700 shadow-sm select-none", children: section.label || "Tablatura" }),
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "overflow-x-auto no-scrollbar", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("pre", { className: "font-mono text-[13px] md:text-sm text-slate-300 leading-relaxed whitespace-pre drop-shadow-sm", children: section.lines.map((line) => line.text || "").join("\n") }) })
+                        ]
+                      },
+                      secIdx
+                    );
+                  }
+                  if (section.type === "comment") {
+                    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                      "div",
+                      {
+                        className: `my-2 select-none pl-3 text-[11px] italic text-m3-secondary/70 dark:text-m3-dark-secondary/70 ${twoColumnLayout ? "break-inside-avoid-column inline-block w-full" : ""}`,
+                        children: section.lines.map((l) => l.text).join(", ")
+                      },
+                      secIdx
+                    );
+                  }
+                  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                    "div",
+                    {
+                      className: `relative pl-6 sm:pl-8 border-l border-m3-border/30 dark:border-m3-dark-border/30 py-1.5 my-4 ${twoColumnLayout ? "break-inside-avoid-column inline-block w-full" : ""}`,
+                      children: [
+                        section.label && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "absolute -left-0.5 top-0 bottom-0 w-0.5 bg-m3-secondary/20 dark:bg-m3-dark-secondary/20 rounded-full" }),
+                        section.label && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-1.5 text-[11px] font-bold text-m3-text/60 dark:text-m3-dark-text/60 uppercase tracking-wider mb-3 select-none", children: [
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Music, { className: "w-3.5 h-3.5 text-m3-secondary/60 shrink-0" }),
+                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: section.label }),
+                          section.repeat && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "ml-2 bg-slate-100 dark:bg-slate-800 text-slate-600 dark:text-slate-300 px-2 py-0.5 rounded text-[10px] font-black border border-slate-200 dark:border-slate-700", children: [
+                            section.repeat,
+                            "x"
+                          ] })
+                        ] }),
+                        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "space-y-4", children: section.lines.map((line, lineIdx) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                          LineRenderer,
+                          {
+                            line,
+                            showChords,
+                            transpose: effectiveTranspose,
+                            onChordClick: handleChordClick
+                          },
+                          lineIdx
+                        )) })
+                      ]
+                    },
+                    secIdx
+                  );
+                })
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "border-t border-neutral-100 dark:border-zinc-900 pt-6 mt-12 pb-12 text-center text-[10px] text-neutral-400 dark:text-neutral-500 select-none space-y-1.5", children: [
+              metadata.artist && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
+                "Artista Original: ",
+                metadata.artist
+              ] }),
+              metadata.composer && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
+                "Compositor: ",
+                metadata.composer
+              ] }),
+              metadata.lyricist && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
+                "Letra: ",
+                metadata.lyricist
+              ] }),
+              metadata.arranger && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
+                "Arranjo: ",
+                metadata.arranger
+              ] }),
+              metadata.year && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
+                "Ano: ",
+                metadata.year
+              ] }),
+              metadata.originalKey && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
+                "Tom Original: ",
+                metadata.originalKey
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "pt-2 mt-2 border-t border-neutral-50/50 dark:border-zinc-900/50 inline-block", children: [
+                metadata.copyright && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
+                  "\xA9 Copyright: ",
+                  metadata.copyright
+                ] }),
+                metadata.ccli && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
+                  "CCLI: ",
+                  metadata.ccli
+                ] })
+              ] }),
+              fileName && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { className: "mt-4 opacity-50", children: [
+                "Ficheiro base: ",
+                fileName
+              ] })
+            ] })
+          ] })
+        }
+      ),
+      metadata.youtube && showYoutubePlayer && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "hidden", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        import_react_youtube.default,
+        {
+          videoId: extractYoutubeId(metadata.youtube),
+          opts: {
+            height: "0",
+            width: "0",
+            playerVars: { autoplay: 1, controls: 0, disablekb: 1 }
+          },
+          onReady: (e) => {
+            setYtPlayerRef(e.target);
+            e.target.pauseVideo();
+            setIsPlayingYoutube(false);
+          },
+          onPlay: () => setIsPlayingYoutube(true),
+          onPause: () => setIsPlayingYoutube(false),
+          onEnd: (e) => {
+            if (isYoutubeRepeatRef.current) {
+              e.target.seekTo(0, true);
+              e.target.playVideo();
+            } else {
+              setIsPlayingYoutube(false);
+            }
+          }
+        }
+      ) }),
+      showYoutubePlayer && metadata.youtube && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "fixed bottom-0 left-0 right-0 h-16 bg-m3-card dark:bg-m3-dark-card border-t border-m3-border dark:border-m3-dark-border shadow-[0_-4px_10px_rgba(0,0,0,0.05)] z-[200] px-4 flex items-center justify-between animate-in slide-in-from-bottom-full", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-3", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "w-10 h-10 rounded overflow-hidden bg-slate-200 dark:bg-slate-800 shrink-0 border border-m3-border/50", children: metadata.youtube.match(YT_ID_REGEX) || metadata.youtube.match(/^[^&?]+$/) ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "img",
+            {
+              src: `https://img.youtube.com/vi/${extractYoutubeId(metadata.youtube)}/default.jpg`,
+              alt: "YouTube Thumbnail",
+              className: "w-full h-full object-cover scale-150"
+            }
+          ) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Disc, { className: "w-5 h-5 m-auto mt-2.5 text-m3-secondary opacity-50" }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "hidden sm:block", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "text-[10px] font-black text-m3-text dark:text-m3-dark-text truncate max-w-[120px]", children: metadata.title }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "text-[9px] text-m3-secondary font-medium", children: "\xC1udio do YouTube" })
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-4", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "button",
+            {
+              onClick: async () => {
+                if (!ytPlayerRef) return;
+                const t = await ytPlayerRef.getCurrentTime();
+                ytPlayerRef.seekTo(Math.max(0, t - 10), true);
+              },
+              className: "text-m3-secondary hover:text-m3-primary transition-colors active:scale-95",
+              title: "Retroceder 10s",
+              children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.SkipBack, { className: "w-4 h-4" })
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "button",
+            {
+              onClick: () => {
+                if (!ytPlayerRef) return;
+                if (isPlayingYoutube) ytPlayerRef.pauseVideo();
+                else ytPlayerRef.playVideo();
+              },
+              className: "w-10 h-10 rounded-full bg-m3-primary text-white flex items-center justify-center hover:opacity-95 shadow-md active:scale-95 transition-all",
+              children: isPlayingYoutube ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Pause, { className: "w-5 h-5" }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Play, { className: "w-5 h-5 ml-1" })
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "button",
+            {
+              onClick: async () => {
+                if (!ytPlayerRef) return;
+                const t = await ytPlayerRef.getCurrentTime();
+                ytPlayerRef.seekTo(t + 10, true);
+              },
+              className: "text-m3-secondary hover:text-m3-primary transition-colors active:scale-95",
+              children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.SkipForward, { className: "w-4 h-4" })
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "button",
+            {
+              onClick: () => setIsYoutubeRepeat((r) => !r),
+              className: `ml-2 transition-colors active:scale-95 ${isYoutubeRepeat ? "text-m3-primary" : "text-m3-secondary hover:text-m3-text"}`,
+              children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Repeat, { className: "w-4 h-4" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flex items-center gap-2", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "button",
+          {
+            onClick: () => {
+              ytPlayerRef?.pauseVideo();
+              setIsPlayingYoutube(false);
+              setShowYoutubePlayer(false);
+            },
+            className: "p-2 text-m3-secondary hover:text-red-500 transition-colors",
+            children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.X, { className: "w-4 h-4" })
+          }
+        ) })
+      ] }),
+      selectedChord && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "fixed inset-0 bg-black/60 z-50 flex items-center justify-center p-4 select-none animate-in fade-in duration-200", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "bg-m3-card dark:bg-m3-dark-card border border-m3-border dark:border-m3-dark-border rounded-3xl w-full max-w-sm overflow-hidden shadow-2xl flex flex-col p-6 space-y-4 animate-in zoom-in-95 duration-200", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.BookOpen, { className: "w-5 h-5 text-m3-primary dark:text-m3-dark-primary" }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("h3", { className: "text-sm font-black text-m3-text dark:text-m3-dark-text uppercase tracking-wider", children: [
+              "Dicion\xE1rio: ",
+              selectedChord
+            ] })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "button",
+            {
+              onClick: () => setSelectedChord(null),
+              className: "p-1 rounded-full hover:bg-m3-hover dark:hover:bg-m3-dark-hover text-m3-secondary dark:text-m3-dark-secondary",
+              children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.X, { className: "w-5 h-5" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex bg-m3-sidebar dark:bg-m3-dark-sidebar p-1 rounded-2xl border border-m3-border dark:border-m3-dark-border", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "button",
+            {
+              onClick: () => setModalInstrument("guitar"),
+              className: `flex-1 py-2 text-xs font-bold rounded-xl transition-all ${modalInstrument === "guitar" ? "bg-m3-primary text-white shadow-sm" : "text-m3-secondary dark:text-m3-dark-secondary hover:text-m3-text"}`,
+              children: "Diagrama de Guitarra"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "button",
+            {
+              onClick: () => setModalInstrument("piano"),
+              className: `flex-1 py-2 text-xs font-bold rounded-xl transition-all ${modalInstrument === "piano" ? "bg-m3-primary text-white shadow-sm" : "text-m3-secondary dark:text-m3-dark-secondary hover:text-m3-text"}`,
+              children: "Teclado de Piano"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "py-4 flex flex-col items-center justify-center min-h-[140px] border border-m3-border/30 dark:border-m3-dark-border/30 rounded-2xl bg-m3-sidebar/30 dark:bg-m3-dark-sidebar/10", children: chordFingering ? modalInstrument === "guitar" && chordFingering.guitar ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          GuitarDiagram,
+          {
+            frets: chordFingering.guitar.frets,
+            fingers: chordFingering.guitar.fingers,
+            barre: chordFingering.guitar.barre
+          }
+        ) : modalInstrument === "piano" && chordFingering.piano ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          PianoDiagram,
+          {
+            highlightKeys: chordFingering.piano.highlightKeys
+          }
+        ) : /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "text-center p-4", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.HelpCircle, { className: "w-8 h-8 mx-auto text-amber-500 opacity-80 mb-2" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { className: "text-xs text-m3-secondary dark:text-m3-dark-secondary font-medium", children: [
+            "O diagrama para",
+            " ",
+            modalInstrument === "guitar" ? "Guitarra" : "Piano",
+            " ",
+            "n\xE3o p\xF4de ser calculado."
+          ] })
+        ] }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "text-center p-6 space-y-2", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.HelpCircle, { className: "w-8 h-8 mx-auto text-amber-500 opacity-80" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { className: "text-xs text-m3-text dark:text-m3-dark-text font-bold", children: [
+            'Acorde "',
+            selectedChord,
+            '" n\xE3o registado'
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "text-[10px] text-m3-secondary dark:text-m3-dark-secondary max-w-[200px] leading-normal", children: "Este acorde n\xE3o se encontra no nosso dicion\xE1rio estrito, mas pode toc\xE1-lo com as notas de acompanhamento habituais." })
+        ] }) }),
+        chordFingering?.piano && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "text-center font-mono text-xs text-m3-secondary dark:text-m3-dark-secondary bg-m3-sidebar dark:bg-m3-dark-sidebar py-2 rounded-xl", children: [
+          "Notas do Acorde:",
+          " ",
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "font-bold text-m3-primary dark:text-m3-dark-primary", children: chordFingering.piano.notes.join(" - ") })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "button",
+          {
+            onClick: () => setSelectedChord(null),
+            className: "w-full bg-m3-sidebar dark:bg-m3-dark-sidebar hover:bg-m3-hover dark:hover:bg-m3-dark-hover text-m3-text dark:text-m3-dark-text text-xs py-3 rounded-2xl border border-m3-border dark:border-m3-dark-border font-bold active:scale-95 transition-all",
+            children: "Voltar ao C\xE2ntico"
+          }
+        )
+      ] }) })
+    ] });
+  }
+);
+var LineRenderer = import_react2.default.memo(
+  ({
+    line,
+    showChords,
+    transpose = 0,
+    onChordClick,
+    maxGridMeasures
+  }) => {
+    if (line.type === "empty") return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "h-2" });
+    if (line.type === "comment") return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(CommentRenderer, { line });
+    if (line.type === "comment_box") return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(CommentBoxRenderer, { line });
+    if (line.type === "chord-section")
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        ChordSectionRenderer,
+        {
+          line,
+          showChords,
+          transpose,
+          onChordClick,
+          maxMeasures: maxGridMeasures
+        }
+      );
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      LyricsRenderer,
+      {
+        line,
+        showChords,
+        transpose,
+        onChordClick
+      }
+    );
+  }
+);
+var CommentRenderer = import_react2.default.memo(({ line }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "text-xs text-slate-400 dark:text-slate-500 italic my-1", children: line.text }));
+var CommentBoxRenderer = import_react2.default.memo(({ line }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "bg-amber-100 dark:bg-amber-900/30 border-l-4 border-amber-500 text-amber-900 dark:text-amber-200 p-2.5 my-2.5 rounded-r-md text-xs font-bold tracking-wide flex items-center gap-2 shadow-sm max-w-fit", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Info, { className: "w-4 h-4 shrink-0 text-amber-600 dark:text-amber-500" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: line.text })
+] }));
+var LyricsRenderer = import_react2.default.memo(
+  ({
+    line,
+    showChords,
+    transpose = 0,
+    onChordClick
+  }) => {
+    const segments = line.segments || [];
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flex flex-wrap items-end leading-relaxed", children: segments.map((seg, segIdx) => {
+      const hasChord = !!seg.chord;
+      const transposed = hasChord ? transposeChord(seg.chord, transpose) : "";
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+        "div",
+        {
+          className: "flex flex-col justify-end relative select-text",
+          style: {
+            minWidth: hasChord && showChords ? `${Math.max(1.1, transposed.length * 0.65)}em` : void 0
+          },
+          children: [
+            showChords && hasChord && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              "span",
+              {
+                className: "font-black text-[#0284c7] font-mono select-none pr-1 inline-block pb-0.5 transition-all cursor-pointer hover:opacity-80",
+                style: { fontSize: "0.85em", lineHeight: "1" },
+                onClick: () => onChordClick?.(transposed),
+                children: transposed
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "text-slate-800 dark:text-slate-200 whitespace-pre", children: seg.text || "\xA0" })
+          ]
+        },
+        segIdx
+      );
+    }) });
+  }
+);
+var ChordSectionRenderer = import_react2.default.memo(
+  ({
+    line,
+    showChords,
+    transpose = 0,
+    onChordClick,
+    maxMeasures
+  }) => {
+    if (!showChords) return null;
+    const measures = line.measures || [];
+    const hasTiming = measures.some(
+      (m) => m.chords.some((c) => c.timing !== void 0 && c.timing !== 1)
+    );
+    const isGridAligned = maxMeasures !== void 0 && maxMeasures > 0;
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "my-1.5 p-1 w-full flex items-stretch bg-slate-50/80 dark:bg-slate-900/40 rounded-lg border border-slate-200/50 dark:border-slate-800/50 shadow-sm", children: [
+      line.startBarline && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flex items-center justify-center shrink-0 w-6", children: renderBarline(line.startBarline) }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+        "div",
+        {
+          className: isGridAligned ? "grid gap-1 flex-1" : "flex flex-wrap flex-1",
+          style: isGridAligned ? {
+            gridTemplateColumns: `repeat(${maxMeasures}, minmax(0, 1fr))`
+          } : void 0,
+          children: [
+            measures.map((measure, mIdx) => {
+              return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                "div",
+                {
+                  className: `flex items-stretch border-r border-slate-200/60 dark:border-slate-700/50 last:border-none ${isGridAligned ? "" : "flex-1 min-w-[120px]"}`,
+                  children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flex-1 flex items-center justify-evenly gap-1 px-1 py-1", children: measure.chords.map((chordSeg, cIdx) => {
+                      const transposed = transposeChord(
+                        chordSeg.chord,
+                        transpose
+                      );
+                      const timing = chordSeg.timing ?? 1;
+                      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                        "span",
+                        {
+                          className: "flex-1 flex items-center justify-center cursor-pointer rounded transition-colors hover:bg-white dark:hover:bg-slate-800 py-1.5 px-1 min-w-max shadow-sm border border-transparent hover:border-slate-200 dark:hover:border-slate-700",
+                          style: { flexGrow: timing },
+                          onClick: () => onChordClick?.(transposed),
+                          title: timing !== 1 ? `Dura\xE7\xE3o: ${timing}x` : void 0,
+                          children: [
+                            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "font-bold text-[#0284c7] dark:text-sky-400 font-mono select-none text-[15px] tracking-wide", children: transposed }),
+                            hasTiming && timing !== 1 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "ml-0.5 mt-0.5 text-[10px] font-semibold text-indigo-400 dark:text-indigo-500 opacity-80", children: [
+                              timing,
+                              "\xD7"
+                            ] })
+                          ]
+                        },
+                        cIdx
+                      );
+                    }) }),
+                    measure.endBarline && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flex items-center justify-center shrink-0 px-1 w-6 bg-slate-100/50 dark:bg-slate-800/50 rounded-r", children: renderBarline(measure.endBarline) })
+                  ]
+                },
+                mIdx
+              );
+            }),
+            isGridAligned && Array.from({
+              length: Math.max(0, maxMeasures - measures.length)
+            }).map((_, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              "div",
+              {
+                className: "border-r border-slate-200/60 dark:border-slate-700/50 last:border-none bg-slate-50/30 dark:bg-slate-800/10 rounded-sm"
+              },
+              `empty-${i}`
+            ))
+          ]
+        }
+      )
+    ] });
+  }
+);
+function renderBarline(barline) {
+  const wrapperStyle = "flex items-center justify-center flex-shrink-0 select-none";
+  const repeatStyle = "text-indigo-400 dark:text-indigo-500 text-[18px] leading-none";
+  const normalStyle = "text-slate-300 dark:text-slate-600 font-black text-[16px] leading-none";
+  switch (barline) {
+    case "|:":
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: wrapperStyle, title: "Start repeat", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: repeatStyle, children: "\u{1D106}" }) });
+    case ":|":
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: wrapperStyle, title: "End repeat", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: repeatStyle, children: "\u{1D107}" }) });
+    case "||":
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: wrapperStyle, title: "Double barline", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: normalStyle, children: "\u2016" }) });
+    case "|]":
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: wrapperStyle, title: "End of piece", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: normalStyle, children: "\u{1D102}" }) });
+    case "|":
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: wrapperStyle, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: normalStyle, children: "|" }) });
+    default:
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        "span",
+        {
+          className: `${wrapperStyle} text-slate-400 dark:text-slate-500 text-xs font-bold tracking-widest`,
+          children: barline
+        }
+      );
+  }
+}
+
+// src/editor/Editor.tsx
+var import_react3 = __toESM(require("react"));
+
+// src/editor/ChordFinder.ts
+var ChordFinder = class {
+  static {
+    this.CHORD_REGEX = /\[(.*?)\]/gi;
+  }
+  /**
+   * Extracts chords from text and returns them formatted for Ace Autocomplete
+   */
+  static getChords(text) {
+    const matches = String(text).match(this.CHORD_REGEX);
+    if (!matches || matches.length === 0) {
+      return [];
+    }
+    const chordCounts = matches.reduce(
+      (acc, chord) => {
+        acc[chord] = (acc[chord] || 0) + 1;
+        return acc;
+      },
+      {}
+    );
+    return Object.entries(chordCounts).map(([chord, count]) => ({
+      value: chord,
+      meta: `${count} occurrence${count > 1 ? "s" : ""}`,
+      score: count
+      // Ace uses score to rank autocomplete suggestions
+    })).sort((a, b) => b.score - a.score);
+  }
+};
+
+// src/editor/mode-chordpro.ts
+async function registerChordproMode(aceInstance) {
+  let ace = aceInstance;
+  if (!ace) {
+    try {
+      const mod = await import("ace-builds");
+      ace = mod.default || mod;
+    } catch {
+      return;
+    }
+  }
+  if (!ace || typeof ace.define !== "function" || ace._chordproModeRegistered) {
+    return;
+  }
+  ace.define(
+    "ace/mode/chordpro_highlight_rules",
+    [
+      "require",
+      "exports",
+      "module",
+      "ace/lib/oop",
+      "ace/mode/text_highlight_rules"
+    ],
+    (require2, exports2) => {
+      const oop = require2("ace/lib/oop");
+      const TextHighlightRules = require2("ace/mode/text_highlight_rules").TextHighlightRules;
+      const ChordproHighlightRules = function() {
+        const rStart = "(\\{\\s*)";
+        const rEnd = "(\\s*\\})";
+        const rSep = "(\\s*:\\s*)";
+        this.$rules = {
+          start: [
+            // Comments
+            { token: "comment.line.number-sign", regex: "^#.*$" },
+            // Tab Block Start -> moves to tabBlock state
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(start_of_tab|sot)" + rEnd,
+              caseInsensitive: true,
+              next: "tabBlock"
+            },
+            // Grid Block Start -> moves to gridBlock state
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(start_of_grid|sog)" + rEnd,
+              caseInsensitive: true,
+              next: "gridBlock"
+            },
+            // Generic Block Starts (Chorus, Verse, Bridge, Custom) with optional labels
+            {
+              token: [
+                "punctuation.tag",
+                "markup.bold",
+                "punctuation.separator",
+                "string",
+                "punctuation.tag"
+              ],
+              regex: rStart + "(start_of_[a-z_]+|so[a-z])" + rSep + "(.*?)" + rEnd,
+              caseInsensitive: true
+            },
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(start_of_[a-z_]+|so[a-z])" + rEnd,
+              caseInsensitive: true
+            },
+            // Generic Block Ends
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(end_of_[a-z_]+|eo[a-z])" + rEnd,
+              caseInsensitive: true
+            },
+            // Formatting & Styling Directives (e.g. textfont, chordsize)
+            {
+              token: [
+                "punctuation.tag",
+                "support.type",
+                "punctuation.separator",
+                "constant.numeric",
+                "punctuation.tag"
+              ],
+              regex: rStart + "(textfont|textsize|chordfont|chordsize|tabfont|tabsize|gridfont|gridsize)" + rSep + "(.*?)" + rEnd,
+              caseInsensitive: true
+            },
+            // Meta Directives (e.g. title, key, tempo)
+            {
+              token: [
+                "punctuation.tag",
+                "keyword.control",
+                "punctuation.separator",
+                "string",
+                "punctuation.tag"
+              ],
+              regex: rStart + "(title|t|subtitle|st|artist|a|composer|lyricist|ccli|translator|youtube|chorus|copyright|album|year|key|k|time|tempo|duration|capo|meta|c|comment|chord|define|song_number|x_[a-zA-Z0-9_]+)" + rSep + "(.*?)" + rEnd,
+              caseInsensitive: true
+            },
+            // Standalone Directives (e.g. column_break, new_page)
+            {
+              token: ["punctuation.tag", "keyword.operator", "punctuation.tag"],
+              regex: rStart + "(column_break|cb|new_page|np|new_song|ns|chorus)" + rEnd,
+              caseInsensitive: true
+            },
+            // Chord Section barlines (||, |:, :|, |)
+            {
+              token: "constant.character.barline",
+              regex: "\\|\\||:\\||\\|:|\\|"
+            },
+            // Inline Annotations e.g. [* Bass fill]
+            {
+              token: ["punctuation.tag", "comment.line", "punctuation.tag"],
+              regex: "(\\[\\s*\\*)(.*?)(\\])"
+            },
+            // Chord with timing annotation e.g. [Em@2x] or [C@0.5x]
+            {
+              token: [
+                "punctuation.tag",
+                "constant.language.bold",
+                "keyword.operator.timing",
+                "punctuation.tag"
+              ],
+              regex: "(\\[)([^\\]@]+)(@[0-9]*\\.?[0-9]+x)(\\])"
+            },
+            // Chords e.g. [C#maj7/F]
+            {
+              token: [
+                "punctuation.tag",
+                "constant.language.bold",
+                "punctuation.tag"
+              ],
+              regex: "(\\[)([^\\]]+)(\\])"
+            },
+            // Invalid/Unknown braces catch-all
+            {
+              token: ["punctuation.tag", "invalid", "punctuation.tag"],
+              regex: rStart + "(.+?)" + rEnd
+            }
+          ],
+          // Advanced State for Tablature blocks
+          tabBlock: [
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(end_of_tab|eot)" + rEnd,
+              caseInsensitive: true,
+              next: "start"
+            },
+            { token: "comment.line", regex: "-+" },
+            // Tab lines
+            { token: "constant.character", regex: "\\|+" },
+            // Measure bars
+            { token: "string.regexp", regex: "^[a-gA-G][b#]?\\s*\\|" },
+            // Tuning strings at start of line
+            { token: "constant.numeric", regex: "\\b[0-9]+\\b" },
+            // Fret numbers
+            { token: "support.function", regex: "[hpsbrv~t]" },
+            // Articulations (hammer-on, pull-off, bend)
+            { defaultToken: "comment" }
+            // Fallback to comment color for tab lines
+          ],
+          // Advanced State for Grid blocks (Jazz grids / Chord progression boxes)
+          gridBlock: [
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(end_of_grid|eog)" + rEnd,
+              caseInsensitive: true,
+              next: "start"
+            },
+            { token: "constant.character", regex: "\\|\\||\\|\\.|\\.\\||\\|" },
+            // Grid barlines
+            { token: "keyword.operator", regex: "%" },
+            // Grid repeat markers
+            {
+              token: "constant.language.bold",
+              regex: "[A-G][b#]?(?:m|maj|dim|aug|sus|[0-9])*(?:\\/[A-G][b#]?)?"
+            },
+            // Grid Chords (raw text)
+            { defaultToken: "text" }
+          ]
+        };
+      };
+      oop.inherits(ChordproHighlightRules, TextHighlightRules);
+      exports2.ChordproHighlightRules = ChordproHighlightRules;
+    }
+  );
+  ace.define(
+    "ace/mode/folding/chordpro",
+    [
+      "require",
+      "exports",
+      "module",
+      "ace/lib/oop",
+      "ace/range",
+      "ace/mode/folding/fold_mode"
+    ],
+    (require2, exports2) => {
+      const oop = require2("ace/lib/oop");
+      const Range = require2("ace/range").Range;
+      const BaseFoldMode = require2("ace/mode/folding/fold_mode").FoldMode;
+      const FoldMode = exports2.FoldMode = function() {
+      };
+      oop.inherits(FoldMode, BaseFoldMode);
+      (function() {
+        this.foldingStartMarker = /\{\s*(so(?<short>[a-z_]+)|start_of_(?<long>[a-z_]+))(:.*?)?\s*\}/i;
+        this.foldingStopMarker = /\{\s*(eo(?<short>[a-z_]+)|end_of_(?<long>[a-z_]+))\s*\}/i;
+        const mapBlockName = (name) => {
+          const map = {
+            c: "chorus",
+            v: "verse",
+            b: "bridge",
+            t: "tab",
+            g: "grid"
+          };
+          return map[name.toLowerCase()] || name.toLowerCase();
+        };
+        this.getFoldWidgetRange = function(session, _, row) {
+          const line = session.getLine(row);
+          const match = line.match(this.foldingStartMarker);
+          if (match && match.groups) {
+            const rawName = match.groups["short"] || match.groups["long"];
+            if (!rawName) return;
+            return this.getRegionBlock(
+              session,
+              line,
+              row,
+              mapBlockName(rawName)
+            );
+          }
+        };
+        this.getRegionBlock = function(session, line, row, normalizedStartName) {
+          const startColumn = line.search(/\s*$/);
+          const maxRow = session.getLength();
+          const startRow = row;
+          let hasMatch = false;
+          while (++row < maxRow) {
+            line = session.getLine(row);
+            const m = this.foldingStopMarker.exec(line);
+            if (m && m.groups) {
+              const rawEndName = m.groups["short"] || m.groups["long"];
+              if (rawEndName && mapBlockName(rawEndName) === normalizedStartName) {
+                hasMatch = true;
+                break;
+              }
+            }
+          }
+          if (hasMatch)
+            return new Range(startRow, startColumn, row, line.length);
+        };
+      }).call(FoldMode.prototype);
+    }
+  );
+  ace.define(
+    "ace/mode/chordpro",
+    [
+      "require",
+      "exports",
+      "module",
+      "ace/lib/oop",
+      "ace/mode/text",
+      "ace/mode/chordpro_highlight_rules",
+      "ace/mode/folding/chordpro"
+    ],
+    (require2, exports2) => {
+      const oop = require2("ace/lib/oop");
+      const TextMode = require2("ace/mode/text").Mode;
+      const ChordproHighlightRules = require2("ace/mode/chordpro_highlight_rules").ChordproHighlightRules;
+      const FoldMode = require2("ace/mode/folding/chordpro").FoldMode;
+      const Mode = function() {
+        this.HighlightRules = ChordproHighlightRules;
+        this.foldingRules = new FoldMode();
+      };
+      oop.inherits(Mode, TextMode);
+      (function() {
+        this.$id = "ace/mode/chordpro";
+        this.snippetFileId = "ace/snippets/chordpro";
+      }).call(Mode.prototype);
+      exports2.Mode = Mode;
+    }
+  );
+  ace._chordproModeRegistered = true;
+}
+
+// src/editor/snippets-chordpro.ts
+async function registerChordproSnippets(aceInstance) {
+  let ace = aceInstance;
+  if (!ace) {
+    try {
+      const mod = await import("ace-builds");
+      ace = mod.default || mod;
+    } catch {
+      return;
+    }
+  }
+  if (!ace || typeof ace.define !== "function" || ace._chordproSnippetsRegistered) {
+    return;
+  }
+  ace.define(
+    "ace/snippets/chordpro",
+    ["require", "exports", "module"],
+    (_, exports2) => {
+      exports2.snippetText = [
+        // album tag
+        "snippet album",
+        "	{album: ${1:value}}",
+        "snippet youtube",
+        "	{youtube: ${1:url}}",
+        "snippet number",
+        "	{song_number: ${1:number}}",
+        "snippet cc",
+        "	{chorus}",
+        // arranger tag
+        "snippet arranger",
+        "	{arranger: ${1:value}}",
+        // artist tag
+        "snippet a",
+        "	{artist: ${1:value}}",
+        "snippet artist",
+        "	{artist: ${1:value}}",
+        // capo tag
+        "snippet capo",
+        "	{capo: ${1:5}}",
+        // composer tag
+        "snippet composer",
+        "	{composer: ${1:value}}",
+        // copyright tag
+        "snippet copyright",
+        "	{copyright: ${1:value}}",
+        // duration tag
+        "snippet duration",
+        "	{duration: ${1:4}:${2:00}}",
+        // key tag
+        "snippet k",
+        "	{key: ${1:Am}}",
+        "snippet key",
+        "	{key: ${1:Am}}",
+        // lyricist tag
+        "snippet lyricist",
+        "	{lyricist: ${1:value}}",
+        // tempo tag
+        "snippet tempo",
+        "	{tempo: ${1:120}}",
+        // time tag
+        "snippet time",
+        "	{time: ${1:4}/${2:4}}",
+        // title tag
+        "snippet t",
+        "	{title: ${1:value}}",
+        "snippet title",
+        "	{title: ${1:value}}",
+        // subtitle tag
+        "snippet st",
+        "	{subtitle: ${1:value}}",
+        "snippet subtitle",
+        "	{subtitle: ${1:value}}",
+        // year tag
+        "snippet year",
+        "	{year: ${1:2020}}",
+        // meta tag
+        "snippet meta",
+        "	{meta: ${1:label} ${2:value}}",
+        // comment tag
+        "snippet c",
+        "	{comment: ${1:value}}",
+        "snippet comment",
+        "	{comment: ${1:value}}",
+        // chorus block
+        "snippet soc",
+        "	{start_of_chorus}",
+        "snippet eoc",
+        "	{end_of_chorus}",
+        "snippet chorus",
+        "	{start_of_chorus: ${1:Refr\xE3o}}",
+        "	${2:lyrics}",
+        "	{end_of_chorus}",
+        // verse block
+        "snippet sov",
+        "	{start_of_verse}",
+        "snippet eov",
+        "	{end_of_verse}",
+        "snippet verse",
+        "	{start_of_verse: ${1:Verso} ${2:1}}",
+        "	${3:lyrics}",
+        "	{end_of_verse}",
+        // bridge block
+        "snippet sob",
+        "	{start_of_bridge}",
+        "snippet eob",
+        "	{end_of_bridge}",
+        "snippet bridge",
+        "	{start_of_bridge: ${1:Ponte}}",
+        "	${2:lyrics}",
+        "	{end_of_bridge}",
+        // tabs block
+        "snippet sot",
+        "	{start_of_tab}",
+        "snippet eot",
+        "	{end_of_tab}",
+        "snippet tab",
+        "	{start_of_tab}",
+        "	e|-${1:-}--------------------------------|",
+        "	B|----------------------------------|",
+        "	G|----------------------------------|",
+        "	D|----------------------------------|",
+        "	A|----------------------------------|",
+        "	E|----------------------------------|",
+        "	{end_of_tab}",
+        // define tag
+        "snippet d",
+        "	{define: ${1:Am} base-fret ${2:1} frets ${3:0 0 0 0 0 0} fingers ${4:0 0 0 0 0 0}}",
+        "snippet define",
+        "	{define: ${1:Am} base-fret ${2:1} frets ${3:0 0 0 0 0 0} fingers ${4:0 0 0 0 0 0}}",
+        // single-liners
+        "snippet cb",
+        "	{column_break}",
+        "snippet column",
+        "	{column_break}",
+        // that's all folks!
+        // chord usage
+        "snippet [",
+        "	[${1:Am}]",
+        // chord section / grid notation
+        "snippet ||",
+        "	||[${1:Am}]|[${2:C}]|[${3:G}]|[${4:F}]||",
+        "snippet grid",
+        "	{start_of_grid}",
+        "	||[${1:Em}]|[${2:C}]|[${3:D}]||",
+        "	{end_of_grid}",
+        "snippet !",
+        "	{title: ${1:value}}",
+        "	{artist: ${2:value}}",
+        "	{duration: ${3:4:00}}",
+        "	{key: ${4:C}}",
+        "	",
+        "	${5:lyrics}",
+        "	{start_of_chorus}",
+        "	${6:lyrics}",
+        "	{end_of_chorus}"
+      ].join("\n");
+      exports2.scope = "chordpro";
+    }
+  );
+  ace._chordproSnippetsRegistered = true;
+}
+
+// src/editor/Editor.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var aceLoaderPromise = null;
+function preloadEditor() {
+  if (!aceLoaderPromise) {
+    aceLoaderPromise = (async () => {
+      try {
+        const aceModule = await import("ace-builds");
+        const ace = aceModule?.default || aceModule;
+        if (typeof window !== "undefined" && ace) {
+          window.ace = ace;
+        }
+        const [reactAceModule] = await Promise.all([
+          import("react-ace"),
+          import("ace-builds/src-noconflict/ext-language_tools"),
+          import("ace-builds/src-noconflict/theme-dracula"),
+          import("ace-builds/src-noconflict/theme-github"),
+          import("ace-builds/src-noconflict/theme-monokai"),
+          import("ace-builds/src-noconflict/theme-solarized_dark"),
+          import("ace-builds/src-noconflict/theme-solarized_light"),
+          import("ace-builds/src-noconflict/theme-textmate"),
+          import("ace-builds/src-noconflict/theme-tomorrow"),
+          import("ace-builds/src-noconflict/theme-tomorrow_night")
+        ]);
+        const AceEditor = reactAceModule?.default || reactAceModule;
+        if (ace) {
+          await registerChordproMode(ace);
+          await registerChordproSnippets(ace);
+          if (typeof ace.require === "function") {
+            try {
+              const langTools = ace.require("ace/ext/language_tools");
+              if (langTools && typeof langTools.addCompleter === "function" && typeof window !== "undefined" && !window._chordproCompleterRegistered) {
+                const chordCompleter = {
+                  getCompletions: (editor, _session, _pos, _prefix, callback) => {
+                    if (!editor || typeof editor.getValue !== "function") {
+                      callback(null, []);
+                      return;
+                    }
+                    const text = editor.getValue();
+                    const chords = ChordFinder.getChords(text);
+                    callback(null, chords);
+                  }
+                };
+                langTools.addCompleter(chordCompleter);
+                window._chordproCompleterRegistered = true;
+              }
+            } catch {
+            }
+          }
+        }
+        if (!AceEditor) {
+          throw new Error("Failed to resolve AceEditor component");
+        }
+        return AceEditor;
+      } catch (error) {
+        console.error("Failed to load Ace editor:", error);
+        aceLoaderPromise = null;
+        const ErrorFallback = () => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "w-full h-full flex items-center justify-center p-4 text-center text-sm text-red-500 bg-red-50/50 dark:bg-red-950/20 rounded-lg border border-red-200 dark:border-red-900/30", children: "Failed to load code editor. Please ensure 'ace-builds' and 'react-ace' are installed." });
+        return ErrorFallback;
+      }
+    })();
+  }
+  return aceLoaderPromise;
+}
+var LazyAce = import_react3.default.lazy(async () => {
+  const Component = await preloadEditor();
+  return { default: Component };
+});
+var SECTION_LABELS = {
+  verse: {
+    start: "start_of_verse",
+    end: "end_of_verse",
+    defaultLabel: "Verso"
+  },
+  chorus: {
+    start: "start_of_chorus",
+    end: "end_of_chorus",
+    defaultLabel: "Refr\xE3o"
+  },
+  bridge: {
+    start: "start_of_bridge",
+    end: "end_of_bridge",
+    defaultLabel: "Ponte"
+  }
+};
+function wrapSelectionInSection(editor, sectionType) {
+  if (!editor || !editor.getSelection || !editor.session) return;
+  if (typeof editor.session.getTextRange !== "function" || typeof editor.session.replace !== "function") {
+    return;
+  }
+  const selection = editor.getSelection();
+  if (!selection || typeof selection.getRange !== "function") return;
+  const range = selection.getRange();
+  if (!range) return;
+  const selectedText = editor.session.getTextRange(range);
+  if (!selectedText || !selectedText.trim()) return;
+  const info = SECTION_LABELS[sectionType];
+  const wrapped = `{${info.start}: ${info.defaultLabel}}
+${selectedText}
+{${info.end}}`;
+  editor.session.replace(range, wrapped);
+}
+var MENU_ITEMS = [
+  { type: "verse", label: "Envolver em Verso", shortcut: "Alt+V" },
+  { type: "chorus", label: "Envolver em Refr\xE3o", shortcut: "Alt+R" },
+  { type: "bridge", label: "Envolver em Ponte", shortcut: "Alt+B" }
+];
+function EditorContextMenu({
+  state,
+  onAction,
+  onClose
+}) {
+  const menuRef = (0, import_react3.useRef)(null);
+  (0, import_react3.useEffect)(() => {
+    const handleClickOutside = (e) => {
+      if (menuRef.current && !menuRef.current.contains(e.target)) {
+        onClose();
+      }
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") onClose();
+    };
+    if (state.visible) {
+      document.addEventListener("mousedown", handleClickOutside);
+      document.addEventListener("keydown", handleEscape);
+    }
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [state.visible, onClose]);
+  if (!state.visible) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    "div",
+    {
+      ref: menuRef,
+      className: "fixed z-[9999] min-w-[240px] bg-white dark:bg-zinc-900 border border-zinc-200 dark:border-zinc-700 rounded-xl shadow-2xl py-1.5 animate-in fade-in zoom-in-95 duration-100",
+      style: { left: state.x, top: state.y },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "px-3 py-1.5 text-[10px] font-bold text-zinc-400 dark:text-zinc-500 uppercase tracking-wider select-none border-b border-zinc-100 dark:border-zinc-800 mb-1", children: "Envolver sele\xE7\xE3o em" }),
+        MENU_ITEMS.map((item) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+          "button",
+          {
+            className: "w-full flex items-center gap-2.5 px-3 py-2 text-left text-sm text-zinc-700 dark:text-zinc-200 hover:bg-indigo-50 dark:hover:bg-indigo-950/40 hover:text-indigo-700 dark:hover:text-indigo-300 transition-colors",
+            onClick: () => {
+              onAction(item.type);
+              onClose();
+            },
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "flex-1 font-medium", children: item.label }),
+              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "text-[10px] font-mono text-zinc-400 dark:text-zinc-500 bg-zinc-100 dark:bg-zinc-800 px-1.5 py-0.5 rounded", children: item.shortcut })
+            ]
+          },
+          item.type
+        ))
+      ]
+    }
+  );
+}
+var DEFAULT_EDITOR_SETTINGS = {
+  theme: "textmate",
+  fontSize: 14,
+  wordWrap: true,
+  showLineNumbers: true
+};
+function Editor({
+  value,
+  onChange,
+  onSave,
+  settings,
+  mode = "chordpro",
+  readOnly = false,
+  fallback = null
+}) {
+  const activeSettings = {
+    ...DEFAULT_EDITOR_SETTINGS,
+    ...settings
+  };
+  const editorRef = (0, import_react3.useRef)(null);
+  const [contextMenu, setContextMenu] = (0, import_react3.useState)({
+    x: 0,
+    y: 0,
+    visible: false
+  });
+  const handleContextMenuAction = (0, import_react3.useCallback)((type) => {
+    if (editorRef.current) {
+      wrapSelectionInSection(editorRef.current, type);
+    }
+  }, []);
+  const handleLoad = (0, import_react3.useCallback)((editor) => {
+    if (!editor) return;
+    editorRef.current = editor;
+    if (editor.commands && typeof editor.commands.addCommand === "function") {
+      editor.commands.addCommand({
+        name: "save",
+        bindKey: { win: "Ctrl-S", mac: "Cmd-S" },
+        exec: (ed) => {
+          if (ed && typeof ed.getValue === "function") {
+            onSave?.(ed.getValue());
+          }
+        }
+      });
+      editor.commands.addCommand({
+        name: "wrapInVerse",
+        bindKey: { win: "Alt-V", mac: "Alt-V" },
+        exec: (ed) => wrapSelectionInSection(ed, "verse")
+      });
+      editor.commands.addCommand({
+        name: "wrapInChorus",
+        bindKey: { win: "Alt-R", mac: "Alt-R" },
+        exec: (ed) => wrapSelectionInSection(ed, "chorus")
+      });
+      editor.commands.addCommand({
+        name: "wrapInBridge",
+        bindKey: { win: "Alt-B", mac: "Alt-B" },
+        exec: (ed) => wrapSelectionInSection(ed, "bridge")
+      });
+    }
+    if (editor.container && typeof editor.container.addEventListener === "function") {
+      const handleContextMenu = (e) => {
+        if (!editor || typeof editor.getSelectedText !== "function") return;
+        const selectedText = editor.getSelectedText();
+        if (selectedText && selectedText.trim()) {
+          e.preventDefault();
+          e.stopPropagation();
+          setContextMenu({ x: e.clientX, y: e.clientY, visible: true });
+        }
+      };
+      editor.container.addEventListener("contextmenu", handleContextMenu);
+    }
+  }, [onSave]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react3.Suspense, { fallback, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      LazyAce,
+      {
+        mode,
+        theme: activeSettings.theme,
+        width: "100%",
+        height: "100%",
+        value,
+        onChange,
+        onLoad: handleLoad,
+        readOnly,
+        fontSize: activeSettings.fontSize,
+        wrapEnabled: activeSettings.wordWrap,
+        showGutter: activeSettings.showLineNumbers,
+        setOptions: {
+          enableLiveAutocompletion: true,
+          enableBasicAutocompletion: true,
+          enableSnippets: true,
+          showLineNumbers: activeSettings.showLineNumbers,
+          tabSize: 2,
+          useWorker: false
+        }
+      }
+    ) }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      EditorContextMenu,
+      {
+        state: contextMenu,
+        onAction: handleContextMenuAction,
+        onClose: () => setContextMenu((s) => ({ ...s, visible: false }))
+      }
+    )
+  ] });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChordFinder,
+  ChordProRenderer,
+  ChordRoll,
+  DefaultChordDictionary,
+  Editor,
+  GuitarDiagram,
+  PianoDiagram,
+  buildChordProText,
+  chordDictionary,
+  convertToChordProDetailed,
+  detectSourceFormat,
+  getNoteValue,
+  getSuggestedCapo,
+  parseChordPro,
+  parseLineSegments,
+  preloadEditor,
+  registerChordproMode,
+  registerChordproSnippets,
+  slugifyTitle,
+  toChordPro,
+  transposeChord,
+  transposeNote
+});
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */