@libraz/libcantus 0.9.0 → 0.9.2

package/dist/chunk-XTC3X6MS.js

@@ -0,0 +1,816 @@
+import {
+  formatNote,
+  midiToNote,
+  noteToPitchClass,
+  parseNote
+} from "./chunk-DYWFNC4A.js";
+import {
+  NAMED_SCALES,
+  chordPitchClasses,
+  chordToneRole,
+  createsHiddenParallelPerfect,
+  createsParallelPerfect,
+  createsVoiceCrossing,
+  createsVoiceOverlap,
+  exceedsSpacing,
+  makeChord,
+  scaleTonesInDegreeOrder
+} from "./chunk-7Y7WF64D.js";
+
+// src/theory/chordscale/index.ts
+function pitchClass(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 = pitchClass(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 = pitchClass(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 = pitchClass(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(pitchClass(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 = pitchClass(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(pitchClass(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/theory/spelling/index.ts
+var LETTER_SEMITONES = [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 mod12(n) {
+  return (n % 12 + 12) % 12;
+}
+function mod7(n) {
+  return (n % 7 + 7) % 7;
+}
+function naturalPc(letter) {
+  return LETTER_SEMITONES[mod7(letter)] ?? 0;
+}
+function alterFor(letter, pc) {
+  let d = mod12(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 = mod12(naturalPc(tonic.letter) + tonic.alter);
+  const offset = mod12(pc - tonicPc);
+  const tones = scaleTonesInDegreeOrder(key);
+  if (isHeptatonic(key)) {
+    const degree = tones.indexOf(mod12(pc));
+    if (degree >= 0) {
+      const letter = mod7(tonic.letter + degree);
+      return { letter, alter: alterFor(letter, pc) };
+    }
+    const chromatic = CHROMATIC_SPELLING[offset];
+    if (chromatic) {
+      const letter = mod7(tonic.letter + chromatic.degreeOffset);
+      return { letter, alter: alterFor(letter, pc) };
+    }
+  }
+  for (let letter = 0; letter < 7; letter += 1) {
+    if (naturalPc(letter) === mod12(pc)) {
+      return { letter, alter: 0 };
+    }
+  }
+  const belowLetter = mod7([0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6][mod12(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(mod12(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 pitchClass2(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 = pitchClass2(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 && pitchClass2(chord.bassPc) !== rootPc) {
+    symbol += `/${pitchClassName(pitchClass2(chord.bassPc), chord.bassSpelling, opts?.flats)}`;
+  }
+  return symbol;
+}
+function transposeChordSymbol(text, semitones, opts) {
+  const chord = parseChordSymbol(text);
+  const transposed = { ...chord, rootPc: pitchClass2(chord.rootPc + semitones) };
+  if (chord.bassPc !== void 0) {
+    transposed.bassPc = pitchClass2(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 pitchClass3(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 (pitchClass3(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 = pitchClass3(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 = pitchClass3(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 = pitchClass3(chord.rootPc);
+  const fifthPc = pitchClass3(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/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/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/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 - pitchClass3(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 = pitchClass3(chord.rootPc);
+  const bassPc = pitchClass3(chord.bassPc ?? chord.rootPc);
+  const omitRoot = style === "rootless" || opts?.rootless === true;
+  let order = dedupePcs(chord.intervals.map((interval) => pitchClass3(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(pitchClass3(opts.topNote)) ? pitchClass3(opts.topNote) : nearestPc(pitchClass3(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 - pitchClass3(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);
+}
+
+export {
+  scaleMatchesChord,
+  chordScales,
+  avoidNotes,
+  availableTensions,
+  chordScaleReport,
+  scalesForChanges,
+  spellPitchClass,
+  spellScale,
+  spellPitchClasses,
+  spellChord,
+  noteNames,
+  parseChordSymbol,
+  formatChordSymbol,
+  transposeChordSymbol,
+  SATB_RANGES,
+  voiceChord,
+  voiceProgression,
+  voiceLeadingCost,
+  nextVoicing,
+  voiceChordStyled
+};
+//# sourceMappingURL=chunk-XTC3X6MS.js.map