@libraz/libcantus 0.9.4 → 1.0.0

package/dist/chunk-H3VORETI.js

@@ -0,0 +1,2243 @@
+import {
+  NAMED_SCALES,
+  chordPitchClasses,
+  chordQualities,
+  chordToneRole,
+  classifySpelledInterval,
+  createsBattuta,
+  createsHiddenParallelPerfect,
+  createsParallelPerfect,
+  createsVoiceCrossing,
+  createsVoiceOverlap,
+  exceedsSpacing,
+  formatChordSymbol,
+  isAugmentedMelodicInterval,
+  isForbiddenMelodicLeap,
+  isLeadingToneResolution,
+  makeChord,
+  namedScaleMask,
+  noteNames,
+  requireScaleMask,
+  scaleTonesInDegreeOrder,
+  simpleIntervalNumber,
+  spellChord,
+  spellPitch,
+  spellScale,
+  spelledKeyOf,
+  toChordData,
+  toKeyScale
+} from "./chunk-INHVXP6Z.js";
+import {
+  InvalidInputError,
+  NoSolutionError,
+  assertFiniteNumber,
+  assertGenerationBudget,
+  assertInteger,
+  assertPositiveInt,
+  diatonicLetterOf,
+  formatNote,
+  noteToMidi,
+  noteToPitchClass,
+  parseInterval,
+  pitchClassOf,
+  spelledInterval,
+  toNoteData,
+  toSpelledInterval,
+  transposeByInterval
+} from "./chunk-VTI6FOLB.js";
+
+// src/theory/transposition/index.ts
+var TRANSPOSING_INSTRUMENTS = Object.freeze({
+  // In B flat: a written C sounds B flat. The lower members of the family read
+  // in the same key an octave higher, so their interval is the compound one.
+  clarinetBb: "-M2",
+  trumpetBb: "-M2",
+  sopranoSax: "-M2",
+  tenorSax: "-M9",
+  bassClarinet: "-M9",
+  // In A: a written C sounds A.
+  clarinetA: "-m3",
+  // In F: a written C sounds F.
+  hornF: "-P5",
+  englishHorn: "-P5",
+  // In E flat: one key, three registers. The sopranino clarinet sounds above
+  // what it reads, the alto saxophone a major sixth below, and the baritone
+  // saxophone an octave below that.
+  clarinetEb: "m3",
+  altoSax: "-M6",
+  baritoneSax: "-M13",
+  // In D: a written C sounds D.
+  trumpetD: "M2",
+  // Octave transposers: the instrument is in C, only the register moves.
+  piccolo: "P8",
+  doubleBass: "-P8",
+  contrabassoon: "-P8",
+  guitar: "-P8"
+});
+function instrumentTransposition(instrument) {
+  if (typeof instrument !== "string") {
+    return toSpelledInterval(instrument);
+  }
+  if (Object.hasOwn(TRANSPOSING_INSTRUMENTS, instrument)) {
+    return parseInterval(TRANSPOSING_INSTRUMENTS[instrument]);
+  }
+  try {
+    return parseInterval(instrument);
+  } catch (error) {
+    if (error instanceof InvalidInputError) {
+      throw new InvalidInputError(
+        `unknown transposing instrument ${JSON.stringify(instrument)}; pass a name from TRANSPOSING_INSTRUMENTS or an interval such as '-M2'`
+      );
+    }
+    throw error;
+  }
+}
+function reversedInterval(step) {
+  const reversed = {
+    number: step.number,
+    quality: step.quality,
+    // Negating a zero span yields -0, which compares unequal to 0 under Object.is.
+    semitones: step.semitones === 0 ? 0 : -step.semitones
+  };
+  if (!(step.descending ?? step.semitones < 0)) {
+    reversed.descending = true;
+  }
+  return reversed;
+}
+function toSoundingPitch(note, instrument) {
+  return transposeByInterval(toNoteData(note), instrumentTransposition(instrument));
+}
+function toWrittenPitch(note, instrument) {
+  return transposeByInterval(
+    toNoteData(note),
+    reversedInterval(instrumentTransposition(instrument))
+  );
+}
+
+// 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"],
+  // The diminished scale played over a diminished seventh is the whole-half
+  // octatonic. Its half-whole rotation belongs to the dominant it colours: over
+  // a diminished seventh every one of its non-chord tones lands a semitone
+  // above a chord tone, so it offers no tension at all.
+  dim7: ["octatonicWholeHalf"],
+  minMaj7: ["melodicMinor"]
+};
+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 data = toChordData(chord);
+  const chordPcs = chordPitchClasses(data);
+  const rootPc = pitchClassOf(data.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(data, name)) {
+      const size = popcount12(mask);
+      ranked.push({
+        name,
+        extra: size - chordPcs.length,
+        size,
+        avoid: avoidNotes(data, name).length
+      });
+    }
+  }
+  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(data, a.name);
+    const idiomaticB = idiomaticRank(data, 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;
+    }
+    if (a.avoid !== b.avoid) {
+      return a.avoid - b.avoid;
+    }
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+  });
+  return ranked.map((entry) => ({ name: entry.name, rootPc }));
+}
+function suspendedTone(chordPcs, rootPc) {
+  const sounds = (semitones) => chordPcs.includes(pitchClassOf(rootPc + semitones));
+  if (sounds(3) || sounds(4)) {
+    return void 0;
+  }
+  if (sounds(5)) {
+    return pitchClassOf(rootPc + 5);
+  }
+  if (sounds(2)) {
+    return pitchClassOf(rootPc + 2);
+  }
+  return void 0;
+}
+function avoidNotes(chord, scaleName, opts = {}) {
+  const mask = requireScaleMask(scaleName);
+  const data = toChordData(chord);
+  const rootPc = pitchClassOf(data.rootPc);
+  const chordPcs = chordPitchClasses(data);
+  const alteredDominant = isAlteredDominant(data, scaleName);
+  if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {
+    return [];
+  }
+  const chordSet = new Set(chordPcs);
+  const suspended = suspendedTone(chordPcs, rootPc);
+  const displacedThird = suspended === void 0 ? void 0 : pitchClassOf(suspended - 1);
+  const melodic = opts.use === "melodic";
+  const semitoneAboveRoot = pitchClassOf(rootPc + 1);
+  const avoid = [];
+  for (let pc = 0; pc < 12; pc += 1) {
+    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
+      continue;
+    }
+    if (melodic && pc !== semitoneAboveRoot) {
+      continue;
+    }
+    if (!alteredDominant && (chordSet.has(pitchClassOf(pc - 1)) || pc === displacedThird)) {
+      avoid.push(pc);
+    }
+  }
+  return avoid.sort((a, b) => a - b);
+}
+var MINOR_RESOLUTION_TENSIONS = [1, 3, 8];
+function resolvesToMinorTonic(chord, chordPcs, target) {
+  if (target === void 0) {
+    return false;
+  }
+  const rootPc = pitchClassOf(chord.rootPc);
+  const sounds = (semitones) => chordPcs.includes(pitchClassOf(rootPc + semitones));
+  if (!sounds(4) || !sounds(10)) {
+    return false;
+  }
+  const targetRootPc = pitchClassOf(target.rootPc);
+  if (targetRootPc !== pitchClassOf(rootPc + 5)) {
+    return false;
+  }
+  return chordPitchClasses(target).includes(pitchClassOf(targetRootPc + 3));
+}
+function availableTensions(chord, scaleName, opts = {}) {
+  const mask = requireScaleMask(scaleName);
+  const data = toChordData(chord);
+  const rootPc = pitchClassOf(data.rootPc);
+  const chordPcs = chordPitchClasses(data);
+  const alteredDominant = isAlteredDominant(data, scaleName);
+  if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {
+    return [];
+  }
+  const chordSet = new Set(chordPcs);
+  const avoidSet = alteredDominant ? /* @__PURE__ */ new Set() : new Set(avoidNotes(data, scaleName));
+  const functional = resolvesToMinorTonic(
+    data,
+    chordPcs,
+    opts.resolvesTo === void 0 ? void 0 : toChordData(opts.resolvesTo)
+  ) ? new Set(MINOR_RESOLUTION_TENSIONS.map((semitones) => pitchClassOf(rootPc + semitones))) : void 0;
+  const tensions = [];
+  for (let pc = 0; pc < 12; pc += 1) {
+    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
+      continue;
+    }
+    if (avoidSet.has(pc) && functional?.has(pc) !== true) {
+      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 data = toChordData(chord);
+  const matches = chordScales(data);
+  const chosen = limit === void 0 ? matches : matches.slice(0, limit);
+  return chosen.map((match) => {
+    const harmonic = avoidNotes(data, match.name);
+    const melodic = new Set(avoidNotes(data, match.name, { use: "melodic" }));
+    return {
+      name: match.name,
+      rootPc: match.rootPc,
+      avoid: harmonic.filter((pc) => melodic.has(pc)),
+      passing: harmonic.filter((pc) => !melodic.has(pc)),
+      tensions: availableTensions(data, 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/figured-bass/index.ts
+var MIN_FIGURE_NUMBER = 2;
+var MAX_FIGURE_NUMBER = 9;
+var OCTAVE_FIGURE = 8;
+var MAX_STACK_SIZE = 4;
+var DOUBLE_ACCIDENTALS = {
+  "##": "doubleSharp",
+  "\u266F\u266F": "doubleSharp",
+  bb: "doubleFlat",
+  "\u266D\u266D": "doubleFlat"
+};
+var SINGLE_ACCIDENTALS = {
+  "#": "sharp",
+  "\u266F": "sharp",
+  "+": "sharp",
+  b: "flat",
+  "\u266D": "flat",
+  n: "natural",
+  "\u266E": "natural"
+};
+var FIGURE_SEPARATORS = /* @__PURE__ */ new Set([" ", "	", ",", "/"]);
+var MOTION_MARKS = /* @__PURE__ */ new Set(["-", "\u2013"]);
+var ACCIDENTAL_GLYPHS = {
+  1: "#",
+  2: "##",
+  "-1": "b",
+  "-2": "bb"
+};
+function invalidFigures(figures, detail) {
+  return new InvalidInputError(`figured bass ${JSON.stringify(figures)} ${detail}`);
+}
+function alteredBy(diatonicAlter, accidental) {
+  switch (accidental) {
+    case "sharp":
+      return diatonicAlter + 1;
+    case "doubleSharp":
+      return diatonicAlter + 2;
+    case "flat":
+      return diatonicAlter - 1;
+    case "doubleFlat":
+      return diatonicAlter - 2;
+    // A natural sign names the natural note, whatever the key would have given.
+    case "natural":
+      return 0;
+    default:
+      return diatonicAlter;
+  }
+}
+function readFigure(text, start) {
+  let index = start;
+  let accidental = "none";
+  const pair = DOUBLE_ACCIDENTALS[text.slice(index, index + 2)];
+  const single = SINGLE_ACCIDENTALS[text[index] ?? ""];
+  if (pair !== void 0) {
+    accidental = pair;
+    index += 2;
+  } else if (single !== void 0) {
+    accidental = single;
+    index += 1;
+  }
+  const digit = text[index] ?? "";
+  if (digit >= "0" && digit <= "9") {
+    const number = Number(digit);
+    if (number < MIN_FIGURE_NUMBER || number > MAX_FIGURE_NUMBER) {
+      throw invalidFigures(
+        text,
+        `names the interval ${number}, which is outside ${MIN_FIGURE_NUMBER}..${MAX_FIGURE_NUMBER}`
+      );
+    }
+    return { figure: { number, accidental }, index: index + 1 };
+  }
+  if (accidental === "none") {
+    const found = text.slice(start, start + 1);
+    throw invalidFigures(
+      text,
+      found === "" ? `ends where a figure was expected, at position ${start}` : `has an unexpected character ${JSON.stringify(found)}`
+    );
+  }
+  return { figure: { number: 3, accidental }, index };
+}
+function parseFigures(text) {
+  const figures = [];
+  const motions = [];
+  let index = 0;
+  while (index < text.length) {
+    if (FIGURE_SEPARATORS.has(text[index] ?? "")) {
+      index += 1;
+      continue;
+    }
+    const first = readFigure(text, index);
+    index = first.index;
+    if (!MOTION_MARKS.has(text[index] ?? "")) {
+      figures.push(first.figure);
+      continue;
+    }
+    const second = readFigure(text, index + 1);
+    index = second.index;
+    if (MOTION_MARKS.has(text[index] ?? "")) {
+      throw invalidFigures(text, "chains more than one motion onto a single figure");
+    }
+    if (first.figure.number === second.figure.number) {
+      throw invalidFigures(text, `moves the interval ${first.figure.number} onto itself`);
+    }
+    motions.push({ from: first.figure, to: second.figure });
+  }
+  return { figures, motions };
+}
+var TRIAD = { intervals: [3, 5], rootInterval: 1 };
+var TRIAD_FIRST = { intervals: [3, 6], rootInterval: 6 };
+var TRIAD_SECOND = { intervals: [4, 6], rootInterval: 4 };
+var SEVENTH = { intervals: [3, 5, 7], rootInterval: 1 };
+var SEVENTH_FIRST = { intervals: [3, 5, 6], rootInterval: 6 };
+var SEVENTH_SECOND = { intervals: [3, 4, 6], rootInterval: 4 };
+var SEVENTH_THIRD = { intervals: [2, 4, 6], rootInterval: 2 };
+var FIGURE_SETS = /* @__PURE__ */ new Map([
+  ["", TRIAD],
+  ["3", TRIAD],
+  ["5", TRIAD],
+  ["3,5", TRIAD],
+  ["6", TRIAD_FIRST],
+  ["3,6", TRIAD_FIRST],
+  ["4,6", TRIAD_SECOND],
+  ["7", SEVENTH],
+  ["3,7", SEVENTH],
+  ["5,7", SEVENTH],
+  ["3,5,7", SEVENTH],
+  ["5,6", SEVENTH_FIRST],
+  ["3,5,6", SEVENTH_FIRST],
+  ["3,4", SEVENTH_SECOND],
+  ["3,4,6", SEVENTH_SECOND],
+  ["2", SEVENTH_THIRD],
+  ["2,4", SEVENTH_THIRD],
+  ["2,4,6", SEVENTH_THIRD]
+]);
+var FIGURE_ABBREVIATIONS = /* @__PURE__ */ new Map([
+  [TRIAD.intervals.join(","), []],
+  [TRIAD_FIRST.intervals.join(","), [6]],
+  [TRIAD_SECOND.intervals.join(","), [6, 4]],
+  [SEVENTH.intervals.join(","), [7]],
+  [SEVENTH_FIRST.intervals.join(","), [6, 5]],
+  [SEVENTH_SECOND.intervals.join(","), [4, 3]],
+  [SEVENTH_THIRD.intervals.join(","), [4, 2]]
+]);
+function tertianQualityIndex() {
+  const index = /* @__PURE__ */ new Map();
+  for (const quality of chordQualities()) {
+    const { intervals } = makeChord(0, quality);
+    const template = intervals.join(",");
+    if (intervals.length >= 3 && intervals.length <= MAX_STACK_SIZE && !index.has(template)) {
+      index.set(template, quality);
+    }
+  }
+  return index;
+}
+var TERTIAN_QUALITIES = tertianQualityIndex();
+function keyLetterAlters(key) {
+  const size = scaleTonesInDegreeOrder(key).length;
+  if (size !== 7) {
+    throw new InvalidInputError(`figured bass requires a heptatonic key (received ${size} tones)`);
+  }
+  const alters = [];
+  for (const note of spellScale(spelledKeyOf(key).tonic, key)) {
+    alters[diatonicLetterOf(note.letter)] = note.alter;
+  }
+  return alters;
+}
+function noteAbove(bass, figure, alters) {
+  const letter = diatonicLetterOf(bass.letter + figure.number - 1);
+  return { letter, alter: alteredBy(alters[letter] ?? 0, figure.accidental) };
+}
+function bareNote(note) {
+  return { letter: diatonicLetterOf(note.letter), alter: note.alter };
+}
+function realizeSonority(bass, resolved, text, alters) {
+  const numbers = [...new Set(resolved.map((figure) => figure.number))].sort((a, b) => a - b);
+  const sonority = FIGURE_SETS.get(numbers.join(","));
+  if (sonority === void 0) {
+    throw invalidFigures(text, "names no chord over the bass");
+  }
+  const written = new Map(resolved.map((figure) => [figure.number, figure.accidental]));
+  const notes = sonority.intervals.map(
+    (number) => noteAbove(bass, { number, accidental: written.get(number) ?? "none" }, alters)
+  );
+  const tones = [bass, ...notes];
+  const root = tones[[1, ...sonority.intervals].indexOf(sonority.rootInterval)] ?? bass;
+  const rootPc = noteToPitchClass(root);
+  const stack = [];
+  for (let step = 0; step < tones.length; step += 1) {
+    const tone = tones.find((candidate) => diatonicLetterOf(candidate.letter - root.letter) === step * 2);
+    if (tone === void 0) {
+      throw new NoSolutionError(
+        `figured bass ${JSON.stringify(text)} sounds ${noteNames(tones).join(" ")}, which does not stack in thirds`
+      );
+    }
+    stack.push(pitchClassOf(noteToPitchClass(tone) - rootPc));
+  }
+  const quality = TERTIAN_QUALITIES.get(stack.join(","));
+  if (quality === void 0) {
+    throw new NoSolutionError(
+      `figured bass ${JSON.stringify(text)} sounds ${noteNames(tones).join(" ")}, which no chord quality names`
+    );
+  }
+  const chord = makeChord(rootPc, quality, noteToPitchClass(bass));
+  chord.rootSpelling = { letter: root.letter, alter: root.alter };
+  chord.bassSpelling = { letter: bass.letter, alter: bass.alter };
+  return { chord, notes };
+}
+function figuredBassRealization(bass, figures, key) {
+  if (typeof figures !== "string") {
+    throw new InvalidInputError(`figured bass must be a string; received ${typeof figures}`);
+  }
+  const bassData = toNoteData(bass);
+  const scale = toKeyScale(key);
+  const alters = keyLetterAlters(scale);
+  noteToPitchClass(bassData);
+  const bassNote = bareNote(bassData);
+  const text = figures.trim();
+  const { figures: written, motions } = parseFigures(text);
+  const suspensions = motions.map((motion) => ({
+    from: motion.from.number,
+    to: motion.to.number,
+    note: noteAbove(bassNote, motion.from, alters),
+    resolution: noteAbove(bassNote, motion.to, alters)
+  }));
+  const resolved = [
+    ...written,
+    ...motions.map((motion) => motion.to).filter((figure) => figure.number !== OCTAVE_FIGURE)
+  ];
+  const { chord, notes } = realizeSonority(bassNote, resolved, text, alters);
+  return { chord, notes: [bassNote, ...notes], suspensions };
+}
+function realizeFiguredBass(bass, figures, key) {
+  return figuredBassRealization(bass, figures, key).chord;
+}
+function figuredBassOf(chord, key) {
+  const data = toChordData(chord);
+  const scale = toKeyScale(key);
+  const alters = keyLetterAlters(scale);
+  const tones = spellChord(data, spelledKeyOf(scale).tonic, scale);
+  const bassPc = pitchClassOf(data.bassPc ?? data.rootPc);
+  const bass = tones.find((tone) => noteToPitchClass(tone) === bassPc);
+  if (bass === void 0) {
+    throw new NoSolutionError(
+      "figured bass measures intervals above a chord tone, and this chord's bass is not one of its tones"
+    );
+  }
+  const written = /* @__PURE__ */ new Map();
+  for (const tone of tones) {
+    if (tone !== bass) {
+      written.set(diatonicLetterOf(tone.letter - bass.letter) + 1, tone);
+    }
+  }
+  const digits = FIGURE_ABBREVIATIONS.get([...written.keys()].sort((a, b) => a - b).join(","));
+  if (digits === void 0) {
+    throw new NoSolutionError(
+      `no figured bass names ${noteNames(tones).join(" ")} over ${noteNames([bass])[0]}`
+    );
+  }
+  const accidentals = /* @__PURE__ */ new Map();
+  for (const [number, tone] of written) {
+    const alteration = tone.alter - (alters[diatonicLetterOf(tone.letter)] ?? 0);
+    if (alteration === 0) {
+      continue;
+    }
+    const glyph = ACCIDENTAL_GLYPHS[alteration];
+    if (glyph === void 0) {
+      throw new NoSolutionError(
+        `no figure names an interval altered by ${alteration} semitones from the key`
+      );
+    }
+    accidentals.set(number, glyph);
+  }
+  const figures = [.../* @__PURE__ */ new Set([...digits, ...accidentals.keys()])].sort((a, b) => b - a).map((number) => `${accidentals.get(number) ?? ""}${number}`).join("");
+  assertRealizesAs(bass, figures, scale, tones);
+  return figures;
+}
+function pitchClassesOf(notes) {
+  return [...new Set(notes.map(noteToPitchClass))].sort((a, b) => a - b);
+}
+function assertRealizesAs(bass, figures, key, tones) {
+  const noFigures = (detail) => new NoSolutionError(
+    `no figured bass names ${noteNames(tones).join(" ")} over ${noteNames([bass])[0]}: the figures ${JSON.stringify(figures)} ${detail}`
+  );
+  let realized;
+  try {
+    realized = figuredBassRealization(bass, figures, key);
+  } catch (error) {
+    throw error instanceof NoSolutionError ? noFigures("read back as no chord at all") : error;
+  }
+  const written = pitchClassesOf(realized.notes);
+  const expected = pitchClassesOf(tones);
+  if (written.length !== expected.length || written.some((pc, index) => pc !== expected[index])) {
+    throw noFigures(`sound ${noteNames(realized.notes).join(" ")} instead`);
+  }
+}
+
+// src/theory/voicing/tendency.ts
+function leadingTonePcOf(key) {
+  return pitchClassOf(key.rootPc - 1);
+}
+var LEADING_TONE_QUALITIES = /* @__PURE__ */ new Set(["dim", "dim7", "m7b5"]);
+function isFunctioningLeadingTone(chord, key) {
+  const role = chordToneRole(leadingTonePcOf(key), chord);
+  if (role === "third") {
+    return pitchClassOf(chord.rootPc) === pitchClassOf(key.rootPc + 7);
+  }
+  if (role === "root") {
+    return LEADING_TONE_QUALITIES.has(chord.quality);
+  }
+  return false;
+}
+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;
+}
+
+// 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;
+var HIDDEN_PERFECT_PENALTY = 6;
+var INITIAL_CANDIDATE_CAPACITY = 512;
+function createCandidateBuffer() {
+  return { pitches: new Int32Array(0), count: 0, voices: 0 };
+}
+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, into = createCandidateBuffer()) {
+  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 voices = ranges.length;
+  into.voices = voices;
+  into.count = 0;
+  let capacity = Math.floor(into.pitches.length / Math.max(1, voices));
+  if (capacity === 0) {
+    capacity = Math.min(maxCandidates, INITIAL_CANDIDATE_CAPACITY);
+    into.pitches = new Int32Array(capacity * voices);
+  }
+  const current = new Int32Array(voices);
+  let nodes = 0;
+  const maxSearchNodes = maxCandidates * SEARCH_NODES_PER_CANDIDATE;
+  const build = (voice) => {
+    nodes += 1;
+    if (into.count >= maxCandidates || nodes > maxSearchNodes) {
+      return;
+    }
+    if (voice === voices) {
+      if (into.count === capacity) {
+        capacity = Math.min(maxCandidates, capacity * 2);
+        const grown = new Int32Array(capacity * voices);
+        grown.set(into.pitches.subarray(0, into.count * voices));
+        into.pitches = grown;
+      }
+      into.pitches.set(current, into.count * voices);
+      into.count += 1;
+      return;
+    }
+    const prev = voice === 0 ? void 0 : 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[voice] = pitch;
+      build(voice + 1);
+    }
+  };
+  build(0);
+  return into;
+}
+function structuralTables(chord, key) {
+  const tones = chordPitchClasses(chord);
+  const missing = tones.map(
+    (pc) => chordToneRole(pc, chord) === "fifth" ? MISSING_FIFTH_PENALTY : MISSING_TONE_PENALTY
+  );
+  const rootPc = pitchClassOf(chord.rootPc);
+  const leadingTonePc = key !== void 0 && isFunctioningLeadingTone(chord, key) ? leadingTonePcOf(key) : -1;
+  const doubling = new Float64Array(12);
+  for (let pc = 0; pc < 12; pc += 1) {
+    if (pc === leadingTonePc) {
+      doubling[pc] = LEADING_TONE_DOUBLING_PENALTY;
+    } else if (pc !== rootPc && chordToneRole(pc, chord) !== "fifth") {
+      doubling[pc] = POOR_DOUBLING_PENALTY;
+    }
+  }
+  return { tones, missing, doubling };
+}
+var PITCH_CLASS_COUNTS = new Int32Array(12);
+function structuralPenalty(tables, pitches, offset, voices) {
+  PITCH_CLASS_COUNTS.fill(0);
+  let penalty = 0;
+  for (let index = 0; index < voices; index += 1) {
+    const pitch = pitches[offset + index];
+    if (pitch === void 0) {
+      continue;
+    }
+    const pc = pitchClassOf(pitch);
+    PITCH_CLASS_COUNTS[pc] = (PITCH_CLASS_COUNTS[pc] ?? 0) + 1;
+    if (index > 0 && pitch === pitches[offset + index - 1]) {
+      penalty += UNISON_PENALTY;
+    }
+  }
+  for (let index = 0; index < tables.tones.length; index += 1) {
+    const pc = tables.tones[index];
+    if (pc !== void 0 && PITCH_CLASS_COUNTS[pc] === 0) {
+      penalty += tables.missing[index] ?? 0;
+    }
+  }
+  for (let pc = 0; pc < 12; pc += 1) {
+    const count = PITCH_CLASS_COUNTS[pc] ?? 0;
+    if (count > 1) {
+      penalty += (count - 1) * (tables.doubling[pc] ?? 0);
+    }
+  }
+  return penalty;
+}
+function resolutionTables(prevChord, nextChord, key) {
+  const nextHas = new Uint8Array(12);
+  for (const pc of chordPitchClasses(nextChord)) {
+    nextHas[pc] = 1;
+  }
+  return {
+    seventhPc: seventhPcOf(prevChord) ?? -1,
+    leadingTonePc: key !== void 0 && isFunctioningLeadingTone(prevChord, key) ? leadingTonePcOf(key) : -1,
+    tonicPc: key === void 0 ? -1 : pitchClassOf(key.rootPc),
+    nextHas
+  };
+}
+function resolutionViolations(tables, prev, prevOffset, cur, curOffset, voices) {
+  const { seventhPc, leadingTonePc, tonicPc, nextHas } = tables;
+  let count = 0;
+  for (let voice = 0; voice < voices; voice += 1) {
+    const from = prev[prevOffset + voice];
+    const to = cur[curOffset + voice];
+    if (from === void 0 || to === void 0) {
+      continue;
+    }
+    const fromPc = pitchClassOf(from);
+    const motion = to - from;
+    if (fromPc === seventhPc && nextHas[fromPc] === 0 && motion !== -1 && motion !== -2) {
+      count += 1;
+    }
+    if (fromPc === leadingTonePc && tonicPc >= 0 && nextHas[tonicPc] === 1 && nextHas[fromPc] === 0 && motion !== 1) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function leadingCost(prev, prevOffset, cur, curOffset, voices) {
+  let total = 0;
+  for (let voice = 0; voice < voices; voice += 1) {
+    const a = prev[prevOffset + voice];
+    const b = cur[curOffset + voice];
+    if (a === void 0 || b === void 0) {
+      continue;
+    }
+    total += Math.abs(b - a);
+  }
+  if (voices >= 2) {
+    const bassPrev = prev[prevOffset];
+    const bassCur = cur[curOffset];
+    const sopPrev = prev[prevOffset + voices - 1];
+    const sopCur = cur[curOffset + voices - 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 violationCount(prev, prevOffset, cur, curOffset, voices) {
+  let count = 0;
+  for (let lower = 0; lower < voices; lower += 1) {
+    for (let upper = lower + 1; upper < voices; upper += 1) {
+      const prevLower = prev[prevOffset + lower];
+      const prevUpper = prev[prevOffset + upper];
+      const curLower = cur[curOffset + lower];
+      const curUpper = cur[curOffset + 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/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 resolveKey(opts) {
+  return opts?.key === void 0 ? void 0 : toKeyScale(opts.key);
+}
+function resolvePreviousChord(opts) {
+  return opts?.previousChord === void 0 ? void 0 : toChordData(opts.previousChord);
+}
+function resolveMaxCandidates(opts) {
+  if (opts?.maxCandidates === void 0) return void 0;
+  assertPositiveInt(opts.maxCandidates, "maxCandidates", 1e6);
+  return opts.maxCandidates;
+}
+function voiceChord(chord, opts) {
+  const data = toChordData(chord);
+  const ranges = resolveRanges(opts);
+  const maxSpacing = resolveMaxSpacing(opts);
+  const candidates = enumerateVoicings(data, ranges, maxSpacing, resolveMaxCandidates(opts));
+  const tables = structuralTables(data, resolveKey(opts));
+  const { pitches, voices } = candidates;
+  let bestOffset = -1;
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (let index = 0; index < candidates.count; index += 1) {
+    const offset = index * voices;
+    let score = structuralPenalty(tables, pitches, offset, voices);
+    for (let i = 0; i < voices; i += 1) {
+      const pitch = pitches[offset + 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;
+      bestOffset = offset;
+    }
+  }
+  if (bestOffset < 0) {
+    throw new NoSolutionError(
+      `no voicing satisfies the given ranges for ${formatChordSymbol(chord)}`
+    );
+  }
+  return [...pitches.subarray(bestOffset, bestOffset + voices)];
+}
+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 data = chords.map((chord) => toChordData(chord));
+  const key = resolveKey(opts);
+  const ranges = resolveRanges(opts);
+  const maxSpacing = resolveMaxSpacing(opts);
+  const maxCandidates = resolveMaxCandidates(opts);
+  const result = [];
+  const buffer = createCandidateBuffer();
+  let prev;
+  let prevChord;
+  for (let index = 0; index < data.length; index += 1) {
+    const chord = data[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, buffer)
+    );
+    const { pitches, voices } = candidates;
+    const structure = structuralTables(chord, key);
+    const resolution = prevChord === void 0 ? void 0 : resolutionTables(prevChord, chord, key);
+    let bestOffset = -1;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (let candidate = 0; candidate < candidates.count; candidate += 1) {
+      const offset = candidate * voices;
+      const unresolved = resolution === void 0 ? 0 : resolutionViolations(resolution, prev, 0, pitches, offset, voices);
+      const score = structuralPenalty(structure, pitches, offset, voices) + leadingCost(prev, 0, pitches, offset, voices) + VIOLATION_PENALTY * violationCount(prev, 0, pitches, offset, voices) + RESOLUTION_PENALTY * unresolved;
+      if (score < bestScore) {
+        bestScore = score;
+        bestOffset = offset;
+      }
+    }
+    if (bestOffset < 0) {
+      throw noSolutionAt(index, chord);
+    }
+    const best = [...pitches.subarray(bestOffset, bestOffset + voices)];
+    result.push(best);
+    prev = best;
+    prevChord = chord;
+  }
+  return result;
+}
+
+// src/theory/voicing/leading.ts
+function voiceLeadingCost(from, to) {
+  if (from.length !== to.length) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return leadingCost(from, 0, to, 0, from.length);
+}
+function nextVoicing(current, chord, opts) {
+  const data = toChordData(chord);
+  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 ? resolveRanges({
+    ranges: 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(data, ranges, maxSpacing, resolveMaxCandidates(opts));
+  const key = resolveKey(opts);
+  const previousChord = resolvePreviousChord(opts);
+  const structure = structuralTables(data, key);
+  const resolution = previousChord === void 0 ? void 0 : resolutionTables(previousChord, data, key);
+  const { pitches, voices } = candidates;
+  let bestOffset = -1;
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (let candidate = 0; candidate < candidates.count; candidate += 1) {
+    const offset = candidate * voices;
+    const score = structuralPenalty(structure, pitches, offset, voices) + leadingCost(source, 0, pitches, offset, voices) + VIOLATION_PENALTY * violationCount(source, 0, pitches, offset, voices) + RESOLUTION_PENALTY * (resolution === void 0 ? 0 : resolutionViolations(resolution, source, 0, pitches, offset, voices));
+    if (score < bestScore) {
+      bestScore = score;
+      bestOffset = offset;
+    }
+  }
+  if (bestOffset < 0) {
+    throw new NoSolutionError("no voicing satisfies the given ranges");
+  }
+  return [...pitches.subarray(bestOffset, bestOffset + voices)];
+}
+
+// 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;
+}
+
+// src/theory/partwriting/internal.ts
+var INTERVAL_WORDS = [
+  "unison",
+  "second",
+  "third",
+  "fourth",
+  "fifth",
+  "sixth",
+  "seventh",
+  "octave"
+];
+function intervalWord(numberValue) {
+  return INTERVAL_WORDS[numberValue - 1] ?? "interval";
+}
+function violation(kind, voices, fromIndex, toIndex, rationale) {
+  return { kind, voices, fromIndex, toIndex, rationale };
+}
+
+// src/theory/partwriting/species.ts
+var EPS = 1e-9;
+var SPECIES_RATIO = { 1: 1, 2: 2, 3: 4, 4: 2, 5: 0 };
+var SPECIES_NUMBERS = Object.keys(SPECIES_RATIO).map(Number);
+var MIN_FLORID_VALUE = 0.125;
+function meanPitch(notes) {
+  if (notes.length === 0) {
+    return 0;
+  }
+  return notes.reduce((sum, note) => sum + noteToMidi(note), 0) / notes.length;
+}
+function impliedDurations(count, measures, ratio) {
+  const full = ratio * Math.max(measures - 1, 0);
+  const closing = Math.max(count - full, 1);
+  return Array.from({ length: count }, (_, index) => index < full ? 1 / ratio : 1 / closing);
+}
+function isStep(interval) {
+  return interval.number === 2;
+}
+function direction(interval) {
+  return Math.sign(interval.semitones);
+}
+function sameNote(a, b) {
+  return a.letter === b.letter && a.alter === b.alter && a.octave === b.octave;
+}
+function isPassedThrough(entries, position) {
+  const previous = entries[position - 1];
+  const current = entries[position];
+  const next = entries[position + 1];
+  if (previous === void 0 || current === void 0 || next === void 0) {
+    return false;
+  }
+  const incoming = spelledInterval(previous.note, current.note);
+  const outgoing = spelledInterval(current.note, next.note);
+  if (!isStep(incoming) || !isStep(outgoing)) {
+    return false;
+  }
+  const passing = direction(incoming) === direction(outgoing);
+  const neighbour = sameNote(previous.note, next.note);
+  return passing || neighbour;
+}
+function isThird(interval) {
+  return interval.number === 3;
+}
+function figureAt(entries, start) {
+  const first = entries[start];
+  const second = entries[start + 1];
+  const third = entries[start + 2];
+  const fourth = entries[start + 3];
+  if (first === void 0 || second === void 0 || third === void 0 || fourth === void 0) {
+    return void 0;
+  }
+  return [first, second, third, fourth];
+}
+function isCambiata(entries, start) {
+  const figure = figureAt(entries, start);
+  if (figure === void 0) {
+    return false;
+  }
+  const [first, second, third, fourth] = figure;
+  if (first.consonance === 2 /* Dissonance */ || third.consonance === 2 /* Dissonance */) {
+    return false;
+  }
+  const approach = spelledInterval(first.note, second.note);
+  const leap = spelledInterval(second.note, third.note);
+  const answer = spelledInterval(third.note, fourth.note);
+  return isStep(approach) && direction(approach) < 0 && isThird(leap) && direction(leap) < 0 && isStep(answer) && direction(answer) > 0;
+}
+function isDoubleNeighbour(entries, start) {
+  const figure = figureAt(entries, start);
+  if (figure === void 0) {
+    return false;
+  }
+  const [first, second, third, fourth] = figure;
+  if (first.consonance === 2 /* Dissonance */ || !sameNote(first.note, fourth.note)) {
+    return false;
+  }
+  const away = spelledInterval(first.note, second.note);
+  const across = spelledInterval(second.note, third.note);
+  const back = spelledInterval(third.note, fourth.note);
+  return isStep(away) && isThird(across) && isStep(back) && direction(away) !== 0 && direction(across) === -direction(away);
+}
+function isFiguredDissonance(entries, position, species) {
+  if (species !== 3 && species !== 5) {
+    return false;
+  }
+  return isCambiata(entries, position - 1) || isDoubleNeighbour(entries, position - 1) || isDoubleNeighbour(entries, position - 2);
+}
+function licenceFor(species, downbeat) {
+  if (species === 1) {
+    return "none";
+  }
+  if (species === 4) {
+    return downbeat ? "suspension" : "none";
+  }
+  if (species === 5) {
+    return downbeat ? "suspension" : "passing";
+  }
+  return downbeat ? "none" : "passing";
+}
+function verticalViolations(entries, position, species, counterpointAbove) {
+  const entry = entries[position];
+  if (entry === void 0) {
+    return [];
+  }
+  const found = [];
+  const upper = counterpointAbove ? entry.note : entry.against;
+  const lower = counterpointAbove ? entry.against : entry.note;
+  if (createsVoiceCrossing(upper, lower)) {
+    found.push(
+      violation(
+        "voiceCrossing",
+        [0, 1],
+        entry.index,
+        entry.index,
+        "The counterpoint crosses to the wrong side of the cantus firmus"
+      )
+    );
+  }
+  if (entry.consonance !== 2 /* Dissonance */) {
+    return found;
+  }
+  const licence = licenceFor(species, entry.downbeat);
+  if (licence === "passing" && (isPassedThrough(entries, position) || isFiguredDissonance(entries, position, species))) {
+    return found;
+  }
+  if (licence === "suspension") {
+    found.push(...suspensionViolations(entries, position));
+    return found;
+  }
+  found.push(
+    violation(
+      "unpreparedDissonance",
+      [0, 1],
+      entry.index,
+      entry.index,
+      licence === "none" ? `A ${entry.interval.quality}${entry.interval.number} falls where this species allows only a consonance` : "The dissonance is not passed through by step"
+    )
+  );
+  return found;
+}
+function suspensionViolations(entries, position) {
+  const entry = entries[position];
+  if (entry === void 0) {
+    return [];
+  }
+  const previous = entries[position - 1];
+  const next = entries[position + 1];
+  const prepared = previous !== void 0 && sameNote(previous.note, entry.note) && previous.consonance !== 2 /* Dissonance */;
+  if (!prepared) {
+    return [
+      violation(
+        "unpreparedDissonance",
+        [0, 1],
+        entry.index,
+        entry.index,
+        "The suspended dissonance is not tied over from a consonance"
+      )
+    ];
+  }
+  const resolution = next === void 0 ? void 0 : spelledInterval(entry.note, next.note);
+  if (next === void 0 || resolution === void 0 || !isStep(resolution) || direction(resolution) >= 0) {
+    return [
+      violation(
+        "unresolvedSuspension",
+        [0, 1],
+        entry.index,
+        next === void 0 ? entry.index : next.index,
+        "The suspension does not fall by step onto its resolution"
+      )
+    ];
+  }
+  return [];
+}
+function melodicViolations(from, to) {
+  const interval = spelledInterval(from.note, to.note);
+  if (isAugmentedMelodicInterval(from.note, to.note)) {
+    return [
+      violation(
+        "augmentedMelodicInterval",
+        [1],
+        from.index,
+        to.index,
+        `The counterpoint moves by an augmented ${intervalWord(interval.number)}`
+      )
+    ];
+  }
+  if (isForbiddenMelodicLeap(from.note, to.note)) {
+    return [
+      violation(
+        "illegalLeap",
+        [1],
+        from.index,
+        to.index,
+        `The counterpoint leaps by a ${interval.quality}${interval.number}`
+      )
+    ];
+  }
+  return [];
+}
+var MAX_LEAPS_IN_ONE_DIRECTION = 2;
+var MAX_LEAP_CHAIN_SPAN = 12;
+var LEAP_NEEDING_ANSWER = 6;
+var TRITONE_SEMITONES = 6;
+function isLeap(interval) {
+  return interval.number > 2;
+}
+function melodicMoves(entries) {
+  const moves = [];
+  for (let position = 1; position < entries.length; position += 1) {
+    const from = entries[position - 1];
+    const to = entries[position];
+    if (from === void 0 || to === void 0) {
+      continue;
+    }
+    moves.push({ from, to, interval: spelledInterval(from.note, to.note) });
+  }
+  return moves;
+}
+function climaxViolations(entries) {
+  const body = entries.slice(0, -1);
+  const peak = body.reduce(
+    (high, entry) => Math.max(high, noteToMidi(entry.note)),
+    Number.NEGATIVE_INFINITY
+  );
+  const arrivals = body.filter((entry, position) => {
+    const previous = body[position - 1];
+    return noteToMidi(entry.note) === peak && (previous === void 0 || noteToMidi(previous.note) !== peak);
+  });
+  const first = arrivals[0];
+  const second = arrivals[1];
+  if (first === void 0 || second === void 0) {
+    return [];
+  }
+  return [
+    violation(
+      "melodicShape",
+      [1],
+      first.index,
+      second.index,
+      "The line reaches its highest note more than once, so it has no one climax"
+    )
+  ];
+}
+function leapChainViolations(moves) {
+  const found = [];
+  let run = [];
+  const close = () => {
+    const first = run[0];
+    const last = run[run.length - 1];
+    const span = run.reduce((total, move) => total + Math.abs(move.interval.semitones), 0);
+    if (first !== void 0 && last !== void 0) {
+      if (run.length > MAX_LEAPS_IN_ONE_DIRECTION) {
+        found.push(
+          violation(
+            "melodicShape",
+            [1],
+            first.from.index,
+            last.to.index,
+            `The counterpoint leaps ${run.length} times in a row in the same direction`
+          )
+        );
+      } else if (run.length > 1 && span > MAX_LEAP_CHAIN_SPAN) {
+        found.push(
+          violation(
+            "melodicShape",
+            [1],
+            first.from.index,
+            last.to.index,
+            "Two leaps in the same direction carry the line further than an octave"
+          )
+        );
+      }
+    }
+    run = [];
+  };
+  for (const move of moves) {
+    if (!isLeap(move.interval)) {
+      close();
+      continue;
+    }
+    const previous = run[run.length - 1];
+    if (previous !== void 0 && direction(previous.interval) !== direction(move.interval)) {
+      close();
+    }
+    run.push(move);
+  }
+  close();
+  return found;
+}
+function leapAnswerViolations(moves) {
+  const found = [];
+  for (let position = 0; position < moves.length; position += 1) {
+    const leap = moves[position];
+    const answer = moves[position + 1];
+    if (leap === void 0 || answer === void 0 || leap.interval.number < LEAP_NEEDING_ANSWER) {
+      continue;
+    }
+    if (isStep(answer.interval) && direction(answer.interval) === -direction(leap.interval)) {
+      continue;
+    }
+    const word = intervalWord(leap.interval.number);
+    found.push(
+      violation(
+        "melodicShape",
+        [1],
+        leap.from.index,
+        answer.to.index,
+        `The leap of ${word === "octave" ? "an" : "a"} ${word} is not answered by a step the other way`
+      )
+    );
+  }
+  return found;
+}
+function tritoneOutlineViolations(entries) {
+  const found = [];
+  let run = [];
+  const close = () => {
+    const first = run[0];
+    const last = run[run.length - 1];
+    if (first !== void 0 && last !== void 0 && run.length > 1) {
+      const outline = spelledInterval(first.from.note, last.to.note);
+      if (Math.abs(outline.semitones) === TRITONE_SEMITONES) {
+        found.push(
+          violation(
+            "melodicShape",
+            [1],
+            first.from.index,
+            last.to.index,
+            "The line turns around on a tritone, outlining the interval it may not leap"
+          )
+        );
+      }
+    }
+    run = [];
+  };
+  for (const move of melodicMoves(entries)) {
+    if (direction(move.interval) === 0) {
+      continue;
+    }
+    const previous = run[run.length - 1];
+    if (previous !== void 0 && direction(previous.interval) !== direction(move.interval)) {
+      close();
+    }
+    run.push(move);
+  }
+  close();
+  return found;
+}
+function repeatedNoteViolations(moves, closingMeasure) {
+  return moves.filter(
+    (move) => sameNote(move.from.note, move.to.note) && move.from.againstIndex < closingMeasure
+  ).map(
+    (move) => violation(
+      "melodicShape",
+      [1],
+      move.from.index,
+      move.to.index,
+      "The counterpoint repeats a note where this species keeps the line moving"
+    )
+  );
+}
+function melodicShapeViolations(entries, species) {
+  const moves = melodicMoves(entries);
+  const closingMeasure = entries[entries.length - 1]?.againstIndex ?? 0;
+  const found = [
+    ...climaxViolations(entries),
+    ...leapChainViolations(moves),
+    ...leapAnswerViolations(moves),
+    ...tritoneOutlineViolations(entries),
+    ...species === 2 || species === 3 ? repeatedNoteViolations(moves, closingMeasure) : []
+  ];
+  return found.sort((left, right) => left.fromIndex - right.fromIndex);
+}
+function motionViolations(from, to, counterpointAbove) {
+  const found = [];
+  const upperPrev = counterpointAbove ? from.note : from.against;
+  const upperCur = counterpointAbove ? to.note : to.against;
+  const lowerPrev = counterpointAbove ? from.against : from.note;
+  const lowerCur = counterpointAbove ? to.against : to.note;
+  if (createsParallelPerfect(upperPrev, upperCur, lowerPrev, lowerCur)) {
+    const fifth = simpleIntervalNumber(to.interval.number) === 5;
+    found.push(
+      violation(
+        fifth ? "parallelFifth" : "parallelOctave",
+        [0, 1],
+        from.index,
+        to.index,
+        fifth ? "The two voices move into consecutive perfect fifths" : "The two voices move into consecutive perfect octaves"
+      )
+    );
+  }
+  if (createsHiddenParallelPerfect(upperPrev, upperCur, lowerPrev, lowerCur)) {
+    found.push(
+      violation(
+        "hiddenPerfect",
+        [0, 1],
+        from.index,
+        to.index,
+        "The voices leap into a perfect interval by similar motion"
+      )
+    );
+  }
+  if (createsBattuta(upperPrev, upperCur, lowerPrev, lowerCur)) {
+    found.push(
+      violation(
+        "battuta",
+        [0, 1],
+        from.index,
+        to.index,
+        "The upper voice leaps down into an octave against the lower voice"
+      )
+    );
+  }
+  return found;
+}
+function lastEntryBefore(entries, againstIndex) {
+  for (let position = entries.length - 1; position >= 0; position -= 1) {
+    const entry = entries[position];
+    if (entry !== void 0 && entry.againstIndex < againstIndex) {
+      return entry;
+    }
+  }
+  return void 0;
+}
+function cadenceViolations(entries, mode, counterpointAbove) {
+  const found = [];
+  const first = entries[0];
+  const last = entries[entries.length - 1];
+  if (first === void 0 || last === void 0) {
+    return found;
+  }
+  if (classifySpelledInterval(first.interval) !== 0 /* PerfectConsonance */) {
+    found.push(
+      violation(
+        "missingCadence",
+        [0, 1],
+        first.index,
+        first.index,
+        "The exercise does not begin on a perfect consonance"
+      )
+    );
+  }
+  if (noteToPitchClass(last.note) !== pitchClassOf(mode.rootPc)) {
+    found.push(
+      violation(
+        "missingCadence",
+        [0, 1],
+        last.index,
+        last.index,
+        "The counterpoint does not close on the final of the mode"
+      )
+    );
+  }
+  const closing = last.interval;
+  if (closing.quality !== "P" || simpleIntervalNumber(closing.number) !== 1) {
+    found.push(
+      violation(
+        "missingCadence",
+        [0, 1],
+        last.index,
+        last.index,
+        "The exercise does not close on an octave or unison"
+      )
+    );
+    return found;
+  }
+  const penultimate = lastEntryBefore(entries, last.againstIndex);
+  if (penultimate === void 0) {
+    return found;
+  }
+  const arrival = entries.find((entry) => entry.againstIndex === last.againstIndex) ?? last;
+  const approach = spelledInterval(penultimate.note, arrival.note);
+  const expected = counterpointAbove ? { quality: "M", number: 6 } : { quality: "m", number: 3 };
+  if (penultimate.interval.quality !== expected.quality || simpleIntervalNumber(penultimate.interval.number) !== expected.number || !isStep(approach)) {
+    found.push(
+      violation(
+        "missingCadence",
+        [0, 1],
+        penultimate.index,
+        arrival.index,
+        counterpointAbove ? "The close is not the major sixth stepping out to the octave" : "The close is not the minor third stepping in to the unison"
+      )
+    );
+  }
+  return found;
+}
+function resolveDurations(counterpoint, measures, species, opts) {
+  const given = opts?.durations;
+  if (given !== void 0) {
+    if (given.length !== counterpoint.length) {
+      return {
+        problem: `The exercise gives ${given.length} durations for ${counterpoint.length} notes`
+      };
+    }
+    for (const duration of given) {
+      const units = duration / MIN_FLORID_VALUE;
+      if (!(duration > 0) || duration > 1 || Math.abs(units - Math.round(units)) > EPS) {
+        return {
+          problem: `A note lasts ${duration} of a measure, which this style does not write`
+        };
+      }
+    }
+    const total = given.reduce((sum, duration) => sum + duration, 0);
+    if (Math.abs(total - measures) > EPS) {
+      return { problem: `The counterpoint fills ${total} of the ${measures} measures` };
+    }
+    return { durations: [...given] };
+  }
+  if (species === 5) {
+    throw new InvalidInputError(
+      "checkSpecies needs durations for the fifth species, whose note values are not fixed"
+    );
+  }
+  const ratio = SPECIES_RATIO[species];
+  const full = ratio * measures;
+  if (counterpoint.length !== full && counterpoint.length !== full - ratio + 1) {
+    return {
+      problem: `Species ${species} sets ${ratio} notes against each of the ${measures} cantus firmus notes, and the counterpoint has ${counterpoint.length}`
+    };
+  }
+  return { durations: impliedDurations(counterpoint.length, measures, ratio) };
+}
+function buildEntries(cantusFirmus, counterpoint, durations, counterpointAbove) {
+  const entries = [];
+  let onset = 0;
+  for (let index = 0; index < counterpoint.length; index += 1) {
+    const note = counterpoint[index];
+    const duration = durations[index] ?? 0;
+    if (note === void 0) {
+      continue;
+    }
+    const againstIndex = Math.min(Math.floor(onset + EPS), cantusFirmus.length - 1);
+    const against = cantusFirmus[againstIndex];
+    if (against === void 0) {
+      continue;
+    }
+    const interval = counterpointAbove ? spelledInterval(against, note) : spelledInterval(note, against);
+    entries.push({
+      note,
+      index,
+      onset,
+      duration,
+      against,
+      againstIndex,
+      downbeat: Math.abs(onset - Math.round(onset)) < EPS,
+      interval,
+      consonance: classifySpelledInterval(interval)
+    });
+    onset += duration;
+  }
+  return entries;
+}
+function motionPairs(entries) {
+  const pairs = [];
+  for (let position = 1; position < entries.length; position += 1) {
+    const previous = entries[position - 1];
+    const current = entries[position];
+    if (previous === void 0 || current === void 0) {
+      continue;
+    }
+    if (previous.againstIndex !== current.againstIndex) {
+      pairs.push([position - 1, position]);
+    }
+  }
+  return pairs;
+}
+function checkSpecies(cantusFirmus, counterpoint, species, mode, opts) {
+  if (!SPECIES_NUMBERS.includes(species)) {
+    throw new InvalidInputError(
+      `species must be one of ${SPECIES_NUMBERS.join(", ")}; received ${JSON.stringify(species)}`
+    );
+  }
+  if (cantusFirmus.length === 0 || counterpoint.length === 0) {
+    throw new InvalidInputError("checkSpecies needs both a cantus firmus and a counterpoint");
+  }
+  const resolved = resolveDurations(counterpoint, cantusFirmus.length, species, opts);
+  if ("problem" in resolved) {
+    return [violation("wrongRhythmicRatio", [1], 0, counterpoint.length - 1, resolved.problem)];
+  }
+  const counterpointAbove = opts?.counterpointAbove ?? meanPitch(counterpoint) >= meanPitch(cantusFirmus);
+  const entries = buildEntries(cantusFirmus, counterpoint, resolved.durations, counterpointAbove);
+  const violations = [];
+  for (let position = 0; position < entries.length; position += 1) {
+    violations.push(...verticalViolations(entries, position, species, counterpointAbove));
+    const previous = entries[position - 1];
+    const current = entries[position];
+    if (previous !== void 0 && current !== void 0) {
+      violations.push(...melodicViolations(previous, current));
+    }
+  }
+  violations.push(...melodicShapeViolations(entries, species));
+  for (const [from, to] of motionPairs(entries)) {
+    const previous = entries[from];
+    const current = entries[to];
+    if (previous !== void 0 && current !== void 0) {
+      violations.push(...motionViolations(previous, current, counterpointAbove));
+    }
+  }
+  violations.push(...cadenceViolations(entries, mode, counterpointAbove));
+  return violations;
+}
+
+// src/theory/partwriting/index.ts
+function bare(note) {
+  return { letter: note.letter, alter: note.alter };
+}
+function midiOf(note, index, voice) {
+  if (note.octave === void 0) {
+    throw new InvalidInputError(`voicings[${index}][${voice}] must carry an octave`);
+  }
+  return noteToMidi(note);
+}
+function isDescendingStep(interval) {
+  return interval.number === 2 && (interval.semitones === -1 || interval.semitones === -2);
+}
+function verticalViolations2(moment, ranges, maxSpacing) {
+  const found = [];
+  const { pitches, index } = moment;
+  for (let voice = 1; voice < pitches.length; voice += 1) {
+    const upper = pitches[voice];
+    const lower = pitches[voice - 1];
+    if (upper === void 0 || lower === void 0) {
+      continue;
+    }
+    if (createsVoiceCrossing(upper, lower)) {
+      found.push(
+        violation(
+          "voiceCrossing",
+          [voice - 1, voice],
+          index,
+          index,
+          "The upper voice lies below the voice beneath it"
+        )
+      );
+    }
+    if (voice >= 2 && exceedsSpacing(upper, lower, maxSpacing)) {
+      found.push(
+        violation(
+          "spacing",
+          [voice - 1, voice],
+          index,
+          index,
+          `Adjacent upper voices lie more than ${maxSpacing} semitones apart`
+        )
+      );
+    }
+  }
+  if (ranges === void 0) {
+    return found;
+  }
+  for (let voice = 0; voice < pitches.length; voice += 1) {
+    const pitch = pitches[voice];
+    const range = ranges[voice];
+    if (pitch === void 0 || range === void 0) {
+      continue;
+    }
+    if (pitch < range.min || pitch > range.max) {
+      found.push(violation("range", [voice], index, index, "The voice sings outside its range"));
+    }
+  }
+  return found;
+}
+function pairViolations(transition) {
+  const found = [];
+  const { from, to } = transition;
+  const voices = Math.min(from.pitches.length, to.pitches.length);
+  for (let lower = 0; lower < voices; lower += 1) {
+    for (let upper = lower + 1; upper < voices; upper += 1) {
+      const upperPrev = from.pitches[upper];
+      const upperCur = to.pitches[upper];
+      const lowerPrev = from.pitches[lower];
+      const lowerCur = to.pitches[lower];
+      if (upperPrev === void 0 || upperCur === void 0 || lowerPrev === void 0 || lowerCur === void 0) {
+        continue;
+      }
+      if (createsParallelPerfect(upperPrev, upperCur, lowerPrev, lowerCur)) {
+        const fifth = pitchClassOf(upperCur - lowerCur) === 7;
+        found.push(
+          violation(
+            fifth ? "parallelFifth" : "parallelOctave",
+            [lower, upper],
+            from.index,
+            to.index,
+            fifth ? "The two voices move into consecutive perfect fifths" : "The two voices move into consecutive perfect octaves"
+          )
+        );
+      }
+      if (upper === lower + 1 && createsVoiceOverlap(upperPrev, upperCur, lowerPrev, lowerCur)) {
+        found.push(
+          violation(
+            "overlap",
+            [lower, upper],
+            from.index,
+            to.index,
+            "The voice moves past where its neighbour just was"
+          )
+        );
+      }
+    }
+  }
+  const bassPrev = from.pitches[0];
+  const bassCur = to.pitches[0];
+  const topPrev = from.pitches[voices - 1];
+  const topCur = to.pitches[voices - 1];
+  if (voices >= 2 && bassPrev !== void 0 && bassCur !== void 0 && topPrev !== void 0 && topCur !== void 0 && createsHiddenParallelPerfect(topPrev, topCur, bassPrev, bassCur)) {
+    found.push(
+      violation(
+        "hiddenPerfect",
+        [0, voices - 1],
+        from.index,
+        to.index,
+        "The outer voices leap into a perfect interval by similar motion"
+      )
+    );
+  }
+  return found;
+}
+function inKey(pc, key) {
+  return (key.modeMask12 >> pitchClassOf(pc - key.rootPc) & 1) === 1;
+}
+function isDominantSonority(chord) {
+  const has = (semitones) => chord.intervals.some((interval) => pitchClassOf(interval) === semitones);
+  return chord.quality === "maj" || has(4) && has(10);
+}
+function isAppliedDominant(chord, next, key) {
+  if (next === void 0 || !isDominantSonority(chord)) {
+    return false;
+  }
+  const target = pitchClassOf(chord.rootPc + 5);
+  return target !== pitchClassOf(key.rootPc) && inKey(target, key) && pitchClassOf(next.rootPc) === target;
+}
+function isNeapolitan(chord, key) {
+  return chord.quality === "maj" && pitchClassOf(chord.rootPc - key.rootPc) === 1;
+}
+function soundsAugmentedSixth(moment, key) {
+  const bass = moment.notes[0];
+  if (bass === void 0 || noteToPitchClass(bass) !== pitchClassOf(key.rootPc + 8)) {
+    return false;
+  }
+  return moment.notes.some((note, voice) => {
+    if (voice === 0) {
+      return false;
+    }
+    const interval = spelledInterval(bass, note);
+    return (interval.number - 1) % 7 + 1 === 6 && pitchClassOf(interval.semitones) === 10;
+  });
+}
+function isChromaticHarmony(moment, next, key) {
+  return isAppliedDominant(moment.chord, next, key) || isNeapolitan(moment.chord, key) || soundsAugmentedSixth(moment, key);
+}
+function approachedByStep(before, moment, voice) {
+  const earlier = before?.notes[voice];
+  const later = moment.notes[voice];
+  if (earlier === void 0 || later === void 0) {
+    return false;
+  }
+  return spelledInterval(earlier, later).number === 2;
+}
+function isOuterVoice(voice, moment) {
+  return voice === 0 || voice === moment.notes.length - 1;
+}
+function crossRelationViolations(transition) {
+  const found = [];
+  const { from, to, key, before, after } = transition;
+  const chromatic = isChromaticHarmony(from, to.chord, key) || isChromaticHarmony(to, after?.chord, key);
+  const reported = /* @__PURE__ */ new Set();
+  for (let first = 0; first < from.notes.length; first += 1) {
+    for (let second = 0; second < to.notes.length; second += 1) {
+      if (first === second) {
+        continue;
+      }
+      const earlier = from.notes[first];
+      const later = to.notes[second];
+      if (earlier === void 0 || later === void 0) {
+        continue;
+      }
+      const letter = diatonicLetterOf(earlier.letter);
+      if (letter !== diatonicLetterOf(later.letter) || earlier.alter === later.alter) {
+        continue;
+      }
+      if (chromatic || approachedByStep(before, from, first) || approachedByStep(from, to, second) || !isOuterVoice(first, from) && !isOuterVoice(second, to)) {
+        continue;
+      }
+      const pair = `${letter}:${Math.min(first, second)}:${Math.max(first, second)}`;
+      if (reported.has(pair)) {
+        continue;
+      }
+      reported.add(pair);
+      found.push(
+        violation(
+          "crossRelation",
+          [first, second],
+          from.index,
+          to.index,
+          `${formatNote(bare(earlier))} is contradicted by ${formatNote(bare(later))} in another voice`
+        )
+      );
+    }
+  }
+  return found;
+}
+function melodicViolations2(transition) {
+  const found = [];
+  const { from, to, key } = transition;
+  const seventhPc = seventhPcOf(from.chord);
+  const nextPcs = new Set(chordPitchClasses(to.chord));
+  const leadingTonePc = leadingTonePcOf(key);
+  const tonicPc = pitchClassOf(key.rootPc);
+  const voices = Math.min(from.notes.length, to.notes.length);
+  for (let voice = 0; voice < voices; voice += 1) {
+    const earlier = from.notes[voice];
+    const later = to.notes[voice];
+    const earlierPitch = from.pitches[voice];
+    const laterPitch = to.pitches[voice];
+    if (earlier === void 0 || later === void 0 || earlierPitch === void 0 || laterPitch === void 0) {
+      continue;
+    }
+    const interval = spelledInterval(earlier, later);
+    if (isAugmentedMelodicInterval(earlier, later)) {
+      found.push(
+        violation(
+          "augmentedMelodicInterval",
+          [voice],
+          from.index,
+          to.index,
+          `The voice moves by an augmented ${intervalWord(interval.number)}`
+        )
+      );
+    }
+    const earlierPc = noteToPitchClass(earlier);
+    if (earlierPc === seventhPc && !nextPcs.has(earlierPc) && !isDescendingStep(interval)) {
+      found.push(
+        violation(
+          "unresolvedSeventh",
+          [voice],
+          from.index,
+          to.index,
+          "The chordal seventh does not fall by step"
+        )
+      );
+    }
+    if (earlierPc === leadingTonePc && isFunctioningLeadingTone(from.chord, key) && nextPcs.has(tonicPc) && !nextPcs.has(earlierPc) && !isLeadingToneResolution(earlierPitch, laterPitch, key)) {
+      found.push(
+        violation(
+          "unresolvedLeadingTone",
+          [voice],
+          from.index,
+          to.index,
+          "The leading tone does not rise to the tonic"
+        )
+      );
+    }
+  }
+  return found;
+}
+function spellVoicing(voicing, chord, key) {
+  const { tonic } = spelledKeyOf(key);
+  return voicing.map((pitch) => spellPitch(pitch, tonic, key, { chordRoot: chord.rootPc }));
+}
+function checkPartWriting(voicings, chords, key, opts) {
+  if (voicings.length !== chords.length) {
+    throw new InvalidInputError(
+      `checkPartWriting needs one chord per voicing; received ${voicings.length} voicings and ${chords.length} chords`
+    );
+  }
+  const maxSpacing = resolveMaxSpacing(opts);
+  const voiceCount = voicings.reduce((widest, voicing) => Math.max(widest, voicing.length), 0);
+  let ranges;
+  if (opts?.ranges === void 0) {
+    ranges = voiceCount === 4 ? SATB_RANGES : void 0;
+  } else {
+    ranges = resolveRanges(opts);
+    if (ranges.length < voiceCount) {
+      throw new InvalidInputError(
+        `checkPartWriting needs one range per voice; received ${ranges.length} ranges for ${voiceCount} voices`
+      );
+    }
+  }
+  const moments = [];
+  for (let index = 0; index < voicings.length; index += 1) {
+    const notes = voicings[index];
+    const chord = chords[index];
+    if (notes === void 0 || chord === void 0) {
+      continue;
+    }
+    moments.push({
+      notes,
+      pitches: notes.map((note, voice) => midiOf(note, index, voice)),
+      chord,
+      index
+    });
+  }
+  const violations = [];
+  for (let position = 0; position < moments.length; position += 1) {
+    const moment = moments[position];
+    const previous = position > 0 ? moments[position - 1] : void 0;
+    if (moment === void 0) {
+      continue;
+    }
+    if (previous !== void 0) {
+      const transition = {
+        from: previous,
+        to: moment,
+        key,
+        before: position > 1 ? moments[position - 2] : void 0,
+        after: moments[position + 1]
+      };
+      violations.push(...pairViolations(transition));
+      violations.push(...crossRelationViolations(transition));
+      violations.push(...melodicViolations2(transition));
+    }
+    violations.push(...verticalViolations2(moment, ranges, maxSpacing));
+  }
+  return violations;
+}
+
+export {
+  TRANSPOSING_INSTRUMENTS,
+  instrumentTransposition,
+  toSoundingPitch,
+  toWrittenPitch,
+  scaleMatchesChord,
+  chordScales,
+  avoidNotes,
+  availableTensions,
+  chordScaleReport,
+  scalesForChanges,
+  figuredBassRealization,
+  realizeFiguredBass,
+  figuredBassOf,
+  SATB_RANGES,
+  voiceChord,
+  voiceProgression,
+  voiceLeadingCost,
+  nextVoicing,
+  voiceChordStyled,
+  checkSpecies,
+  spellVoicing,
+  checkPartWriting
+};
+//# sourceMappingURL=chunk-H3VORETI.js.map