@libraz/libcantus 1.2.0 → 1.4.0

package/dist/chunk-GEDTJHAC.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/libcantus/libcantus/dist/chunk-GEDTJHAC.cjs"],"names":[],"mappings":"AAAA","file":"/home/runner/work/libcantus/libcantus/dist/chunk-GEDTJHAC.cjs"}
+{"version":3,"sources":["/home/runner/work/libcantus/libcantus/ts/dist/chunk-GEDTJHAC.cjs"],"names":[],"mappings":"AAAA","file":"/home/runner/work/libcantus/libcantus/ts/dist/chunk-GEDTJHAC.cjs"}

package/dist/{chunk-RFIBF2RR.js → chunk-H7FVMBUC.js}

@@ -33,7 +33,7 @@ import {
   tryParseKeyName,
   tryParseNote,
   unwrapParse
-} from "./chunk-AGOVW7U6.js";
+} from "./chunk-YYVXRV3V.js";
 
 // src/theory/scale/masks.ts
 function maskFromOffsets(offsets) {
@@ -328,7 +328,9 @@ function toKeyScale(value) {
       return normalizedKeyScale(data);
     }
   }
-  throw new InvalidInputError(`key must be a key name or a key/scale; received ${typeof value}`);
+  throw new InvalidInputError(
+    `key must be a key name or a key/scale; received ${describeRejected(value)}`
+  );
 }
 
 // src/theory/scale/degrees.ts
@@ -449,7 +451,7 @@ function rotateMask(mask, semitones) {
   const steps = (semitones % 12 + 12) % 12;
   return (mask >> steps | mask << 12 - steps) & 4095;
 }
-var DIATONIC_MODE_OFFSETS = /* @__PURE__ */ new Map([
+var DIATONIC_MODE_OFFSET_ENTRIES = [
   [rotateMask(MAJOR_MASK, 5), 1],
   // lydian
   [MAJOR_MASK, 0],
@@ -464,7 +466,8 @@ var DIATONIC_MODE_OFFSETS = /* @__PURE__ */ new Map([
   // phrygian
   [rotateMask(MAJOR_MASK, 11), -5]
   // locrian
-]);
+];
+var DIATONIC_MODE_OFFSETS = new Map(DIATONIC_MODE_OFFSET_ENTRIES);
 function modeOffset(key) {
   const diatonic = DIATONIC_MODE_OFFSETS.get(key.modeMask12);
   if (diatonic !== void 0) {
@@ -1097,7 +1100,7 @@ function chordSpecQuality(spec) {
   }
   return nearest ?? BASE_QUALITY[checked.base];
 }
-var EXTENSION_BY_SEMITONE = /* @__PURE__ */ new Map([
+var EXTENSION_ENTRIES = [
   [13, { degree: 9, alter: -1 }],
   [14, { degree: 9, alter: 0 }],
   [15, { degree: 9, alter: 1 }],
@@ -1107,7 +1110,8 @@ var EXTENSION_BY_SEMITONE = /* @__PURE__ */ new Map([
   [20, { degree: 13, alter: -1 }],
   [21, { degree: 13, alter: 0 }],
   [22, { degree: 13, alter: 1 }]
-]);
+];
+var EXTENSION_BY_SEMITONE = new Map(EXTENSION_ENTRIES);
 function sameOffsets(a, b) {
   return a.length === b.length && a.every((offset, index) => offset === b[index]);
 }
@@ -1172,6 +1176,9 @@ function chordSpecFromIntervals(intervals) {
   const normalized = normalizeChordSpec(spec);
   return sameOffsets(specIntervals(normalized), offsets) ? normalized : void 0;
 }
+var ALTERABLE_DEGREES = [5, 9, 11, 13];
+var ALTERATION_STEPS = [-1, 0, 1];
+var ADDABLE_DEGREES = [6, 9, 11, 13];
 function assertPart(value, allowed, name) {
   if (!allowed.includes(value)) {
     throw new InvalidInputError(
@@ -1190,7 +1197,7 @@ function assertDegreeIn(value, allowed, name) {
 }
 function assertDegreeList(value, allowed, name) {
   if (!Array.isArray(value)) {
-    throw new InvalidInputError(`${name} must be an array; received ${typeof value}`);
+    throw new InvalidInputError(`${name} must be an array; received ${describeRejected(value)}`);
   }
   for (const degree of value) {
     assertDegreeIn(degree, allowed, name);
@@ -1198,7 +1205,7 @@ function assertDegreeList(value, allowed, name) {
 }
 function assertChordSpec(spec) {
   if (spec === null || typeof spec !== "object") {
-    throw new InvalidInputError(`chord spec must be an object; received ${typeof spec}`);
+    throw new InvalidInputError(`chord spec must be an object; received ${describeRejected(spec)}`);
   }
   assertFiniteNumber(spec.rootPc, "chord spec rootPc");
   if (spec.bassPc !== void 0) {
@@ -1216,10 +1223,10 @@ function assertChordSpec(spec) {
     throw new InvalidInputError("chord spec alterations must be an array");
   }
   for (const alteration of spec.alterations) {
-    assertDegreeIn(alteration?.degree, [5, 9, 11, 13], "chord spec alteration degree");
-    assertDegreeIn(alteration.alter, [-1, 0, 1], "chord spec alteration");
+    assertDegreeIn(alteration?.degree, ALTERABLE_DEGREES, "chord spec alteration degree");
+    assertDegreeIn(alteration.alter, ALTERATION_STEPS, "chord spec alteration");
   }
-  assertDegreeList(spec.additions, [6, 9, 11, 13], "chord spec additions");
+  assertDegreeList(spec.additions, ADDABLE_DEGREES, "chord spec additions");
   assertDegreeList(spec.omissions, OMITTABLE_DEGREES, "chord spec omissions");
   return normalizeChordSpec(spec);
 }
@@ -1230,7 +1237,7 @@ function chordQualities() {
   return [...QUALITY_ORDER];
 }
 function assertChordQuality(quality) {
-  if (!Object.hasOwn(QUALITY_INTERVALS, quality)) {
+  if (typeof quality !== "string" || !Object.hasOwn(QUALITY_INTERVALS, quality)) {
     throw new InvalidInputError(`Unknown chord quality: ${String(quality)}`);
   }
   return quality;
@@ -1244,17 +1251,20 @@ function assertChord(chord, name = "chord") {
 function chordFromDegree(degree, ext, key) {
   assertDegree(degree, "chord degree");
   assertChordQuality(ext);
-  const scale = toKeyScale(key);
-  const tones = scaleTonesInDegreeOrder(scale);
+  const resolved = resolveKey(key);
+  const tones = scaleTonesInDegreeOrder(resolved.scale);
   const length = tones.length;
   const index = length > 0 ? (degree - 1) % length : 0;
-  const rootPc = tones[index] ?? pitchClassOf(scale.rootPc);
-  return { rootPc, quality: ext, intervals: [...QUALITY_INTERVALS[ext]] };
+  const rootPc = tones[index] ?? pitchClassOf(resolved.scale.rootPc);
+  return makeSpelledChord(rootPc, ext, { rootSpelling: keySpelling(rootPc, resolved) });
 }
 function makeChord(rootPc, quality, bassPc) {
+  return makeSpelledChord(rootPc, quality, { bassPc });
+}
+function makeSpelledChord(rootPc, quality, parts2 = {}) {
   assertFiniteNumber(rootPc, "chord rootPc");
-  if (bassPc !== void 0) {
-    assertFiniteNumber(bassPc, "chord bassPc");
+  if (parts2.bassPc !== void 0) {
+    assertFiniteNumber(parts2.bassPc, "chord bassPc");
   }
   assertChordQuality(quality);
   const chord = {
@@ -1262,11 +1272,32 @@ function makeChord(rootPc, quality, bassPc) {
     quality,
     intervals: [...QUALITY_INTERVALS[quality] ?? []]
   };
-  if (bassPc !== void 0) {
-    chord.bassPc = pitchClassOf(bassPc);
+  if (parts2.bassPc !== void 0) {
+    chord.bassPc = pitchClassOf(parts2.bassPc);
+  }
+  if (parts2.rootSpelling !== void 0) {
+    chord.rootSpelling = { letter: parts2.rootSpelling.letter, alter: parts2.rootSpelling.alter };
+  }
+  if (parts2.bassSpelling !== void 0) {
+    chord.bassSpelling = { letter: parts2.bassSpelling.letter, alter: parts2.bassSpelling.alter };
+  } else if (chord.rootSpelling !== void 0 && chord.bassPc !== void 0) {
+    const index = chord.intervals.findIndex(
+      (interval) => pitchClassOf(chord.rootPc + interval) === chord.bassPc
+    );
+    const tone = index >= 0 ? spellChordFromRoot(chord, chord.rootSpelling)[index] : void 0;
+    if (tone !== void 0) {
+      chord.bassSpelling = { letter: tone.letter, alter: tone.alter };
+    }
+  }
+  if (parts2.toneSpellings !== void 0) {
+    chord.toneSpellings = parts2.toneSpellings.map(({ letter, alter }) => ({ letter, alter }));
   }
   return chord;
 }
+function keySpelling(pc, key) {
+  const { letter, alter } = spellPitchClass(pc, key.tonic, key.scale);
+  return { letter, alter };
+}
 function chordFromSpec(spec) {
   const checked = assertChordSpec(spec);
   const chord = {
@@ -1298,7 +1329,9 @@ function chordSpecOf(chord) {
 function copySpanIntervals(intervals) {
   const name = "chord span intervals";
   if (!Array.isArray(intervals)) {
-    throw new InvalidInputError(`${name} must be an array; received ${typeof intervals}`);
+    throw new InvalidInputError(
+      `${name} must be an array; received ${describeRejected(intervals)}`
+    );
   }
   if (intervals.length === 0) {
     throw new InvalidInputError(`${name} must name at least one interval`);
@@ -1322,7 +1355,7 @@ function hasCustomIntervals(chord) {
 }
 function chordFromSpan(span) {
   assertRecord(span, "chord span");
-  const chord = makeChord(span.rootPc, span.quality, span.bassPc);
+  const chord = makeSpelledChord(span.rootPc, span.quality, { bassPc: span.bassPc });
   if (span.intervals !== void 0) {
     chord.intervals = copySpanIntervals(span.intervals);
   }
@@ -1558,8 +1591,9 @@ function matchesQualityIntervals(quality, intervals) {
   const template = QUALITY_INTERVALS[quality];
   return template.length === intervals.length && template.every((interval, index) => interval === intervals[index]);
 }
-function stackThirds(degree, key, size) {
+function stackThirds(degree, resolved, size) {
   assertDegree(degree, "chord degree");
+  const key = resolved.scale;
   const tones = scaleTonesInDegreeOrder(key);
   const length = tones.length;
   if (length !== 7) {
@@ -1581,13 +1615,13 @@ function stackThirds(degree, key, size) {
       `scale thirds at degree ${degree} produce unsupported intervals [${offsets.join(", ")}]`
     );
   }
-  return { rootPc, quality, intervals: offsets };
+  return makeSpelledChord(rootPc, quality, { rootSpelling: keySpelling(rootPc, resolved) });
 }
 function diatonicTriad(degree, key) {
-  return stackThirds(degree, toKeyScale(key), 3);
+  return stackThirds(degree, resolveKey(key), 3);
 }
 function diatonicSeventh(degree, key) {
-  return stackThirds(degree, toKeyScale(key), 4);
+  return stackThirds(degree, resolveKey(key), 4);
 }
 
 // src/theory/spelling/index.ts
@@ -1686,7 +1720,8 @@ function capChromaticAccidentals(preferred, alternative) {
 var DIATONIC_LETTER_COUNT = 7;
 var MAX_JOINT_TONE_COUNT = DIATONIC_LETTER_COUNT + 1;
 var MAJOR_SEMITONES = [0, 2, 4, 5, 7, 9, 11];
-var IMPERFECT_DEGREES = /* @__PURE__ */ new Set([1, 2, 5, 6]);
+var IMPERFECT_DEGREE_LIST = [1, 2, 5, 6];
+var IMPERFECT_DEGREES = new Set(IMPERFECT_DEGREE_LIST);
 var DIATONIC_MODE_OFFSETS2 = MAJOR_SEMITONES.map(
   (tonic, mode) => MAJOR_SEMITONES.map((_, degree) => pitchClassOf((MAJOR_SEMITONES[(mode + degree) % 7] ?? 0) - tonic))
 );
@@ -1869,9 +1904,10 @@ function spellByKey(pc, tonic, key) {
       return preferred;
     }
   }
-  const belowLetter = diatonicLetterOf([0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6][pitchClassOf(pc)] ?? 0);
+  const belowLetter = diatonicLetterOf(LETTER_BELOW_PITCH_CLASS[pitchClassOf(pc)] ?? 0);
   return { letter: belowLetter, alter: alterFor(belowLetter, pc) };
 }
+var LETTER_BELOW_PITCH_CLASS = [0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6];
 var CHORD_TONE_LETTER_STEPS = {
   0: 0,
   // root
@@ -1926,10 +1962,10 @@ function neighbourSpelling(neighbour, gap, letterStep, pc, tonic, key) {
   }
   return letterFor(spellByKey(pitchClassOf(neighbour), tonic, key), letterStep, pc);
 }
-function refineByContext(pc, tonic, key, context, keySpelling) {
+function refineByContext(pc, tonic, key, context, keySpelling2) {
   const tonicPc = pitchClassOf(naturalPitchClassOf(tonic.letter) + tonic.alter);
   if (pitchClassOf(pc) === tonicPc || isScaleTone(pc, key)) {
-    return keySpelling;
+    return keySpelling2;
   }
   const { previous, next } = context;
   const candidates = [
@@ -1952,7 +1988,7 @@ function refineByContext(pc, tonic, key, context, keySpelling) {
       return candidate;
     }
   }
-  return keySpelling;
+  return keySpelling2;
 }
 function spellPitchClass(pc, tonic, key, context) {
   const note = toNoteData(tonic);
@@ -1962,8 +1998,8 @@ function spellPitchClass(pc, tonic, key, context) {
   return spelledPitchClass(pc, note, scale, context);
 }
 function spelledPitchClass(pc, tonic, key, context) {
-  const keySpelling = spellByKey(pc, tonic, key);
-  return context === void 0 ? keySpelling : refineByContext(pc, tonic, key, context, keySpelling);
+  const keySpelling2 = spellByKey(pc, tonic, key);
+  return context === void 0 ? keySpelling2 : refineByContext(pc, tonic, key, context, keySpelling2);
 }
 function spellScale(tonic, key) {
   const note = toNoteData(tonic);
@@ -1980,6 +2016,7 @@ function spellPitchClasses(pcs, tonic, key) {
     (pc, index) => spelledPitchClass(assertPitchClass(pc, `pcs[${index}]`), note, scale)
   );
 }
+var SIMPLE_LETTER_OFFSETS = [0, 1, 1, 2, 2, 3, 4, 4, 4, 5, 6, 6];
 function chordLetterOffset(interval, chord) {
   switch (interval) {
     case 0:
@@ -1994,7 +2031,7 @@ function chordLetterOffset(interval, chord) {
     case 4:
       return 2;
     case 15:
-      return chord.intervals.some((i) => i === 3 || i === 4) ? 1 : 2;
+      return 1;
     case 5:
     case 16:
     case 17:
@@ -2018,7 +2055,7 @@ function chordLetterOffset(interval, chord) {
     default: {
       const octaves = Math.floor(Math.max(0, interval) / 12);
       const simple = pitchClassOf(interval);
-      const simpleOffset = [0, 1, 1, 2, 2, 3, 4, 4, 4, 5, 6, 6][simple] ?? 0;
+      const simpleOffset = SIMPLE_LETTER_OFFSETS[simple] ?? 0;
       return octaves * 7 + simpleOffset;
     }
   }
@@ -2527,17 +2564,21 @@ function assertSafetyContext(q) {
     throw new InvalidInputError("vocalLow must not exceed vocalHigh");
   }
   if (!Array.isArray(q.otherVoices)) {
-    throw new InvalidInputError(`otherVoices must be an array; received ${typeof q.otherVoices}`);
+    throw new InvalidInputError(
+      `otherVoices must be an array; received ${describeRejected(q.otherVoices)}`
+    );
   }
   assertGenerationBudget(q.otherVoices.length, "other voices");
   for (let index = 0; index < q.otherVoices.length; index += 1) {
-    const voice = q.otherVoices[index];
-    if (!voice) continue;
+    const voice = assertRecord(q.otherVoices[index], `otherVoices[${index}]`);
     assertMidiPitch(voice.pitch, `otherVoices[${index}].pitch`);
     if (voice.prevPitch !== void 0) {
       assertMidiPitch(voice.prevPitch, `otherVoices[${index}].prevPitch`);
     }
   }
+  if (q.chord !== null) {
+    assertRecord(q.chord, "chord");
+  }
 }
 function evaluateInternal(q, collectSuggestions, collectPartners) {
   let reasons = 0;
@@ -2925,6 +2966,19 @@ var ADDED_DEGREES = {
 };
 var ALTERABLE = { "5": 5, "9": 9, "11": 11, "13": 13 };
 var OMITTABLE = { "1": 1, "3": 3, "5": 5 };
+var SUSPENSION_TOKENS = [
+  ["sus2", "sus2"],
+  ["sus4", "sus4"],
+  ["sus", "sus4"]
+];
+var OMISSION_TOKENS = [
+  ["omit", 4],
+  ["no", 2]
+];
+var ACCIDENTAL_TOKENS = [
+  ["b", -1],
+  ["#", 1]
+];
 function alterationKey(degree, alter) {
   return `${degree}:${alter}`;
 }
@@ -2984,11 +3038,7 @@ function stackTo(draft, top) {
   }
 }
 function applyFigure(draft, text, at) {
-  const base = matchToken(text, at, [
-    ["sus2", "sus2"],
-    ["sus4", "sus4"],
-    ["sus", "sus4"]
-  ]);
+  const base = matchToken(text, at, SUSPENSION_TOKENS);
   if (base !== void 0) {
     draft.base = base.value;
     return base.next;
@@ -3007,10 +3057,7 @@ function applyFigure(draft, text, at) {
     draft.additions.add(degree2.value);
     return degree2.next;
   }
-  const omitted = matchToken(text, at, [
-    ["omit", 4],
-    ["no", 2]
-  ]);
+  const omitted = matchToken(text, at, OMISSION_TOKENS);
   if (omitted !== void 0) {
     const degree2 = matchNumberToken(text, omitted.next, OMITTABLE);
     if (degree2 === void 0) {
@@ -3019,10 +3066,7 @@ function applyFigure(draft, text, at) {
     draft.omissions.add(degree2.value);
     return degree2.next;
   }
-  const accidental = matchToken(text, at, [
-    ["b", -1],
-    ["#", 1]
-  ]);
+  const accidental = matchToken(text, at, ACCIDENTAL_TOKENS);
   const from = accidental?.next ?? at;
   const degree = matchNumberToken(text, from, ALTERABLE);
   if (degree === void 0) {
@@ -3203,7 +3247,7 @@ function bassNote(text, system) {
   }
   return bareNote(text, system);
 }
-function makeSpelledChord(root, spec, bass) {
+function chordFromSymbolParts(root, spec, bass) {
   const rooted = { ...spec, rootPc: noteToPitchClass(root) };
   if (bass !== void 0) {
     rooted.bassPc = noteToPitchClass(bass);
@@ -3221,11 +3265,11 @@ function chordAfterRoot(root, rest, system) {
     const slashSpec = suffixSpec(rest.slice(0, slashIndex));
     const bass = slashSpec === void 0 ? void 0 : bassNote(rest.slice(slashIndex + 1), system);
     if (slashSpec !== void 0 && bass !== void 0) {
-      return makeSpelledChord(root, slashSpec, bass);
+      return chordFromSymbolParts(root, slashSpec, bass);
     }
   }
   const spec = suffixSpec(rest);
-  return spec === void 0 ? void 0 : makeSpelledChord(root, spec);
+  return spec === void 0 ? void 0 : chordFromSymbolParts(root, spec);
 }
 
 // src/theory/symbol/suffix.ts
@@ -3302,7 +3346,11 @@ var BASE_SUFFIX = {
   sus4: "sus4",
   power: "5"
 };
-var SEVENTH_SUFFIX = { maj7: "maj7", min7: "7", dim7: "dim7" };
+var SEVENTH_SUFFIX = {
+  maj7: "maj7",
+  min7: "7",
+  dim7: "dim7"
+};
 var MAJOR_SEVENTH_AFTER_BASE = "Maj7";
 function builtCoreSuffix(spec) {
   const base = BASE_SUFFIX[spec.base];
@@ -3421,12 +3469,12 @@ function tryParseChordSymbol(text, opts) {
 }
 function formatChordSymbol(chord, opts) {
   const data = toChordData(chord);
-  if (!Object.hasOwn(CANONICAL_SUFFIX, data.quality)) {
+  if (typeof data.quality !== "string" || !Object.hasOwn(CANONICAL_SUFFIX, data.quality)) {
     throw new InvalidInputError(`Unknown chord quality: ${String(data.quality)}`);
   }
   const asked = assertOptions(opts, "opts");
   const system = asked.system ?? DEFAULT_SYSTEM;
-  const flats = asked.flats;
+  const flats = symbolFlats(asked.flats);
   const rootPc = pitchClassOf(data.rootPc);
   const rootHint = hintFor(data.rootSpelling, rootPc);
   const rootSpelling = rootSpellingFor(rootPc, rootHint, flats);
@@ -3441,7 +3489,7 @@ function formatChordSymbol(chord, opts) {
       (degreeOfInterval(pitchClassOf(bassPc - rootPc), data) ?? 1) - 1,
       bassPc
     ) : void 0;
-    const bassName = rootHint !== void 0 && bassHint !== void 0 ? symbolName(
+    const bassName = flats !== void 0 && rootHint !== void 0 && bassHint !== void 0 ? symbolName(
       carriedBass(
         bassHint,
         rootHint,
@@ -3455,6 +3503,9 @@ function formatChordSymbol(chord, opts) {
   }
   return symbol;
 }
+function symbolFlats(flats) {
+  return flats === void 0 ? void 0 : assertFlag(flats, "flats");
+}
 function transposeChordSpellings(spellings, semitones, flats) {
   const byLetter = (spelling) => spelling === void 0 ? void 0 : bareSpelling(transposeNote(spelling, semitones));
   const movedRoot = byLetter(spellings.rootSpelling);
@@ -3505,7 +3556,7 @@ function transposeChordSymbol(text, semitones, opts) {
   if (chord.bassPc !== void 0) {
     transposed.bassPc = pitchClassOf(chord.bassPc + semitones);
   }
-  const spellings = transposeChordSpellings(chord, semitones, opts?.flats);
+  const spellings = transposeChordSpellings(chord, semitones, symbolFlats(opts?.flats));
   if (spellings.rootSpelling !== void 0) {
     transposed.rootSpelling = spellings.rootSpelling;
   }
@@ -3552,11 +3603,11 @@ function toChordData(value) {
     return parseChordSymbol(value);
   }
   if (typeof value === "object" && value !== null) {
-    const data = "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : value;
+    const data = "toJSON" in value && typeof value.toJSON === "function" ? "data" in value && typeof value.data === "object" && value.data !== null ? value.data : value.toJSON() : value;
     return normalizedChord(data);
   }
   throw new InvalidInputError(
-    `chord must be a chord symbol or chord data; received ${typeof value}`
+    `chord must be a chord symbol or chord data; received ${describeRejected(value)}`
   );
 }
 
@@ -3567,6 +3618,9 @@ function hasInterval(chord, semitones) {
 function isDiatonicChord(chord, key) {
   return chordPitchClasses(chord).every((pc) => isScaleTone(pc, key));
 }
+function isNativeDominantSeventh(rootPc, key) {
+  return isDiatonicChord(makeChord(rootPc, "dom7"), key);
+}
 function hasMajorThird(chord) {
   return hasInterval(chord, 4);
 }
@@ -3627,10 +3681,23 @@ function appliedDominantTarget(rootPc, key) {
     (degree) => degree.degreeNumber !== 1 && degree.rootPc === target
   ) ?? null;
 }
+function cadencesThroughRaisedSeventh(key) {
+  return isMinorMask(key.modeMask12) && scaleSystemOf(key) === "common-practice";
+}
 function leadingTonePcOf(key) {
   return pitchClassOf(key.rootPc - 1);
 }
-var LEADING_TONE_QUALITIES = /* @__PURE__ */ new Set(["dim", "dim7", "m7b5"]);
+var LEADING_TONE_QUALITY_NAMES = ["dim", "dim7", "m7b5"];
+var LEADING_TONE_QUALITIES = new Set(
+  LEADING_TONE_QUALITY_NAMES
+);
+function appliedChordTarget(chord, key) {
+  const dominant = hasDominantSonority(chord);
+  if (!dominant && !LEADING_TONE_QUALITIES.has(chord.quality)) {
+    return null;
+  }
+  return appliedDominantTarget(chord.rootPc + (dominant ? 5 : 1), key);
+}
 function soundsDiminishedTriad(chord) {
   return hasInterval(chord, 3) && hasInterval(chord, 6) && !hasInterval(chord, 7);
 }
@@ -3757,12 +3824,16 @@ export {
   scaleSystemOf,
   supportsFunctionalHarmony,
   chordSpecIntervals,
+  QUALITY_INTERVALS,
+  chordSpecForQuality,
   chordSpecQuality,
   chordQualities,
   assertChordQuality,
   assertChord,
   chordFromDegree,
   makeChord,
+  makeSpelledChord,
+  keySpelling,
   chordFromSpec,
   chordSpecOf,
   chordFromSpan,
@@ -3800,22 +3871,24 @@ export {
   evaluateSafety,
   enumerateSafePitches,
   toChordData,
+  spellingAbove,
   parseChordSymbol,
   tryParseChordSymbol,
   formatChordSymbol,
   transposeChordSpellings,
   transposeChordSymbol,
   isDiatonicChord,
+  isNativeDominantSeventh,
   hasMajorThird,
   soundsDominantSeventh,
-  hasDominantSonority,
   isDominantChordOf,
   isNeapolitanChordOf,
   heptatonicFrameOf,
   tonicizableDegrees,
-  appliedDominantTarget,
+  cadencesThroughRaisedSeventh,
   leadingTonePcOf,
   LEADING_TONE_QUALITIES,
+  appliedChordTarget,
   isLeadingToneChordOf,
   isFunctioningLeadingTone,
   seventhPcOf,
@@ -3823,4 +3896,4 @@ export {
   isDescendingStep,
   isFrustratedLeadingTone
 };
-//# sourceMappingURL=chunk-RFIBF2RR.js.map
+//# sourceMappingURL=chunk-H7FVMBUC.js.map