@libraz/libcantus 0.9.5 → 1.0.0

package/dist/chunk-7EONYVI5.js

@@ -1,1204 +0,0 @@
-import {
-  NAMED_SCALES,
-  chordPitchClasses,
-  chordToneRole,
-  createsHiddenParallelPerfect,
-  createsParallelPerfect,
-  createsVoiceOverlap,
-  makeChord,
-  namedScaleMask,
-  requireScaleMask,
-  scaleTonesInDegreeOrder
-} from "./chunk-KBTTEX7Q.js";
-import {
-  InvalidInputError,
-  NoSolutionError,
-  assertFiniteNumber,
-  assertFiniteSemitones,
-  assertGenerationBudget,
-  assertInteger,
-  assertPositiveInt,
-  diatonicLetterOf,
-  formatNote,
-  midiToNote,
-  naturalPitchClassOf,
-  noteToPitchClass,
-  parseNote,
-  pitchClassOf,
-  transposeNote
-} from "./chunk-R2VVFAIN.js";
-
-// src/theory/chordscale/index.ts
-function popcount12(mask) {
-  let count = 0;
-  for (let n = 0; n < 12; n += 1) {
-    count += mask >> n & 1;
-  }
-  return count;
-}
-function maskHasPitchClass(mask, scaleRootPc, pc) {
-  const offset = pitchClassOf(pc - scaleRootPc);
-  return (mask >> offset & 1) === 1;
-}
-function scaleMatchesChord(chordPcs, scaleMask, scaleRootPc) {
-  for (const pc of chordPcs) {
-    if (!maskHasPitchClass(scaleMask, scaleRootPc, pc)) {
-      return false;
-    }
-  }
-  return true;
-}
-var ALIASED_SCALE_NAMES = /* @__PURE__ */ new Set(["major", "naturalMinor"]);
-var HEPTATONIC_SIZE = 7;
-var SCALE_PREFERENCE = [
-  "ionian",
-  "major",
-  "mixolydian",
-  "dorian",
-  "lydian",
-  "aeolian",
-  "naturalMinor",
-  "phrygian",
-  "locrian"
-];
-var IDIOMATIC_SCALES = {
-  aug: ["wholeTone"],
-  m7b5: ["locrian"]
-};
-function conventionalRank(name) {
-  const index = SCALE_PREFERENCE.indexOf(name);
-  return index < 0 ? SCALE_PREFERENCE.length : index;
-}
-function idiomaticRank(chord, name) {
-  const choices = IDIOMATIC_SCALES[chord.quality];
-  if (choices === void 0) {
-    return 0;
-  }
-  const index = choices.indexOf(name);
-  return index < 0 ? choices.length + 1 : index;
-}
-function isAlteredDominant(chord, scaleName) {
-  return chord.quality === "dom7" && scaleName === "altered";
-}
-function chordScales(chord) {
-  const chordPcs = chordPitchClasses(chord);
-  const rootPc = pitchClassOf(chord.rootPc);
-  const ranked = [];
-  const seenMasks = /* @__PURE__ */ new Set();
-  for (const name of Object.keys(NAMED_SCALES)) {
-    if (name === "chromatic" || ALIASED_SCALE_NAMES.has(name)) {
-      continue;
-    }
-    const mask = namedScaleMask(name);
-    if (mask === void 0 || seenMasks.has(mask)) {
-      continue;
-    }
-    seenMasks.add(mask);
-    if (scaleMatchesChord(chordPcs, mask, rootPc) || isAlteredDominant(chord, name)) {
-      const size = popcount12(mask);
-      ranked.push({ name, extra: size - chordPcs.length, size });
-    }
-  }
-  if (ranked.length === 0) {
-    if (NAMED_SCALES.chromatic !== void 0) {
-      return [{ name: "chromatic", rootPc }];
-    }
-    return [];
-  }
-  const preferHeptatonic = chordPcs.length <= 3;
-  ranked.sort((a, b) => {
-    const idiomaticA = idiomaticRank(chord, a.name);
-    const idiomaticB = idiomaticRank(chord, b.name);
-    if (idiomaticA !== idiomaticB) {
-      return idiomaticA - idiomaticB;
-    }
-    if (preferHeptatonic && a.size === HEPTATONIC_SIZE !== (b.size === HEPTATONIC_SIZE)) {
-      return a.size === HEPTATONIC_SIZE ? -1 : 1;
-    }
-    if (a.extra !== b.extra) {
-      return a.extra - b.extra;
-    }
-    const rankA = conventionalRank(a.name);
-    const rankB = conventionalRank(b.name);
-    if (rankA !== rankB) {
-      return rankA - rankB;
-    }
-    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-  });
-  return ranked.map((entry) => ({ name: entry.name, rootPc }));
-}
-function avoidNotes(chord, scaleName) {
-  const mask = requireScaleMask(scaleName);
-  const rootPc = pitchClassOf(chord.rootPc);
-  const chordPcs = chordPitchClasses(chord);
-  const alteredDominant = isAlteredDominant(chord, scaleName);
-  if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {
-    return [];
-  }
-  const chordSet = new Set(chordPcs);
-  const avoid = [];
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
-      continue;
-    }
-    const suspendedThird = chord.quality === "sus4" || chord.quality === "7sus4" ? pc === pitchClassOf(rootPc + 4) : false;
-    if (!alteredDominant && (chordSet.has(pitchClassOf(pc - 1)) || suspendedThird)) {
-      avoid.push(pc);
-    }
-  }
-  return avoid.sort((a, b) => a - b);
-}
-function availableTensions(chord, scaleName) {
-  const mask = requireScaleMask(scaleName);
-  const rootPc = pitchClassOf(chord.rootPc);
-  const chordPcs = chordPitchClasses(chord);
-  const alteredDominant = isAlteredDominant(chord, scaleName);
-  if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {
-    return [];
-  }
-  const chordSet = new Set(chordPcs);
-  const avoidSet = alteredDominant ? /* @__PURE__ */ new Set() : new Set(avoidNotes(chord, scaleName));
-  const tensions = [];
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc) || avoidSet.has(pc)) {
-      continue;
-    }
-    tensions.push(pc);
-  }
-  return tensions.sort((a, b) => a - b);
-}
-function chordScaleReport(chord, limit) {
-  if (limit !== void 0) {
-    assertPositiveInt(limit, "chord-scale report limit");
-  }
-  const matches = chordScales(chord);
-  const chosen = limit === void 0 ? matches : matches.slice(0, limit);
-  return chosen.map((match) => ({
-    name: match.name,
-    rootPc: match.rootPc,
-    avoid: avoidNotes(chord, match.name),
-    tensions: availableTensions(chord, match.name)
-  }));
-}
-var RANK_PENALTY = 0.01;
-function scalePitchClassSet(name, rootPc) {
-  const mask = namedScaleMask(name);
-  const pcs = /* @__PURE__ */ new Set();
-  if (mask === void 0) {
-    return pcs;
-  }
-  for (let n = 0; n < 12; n += 1) {
-    if ((mask >> n & 1) === 1) {
-      pcs.add(pitchClassOf(rootPc + n));
-    }
-  }
-  return pcs;
-}
-function symmetricDifferenceSize(a, b) {
-  let count = 0;
-  for (const pc of a) {
-    if (!b.has(pc)) {
-      count += 1;
-    }
-  }
-  for (const pc of b) {
-    if (!a.has(pc)) {
-      count += 1;
-    }
-  }
-  return count;
-}
-function scalesForChanges(chords) {
-  assertGenerationBudget(chords.length, "chord-scale changes");
-  if (chords.length === 0) {
-    return [];
-  }
-  const candidateLists = chords.map((chord) => chordScales(chord));
-  const pcSets = candidateLists.map(
-    (candidates) => candidates.map((match) => scalePitchClassSet(match.name, match.rootPc))
-  );
-  const first = candidateLists[0] ?? [];
-  const dp = [first.map((_, j) => j * RANK_PENALTY)];
-  const back = [first.map(() => -1)];
-  for (let i = 1; i < candidateLists.length; i += 1) {
-    const candidates = candidateLists[i] ?? [];
-    const prevCosts = dp[i - 1] ?? [];
-    const prevSets = pcSets[i - 1] ?? [];
-    const curSets = pcSets[i] ?? [];
-    const stageCosts = [];
-    const stageBack = [];
-    for (let j = 0; j < candidates.length; j += 1) {
-      let bestCost = Number.POSITIVE_INFINITY;
-      let bestPrev = -1;
-      for (let k = 0; k < prevCosts.length; k += 1) {
-        const transition = symmetricDifferenceSize(
-          prevSets[k] ?? /* @__PURE__ */ new Set(),
-          curSets[j] ?? /* @__PURE__ */ new Set()
-        );
-        const cost = (prevCosts[k] ?? 0) + transition;
-        if (cost < bestCost) {
-          bestCost = cost;
-          bestPrev = k;
-        }
-      }
-      stageCosts.push(bestCost + j * RANK_PENALTY);
-      stageBack.push(bestPrev);
-    }
-    dp.push(stageCosts);
-    back.push(stageBack);
-  }
-  const lastCosts = dp[dp.length - 1] ?? [];
-  let bestFinal = 0;
-  for (let j = 1; j < lastCosts.length; j += 1) {
-    if ((lastCosts[j] ?? Number.POSITIVE_INFINITY) < (lastCosts[bestFinal] ?? 0)) {
-      bestFinal = j;
-    }
-  }
-  const chosenIndices = new Array(candidateLists.length);
-  let current = bestFinal;
-  for (let i = candidateLists.length - 1; i >= 0; i -= 1) {
-    chosenIndices[i] = current;
-    current = back[i]?.[current] ?? -1;
-  }
-  return chords.map((chord, i) => {
-    const candidates = candidateLists[i] ?? [];
-    const scale = candidates[chosenIndices[i] ?? 0] ?? { name: "chromatic", rootPc: chord.rootPc };
-    return { chord, scale };
-  });
-}
-
-// src/theory/spelling/index.ts
-var CHROMATIC_SPELLING = {
-  1: 1,
-  // b2
-  2: 1,
-  // M2
-  3: 2,
-  // b3
-  4: 2,
-  // M3
-  5: 3,
-  // P4
-  6: 3,
-  // #4
-  7: 4,
-  // P5
-  8: 5,
-  // b6
-  9: 5,
-  // #6 (raised sixth of a minor key)
-  10: 6,
-  // b7
-  11: 6
-  // #7 (raised leading tone of a minor key)
-};
-var CHROMATIC_SPELLING_FLAT = {
-  ...CHROMATIC_SPELLING,
-  6: 4
-  // b5
-};
-var CHROMATIC_SPELLING_SHARP = {
-  1: 0,
-  // #1
-  2: 1,
-  // M2
-  3: 1,
-  // #2
-  4: 2,
-  // M3
-  5: 3,
-  // P4
-  6: 3,
-  // #4
-  7: 4,
-  // P5
-  8: 4,
-  // #5
-  9: 5,
-  // M6
-  10: 5,
-  // #6
-  11: 6
-  // M7
-};
-function alterFor(letter, pc) {
-  let d = pitchClassOf(pc - naturalPitchClassOf(letter));
-  if (d > 6) {
-    d -= 12;
-  }
-  return d;
-}
-function letterFor(tonic, degreeOffset, pc) {
-  if (degreeOffset === void 0) {
-    return void 0;
-  }
-  const letter = diatonicLetterOf(tonic.letter + degreeOffset);
-  return { letter, alter: alterFor(letter, pc) };
-}
-function pickSpelling(flat, sharp, preferFlat) {
-  if (flat === void 0 || sharp === void 0) {
-    return flat ?? sharp;
-  }
-  if (Math.abs(flat.alter) !== Math.abs(sharp.alter)) {
-    return Math.abs(flat.alter) < Math.abs(sharp.alter) ? flat : sharp;
-  }
-  return preferFlat ? flat : sharp;
-}
-function capChromaticAccidentals(preferred, alternative) {
-  return alternative !== void 0 && Math.abs(preferred.alter) - Math.abs(alternative.alter) >= 2 ? alternative : preferred;
-}
-function isHeptatonic(key) {
-  return scaleTonesInDegreeOrder(key).length === 7;
-}
-function hasMinorThird(key) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const root = pitchClassOf(key.rootPc);
-  return tones.includes(pitchClassOf(root + 3)) && !tones.includes(pitchClassOf(root + 4));
-}
-function spellPitchClass(pc, tonic, key) {
-  const tonicPc = pitchClassOf(naturalPitchClassOf(tonic.letter) + tonic.alter);
-  const offset = pitchClassOf(pc - tonicPc);
-  if (offset === 0) {
-    return { letter: diatonicLetterOf(tonic.letter), alter: tonic.alter };
-  }
-  const heptatonic = isHeptatonic(key);
-  if (heptatonic) {
-    const degree = scaleTonesInDegreeOrder(key).indexOf(pitchClassOf(pc));
-    if (degree >= 0) {
-      const letter = diatonicLetterOf(tonic.letter + degree);
-      return { letter, alter: alterFor(letter, pc) };
-    }
-    const degreeOffset = CHROMATIC_SPELLING[offset];
-    const preferred = letterFor(tonic, degreeOffset, pc);
-    if (preferred !== void 0) {
-      const flat = letterFor(tonic, CHROMATIC_SPELLING_FLAT[offset], pc);
-      const sharp = letterFor(tonic, CHROMATIC_SPELLING_SHARP[offset], pc);
-      const alternative = flat?.letter === preferred.letter ? sharp : sharp?.letter === preferred.letter ? flat : void 0;
-      return capChromaticAccidentals(preferred, alternative);
-    }
-  } else {
-    const flat = letterFor(tonic, CHROMATIC_SPELLING_FLAT[offset], pc);
-    const sharp = letterFor(tonic, CHROMATIC_SPELLING_SHARP[offset], pc);
-    const best = pickSpelling(flat, sharp, tonic.alter < 0 || hasMinorThird(key));
-    if (best !== void 0) {
-      return best;
-    }
-  }
-  const belowLetter = diatonicLetterOf([0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6][pitchClassOf(pc)] ?? 0);
-  return { letter: belowLetter, alter: alterFor(belowLetter, pc) };
-}
-function spellScale(tonic, key) {
-  return scaleTonesInDegreeOrder(key).map((pc) => spellPitchClass(pc, tonic, key));
-}
-function spellPitchClasses(pcs, tonic, key) {
-  return pcs.map((pc) => spellPitchClass(pc, tonic, key));
-}
-function chordLetterOffset(interval, chord) {
-  switch (interval) {
-    case 0:
-    case 12:
-      return 0;
-    case 1:
-    case 2:
-    case 13:
-    case 14:
-      return 1;
-    case 3:
-    case 4:
-    case 16:
-      return 2;
-    case 15:
-      return chord.intervals.some((i) => i === 3 || i === 4) ? 1 : 2;
-    case 5:
-    case 17:
-    case 18:
-      return 3;
-    case 6:
-    case 7:
-    case 8:
-    case 19:
-      return 4;
-    case 9:
-      return chord.quality === "dim7" ? 6 : 5;
-    case 20:
-    case 21:
-      return 5;
-    case 10:
-    case 11:
-    case 22:
-    case 23:
-      return 6;
-    default: {
-      const octaves = Math.floor(Math.max(0, interval) / 12);
-      const simple = pitchClassOf(interval);
-      const simpleOffset = [0, 1, 1, 2, 2, 3, 4, 4, 4, 5, 6, 6][simple] ?? 0;
-      return octaves * 7 + simpleOffset;
-    }
-  }
-}
-function spellChordFromRoot(chord, root) {
-  if (pitchClassOf(naturalPitchClassOf(root.letter) + root.alter) !== pitchClassOf(chord.rootPc)) {
-    throw new InvalidInputError("chord root spelling must match chord.rootPc");
-  }
-  return chord.intervals.map((interval) => {
-    const letter = diatonicLetterOf(root.letter + chordLetterOffset(interval, chord));
-    const pc = pitchClassOf(chord.rootPc + interval);
-    return { letter, alter: alterFor(letter, pc) };
-  });
-}
-function spellChord(chord, tonic, key) {
-  return spellChordFromRoot(chord, chordRootSpelling(chord, tonic, key));
-}
-function chordRootSpelling(chord, tonic, key) {
-  const hint = chord.rootSpelling;
-  if (hint !== void 0 && pitchClassOf(naturalPitchClassOf(hint.letter) + hint.alter) === pitchClassOf(chord.rootPc)) {
-    return { letter: diatonicLetterOf(hint.letter), alter: hint.alter };
-  }
-  return spellPitchClass(chord.rootPc, tonic, key);
-}
-function spellPitch(pitch, tonic, key) {
-  const rounded = Math.round(pitch);
-  const spelled = spellPitchClass(pitchClassOf(rounded), tonic, key);
-  const octave = (rounded - naturalPitchClassOf(spelled.letter) - spelled.alter) / 12 - 1;
-  return { letter: spelled.letter, alter: spelled.alter, octave };
-}
-function noteNames(notes) {
-  return notes.map(formatNote);
-}
-
-// src/theory/symbol/index.ts
-var ROOT_RE = /^[A-Ga-g](?:#{1,2}|b{1,2}|x)?/;
-var BASS_RE = /^[A-Ga-g](?:#{1,2}|b{1,2}|x)?$/;
-var QUALITY_MAP = {
-  "": "maj",
-  maj: "maj",
-  m: "min",
-  min: "min",
-  "-": "min",
-  dim: "dim",
-  "\xB0": "dim",
-  aug: "aug",
-  "+": "aug",
-  maj7: "maj7",
-  M7: "maj7",
-  \u0394: "maj7",
-  \u03947: "maj7",
-  m7: "min7",
-  min7: "min7",
-  "-7": "min7",
-  "7": "dom7",
-  dim7: "dim7",
-  "\xB07": "dim7",
-  m7b5: "m7b5",
-  \u00F8: "m7b5",
-  \u00F87: "m7b5",
-  min7b5: "m7b5",
-  mMaj7: "minMaj7",
-  mM7: "minMaj7",
-  minMaj7: "minMaj7",
-  mMaj9: "minMaj9",
-  mM9: "minMaj9",
-  minMaj9: "minMaj9",
-  mMaj11: "minMaj11",
-  mM11: "minMaj11",
-  minMaj11: "minMaj11",
-  mMaj13: "minMaj13",
-  mM13: "minMaj13",
-  minMaj13: "minMaj13",
-  aug7: "aug7",
-  "+7": "aug7",
-  "7#5": "aug7",
-  augMaj7: "augMaj7",
-  augM7: "augMaj7",
-  "+maj7": "augMaj7",
-  "+M7": "augMaj7",
-  majb5: "majb5",
-  "maj(b5)": "majb5",
-  "(b5)": "majb5",
-  "6": "6",
-  m6: "min6",
-  min6: "min6",
-  "6/9": "6/9",
-  "69": "6/9",
-  sus2: "sus2",
-  sus: "sus4",
-  sus4: "sus4",
-  add9: "add9",
-  add11: "add11",
-  maj9: "maj9",
-  M9: "maj9",
-  m9: "min9",
-  min9: "min9",
-  "9": "dom9",
-  "7b9": "7b9",
-  "7#9": "7#9",
-  "7#11": "7#11",
-  "7b13": "7b13",
-  "11": "11",
-  "13": "13",
-  "5": "5",
-  "7sus4": "7sus4",
-  "7sus": "7sus4",
-  "9sus4": "11",
-  "9sus": "11",
-  "7b5": "7b5",
-  "7alt": "7alt",
-  alt: "7alt",
-  "13b9": "13b9",
-  maj13: "maj13",
-  M13: "maj13",
-  "maj7#11": "maj7#11",
-  "M7#11": "maj7#11",
-  m11: "min11",
-  min11: "min11",
-  m13: "min13",
-  min13: "min13",
-  madd9: "minAdd9",
-  "min(add9)": "minAdd9",
-  "m(add9)": "minAdd9",
-  "6add9": "6/9",
-  "m6/9": "min6/9",
-  m69: "min6/9",
-  "min6/9": "min6/9",
-  // ASCII stand-ins for the degree and half-diminished glyphs, which most
-  // lead sheets and chord-chart text files use instead of the typographic ones.
-  o: "dim",
-  o7: "dim7",
-  h: "m7b5",
-  h7: "m7b5"
-};
-var CANONICAL_SUFFIX = {
-  maj: "",
-  min: "m",
-  dim: "dim",
-  aug: "aug",
-  maj7: "maj7",
-  min7: "m7",
-  dom7: "7",
-  dim7: "dim7",
-  m7b5: "m7b5",
-  minMaj7: "mMaj7",
-  minMaj9: "mMaj9",
-  minMaj11: "mMaj11",
-  minMaj13: "mMaj13",
-  aug7: "aug7",
-  augMaj7: "augMaj7",
-  majb5: "maj(b5)",
-  "6": "6",
-  min6: "m6",
-  "6/9": "6/9",
-  sus2: "sus2",
-  sus4: "sus4",
-  add9: "add9",
-  add11: "add11",
-  maj9: "maj9",
-  min9: "m9",
-  dom9: "9",
-  "7b9": "7b9",
-  "7#9": "7#9",
-  "7#11": "7#11",
-  "7b13": "7b13",
-  "11": "11",
-  "13": "13",
-  "5": "5",
-  "7sus4": "7sus4",
-  "7b5": "7b5",
-  "7alt": "7alt",
-  "13b9": "13b9",
-  maj13: "maj13",
-  "maj7#11": "maj7#11",
-  min11: "m11",
-  min13: "m13",
-  minAdd9: "madd9",
-  "min6/9": "m6/9"
-};
-function knownQuality(suffix) {
-  return Object.hasOwn(QUALITY_MAP, suffix) ? QUALITY_MAP[suffix] : void 0;
-}
-function makeSpelledChord(root, quality, bass) {
-  const chord = makeChord(
-    noteToPitchClass(root),
-    quality,
-    bass === void 0 ? void 0 : noteToPitchClass(bass)
-  );
-  chord.rootSpelling = { letter: root.letter, alter: root.alter };
-  if (bass !== void 0) {
-    chord.bassSpelling = { letter: bass.letter, alter: bass.alter };
-  }
-  return chord;
-}
-function parseChordSymbol(text) {
-  const trimmed = text.trim().replaceAll("\u266F", "#").replaceAll("\u266D", "b").replaceAll("\u{1D12A}", "x").replaceAll("\u{1D12B}", "bb");
-  const rootMatch = ROOT_RE.exec(trimmed);
-  if (!rootMatch) {
-    throw new InvalidInputError(`Invalid chord symbol: ${text}`);
-  }
-  const rootToken = rootMatch[0];
-  const rootNote = parseNote(rootToken);
-  const rest = trimmed.slice(rootToken.length);
-  const slashIndex = rest.lastIndexOf("/");
-  if (slashIndex !== -1) {
-    const before = rest.slice(0, slashIndex);
-    const after = rest.slice(slashIndex + 1);
-    const beforeQuality = knownQuality(before);
-    if (beforeQuality !== void 0 && BASS_RE.test(after)) {
-      return makeSpelledChord(rootNote, beforeQuality, parseNote(after));
-    }
-  }
-  const quality = knownQuality(rest);
-  if (quality === void 0) {
-    throw new InvalidInputError(`Unrecognized chord quality: ${text}`);
-  }
-  return makeSpelledChord(rootNote, quality);
-}
-function pitchClassName(pc, hint, flats, inheritFlats) {
-  if (flats === void 0 && hint !== void 0 && noteToPitchClass(hint) === pc) {
-    return formatNote(hint);
-  }
-  const note = midiToNote(60 + pc, flats ?? inheritFlats ? "flat" : "sharp");
-  return formatNote({ letter: note.letter, alter: note.alter });
-}
-function formatChordSymbol(chord, opts) {
-  assertFiniteNumber(chord.rootPc, "chord rootPc");
-  if (chord.bassPc !== void 0) {
-    assertFiniteNumber(chord.bassPc, "chord bassPc");
-  }
-  if (!Object.hasOwn(CANONICAL_SUFFIX, chord.quality)) {
-    throw new InvalidInputError(`Unknown chord quality: ${String(chord.quality)}`);
-  }
-  const rootPc = pitchClassOf(chord.rootPc);
-  const rootHint = chord.rootSpelling;
-  const rootName = pitchClassName(rootPc, rootHint, opts?.flats);
-  const suffix = CANONICAL_SUFFIX[chord.quality];
-  let symbol = `${rootName}${suffix}`;
-  if (chord.bassPc !== void 0 && pitchClassOf(chord.bassPc) !== rootPc) {
-    const inheritFlats = rootHint !== void 0 && noteToPitchClass(rootHint) === rootPc ? rootHint.alter < 0 : void 0;
-    symbol += `/${pitchClassName(pitchClassOf(chord.bassPc), chord.bassSpelling, opts?.flats, inheritFlats)}`;
-  }
-  return symbol;
-}
-function transposeChordSymbol(text, semitones, opts) {
-  assertFiniteSemitones(semitones);
-  const chord = parseChordSymbol(text);
-  const transposed = { ...chord, rootPc: pitchClassOf(chord.rootPc + semitones) };
-  if (chord.rootSpelling !== void 0) {
-    const hint = transposeNote(chord.rootSpelling, semitones);
-    transposed.rootSpelling = { letter: hint.letter, alter: hint.alter };
-  }
-  if (chord.bassPc !== void 0) {
-    transposed.bassPc = pitchClassOf(chord.bassPc + semitones);
-  }
-  if (chord.bassSpelling !== void 0) {
-    const hint = transposeNote(chord.bassSpelling, semitones);
-    transposed.bassSpelling = { letter: hint.letter, alter: hint.alter };
-  }
-  return formatChordSymbol(transposed, opts);
-}
-
-// src/theory/voicing/internal.ts
-var DEFAULT_MAX_SPACING = 12;
-var VIOLATION_PENALTY = 1e3;
-var MISSING_TONE_PENALTY = 500;
-var MISSING_FIFTH_PENALTY = 20;
-var POOR_DOUBLING_PENALTY = 4;
-var UNISON_PENALTY = 100;
-var LEADING_TONE_DOUBLING_PENALTY = 200;
-var RESOLUTION_PENALTY = 200;
-var DEFAULT_MAX_CANDIDATES = 4e3;
-var SEARCH_NODES_PER_CANDIDATE = 16;
-function pitchesForPc(pc, range) {
-  const result = [];
-  for (let midi = Math.ceil(range.min); midi <= range.max; midi += 1) {
-    if (pitchClassOf(midi) === pc) {
-      result.push(midi);
-    }
-  }
-  const center = (range.min + range.max) / 2;
-  return result.sort((a, b) => {
-    const da = Math.abs(a - center);
-    const db = Math.abs(b - center);
-    return da === db ? a - b : da - db;
-  });
-}
-function enumerateVoicings(chord, ranges, maxSpacing, maxCandidates = DEFAULT_MAX_CANDIDATES) {
-  const chordPcs = chordPitchClasses(chord);
-  const bassPc = pitchClassOf(chord.bassPc ?? chord.rootPc);
-  const byVoice = ranges.map(
-    (range, voice) => (voice === 0 ? [bassPc] : chordPcs).flatMap((pc) => pitchesForPc(pc, range))
-  );
-  for (let voice = 0; voice < byVoice.length; voice += 1) {
-    if ((byVoice[voice] ?? []).length === 0) {
-      throw new NoSolutionError("no voicing satisfies the given ranges");
-    }
-  }
-  const results = [];
-  const current = [];
-  let nodes = 0;
-  const maxSearchNodes = maxCandidates * SEARCH_NODES_PER_CANDIDATE;
-  const build = (voice) => {
-    nodes += 1;
-    if (results.length >= maxCandidates || nodes > maxSearchNodes) {
-      return;
-    }
-    if (voice === ranges.length) {
-      results.push([...current]);
-      return;
-    }
-    const prev = current[voice - 1];
-    for (const pitch of byVoice[voice] ?? []) {
-      if (prev !== void 0) {
-        if (pitch < prev) {
-          continue;
-        }
-        const spacingLimit = voice === 1 ? maxSpacing + 12 : maxSpacing;
-        if (pitch - prev > spacingLimit) {
-          continue;
-        }
-      }
-      current.push(pitch);
-      build(voice + 1);
-      current.pop();
-    }
-  };
-  build(0);
-  return results;
-}
-function structuralPenalty(pitches, chord, key) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const pitch of pitches) {
-    const pc = pitchClassOf(pitch);
-    counts.set(pc, (counts.get(pc) ?? 0) + 1);
-  }
-  let penalty = 0;
-  for (let index = 1; index < pitches.length; index += 1) {
-    if (pitches[index] === pitches[index - 1]) {
-      penalty += UNISON_PENALTY;
-    }
-  }
-  for (const pc of chordPitchClasses(chord)) {
-    if (!counts.has(pc)) {
-      penalty += chordToneRole(pc, chord) === "fifth" ? MISSING_FIFTH_PENALTY : MISSING_TONE_PENALTY;
-    }
-  }
-  const rootPc = pitchClassOf(chord.rootPc);
-  const leadingTonePc = key === void 0 ? void 0 : pitchClassOf(key.rootPc - 1);
-  for (const [pc, count] of counts) {
-    if (count <= 1) {
-      continue;
-    }
-    if (pc === leadingTonePc) {
-      penalty += (count - 1) * LEADING_TONE_DOUBLING_PENALTY;
-      continue;
-    }
-    if (pc !== rootPc && chordToneRole(pc, chord) !== "fifth") {
-      penalty += (count - 1) * POOR_DOUBLING_PENALTY;
-    }
-  }
-  return penalty;
-}
-function seventhPcOf(chord) {
-  for (const interval of chord.intervals) {
-    const pc = pitchClassOf(chord.rootPc + interval);
-    if (chordToneRole(pc, chord) === "seventh") {
-      return pc;
-    }
-  }
-  return void 0;
-}
-function resolutionViolations(prev, cur, prevChord, nextChord, key) {
-  const seventhPc = seventhPcOf(prevChord);
-  const leadingTonePc = key === void 0 ? void 0 : pitchClassOf(key.rootPc - 1);
-  const tonicPc = key === void 0 ? void 0 : pitchClassOf(key.rootPc);
-  const nextPcs = new Set(chordPitchClasses(nextChord));
-  let count = 0;
-  for (let voice = 0; voice < prev.length && voice < cur.length; voice += 1) {
-    const from = prev[voice];
-    const to = cur[voice];
-    if (from === void 0 || to === void 0) {
-      continue;
-    }
-    const fromPc = pitchClassOf(from);
-    const motion = to - from;
-    if (fromPc === seventhPc && !nextPcs.has(fromPc) && motion !== -1 && motion !== -2) {
-      count += 1;
-    }
-    if (fromPc === leadingTonePc && tonicPc !== void 0 && nextPcs.has(tonicPc) && !nextPcs.has(fromPc) && motion !== 1) {
-      count += 1;
-    }
-  }
-  return count;
-}
-function violationCount(prev, cur) {
-  let count = 0;
-  for (let lower = 0; lower < cur.length; lower += 1) {
-    for (let upper = lower + 1; upper < cur.length; upper += 1) {
-      const prevLower = prev[lower];
-      const prevUpper = prev[upper];
-      const curLower = cur[lower];
-      const curUpper = cur[upper];
-      if (prevLower === void 0 || prevUpper === void 0 || curLower === void 0 || curUpper === void 0) {
-        continue;
-      }
-      if (createsParallelPerfect(prevUpper, curUpper, prevLower, curLower)) {
-        count += 1;
-      }
-      if (upper === lower + 1) {
-        if (createsVoiceOverlap(prevUpper, curUpper, prevLower, curLower)) {
-          count += 1;
-        }
-      }
-    }
-  }
-  return count;
-}
-
-// src/theory/voicing/leading.ts
-var HIDDEN_PERFECT_PENALTY = 6;
-function voiceLeadingCost(from, to) {
-  if (from.length !== to.length) {
-    return Number.POSITIVE_INFINITY;
-  }
-  let total = 0;
-  for (let i = 0; i < from.length; i += 1) {
-    const a = from[i];
-    const b = to[i];
-    if (a === void 0 || b === void 0) {
-      continue;
-    }
-    total += Math.abs(b - a);
-  }
-  if (from.length >= 2) {
-    const bassPrev = from[0];
-    const bassCur = to[0];
-    const sopPrev = from[from.length - 1];
-    const sopCur = to[to.length - 1];
-    if (bassPrev !== void 0 && bassCur !== void 0 && sopPrev !== void 0 && sopCur !== void 0 && createsHiddenParallelPerfect(bassPrev, bassCur, sopPrev, sopCur)) {
-      total += HIDDEN_PERFECT_PENALTY;
-    }
-  }
-  return total;
-}
-function nextVoicing(current, chord, opts) {
-  const derived = opts?.ranges === void 0 && opts?.voices === void 0;
-  if (derived) {
-    if (current.length === 0) {
-      throw new InvalidInputError("current must contain at least one pitch");
-    }
-    for (let index = 0; index < current.length; index += 1) {
-      assertFiniteNumber(current[index] ?? Number.NaN, `current[${index}]`);
-    }
-  }
-  const ranges = derived ? current.map((pitch) => {
-    const centre = Math.min(127, Math.max(0, pitch));
-    return { min: Math.max(0, centre - 12), max: Math.min(127, centre + 12) };
-  }) : resolveRanges(opts);
-  for (let index = 0; index < current.length; index += 1) {
-    assertFiniteNumber(current[index] ?? Number.NaN, `current[${index}]`);
-  }
-  if (current.length < ranges.length) {
-    throw new InvalidInputError(
-      `current has ${current.length} voices but the requested ranges require ${ranges.length}`
-    );
-  }
-  const source = current.length === ranges.length ? current : ranges.length === 1 ? [current[0] ?? Number.NaN] : ranges.map((_, index) => {
-    const sourceIndex = Math.round(index * (current.length - 1) / (ranges.length - 1));
-    return current[sourceIndex] ?? Number.NaN;
-  });
-  const maxSpacing = resolveMaxSpacing(opts);
-  const candidates = enumerateVoicings(chord, ranges, maxSpacing, resolveMaxCandidates(opts));
-  const previousChord = opts?.previousChord;
-  let best;
-  let bestScore = Number.POSITIVE_INFINITY;
-  for (const candidate of candidates) {
-    const score = structuralPenalty(candidate, chord, opts?.key) + voiceLeadingCost(source, candidate) + VIOLATION_PENALTY * violationCount(source, candidate) + RESOLUTION_PENALTY * (previousChord === void 0 ? 0 : resolutionViolations(source, candidate, previousChord, chord, opts?.key));
-    if (score < bestScore) {
-      bestScore = score;
-      best = candidate;
-    }
-  }
-  if (best === void 0) {
-    throw new NoSolutionError("no voicing satisfies the given ranges");
-  }
-  return best;
-}
-
-// src/theory/voicing/satb.ts
-var SATB_RANGES = Object.freeze([
-  Object.freeze({ min: 40, max: 60 }),
-  Object.freeze({ min: 48, max: 67 }),
-  Object.freeze({ min: 55, max: 74 }),
-  Object.freeze({ min: 60, max: 79 })
-]);
-var DERIVED_LOW = 40;
-var DERIVED_HIGH = 79;
-var DERIVED_SPAN = 19;
-function resolveRanges(opts) {
-  if (opts?.ranges !== void 0) {
-    if (opts.ranges.length === 0) {
-      throw new InvalidInputError("ranges must contain at least one voice range");
-    }
-    assertGenerationBudget(opts.ranges.length, "voice ranges", 128);
-    return opts.ranges.map((range, index) => {
-      assertFiniteNumber(range.min, `ranges[${index}].min`);
-      assertFiniteNumber(range.max, `ranges[${index}].max`);
-      if (range.min > range.max) {
-        throw new InvalidInputError(`ranges[${index}].min must not exceed max`);
-      }
-      assertGenerationBudget(
-        Math.floor(range.max) - Math.ceil(range.min) + 1,
-        `ranges[${index}] span`,
-        4096
-      );
-      return { ...range };
-    });
-  }
-  const voices = opts?.voices ?? 4;
-  assertPositiveInt(voices, "voices", 128);
-  if (voices === 4) {
-    return SATB_RANGES.map((range) => ({ ...range }));
-  }
-  if (voices === 1) {
-    return [{ min: DERIVED_LOW, max: DERIVED_HIGH }];
-  }
-  const ranges = [];
-  for (let i = 0; i < voices; i += 1) {
-    const min = Math.round(
-      DERIVED_LOW + i * (DERIVED_HIGH - DERIVED_SPAN - DERIVED_LOW) / (voices - 1)
-    );
-    ranges.push({ min, max: min + DERIVED_SPAN });
-  }
-  return ranges;
-}
-function resolveMaxSpacing(opts) {
-  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;
-  assertFiniteNumber(maxSpacing, "maxSpacing");
-  if (maxSpacing < 0) {
-    throw new InvalidInputError("maxSpacing must be non-negative");
-  }
-  return maxSpacing;
-}
-function resolveMaxCandidates(opts) {
-  if (opts?.maxCandidates === void 0) return void 0;
-  assertPositiveInt(opts.maxCandidates, "maxCandidates", 1e6);
-  return opts.maxCandidates;
-}
-function voiceChord(chord, opts) {
-  const ranges = resolveRanges(opts);
-  const maxSpacing = resolveMaxSpacing(opts);
-  const candidates = enumerateVoicings(chord, ranges, maxSpacing, resolveMaxCandidates(opts));
-  let best;
-  let bestScore = Number.POSITIVE_INFINITY;
-  for (const candidate of candidates) {
-    let score = structuralPenalty(candidate, chord, opts?.key);
-    for (let i = 0; i < candidate.length; i += 1) {
-      const pitch = candidate[i];
-      const range = ranges[i];
-      if (pitch === void 0 || range === void 0) {
-        continue;
-      }
-      score += Math.abs(pitch - (range.min + range.max) / 2);
-    }
-    if (score < bestScore) {
-      bestScore = score;
-      best = candidate;
-    }
-  }
-  if (best === void 0) {
-    throw new NoSolutionError(
-      `no voicing satisfies the given ranges for ${formatChordSymbol(chord)}`
-    );
-  }
-  return best;
-}
-function noSolutionAt(index, chord) {
-  return new NoSolutionError(
-    `no voicing satisfies the given ranges for ${formatChordSymbol(chord)} at index ${index}`,
-    { at: index }
-  );
-}
-function locate(index, chord, work) {
-  try {
-    return work();
-  } catch (error) {
-    if (error instanceof NoSolutionError) {
-      throw noSolutionAt(index, chord);
-    }
-    throw error;
-  }
-}
-function voiceProgression(chords, opts) {
-  assertGenerationBudget(chords.length, "voiced progression chords", opts?.budget);
-  const ranges = resolveRanges(opts);
-  const maxSpacing = resolveMaxSpacing(opts);
-  const maxCandidates = resolveMaxCandidates(opts);
-  const result = [];
-  let prev;
-  let prevChord;
-  for (let index = 0; index < chords.length; index += 1) {
-    const chord = chords[index];
-    if (chord === void 0) {
-      continue;
-    }
-    if (prev === void 0) {
-      prev = locate(index, chord, () => voiceChord(chord, opts));
-      prevChord = chord;
-      result.push(prev);
-      continue;
-    }
-    const candidates = locate(
-      index,
-      chord,
-      () => enumerateVoicings(chord, ranges, maxSpacing, maxCandidates)
-    );
-    let best;
-    let bestScore = Number.POSITIVE_INFINITY;
-    for (const candidate of candidates) {
-      const unresolved = prevChord === void 0 ? 0 : resolutionViolations(prev, candidate, prevChord, chord, opts?.key);
-      const score = structuralPenalty(candidate, chord, opts?.key) + voiceLeadingCost(prev, candidate) + VIOLATION_PENALTY * violationCount(prev, candidate) + RESOLUTION_PENALTY * unresolved;
-      if (score < bestScore) {
-        bestScore = score;
-        best = candidate;
-      }
-    }
-    if (best === void 0) {
-      throw noSolutionAt(index, chord);
-    }
-    result.push(best);
-    prev = best;
-    prevChord = chord;
-  }
-  return result;
-}
-
-// src/theory/voicing/styled.ts
-var DEFAULT_STYLE_OCTAVE = 4;
-function dedupePcs(pcs) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const pc of pcs) {
-    if (!seen.has(pc)) {
-      seen.add(pc);
-      result.push(pc);
-    }
-  }
-  return result;
-}
-function lowestPitchAtOrAbove(pc, floor) {
-  return floor + ((pc - pitchClassOf(floor)) % 12 + 12) % 12;
-}
-function nearestPc(target, pcs) {
-  let best = pcs[0] ?? target;
-  let bestDist = 12;
-  for (const pc of pcs) {
-    const dist = Math.min(((pc - target) % 12 + 12) % 12, ((target - pc) % 12 + 12) % 12);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = pc;
-    }
-  }
-  return best;
-}
-function voiceChordStyled(chord, opts) {
-  const style = opts?.style ?? "close";
-  const octave = opts?.octave ?? DEFAULT_STYLE_OCTAVE;
-  assertInteger(octave, "styled voicing octave", -10, 10);
-  if (opts?.topNote !== void 0) {
-    assertFiniteNumber(opts.topNote, "styled voicing topNote");
-  }
-  const base = 12 * (octave + 1);
-  const rootPc = pitchClassOf(chord.rootPc);
-  const bassPc = pitchClassOf(chord.bassPc ?? chord.rootPc);
-  const omitRoot = style === "rootless" || opts?.rootless === true;
-  let order = dedupePcs(chord.intervals.map((interval) => pitchClassOf(chord.rootPc + interval)));
-  const bassIndex = order.indexOf(bassPc);
-  if (bassIndex > 0) {
-    order = [...order.slice(bassIndex), ...order.slice(0, bassIndex)];
-  } else if (bassIndex < 0) {
-    order = [bassPc, ...order];
-  }
-  if (style === "shell") {
-    const roles = order.map((pc) => chordToneRole(pc, chord));
-    const guide = roles.includes("seventh") ? "seventh" : roles.includes("sixth") ? "sixth" : "fifth";
-    order = order.filter((_pc, i) => {
-      const role = roles[i];
-      return _pc === bassPc || role === "root" || role === "third" || role === guide;
-    });
-  }
-  if (omitRoot) {
-    order = order.filter((pc) => pc !== rootPc || chord.bassPc !== void 0 && pc === bassPc);
-  }
-  if (order.length === 0) {
-    return [];
-  }
-  if (opts?.topNote !== void 0) {
-    const target = order.includes(pitchClassOf(opts.topNote)) ? pitchClassOf(opts.topNote) : nearestPc(pitchClassOf(opts.topNote), order);
-    const targetIndex = order.indexOf(target);
-    order = [...order.slice(targetIndex + 1), ...order.slice(0, targetIndex + 1)];
-  }
-  const stack = [];
-  let prev;
-  for (const pc of order) {
-    if (prev === void 0) {
-      prev = lowestPitchAtOrAbove(pc, base);
-    } else {
-      let delta = ((pc - pitchClassOf(prev)) % 12 + 12) % 12;
-      if (delta === 0) {
-        delta = 12;
-      }
-      prev += delta;
-    }
-    stack.push(prev);
-  }
-  if (style === "drop2" && stack.length >= 2) {
-    stack[stack.length - 2] = (stack[stack.length - 2] ?? 0) - 12;
-  } else if (style === "drop3" && stack.length >= 3) {
-    stack[stack.length - 3] = (stack[stack.length - 3] ?? 0) - 12;
-  }
-  if (chord.bassPc !== void 0) {
-    const bassIndexInStack = stack.findIndex((pitch) => pitchClassOf(pitch) === bassPc);
-    if (bassIndexInStack >= 0) {
-      const otherLowest = Math.min(
-        ...stack.filter((_pitch, index) => index !== bassIndexInStack),
-        Number.POSITIVE_INFINITY
-      );
-      while ((stack[bassIndexInStack] ?? 0) >= otherLowest) {
-        stack[bassIndexInStack] = (stack[bassIndexInStack] ?? 0) - 12;
-      }
-    }
-  }
-  const voicing = stack.sort((a, b) => a - b);
-  const lowest = voicing[0] ?? 0;
-  const highest = voicing[voicing.length - 1] ?? 0;
-  if (lowest < 0 || highest > 127) {
-    throw new InvalidInputError(
-      `styled voicing at octave ${octave} spans MIDI ${lowest}..${highest}, outside 0..127`
-    );
-  }
-  return voicing;
-}
-
-export {
-  scaleMatchesChord,
-  chordScales,
-  avoidNotes,
-  availableTensions,
-  chordScaleReport,
-  scalesForChanges,
-  spellPitchClass,
-  spellScale,
-  spellPitchClasses,
-  spellChordFromRoot,
-  spellChord,
-  spellPitch,
-  noteNames,
-  parseChordSymbol,
-  formatChordSymbol,
-  transposeChordSymbol,
-  SATB_RANGES,
-  voiceChord,
-  voiceProgression,
-  voiceLeadingCost,
-  nextVoicing,
-  voiceChordStyled
-};
-//# sourceMappingURL=chunk-7EONYVI5.js.map