@libraz/libcantus 0.9.1 → 0.9.2

package/dist/theory/index.cjs

@@ -0,0 +1,1677 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/theory/index.ts
+var theory_exports = {};
+__export(theory_exports, {
+  BLUES_MASK: () => BLUES_MASK,
+  CHROMATIC_MASK: () => CHROMATIC_MASK,
+  DORIAN_MASK: () => DORIAN_MASK,
+  HARMONIC_MINOR_MASK: () => HARMONIC_MINOR_MASK,
+  LOCRIAN_MASK: () => LOCRIAN_MASK,
+  LYDIAN_MASK: () => LYDIAN_MASK,
+  MAJOR_MASK: () => MAJOR_MASK,
+  MAJOR_PENTATONIC_MASK: () => MAJOR_PENTATONIC_MASK,
+  MELODIC_MINOR_MASK: () => MELODIC_MINOR_MASK,
+  MINOR_PENTATONIC_MASK: () => MINOR_PENTATONIC_MASK,
+  MIXOLYDIAN_MASK: () => MIXOLYDIAN_MASK,
+  NAMED_SCALES: () => NAMED_SCALES,
+  NATURAL_MINOR_MASK: () => NATURAL_MINOR_MASK,
+  NoteSafety: () => NoteSafety,
+  OCTATONIC_HALF_WHOLE_MASK: () => OCTATONIC_HALF_WHOLE_MASK,
+  OCTATONIC_WHOLE_HALF_MASK: () => OCTATONIC_WHOLE_HALF_MASK,
+  PHRYGIAN_MASK: () => PHRYGIAN_MASK,
+  ReasonFlag: () => ReasonFlag,
+  SATB_RANGES: () => SATB_RANGES,
+  WHOLE_TONE_MASK: () => WHOLE_TONE_MASK,
+  availableTensions: () => availableTensions,
+  avoidNotes: () => avoidNotes,
+  chordFromDegree: () => chordFromDegree,
+  chordPitchClasses: () => chordPitchClasses,
+  chordQualities: () => chordQualities,
+  chordScaleReport: () => chordScaleReport,
+  chordScales: () => chordScales,
+  chordToneRole: () => chordToneRole,
+  createsHiddenParallelPerfect: () => createsHiddenParallelPerfect,
+  createsParallelOctave: () => createsParallelOctave,
+  createsParallelPerfect: () => createsParallelPerfect,
+  createsParallelUnison: () => createsParallelUnison,
+  createsVerticalDissonance: () => createsVerticalDissonance,
+  createsVoiceCrossing: () => createsVoiceCrossing,
+  createsVoiceOverlap: () => createsVoiceOverlap,
+  diatonicPitchClasses: () => diatonicPitchClasses,
+  diatonicSeventh: () => diatonicSeventh,
+  diatonicTriad: () => diatonicTriad,
+  enumerateSafePitches: () => enumerateSafePitches,
+  evaluateSafety: () => evaluateSafety,
+  exceedsSpacing: () => exceedsSpacing,
+  formatChordSymbol: () => formatChordSymbol,
+  isForbiddenMelodicLeap: () => isForbiddenMelodicLeap,
+  isLeadingToneResolution: () => isLeadingToneResolution,
+  isScaleTone: () => isScaleTone,
+  majorKey: () => majorKey,
+  makeChord: () => makeChord,
+  maskFromOffsets: () => maskFromOffsets,
+  minorKey: () => minorKey,
+  nearestScaleTone: () => nearestScaleTone,
+  nextVoicing: () => nextVoicing,
+  noteNames: () => noteNames,
+  parseChordSymbol: () => parseChordSymbol,
+  pitchToScaleDegree: () => pitchToScaleDegree,
+  roleOf: () => roleOf,
+  scaleByName: () => scaleByName,
+  scaleMatchesChord: () => scaleMatchesChord,
+  scaleTonesInDegreeOrder: () => scaleTonesInDegreeOrder,
+  scalesForChanges: () => scalesForChanges,
+  spellChord: () => spellChord,
+  spellPitchClass: () => spellPitchClass,
+  spellPitchClasses: () => spellPitchClasses,
+  spellScale: () => spellScale,
+  transposeChordSymbol: () => transposeChordSymbol,
+  voiceChord: () => voiceChord,
+  voiceChordStyled: () => voiceChordStyled,
+  voiceLeadingCost: () => voiceLeadingCost,
+  voiceProgression: () => voiceProgression
+});
+module.exports = __toCommonJS(theory_exports);
+
+// src/theory/scale/degrees.ts
+function pitchClass(pitch) {
+  return (Math.trunc(pitch) % 12 + 12) % 12;
+}
+function scaleOffset(pitch, key) {
+  return (pitchClass(pitch) - pitchClass(key.rootPc) + 12) % 12;
+}
+function isScaleTone(pitch, key) {
+  return (key.modeMask12 >> scaleOffset(pitch, key) & 1) === 1;
+}
+function nearestScaleTone(pitch, key) {
+  const base = Math.round(pitch);
+  for (let distance = 0; distance < 12; distance += 1) {
+    const lower = base - distance;
+    if (isScaleTone(lower, key)) {
+      return lower;
+    }
+    const higher = base + distance;
+    if (isScaleTone(higher, key)) {
+      return higher;
+    }
+  }
+  return base;
+}
+function pitchToScaleDegree(pitch, key) {
+  const offset = scaleOffset(pitch, key);
+  if ((key.modeMask12 >> offset & 1) === 0) {
+    return -1;
+  }
+  let degree = 0;
+  for (let n = 0; n < offset; n += 1) {
+    if ((key.modeMask12 >> n & 1) === 1) {
+      degree += 1;
+    }
+  }
+  return degree;
+}
+function diatonicPitchClasses(key) {
+  const root = pitchClass(key.rootPc);
+  const pcs = [];
+  for (let n = 0; n < 12; n += 1) {
+    if ((key.modeMask12 >> n & 1) === 1) {
+      pcs.push((root + n) % 12);
+    }
+  }
+  return pcs.sort((a, b) => a - b);
+}
+function scaleTonesInDegreeOrder(key) {
+  const root = pitchClass(key.rootPc);
+  const pcs = [];
+  for (let n = 0; n < 12; n += 1) {
+    if ((key.modeMask12 >> n & 1) === 1) {
+      pcs.push((root + n) % 12);
+    }
+  }
+  return pcs;
+}
+
+// src/theory/scale/masks.ts
+function maskFromOffsets(offsets) {
+  let mask = 1;
+  for (const offset of offsets) {
+    mask |= 1 << (offset % 12 + 12) % 12;
+  }
+  return mask;
+}
+var MAJOR_MASK = 2741;
+var NATURAL_MINOR_MASK = 1453;
+var HARMONIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 8, 11]);
+var MELODIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 11]);
+var DORIAN_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 10]);
+var PHRYGIAN_MASK = maskFromOffsets([0, 1, 3, 5, 7, 8, 10]);
+var LYDIAN_MASK = maskFromOffsets([0, 2, 4, 6, 7, 9, 11]);
+var MIXOLYDIAN_MASK = maskFromOffsets([0, 2, 4, 5, 7, 9, 10]);
+var LOCRIAN_MASK = maskFromOffsets([0, 1, 3, 5, 6, 8, 10]);
+var MAJOR_PENTATONIC_MASK = maskFromOffsets([0, 2, 4, 7, 9]);
+var MINOR_PENTATONIC_MASK = maskFromOffsets([0, 3, 5, 7, 10]);
+var BLUES_MASK = maskFromOffsets([0, 3, 5, 6, 7, 10]);
+var WHOLE_TONE_MASK = maskFromOffsets([0, 2, 4, 6, 8, 10]);
+var OCTATONIC_HALF_WHOLE_MASK = maskFromOffsets([0, 1, 3, 4, 6, 7, 9, 10]);
+var OCTATONIC_WHOLE_HALF_MASK = maskFromOffsets([0, 2, 3, 5, 6, 8, 9, 11]);
+var CHROMATIC_MASK = 4095;
+var NAMED_SCALES = {
+  major: MAJOR_MASK,
+  ionian: MAJOR_MASK,
+  naturalMinor: NATURAL_MINOR_MASK,
+  aeolian: NATURAL_MINOR_MASK,
+  harmonicMinor: HARMONIC_MINOR_MASK,
+  melodicMinor: MELODIC_MINOR_MASK,
+  dorian: DORIAN_MASK,
+  phrygian: PHRYGIAN_MASK,
+  lydian: LYDIAN_MASK,
+  mixolydian: MIXOLYDIAN_MASK,
+  locrian: LOCRIAN_MASK,
+  majorPentatonic: MAJOR_PENTATONIC_MASK,
+  minorPentatonic: MINOR_PENTATONIC_MASK,
+  blues: BLUES_MASK,
+  wholeTone: WHOLE_TONE_MASK,
+  octatonicHalfWhole: OCTATONIC_HALF_WHOLE_MASK,
+  octatonicWholeHalf: OCTATONIC_WHOLE_HALF_MASK,
+  chromatic: CHROMATIC_MASK
+};
+
+// src/theory/scale/key.ts
+function majorKey(rootPc) {
+  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: MAJOR_MASK };
+}
+function minorKey(rootPc) {
+  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: NATURAL_MINOR_MASK };
+}
+function scaleByName(name, rootPc) {
+  const mask = NAMED_SCALES[name];
+  if (mask === void 0) {
+    throw new Error(`Unknown scale: ${name}`);
+  }
+  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: mask };
+}
+
+// src/theory/chord/index.ts
+var QUALITY_INTERVALS = {
+  maj: [0, 4, 7],
+  min: [0, 3, 7],
+  dim: [0, 3, 6],
+  aug: [0, 4, 8],
+  majb5: [0, 4, 6],
+  maj7: [0, 4, 7, 11],
+  min7: [0, 3, 7, 10],
+  dom7: [0, 4, 7, 10],
+  dim7: [0, 3, 6, 9],
+  m7b5: [0, 3, 6, 10],
+  minMaj7: [0, 3, 7, 11],
+  aug7: [0, 4, 8, 10],
+  augMaj7: [0, 4, 8, 11],
+  "6": [0, 4, 7, 9],
+  min6: [0, 3, 7, 9],
+  "6/9": [0, 4, 7, 9, 14],
+  sus2: [0, 2, 7],
+  sus4: [0, 5, 7],
+  add9: [0, 4, 7, 14],
+  add11: [0, 4, 7, 17],
+  maj9: [0, 4, 7, 11, 14],
+  min9: [0, 3, 7, 10, 14],
+  dom9: [0, 4, 7, 10, 14],
+  "7b9": [0, 4, 7, 10, 13],
+  "7#9": [0, 4, 7, 10, 15],
+  "7#11": [0, 4, 7, 10, 18],
+  "7b13": [0, 4, 7, 10, 20],
+  "11": [0, 7, 10, 14, 17],
+  "13": [0, 4, 7, 10, 14, 21],
+  "5": [0, 7]
+};
+function pitchClass2(value) {
+  return (Math.trunc(value) % 12 + 12) % 12;
+}
+function chordQualities() {
+  return Object.keys(QUALITY_INTERVALS);
+}
+function chordFromDegree(degree, ext, key) {
+  const tones = scaleTonesInDegreeOrder(key);
+  const length = tones.length;
+  const index = length > 0 ? (degree % length + length) % length : 0;
+  const rootPc = tones[index] ?? pitchClass2(key.rootPc);
+  return { rootPc, quality: ext, intervals: [...QUALITY_INTERVALS[ext]] };
+}
+function makeChord(rootPc, quality, bassPc) {
+  const chord = {
+    rootPc: pitchClass2(rootPc),
+    quality,
+    intervals: [...QUALITY_INTERVALS[quality]]
+  };
+  if (bassPc !== void 0) {
+    chord.bassPc = pitchClass2(bassPc);
+  }
+  return chord;
+}
+function chordPitchClasses(chord) {
+  const set = /* @__PURE__ */ new Set();
+  for (const interval of chord.intervals) {
+    set.add(pitchClass2(chord.rootPc + interval));
+  }
+  return [...set].sort((a, b) => a - b);
+}
+function chordToneOffsets(chord) {
+  return new Set(chord.intervals.map((i) => (i % 12 + 12) % 12));
+}
+function chordToneRole(pitch, chord) {
+  const interval = (pitchClass2(pitch) - pitchClass2(chord.rootPc) + 12) % 12;
+  const tones = chordToneOffsets(chord);
+  if (interval === 0) {
+    return "root";
+  }
+  if (interval === 3 || interval === 4) {
+    return tones.has(interval) ? "third" : null;
+  }
+  if (interval === 7) {
+    return tones.has(7) ? "fifth" : null;
+  }
+  if (interval === 6) {
+    return tones.has(6) && !tones.has(7) ? "fifth" : null;
+  }
+  if (interval === 8) {
+    return tones.has(8) && !tones.has(7) ? "fifth" : null;
+  }
+  if (interval === 9) {
+    const hasHigherSeventh = tones.has(10) || tones.has(11);
+    const isDiminishedSeventh = tones.has(3) && tones.has(6) && !hasHigherSeventh;
+    if (isDiminishedSeventh) {
+      return "seventh";
+    }
+    if (tones.has(9) && !hasHigherSeventh) {
+      return "sixth";
+    }
+    return null;
+  }
+  if (interval === 10 || interval === 11) {
+    return tones.has(interval) ? "seventh" : null;
+  }
+  return null;
+}
+function classifyTriad(thirdIc, fifthIc) {
+  if (thirdIc === 4 && fifthIc === 8) {
+    return "aug";
+  }
+  if (thirdIc === 4 && fifthIc === 6) {
+    return "majb5";
+  }
+  if (thirdIc === 3 && fifthIc === 6) {
+    return "dim";
+  }
+  if (thirdIc === 3) {
+    return "min";
+  }
+  return "maj";
+}
+function classifySeventh(thirdIc, fifthIc, seventhIc) {
+  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 9) {
+    return "dim7";
+  }
+  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 10) {
+    return "m7b5";
+  }
+  if (thirdIc === 3 && seventhIc === 11) {
+    return "minMaj7";
+  }
+  if (thirdIc === 3) {
+    return "min7";
+  }
+  if (fifthIc === 8 && seventhIc === 10) {
+    return "aug7";
+  }
+  if (fifthIc === 8 && seventhIc === 11) {
+    return "augMaj7";
+  }
+  if (seventhIc === 11) {
+    return "maj7";
+  }
+  return "dom7";
+}
+function stackThirds(degree, key, size) {
+  const tones = scaleTonesInDegreeOrder(key);
+  const length = tones.length;
+  if (length === 0) {
+    return { rootPc: pitchClass2(key.rootPc), quality: "maj", intervals: [0, 4, 7] };
+  }
+  const idx = (step) => ((degree + step) % length + length) % length;
+  const rootPc = tones[idx(0)] ?? pitchClass2(key.rootPc);
+  const offsets = [0, 2, 4, 6].slice(0, size).map((step) => {
+    const pc = tones[idx(step)] ?? rootPc;
+    return ((pc - rootPc) % 12 + 12) % 12;
+  });
+  const thirdIc = offsets[1] ?? 4;
+  const fifthIc = offsets[2] ?? 7;
+  const quality = size === 3 ? classifyTriad(thirdIc, fifthIc) : classifySeventh(thirdIc, fifthIc, offsets[3] ?? 11);
+  return { rootPc, quality, intervals: offsets };
+}
+function diatonicTriad(degree, key) {
+  return stackThirds(degree, key, 3);
+}
+function diatonicSeventh(degree, key) {
+  return stackThirds(degree, key, 4);
+}
+
+// src/theory/chordscale/index.ts
+function pitchClass3(value) {
+  return (Math.trunc(value) % 12 + 12) % 12;
+}
+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 = pitchClass3(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;
+function chordScales(chord) {
+  const chordPcs = chordPitchClasses(chord);
+  const rootPc = pitchClass3(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 = NAMED_SCALES[name];
+    if (mask === void 0 || seenMasks.has(mask)) {
+      continue;
+    }
+    seenMasks.add(mask);
+    if (scaleMatchesChord(chordPcs, mask, rootPc)) {
+      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) => {
+    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;
+    }
+    if (a.size !== b.size) {
+      return a.size - b.size;
+    }
+    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 = NAMED_SCALES[scaleName];
+  if (mask === void 0) {
+    return [];
+  }
+  const rootPc = pitchClass3(chord.rootPc);
+  const chordPcs = chordPitchClasses(chord);
+  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {
+    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;
+    }
+    if (chordSet.has(pitchClass3(pc - 1))) {
+      avoid.push(pc);
+    }
+  }
+  return avoid.sort((a, b) => a - b);
+}
+function availableTensions(chord, scaleName) {
+  const mask = NAMED_SCALES[scaleName];
+  if (mask === void 0) {
+    return [];
+  }
+  const rootPc = pitchClass3(chord.rootPc);
+  const chordPcs = chordPitchClasses(chord);
+  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {
+    return [];
+  }
+  const chordSet = new Set(chordPcs);
+  const avoidSet = 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) {
+  const matches = chordScales(chord);
+  const chosen = limit === void 0 ? matches : matches.slice(0, Math.max(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 = NAMED_SCALES[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(pitchClass3(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) {
+  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/core/interval/index.ts
+function simpleInterval(semitones) {
+  return Math.abs(semitones) % 12;
+}
+function isConsonantInterval(semitones, twoVoice = true) {
+  const pc = simpleInterval(semitones);
+  if (pc === 5) {
+    return !twoVoice;
+  }
+  return pc === 0 || pc === 3 || pc === 4 || pc === 7 || pc === 8 || pc === 9;
+}
+
+// src/theory/counterpoint/index.ts
+function pitchClass4(pitch) {
+  return (Math.trunc(pitch) % 12 + 12) % 12;
+}
+function createsVoiceCrossing(upperPitch, lowerPitch) {
+  return upperPitch < lowerPitch;
+}
+function createsVerticalDissonance(a, b, twoVoice) {
+  return !isConsonantInterval(a - b, twoVoice);
+}
+function isForbiddenMelodicLeap(prev, cur) {
+  const semis = Math.abs(cur - prev);
+  return semis === 6 || semis === 10 || semis === 11 || semis > 12;
+}
+function simpleClass(semitones) {
+  return Math.abs(semitones) % 12;
+}
+function isPerfectClass(cls) {
+  return cls === 0 || cls === 7;
+}
+function similarMotion(aMove, bMove) {
+  return aMove !== 0 && bMove !== 0 && aMove > 0 === bMove > 0;
+}
+function bothVoicesMove(aMove, bMove) {
+  return aMove !== 0 && bMove !== 0;
+}
+function createsParallelPerfect(aPrev, aCur, bPrev, bCur) {
+  if (!bothVoicesMove(aCur - aPrev, bCur - bPrev)) {
+    return false;
+  }
+  const nowClass = simpleClass(aCur - bCur);
+  const prevClass = simpleClass(aPrev - bPrev);
+  return isPerfectClass(nowClass) && nowClass === prevClass;
+}
+function createsParallelOctave(aPrev, aCur, bPrev, bCur) {
+  if (!similarMotion(aCur - aPrev, bCur - bPrev)) {
+    return false;
+  }
+  return simpleClass(aCur - bCur) === 0 && simpleClass(aPrev - bPrev) === 0;
+}
+function createsParallelUnison(aPrev, aCur, bPrev, bCur) {
+  if (aCur === aPrev || bCur === bPrev) {
+    return false;
+  }
+  return aCur === bCur && aPrev === bPrev;
+}
+function createsHiddenParallelPerfect(aPrev, aCur, bPrev, bCur) {
+  const aMove = aCur - aPrev;
+  const bMove = bCur - bPrev;
+  if (!similarMotion(aMove, bMove)) {
+    return false;
+  }
+  const nowClass = simpleClass(aCur - bCur);
+  const prevClass = simpleClass(aPrev - bPrev);
+  if (!isPerfectClass(nowClass) || prevClass === nowClass) {
+    return false;
+  }
+  const upperMove = aCur >= bCur ? aMove : bMove;
+  if (Math.abs(upperMove) <= 2) {
+    return false;
+  }
+  return true;
+}
+function createsVoiceOverlap(upperPrev, upperCur, lowerPrev, lowerCur) {
+  return upperCur < lowerPrev || lowerCur > upperPrev;
+}
+function exceedsSpacing(upperPitch, lowerPitch, maxSemitones = 12) {
+  return Math.abs(upperPitch - lowerPitch) > maxSemitones;
+}
+function isLeadingToneResolution(prev, cur, key) {
+  const tonic = pitchClass4(key.rootPc);
+  const leading = (tonic + 11) % 12;
+  if (pitchClass4(prev) !== leading || pitchClass4(cur) !== tonic) {
+    return false;
+  }
+  return cur > prev && cur - prev <= 2;
+}
+
+// src/theory/harmony/index.ts
+function roleOf(pitch, chord, chordId = 0) {
+  const interval = ((Math.trunc(pitch) - chord.rootPc) % 12 + 12) % 12;
+  const tones = new Set(chord.intervals.map((i) => (i % 12 + 12) % 12));
+  const hasHigherSeventh = tones.has(10) || tones.has(11);
+  const hasThird = tones.has(3) || tones.has(4);
+  const isSuspendedTone = !hasThird && (interval === 5 && tones.has(5) || interval === 2 && tones.has(2));
+  let role;
+  let lock;
+  if (interval === 0) {
+    role = "root";
+    lock = "identity";
+  } else if (isSuspendedTone) {
+    role = "third";
+    lock = "quality";
+  } else if (interval === 3 || interval === 4) {
+    role = "third";
+    lock = "quality";
+  } else if (interval === 6 || interval === 7 || interval === 8) {
+    role = "fifth";
+    lock = "voicing";
+  } else if (interval === 9 && tones.has(3) && tones.has(6) && !hasHigherSeventh) {
+    role = "seventh";
+    lock = "voicing";
+  } else if (interval === 9 && tones.has(9) && !hasHigherSeventh) {
+    role = "sixth";
+    lock = "voicing";
+  } else if (interval === 10 || interval === 11) {
+    role = "seventh";
+    lock = "voicing";
+  } else {
+    role = "tension";
+    lock = "voicing";
+  }
+  return { role, lock, belongsToChordId: chordId };
+}
+
+// src/theory/safety/index.ts
+var NoteSafety = /* @__PURE__ */ ((NoteSafety2) => {
+  NoteSafety2[NoteSafety2["Safe"] = 0] = "Safe";
+  NoteSafety2[NoteSafety2["Warning"] = 1] = "Warning";
+  NoteSafety2[NoteSafety2["Dissonant"] = 2] = "Dissonant";
+  return NoteSafety2;
+})(NoteSafety || {});
+var ReasonFlag = /* @__PURE__ */ ((ReasonFlag2) => {
+  ReasonFlag2[ReasonFlag2["ChordTone"] = 1] = "ChordTone";
+  ReasonFlag2[ReasonFlag2["Tension"] = 2] = "Tension";
+  ReasonFlag2[ReasonFlag2["AvoidNote"] = 4] = "AvoidNote";
+  ReasonFlag2[ReasonFlag2["ScaleTone"] = 8] = "ScaleTone";
+  ReasonFlag2[ReasonFlag2["NonScale"] = 16] = "NonScale";
+  ReasonFlag2[ReasonFlag2["OutOfRange"] = 32] = "OutOfRange";
+  ReasonFlag2[ReasonFlag2["Tritone"] = 64] = "Tritone";
+  ReasonFlag2[ReasonFlag2["LargeLeap"] = 128] = "LargeLeap";
+  ReasonFlag2[ReasonFlag2["MinorSecond"] = 256] = "MinorSecond";
+  ReasonFlag2[ReasonFlag2["MajorSeventh"] = 512] = "MajorSeventh";
+  ReasonFlag2[ReasonFlag2["VerticalDissonance"] = 1024] = "VerticalDissonance";
+  ReasonFlag2[ReasonFlag2["ParallelPerfect"] = 2048] = "ParallelPerfect";
+  ReasonFlag2[ReasonFlag2["HiddenParallel"] = 4096] = "HiddenParallel";
+  ReasonFlag2[ReasonFlag2["VoiceCrossing"] = 8192] = "VoiceCrossing";
+  ReasonFlag2[ReasonFlag2["Suspension"] = 16384] = "Suspension";
+  ReasonFlag2[ReasonFlag2["NeedsResolution"] = 32768] = "NeedsResolution";
+  return ReasonFlag2;
+})(ReasonFlag || {});
+var SUGGESTION_WINDOW = 12;
+var MAX_SUGGESTIONS = 3;
+function pitchClass5(pitch) {
+  return (Math.trunc(pitch) % 12 + 12) % 12;
+}
+function intervalAboveRoot(pitch, chord) {
+  return ((pitchClass5(pitch) - pitchClass5(chord.rootPc)) % 12 + 12) % 12;
+}
+function isChordMember(pitch, chord) {
+  return chordPitchClasses(chord).includes(pitchClass5(pitch));
+}
+function avoidsFourth(chord) {
+  return chord.intervals.includes(4) && !chord.intervals.includes(5);
+}
+function avoidsMajorSeventh(chord) {
+  return chord.intervals.includes(4) && chord.intervals.includes(10);
+}
+function stepResolution(pitch, chord) {
+  for (let delta = 1; delta <= 2; delta += 1) {
+    if (isChordMember(pitch - delta, chord)) {
+      return pitch - delta;
+    }
+  }
+  return void 0;
+}
+function evaluateSafety(q) {
+  return evaluateInternal(q, true);
+}
+function evaluateInternal(q, collectSuggestions) {
+  let reasons = 0;
+  let level = 0 /* Safe */;
+  let resolveTo;
+  const raise = (l) => {
+    if (l > level) {
+      level = l;
+    }
+  };
+  const avoidSeverity = q.profile === "strict" ? 2 /* Dissonant */ : 1 /* Warning */;
+  const parallelSeverity = avoidSeverity;
+  const pitch = q.candidatePitch;
+  if (q.vocalLow !== void 0 && pitch < q.vocalLow || q.vocalHigh !== void 0 && pitch > q.vocalHigh) {
+    reasons |= 32 /* OutOfRange */;
+    raise(1 /* Warning */);
+  }
+  const inScale = isScaleTone(pitch, q.key);
+  const chord = q.chord;
+  if (chord && isChordMember(pitch, chord)) {
+    reasons |= 1 /* ChordTone */;
+  } else if (chord) {
+    const ic = intervalAboveRoot(pitch, chord);
+    const isTension = ic === 2 || ic === 5 || ic === 9;
+    const avoid = ic === 5 && avoidsFourth(chord) || ic === 11 && avoidsMajorSeventh(chord);
+    if (avoid) {
+      reasons |= 4 /* AvoidNote */;
+      if (isTension) {
+        reasons |= 2 /* Tension */;
+      }
+      reasons |= 32768 /* NeedsResolution */;
+      resolveTo = stepResolution(pitch, chord);
+      raise(avoidSeverity);
+    } else if (isTension && inScale) {
+      reasons |= 2 /* Tension */;
+      raise(1 /* Warning */);
+    } else if (inScale) {
+      reasons |= 8 /* ScaleTone */;
+      raise(1 /* Warning */);
+    } else {
+      reasons |= 16 /* NonScale */;
+      raise(2 /* Dissonant */);
+    }
+  } else if (inScale) {
+    reasons |= 8 /* ScaleTone */;
+    raise(1 /* Warning */);
+  } else {
+    reasons |= 16 /* NonScale */;
+    raise(2 /* Dissonant */);
+  }
+  if (chord && !(chord.intervals.includes(4) && chord.intervals.includes(10))) {
+    const ic = intervalAboveRoot(pitch, chord);
+    const toneOffsets = chord.intervals.map((i) => (i % 12 + 12) % 12);
+    if (toneOffsets.some((t) => Math.abs(ic - t) === 6)) {
+      reasons |= 64 /* Tritone */;
+    }
+  }
+  if (q.prevPitch !== void 0) {
+    const pc = Math.abs(pitch - q.prevPitch) % 12;
+    if (pc === 6) {
+      reasons |= 64 /* Tritone */;
+    }
+    if (isForbiddenMelodicLeap(q.prevPitch, pitch)) {
+      reasons |= 128 /* LargeLeap */;
+    }
+    if (pc === 1) {
+      reasons |= 256 /* MinorSecond */;
+    }
+    if (pc === 11) {
+      reasons |= 512 /* MajorSeventh */;
+    }
+  }
+  if (q.strongBeat) {
+    const twoVoice = q.otherVoices.length === 1;
+    const prev = q.prevPitch;
+    for (const ov of q.otherVoices) {
+      if (!createsVerticalDissonance(pitch, ov.pitch, twoVoice)) {
+        continue;
+      }
+      reasons |= 1024 /* VerticalDissonance */;
+      raise(2 /* Dissonant */);
+      if (prev !== void 0 && pitch === prev && ov.prevPitch !== void 0 && !createsVerticalDissonance(prev, ov.prevPitch, twoVoice)) {
+        reasons |= 16384 /* Suspension */;
+      }
+    }
+  }
+  if (q.prevPitch !== void 0) {
+    const prev = q.prevPitch;
+    for (const ov of q.otherVoices) {
+      if (ov.prevPitch === void 0) {
+        continue;
+      }
+      if (createsParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
+        reasons |= 2048 /* ParallelPerfect */;
+        raise(parallelSeverity);
+      }
+      if (createsHiddenParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
+        reasons |= 4096 /* HiddenParallel */;
+        raise(parallelSeverity);
+      }
+      const crossedNow = pitch - ov.pitch;
+      const crossedPrev = prev - ov.prevPitch;
+      if (crossedNow !== 0 && crossedPrev !== 0 && crossedNow > 0 !== crossedPrev > 0) {
+        reasons |= 8192 /* VoiceCrossing */;
+        raise(parallelSeverity);
+      }
+    }
+  }
+  const result = { safety: level, reasons, rationale: describe(reasons, q) };
+  if (resolveTo !== void 0) {
+    result.resolveTo = resolveTo;
+  }
+  if (collectSuggestions && level !== 0 /* Safe */) {
+    const suggestions = findSafeNearby(q, pitch);
+    if (suggestions.length > 0) {
+      result.suggestions = suggestions;
+    }
+  }
+  return result;
+}
+function findSafeNearby(q, candidate) {
+  const out = [];
+  for (let d = 1; d <= SUGGESTION_WINDOW; d += 1) {
+    for (const p of [candidate - d, candidate + d]) {
+      if (evaluateInternal({ ...q, candidatePitch: p }, false).safety === 0 /* Safe */) {
+        out.push(p);
+        if (out.length >= MAX_SUGGESTIONS) {
+          return out;
+        }
+      }
+    }
+  }
+  return out;
+}
+function describe(reasons, q) {
+  if (reasons & 32 /* OutOfRange */) {
+    return "Outside the target vocal range";
+  }
+  if (reasons & 16384 /* Suspension */) {
+    return "Prepared suspension \u2014 a held consonance now dissonant, awaiting resolution";
+  }
+  if (reasons & 1024 /* VerticalDissonance */) {
+    return "Dissonant against a sounding voice on a strong beat";
+  }
+  if (reasons & 4 /* AvoidNote */) {
+    return "Avoid note \u2014 clashes with a chord tone a semitone away";
+  }
+  if (reasons & 2048 /* ParallelPerfect */) {
+    return "Parallel perfect interval with another voice";
+  }
+  if (reasons & 4096 /* HiddenParallel */) {
+    return "Hidden perfect interval by similar motion";
+  }
+  if (reasons & 8192 /* VoiceCrossing */) {
+    return "Crosses another voice";
+  }
+  if (reasons & 1 /* ChordTone */) {
+    return "Chord tone";
+  }
+  if (reasons & 2 /* Tension */) {
+    return "Chord tension";
+  }
+  if (reasons & 16 /* NonScale */) {
+    return "Outside the key";
+  }
+  if (reasons & 8 /* ScaleTone */) {
+    return "Scale tone, not in the chord";
+  }
+  return q.chord ? "Placeable" : "No chord context";
+}
+function enumerateSafePitches(q, pitchLow, pitchHigh) {
+  const chordTones = [];
+  const others = [];
+  if (!Number.isFinite(pitchLow) || !Number.isFinite(pitchHigh)) {
+    return [];
+  }
+  for (let pitch = pitchHigh; pitch >= pitchLow; pitch -= 1) {
+    const result = evaluateInternal({ ...q, candidatePitch: pitch }, false);
+    if (result.safety === 2 /* Dissonant */) {
+      continue;
+    }
+    if (result.reasons & 1 /* ChordTone */) {
+      chordTones.push(pitch);
+    } else {
+      others.push(pitch);
+    }
+  }
+  return [...chordTones, ...others];
+}
+
+// src/core/pitch/index.ts
+var LETTER_SEMITONES = [0, 2, 4, 5, 7, 9, 11];
+var LETTER_NAMES = ["C", "D", "E", "F", "G", "A", "B"];
+function mod12(n) {
+  return (n % 12 + 12) % 12;
+}
+function mod7(n) {
+  return (n % 7 + 7) % 7;
+}
+function parseNote(text) {
+  const match = /^([A-Ga-g])([#x]*|b*)(-?\d+)?$/.exec(text.trim());
+  if (!match) {
+    throw new Error(`Invalid note: ${text}`);
+  }
+  const letterGlyph = (match[1] ?? "").toUpperCase();
+  const letter = LETTER_NAMES.indexOf(letterGlyph);
+  let alter = 0;
+  for (const ch of match[2] ?? "") {
+    if (ch === "#") {
+      alter += 1;
+    } else if (ch === "x") {
+      alter += 2;
+    } else if (ch === "b") {
+      alter -= 1;
+    }
+  }
+  const note = { letter, alter };
+  if (match[3] !== void 0) {
+    note.octave = Number.parseInt(match[3], 10);
+  }
+  return note;
+}
+function formatAlter(alter) {
+  if (alter > 0) {
+    return "#".repeat(alter);
+  }
+  if (alter < 0) {
+    return "b".repeat(-alter);
+  }
+  return "";
+}
+function formatNote(note) {
+  const glyph = LETTER_NAMES[mod7(note.letter)] ?? "C";
+  const octave = note.octave === void 0 ? "" : String(note.octave);
+  return `${glyph}${formatAlter(note.alter)}${octave}`;
+}
+function noteToPitchClass(note) {
+  const natural = LETTER_SEMITONES[mod7(note.letter)] ?? 0;
+  return mod12(natural + note.alter);
+}
+var SHARP_SPELLING = [
+  [0, 0],
+  [0, 1],
+  [1, 0],
+  [1, 1],
+  [2, 0],
+  [3, 0],
+  [3, 1],
+  [4, 0],
+  [4, 1],
+  [5, 0],
+  [5, 1],
+  [6, 0]
+];
+var FLAT_SPELLING = [
+  [0, 0],
+  [1, -1],
+  [1, 0],
+  [2, -1],
+  [2, 0],
+  [3, 0],
+  [4, -1],
+  [4, 0],
+  [5, -1],
+  [5, 0],
+  [6, -1],
+  [6, 0]
+];
+function midiToNote(midi, spelling = "sharp") {
+  const rounded = Math.round(midi);
+  const pc = mod12(rounded);
+  const octave = Math.floor(rounded / 12) - 1;
+  const table = spelling === "sharp" ? SHARP_SPELLING : FLAT_SPELLING;
+  const entry = table[pc] ?? [0, 0];
+  return { letter: entry[0], alter: entry[1], octave };
+}
+
+// src/theory/spelling/index.ts
+var LETTER_SEMITONES2 = [0, 2, 4, 5, 7, 9, 11];
+var CHROMATIC_SPELLING = {
+  1: { degreeOffset: 1, alter: -1 },
+  // b2
+  3: { degreeOffset: 2, alter: -1 },
+  // b3
+  6: { degreeOffset: 3, alter: 1 },
+  // #4
+  8: { degreeOffset: 5, alter: -1 },
+  // b6
+  9: { degreeOffset: 5, alter: 1 },
+  // #6 (raised sixth of a minor key)
+  10: { degreeOffset: 6, alter: -1 },
+  // b7
+  11: { degreeOffset: 6, alter: 1 }
+  // #7 (raised leading tone of a minor key)
+};
+function mod122(n) {
+  return (n % 12 + 12) % 12;
+}
+function mod72(n) {
+  return (n % 7 + 7) % 7;
+}
+function naturalPc(letter) {
+  return LETTER_SEMITONES2[mod72(letter)] ?? 0;
+}
+function alterFor(letter, pc) {
+  let d = mod122(pc - naturalPc(letter));
+  if (d > 6) {
+    d -= 12;
+  }
+  return d;
+}
+function isHeptatonic(key) {
+  return scaleTonesInDegreeOrder(key).length === 7;
+}
+function spellPitchClass(pc, tonic, key) {
+  const tonicPc = mod122(naturalPc(tonic.letter) + tonic.alter);
+  const offset = mod122(pc - tonicPc);
+  const tones = scaleTonesInDegreeOrder(key);
+  if (isHeptatonic(key)) {
+    const degree = tones.indexOf(mod122(pc));
+    if (degree >= 0) {
+      const letter = mod72(tonic.letter + degree);
+      return { letter, alter: alterFor(letter, pc) };
+    }
+    const chromatic = CHROMATIC_SPELLING[offset];
+    if (chromatic) {
+      const letter = mod72(tonic.letter + chromatic.degreeOffset);
+      return { letter, alter: alterFor(letter, pc) };
+    }
+  }
+  for (let letter = 0; letter < 7; letter += 1) {
+    if (naturalPc(letter) === mod122(pc)) {
+      return { letter, alter: 0 };
+    }
+  }
+  const belowLetter = mod72([0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6][mod122(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 spellChord(chord, tonic, key) {
+  return chord.intervals.map(
+    (interval) => spellPitchClass(mod122(chord.rootPc + interval), tonic, key)
+  );
+}
+function noteNames(notes) {
+  return notes.map(formatNote);
+}
+
+// src/theory/symbol/index.ts
+var ROOT_RE = /^[A-Ga-g](?:#{1,2}|b{1,2})?/;
+var BASS_RE = /^[A-Ga-g](?:#{1,2}|b{1,2})?$/;
+var QUALITY_MAP = {
+  "": "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",
+  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"
+};
+var CANONICAL_SUFFIX = {
+  maj: "",
+  min: "m",
+  dim: "dim",
+  aug: "aug",
+  maj7: "maj7",
+  min7: "m7",
+  dom7: "7",
+  dim7: "dim7",
+  m7b5: "m7b5",
+  minMaj7: "mMaj7",
+  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"
+};
+function pitchClass6(value) {
+  return (Math.trunc(value) % 12 + 12) % 12;
+}
+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();
+  const rootMatch = ROOT_RE.exec(trimmed);
+  if (!rootMatch) {
+    throw new Error(`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 = QUALITY_MAP[before];
+    if (beforeQuality !== void 0 && BASS_RE.test(after)) {
+      return makeSpelledChord(rootNote, beforeQuality, parseNote(after));
+    }
+  }
+  const quality = QUALITY_MAP[rest];
+  if (quality === void 0) {
+    throw new Error(`Unrecognized chord quality: ${text}`);
+  }
+  return makeSpelledChord(rootNote, quality);
+}
+function pitchClassName(pc, hint, flats) {
+  if (flats === void 0 && hint !== void 0 && noteToPitchClass(hint) === pc) {
+    return formatNote(hint);
+  }
+  const note = midiToNote(60 + pc, flats ? "flat" : "sharp");
+  return formatNote({ letter: note.letter, alter: note.alter });
+}
+function formatChordSymbol(chord, opts) {
+  const rootPc = pitchClass6(chord.rootPc);
+  const rootName = pitchClassName(rootPc, chord.rootSpelling, opts?.flats);
+  const suffix = CANONICAL_SUFFIX[chord.quality];
+  let symbol = `${rootName}${suffix}`;
+  if (chord.bassPc !== void 0 && pitchClass6(chord.bassPc) !== rootPc) {
+    symbol += `/${pitchClassName(pitchClass6(chord.bassPc), chord.bassSpelling, opts?.flats)}`;
+  }
+  return symbol;
+}
+function transposeChordSymbol(text, semitones, opts) {
+  const chord = parseChordSymbol(text);
+  const transposed = { ...chord, rootPc: pitchClass6(chord.rootPc + semitones) };
+  if (chord.bassPc !== void 0) {
+    transposed.bassPc = pitchClass6(chord.bassPc + semitones);
+  }
+  return formatChordSymbol(transposed, opts);
+}
+
+// src/theory/voicing/internal.ts
+var DEFAULT_MAX_SPACING = 12;
+var VIOLATION_PENALTY = 1e3;
+var MISSING_TONE_PENALTY = 500;
+var POOR_DOUBLING_PENALTY = 4;
+var MAX_CANDIDATES = 4e3;
+function pitchClass7(value) {
+  return (Math.trunc(value) % 12 + 12) % 12;
+}
+function pitchesForPc(pc, range) {
+  const result = [];
+  for (let midi = Math.ceil(range.min); midi <= range.max; midi += 1) {
+    if (pitchClass7(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) {
+  const chordPcs = chordPitchClasses(chord);
+  const bassPc = pitchClass7(chord.bassPc ?? chord.rootPc);
+  const results = [];
+  const current = [];
+  const build = (voice) => {
+    if (results.length >= MAX_CANDIDATES) {
+      return;
+    }
+    if (voice === ranges.length) {
+      results.push([...current]);
+      return;
+    }
+    const range = ranges[voice];
+    if (range === void 0) {
+      return;
+    }
+    const pcs = voice === 0 ? [bassPc] : chordPcs;
+    const prev = current[voice - 1];
+    for (const pc of pcs) {
+      for (const pitch of pitchesForPc(pc, range)) {
+        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) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const pitch of pitches) {
+    const pc = pitchClass7(pitch);
+    counts.set(pc, (counts.get(pc) ?? 0) + 1);
+  }
+  let penalty = 0;
+  for (const pc of chordPitchClasses(chord)) {
+    if (!counts.has(pc)) {
+      penalty += MISSING_TONE_PENALTY;
+    }
+  }
+  const rootPc = pitchClass7(chord.rootPc);
+  const fifthPc = pitchClass7(chord.rootPc + 7);
+  for (const [pc, count] of counts) {
+    if (count > 1 && pc !== rootPc && pc !== fifthPc) {
+      penalty += (count - 1) * POOR_DOUBLING_PENALTY;
+    }
+  }
+  return penalty;
+}
+function violationCount(prev, cur, maxSpacing) {
+  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 (createsVoiceCrossing(curUpper, curLower)) {
+        count += 1;
+      }
+      if (upper === lower + 1) {
+        if (createsVoiceOverlap(prevUpper, curUpper, prevLower, curLower)) {
+          count += 1;
+        }
+        if (lower > 0 && exceedsSpacing(curUpper, curLower, maxSpacing)) {
+          count += 1;
+        }
+      }
+    }
+  }
+  return count;
+}
+
+// src/theory/voicing/satb.ts
+var SATB_RANGES = [
+  { min: 40, max: 60 },
+  { min: 48, max: 67 },
+  { min: 55, max: 74 },
+  { 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 Error("ranges must contain at least one voice range");
+    }
+    return opts.ranges.map((range) => ({ ...range }));
+  }
+  const voices = opts?.voices ?? 4;
+  if (voices < 1) {
+    throw new Error("voices must be at least 1");
+  }
+  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 voiceChord(chord, opts) {
+  const ranges = resolveRanges(opts);
+  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;
+  const candidates = enumerateVoicings(chord, ranges, maxSpacing);
+  let best;
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    let score = structuralPenalty(candidate, chord);
+    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 Error("no voicing satisfies the given ranges");
+  }
+  return best;
+}
+function voiceProgression(chords, opts) {
+  const ranges = resolveRanges(opts);
+  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;
+  const result = [];
+  let prev;
+  for (const chord of chords) {
+    if (prev === void 0) {
+      prev = voiceChord(chord, opts);
+      result.push(prev);
+      continue;
+    }
+    const candidates = enumerateVoicings(chord, ranges, maxSpacing);
+    let best;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+      const score = structuralPenalty(candidate, chord) + voiceLeadingCost(prev, candidate) + VIOLATION_PENALTY * violationCount(prev, candidate, maxSpacing);
+      if (score < bestScore) {
+        bestScore = score;
+        best = candidate;
+      }
+    }
+    if (best === void 0) {
+      throw new Error("no voicing satisfies the given ranges");
+    }
+    result.push(best);
+    prev = best;
+  }
+  return result;
+}
+
+// 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 ranges = opts?.ranges !== void 0 || opts?.voices !== void 0 ? resolveRanges(opts) : 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) };
+  });
+  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;
+  const candidates = enumerateVoicings(chord, ranges, maxSpacing);
+  let best;
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    const score = structuralPenalty(candidate, chord) + voiceLeadingCost(current, candidate) + VIOLATION_PENALTY * violationCount(current, candidate, maxSpacing);
+    if (score < bestScore) {
+      bestScore = score;
+      best = candidate;
+    }
+  }
+  if (best === void 0) {
+    throw new Error("no voicing satisfies the given ranges");
+  }
+  return best;
+}
+
+// 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 - pitchClass7(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 base = 12 * ((opts?.octave ?? DEFAULT_STYLE_OCTAVE) + 1);
+  const rootPc = pitchClass7(chord.rootPc);
+  const bassPc = pitchClass7(chord.bassPc ?? chord.rootPc);
+  const omitRoot = style === "rootless" || opts?.rootless === true;
+  let order = dedupePcs(chord.intervals.map((interval) => pitchClass7(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 role === "root" || role === "third" || role === guide;
+    });
+  }
+  if (omitRoot) {
+    order = order.filter((pc) => pc !== rootPc);
+  }
+  if (order.length === 0) {
+    return [];
+  }
+  if (opts?.topNote !== void 0) {
+    const target = order.includes(pitchClass7(opts.topNote)) ? pitchClass7(opts.topNote) : nearestPc(pitchClass7(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 - pitchClass7(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;
+  }
+  return stack.sort((a, b) => a - b);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BLUES_MASK,
+  CHROMATIC_MASK,
+  DORIAN_MASK,
+  HARMONIC_MINOR_MASK,
+  LOCRIAN_MASK,
+  LYDIAN_MASK,
+  MAJOR_MASK,
+  MAJOR_PENTATONIC_MASK,
+  MELODIC_MINOR_MASK,
+  MINOR_PENTATONIC_MASK,
+  MIXOLYDIAN_MASK,
+  NAMED_SCALES,
+  NATURAL_MINOR_MASK,
+  NoteSafety,
+  OCTATONIC_HALF_WHOLE_MASK,
+  OCTATONIC_WHOLE_HALF_MASK,
+  PHRYGIAN_MASK,
+  ReasonFlag,
+  SATB_RANGES,
+  WHOLE_TONE_MASK,
+  availableTensions,
+  avoidNotes,
+  chordFromDegree,
+  chordPitchClasses,
+  chordQualities,
+  chordScaleReport,
+  chordScales,
+  chordToneRole,
+  createsHiddenParallelPerfect,
+  createsParallelOctave,
+  createsParallelPerfect,
+  createsParallelUnison,
+  createsVerticalDissonance,
+  createsVoiceCrossing,
+  createsVoiceOverlap,
+  diatonicPitchClasses,
+  diatonicSeventh,
+  diatonicTriad,
+  enumerateSafePitches,
+  evaluateSafety,
+  exceedsSpacing,
+  formatChordSymbol,
+  isForbiddenMelodicLeap,
+  isLeadingToneResolution,
+  isScaleTone,
+  majorKey,
+  makeChord,
+  maskFromOffsets,
+  minorKey,
+  nearestScaleTone,
+  nextVoicing,
+  noteNames,
+  parseChordSymbol,
+  pitchToScaleDegree,
+  roleOf,
+  scaleByName,
+  scaleMatchesChord,
+  scaleTonesInDegreeOrder,
+  scalesForChanges,
+  spellChord,
+  spellPitchClass,
+  spellPitchClasses,
+  spellScale,
+  transposeChordSymbol,
+  voiceChord,
+  voiceChordStyled,
+  voiceLeadingCost,
+  voiceProgression
+});
+//# sourceMappingURL=index.cjs.map