@dsebastien/music-notation 0.0.0-stage → 0.1.0

package/dist/chunks/index-b71brbpf.js

@@ -0,0 +1,1028 @@
+import {
+  chromaOf2,
+  midiOf2,
+  nameOf2,
+  splitChordSymbol,
+  isFlat2
+} from "./index-y8a78sfx.js";
+
+// src/render/dom.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var apply = (el, attrs) => {
+  for (const [name, value] of Object.entries(attrs)) {
+    if (value !== undefined)
+      el.setAttribute(name, String(value));
+  }
+};
+function svg(doc, tag, attrs = {}, children = []) {
+  const el = doc.createElementNS(SVG_NS, tag);
+  apply(el, attrs);
+  for (const child of children)
+    if (child)
+      el.appendChild(child);
+  return el;
+}
+function svgText(doc, text, attrs = {}) {
+  const el = svg(doc, "text", attrs);
+  el.textContent = text;
+  return el;
+}
+function html(doc, tag, cls, text) {
+  const el = doc.createElement(tag);
+  if (cls)
+    el.className = cls;
+  if (text !== undefined)
+    el.textContent = text;
+  return el;
+}
+function svgRoot(doc, width, height, cls, label) {
+  return svg(doc, "svg", {
+    xmlns: SVG_NS,
+    viewBox: `0 0 ${width} ${height}`,
+    width,
+    class: `mn-svg ${cls}`,
+    role: "img",
+    "aria-label": label
+  });
+}
+
+// src/chord/guitar.ts
+var STANDARD_TUNING2 = [40, 45, 50, 55, 59, 64];
+function parseFrets2(text) {
+  const trimmed = text.trim();
+  const tokens = /[\s,-]/.test(trimmed) ? trimmed.split(/[\s,-]+/) : [...trimmed];
+  const frets = tokens.filter(Boolean).map((t) => /^[xX]$/.test(t) ? null : /^\d+$/.test(t) ? Number(t) : NaN);
+  return frets.length >= 2 && frets.every((f) => f === null || Number.isInteger(f) && f <= 36) ? frets : null;
+}
+function parseFingers2(text) {
+  const trimmed = text.trim();
+  const tokens = /[\s,]/.test(trimmed) || trimmed.includes("-", 1) ? trimmed.split(/[\s,-]+/) : [...trimmed];
+  return tokens.filter(Boolean).map((t) => /^[0xX]$/.test(t) ? null : t.toUpperCase());
+}
+function baseFretOf2(frets) {
+  const fretted = frets.filter((f) => f !== null && f > 0);
+  if (!fretted.length || Math.max(...fretted) <= 4)
+    return 1;
+  return Math.min(...fretted);
+}
+function barresOf(voicing) {
+  const byKey = new Map;
+  voicing.frets.forEach((fret, string) => {
+    const finger = voicing.fingers[string];
+    if (fret === null || fret === 0 || !finger)
+      return;
+    const key = `${finger}@${fret}`;
+    byKey.set(key, [...byKey.get(key) ?? [], string]);
+  });
+  const barres = [];
+  for (const [key, strings] of byKey) {
+    if (strings.length < 2)
+      continue;
+    const [finger, fret] = key.split("@");
+    barres.push({
+      fret: Number(fret),
+      from: Math.min(...strings),
+      to: Math.max(...strings),
+      finger
+    });
+  }
+  return barres;
+}
+var SPACING = 18;
+var ROW = 20;
+var LEFT = 30;
+var TITLE = 22;
+var MARKERS = 16;
+function renderGuitarDiagram2(doc, voicing, options = {}) {
+  const strings = voicing.frets.length;
+  const base = voicing.baseFret ?? baseFretOf2(voicing.frets);
+  const fretted = voicing.frets.filter((f) => f !== null && f > 0);
+  const rows = Math.max(4, fretted.length ? Math.max(...fretted) - base + 1 : 0);
+  const top = (options.title ? TITLE : 4) + MARKERS;
+  const width = LEFT + (strings - 1) * SPACING + 14;
+  const height = top + rows * ROW + 10;
+  const x = (string) => LEFT + string * SPACING;
+  const y = (row) => top + row * ROW;
+  const label = options.title ? `${options.title} chord diagram` : "Chord diagram";
+  const root = svgRoot(doc, width, height, "mn-guitar-chord", label);
+  if (options.title) {
+    root.appendChild(svgText(doc, options.title, {
+      class: "mn-title",
+      x: width / 2,
+      y: 15,
+      "text-anchor": "middle"
+    }));
+  }
+  for (let row = 0;row <= rows; row++) {
+    root.appendChild(svg(doc, "line", {
+      class: row === 0 && base === 1 ? "mn-nut" : "mn-fret",
+      x1: x(0),
+      x2: x(strings - 1),
+      y1: y(row),
+      y2: y(row)
+    }));
+  }
+  for (let s = 0;s < strings; s++) {
+    root.appendChild(svg(doc, "line", { class: "mn-string", x1: x(s), x2: x(s), y1: y(0), y2: y(rows) }));
+  }
+  if (base > 1) {
+    root.appendChild(svgText(doc, `${base}fr`, {
+      class: "mn-base-fret",
+      x: LEFT - 10,
+      y: y(0.5) + 4,
+      "text-anchor": "end"
+    }));
+  }
+  for (const barre of barresOf(voicing)) {
+    const cy = y(barre.fret - base + 0.5);
+    root.appendChild(svg(doc, "rect", {
+      class: "mn-barre",
+      x: x(barre.from) - 7,
+      y: cy - 7,
+      width: x(barre.to) - x(barre.from) + 14,
+      height: 14,
+      rx: 7
+    }));
+  }
+  const tuning = options.tuning ?? (strings === 6 ? STANDARD_TUNING2 : undefined);
+  voicing.frets.forEach((fret, s) => {
+    const cx = x(s);
+    if (fret === null) {
+      root.appendChild(svgText(doc, "×", {
+        class: "mn-muted",
+        x: cx,
+        y: top - 4,
+        "text-anchor": "middle"
+      }));
+      return;
+    }
+    const open = tuning?.[s];
+    const isRoot = options.root !== undefined && options.root !== null && open !== undefined && (open + fret) % 12 === options.root;
+    if (fret === 0) {
+      root.appendChild(svg(doc, "circle", {
+        class: `mn-open${isRoot ? " mn-root" : ""}`,
+        cx,
+        cy: top - 8,
+        r: 4
+      }));
+      return;
+    }
+    const cy = y(fret - base + 0.5);
+    root.appendChild(svg(doc, "circle", { class: `mn-dot${isRoot ? " mn-root" : ""}`, cx, cy, r: 7 }));
+    const finger = voicing.fingers[s];
+    if (finger) {
+      root.appendChild(svgText(doc, finger, {
+        class: "mn-dot-text",
+        x: cx,
+        y: cy + 4,
+        "text-anchor": "middle"
+      }));
+    }
+  });
+  return root;
+}
+
+// src/chords/chordpro.ts
+var ALIASES = {
+  t: "title",
+  st: "subtitle",
+  c: "comment",
+  ci: "comment",
+  comment_italic: "comment",
+  cb: "comment",
+  comment_box: "comment",
+  highlight: "comment",
+  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"
+};
+var SECTION_KINDS = new Set(["verse", "chorus", "bridge", "tab", "grid"]);
+function parseLyrics2(line) {
+  const segments = [];
+  const re = /\[([^\]]*)\]/g;
+  let last = 0;
+  let chord = null;
+  let m;
+  while (m = re.exec(line)) {
+    const text = line.slice(last, m.index);
+    if (text || chord !== null)
+      segments.push({ chord, text });
+    chord = m[1].trim();
+    last = m.index + m[0].length;
+  }
+  const rest = line.slice(last);
+  if (rest || chord !== null)
+    segments.push({ chord, text: rest });
+  return segments;
+}
+function parseDirective(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
+    return null;
+  const inner = trimmed.slice(1, -1).trim();
+  const m = /^[\w-]+/.exec(inner);
+  if (!m)
+    return null;
+  const rest = inner.slice(m[0].length);
+  if (rest && !/^[\s:]/.test(rest))
+    return null;
+  return { name: m[0].toLowerCase(), value: rest.replace(/^\s*:?/, "").trim() };
+}
+function parseChordPro2(source) {
+  const song = {
+    title: null,
+    subtitle: null,
+    artist: null,
+    key: null,
+    capo: null,
+    tempo: null,
+    time: null,
+    transpose: 0,
+    sections: []
+  };
+  let section = { kind: "none", label: null, lines: [] };
+  const open = (kind, label) => {
+    if (section.lines.length || section.kind !== "none")
+      song.sections.push(section);
+    section = { kind, label, lines: [] };
+  };
+  for (const raw of source.split(/\r?\n/)) {
+    const line = raw.replace(/\s+$/, "");
+    if (/^\s*#/.test(line))
+      continue;
+    const directive = parseDirective(line);
+    if (directive) {
+      const { name, value } = directive;
+      const key = ALIASES[name] ?? name;
+      const start = /^start_of_(\w+)$/.exec(key);
+      const end = /^end_of_(\w+)$/.exec(key);
+      if (start) {
+        const kind = SECTION_KINDS.has(start[1]) ? start[1] : "verse";
+        open(kind, value.replace(/^label\s*=\s*"?|"$/g, "") || null);
+      } else if (end) {
+        open("none", null);
+      } else if (key === "comment") {
+        section.lines.push({ kind: "comment", text: value });
+      } else if (key === "title" || key === "subtitle" || key === "artist" || key === "key" || key === "tempo" || key === "time") {
+        song[key] = value || null;
+      } else if (key === "capo") {
+        const capo = Number(value);
+        song.capo = Number.isInteger(capo) && capo > 0 ? capo : null;
+      } else if (key === "transpose") {
+        const semitones = Number(value);
+        if (Number.isInteger(semitones))
+          song.transpose = semitones;
+      }
+      continue;
+    }
+    if (!line.trim())
+      section.lines.push({ kind: "empty" });
+    else if (section.kind === "tab" || section.kind === "grid")
+      section.lines.push({ kind: "text", text: line });
+    else
+      section.lines.push({ kind: "lyrics", segments: parseLyrics2(line) });
+  }
+  open("none", null);
+  for (const s of song.sections) {
+    while (s.lines[0]?.kind === "empty")
+      s.lines.shift();
+    while (s.lines[s.lines.length - 1]?.kind === "empty")
+      s.lines.pop();
+  }
+  song.sections = song.sections.filter((s) => s.lines.length || s.label);
+  return song;
+}
+
+// src/theory/transpose.ts
+var FLAT_KEYS = new Set([5, 10, 3, 8, 1]);
+var FLAT_MINOR_KEYS = new Set([2, 7, 0, 5, 10, 3]);
+function keyPrefersFlats2(key) {
+  const m = /^([A-G][#♯b♭]?)(m|min|minor)?\b/.exec(key.trim());
+  if (!m)
+    return false;
+  const chroma = chromaOf2(m[1]);
+  if (chroma === null)
+    return false;
+  if (isFlat2(m[1]))
+    return true;
+  return m[2] ? FLAT_MINOR_KEYS.has(chroma) : FLAT_KEYS.has(chroma);
+}
+var shift = (note, semitones, preferFlats) => {
+  const chroma = chromaOf2(note);
+  return chroma === null ? note : nameOf2(chroma + semitones, preferFlats);
+};
+function transposeChord2(symbol, semitones, preferFlats) {
+  const trimmed = symbol.trim();
+  const parts = splitChordSymbol(trimmed);
+  const steps = Math.round(semitones) || 0;
+  if (!parts || steps % 12 === 0)
+    return trimmed;
+  const flats = preferFlats ?? isFlat2(parts.root);
+  const bass = parts.bass ? `/${shift(parts.bass, steps, flats)}` : "";
+  return `${shift(parts.root, steps, flats)}${parts.suffix}${bass}`;
+}
+function transposeKey2(key, semitones) {
+  const m = /^([A-G][#♯b♭]?)(.*)$/.exec(key.trim());
+  const chroma = m ? chromaOf2(m[1]) : null;
+  const steps = Math.round(semitones) || 0;
+  if (!m || chroma === null || steps % 12 === 0)
+    return key.trim();
+  const target = ((chroma + steps) % 12 + 12) % 12;
+  const minor = /^\s*(m|min|minor)\b/.test(m[2]);
+  const flats = minor ? FLAT_MINOR_KEYS.has(target) : FLAT_KEYS.has(target);
+  return `${nameOf2(target, flats)}${m[2]}`;
+}
+
+// src/chords/chart.ts
+var SECTION_LABELS = {
+  chorus: "Chorus",
+  bridge: "Bridge",
+  tab: "Tab",
+  grid: "Grid"
+};
+function renderChart2(doc, song, options = {}) {
+  const extra = options.transpose ?? 0;
+  const semitones = song.transpose + (Number.isFinite(extra) ? Math.round(extra) : 0);
+  const key = song.key ? transposeKey2(song.key, semitones) : null;
+  const flats = key ? keyPrefersFlats2(key) : undefined;
+  const chord = (symbol) => transposeChord2(symbol, semitones, flats);
+  const root = html(doc, "div", "mn-chart");
+  if (song.title || song.subtitle || song.artist) {
+    const header = html(doc, "div", "mn-chart-header");
+    if (song.title)
+      header.appendChild(html(doc, "div", "mn-chart-title", song.title));
+    const by = [song.subtitle, song.artist].filter(Boolean).join(" · ");
+    if (by)
+      header.appendChild(html(doc, "div", "mn-chart-subtitle", by));
+    root.appendChild(header);
+  }
+  const meta = [
+    key ? `Key ${key}` : null,
+    song.capo ? `Capo ${song.capo}` : null,
+    song.tempo ? `${song.tempo} BPM` : null,
+    song.time ? song.time : null,
+    semitones % 12 ? `Transposed ${semitones > 0 ? "+" : ""}${semitones}` : null
+  ].filter((m) => m !== null);
+  if (meta.length)
+    root.appendChild(html(doc, "div", "mn-chart-meta", meta.join(" · ")));
+  for (const section of song.sections) {
+    const el = html(doc, "div", `mn-section mn-section-${section.kind}`);
+    const label = section.label ?? SECTION_LABELS[section.kind];
+    if (label)
+      el.appendChild(html(doc, "div", "mn-section-label", label));
+    for (const line of section.lines) {
+      if (line.kind === "empty")
+        el.appendChild(html(doc, "div", "mn-line mn-line-empty"));
+      else if (line.kind === "comment")
+        el.appendChild(html(doc, "div", "mn-line mn-comment", line.text));
+      else if (line.kind === "text")
+        el.appendChild(html(doc, "pre", "mn-line mn-pre", line.text));
+      else {
+        const row = html(doc, "div", "mn-line");
+        const chordsOnly = line.segments.every((s) => !s.text.trim());
+        if (chordsOnly)
+          row.classList.add("mn-chords-only");
+        for (const segment of line.segments) {
+          const seg = html(doc, "span", "mn-seg");
+          seg.appendChild(html(doc, "span", "mn-chord", segment.chord === null ? "" : chord(segment.chord)));
+          seg.appendChild(html(doc, "span", "mn-lyric", segment.text || (chordsOnly ? "" : " ")));
+          row.appendChild(seg);
+        }
+        el.appendChild(row);
+      }
+    }
+    root.appendChild(el);
+  }
+  return root;
+}
+
+// src/theory/note-set.ts
+import { Chord, Scale } from "tonal";
+var memberFor = (set, chroma) => set.members.find((m) => m.chroma === chroma);
+var memberOf2 = (set, midi) => set.pitches && !set.pitches.includes(midi) ? undefined : memberFor(set, (midi % 12 + 12) % 12);
+function intervalLabel2(interval) {
+  const m = /^(\d+)([PMmdA]+)$/.exec(interval);
+  if (!m)
+    return interval;
+  const [, number, quality] = m;
+  if (number === "1" && quality === "P")
+    return "R";
+  const perfect = ["1", "4", "5", "8", "11", "12"].includes(String((Number(number) - 1) % 7 + 1));
+  if (quality === "P" || quality === "M")
+    return number;
+  if (quality === "m")
+    return `b${number}`;
+  if (quality.startsWith("A"))
+    return `${"#".repeat(quality.length)}${number}`;
+  return `${"b".repeat(quality.length + (perfect ? 0 : 1))}${number}`;
+}
+function labelOf2(member, label, finger) {
+  switch (label) {
+    case "none":
+      return "";
+    case "degrees":
+      return member.degree === null ? member.name : String(member.degree);
+    case "intervals":
+      return member.interval === null ? member.name : intervalLabel2(member.interval);
+    case "fingers":
+      return finger ?? "";
+    default:
+      return member.name;
+  }
+}
+var fromNames = (title, names, intervals, chord = false) => {
+  const members = [];
+  names.forEach((name, i) => {
+    const chroma = chromaOf2(name);
+    if (chroma === null || members.some((m) => m.chroma === chroma))
+      return;
+    members.push({
+      chroma,
+      name,
+      degree: intervals ? chord ? Number(/^\d+/.exec(intervals[i] ?? "")?.[0] ?? i + 1) : i + 1 : null,
+      interval: intervals?.[i] ?? null
+    });
+  });
+  if (!members.length)
+    return null;
+  return {
+    title,
+    members,
+    root: intervals ? members[0].chroma : null,
+    pitches: null,
+    preferFlats: names.some(isFlat2)
+  };
+};
+function chordNoteSet2(symbol) {
+  const parts = splitChordSymbol(symbol);
+  if (!parts)
+    return null;
+  const chord = Chord.get(parts.root + parts.suffix);
+  if (chord.empty)
+    return null;
+  const bass = parts.bass;
+  const set = fromNames(symbol.trim(), chord.notes, chord.intervals, true);
+  const bassChroma = bass ? chromaOf2(bass) : null;
+  if (set && bass && bassChroma !== null && !memberFor(set, bassChroma)) {
+    set.members.push({ chroma: bassChroma, name: bass, degree: null, interval: null });
+  }
+  return set;
+}
+function scaleNoteSet2(name) {
+  const scale = Scale.get(name.trim());
+  if (scale.empty || !scale.tonic)
+    return null;
+  return fromNames(name.trim(), scale.notes, scale.intervals);
+}
+function listNoteSet2(text) {
+  const tokens = text.split(/[\s,]+/).filter(Boolean);
+  if (!tokens.length)
+    return null;
+  const withOctaves = tokens.every((t) => midiOf2(t) !== null);
+  const names = withOctaves ? tokens.map((t) => t.replace(/-?\d$/, "")) : tokens;
+  if (!withOctaves && names.some((n) => chromaOf2(n) === null))
+    return null;
+  const set = fromNames(tokens.join(" "), names, null);
+  if (set && withOctaves)
+    set.pitches = tokens.map((t) => midiOf2(t));
+  return set;
+}
+
+// src/fretboard/fretboard.ts
+var STRING_GAP = 20;
+var FRET_W = 44;
+var OPEN_W = 30;
+var LEFT2 = 24;
+var TITLE2 = 22;
+var BOTTOM = 22;
+var SINGLE_INLAYS = new Set([3, 5, 7, 9, 15, 17, 19, 21]);
+function renderFretboard2(doc, set, options = {}) {
+  const tuning = options.tuning ?? STANDARD_TUNING2;
+  const [from, to] = options.frets ?? [0, 12];
+  const first = Math.max(from, 1);
+  const strings = tuning.length;
+  const label = options.label ?? "notes";
+  const top = (options.title ? TITLE2 : 0) + 12;
+  const openW = from === 0 ? OPEN_W : 0;
+  const nutX = LEFT2 + openW;
+  const width = nutX + (to - first + 1) * FRET_W + 8;
+  const height = top + (strings - 1) * STRING_GAP + BOTTOM + 8;
+  const y = (row) => top + row * STRING_GAP;
+  const wireX = (fret) => nutX + (fret - first + 1) * FRET_W;
+  const centerX = (fret) => fret === 0 ? LEFT2 + OPEN_W / 2 : wireX(fret) - FRET_W / 2;
+  const root = svgRoot(doc, width, height, "mn-fretboard", options.title ?? `Fretboard: ${set.title}`);
+  if (options.title) {
+    root.appendChild(svgText(doc, options.title, {
+      class: "mn-title",
+      x: width / 2,
+      y: 15,
+      "text-anchor": "middle"
+    }));
+  }
+  const middle = y((strings - 1) / 2);
+  for (let fret = first;fret <= to; fret++) {
+    const cx = wireX(fret) - FRET_W / 2;
+    if (SINGLE_INLAYS.has(fret))
+      root.appendChild(svg(doc, "circle", { class: "mn-inlay", cx, cy: middle, r: 4 }));
+    if (fret % 12 === 0) {
+      root.appendChild(svg(doc, "circle", { class: "mn-inlay", cx, cy: y(strings > 3 ? 1.5 : 0.5), r: 4 }));
+      root.appendChild(svg(doc, "circle", {
+        class: "mn-inlay",
+        cx,
+        cy: y(strings > 3 ? strings - 2.5 : strings - 1.5),
+        r: 4
+      }));
+    }
+    root.appendChild(svgText(doc, String(fret), {
+      class: "mn-fret-number",
+      x: cx,
+      y: y(strings - 1) + BOTTOM,
+      "text-anchor": "middle"
+    }));
+  }
+  root.appendChild(svg(doc, "line", {
+    class: first === 1 ? "mn-nut" : "mn-fret",
+    x1: nutX,
+    x2: nutX,
+    y1: y(0),
+    y2: y(strings - 1)
+  }));
+  for (let fret = first;fret <= to; fret++) {
+    root.appendChild(svg(doc, "line", {
+      class: "mn-fret",
+      x1: wireX(fret),
+      x2: wireX(fret),
+      y1: y(0),
+      y2: y(strings - 1)
+    }));
+  }
+  for (let row = 0;row < strings; row++) {
+    const open = tuning[strings - 1 - row];
+    root.appendChild(svg(doc, "line", {
+      class: "mn-string",
+      x1: nutX - openW,
+      x2: wireX(to),
+      y1: y(row),
+      y2: y(row)
+    }));
+    root.appendChild(svgText(doc, nameOf2(open, set.preferFlats), {
+      class: "mn-string-name",
+      x: LEFT2 - 8,
+      y: y(row) + 4,
+      "text-anchor": "end"
+    }));
+    for (let fret = from;fret <= to; fret++) {
+      const member = memberOf2(set, open + fret);
+      if (!member)
+        continue;
+      const cx = centerX(fret);
+      const isRoot = set.root === member.chroma;
+      root.appendChild(svg(doc, "circle", {
+        class: `mn-dot${isRoot ? " mn-root" : ""}`,
+        cx,
+        cy: y(row),
+        r: 8
+      }));
+      const text = labelOf2(member, label);
+      if (text) {
+        root.appendChild(svgText(doc, text, {
+          class: "mn-dot-text",
+          x: cx,
+          y: y(row) + 4,
+          "text-anchor": "middle"
+        }));
+      }
+    }
+  }
+  return root;
+}
+
+// src/fretboard/tuning.ts
+var NAMED = new Map(Object.entries({
+  standard: "E2 A2 D3 G3 B3 E4",
+  "drop d": "D2 A2 D3 G3 B3 E4",
+  dadgad: "D2 A2 D3 G3 A3 D4",
+  "open g": "D2 G2 D3 G3 B3 D4",
+  "open d": "D2 A2 D3 F#3 A3 D4",
+  "open e": "E2 B2 E3 G#3 B3 E4",
+  "half step down": "Eb2 Ab2 Db3 Gb3 Bb3 Eb4",
+  bass: "E1 A1 D2 G2",
+  ukulele: "G4 C4 E4 A4"
+}));
+function parseTuning2(text) {
+  const trimmed = text.trim();
+  const named = NAMED.get(trimmed.toLowerCase().replace(/\s*\(.*\)$/, ""));
+  if (named)
+    return parseTuning2(named);
+  const spaced = trimmed.split(/[\s,]+/).filter(Boolean);
+  if (spaced.length > 1 && spaced.every((t) => midiOf2(t) !== null)) {
+    return spaced.map((t) => midiOf2(t));
+  }
+  const names = spaced.length > 1 ? spaced : trimmed.match(/[A-G][#♯b♭]?|[a-g][#♯♭]?/g) ?? [];
+  if (names.length < 2 || names.join("") !== spaced.join(""))
+    return null;
+  const midis = [];
+  for (const name of names) {
+    const chroma = chromaOf2(name);
+    if (chroma === null)
+      return null;
+    const previous = midis[midis.length - 1];
+    if (previous === undefined) {
+      const candidates = [28, 40, 52].map((c) => c - c % 12 + chroma);
+      midis.push(candidates.reduce((a, b) => Math.abs(b - 40) < Math.abs(a - 40) ? b : a));
+    } else {
+      let midi = previous - previous % 12 + chroma;
+      while (midi <= previous)
+        midi += 12;
+      midis.push(midi);
+    }
+  }
+  return midis;
+}
+
+// src/keyboard/keyboard.ts
+var BLACK = new Set([1, 3, 6, 8, 10]);
+var WHITE_W = 22;
+var WHITE_H = 104;
+var BLACK_W = 14;
+var BLACK_H = 64;
+var TITLE3 = 22;
+var isBlack = (midi) => BLACK.has((midi % 12 + 12) % 12);
+function parseKeyRange2(text) {
+  const parts = text.split(/\s*-\s*(?=[A-Ga-g])/);
+  if (parts.length !== 2)
+    return null;
+  const [from, to] = parts.map((n) => midiOf2(n));
+  return from !== undefined && from !== null && to !== undefined && to !== null && from < to ? [from, to] : null;
+}
+function keyRangeOf2(set) {
+  if (!set.pitches?.length)
+    return [60, 83];
+  const low = Math.min(...set.pitches);
+  const high = Math.max(...set.pitches);
+  return [low - (low % 12 + 12) % 12, high + 11 - (high % 12 + 12) % 12];
+}
+function renderKeyboard2(doc, set, options = {}) {
+  let [from, to] = options.range ?? keyRangeOf2(set);
+  if (isBlack(from))
+    from--;
+  if (isBlack(to))
+    to++;
+  const whites = [];
+  for (let midi = from;midi <= to; midi++)
+    if (!isBlack(midi))
+      whites.push(midi);
+  const top = options.title ? TITLE3 : 0;
+  const width = whites.length * WHITE_W + 2;
+  const height = top + WHITE_H + 2;
+  const label = options.label ?? "notes";
+  const root = svgRoot(doc, width, height, "mn-keyboard", options.title ?? `Keyboard: ${set.title}`);
+  if (options.title) {
+    root.appendChild(svgText(doc, options.title, {
+      class: "mn-title",
+      x: width / 2,
+      y: 15,
+      "text-anchor": "middle"
+    }));
+  }
+  const keyClass = (midi, black) => {
+    const member = memberOf2(set, midi);
+    const classes = [black ? "mn-key-black" : "mn-key-white"];
+    if (member)
+      classes.push("mn-on");
+    if (member && set.root === member.chroma)
+      classes.push("mn-root");
+    return { member, cls: classes.join(" ") };
+  };
+  const caption = (midi, x, y, black) => {
+    const member = memberOf2(set, midi);
+    if (!member)
+      return;
+    const text = labelOf2(member, label, options.fingers?.get(midi));
+    if (!text)
+      return;
+    root.appendChild(svgText(doc, text, {
+      class: black ? "mn-key-label mn-key-label-black" : "mn-key-label",
+      x,
+      y,
+      "text-anchor": "middle"
+    }));
+  };
+  whites.forEach((midi, i) => {
+    const x = 1 + i * WHITE_W;
+    const { cls } = keyClass(midi, false);
+    root.appendChild(svg(doc, "rect", { class: cls, x, y: top + 1, width: WHITE_W, height: WHITE_H, rx: 2 }));
+    caption(midi, x + WHITE_W / 2, top + WHITE_H - 8, false);
+  });
+  whites.forEach((midi, i) => {
+    const black = midi + 1;
+    if (black > to || !isBlack(black))
+      return;
+    const x = 1 + (i + 1) * WHITE_W - BLACK_W / 2;
+    const { cls } = keyClass(black, true);
+    root.appendChild(svg(doc, "rect", { class: cls, x, y: top + 1, width: BLACK_W, height: BLACK_H, rx: 2 }));
+    caption(black, x + BLACK_W / 2, top + BLACK_H - 8, true);
+  });
+  return root;
+}
+
+// src/theory/chord-symbol.ts
+var QUALITY_SUFFIXES = [
+  [/^(m7b5|m7-5|ø7?)$/, "Minor 7 flat 5"],
+  [/^(dim7|°7)$/, "Diminished 7"],
+  [/^(maj9|M9|Δ9)$/, "Major 9"],
+  [/^(maj7|M7|Δ7?)$/, "Major 7"],
+  [/^(7sus4)$/, "7sus4"],
+  [/^(m9|min9|-9)$/, "Minor 9"],
+  [/^(m7|min7|-7)$/, "Minor 7"],
+  [/^(m6|min6|-6)$/, "Minor 6"],
+  [/^(m|min|-)$/, "Minor"],
+  [/^(dim|°)$/, "Diminished"],
+  [/^(aug|\+)$/, "Augmented"],
+  [/^(sus2)$/, "Sus2"],
+  [/^(sus4|sus)$/, "Sus4"],
+  [/^(add9|add2)$/, "Add9"],
+  [/^5$/, "5 (Power)"],
+  [/^(6\/9|69)$/, "6/9"],
+  [/^(mM7|mMaj7|mmaj7|m\(maj7\)|-\(maj7\))$/, "Minor major 7"],
+  [/^(13|11|9|7|6)$/, "$1"],
+  [/^(maj|M)?$/, "Major"]
+];
+var spell = (note) => note[0] + (note[1] === "#" ? " Sharp" : note[1] === "b" ? " Flat" : "");
+var plain = (quality) => quality.replace(/\s*\([^)]*\)/g, "").trim();
+function parseChord2(symbol) {
+  const parts = splitChordSymbol(symbol);
+  if (!parts)
+    return null;
+  const trimmed = symbol.trim();
+  const { root, suffix, bass } = parts;
+  let quality = null;
+  for (const [re, label] of QUALITY_SUFFIXES) {
+    const hit = re.exec(suffix);
+    if (hit) {
+      quality = label.replace("$1", hit[1] ?? "");
+      break;
+    }
+  }
+  if (!quality)
+    return null;
+  return {
+    symbol: trimmed,
+    root,
+    quality,
+    bass,
+    name: `${spell(root)} ${plain(quality)}${bass ? ` over ${spell(bass)}` : ""}`
+  };
+}
+
+// src/blocks/block-source.ts
+var FIELD = /^([A-Za-z][\w-]*)\s*:\s*(.*)$/;
+function parseBlockSource(source) {
+  const fields = new Map;
+  let head = null;
+  source.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).forEach((line, i) => {
+    const m = FIELD.exec(line);
+    if (m)
+      fields.set(m[1].toLowerCase(), m[2].trim());
+    else if (i === 0)
+      head = line;
+    else
+      throw new Error(`Expected "key: value", got "${line}"`);
+  });
+  return { head, fields };
+}
+function parseRange(text) {
+  const m = /^(\d+)\s*(?:-\s*(\d+))?$/.exec(text.trim());
+  if (!m)
+    return null;
+  const from = Number(m[1]);
+  const to = m[2] === undefined ? from : Number(m[2]);
+  return from <= to ? [from, to] : null;
+}
+
+// src/blocks/note-set-field.ts
+var LABELS = new Set(["notes", "degrees", "intervals", "none"]);
+function noteSetOf(block) {
+  const scale = block.fields.get("scale");
+  const chord = block.fields.get("chord");
+  const notes = block.fields.get("notes");
+  if (scale !== undefined)
+    return orFail(scaleNoteSet2(scale), `Unknown scale "${scale}"`);
+  if (chord !== undefined)
+    return orFail(chordNoteSet2(chord), `Unknown chord "${chord}"`);
+  if (notes !== undefined)
+    return orFail(listNoteSet2(notes), `Invalid notes "${notes}"`);
+  if (block.head) {
+    const exact = listNoteSet2(block.head);
+    const set = scaleNoteSet2(block.head) ?? (exact?.pitches ? exact : null) ?? chordNoteSet2(block.head) ?? exact;
+    return orFail(set, `"${block.head}" is not a scale, chord or list of notes`);
+  }
+  throw new Error('Add "scale:", "chord:" or "notes:"');
+}
+function labelField(block, fallback, fingers = false) {
+  const value = block.fields.get("labels")?.toLowerCase();
+  if (value === undefined)
+    return fallback;
+  if (!LABELS.has(value) && !(fingers && value === "fingers")) {
+    const choices = fingers ? "notes, degrees, intervals, fingers or none" : "notes, degrees, intervals or none";
+    throw new Error(`Unknown labels "${value}": use ${choices}`);
+  }
+  return value;
+}
+function orFail(value, message) {
+  if (value === null)
+    throw new Error(message);
+  return value;
+}
+
+// src/blocks/renderers.ts
+var field = (block, ...names) => {
+  for (const name of names) {
+    const value = block.fields.get(name);
+    if (value !== undefined && value !== "")
+      return value;
+  }
+  return;
+};
+var rootOf = (symbol) => {
+  const parts = splitChordSymbol(symbol);
+  return parts && parseChord2(symbol) ? chromaOf2(parts.root) : null;
+};
+var positiveInt = (text, what) => {
+  const n = Number(text);
+  if (!Number.isInteger(n) || n < 1)
+    throw new Error(`${what} must be a whole number from 1, got "${text}"`);
+  return n;
+};
+function shorthand(head) {
+  const tokens = head?.split(/\s+/).filter(Boolean) ?? [];
+  const symbol = tokens[0] && !parseFrets2(tokens[0]) ? tokens.shift() : undefined;
+  return { symbol, frets: tokens[0], fingers: tokens[1] };
+}
+function pianoPitches(symbol) {
+  const set = orFail(chordNoteSet2(symbol), `Unknown chord "${symbol}"`);
+  const bassName = splitChordSymbol(symbol)?.bass;
+  const bass = bassName ? chromaOf2(bassName) : null;
+  const pitches = [];
+  let previous = 59;
+  for (const member of set.members) {
+    if (bass !== null && member.chroma === bass && member.degree === null)
+      continue;
+    let midi = 60 + member.chroma;
+    while (midi <= previous)
+      midi += 12;
+    while (midi - 12 > previous)
+      midi -= 12;
+    pitches.push(midi);
+    previous = midi;
+  }
+  if (bass !== null)
+    pitches.unshift(48 + bass);
+  return { ...set, pitches };
+}
+var renderChord = (doc, source, options) => {
+  const block = parseBlockSource(source);
+  const short = shorthand(block.head);
+  const symbol = field(block, "symbol", "chord") ?? short.symbol;
+  const title = field(block, "title", "name") ?? symbol;
+  const instrument = field(block, "instrument")?.toLowerCase();
+  const pitchesText = field(block, "pitches", "notes");
+  if (instrument === "piano" || instrument === "keyboard" || pitchesText && !instrument) {
+    let set;
+    if (pitchesText) {
+      set = orFail(listNoteSet2(pitchesText), `Invalid pitches "${pitchesText}"`);
+      if (!set.pitches) {
+        let previous = 59;
+        set.pitches = set.members.map((m) => {
+          let midi = 60 + m.chroma;
+          while (midi <= previous)
+            midi += 12;
+          previous = midi;
+          return midi;
+        });
+      }
+      const chord = symbol ? chordNoteSet2(symbol) : null;
+      if (chord)
+        set.root = chord.root;
+    } else if (symbol) {
+      set = pianoPitches(symbol);
+    } else {
+      throw new Error('Add a chord symbol or "pitches:"');
+    }
+    const fingering = field(block, "fingering", "fingers");
+    const fingers = new Map;
+    if (fingering) {
+      const sorted = [...set.pitches].sort((a, b) => a - b);
+      fingering.split(/[\s,-]+/).filter(Boolean).forEach((finger, i) => {
+        if (sorted[i] !== undefined)
+          fingers.set(sorted[i], finger);
+      });
+    }
+    const range = field(block, "range");
+    return renderKeyboard2(doc, set, {
+      title,
+      label: labelField(block, fingers.size ? "fingers" : "notes", fingers.size > 0),
+      fingers,
+      range: range ? orFail(parseKeyRange2(range), `Invalid range "${range}": use e.g. C3-B4`) : keyRangeOf2(set)
+    });
+  }
+  if (instrument && instrument !== "guitar" && !field(block, "tuning")) {
+    throw new Error(`Unknown instrument "${instrument}": use guitar or piano, or give a tuning`);
+  }
+  const fretsText = field(block, "frets") ?? short.frets;
+  let voicing;
+  if (fretsText) {
+    const frets = orFail(parseFrets2(fretsText), `Invalid frets "${fretsText}": use e.g. x02220`);
+    const fingersText = field(block, "fingers") ?? short.fingers;
+    const fingers = fingersText ? parseFingers2(fingersText) : [];
+    if (fingersText && fingers.length !== frets.length) {
+      throw new Error(`"${fingersText}" has ${fingers.length} fingers for ${frets.length} strings`);
+    }
+    voicing = { frets, fingers: frets.map((_, i) => fingers[i] ?? null) };
+  } else if (symbol && options.voicings) {
+    const n = field(block, "voicing");
+    const index = n ? positiveInt(n, "voicing") - 1 : 0;
+    voicing = orFail(options.voicings(symbol, index), `No voicing ${index + 1} found for "${symbol}": add "frets:"`);
+  } else {
+    throw new Error(symbol ? `Add "frets:" for ${symbol} (e.g. frets: x02220)` : 'Add a chord symbol and "frets:"');
+  }
+  const position = field(block, "position", "base");
+  if (position) {
+    const base = positiveInt(position, "position");
+    const fretted = voicing.frets.filter((f) => f !== null && f > 0);
+    if (fretted.length && base > Math.min(...fretted)) {
+      throw new Error(`position ${base} is above the lowest fretted note (fret ${Math.min(...fretted)})`);
+    }
+    voicing.baseFret = base;
+  } else
+    voicing.baseFret ??= baseFretOf2(voicing.frets);
+  const tuningText = field(block, "tuning");
+  const tuning = tuningText ? orFail(parseTuning2(tuningText), `Unknown tuning "${tuningText}"`) : undefined;
+  if (tuning && tuning.length !== voicing.frets.length) {
+    throw new Error(`The tuning has ${tuning.length} strings, the frets ${voicing.frets.length}`);
+  }
+  const root = symbol ? chordNoteSet2(symbol)?.root ?? rootOf(symbol) : null;
+  return renderGuitarDiagram2(doc, voicing, { title, root, tuning });
+};
+var renderKeyboardBlock = (doc, source) => {
+  const block = parseBlockSource(source);
+  const set = noteSetOf(block);
+  const range = field(block, "range");
+  return renderKeyboard2(doc, set, {
+    title: field(block, "title"),
+    label: labelField(block, "notes"),
+    range: range ? orFail(parseKeyRange2(range), `Invalid range "${range}": use e.g. C3-B4`) : undefined
+  });
+};
+var renderFretboardBlock = (doc, source) => {
+  const block = parseBlockSource(source);
+  const set = noteSetOf(block);
+  const fretsText = field(block, "frets");
+  const frets = fretsText ? orFail(parseRange(fretsText), `Invalid frets "${fretsText}": use e.g. 5-8`) : undefined;
+  if (frets && frets[1] > 36)
+    throw new Error("Frets go up to 36");
+  const tuningText = field(block, "tuning");
+  return renderFretboard2(doc, set, {
+    title: field(block, "title"),
+    label: labelField(block, "notes"),
+    frets,
+    tuning: tuningText ? orFail(parseTuning2(tuningText), `Unknown tuning "${tuningText}"`) : undefined
+  });
+};
+var renderChordsBlock = (doc, source, options) => renderChart2(doc, parseChordPro2(source), { transpose: options.transpose });
+var RENDERERS = {
+  chord: renderChord,
+  chords: renderChordsBlock,
+  keyboard: renderKeyboardBlock,
+  fretboard: renderFretboardBlock
+};
+
+// src/render/render-block.ts
+var LANGUAGES2 = Object.keys(RENDERERS);
+var isNotationLanguage2 = (language) => Object.prototype.hasOwnProperty.call(RENDERERS, language);
+function renderBlock2(language, source, host, options = {}) {
+  const doc = host.ownerDocument;
+  const el = html(doc, "div", `mn-block mn-block-${language}`);
+  let error = null;
+  try {
+    el.appendChild(RENDERERS[language](doc, source, options));
+  } catch (e) {
+    error = e instanceof Error ? e.message : String(e);
+    el.classList.add("mn-error");
+    el.appendChild(html(doc, "div", "mn-error-message", `${language}: ${error}`));
+  }
+  host.appendChild(el);
+  return { ok: error === null, el, error, destroy: () => el.remove() };
+}
+
+export { STANDARD_TUNING2, parseFrets2, parseFingers2, baseFretOf2, renderGuitarDiagram2, parseLyrics2, parseChordPro2, keyPrefersFlats2, transposeChord2, transposeKey2, renderChart2, memberOf2, intervalLabel2, labelOf2, chordNoteSet2, scaleNoteSet2, listNoteSet2, renderFretboard2, parseTuning2, parseKeyRange2, keyRangeOf2, renderKeyboard2, parseChord2, LANGUAGES2, isNotationLanguage2, renderBlock2 };
+
+//# debugId=627AFEC8F03B83D064756E2164756E21
+//# sourceMappingURL=index-b71brbpf.js.map