@libraz/libcantus 1.0.1 → 1.1.0

package/dist/{chunk-WWURE4XT.cjs → chunk-RVS4G4MR.cjs}

@@ -26,7 +26,6 @@
 
 
 
-var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
 
 
 
@@ -34,6 +33,7 @@ var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
 
 
 
+var _chunkYPB3A3EYcjs = require('./chunk-YPB3A3EY.cjs');
 
 
 
@@ -44,7 +44,18 @@ var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
 
 
 
-var _chunkQ2WGKJNNcjs = require('./chunk-Q2WGKJNN.cjs');
+
+
+
+
+
+
+
+
+
+
+
+var _chunkXKSO2V5Icjs = require('./chunk-XKSO2V5I.cjs');
 
 // src/theory/transposition/index.ts
 var TRANSPOSING_INSTRUMENTS = Object.freeze({
@@ -74,18 +85,22 @@ var TRANSPOSING_INSTRUMENTS = Object.freeze({
   contrabassoon: "-P8",
   guitar: "-P8"
 });
+var PROFILE_NAME_ALIASES = Object.freeze({
+  "guitar (drop D)": "guitar"
+});
 function instrumentTransposition(instrument) {
   if (typeof instrument !== "string") {
-    return _chunkQ2WGKJNNcjs.toSpelledInterval.call(void 0, instrument);
+    return _chunkXKSO2V5Icjs.toSpelledInterval.call(void 0, instrument);
   }
-  if (Object.hasOwn(TRANSPOSING_INSTRUMENTS, instrument)) {
-    return _chunkQ2WGKJNNcjs.parseInterval.call(void 0, TRANSPOSING_INSTRUMENTS[instrument]);
+  const name = Object.hasOwn(PROFILE_NAME_ALIASES, instrument) ? PROFILE_NAME_ALIASES[instrument] : instrument;
+  if (Object.hasOwn(TRANSPOSING_INSTRUMENTS, name)) {
+    return _chunkXKSO2V5Icjs.parseInterval.call(void 0, TRANSPOSING_INSTRUMENTS[name]);
   }
   try {
-    return _chunkQ2WGKJNNcjs.parseInterval.call(void 0, instrument);
+    return _chunkXKSO2V5Icjs.parseInterval.call(void 0, instrument);
   } catch (error) {
-    if (error instanceof _chunkQ2WGKJNNcjs.InvalidInputError) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
+    if (error instanceof _chunkXKSO2V5Icjs.InvalidInputError) {
+      throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
         `unknown transposing instrument ${JSON.stringify(instrument)}; pass a name from TRANSPOSING_INSTRUMENTS or an interval such as '-M2'`
       );
     }
@@ -93,332 +108,24 @@ function instrumentTransposition(instrument) {
   }
 }
 function reversedInterval(step) {
-  const reversed = {
+  return {
     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
+    semitones: step.semitones === 0 ? 0 : -step.semitones,
+    descending: !step.descending
   };
-  if (!(_nullishCoalesce(step.descending, () => ( step.semitones < 0)))) {
-    reversed.descending = true;
-  }
-  return reversed;
 }
 function toSoundingPitch(note, instrument) {
-  return _chunkQ2WGKJNNcjs.transposeByInterval.call(void 0, _chunkQ2WGKJNNcjs.toNoteData.call(void 0, note), instrumentTransposition(instrument));
+  return _chunkXKSO2V5Icjs.transposeByInterval.call(void 0, _chunkXKSO2V5Icjs.toNoteData.call(void 0, note), instrumentTransposition(instrument));
 }
 function toWrittenPitch(note, instrument) {
-  return _chunkQ2WGKJNNcjs.transposeByInterval.call(void 0, 
-    _chunkQ2WGKJNNcjs.toNoteData.call(void 0, note),
+  return _chunkXKSO2V5Icjs.transposeByInterval.call(void 0, 
+    _chunkXKSO2V5Icjs.toNoteData.call(void 0, 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 = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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 = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
-  const chordPcs = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, data);
-  const rootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, data.rootPc);
-  const ranked = [];
-  const seenMasks = /* @__PURE__ */ new Set();
-  for (const name of Object.keys(_chunkUADYAYATcjs.NAMED_SCALES)) {
-    if (name === "chromatic" || ALIASED_SCALE_NAMES.has(name)) {
-      continue;
-    }
-    const mask = _chunkUADYAYATcjs.namedScaleMask.call(void 0, 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 (_chunkUADYAYATcjs.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(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, rootPc + semitones));
-  if (sounds(3) || sounds(4)) {
-    return void 0;
-  }
-  if (sounds(5)) {
-    return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, rootPc + 5);
-  }
-  if (sounds(2)) {
-    return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, rootPc + 2);
-  }
-  return void 0;
-}
-function avoidNotes(chord, scaleName, opts = {}) {
-  const mask = _chunkUADYAYATcjs.requireScaleMask.call(void 0, scaleName);
-  const data = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
-  const rootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, data.rootPc);
-  const chordPcs = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, 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 : _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, suspended - 1);
-  const melodic = opts.use === "melodic";
-  const semitoneAboveRoot = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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 = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc);
-  const sounds = (semitones) => chordPcs.includes(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, rootPc + semitones));
-  if (!sounds(4) || !sounds(10)) {
-    return false;
-  }
-  const targetRootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, target.rootPc);
-  if (targetRootPc !== _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, rootPc + 5)) {
-    return false;
-  }
-  return _chunkUADYAYATcjs.chordPitchClasses.call(void 0, target).includes(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, targetRootPc + 3));
-}
-function availableTensions(chord, scaleName, opts = {}) {
-  const mask = _chunkUADYAYATcjs.requireScaleMask.call(void 0, scaleName);
-  const data = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
-  const rootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, data.rootPc);
-  const chordPcs = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, 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 : _chunkUADYAYATcjs.toChordData.call(void 0, opts.resolvesTo)
-  ) ? new Set(MINOR_RESOLUTION_TENSIONS.map((semitones) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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) && _optionalChain([functional, 'optionalAccess', _2 => _2.has, 'call', _3 => _3(pc)]) !== true) {
-      continue;
-    }
-    tensions.push(pc);
-  }
-  return tensions.sort((a, b) => a - b);
-}
-function chordScaleReport(chord, limit) {
-  if (limit !== void 0) {
-    _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, limit, "chord-scale report limit");
-  }
-  const data = _chunkUADYAYATcjs.toChordData.call(void 0, 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 = _chunkUADYAYATcjs.namedScaleMask.call(void 0, 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(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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) {
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, 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 = _nullishCoalesce(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 = _nullishCoalesce(candidateLists[i], () => ( []));
-    const prevCosts = _nullishCoalesce(dp[i - 1], () => ( []));
-    const prevSets = _nullishCoalesce(pcSets[i - 1], () => ( []));
-    const curSets = _nullishCoalesce(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(
-          _nullishCoalesce(prevSets[k], () => ( /* @__PURE__ */ new Set())),
-          _nullishCoalesce(curSets[j], () => ( /* @__PURE__ */ new Set()))
-        );
-        const cost = (_nullishCoalesce(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 = _nullishCoalesce(dp[dp.length - 1], () => ( []));
-  let bestFinal = 0;
-  for (let j = 1; j < lastCosts.length; j += 1) {
-    if ((_nullishCoalesce(lastCosts[j], () => ( Number.POSITIVE_INFINITY))) < (_nullishCoalesce(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 = _nullishCoalesce(_optionalChain([back, 'access', _4 => _4[i], 'optionalAccess', _5 => _5[current]]), () => ( -1));
-  }
-  return chords.map((chord, i) => {
-    const candidates = _nullishCoalesce(candidateLists[i], () => ( []));
-    const scale = _nullishCoalesce(candidates[_nullishCoalesce(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;
@@ -433,7 +140,7 @@ var DOUBLE_ACCIDENTALS = {
 var SINGLE_ACCIDENTALS = {
   "#": "sharp",
   "\u266F": "sharp",
-  "+": "sharp",
+  "+": "raised",
   b: "flat",
   "\u266D": "flat",
   n: "natural",
@@ -441,31 +148,28 @@ var SINGLE_ACCIDENTALS = {
 };
 var FIGURE_SEPARATORS = /* @__PURE__ */ new Set([" ", "	", ",", "/"]);
 var MOTION_MARKS = /* @__PURE__ */ new Set(["-", "\u2013"]);
-var ACCIDENTAL_GLYPHS = {
-  1: "#",
-  2: "##",
-  "-1": "b",
-  "-2": "bb"
-};
+var PRINTED_ACCIDENTALS = [
+  ["natural", "n", 0],
+  ["sharp", "#", 1],
+  ["doubleSharp", "##", 2],
+  ["flat", "b", -1],
+  ["doubleFlat", "bb", -2]
+];
+var PRINTED_ALTERS = new Map(
+  PRINTED_ACCIDENTALS.map(([accidental, , alter]) => [accidental, alter])
+);
+var ACCIDENTAL_GLYPHS = new Map(
+  PRINTED_ACCIDENTALS.map(([, glyph, alter]) => [alter, glyph])
+);
 function invalidFigures(figures, detail) {
-  return new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`figured bass ${JSON.stringify(figures)} ${detail}`);
+  return new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`figured bass ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, 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;
+  const printed = PRINTED_ALTERS.get(accidental);
+  if (printed !== void 0) {
+    return printed;
   }
+  return accidental === "raised" ? diatonicAlter + 1 : diatonicAlter;
 }
 function readFigure(text, start) {
   let index = start;
@@ -564,8 +268,8 @@ var FIGURE_ABBREVIATIONS = /* @__PURE__ */ new Map([
 ]);
 function tertianQualityIndex() {
   const index = /* @__PURE__ */ new Map();
-  for (const quality of _chunkUADYAYATcjs.chordQualities.call(void 0, )) {
-    const { intervals } = _chunkUADYAYATcjs.makeChord.call(void 0, 0, quality);
+  for (const quality of _chunkYPB3A3EYcjs.chordQualities.call(void 0, )) {
+    const { intervals } = _chunkYPB3A3EYcjs.makeChord.call(void 0, 0, quality);
     const template = intervals.join(",");
     if (intervals.length >= 3 && intervals.length <= MAX_STACK_SIZE && !index.has(template)) {
       index.set(template, quality);
@@ -575,22 +279,22 @@ function tertianQualityIndex() {
 }
 var TERTIAN_QUALITIES = tertianQualityIndex();
 function keyLetterAlters(key) {
-  const size = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, key).length;
+  const size = _chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, key.scale).length;
   if (size !== 7) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`figured bass requires a heptatonic key (received ${size} tones)`);
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`figured bass requires a heptatonic key (received ${size} tones)`);
   }
   const alters = [];
-  for (const note of _chunkUADYAYATcjs.spellScale.call(void 0, _chunkUADYAYATcjs.spelledKeyOf.call(void 0, key).tonic, key)) {
-    alters[_chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, note.letter)] = note.alter;
+  for (const note of _chunkYPB3A3EYcjs.spellScale.call(void 0, key.tonic, key.scale)) {
+    alters[_chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, note.letter)] = note.alter;
   }
   return alters;
 }
 function noteAbove(bass, figure, alters) {
-  const letter = _chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, bass.letter + figure.number - 1);
+  const letter = _chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, bass.letter + figure.number - 1);
   return { letter, alter: alteredBy(_nullishCoalesce(alters[letter], () => ( 0)), figure.accidental) };
 }
 function bareNote(note) {
-  return { letter: _chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, note.letter), alter: note.alter };
+  return { letter: _chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, 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);
@@ -604,36 +308,35 @@ function realizeSonority(bass, resolved, text, alters) {
   );
   const tones = [bass, ...notes];
   const root = _nullishCoalesce(tones[[1, ...sonority.intervals].indexOf(sonority.rootInterval)], () => ( bass));
-  const rootPc = _chunkQ2WGKJNNcjs.noteToPitchClass.call(void 0, root);
+  const rootPc = _chunkXKSO2V5Icjs.noteToPitchClass.call(void 0, root);
   const stack = [];
   for (let step = 0; step < tones.length; step += 1) {
-    const tone = tones.find((candidate) => _chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, candidate.letter - root.letter) === step * 2);
+    const tone = tones.find((candidate) => _chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, candidate.letter - root.letter) === step * 2);
     if (tone === void 0) {
-      throw new (0, _chunkQ2WGKJNNcjs.NoSolutionError)(
-        `figured bass ${JSON.stringify(text)} sounds ${_chunkUADYAYATcjs.noteNames.call(void 0, tones).join(" ")}, which does not stack in thirds`
+      throw new (0, _chunkXKSO2V5Icjs.NoSolutionError)(
+        `figured bass ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, text)} sounds ${_chunkYPB3A3EYcjs.noteNames.call(void 0, tones).join(" ")}, which does not stack in thirds`
       );
     }
-    stack.push(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _chunkQ2WGKJNNcjs.noteToPitchClass.call(void 0, tone) - rootPc));
+    stack.push(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _chunkXKSO2V5Icjs.noteToPitchClass.call(void 0, tone) - rootPc));
   }
   const quality = TERTIAN_QUALITIES.get(stack.join(","));
   if (quality === void 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.NoSolutionError)(
-      `figured bass ${JSON.stringify(text)} sounds ${_chunkUADYAYATcjs.noteNames.call(void 0, tones).join(" ")}, which no chord quality names`
+    throw new (0, _chunkXKSO2V5Icjs.NoSolutionError)(
+      `figured bass ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, text)} sounds ${_chunkYPB3A3EYcjs.noteNames.call(void 0, tones).join(" ")}, which no chord quality names`
     );
   }
-  const chord = _chunkUADYAYATcjs.makeChord.call(void 0, rootPc, quality, _chunkQ2WGKJNNcjs.noteToPitchClass.call(void 0, bass));
+  const chord = _chunkYPB3A3EYcjs.makeChord.call(void 0, rootPc, quality, _chunkXKSO2V5Icjs.noteToPitchClass.call(void 0, 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 (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`figured bass must be a string; received ${typeof figures}`);
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`figured bass must be a string; received ${typeof figures}`);
   }
-  const bassData = _chunkQ2WGKJNNcjs.toNoteData.call(void 0, bass);
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const alters = keyLetterAlters(scale);
-  _chunkQ2WGKJNNcjs.noteToPitchClass.call(void 0, bassData);
+  const bassData = _chunkXKSO2V5Icjs.toNoteData.call(void 0, bass);
+  const alters = keyLetterAlters(_chunkYPB3A3EYcjs.resolveKey.call(void 0, key));
+  _chunkXKSO2V5Icjs.noteToPitchClass.call(void 0, bassData);
   const bassNote = bareNote(bassData);
   const text = figures.trim();
   const { figures: written, motions } = parseFigures(text);
@@ -654,90 +357,170 @@ function realizeFiguredBass(bass, figures, key) {
   return figuredBassRealization(bass, figures, key).chord;
 }
 function figuredBassOf(chord, key) {
-  const data = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const alters = keyLetterAlters(scale);
-  const tones = _chunkUADYAYATcjs.spellChord.call(void 0, data, _chunkUADYAYATcjs.spelledKeyOf.call(void 0, scale).tonic, scale);
-  const bassPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _nullishCoalesce(data.bassPc, () => ( data.rootPc)));
-  const bass = tones.find((tone) => _chunkQ2WGKJNNcjs.noteToPitchClass.call(void 0, tone) === bassPc);
+  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
+  const resolved = _chunkYPB3A3EYcjs.resolveKey.call(void 0, key);
+  const alters = keyLetterAlters(resolved);
+  const tones = _chunkYPB3A3EYcjs.spellChord.call(void 0, data, resolved.tonic, resolved.scale);
+  const bassPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _nullishCoalesce(data.bassPc, () => ( data.rootPc)));
+  const bass = tones.find((tone) => _chunkXKSO2V5Icjs.noteToPitchClass.call(void 0, tone) === bassPc);
   if (bass === void 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.NoSolutionError)(
+    throw new (0, _chunkXKSO2V5Icjs.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(_chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, tone.letter - bass.letter) + 1, tone);
+      written.set(_chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, 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 (0, _chunkQ2WGKJNNcjs.NoSolutionError)(
-      `no figured bass names ${_chunkUADYAYATcjs.noteNames.call(void 0, tones).join(" ")} over ${_chunkUADYAYATcjs.noteNames.call(void 0, [bass])[0]}`
+    throw new (0, _chunkXKSO2V5Icjs.NoSolutionError)(
+      `no figured bass names ${_chunkYPB3A3EYcjs.noteNames.call(void 0, tones).join(" ")} over ${_chunkYPB3A3EYcjs.noteNames.call(void 0, [bass])[0]}`
     );
   }
   const accidentals = /* @__PURE__ */ new Map();
   for (const [number, tone] of written) {
-    const alteration = tone.alter - (_nullishCoalesce(alters[_chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, tone.letter)], () => ( 0)));
-    if (alteration === 0) {
+    if (tone.alter === (_nullishCoalesce(alters[_chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, tone.letter)], () => ( 0)))) {
       continue;
     }
-    const glyph = ACCIDENTAL_GLYPHS[alteration];
+    const glyph = ACCIDENTAL_GLYPHS.get(tone.alter);
     if (glyph === void 0) {
-      throw new (0, _chunkQ2WGKJNNcjs.NoSolutionError)(
-        `no figure names an interval altered by ${alteration} semitones from the key`
-      );
+      throw new (0, _chunkXKSO2V5Icjs.NoSolutionError)(`no accidental writes a note altered by ${tone.alter} semitones`);
     }
     accidentals.set(number, glyph);
   }
   const figures = [.../* @__PURE__ */ new Set([...digits, ...accidentals.keys()])].sort((a, b) => b - a).map((number) => `${_nullishCoalesce(accidentals.get(number), () => ( ""))}${number}`).join("");
-  assertRealizesAs(bass, figures, scale, tones);
+  assertRealizesAs(bass, figures, resolved, tones);
   return figures;
 }
 function pitchClassesOf(notes) {
-  return [...new Set(notes.map(_chunkQ2WGKJNNcjs.noteToPitchClass))].sort((a, b) => a - b);
+  return [...new Set(notes.map(_chunkXKSO2V5Icjs.noteToPitchClass))].sort((a, b) => a - b);
 }
 function assertRealizesAs(bass, figures, key, tones) {
-  const noFigures = (detail) => new (0, _chunkQ2WGKJNNcjs.NoSolutionError)(
-    `no figured bass names ${_chunkUADYAYATcjs.noteNames.call(void 0, tones).join(" ")} over ${_chunkUADYAYATcjs.noteNames.call(void 0, [bass])[0]}: the figures ${JSON.stringify(figures)} ${detail}`
+  const noFigures = (detail) => new (0, _chunkXKSO2V5Icjs.NoSolutionError)(
+    `no figured bass names ${_chunkYPB3A3EYcjs.noteNames.call(void 0, tones).join(" ")} over ${_chunkYPB3A3EYcjs.noteNames.call(void 0, [bass])[0]}: the figures ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, figures)} ${detail}`
   );
   let realized;
   try {
     realized = figuredBassRealization(bass, figures, key);
   } catch (error) {
-    throw error instanceof _chunkQ2WGKJNNcjs.NoSolutionError ? noFigures("read back as no chord at all") : error;
+    throw error instanceof _chunkXKSO2V5Icjs.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 ${_chunkUADYAYATcjs.noteNames.call(void 0, realized.notes).join(" ")} instead`);
+    throw noFigures(`sound ${_chunkYPB3A3EYcjs.noteNames.call(void 0, realized.notes).join(" ")} instead`);
   }
 }
 
-// src/theory/voicing/tendency.ts
-function leadingTonePcOf(key) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc - 1);
+// src/theory/partwriting/cross-relation.ts
+function resolvesAsAppliedDominant(chord, next, key) {
+  if (next === void 0 || !_chunkYPB3A3EYcjs.hasDominantSonority.call(void 0, chord)) {
+    return false;
+  }
+  const target = _chunkYPB3A3EYcjs.appliedDominantTarget.call(void 0, chord.rootPc + 5, key);
+  return target !== null && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, next.rootPc) === target.rootPc;
 }
-var LEADING_TONE_QUALITIES = /* @__PURE__ */ new Set(["dim", "dim7", "m7b5"]);
-function isFunctioningLeadingTone(chord, key) {
-  const role = _chunkUADYAYATcjs.chordToneRole.call(void 0, leadingTonePcOf(key), chord);
-  if (role === "third") {
-    return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc) === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc + 7);
+function soundsAugmentedSixth(moment, key) {
+  const bass = moment.notes[0];
+  if (bass === void 0 || _chunkXKSO2V5Icjs.noteToPitchClass.call(void 0, bass) !== _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc + 8)) {
+    return false;
   }
-  if (role === "root") {
-    return LEADING_TONE_QUALITIES.has(chord.quality);
+  return moment.notes.some((note, voice) => {
+    if (voice === 0) {
+      return false;
+    }
+    const interval = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, bass, note);
+    return (interval.number - 1) % 7 + 1 === 6 && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, interval.semitones) === 10;
+  });
+}
+function isChromaticHarmony(moment, next, key) {
+  return resolvesAsAppliedDominant(moment.chord, next, key) || _chunkYPB3A3EYcjs.isNeapolitanChordOf.call(void 0, moment.chord, key) || soundsAugmentedSixth(moment, key);
+}
+function approachedByStep(before, moment, voice) {
+  const earlier = _optionalChain([before, 'optionalAccess', _2 => _2[voice]]);
+  const later = moment[voice];
+  if (earlier === void 0 || later === void 0) {
+    return false;
   }
-  return false;
+  return _chunkXKSO2V5Icjs.spelledInterval.call(void 0, earlier, later).number === 2;
 }
-function seventhPcOf(chord) {
-  for (const interval of chord.intervals) {
-    const pc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc + interval);
-    if (_chunkUADYAYATcjs.chordToneRole.call(void 0, pc, chord) === "seventh") {
-      return pc;
+function isOuterVoice(voice, notes) {
+  return voice === 0 || voice === notes.length - 1;
+}
+function crossRelations(from, to, key, context = {}) {
+  const found = [];
+  const chromatic = isChromaticHarmony(from, to.chord, key) || isChromaticHarmony(to, context.after, key);
+  if (chromatic) {
+    return found;
+  }
+  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 = _chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, earlier.letter);
+      if (letter !== _chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, later.letter) || earlier.alter === later.alter) {
+        continue;
+      }
+      if (approachedByStep(context.before, from.notes, first) || approachedByStep(from.notes, to.notes, second) || !isOuterVoice(first, from.notes) && !isOuterVoice(second, to.notes)) {
+        continue;
+      }
+      const pair = `${letter}:${Math.min(first, second)}:${Math.max(first, second)}`;
+      if (reported.has(pair)) {
+        continue;
+      }
+      reported.add(pair);
+      found.push({ earlierVoice: first, laterVoice: second, earlier, later });
     }
   }
-  return void 0;
+  return found;
+}
+
+// src/theory/voicing/tendency.ts
+function spellingTable(keyLike, chord) {
+  const { tonic, scale: key } = _chunkYPB3A3EYcjs.resolveKey.call(void 0, keyLike);
+  const notes = [];
+  const bases = [];
+  for (let pc = 0; pc < 12; pc += 1) {
+    const note = chord === void 0 ? _chunkYPB3A3EYcjs.spellPitchClass.call(void 0, pc, tonic, key) : _chunkYPB3A3EYcjs.spellPitchClass.call(void 0, pc, tonic, key, { chord });
+    notes.push(note);
+    bases.push(_chunkXKSO2V5Icjs.noteToMidi.call(void 0, { letter: note.letter, alter: note.alter, octave: 0 }));
+  }
+  return { notes, bases };
+}
+function spelledAt(table, pitch) {
+  const pc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch);
+  const note = table.notes[pc];
+  const base = table.bases[pc];
+  if (note === void 0 || base === void 0) {
+    return void 0;
+  }
+  return { letter: note.letter, alter: note.alter, octave: (pitch - base) / 12 };
+}
+function movesByAugmentedInterval(from, fromPitch, to, toPitch) {
+  const earlier = spelledAt(from, fromPitch);
+  const later = spelledAt(to, toPitch);
+  if (earlier === void 0 || later === void 0) {
+    return false;
+  }
+  return _chunkYPB3A3EYcjs.isAugmentedMelodicInterval.call(void 0, earlier, later);
+}
+function movesByDescendingStep(from, fromPitch, to, toPitch) {
+  const earlier = spelledAt(from, fromPitch);
+  const later = spelledAt(to, toPitch);
+  if (earlier === void 0 || later === void 0) {
+    return false;
+  }
+  return _chunkYPB3A3EYcjs.isDescendingStep.call(void 0, _chunkXKSO2V5Icjs.spelledInterval.call(void 0, earlier, later));
 }
 
 // src/theory/voicing/internal.ts
@@ -750,8 +533,11 @@ var UNISON_PENALTY = 100;
 var LEADING_TONE_DOUBLING_PENALTY = 200;
 var RESOLUTION_PENALTY = 200;
 var DEFAULT_MAX_CANDIDATES = 4e3;
+var MAX_LOOKAHEAD_PAIRS = 1e6;
 var SEARCH_NODES_PER_CANDIDATE = 16;
-var HIDDEN_PERFECT_PENALTY = 6;
+var HIDDEN_PERFECT_PENALTY = 100;
+var CROSS_RELATION_PENALTY = HIDDEN_PERFECT_PENALTY;
+var AUGMENTED_MELODIC_PENALTY = VIOLATION_PENALTY;
 var INITIAL_CANDIDATE_CAPACITY = 512;
 function createCandidateBuffer() {
   return { pitches: new Int32Array(0), count: 0, voices: 0 };
@@ -759,7 +545,7 @@ function createCandidateBuffer() {
 function pitchesForPc(pc, range) {
   const result = [];
   for (let midi = Math.ceil(range.min); midi <= range.max; midi += 1) {
-    if (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, midi) === pc) {
+    if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, midi) === pc) {
       result.push(midi);
     }
   }
@@ -771,14 +557,14 @@ function pitchesForPc(pc, range) {
   });
 }
 function enumerateVoicings(chord, ranges, maxSpacing, maxCandidates = DEFAULT_MAX_CANDIDATES, into = createCandidateBuffer()) {
-  const chordPcs = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord);
-  const bassPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc)));
+  const chordPcs = _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord);
+  const bassPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _nullishCoalesce(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 ((_nullishCoalesce(byVoice[voice], () => ( []))).length === 0) {
-      throw new (0, _chunkQ2WGKJNNcjs.NoSolutionError)("no voicing satisfies the given ranges");
+      throw new (0, _chunkXKSO2V5Icjs.NoSolutionError)("no voicing satisfies the given ranges");
     }
   }
   const voices = ranges.length;
@@ -827,17 +613,17 @@ function enumerateVoicings(chord, ranges, maxSpacing, maxCandidates = DEFAULT_MA
   return into;
 }
 function structuralTables(chord, key) {
-  const tones = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord);
+  const tones = _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord);
   const missing = tones.map(
-    (pc) => _chunkUADYAYATcjs.chordToneRole.call(void 0, pc, chord) === "fifth" ? MISSING_FIFTH_PENALTY : MISSING_TONE_PENALTY
+    (pc) => _chunkYPB3A3EYcjs.chordToneRole.call(void 0, pc, chord) === "fifth" ? MISSING_FIFTH_PENALTY : MISSING_TONE_PENALTY
   );
-  const rootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc);
-  const leadingTonePc = key !== void 0 && isFunctioningLeadingTone(chord, key) ? leadingTonePcOf(key) : -1;
+  const rootPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc);
+  const leadingTonePc = key !== void 0 && _chunkYPB3A3EYcjs.isFunctioningLeadingTone.call(void 0, chord, key) ? _chunkYPB3A3EYcjs.leadingTonePcOf.call(void 0, 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 && _chunkUADYAYATcjs.chordToneRole.call(void 0, pc, chord) !== "fifth") {
+    } else if (pc !== rootPc && _chunkYPB3A3EYcjs.chordToneRole.call(void 0, pc, chord) !== "fifth") {
       doubling[pc] = POOR_DOUBLING_PENALTY;
     }
   }
@@ -852,7 +638,7 @@ function structuralPenalty(tables, pitches, offset, voices) {
     if (pitch === void 0) {
       continue;
     }
-    const pc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitch);
+    const pc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch);
     PITCH_CLASS_COUNTS[pc] = (_nullishCoalesce(PITCH_CLASS_COUNTS[pc], () => ( 0))) + 1;
     if (index > 0 && pitch === pitches[offset + index - 1]) {
       penalty += UNISON_PENALTY;
@@ -874,18 +660,19 @@ function structuralPenalty(tables, pitches, offset, voices) {
 }
 function resolutionTables(prevChord, nextChord, key) {
   const nextHas = new Uint8Array(12);
-  for (const pc of _chunkUADYAYATcjs.chordPitchClasses.call(void 0, nextChord)) {
+  for (const pc of _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, nextChord)) {
     nextHas[pc] = 1;
   }
   return {
-    seventhPc: _nullishCoalesce(seventhPcOf(prevChord), () => ( -1)),
-    leadingTonePc: key !== void 0 && isFunctioningLeadingTone(prevChord, key) ? leadingTonePcOf(key) : -1,
-    tonicPc: key === void 0 ? -1 : _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc),
-    nextHas
+    seventhPc: _nullishCoalesce(_chunkYPB3A3EYcjs.seventhPcOf.call(void 0, prevChord), () => ( -1)),
+    leadingTonePc: key !== void 0 && _chunkYPB3A3EYcjs.isFunctioningLeadingTone.call(void 0, prevChord, key) ? _chunkYPB3A3EYcjs.leadingTonePcOf.call(void 0, key) : -1,
+    tonicPc: key === void 0 ? -1 : _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc),
+    nextHas,
+    nextChord
   };
 }
-function resolutionViolations(tables, prev, prevOffset, cur, curOffset, voices) {
-  const { seventhPc, leadingTonePc, tonicPc, nextHas } = tables;
+function resolutionViolations(tables, spelling, prev, prevOffset, cur, curOffset, voices) {
+  const { seventhPc, leadingTonePc, tonicPc, nextHas, nextChord } = tables;
   let count = 0;
   for (let voice = 0; voice < voices; voice += 1) {
     const from = prev[prevOffset + voice];
@@ -893,12 +680,14 @@ function resolutionViolations(tables, prev, prevOffset, cur, curOffset, voices)
     if (from === void 0 || to === void 0) {
       continue;
     }
-    const fromPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, from);
+    const fromPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, from);
     const motion = to - from;
-    if (fromPc === seventhPc && nextHas[fromPc] === 0 && motion !== -1 && motion !== -2) {
+    const resolved = spelling === void 0 ? motion === -1 || motion === -2 : movesByDescendingStep(spelling.from, from, spelling.to, to);
+    if (fromPc === seventhPc && nextHas[fromPc] === 0 && !resolved) {
       count += 1;
     }
-    if (fromPc === leadingTonePc && tonicPc >= 0 && nextHas[tonicPc] === 1 && nextHas[fromPc] === 0 && motion !== 1) {
+    const inner = voice > 0 && voice < voices - 1;
+    if (fromPc === leadingTonePc && tonicPc >= 0 && nextHas[tonicPc] === 1 && nextHas[fromPc] === 0 && motion !== 1 && !(inner && _chunkYPB3A3EYcjs.isFrustratedLeadingTone.call(void 0, from, to, nextChord))) {
       count += 1;
     }
   }
@@ -914,16 +703,76 @@ function leadingCost(prev, prevOffset, cur, curOffset, voices) {
     }
     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 && _chunkUADYAYATcjs.createsHiddenParallelPerfect.call(void 0, bassPrev, bassCur, sopPrev, sopCur)) {
-      total += HIDDEN_PERFECT_PENALTY;
+  return total;
+}
+function createsOuterHiddenPerfect(prev, prevOffset, cur, curOffset, voices) {
+  if (voices < 2) {
+    return false;
+  }
+  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) {
+    return false;
+  }
+  return _chunkYPB3A3EYcjs.createsHiddenParallelPerfect.call(void 0, sopPrev, sopCur, bassPrev, bassCur);
+}
+function augmentedMelodicCount(spelling, prev, prevOffset, cur, curOffset, voices) {
+  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;
+    }
+    if (movesByAugmentedInterval(spelling.from, from, spelling.to, to)) {
+      count += 1;
     }
   }
-  return total;
+  return count;
+}
+function spellRow(table, pitches, offset, voices) {
+  const notes = [];
+  for (let voice = 0; voice < voices; voice += 1) {
+    const pitch = pitches[offset + voice];
+    const note = pitch === void 0 ? void 0 : spelledAt(table, pitch);
+    if (note !== void 0) {
+      notes.push(note);
+    }
+  }
+  return notes;
+}
+function contradictsALetter(spelling, prev, prevOffset, cur, curOffset, voices) {
+  for (let voice = 0; voice < voices; voice += 1) {
+    const from = prev[prevOffset + voice];
+    const earlier = from === void 0 ? void 0 : spelling.from.notes[_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, from)];
+    if (earlier === void 0) {
+      continue;
+    }
+    for (let other = 0; other < voices; other += 1) {
+      if (other === voice) {
+        continue;
+      }
+      const to = cur[curOffset + other];
+      const later = to === void 0 ? void 0 : spelling.to.notes[_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, to)];
+      if (later !== void 0 && earlier.alter !== later.alter && _chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, earlier.letter) === _chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, later.letter)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function crossRelationCount(spelling, tables, prev, prevOffset, cur, curOffset, voices) {
+  if (!contradictsALetter(spelling, prev, prevOffset, cur, curOffset, voices)) {
+    return 0;
+  }
+  return crossRelations(
+    { notes: spellRow(spelling.from, prev, prevOffset, voices), chord: tables.fromChord },
+    { notes: spellRow(spelling.to, cur, curOffset, voices), chord: tables.toChord },
+    tables.key,
+    { after: tables.afterChord }
+  ).length;
 }
 function violationCount(prev, prevOffset, cur, curOffset, voices) {
   let count = 0;
@@ -936,11 +785,11 @@ function violationCount(prev, prevOffset, cur, curOffset, voices) {
       if (prevLower === void 0 || prevUpper === void 0 || curLower === void 0 || curUpper === void 0) {
         continue;
       }
-      if (_chunkUADYAYATcjs.createsParallelPerfect.call(void 0, prevUpper, curUpper, prevLower, curLower)) {
+      if (_chunkYPB3A3EYcjs.createsParallelPerfect.call(void 0, prevUpper, curUpper, prevLower, curLower)) {
         count += 1;
       }
       if (upper === lower + 1) {
-        if (_chunkUADYAYATcjs.createsVoiceOverlap.call(void 0, prevUpper, curUpper, prevLower, curLower)) {
+        if (_chunkYPB3A3EYcjs.createsVoiceOverlap.call(void 0, prevUpper, curUpper, prevLower, curLower)) {
           count += 1;
         }
       }
@@ -948,6 +797,24 @@ function violationCount(prev, prevOffset, cur, curOffset, voices) {
   }
   return count;
 }
+function moveScoring(prevChord, chord, key, nextChord) {
+  return {
+    structure: structuralTables(chord, _optionalChain([key, 'optionalAccess', _3 => _3.scale])),
+    resolution: prevChord === void 0 ? void 0 : resolutionTables(prevChord, chord, _optionalChain([key, 'optionalAccess', _4 => _4.scale])),
+    spelling: key === void 0 ? void 0 : { from: spellingTable(key, prevChord), to: spellingTable(key, chord) },
+    crossRelation: prevChord === void 0 || key === void 0 ? void 0 : { fromChord: prevChord, toChord: chord, afterChord: nextChord, key: key.scale }
+  };
+}
+function violationWeight(scoring, prev, prevOffset, cur, curOffset, voices) {
+  const { resolution, spelling, crossRelation } = scoring;
+  const unresolved = resolution === void 0 ? 0 : resolutionViolations(resolution, spelling, prev, prevOffset, cur, curOffset, voices);
+  const augmented = spelling === void 0 ? 0 : augmentedMelodicCount(spelling, prev, prevOffset, cur, curOffset, voices);
+  const contradictions = spelling === void 0 || crossRelation === void 0 ? 0 : crossRelationCount(spelling, crossRelation, prev, prevOffset, cur, curOffset, voices);
+  return VIOLATION_PENALTY * violationCount(prev, prevOffset, cur, curOffset, voices) + RESOLUTION_PENALTY * unresolved + AUGMENTED_MELODIC_PENALTY * augmented + CROSS_RELATION_PENALTY * contradictions + (createsOuterHiddenPerfect(prev, prevOffset, cur, curOffset, voices) ? HIDDEN_PERFECT_PENALTY : 0);
+}
+function moveScore(scoring, prev, prevOffset, cur, curOffset, voices) {
+  return structuralPenalty(scoring.structure, cur, curOffset, voices) + leadingCost(prev, prevOffset, cur, curOffset, voices) + violationWeight(scoring, prev, prevOffset, cur, curOffset, voices);
+}
 
 // src/theory/voicing/satb.ts
 var SATB_RANGES = Object.freeze([
@@ -960,18 +827,19 @@ var DERIVED_LOW = 40;
 var DERIVED_HIGH = 79;
 var DERIVED_SPAN = 19;
 function resolveRanges(opts) {
-  if (_optionalChain([opts, 'optionalAccess', _6 => _6.ranges]) !== void 0) {
+  _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  if (_optionalChain([opts, 'optionalAccess', _5 => _5.ranges]) !== void 0) {
     if (opts.ranges.length === 0) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("ranges must contain at least one voice range");
+      throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)("ranges must contain at least one voice range");
     }
-    _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, opts.ranges.length, "voice ranges", 128);
+    _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, opts.ranges.length, "voice ranges", 128);
     return opts.ranges.map((range, index) => {
-      _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, range.min, `ranges[${index}].min`);
-      _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, range.max, `ranges[${index}].max`);
+      _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, range.min, `ranges[${index}].min`);
+      _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, range.max, `ranges[${index}].max`);
       if (range.min > range.max) {
-        throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`ranges[${index}].min must not exceed max`);
+        throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`ranges[${index}].min must not exceed max`);
       }
-      _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, 
+      _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, 
         Math.floor(range.max) - Math.ceil(range.min) + 1,
         `ranges[${index}] span`,
         4096
@@ -979,8 +847,8 @@ function resolveRanges(opts) {
       return { ...range };
     });
   }
-  const voices = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _7 => _7.voices]), () => ( 4));
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, voices, "voices", 128);
+  const voices = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _6 => _6.voices]), () => ( 4));
+  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, voices, "voices", 128);
   if (voices === 4) {
     return SATB_RANGES.map((range) => ({ ...range }));
   }
@@ -997,59 +865,63 @@ function resolveRanges(opts) {
   return ranges;
 }
 function resolveMaxSpacing(opts) {
-  const maxSpacing = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _8 => _8.maxSpacing]), () => ( DEFAULT_MAX_SPACING));
-  _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, maxSpacing, "maxSpacing");
+  const maxSpacing = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _7 => _7.maxSpacing]), () => ( DEFAULT_MAX_SPACING));
+  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, maxSpacing, "maxSpacing");
   if (maxSpacing < 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("maxSpacing must be non-negative");
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)("maxSpacing must be non-negative");
   }
   return maxSpacing;
 }
-function resolveKey(opts) {
-  return _optionalChain([opts, 'optionalAccess', _9 => _9.key]) === void 0 ? void 0 : _chunkUADYAYATcjs.toKeyScale.call(void 0, opts.key);
+function resolvedKeyOf(opts) {
+  return _optionalChain([opts, 'optionalAccess', _8 => _8.key]) === void 0 ? void 0 : _chunkYPB3A3EYcjs.resolveKey.call(void 0, opts.key);
 }
 function resolvePreviousChord(opts) {
-  return _optionalChain([opts, 'optionalAccess', _10 => _10.previousChord]) === void 0 ? void 0 : _chunkUADYAYATcjs.toChordData.call(void 0, opts.previousChord);
+  return _optionalChain([opts, 'optionalAccess', _9 => _9.previousChord]) === void 0 ? void 0 : _chunkYPB3A3EYcjs.toChordData.call(void 0, opts.previousChord);
 }
 function resolveMaxCandidates(opts) {
-  if (_optionalChain([opts, 'optionalAccess', _11 => _11.maxCandidates]) === void 0) return void 0;
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, opts.maxCandidates, "maxCandidates", 1e6);
+  if (_optionalChain([opts, 'optionalAccess', _10 => _10.maxCandidates]) === void 0) return void 0;
+  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, opts.maxCandidates, "maxCandidates", 1e6);
   return opts.maxCandidates;
 }
+function centeringPenalty(ranges, pitches, offset, voices) {
+  let penalty = 0;
+  for (let voice = 0; voice < voices; voice += 1) {
+    const pitch = pitches[offset + voice];
+    const range = ranges[voice];
+    if (pitch === void 0 || range === void 0) {
+      continue;
+    }
+    penalty += Math.abs(pitch - (range.min + range.max) / 2);
+  }
+  return penalty;
+}
 function voiceChord(chord, opts) {
-  const data = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
+  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
   const ranges = resolveRanges(opts);
   const maxSpacing = resolveMaxSpacing(opts);
   const candidates = enumerateVoicings(data, ranges, maxSpacing, resolveMaxCandidates(opts));
-  const tables = structuralTables(data, resolveKey(opts));
+  const { structure } = moveScoring(void 0, data, resolvedKeyOf(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);
-    }
+    const score = structuralPenalty(structure, pitches, offset, voices) + centeringPenalty(ranges, pitches, offset, voices);
     if (score < bestScore) {
       bestScore = score;
       bestOffset = offset;
     }
   }
   if (bestOffset < 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.NoSolutionError)(
-      `no voicing satisfies the given ranges for ${_chunkUADYAYATcjs.formatChordSymbol.call(void 0, chord)}`
+    throw new (0, _chunkXKSO2V5Icjs.NoSolutionError)(
+      `no voicing satisfies the given ranges for ${_chunkYPB3A3EYcjs.formatChordSymbol.call(void 0, chord)}`
     );
   }
   return [...pitches.subarray(bestOffset, bestOffset + voices)];
 }
 function noSolutionAt(index, chord) {
-  return new (0, _chunkQ2WGKJNNcjs.NoSolutionError)(
-    `no voicing satisfies the given ranges for ${_chunkUADYAYATcjs.formatChordSymbol.call(void 0, chord)} at index ${index}`,
+  return new (0, _chunkXKSO2V5Icjs.NoSolutionError)(
+    `no voicing satisfies the given ranges for ${_chunkYPB3A3EYcjs.formatChordSymbol.call(void 0, chord)} at index ${index}`,
     { at: index }
   );
 }
@@ -1057,48 +929,72 @@ function locate(index, chord, work) {
   try {
     return work();
   } catch (error) {
-    if (error instanceof _chunkQ2WGKJNNcjs.NoSolutionError) {
+    if (error instanceof _chunkXKSO2V5Icjs.NoSolutionError) {
       throw noSolutionAt(index, chord);
     }
     throw error;
   }
 }
+function successorWeight(next, cur, curOffset, voices) {
+  const { candidates, scoring } = next;
+  const { pitches } = candidates;
+  let bestScore = Number.POSITIVE_INFINITY;
+  let bestWeight = 0;
+  for (let candidate = 0; candidate < candidates.count; candidate += 1) {
+    const offset = candidate * voices;
+    const weight = violationWeight(scoring, cur, curOffset, pitches, offset, voices);
+    const score = weight + structuralPenalty(scoring.structure, pitches, offset, voices) + leadingCost(cur, curOffset, pitches, offset, voices);
+    if (score < bestScore) {
+      bestScore = score;
+      bestWeight = weight;
+    }
+  }
+  return bestWeight;
+}
 function voiceProgression(chords, opts) {
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, chords.length, "voiced progression chords", _optionalChain([opts, 'optionalAccess', _12 => _12.budget]));
-  const data = chords.map((chord) => _chunkUADYAYATcjs.toChordData.call(void 0, chord));
-  const key = resolveKey(opts);
+  const progression = _chunkXKSO2V5Icjs.assertArray.call(void 0, chords, "chords");
+  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, progression.length, "voiced progression chords", _optionalChain([opts, 'optionalAccess', _11 => _11.budget]));
+  const data = progression.map((chord) => _chunkYPB3A3EYcjs.toChordData.call(void 0, chord));
+  const key = resolvedKeyOf(opts);
   const ranges = resolveRanges(opts);
   const maxSpacing = resolveMaxSpacing(opts);
   const maxCandidates = resolveMaxCandidates(opts);
   const result = [];
-  const buffer = createCandidateBuffer();
+  const first = data[0];
+  if (first === void 0) {
+    return result;
+  }
+  let current = locate(
+    0,
+    first,
+    () => enumerateVoicings(first, ranges, maxSpacing, maxCandidates, createCandidateBuffer())
+  );
+  let spare = createCandidateBuffer();
+  let scoring = moveScoring(void 0, first, key);
   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);
+  for (const [index, chord] of data.entries()) {
+    const nextChord = data[index + 1];
+    const lookahead = nextChord === void 0 ? void 0 : {
+      candidates: locate(
+        index + 1,
+        nextChord,
+        () => enumerateVoicings(nextChord, ranges, maxSpacing, maxCandidates, spare)
+      ),
+      // The chord after the one being reached goes in too: it is what
+      // says whether the chromatic tone the next chord introduces is the
+      // one an applied dominant is written with.
+      scoring: moveScoring(chord, nextChord, key, data[index + 2])
+    };
+    const { pitches, voices, count } = current;
+    const weighed = lookahead !== void 0 && count * lookahead.candidates.count <= MAX_LOOKAHEAD_PAIRS ? lookahead : void 0;
     let bestOffset = -1;
     let bestScore = Number.POSITIVE_INFINITY;
-    for (let candidate = 0; candidate < candidates.count; candidate += 1) {
+    for (let candidate = 0; candidate < 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;
+      let score = prev === void 0 ? structuralPenalty(scoring.structure, pitches, offset, voices) + centeringPenalty(ranges, pitches, offset, voices) : moveScore(scoring, prev, 0, pitches, offset, voices);
+      if (weighed !== void 0) {
+        score += successorWeight(weighed, pitches, offset, voices);
+      }
       if (score < bestScore) {
         bestScore = score;
         bestOffset = offset;
@@ -1110,28 +1006,41 @@ function voiceProgression(chords, opts) {
     const best = [...pitches.subarray(bestOffset, bestOffset + voices)];
     result.push(best);
     prev = best;
-    prevChord = chord;
+    if (lookahead !== void 0) {
+      spare = current;
+      current = lookahead.candidates;
+      scoring = lookahead.scoring;
+    }
   }
   return result;
 }
 
 // src/theory/voicing/leading.ts
+function assertVoicing(pitches, name) {
+  const voices = _chunkXKSO2V5Icjs.assertArray.call(void 0, pitches, name);
+  for (let index = 0; index < voices.length; index += 1) {
+    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, _nullishCoalesce(voices[index], () => ( Number.NaN)), `${name}[${index}]`);
+  }
+  return voices;
+}
 function voiceLeadingCost(from, to) {
-  if (from.length !== to.length) {
+  const previous = assertVoicing(from, "from");
+  const next = assertVoicing(to, "to");
+  if (previous.length !== next.length) {
     return Number.POSITIVE_INFINITY;
   }
-  return leadingCost(from, 0, to, 0, from.length);
+  return leadingCost(previous, 0, next, 0, previous.length);
 }
 function nextVoicing(current, chord, opts) {
-  const data = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
-  const derived = _optionalChain([opts, 'optionalAccess', _13 => _13.ranges]) === void 0 && _optionalChain([opts, 'optionalAccess', _14 => _14.voices]) === void 0;
+  _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  assertVoicing(current, "current");
+  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
+  const derived = _optionalChain([opts, 'optionalAccess', _12 => _12.ranges]) === void 0 && _optionalChain([opts, 'optionalAccess', _13 => _13.voices]) === void 0;
   if (derived) {
     if (current.length === 0) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("current must contain at least one pitch");
-    }
-    for (let index = 0; index < current.length; index += 1) {
-      _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, _nullishCoalesce(current[index], () => ( Number.NaN)), `current[${index}]`);
+      throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)("current must contain at least one pitch");
     }
+    assertVoicing(current, "current");
   }
   const ranges = derived ? resolveRanges({
     ranges: current.map((pitch) => {
@@ -1139,11 +1048,9 @@ function nextVoicing(current, chord, opts) {
       return { min: Math.max(0, centre - 12), max: Math.min(127, centre + 12) };
     })
   }) : resolveRanges(opts);
-  for (let index = 0; index < current.length; index += 1) {
-    _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, _nullishCoalesce(current[index], () => ( Number.NaN)), `current[${index}]`);
-  }
+  assertVoicing(current, "current");
   if (current.length < ranges.length) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
       `current has ${current.length} voices but the requested ranges require ${ranges.length}`
     );
   }
@@ -1153,29 +1060,33 @@ function nextVoicing(current, chord, opts) {
   });
   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 key = resolvedKeyOf(opts);
+  const scoring = moveScoring(resolvePreviousChord(opts), 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));
+    const score = moveScore(scoring, source, 0, pitches, offset, voices);
     if (score < bestScore) {
       bestScore = score;
       bestOffset = offset;
     }
   }
   if (bestOffset < 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.NoSolutionError)("no voicing satisfies the given ranges");
+    throw new (0, _chunkXKSO2V5Icjs.NoSolutionError)("no voicing satisfies the given ranges");
   }
   return [...pitches.subarray(bestOffset, bestOffset + voices)];
 }
 
 // src/theory/voicing/styled.ts
 var DEFAULT_STYLE_OCTAVE = 4;
+function dropPositionFromTop(style) {
+  if (style === "drop2") {
+    return 2;
+  }
+  return style === "drop3" ? 3 : 0;
+}
 function dedupePcs(pcs) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -1188,7 +1099,7 @@ function dedupePcs(pcs) {
   return result;
 }
 function lowestPitchAtOrAbove(pc, floor) {
-  return floor + ((pc - _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, floor)) % 12 + 12) % 12;
+  return floor + ((pc - _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, floor)) % 12 + 12) % 12;
 }
 function nearestPc(target, pcs) {
   let best = _nullishCoalesce(pcs[0], () => ( target));
@@ -1202,26 +1113,29 @@ function nearestPc(target, pcs) {
   }
   return best;
 }
-function voiceChordStyled(chord, opts) {
-  const style = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _15 => _15.style]), () => ( "close"));
-  const octave = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _16 => _16.octave]), () => ( DEFAULT_STYLE_OCTAVE));
-  _chunkQ2WGKJNNcjs.assertInteger.call(void 0, octave, "styled voicing octave", -10, 10);
-  if (_optionalChain([opts, 'optionalAccess', _17 => _17.topNote]) !== void 0) {
-    _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, opts.topNote, "styled voicing topNote");
+function voiceChordStyled(given, opts) {
+  _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  const chord = _chunkYPB3A3EYcjs.toChordData.call(void 0, given);
+  const style = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _14 => _14.style]), () => ( "close"));
+  const octave = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _15 => _15.octave]), () => ( DEFAULT_STYLE_OCTAVE));
+  _chunkXKSO2V5Icjs.assertInteger.call(void 0, octave, "styled voicing octave", -10, 10);
+  if (_optionalChain([opts, 'optionalAccess', _16 => _16.topNote]) !== void 0) {
+    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, opts.topNote, "styled voicing topNote");
   }
   const base = 12 * (octave + 1);
-  const rootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc);
-  const bassPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc)));
-  const omitRoot = style === "rootless" || _optionalChain([opts, 'optionalAccess', _18 => _18.rootless]) === true;
-  let order = dedupePcs(chord.intervals.map((interval) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc + interval)));
+  const rootPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc);
+  const bassPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc)));
+  const omitRoot = style === "rootless" || _optionalChain([opts, 'optionalAccess', _17 => _17.rootless]) === true;
+  let order = dedupePcs(chord.intervals.map((interval) => _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc + interval)));
   const bassIndex = order.indexOf(bassPc);
+  const bassIsChordTone = bassIndex >= 0;
   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) => _chunkUADYAYATcjs.chordToneRole.call(void 0, pc, chord));
+    const roles = order.map((pc) => _chunkYPB3A3EYcjs.chordToneRole.call(void 0, pc, chord));
     const guide = roles.includes("seventh") ? "seventh" : roles.includes("sixth") ? "sixth" : "fifth";
     order = order.filter((_pc, i) => {
       const role = roles[i];
@@ -1234,18 +1148,27 @@ function voiceChordStyled(chord, opts) {
   if (order.length === 0) {
     return [];
   }
-  if (_optionalChain([opts, 'optionalAccess', _19 => _19.topNote]) !== void 0) {
-    const target = order.includes(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, opts.topNote)) ? _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, opts.topNote) : nearestPc(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, opts.topNote), order);
+  if (_optionalChain([opts, 'optionalAccess', _18 => _18.topNote]) !== void 0) {
+    const target = order.includes(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, opts.topNote)) ? _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, opts.topNote) : nearestPc(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, opts.topNote), order);
     const targetIndex = order.indexOf(target);
     order = [...order.slice(targetIndex + 1), ...order.slice(0, targetIndex + 1)];
   }
+  const dropFromTop = dropPositionFromTop(style);
+  const dropsToNamedBass = dropFromTop > 0 && bassIsChordTone && chord.bassPc !== void 0 && order.length > dropFromTop;
+  if (dropsToNamedBass) {
+    const bassAt = order.indexOf(bassPc);
+    if (bassAt >= 0) {
+      const shift = ((bassAt - (order.length - dropFromTop)) % order.length + order.length) % order.length;
+      order = [...order.slice(shift), ...order.slice(0, shift)];
+    }
+  }
   const stack = [];
   let prev;
   for (const pc of order) {
     if (prev === void 0) {
       prev = lowestPitchAtOrAbove(pc, base);
     } else {
-      let delta = ((pc - _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, prev)) % 12 + 12) % 12;
+      let delta = ((pc - _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, prev)) % 12 + 12) % 12;
       if (delta === 0) {
         delta = 12;
       }
@@ -1253,13 +1176,13 @@ function voiceChordStyled(chord, opts) {
     }
     stack.push(prev);
   }
-  if (style === "drop2" && stack.length >= 2) {
-    stack[stack.length - 2] = (_nullishCoalesce(stack[stack.length - 2], () => ( 0))) - 12;
-  } else if (style === "drop3" && stack.length >= 3) {
-    stack[stack.length - 3] = (_nullishCoalesce(stack[stack.length - 3], () => ( 0))) - 12;
+  const stackedFloor = bassIsChordTone ? 0 : 1;
+  if (dropFromTop > 0 && stack.length - dropFromTop > stackedFloor) {
+    const dropIndex = stack.length - dropFromTop;
+    stack[dropIndex] = (_nullishCoalesce(stack[dropIndex], () => ( 0))) - 12;
   }
   if (chord.bassPc !== void 0) {
-    const bassIndexInStack = stack.findIndex((pitch) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitch) === bassPc);
+    const bassIndexInStack = stack.findIndex((pitch) => _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch) === bassPc);
     if (bassIndexInStack >= 0) {
       const otherLowest = Math.min(
         ...stack.filter((_pitch, index) => index !== bassIndexInStack),
@@ -1274,7 +1197,7 @@ function voiceChordStyled(chord, opts) {
   const lowest = _nullishCoalesce(voicing[0], () => ( 0));
   const highest = _nullishCoalesce(voicing[voicing.length - 1], () => ( 0));
   if (lowest < 0 || highest > 127) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
       `styled voicing at octave ${octave} spans MIDI ${lowest}..${highest}, outside 0..127`
     );
   }
@@ -1290,17 +1213,26 @@ var INTERVAL_WORDS = [
   "fifth",
   "sixth",
   "seventh",
-  "octave"
+  "octave",
+  "ninth",
+  "tenth",
+  "eleventh",
+  "twelfth",
+  "thirteenth",
+  "fourteenth",
+  "fifteenth"
 ];
 function intervalWord(numberValue) {
-  return _nullishCoalesce(INTERVAL_WORDS[numberValue - 1], () => ( "interval"));
+  return _nullishCoalesce(INTERVAL_WORDS[numberValue - 1], () => ( `${numberValue}th`));
+}
+function intervalArticle(word) {
+  return /^[aeiou]/.test(word) ? "an" : "a";
 }
 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;
@@ -1308,7 +1240,7 @@ function meanPitch(notes) {
   if (notes.length === 0) {
     return 0;
   }
-  return notes.reduce((sum, note) => sum + _chunkQ2WGKJNNcjs.noteToMidi.call(void 0, note), 0) / notes.length;
+  return notes.reduce((sum, note) => sum + _chunkXKSO2V5Icjs.noteToMidi.call(void 0, note), 0) / notes.length;
 }
 function impliedDurations(count, measures, ratio) {
   const full = ratio * Math.max(measures - 1, 0);
@@ -1324,21 +1256,22 @@ function direction(interval) {
 function sameNote(a, b) {
   return a.letter === b.letter && a.alter === b.alter && a.octave === b.octave;
 }
-function isPassedThrough(entries, position) {
+function isPassedThrough(entries, position, species) {
   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 = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, previous.note, current.note);
-  const outgoing = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, current.note, next.note);
+  const incoming = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, previous.note, current.note);
+  const outgoing = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, 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;
+  if (direction(incoming) === direction(outgoing)) {
+    return true;
+  }
+  return sameNote(previous.note, next.note) && (species === 3 || species === 5);
 }
 function isThird(interval) {
   return interval.number === 3;
@@ -1362,9 +1295,9 @@ function isCambiata(entries, start) {
   if (first.consonance === 2 /* Dissonance */ || third.consonance === 2 /* Dissonance */) {
     return false;
   }
-  const approach = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, first.note, second.note);
-  const leap = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, second.note, third.note);
-  const answer = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, third.note, fourth.note);
+  const approach = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, first.note, second.note);
+  const leap = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, second.note, third.note);
+  const answer = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, third.note, fourth.note);
   return isStep(approach) && direction(approach) < 0 && isThird(leap) && direction(leap) < 0 && isStep(answer) && direction(answer) > 0;
 }
 function isDoubleNeighbour(entries, start) {
@@ -1376,9 +1309,9 @@ function isDoubleNeighbour(entries, start) {
   if (first.consonance === 2 /* Dissonance */ || !sameNote(first.note, fourth.note)) {
     return false;
   }
-  const away = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, first.note, second.note);
-  const across = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, second.note, third.note);
-  const back = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, third.note, fourth.note);
+  const away = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, first.note, second.note);
+  const across = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, second.note, third.note);
+  const back = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, third.note, fourth.note);
   return isStep(away) && isThird(across) && isStep(back) && direction(away) !== 0 && direction(across) === -direction(away);
 }
 function isFiguredDissonance(entries, position, species) {
@@ -1399,7 +1332,7 @@ function licenceFor(species, downbeat) {
   }
   return downbeat ? "none" : "passing";
 }
-function verticalViolations(entries, position, species, counterpointAbove) {
+function verticalViolations(entries, position, species, counterpointAbove, crossed) {
   const entry = entries[position];
   if (entry === void 0) {
     return [];
@@ -1407,7 +1340,8 @@ function verticalViolations(entries, position, species, counterpointAbove) {
   const found = [];
   const upper = counterpointAbove ? entry.note : entry.against;
   const lower = counterpointAbove ? entry.against : entry.note;
-  if (_chunkUADYAYATcjs.createsVoiceCrossing.call(void 0, upper, lower)) {
+  if (!crossed.has(entry.index) && _chunkYPB3A3EYcjs.createsVoiceCrossing.call(void 0, upper, lower)) {
+    crossed.add(entry.index);
     found.push(
       violation(
         "voiceCrossing",
@@ -1422,7 +1356,7 @@ function verticalViolations(entries, position, species, counterpointAbove) {
     return found;
   }
   const licence = licenceFor(species, entry.downbeat);
-  if (licence === "passing" && (isPassedThrough(entries, position) || isFiguredDissonance(entries, position, species))) {
+  if (licence === "passing" && (isPassedThrough(entries, position, species) || isFiguredDissonance(entries, position, species))) {
     return found;
   }
   if (licence === "suspension") {
@@ -1459,7 +1393,7 @@ function suspensionViolations(entries, position) {
       )
     ];
   }
-  const resolution = next === void 0 ? void 0 : _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, entry.note, next.note);
+  const resolution = next === void 0 ? void 0 : _chunkXKSO2V5Icjs.spelledInterval.call(void 0, entry.note, next.note);
   if (next === void 0 || resolution === void 0 || !isStep(resolution) || direction(resolution) >= 0) {
     return [
       violation(
@@ -1471,11 +1405,22 @@ function suspensionViolations(entries, position) {
       )
     ];
   }
+  if (next.consonance === 2 /* Dissonance */) {
+    return [
+      violation(
+        "unresolvedSuspension",
+        [0, 1],
+        entry.index,
+        next.index,
+        `The suspension falls onto a ${next.interval.quality}${next.interval.number}, which is no resolution`
+      )
+    ];
+  }
   return [];
 }
 function melodicViolations(from, to) {
-  const interval = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, from.note, to.note);
-  if (_chunkUADYAYATcjs.isAugmentedMelodicInterval.call(void 0, from.note, to.note)) {
+  const interval = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, from.note, to.note);
+  if (_chunkYPB3A3EYcjs.isAugmentedMelodicInterval.call(void 0, from.note, to.note)) {
     return [
       violation(
         "augmentedMelodicInterval",
@@ -1486,7 +1431,7 @@ function melodicViolations(from, to) {
       )
     ];
   }
-  if (_chunkUADYAYATcjs.isForbiddenMelodicLeap.call(void 0, from.note, to.note)) {
+  if (_chunkYPB3A3EYcjs.isForbiddenMelodicLeap.call(void 0, from.note, to.note)) {
     return [
       violation(
         "illegalLeap",
@@ -1514,19 +1459,19 @@ function melodicMoves(entries) {
     if (from === void 0 || to === void 0) {
       continue;
     }
-    moves.push({ from, to, interval: _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, from.note, to.note) });
+    moves.push({ from, to, interval: _chunkXKSO2V5Icjs.spelledInterval.call(void 0, from.note, to.note) });
   }
   return moves;
 }
 function climaxViolations(entries) {
   const body = entries.slice(0, -1);
   const peak = body.reduce(
-    (high, entry) => Math.max(high, _chunkQ2WGKJNNcjs.noteToMidi.call(void 0, entry.note)),
+    (high, entry) => Math.max(high, _chunkXKSO2V5Icjs.noteToMidi.call(void 0, entry.note)),
     Number.NEGATIVE_INFINITY
   );
   const arrivals = body.filter((entry, position) => {
     const previous = body[position - 1];
-    return _chunkQ2WGKJNNcjs.noteToMidi.call(void 0, entry.note) === peak && (previous === void 0 || _chunkQ2WGKJNNcjs.noteToMidi.call(void 0, previous.note) !== peak);
+    return _chunkXKSO2V5Icjs.noteToMidi.call(void 0, entry.note) === peak && (previous === void 0 || _chunkXKSO2V5Icjs.noteToMidi.call(void 0, previous.note) !== peak);
   });
   const first = arrivals[0];
   const second = arrivals[1];
@@ -1607,7 +1552,7 @@ function leapAnswerViolations(moves) {
         [1],
         leap.from.index,
         answer.to.index,
-        `The leap of ${word === "octave" ? "an" : "a"} ${word} is not answered by a step the other way`
+        `The leap of ${intervalArticle(word)} ${word} is not answered by a step the other way`
       )
     );
   }
@@ -1620,7 +1565,7 @@ function tritoneOutlineViolations(entries) {
     const first = run[0];
     const last = run[run.length - 1];
     if (first !== void 0 && last !== void 0 && run.length > 1) {
-      const outline = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, first.from.note, last.to.note);
+      const outline = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, first.from.note, last.to.note);
       if (Math.abs(outline.semitones) === TRITONE_SEMITONES) {
         found.push(
           violation(
@@ -1663,7 +1608,7 @@ function repeatedNoteViolations(moves, closingMeasure) {
 }
 function melodicShapeViolations(entries, species) {
   const moves = melodicMoves(entries);
-  const closingMeasure = _nullishCoalesce(_optionalChain([entries, 'access', _20 => _20[entries.length - 1], 'optionalAccess', _21 => _21.againstIndex]), () => ( 0));
+  const closingMeasure = _nullishCoalesce(_optionalChain([entries, 'access', _19 => _19[entries.length - 1], 'optionalAccess', _20 => _20.againstIndex]), () => ( 0));
   const found = [
     ...climaxViolations(entries),
     ...leapChainViolations(moves),
@@ -1673,14 +1618,19 @@ function melodicShapeViolations(entries, species) {
   ];
   return found.sort((left, right) => left.fromIndex - right.fromIndex);
 }
+function inTimeOrder(violations) {
+  return [...violations].sort(
+    (left, right) => left.fromIndex - right.fromIndex || left.toIndex - right.toIndex
+  );
+}
 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 (_chunkUADYAYATcjs.createsParallelPerfect.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur)) {
-    const fifth = _chunkUADYAYATcjs.simpleIntervalNumber.call(void 0, to.interval.number) === 5;
+  if (_chunkYPB3A3EYcjs.createsParallelPerfect.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur)) {
+    const fifth = _chunkYPB3A3EYcjs.simpleIntervalNumber.call(void 0, to.interval.number) === 5;
     found.push(
       violation(
         fifth ? "parallelFifth" : "parallelOctave",
@@ -1691,18 +1641,18 @@ function motionViolations(from, to, counterpointAbove) {
       )
     );
   }
-  if (_chunkUADYAYATcjs.createsHiddenParallelPerfect.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur)) {
+  if (_chunkYPB3A3EYcjs.createsHiddenParallelPerfect.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur, "twoVoice")) {
     found.push(
       violation(
         "hiddenPerfect",
         [0, 1],
         from.index,
         to.index,
-        "The voices leap into a perfect interval by similar motion"
+        "The voices move into a perfect interval by similar motion"
       )
     );
   }
-  if (_chunkUADYAYATcjs.createsBattuta.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur)) {
+  if (_chunkYPB3A3EYcjs.createsBattuta.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur)) {
     found.push(
       violation(
         "battuta",
@@ -1731,7 +1681,7 @@ function cadenceViolations(entries, mode, counterpointAbove) {
   if (first === void 0 || last === void 0) {
     return found;
   }
-  if (_chunkUADYAYATcjs.classifySpelledInterval.call(void 0, first.interval) !== 0 /* PerfectConsonance */) {
+  if (_chunkYPB3A3EYcjs.classifySpelledInterval.call(void 0, first.interval) !== 0 /* PerfectConsonance */) {
     found.push(
       violation(
         "missingCadence",
@@ -1742,7 +1692,7 @@ function cadenceViolations(entries, mode, counterpointAbove) {
       )
     );
   }
-  if (_chunkQ2WGKJNNcjs.noteToPitchClass.call(void 0, last.note) !== _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, mode.rootPc)) {
+  if (_chunkXKSO2V5Icjs.noteToPitchClass.call(void 0, last.note) !== _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, mode.rootPc)) {
     found.push(
       violation(
         "missingCadence",
@@ -1754,7 +1704,7 @@ function cadenceViolations(entries, mode, counterpointAbove) {
     );
   }
   const closing = last.interval;
-  if (closing.quality !== "P" || _chunkUADYAYATcjs.simpleIntervalNumber.call(void 0, closing.number) !== 1) {
+  if (closing.quality !== "P" || _chunkYPB3A3EYcjs.simpleIntervalNumber.call(void 0, closing.number) !== 1) {
     found.push(
       violation(
         "missingCadence",
@@ -1771,9 +1721,9 @@ function cadenceViolations(entries, mode, counterpointAbove) {
     return found;
   }
   const arrival = _nullishCoalesce(entries.find((entry) => entry.againstIndex === last.againstIndex), () => ( last));
-  const approach = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, penultimate.note, arrival.note);
+  const approach = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, penultimate.note, arrival.note);
   const expected = counterpointAbove ? { quality: "M", number: 6 } : { quality: "m", number: 3 };
-  if (penultimate.interval.quality !== expected.quality || _chunkUADYAYATcjs.simpleIntervalNumber.call(void 0, penultimate.interval.number) !== expected.number || !isStep(approach)) {
+  if (penultimate.interval.quality !== expected.quality || _chunkYPB3A3EYcjs.simpleIntervalNumber.call(void 0, penultimate.interval.number) !== expected.number || !isStep(approach)) {
     found.push(
       violation(
         "missingCadence",
@@ -1787,7 +1737,7 @@ function cadenceViolations(entries, mode, counterpointAbove) {
   return found;
 }
 function resolveDurations(counterpoint, measures, species, opts) {
-  const given = _optionalChain([opts, 'optionalAccess', _22 => _22.durations]);
+  const given = _optionalChain([opts, 'optionalAccess', _21 => _21.durations]);
   if (given !== void 0) {
     if (given.length !== counterpoint.length) {
       return {
@@ -1796,20 +1746,20 @@ function resolveDurations(counterpoint, measures, species, opts) {
     }
     for (const duration of given) {
       const units = duration / MIN_FLORID_VALUE;
-      if (!(duration > 0) || duration > 1 || Math.abs(units - Math.round(units)) > EPS) {
+      if (!(duration > 0) || duration > 1 || Math.abs(units - Math.round(units)) > _chunkXKSO2V5Icjs.BEAT_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) {
+    if (Math.abs(total - measures) > _chunkXKSO2V5Icjs.BEAT_EPS) {
       return { problem: `The counterpoint fills ${total} of the ${measures} measures` };
     }
     return { durations: [...given] };
   }
   if (species === 5) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
       "checkSpecies needs durations for the fifth species, whose note values are not fixed"
     );
   }
@@ -1831,23 +1781,32 @@ function buildEntries(cantusFirmus, counterpoint, durations, counterpointAbove)
     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 struckOver = Math.min(Math.floor(onset + _chunkXKSO2V5Icjs.BEAT_EPS), cantusFirmus.length - 1);
+    const lastOver = Math.min(
+      Math.max(Math.ceil(onset + duration - _chunkXKSO2V5Icjs.BEAT_EPS) - 1, struckOver),
+      cantusFirmus.length - 1
+    );
+    for (let againstIndex = struckOver; againstIndex <= lastOver; againstIndex += 1) {
+      const against = cantusFirmus[againstIndex];
+      if (against === void 0) {
+        continue;
+      }
+      const held = againstIndex > struckOver;
+      const begins = held ? againstIndex : onset;
+      const interval = counterpointAbove ? _chunkXKSO2V5Icjs.spelledInterval.call(void 0, against, note) : _chunkXKSO2V5Icjs.spelledInterval.call(void 0, note, against);
+      entries.push({
+        note,
+        index,
+        onset: begins,
+        duration: onset + duration - begins,
+        held,
+        against,
+        againstIndex,
+        downbeat: Math.abs(begins - Math.round(begins)) < _chunkXKSO2V5Icjs.BEAT_EPS,
+        interval,
+        consonance: _chunkYPB3A3EYcjs.classifySpelledInterval.call(void 0, interval)
+      });
     }
-    const interval = counterpointAbove ? _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, against, note) : _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, note, against);
-    entries.push({
-      note,
-      index,
-      onset,
-      duration,
-      against,
-      againstIndex,
-      downbeat: Math.abs(onset - Math.round(onset)) < EPS,
-      interval,
-      consonance: _chunkUADYAYATcjs.classifySpelledInterval.call(void 0, interval)
-    });
     onset += duration;
   }
   return entries;
@@ -1866,40 +1825,50 @@ function motionPairs(entries) {
   }
   return pairs;
 }
-function checkSpecies(cantusFirmus, counterpoint, species, mode, opts) {
+function checkSpecies(cantusFirmus, counterpoint, species, modeLike, opts) {
+  _chunkXKSO2V5Icjs.assertArray.call(void 0, cantusFirmus, "cantus firmus");
+  _chunkXKSO2V5Icjs.assertArray.call(void 0, counterpoint, "counterpoint");
+  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  const mode = _chunkYPB3A3EYcjs.toKeyScale.call(void 0, modeLike);
   if (!SPECIES_NUMBERS.includes(species)) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-      `species must be one of ${SPECIES_NUMBERS.join(", ")}; received ${JSON.stringify(species)}`
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
+      `species must be one of ${SPECIES_NUMBERS.join(", ")}; received ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, species)}`
     );
   }
   if (cantusFirmus.length === 0 || counterpoint.length === 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("checkSpecies needs both a cantus firmus and a counterpoint");
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)("checkSpecies needs both a cantus firmus and a counterpoint");
   }
-  const resolved = resolveDurations(counterpoint, cantusFirmus.length, species, opts);
+  const resolved = resolveDurations(counterpoint, cantusFirmus.length, species, asked);
   if ("problem" in resolved) {
-    return [violation("wrongRhythmicRatio", [1], 0, counterpoint.length - 1, resolved.problem)];
+    return inTimeOrder([
+      violation("wrongRhythmicRatio", [1], 0, counterpoint.length - 1, resolved.problem)
+    ]);
   }
-  const counterpointAbove = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _23 => _23.counterpointAbove]), () => ( meanPitch(counterpoint) >= meanPitch(cantusFirmus)));
+  const counterpointAbove = _nullishCoalesce(asked.counterpointAbove, () => ( meanPitch(counterpoint) >= meanPitch(cantusFirmus)));
   const entries = buildEntries(cantusFirmus, counterpoint, resolved.durations, counterpointAbove);
+  const struck = entries.filter((entry) => !entry.held);
   const violations = [];
+  const crossed = /* @__PURE__ */ new Set();
   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];
+    violations.push(...verticalViolations(entries, position, species, counterpointAbove, crossed));
+  }
+  for (let position = 1; position < struck.length; position += 1) {
+    const previous = struck[position - 1];
+    const current = struck[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];
+  violations.push(...melodicShapeViolations(struck, species));
+  for (const [from, to] of motionPairs(struck)) {
+    const previous = struck[from];
+    const current = struck[to];
     if (previous !== void 0 && current !== void 0) {
       violations.push(...motionViolations(previous, current, counterpointAbove));
     }
   }
-  violations.push(...cadenceViolations(entries, mode, counterpointAbove));
-  return violations;
+  violations.push(...cadenceViolations(struck, mode, counterpointAbove));
+  return inTimeOrder(violations);
 }
 
 // src/theory/partwriting/index.ts
@@ -1908,12 +1877,9 @@ function bare(note) {
 }
 function midiOf(note, index, voice) {
   if (note.octave === void 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`voicings[${index}][${voice}] must carry an octave`);
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`voicings[${index}][${voice}] must carry an octave`);
   }
-  return _chunkQ2WGKJNNcjs.noteToMidi.call(void 0, note);
-}
-function isDescendingStep(interval) {
-  return interval.number === 2 && (interval.semitones === -1 || interval.semitones === -2);
+  return _chunkXKSO2V5Icjs.noteToMidi.call(void 0, note);
 }
 function verticalViolations2(moment, ranges, maxSpacing) {
   const found = [];
@@ -1924,7 +1890,7 @@ function verticalViolations2(moment, ranges, maxSpacing) {
     if (upper === void 0 || lower === void 0) {
       continue;
     }
-    if (_chunkUADYAYATcjs.createsVoiceCrossing.call(void 0, upper, lower)) {
+    if (_chunkYPB3A3EYcjs.createsVoiceCrossing.call(void 0, upper, lower)) {
       found.push(
         violation(
           "voiceCrossing",
@@ -1935,7 +1901,7 @@ function verticalViolations2(moment, ranges, maxSpacing) {
         )
       );
     }
-    if (voice >= 2 && _chunkUADYAYATcjs.exceedsSpacing.call(void 0, upper, lower, maxSpacing)) {
+    if (voice >= 2 && _chunkYPB3A3EYcjs.exceedsSpacing.call(void 0, upper, lower, maxSpacing)) {
       found.push(
         violation(
           "spacing",
@@ -1975,8 +1941,8 @@ function pairViolations(transition) {
       if (upperPrev === void 0 || upperCur === void 0 || lowerPrev === void 0 || lowerCur === void 0) {
         continue;
       }
-      if (_chunkUADYAYATcjs.createsParallelPerfect.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur)) {
-        const fifth = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, upperCur - lowerCur) === 7;
+      if (_chunkYPB3A3EYcjs.createsParallelPerfect.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur)) {
+        const fifth = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, upperCur - lowerCur) === 7;
         found.push(
           violation(
             fifth ? "parallelFifth" : "parallelOctave",
@@ -1987,7 +1953,7 @@ function pairViolations(transition) {
           )
         );
       }
-      if (upper === lower + 1 && _chunkUADYAYATcjs.createsVoiceOverlap.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur)) {
+      if (upper === lower + 1 && _chunkYPB3A3EYcjs.createsVoiceOverlap.call(void 0, upperPrev, upperCur, lowerPrev, lowerCur)) {
         found.push(
           violation(
             "overlap",
@@ -2004,110 +1970,38 @@ function pairViolations(transition) {
   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 && _chunkUADYAYATcjs.createsHiddenParallelPerfect.call(void 0, topPrev, topCur, bassPrev, bassCur)) {
+  if (voices >= 2 && bassPrev !== void 0 && bassCur !== void 0 && topPrev !== void 0 && topCur !== void 0 && _chunkYPB3A3EYcjs.createsHiddenParallelPerfect.call(void 0, 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"
+        "The outer voices reach a perfect interval by similar motion, the upper one by leap"
       )
     );
   }
   return found;
 }
-function inKey(pc, key) {
-  return (key.modeMask12 >> _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pc - key.rootPc) & 1) === 1;
-}
-function isDominantSonority(chord) {
-  const has = (semitones) => chord.intervals.some((interval) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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 = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc + 5);
-  return target !== _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc) && inKey(target, key) && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, next.rootPc) === target;
-}
-function isNeapolitan(chord, key) {
-  return chord.quality === "maj" && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 1;
-}
-function soundsAugmentedSixth(moment, key) {
-  const bass = moment.notes[0];
-  if (bass === void 0 || _chunkQ2WGKJNNcjs.noteToPitchClass.call(void 0, bass) !== _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc + 8)) {
-    return false;
-  }
-  return moment.notes.some((note, voice) => {
-    if (voice === 0) {
-      return false;
-    }
-    const interval = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, bass, note);
-    return (interval.number - 1) % 7 + 1 === 6 && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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 = _optionalChain([before, 'optionalAccess', _24 => _24.notes, 'access', _25 => _25[voice]]);
-  const later = moment.notes[voice];
-  if (earlier === void 0 || later === void 0) {
-    return false;
-  }
-  return _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, 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, _optionalChain([after, 'optionalAccess', _26 => _26.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 = _chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, earlier.letter);
-      if (letter !== _chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, 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,
-          `${_chunkQ2WGKJNNcjs.formatNote.call(void 0, bare(earlier))} is contradicted by ${_chunkQ2WGKJNNcjs.formatNote.call(void 0, bare(later))} in another voice`
-        )
-      );
-    }
-  }
-  return found;
+  return crossRelations(from, to, key, { before: _optionalChain([before, 'optionalAccess', _22 => _22.notes]), after: _optionalChain([after, 'optionalAccess', _23 => _23.chord]) }).map(
+    (clash) => violation(
+      "crossRelation",
+      [clash.earlierVoice, clash.laterVoice],
+      from.index,
+      to.index,
+      `${_chunkXKSO2V5Icjs.formatNote.call(void 0, bare(clash.earlier))} is contradicted by ${_chunkXKSO2V5Icjs.formatNote.call(void 0, bare(clash.later))} in another voice`
+    )
+  );
 }
 function melodicViolations2(transition) {
   const found = [];
   const { from, to, key } = transition;
-  const seventhPc = seventhPcOf(from.chord);
-  const nextPcs = new Set(_chunkUADYAYATcjs.chordPitchClasses.call(void 0, to.chord));
-  const leadingTonePc = leadingTonePcOf(key);
-  const tonicPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc);
+  const seventhPc = _chunkYPB3A3EYcjs.seventhPcOf.call(void 0, from.chord);
+  const nextPcs = new Set(_chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, to.chord));
+  const leadingTonePc = _chunkYPB3A3EYcjs.leadingTonePcOf.call(void 0, key);
+  const tonicPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, 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];
@@ -2117,8 +2011,8 @@ function melodicViolations2(transition) {
     if (earlier === void 0 || later === void 0 || earlierPitch === void 0 || laterPitch === void 0) {
       continue;
     }
-    const interval = _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, earlier, later);
-    if (_chunkUADYAYATcjs.isAugmentedMelodicInterval.call(void 0, earlier, later)) {
+    const interval = _chunkXKSO2V5Icjs.spelledInterval.call(void 0, earlier, later);
+    if (_chunkYPB3A3EYcjs.isAugmentedMelodicInterval.call(void 0, earlier, later)) {
       found.push(
         violation(
           "augmentedMelodicInterval",
@@ -2129,8 +2023,8 @@ function melodicViolations2(transition) {
         )
       );
     }
-    const earlierPc = _chunkQ2WGKJNNcjs.noteToPitchClass.call(void 0, earlier);
-    if (earlierPc === seventhPc && !nextPcs.has(earlierPc) && !isDescendingStep(interval)) {
+    const earlierPc = _chunkXKSO2V5Icjs.noteToPitchClass.call(void 0, earlier);
+    if (earlierPc === seventhPc && !nextPcs.has(earlierPc) && !_chunkYPB3A3EYcjs.isDescendingStep.call(void 0, interval)) {
       found.push(
         violation(
           "unresolvedSeventh",
@@ -2141,7 +2035,8 @@ function melodicViolations2(transition) {
         )
       );
     }
-    if (earlierPc === leadingTonePc && isFunctioningLeadingTone(from.chord, key) && nextPcs.has(tonicPc) && !nextPcs.has(earlierPc) && !_chunkUADYAYATcjs.isLeadingToneResolution.call(void 0, earlierPitch, laterPitch, key)) {
+    const inner = !isOuterVoice(voice, from.notes) && !isOuterVoice(voice, to.notes);
+    if (earlierPc === leadingTonePc && _chunkYPB3A3EYcjs.isFunctioningLeadingTone.call(void 0, from.chord, key) && nextPcs.has(tonicPc) && !nextPcs.has(earlierPc) && !_chunkYPB3A3EYcjs.isLeadingToneResolution.call(void 0, earlierPitch, laterPitch, key) && !(inner && _chunkYPB3A3EYcjs.isFrustratedLeadingTone.call(void 0, earlierPitch, laterPitch, to.chord))) {
       found.push(
         violation(
           "unresolvedLeadingTone",
@@ -2156,24 +2051,30 @@ function melodicViolations2(transition) {
   return found;
 }
 function spellVoicing(voicing, chord, key) {
-  const { tonic } = _chunkUADYAYATcjs.spelledKeyOf.call(void 0, key);
-  return voicing.map((pitch) => _chunkUADYAYATcjs.spellPitch.call(void 0, pitch, tonic, key, { chordRoot: chord.rootPc }));
-}
-function checkPartWriting(voicings, chords, key, opts) {
+  _chunkXKSO2V5Icjs.assertArray.call(void 0, voicing, "voicing");
+  _chunkYPB3A3EYcjs.assertChord.call(void 0, chord);
+  const { tonic, scale } = _chunkYPB3A3EYcjs.resolveKey.call(void 0, key);
+  return voicing.map((pitch) => _chunkYPB3A3EYcjs.spellPitch.call(void 0, pitch, tonic, scale, { chord }));
+}
+function checkPartWriting(voicings, chords, keyLike, opts) {
+  _chunkXKSO2V5Icjs.assertArray.call(void 0, voicings, "voicings");
+  _chunkXKSO2V5Icjs.assertArray.call(void 0, chords, "chords");
+  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  const key = _chunkYPB3A3EYcjs.toKeyScale.call(void 0, keyLike);
   if (voicings.length !== chords.length) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
+    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
       `checkPartWriting needs one chord per voicing; received ${voicings.length} voicings and ${chords.length} chords`
     );
   }
-  const maxSpacing = resolveMaxSpacing(opts);
+  const maxSpacing = resolveMaxSpacing(asked);
   const voiceCount = voicings.reduce((widest, voicing) => Math.max(widest, voicing.length), 0);
   let ranges;
-  if (_optionalChain([opts, 'optionalAccess', _27 => _27.ranges]) === void 0) {
+  if (asked.ranges === void 0) {
     ranges = voiceCount === 4 ? SATB_RANGES : void 0;
   } else {
-    ranges = resolveRanges(opts);
+    ranges = resolveRanges(asked);
     if (ranges.length < voiceCount) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
+      throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
         `checkPartWriting needs one range per voice; received ${ranges.length} ranges for ${voiceCount} voices`
       );
     }
@@ -2233,11 +2134,5 @@ function checkPartWriting(voicings, chords, key, opts) {
 
 
 
-
-
-
-
-
-
-exports.TRANSPOSING_INSTRUMENTS = TRANSPOSING_INSTRUMENTS; exports.instrumentTransposition = instrumentTransposition; exports.toSoundingPitch = toSoundingPitch; exports.toWrittenPitch = toWrittenPitch; exports.scaleMatchesChord = scaleMatchesChord; exports.chordScales = chordScales; exports.avoidNotes = avoidNotes; exports.availableTensions = availableTensions; exports.chordScaleReport = chordScaleReport; exports.scalesForChanges = scalesForChanges; exports.figuredBassRealization = figuredBassRealization; exports.realizeFiguredBass = realizeFiguredBass; exports.figuredBassOf = figuredBassOf; exports.SATB_RANGES = SATB_RANGES; exports.voiceChord = voiceChord; exports.voiceProgression = voiceProgression; exports.voiceLeadingCost = voiceLeadingCost; exports.nextVoicing = nextVoicing; exports.voiceChordStyled = voiceChordStyled; exports.checkSpecies = checkSpecies; exports.spellVoicing = spellVoicing; exports.checkPartWriting = checkPartWriting;
-//# sourceMappingURL=chunk-WWURE4XT.cjs.map
+exports.TRANSPOSING_INSTRUMENTS = TRANSPOSING_INSTRUMENTS; exports.instrumentTransposition = instrumentTransposition; exports.toSoundingPitch = toSoundingPitch; exports.toWrittenPitch = toWrittenPitch; exports.figuredBassRealization = figuredBassRealization; exports.realizeFiguredBass = realizeFiguredBass; exports.figuredBassOf = figuredBassOf; exports.SATB_RANGES = SATB_RANGES; exports.voiceChord = voiceChord; exports.voiceProgression = voiceProgression; exports.voiceLeadingCost = voiceLeadingCost; exports.nextVoicing = nextVoicing; exports.voiceChordStyled = voiceChordStyled; exports.checkSpecies = checkSpecies; exports.spellVoicing = spellVoicing; exports.checkPartWriting = checkPartWriting;
+//# sourceMappingURL=chunk-RVS4G4MR.cjs.map