@libraz/libcantus 0.9.3 → 0.9.4

package/dist/theory/index.cjs

@@ -1,1823 +1,173 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/theory/index.ts
-var theory_exports = {};
-__export(theory_exports, {
-  BLUES_MASK: () => BLUES_MASK,
-  CHROMATIC_MASK: () => CHROMATIC_MASK,
-  DORIAN_MASK: () => DORIAN_MASK,
-  HARMONIC_MINOR_MASK: () => HARMONIC_MINOR_MASK,
-  LOCRIAN_MASK: () => LOCRIAN_MASK,
-  LYDIAN_MASK: () => LYDIAN_MASK,
-  MAJOR_MASK: () => MAJOR_MASK,
-  MAJOR_PENTATONIC_MASK: () => MAJOR_PENTATONIC_MASK,
-  MELODIC_MINOR_MASK: () => MELODIC_MINOR_MASK,
-  MINOR_PENTATONIC_MASK: () => MINOR_PENTATONIC_MASK,
-  MIXOLYDIAN_MASK: () => MIXOLYDIAN_MASK,
-  NAMED_SCALES: () => NAMED_SCALES,
-  NATURAL_MINOR_MASK: () => NATURAL_MINOR_MASK,
-  NoteSafety: () => NoteSafety,
-  OCTATONIC_HALF_WHOLE_MASK: () => OCTATONIC_HALF_WHOLE_MASK,
-  OCTATONIC_WHOLE_HALF_MASK: () => OCTATONIC_WHOLE_HALF_MASK,
-  PHRYGIAN_MASK: () => PHRYGIAN_MASK,
-  ReasonFlag: () => ReasonFlag,
-  SATB_RANGES: () => SATB_RANGES,
-  WHOLE_TONE_MASK: () => WHOLE_TONE_MASK,
-  availableTensions: () => availableTensions,
-  avoidNotes: () => avoidNotes,
-  chordFromDegree: () => chordFromDegree,
-  chordPitchClasses: () => chordPitchClasses,
-  chordQualities: () => chordQualities,
-  chordScaleReport: () => chordScaleReport,
-  chordScales: () => chordScales,
-  chordToneRole: () => chordToneRole,
-  createsHiddenParallelPerfect: () => createsHiddenParallelPerfect,
-  createsParallelOctave: () => createsParallelOctave,
-  createsParallelPerfect: () => createsParallelPerfect,
-  createsParallelUnison: () => createsParallelUnison,
-  createsVerticalDissonance: () => createsVerticalDissonance,
-  createsVoiceCrossing: () => createsVoiceCrossing,
-  createsVoiceOverlap: () => createsVoiceOverlap,
-  diatonicPitchClasses: () => diatonicPitchClasses,
-  diatonicSeventh: () => diatonicSeventh,
-  diatonicTriad: () => diatonicTriad,
-  enumerateSafePitches: () => enumerateSafePitches,
-  evaluateSafety: () => evaluateSafety,
-  exceedsSpacing: () => exceedsSpacing,
-  formatChordSymbol: () => formatChordSymbol,
-  isForbiddenMelodicLeap: () => isForbiddenMelodicLeap,
-  isLeadingToneResolution: () => isLeadingToneResolution,
-  isScaleTone: () => isScaleTone,
-  majorKey: () => majorKey,
-  makeChord: () => makeChord,
-  maskFromOffsets: () => maskFromOffsets,
-  minorKey: () => minorKey,
-  nearestScaleTone: () => nearestScaleTone,
-  nextVoicing: () => nextVoicing,
-  noteNames: () => noteNames,
-  parseChordSymbol: () => parseChordSymbol,
-  pitchToScaleDegree: () => pitchToScaleDegree,
-  roleOf: () => roleOf,
-  scaleByName: () => scaleByName,
-  scaleMatchesChord: () => scaleMatchesChord,
-  scaleTonesInDegreeOrder: () => scaleTonesInDegreeOrder,
-  scalesForChanges: () => scalesForChanges,
-  spellChord: () => spellChord,
-  spellPitchClass: () => spellPitchClass,
-  spellPitchClasses: () => spellPitchClasses,
-  spellScale: () => spellScale,
-  transposeChordSymbol: () => transposeChordSymbol,
-  voiceChord: () => voiceChord,
-  voiceChordStyled: () => voiceChordStyled,
-  voiceLeadingCost: () => voiceLeadingCost,
-  voiceProgression: () => voiceProgression
-});
-module.exports = __toCommonJS(theory_exports);
-
-// src/theory/scale/degrees.ts
-function pitchClass(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function scaleOffset(pitch, key) {
-  return (pitchClass(pitch) - pitchClass(key.rootPc) + 12) % 12;
-}
-function isScaleTone(pitch, key) {
-  return (key.modeMask12 >> scaleOffset(pitch, key) & 1) === 1;
-}
-function nearestScaleTone(pitch, key) {
-  const base = Math.round(pitch);
-  for (let distance = 0; distance < 12; distance += 1) {
-    const lower = base - distance;
-    if (isScaleTone(lower, key)) {
-      return lower;
-    }
-    const higher = base + distance;
-    if (isScaleTone(higher, key)) {
-      return higher;
-    }
-  }
-  return base;
-}
-function pitchToScaleDegree(pitch, key) {
-  const offset = scaleOffset(pitch, key);
-  if ((key.modeMask12 >> offset & 1) === 0) {
-    return -1;
-  }
-  let degree = 0;
-  for (let n = 0; n < offset; n += 1) {
-    if ((key.modeMask12 >> n & 1) === 1) {
-      degree += 1;
-    }
-  }
-  return degree;
-}
-function diatonicPitchClasses(key) {
-  const root = pitchClass(key.rootPc);
-  const pcs = [];
-  for (let n = 0; n < 12; n += 1) {
-    if ((key.modeMask12 >> n & 1) === 1) {
-      pcs.push((root + n) % 12);
-    }
-  }
-  return pcs.sort((a, b) => a - b);
-}
-function scaleTonesInDegreeOrder(key) {
-  const root = pitchClass(key.rootPc);
-  const pcs = [];
-  for (let n = 0; n < 12; n += 1) {
-    if ((key.modeMask12 >> n & 1) === 1) {
-      pcs.push((root + n) % 12);
-    }
-  }
-  return pcs;
-}
-
-// src/theory/scale/masks.ts
-function maskFromOffsets(offsets) {
-  let mask = 1;
-  for (const offset of offsets) {
-    mask |= 1 << (offset % 12 + 12) % 12;
-  }
-  return mask;
-}
-var MAJOR_MASK = 2741;
-var NATURAL_MINOR_MASK = 1453;
-var HARMONIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 8, 11]);
-var MELODIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 11]);
-var DORIAN_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 10]);
-var PHRYGIAN_MASK = maskFromOffsets([0, 1, 3, 5, 7, 8, 10]);
-var LYDIAN_MASK = maskFromOffsets([0, 2, 4, 6, 7, 9, 11]);
-var MIXOLYDIAN_MASK = maskFromOffsets([0, 2, 4, 5, 7, 9, 10]);
-var LOCRIAN_MASK = maskFromOffsets([0, 1, 3, 5, 6, 8, 10]);
-var MAJOR_PENTATONIC_MASK = maskFromOffsets([0, 2, 4, 7, 9]);
-var MINOR_PENTATONIC_MASK = maskFromOffsets([0, 3, 5, 7, 10]);
-var BLUES_MASK = maskFromOffsets([0, 3, 5, 6, 7, 10]);
-var WHOLE_TONE_MASK = maskFromOffsets([0, 2, 4, 6, 8, 10]);
-var OCTATONIC_HALF_WHOLE_MASK = maskFromOffsets([0, 1, 3, 4, 6, 7, 9, 10]);
-var OCTATONIC_WHOLE_HALF_MASK = maskFromOffsets([0, 2, 3, 5, 6, 8, 9, 11]);
-var CHROMATIC_MASK = 4095;
-var NAMED_SCALES = {
-  major: MAJOR_MASK,
-  ionian: MAJOR_MASK,
-  naturalMinor: NATURAL_MINOR_MASK,
-  aeolian: NATURAL_MINOR_MASK,
-  harmonicMinor: HARMONIC_MINOR_MASK,
-  melodicMinor: MELODIC_MINOR_MASK,
-  dorian: DORIAN_MASK,
-  phrygian: PHRYGIAN_MASK,
-  lydian: LYDIAN_MASK,
-  mixolydian: MIXOLYDIAN_MASK,
-  locrian: LOCRIAN_MASK,
-  majorPentatonic: MAJOR_PENTATONIC_MASK,
-  minorPentatonic: MINOR_PENTATONIC_MASK,
-  blues: BLUES_MASK,
-  wholeTone: WHOLE_TONE_MASK,
-  octatonicHalfWhole: OCTATONIC_HALF_WHOLE_MASK,
-  octatonicWholeHalf: OCTATONIC_WHOLE_HALF_MASK,
-  chromatic: CHROMATIC_MASK
-};
-
-// src/theory/scale/key.ts
-function majorKey(rootPc) {
-  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: MAJOR_MASK };
-}
-function minorKey(rootPc) {
-  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: NATURAL_MINOR_MASK };
-}
-function scaleByName(name, rootPc) {
-  const mask = NAMED_SCALES[name];
-  if (mask === void 0) {
-    throw new Error(`Unknown scale: ${name}`);
-  }
-  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: mask };
-}
-
-// src/theory/chord/index.ts
-var QUALITY_INTERVALS = {
-  maj: [0, 4, 7],
-  min: [0, 3, 7],
-  dim: [0, 3, 6],
-  aug: [0, 4, 8],
-  majb5: [0, 4, 6],
-  maj7: [0, 4, 7, 11],
-  min7: [0, 3, 7, 10],
-  dom7: [0, 4, 7, 10],
-  dim7: [0, 3, 6, 9],
-  m7b5: [0, 3, 6, 10],
-  minMaj7: [0, 3, 7, 11],
-  aug7: [0, 4, 8, 10],
-  augMaj7: [0, 4, 8, 11],
-  "6": [0, 4, 7, 9],
-  min6: [0, 3, 7, 9],
-  "6/9": [0, 4, 7, 9, 14],
-  sus2: [0, 2, 7],
-  sus4: [0, 5, 7],
-  add9: [0, 4, 7, 14],
-  add11: [0, 4, 7, 17],
-  maj9: [0, 4, 7, 11, 14],
-  min9: [0, 3, 7, 10, 14],
-  dom9: [0, 4, 7, 10, 14],
-  "7b9": [0, 4, 7, 10, 13],
-  "7#9": [0, 4, 7, 10, 15],
-  "7#11": [0, 4, 7, 10, 18],
-  "7b13": [0, 4, 7, 10, 20],
-  "11": [0, 7, 10, 14, 17],
-  "13": [0, 4, 7, 10, 14, 21],
-  "5": [0, 7]
-};
-function pitchClass2(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function chordQualities() {
-  return Object.keys(QUALITY_INTERVALS);
-}
-function chordFromDegree(degree, ext, key) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const length = tones.length;
-  const index = length > 0 ? (degree % length + length) % length : 0;
-  const rootPc = tones[index] ?? pitchClass2(key.rootPc);
-  return { rootPc, quality: ext, intervals: [...QUALITY_INTERVALS[ext]] };
-}
-function makeChord(rootPc, quality, bassPc) {
-  const chord = {
-    rootPc: pitchClass2(rootPc),
-    quality,
-    intervals: [...QUALITY_INTERVALS[quality]]
-  };
-  if (bassPc !== void 0) {
-    chord.bassPc = pitchClass2(bassPc);
-  }
-  return chord;
-}
-function chordPitchClasses(chord) {
-  const set = /* @__PURE__ */ new Set();
-  for (const interval of chord.intervals) {
-    set.add(pitchClass2(chord.rootPc + interval));
-  }
-  return [...set].sort((a, b) => a - b);
-}
-function chordToneOffsets(chord) {
-  return new Set(chord.intervals.map((i) => (i % 12 + 12) % 12));
-}
-function chordToneRole(pitch, chord) {
-  const interval = (pitchClass2(pitch) - pitchClass2(chord.rootPc) + 12) % 12;
-  const tones = chordToneOffsets(chord);
-  if (interval === 0) {
-    return "root";
-  }
-  if (interval === 3 || interval === 4) {
-    return tones.has(interval) ? "third" : null;
-  }
-  if (interval === 7) {
-    return tones.has(7) ? "fifth" : null;
-  }
-  if (interval === 6) {
-    return tones.has(6) && !tones.has(7) ? "fifth" : null;
-  }
-  if (interval === 8) {
-    return tones.has(8) && !tones.has(7) ? "fifth" : null;
-  }
-  if (interval === 9) {
-    const hasHigherSeventh = tones.has(10) || tones.has(11);
-    const isDiminishedSeventh = tones.has(3) && tones.has(6) && !hasHigherSeventh;
-    if (isDiminishedSeventh) {
-      return "seventh";
-    }
-    if (tones.has(9) && !hasHigherSeventh) {
-      return "sixth";
-    }
-    return null;
-  }
-  if (interval === 10 || interval === 11) {
-    return tones.has(interval) ? "seventh" : null;
-  }
-  return null;
-}
-function classifyTriad(thirdIc, fifthIc) {
-  if (thirdIc === 4 && fifthIc === 8) {
-    return "aug";
-  }
-  if (thirdIc === 4 && fifthIc === 6) {
-    return "majb5";
-  }
-  if (thirdIc === 3 && fifthIc === 6) {
-    return "dim";
-  }
-  if (thirdIc === 3) {
-    return "min";
-  }
-  return "maj";
-}
-function classifySeventh(thirdIc, fifthIc, seventhIc) {
-  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 9) {
-    return "dim7";
-  }
-  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 10) {
-    return "m7b5";
-  }
-  if (thirdIc === 3 && seventhIc === 11) {
-    return "minMaj7";
-  }
-  if (thirdIc === 3) {
-    return "min7";
-  }
-  if (fifthIc === 8 && seventhIc === 10) {
-    return "aug7";
-  }
-  if (fifthIc === 8 && seventhIc === 11) {
-    return "augMaj7";
-  }
-  if (seventhIc === 11) {
-    return "maj7";
-  }
-  return "dom7";
-}
-function stackThirds(degree, key, size) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const length = tones.length;
-  if (length !== 7) {
-    throw new Error(
-      `diatonic chord stacking requires a heptatonic scale (received ${length} tones)`
-    );
-  }
-  const idx = (step) => ((degree + step) % length + length) % length;
-  const rootPc = tones[idx(0)] ?? pitchClass2(key.rootPc);
-  const offsets = [0, 2, 4, 6].slice(0, size).map((step) => {
-    const pc = tones[idx(step)] ?? rootPc;
-    return ((pc - rootPc) % 12 + 12) % 12;
-  });
-  const thirdIc = offsets[1] ?? 4;
-  const fifthIc = offsets[2] ?? 7;
-  const quality = size === 3 ? classifyTriad(thirdIc, fifthIc) : classifySeventh(thirdIc, fifthIc, offsets[3] ?? 11);
-  return { rootPc, quality, intervals: offsets };
-}
-function diatonicTriad(degree, key) {
-  return stackThirds(degree, key, 3);
-}
-function diatonicSeventh(degree, key) {
-  return stackThirds(degree, key, 4);
-}
-
-// src/theory/chordscale/index.ts
-function pitchClass3(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function popcount12(mask) {
-  let count = 0;
-  for (let n = 0; n < 12; n += 1) {
-    count += mask >> n & 1;
-  }
-  return count;
-}
-function maskHasPitchClass(mask, scaleRootPc, pc) {
-  const offset = pitchClass3(pc - scaleRootPc);
-  return (mask >> offset & 1) === 1;
-}
-function scaleMatchesChord(chordPcs, scaleMask, scaleRootPc) {
-  for (const pc of chordPcs) {
-    if (!maskHasPitchClass(scaleMask, scaleRootPc, pc)) {
-      return false;
-    }
-  }
-  return true;
-}
-var ALIASED_SCALE_NAMES = /* @__PURE__ */ new Set(["major", "naturalMinor"]);
-var HEPTATONIC_SIZE = 7;
-function chordScales(chord) {
-  const chordPcs = chordPitchClasses(chord);
-  const rootPc = pitchClass3(chord.rootPc);
-  const ranked = [];
-  const seenMasks = /* @__PURE__ */ new Set();
-  for (const name of Object.keys(NAMED_SCALES)) {
-    if (name === "chromatic" || ALIASED_SCALE_NAMES.has(name)) {
-      continue;
-    }
-    const mask = NAMED_SCALES[name];
-    if (mask === void 0 || seenMasks.has(mask)) {
-      continue;
-    }
-    seenMasks.add(mask);
-    if (scaleMatchesChord(chordPcs, mask, rootPc)) {
-      const size = popcount12(mask);
-      ranked.push({ name, extra: size - chordPcs.length, size });
-    }
-  }
-  if (ranked.length === 0) {
-    if (NAMED_SCALES.chromatic !== void 0) {
-      return [{ name: "chromatic", rootPc }];
-    }
-    return [];
-  }
-  const preferHeptatonic = chordPcs.length <= 3;
-  ranked.sort((a, b) => {
-    if (preferHeptatonic && a.size === HEPTATONIC_SIZE !== (b.size === HEPTATONIC_SIZE)) {
-      return a.size === HEPTATONIC_SIZE ? -1 : 1;
-    }
-    if (a.extra !== b.extra) {
-      return a.extra - b.extra;
-    }
-    if (a.size !== b.size) {
-      return a.size - b.size;
-    }
-    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-  });
-  return ranked.map((entry) => ({ name: entry.name, rootPc }));
-}
-function avoidNotes(chord, scaleName) {
-  const mask = NAMED_SCALES[scaleName];
-  if (mask === void 0) {
-    return [];
-  }
-  const rootPc = pitchClass3(chord.rootPc);
-  const chordPcs = chordPitchClasses(chord);
-  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {
-    return [];
-  }
-  const chordSet = new Set(chordPcs);
-  const avoid = [];
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
-      continue;
-    }
-    if (chordSet.has(pitchClass3(pc - 1))) {
-      avoid.push(pc);
-    }
-  }
-  return avoid.sort((a, b) => a - b);
-}
-function availableTensions(chord, scaleName) {
-  const mask = NAMED_SCALES[scaleName];
-  if (mask === void 0) {
-    return [];
-  }
-  const rootPc = pitchClass3(chord.rootPc);
-  const chordPcs = chordPitchClasses(chord);
-  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {
-    return [];
-  }
-  const chordSet = new Set(chordPcs);
-  const avoidSet = new Set(avoidNotes(chord, scaleName));
-  const tensions = [];
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc) || avoidSet.has(pc)) {
-      continue;
-    }
-    tensions.push(pc);
-  }
-  return tensions.sort((a, b) => a - b);
-}
-function chordScaleReport(chord, limit) {
-  const matches = chordScales(chord);
-  const chosen = limit === void 0 ? matches : matches.slice(0, Math.max(0, limit));
-  return chosen.map((match) => ({
-    name: match.name,
-    rootPc: match.rootPc,
-    avoid: avoidNotes(chord, match.name),
-    tensions: availableTensions(chord, match.name)
-  }));
-}
-var RANK_PENALTY = 0.01;
-function scalePitchClassSet(name, rootPc) {
-  const mask = NAMED_SCALES[name];
-  const pcs = /* @__PURE__ */ new Set();
-  if (mask === void 0) {
-    return pcs;
-  }
-  for (let n = 0; n < 12; n += 1) {
-    if ((mask >> n & 1) === 1) {
-      pcs.add(pitchClass3(rootPc + n));
-    }
-  }
-  return pcs;
-}
-function symmetricDifferenceSize(a, b) {
-  let count = 0;
-  for (const pc of a) {
-    if (!b.has(pc)) {
-      count += 1;
-    }
-  }
-  for (const pc of b) {
-    if (!a.has(pc)) {
-      count += 1;
-    }
-  }
-  return count;
-}
-function scalesForChanges(chords) {
-  if (chords.length === 0) {
-    return [];
-  }
-  const candidateLists = chords.map((chord) => chordScales(chord));
-  const pcSets = candidateLists.map(
-    (candidates) => candidates.map((match) => scalePitchClassSet(match.name, match.rootPc))
-  );
-  const first = candidateLists[0] ?? [];
-  const dp = [first.map((_, j) => j * RANK_PENALTY)];
-  const back = [first.map(() => -1)];
-  for (let i = 1; i < candidateLists.length; i += 1) {
-    const candidates = candidateLists[i] ?? [];
-    const prevCosts = dp[i - 1] ?? [];
-    const prevSets = pcSets[i - 1] ?? [];
-    const curSets = pcSets[i] ?? [];
-    const stageCosts = [];
-    const stageBack = [];
-    for (let j = 0; j < candidates.length; j += 1) {
-      let bestCost = Number.POSITIVE_INFINITY;
-      let bestPrev = -1;
-      for (let k = 0; k < prevCosts.length; k += 1) {
-        const transition = symmetricDifferenceSize(
-          prevSets[k] ?? /* @__PURE__ */ new Set(),
-          curSets[j] ?? /* @__PURE__ */ new Set()
-        );
-        const cost = (prevCosts[k] ?? 0) + transition;
-        if (cost < bestCost) {
-          bestCost = cost;
-          bestPrev = k;
-        }
-      }
-      stageCosts.push(bestCost + j * RANK_PENALTY);
-      stageBack.push(bestPrev);
-    }
-    dp.push(stageCosts);
-    back.push(stageBack);
-  }
-  const lastCosts = dp[dp.length - 1] ?? [];
-  let bestFinal = 0;
-  for (let j = 1; j < lastCosts.length; j += 1) {
-    if ((lastCosts[j] ?? Number.POSITIVE_INFINITY) < (lastCosts[bestFinal] ?? 0)) {
-      bestFinal = j;
-    }
-  }
-  const chosenIndices = new Array(candidateLists.length);
-  let current = bestFinal;
-  for (let i = candidateLists.length - 1; i >= 0; i -= 1) {
-    chosenIndices[i] = current;
-    current = back[i]?.[current] ?? -1;
-  }
-  return chords.map((chord, i) => {
-    const candidates = candidateLists[i] ?? [];
-    const scale = candidates[chosenIndices[i] ?? 0] ?? { name: "chromatic", rootPc: chord.rootPc };
-    return { chord, scale };
-  });
-}
-
-// src/core/interval/index.ts
-function simpleInterval(semitones) {
-  return Math.abs(semitones) % 12;
-}
-function isConsonantInterval(semitones, twoVoice = true) {
-  const pc = simpleInterval(semitones);
-  if (pc === 5) {
-    return !twoVoice;
-  }
-  return pc === 0 || pc === 3 || pc === 4 || pc === 7 || pc === 8 || pc === 9;
-}
-
-// src/theory/counterpoint/index.ts
-function pitchClass4(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function createsVoiceCrossing(upperPitch, lowerPitch) {
-  return upperPitch < lowerPitch;
-}
-function createsVerticalDissonance(a, b, twoVoice) {
-  return !isConsonantInterval(a - b, twoVoice);
-}
-function isForbiddenMelodicLeap(prev, cur) {
-  const semis = Math.abs(cur - prev);
-  return semis === 6 || semis === 10 || semis === 11 || semis > 12;
-}
-function simpleClass(semitones) {
-  return Math.abs(semitones) % 12;
-}
-function isPerfectClass(cls) {
-  return cls === 0 || cls === 7;
-}
-function similarMotion(aMove, bMove) {
-  return aMove !== 0 && bMove !== 0 && aMove > 0 === bMove > 0;
-}
-function bothVoicesMove(aMove, bMove) {
-  return aMove !== 0 && bMove !== 0;
-}
-function createsParallelPerfect(aPrev, aCur, bPrev, bCur) {
-  if (!bothVoicesMove(aCur - aPrev, bCur - bPrev)) {
-    return false;
-  }
-  const nowClass = simpleClass(aCur - bCur);
-  const prevClass = simpleClass(aPrev - bPrev);
-  return isPerfectClass(nowClass) && nowClass === prevClass;
-}
-function createsParallelOctave(aPrev, aCur, bPrev, bCur) {
-  if (!similarMotion(aCur - aPrev, bCur - bPrev)) {
-    return false;
-  }
-  return simpleClass(aCur - bCur) === 0 && simpleClass(aPrev - bPrev) === 0;
-}
-function createsParallelUnison(aPrev, aCur, bPrev, bCur) {
-  if (aCur === aPrev || bCur === bPrev) {
-    return false;
-  }
-  return aCur === bCur && aPrev === bPrev;
-}
-function createsHiddenParallelPerfect(aPrev, aCur, bPrev, bCur) {
-  const aMove = aCur - aPrev;
-  const bMove = bCur - bPrev;
-  if (!similarMotion(aMove, bMove)) {
-    return false;
-  }
-  const nowClass = simpleClass(aCur - bCur);
-  const prevClass = simpleClass(aPrev - bPrev);
-  if (!isPerfectClass(nowClass) || prevClass === nowClass) {
-    return false;
-  }
-  const upperMove = aCur >= bCur ? aMove : bMove;
-  if (Math.abs(upperMove) <= 2) {
-    return false;
-  }
-  return true;
-}
-function createsVoiceOverlap(upperPrev, upperCur, lowerPrev, lowerCur) {
-  return upperCur < lowerPrev || lowerCur > upperPrev;
-}
-function exceedsSpacing(upperPitch, lowerPitch, maxSemitones = 12) {
-  return Math.abs(upperPitch - lowerPitch) > maxSemitones;
-}
-function isLeadingToneResolution(prev, cur, key) {
-  const tonic = pitchClass4(key.rootPc);
-  const leading = (tonic + 11) % 12;
-  if (pitchClass4(prev) !== leading || pitchClass4(cur) !== tonic) {
-    return false;
-  }
-  return cur > prev && cur - prev <= 2;
-}
-
-// src/theory/harmony/index.ts
-function roleOf(pitch, chord, chordId = 0) {
-  const interval = ((Math.trunc(pitch) - chord.rootPc) % 12 + 12) % 12;
-  const tones = new Set(chord.intervals.map((i) => (i % 12 + 12) % 12));
-  const hasThird = tones.has(3) || tones.has(4);
-  const isSuspendedTone = !hasThird && (interval === 5 && tones.has(5) || interval === 2 && tones.has(2));
-  const chordRole = chordToneRole(pitch, chord);
-  let role;
-  let lock;
-  if (isSuspendedTone) {
-    role = "third";
-    lock = "quality";
-  } else if (chordRole !== null) {
-    role = chordRole;
-    lock = chordRole === "root" ? "identity" : chordRole === "third" ? "quality" : "voicing";
-  } else {
-    role = "tension";
-    lock = "voicing";
-  }
-  return { role, lock, belongsToChordId: chordId };
-}
-
-// src/core/validation/index.ts
-var DEFAULT_GENERATION_BUDGET = 1e6;
-function assertFiniteNumber(value, name) {
-  if (!Number.isFinite(value)) {
-    throw new RangeError(`${name} must be finite; received ${value}`);
-  }
-  return value;
-}
-function assertInteger(value, name, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
-  assertFiniteNumber(value, name);
-  if (!Number.isSafeInteger(value) || value < min || value > max) {
-    throw new RangeError(`${name} must be an integer in [${min}, ${max}]; received ${value}`);
-  }
-  return value;
-}
-function assertPositiveInt(value, name, max = DEFAULT_GENERATION_BUDGET) {
-  return assertInteger(value, name, 1, max);
-}
-function assertGenerationBudget(estimated, name, limit = DEFAULT_GENERATION_BUDGET) {
-  assertFiniteNumber(estimated, name);
-  assertPositiveInt(limit, `${name} limit`, Number.MAX_SAFE_INTEGER);
-  if (estimated < 0 || estimated > limit) {
-    throw new RangeError(`${name} exceeds the generation budget ${limit}; received ${estimated}`);
-  }
-  return estimated;
-}
-
-// src/theory/safety/index.ts
-var NoteSafety = /* @__PURE__ */ ((NoteSafety2) => {
-  NoteSafety2[NoteSafety2["Safe"] = 0] = "Safe";
-  NoteSafety2[NoteSafety2["Warning"] = 1] = "Warning";
-  NoteSafety2[NoteSafety2["Dissonant"] = 2] = "Dissonant";
-  return NoteSafety2;
-})(NoteSafety || {});
-var ReasonFlag = /* @__PURE__ */ ((ReasonFlag2) => {
-  ReasonFlag2[ReasonFlag2["ChordTone"] = 1] = "ChordTone";
-  ReasonFlag2[ReasonFlag2["Tension"] = 2] = "Tension";
-  ReasonFlag2[ReasonFlag2["AvoidNote"] = 4] = "AvoidNote";
-  ReasonFlag2[ReasonFlag2["ScaleTone"] = 8] = "ScaleTone";
-  ReasonFlag2[ReasonFlag2["NonScale"] = 16] = "NonScale";
-  ReasonFlag2[ReasonFlag2["OutOfRange"] = 32] = "OutOfRange";
-  ReasonFlag2[ReasonFlag2["Tritone"] = 64] = "Tritone";
-  ReasonFlag2[ReasonFlag2["LargeLeap"] = 128] = "LargeLeap";
-  ReasonFlag2[ReasonFlag2["MinorSecond"] = 256] = "MinorSecond";
-  ReasonFlag2[ReasonFlag2["MajorSeventh"] = 512] = "MajorSeventh";
-  ReasonFlag2[ReasonFlag2["VerticalDissonance"] = 1024] = "VerticalDissonance";
-  ReasonFlag2[ReasonFlag2["ParallelPerfect"] = 2048] = "ParallelPerfect";
-  ReasonFlag2[ReasonFlag2["HiddenParallel"] = 4096] = "HiddenParallel";
-  ReasonFlag2[ReasonFlag2["VoiceCrossing"] = 8192] = "VoiceCrossing";
-  ReasonFlag2[ReasonFlag2["Suspension"] = 16384] = "Suspension";
-  ReasonFlag2[ReasonFlag2["NeedsResolution"] = 32768] = "NeedsResolution";
-  return ReasonFlag2;
-})(ReasonFlag || {});
-var SUGGESTION_WINDOW = 12;
-var MAX_SUGGESTIONS = 3;
-var REASON_SEVERITY = [
-  [2 /* Tension */, 1 /* Warning */, 1 /* Warning */],
-  [4 /* AvoidNote */, 1 /* Warning */, 2 /* Dissonant */],
-  [8 /* ScaleTone */, 1 /* Warning */, 1 /* Warning */],
-  [16 /* NonScale */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [32 /* OutOfRange */, 1 /* Warning */, 1 /* Warning */],
-  [64 /* Tritone */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [128 /* LargeLeap */, 1 /* Warning */, 2 /* Dissonant */],
-  [1024 /* VerticalDissonance */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [2048 /* ParallelPerfect */, 1 /* Warning */, 2 /* Dissonant */],
-  [4096 /* HiddenParallel */, 1 /* Warning */, 2 /* Dissonant */],
-  [8192 /* VoiceCrossing */, 1 /* Warning */, 2 /* Dissonant */],
-  [16384 /* Suspension */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [32768 /* NeedsResolution */, 1 /* Warning */, 2 /* Dissonant */]
-];
-function minimumSafetyForReasons(reasons, profile) {
-  let minimum = 0 /* Safe */;
-  const severityIndex = profile === "strict" ? 2 : 1;
-  for (const entry of REASON_SEVERITY) {
-    if (reasons & entry[0]) {
-      minimum = Math.max(minimum, entry[severityIndex]);
-    }
-  }
-  return minimum;
-}
-function pitchClass5(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function intervalAboveRoot(pitch, chord) {
-  return ((pitchClass5(pitch) - pitchClass5(chord.rootPc)) % 12 + 12) % 12;
-}
-function isChordMember(pitch, chord) {
-  return chordPitchClasses(chord).includes(pitchClass5(pitch));
-}
-function avoidsFourth(chord) {
-  return chord.intervals.includes(4) && !chord.intervals.includes(5);
-}
-function avoidsMajorSeventh(chord) {
-  return chord.intervals.includes(4) && chord.intervals.includes(10);
-}
-function stepResolution(pitch, chord) {
-  for (let delta = 1; delta <= 2; delta += 1) {
-    if (isChordMember(pitch - delta, chord)) {
-      return pitch - delta;
-    }
-  }
-  return void 0;
-}
-function evaluateSafety(q) {
-  assertSafetyContext(q);
-  assertFiniteNumber(q.candidatePitch, "candidatePitch");
-  return evaluateInternal(q, true);
-}
-function assertSafetyContext(q) {
-  if (q.prevPitch !== void 0) assertFiniteNumber(q.prevPitch, "prevPitch");
-  if (q.vocalLow !== void 0) assertFiniteNumber(q.vocalLow, "vocalLow");
-  if (q.vocalHigh !== void 0) assertFiniteNumber(q.vocalHigh, "vocalHigh");
-  if (q.vocalLow !== void 0 && q.vocalHigh !== void 0 && q.vocalLow > q.vocalHigh) {
-    throw new RangeError("vocalLow must not exceed vocalHigh");
-  }
-  assertGenerationBudget(q.otherVoices.length, "other voices");
-  for (let index = 0; index < q.otherVoices.length; index += 1) {
-    const voice = q.otherVoices[index];
-    if (!voice) continue;
-    assertFiniteNumber(voice.pitch, `otherVoices[${index}].pitch`);
-    if (voice.prevPitch !== void 0) {
-      assertFiniteNumber(voice.prevPitch, `otherVoices[${index}].prevPitch`);
-    }
-  }
-}
-function evaluateInternal(q, collectSuggestions) {
-  let reasons = 0;
-  let level = 0 /* Safe */;
-  let resolveTo;
-  const raise = (l) => {
-    if (l > level) {
-      level = l;
-    }
-  };
-  const avoidSeverity = q.profile === "strict" ? 2 /* Dissonant */ : 1 /* Warning */;
-  const parallelSeverity = avoidSeverity;
-  const pitch = q.candidatePitch;
-  if (q.vocalLow !== void 0 && pitch < q.vocalLow || q.vocalHigh !== void 0 && pitch > q.vocalHigh) {
-    reasons |= 32 /* OutOfRange */;
-    raise(1 /* Warning */);
-  }
-  const inScale = isScaleTone(pitch, q.key);
-  const chord = q.chord;
-  if (chord && isChordMember(pitch, chord)) {
-    reasons |= 1 /* ChordTone */;
-  } else if (chord) {
-    const ic = intervalAboveRoot(pitch, chord);
-    const isTension = ic === 2 || ic === 5 || ic === 9;
-    const avoid = ic === 5 && avoidsFourth(chord) || ic === 11 && avoidsMajorSeventh(chord);
-    if (avoid) {
-      reasons |= 4 /* AvoidNote */;
-      if (isTension) {
-        reasons |= 2 /* Tension */;
-      }
-      reasons |= 32768 /* NeedsResolution */;
-      resolveTo = stepResolution(pitch, chord);
-      raise(avoidSeverity);
-    } else if (isTension && inScale) {
-      reasons |= 2 /* Tension */;
-      raise(1 /* Warning */);
-    } else if (inScale) {
-      reasons |= 8 /* ScaleTone */;
-      raise(1 /* Warning */);
-    } else {
-      reasons |= 16 /* NonScale */;
-      raise(2 /* Dissonant */);
-    }
-  } else if (inScale) {
-    reasons |= 8 /* ScaleTone */;
-    raise(1 /* Warning */);
-  } else {
-    reasons |= 16 /* NonScale */;
-    raise(2 /* Dissonant */);
-  }
-  if (chord && !(chord.intervals.includes(4) && chord.intervals.includes(10))) {
-    const ic = intervalAboveRoot(pitch, chord);
-    const toneOffsets = chord.intervals.map((i) => (i % 12 + 12) % 12);
-    if (toneOffsets.some((t) => Math.abs(ic - t) === 6)) {
-      reasons |= 64 /* Tritone */;
-    }
-  }
-  if (q.prevPitch !== void 0) {
-    const pc = Math.abs(pitch - q.prevPitch) % 12;
-    if (pc === 6) {
-      reasons |= 64 /* Tritone */;
-      raise(2 /* Dissonant */);
-    }
-    if (isForbiddenMelodicLeap(q.prevPitch, pitch)) {
-      reasons |= 128 /* LargeLeap */;
-      raise(parallelSeverity);
-    }
-    if (pc === 1) {
-      reasons |= 256 /* MinorSecond */;
-    }
-    if (pc === 11) {
-      reasons |= 512 /* MajorSeventh */;
-    }
-  }
-  if (q.strongBeat) {
-    const twoVoice = q.otherVoices.length === 1;
-    const prev = q.prevPitch;
-    for (const ov of q.otherVoices) {
-      if (!createsVerticalDissonance(pitch, ov.pitch, twoVoice)) {
-        continue;
-      }
-      reasons |= 1024 /* VerticalDissonance */;
-      raise(2 /* Dissonant */);
-      if (prev !== void 0 && pitch === prev && ov.prevPitch !== void 0 && !createsVerticalDissonance(prev, ov.prevPitch, twoVoice)) {
-        reasons |= 16384 /* Suspension */;
-      }
-    }
-  }
-  if (q.prevPitch !== void 0) {
-    const prev = q.prevPitch;
-    for (const ov of q.otherVoices) {
-      if (ov.prevPitch === void 0) {
-        continue;
-      }
-      if (createsParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
-        reasons |= 2048 /* ParallelPerfect */;
-        raise(parallelSeverity);
-      }
-      if (createsHiddenParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
-        reasons |= 4096 /* HiddenParallel */;
-        raise(parallelSeverity);
-      }
-      const crossedNow = pitch - ov.pitch;
-      const crossedPrev = prev - ov.prevPitch;
-      if (crossedNow !== 0 && crossedPrev !== 0 && crossedNow > 0 !== crossedPrev > 0) {
-        reasons |= 8192 /* VoiceCrossing */;
-        raise(parallelSeverity);
-      }
-    }
-  }
-  raise(minimumSafetyForReasons(reasons, q.profile));
-  const result = { safety: level, reasons, rationale: describe(reasons, q) };
-  if (resolveTo !== void 0) {
-    result.resolveTo = resolveTo;
-  }
-  if (collectSuggestions && level !== 0 /* Safe */) {
-    const suggestions = findSafeNearby(q, pitch);
-    if (suggestions.length > 0) {
-      result.suggestions = suggestions;
-    }
-  }
-  return result;
-}
-function findSafeNearby(q, candidate) {
-  const out = [];
-  for (let d = 1; d <= SUGGESTION_WINDOW; d += 1) {
-    for (const p of [candidate - d, candidate + d]) {
-      if (evaluateInternal({ ...q, candidatePitch: p }, false).safety === 0 /* Safe */) {
-        out.push(p);
-        if (out.length >= MAX_SUGGESTIONS) {
-          return out;
-        }
-      }
-    }
-  }
-  return out;
-}
-function describe(reasons, q) {
-  if (reasons & 32 /* OutOfRange */) {
-    return "Outside the target vocal range";
-  }
-  if (reasons & 16384 /* Suspension */) {
-    return "Prepared suspension \u2014 a held consonance now dissonant, awaiting resolution";
-  }
-  if (reasons & 1024 /* VerticalDissonance */) {
-    return "Dissonant against a sounding voice on a strong beat";
-  }
-  if (reasons & 4 /* AvoidNote */) {
-    return "Avoid note \u2014 clashes with a chord tone a semitone away";
-  }
-  if (reasons & 2048 /* ParallelPerfect */) {
-    return "Parallel perfect interval with another voice";
-  }
-  if (reasons & 4096 /* HiddenParallel */) {
-    return "Hidden perfect interval by similar motion";
-  }
-  if (reasons & 8192 /* VoiceCrossing */) {
-    return "Crosses another voice";
-  }
-  if (reasons & 1 /* ChordTone */) {
-    return "Chord tone";
-  }
-  if (reasons & 2 /* Tension */) {
-    return "Chord tension";
-  }
-  if (reasons & 16 /* NonScale */) {
-    return "Outside the key";
-  }
-  if (reasons & 8 /* ScaleTone */) {
-    return "Scale tone, not in the chord";
-  }
-  return q.chord ? "Placeable" : "No chord context";
-}
-function enumerateSafePitches(q, pitchLow, pitchHigh) {
-  assertSafetyContext(q);
-  const chordTones = [];
-  const others = [];
-  assertInteger(pitchLow, "pitchLow");
-  assertInteger(pitchHigh, "pitchHigh");
-  if (pitchLow > pitchHigh) {
-    throw new RangeError(`pitchLow must not exceed pitchHigh; received ${pitchLow} > ${pitchHigh}`);
-  }
-  assertGenerationBudget(pitchHigh - pitchLow + 1, "safe pitch candidates");
-  for (let pitch = pitchHigh; pitch >= pitchLow; pitch -= 1) {
-    const result = evaluateInternal({ ...q, candidatePitch: pitch }, false);
-    if (result.safety === 2 /* Dissonant */) {
-      continue;
-    }
-    if (result.reasons & 1 /* ChordTone */) {
-      chordTones.push(pitch);
-    } else {
-      others.push(pitch);
-    }
-  }
-  return [...chordTones, ...others];
-}
-
-// src/core/pitch/index.ts
-var LETTER_SEMITONES = [0, 2, 4, 5, 7, 9, 11];
-var LETTER_NAMES = ["C", "D", "E", "F", "G", "A", "B"];
-function mod12(n) {
-  return (n % 12 + 12) % 12;
-}
-function mod7(n) {
-  return (n % 7 + 7) % 7;
-}
-function parseNote(text) {
-  const match = /^([A-Ga-g])([#x]*|b*)(-?\d+)?$/.exec(text.trim());
-  if (!match) {
-    throw new Error(`Invalid note: ${text}`);
-  }
-  const letterGlyph = (match[1] ?? "").toUpperCase();
-  const letter = LETTER_NAMES.indexOf(letterGlyph);
-  let alter = 0;
-  for (const ch of match[2] ?? "") {
-    if (ch === "#") {
-      alter += 1;
-    } else if (ch === "x") {
-      alter += 2;
-    } else if (ch === "b") {
-      alter -= 1;
-    }
-  }
-  const note = { letter, alter };
-  if (match[3] !== void 0) {
-    note.octave = Number.parseInt(match[3], 10);
-  }
-  return note;
-}
-function formatAlter(alter) {
-  if (alter > 0) {
-    return "#".repeat(alter);
-  }
-  if (alter < 0) {
-    return "b".repeat(-alter);
-  }
-  return "";
-}
-function formatNote(note) {
-  const glyph = LETTER_NAMES[mod7(note.letter)] ?? "C";
-  const octave = note.octave === void 0 ? "" : String(note.octave);
-  return `${glyph}${formatAlter(note.alter)}${octave}`;
-}
-function noteToPitchClass(note) {
-  const natural = LETTER_SEMITONES[mod7(note.letter)] ?? 0;
-  return mod12(natural + note.alter);
-}
-var SHARP_SPELLING = [
-  [0, 0],
-  [0, 1],
-  [1, 0],
-  [1, 1],
-  [2, 0],
-  [3, 0],
-  [3, 1],
-  [4, 0],
-  [4, 1],
-  [5, 0],
-  [5, 1],
-  [6, 0]
-];
-var FLAT_SPELLING = [
-  [0, 0],
-  [1, -1],
-  [1, 0],
-  [2, -1],
-  [2, 0],
-  [3, 0],
-  [4, -1],
-  [4, 0],
-  [5, -1],
-  [5, 0],
-  [6, -1],
-  [6, 0]
-];
-function midiToNote(midi, spelling = "sharp") {
-  const rounded = Math.round(midi);
-  const pc = mod12(rounded);
-  const octave = Math.floor(rounded / 12) - 1;
-  const table = spelling === "sharp" ? SHARP_SPELLING : FLAT_SPELLING;
-  const entry = table[pc] ?? [0, 0];
-  return { letter: entry[0], alter: entry[1], octave };
-}
-
-// src/theory/spelling/index.ts
-var LETTER_SEMITONES2 = [0, 2, 4, 5, 7, 9, 11];
-var CHROMATIC_SPELLING = {
-  1: { degreeOffset: 1, alter: -1 },
-  // b2
-  3: { degreeOffset: 2, alter: -1 },
-  // b3
-  6: { degreeOffset: 3, alter: 1 },
-  // #4
-  8: { degreeOffset: 5, alter: -1 },
-  // b6
-  9: { degreeOffset: 5, alter: 1 },
-  // #6 (raised sixth of a minor key)
-  10: { degreeOffset: 6, alter: -1 },
-  // b7
-  11: { degreeOffset: 6, alter: 1 }
-  // #7 (raised leading tone of a minor key)
-};
-function mod122(n) {
-  return (n % 12 + 12) % 12;
-}
-function mod72(n) {
-  return (n % 7 + 7) % 7;
-}
-function naturalPc(letter) {
-  return LETTER_SEMITONES2[mod72(letter)] ?? 0;
-}
-function alterFor(letter, pc) {
-  let d = mod122(pc - naturalPc(letter));
-  if (d > 6) {
-    d -= 12;
-  }
-  return d;
-}
-function isHeptatonic(key) {
-  return scaleTonesInDegreeOrder(key).length === 7;
-}
-function spellPitchClass(pc, tonic, key) {
-  const tonicPc = mod122(naturalPc(tonic.letter) + tonic.alter);
-  const offset = mod122(pc - tonicPc);
-  const tones = scaleTonesInDegreeOrder(key);
-  if (isHeptatonic(key)) {
-    const degree = tones.indexOf(mod122(pc));
-    if (degree >= 0) {
-      const letter = mod72(tonic.letter + degree);
-      return { letter, alter: alterFor(letter, pc) };
-    }
-    const chromatic = CHROMATIC_SPELLING[offset];
-    if (chromatic) {
-      const letter = mod72(tonic.letter + chromatic.degreeOffset);
-      return { letter, alter: alterFor(letter, pc) };
-    }
-  }
-  for (let letter = 0; letter < 7; letter += 1) {
-    if (naturalPc(letter) === mod122(pc)) {
-      return { letter, alter: 0 };
-    }
-  }
-  const belowLetter = mod72([0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6][mod122(pc)] ?? 0);
-  return { letter: belowLetter, alter: alterFor(belowLetter, pc) };
-}
-function spellScale(tonic, key) {
-  return scaleTonesInDegreeOrder(key).map((pc) => spellPitchClass(pc, tonic, key));
-}
-function spellPitchClasses(pcs, tonic, key) {
-  return pcs.map((pc) => spellPitchClass(pc, tonic, key));
-}
-function chordLetterOffset(interval, chord) {
-  switch (interval) {
-    case 0:
-    case 12:
-      return 0;
-    case 1:
-    case 2:
-    case 13:
-    case 14:
-      return 1;
-    case 3:
-    case 4:
-    case 15:
-    case 16:
-      return 2;
-    case 5:
-    case 17:
-    case 18:
-      return 3;
-    case 6:
-    case 7:
-    case 8:
-    case 19:
-      return 4;
-    case 9:
-      return chord.quality === "dim7" ? 6 : 5;
-    case 20:
-    case 21:
-      return 5;
-    case 10:
-    case 11:
-    case 22:
-    case 23:
-      return 6;
-    default: {
-      const octaves = Math.floor(Math.max(0, interval) / 12);
-      const simple = mod122(interval);
-      const simpleOffset = [0, 1, 1, 2, 2, 3, 4, 4, 4, 5, 6, 6][simple] ?? 0;
-      return octaves * 7 + simpleOffset;
-    }
-  }
-}
-function spellChordFromRoot(chord, root) {
-  return chord.intervals.map((interval) => {
-    const letter = mod72(root.letter + chordLetterOffset(interval, chord));
-    const pc = mod122(chord.rootPc + interval);
-    return { letter, alter: alterFor(letter, pc) };
-  });
-}
-function spellChord(chord, tonic, key) {
-  const root = spellPitchClass(chord.rootPc, tonic, key);
-  return spellChordFromRoot(chord, root);
-}
-function noteNames(notes) {
-  return notes.map(formatNote);
-}
-
-// src/theory/symbol/index.ts
-var ROOT_RE = /^[A-Ga-g](?:#{1,2}|b{1,2})?/;
-var BASS_RE = /^[A-Ga-g](?:#{1,2}|b{1,2})?$/;
-var QUALITY_MAP = {
-  "": "maj",
-  m: "min",
-  min: "min",
-  "-": "min",
-  dim: "dim",
-  "\xB0": "dim",
-  aug: "aug",
-  "+": "aug",
-  maj7: "maj7",
-  M7: "maj7",
-  \u0394: "maj7",
-  \u03947: "maj7",
-  m7: "min7",
-  min7: "min7",
-  "-7": "min7",
-  "7": "dom7",
-  dim7: "dim7",
-  "\xB07": "dim7",
-  m7b5: "m7b5",
-  \u00F8: "m7b5",
-  \u00F87: "m7b5",
-  min7b5: "m7b5",
-  mMaj7: "minMaj7",
-  mM7: "minMaj7",
-  minMaj7: "minMaj7",
-  aug7: "aug7",
-  "+7": "aug7",
-  "7#5": "aug7",
-  augMaj7: "augMaj7",
-  augM7: "augMaj7",
-  "+maj7": "augMaj7",
-  "+M7": "augMaj7",
-  majb5: "majb5",
-  "maj(b5)": "majb5",
-  "(b5)": "majb5",
-  "6": "6",
-  m6: "min6",
-  min6: "min6",
-  "6/9": "6/9",
-  "69": "6/9",
-  sus2: "sus2",
-  sus: "sus4",
-  sus4: "sus4",
-  add9: "add9",
-  add11: "add11",
-  maj9: "maj9",
-  M9: "maj9",
-  m9: "min9",
-  min9: "min9",
-  "9": "dom9",
-  "7b9": "7b9",
-  "7#9": "7#9",
-  "7#11": "7#11",
-  "7b13": "7b13",
-  "11": "11",
-  "13": "13",
-  "5": "5"
-};
-var CANONICAL_SUFFIX = {
-  maj: "",
-  min: "m",
-  dim: "dim",
-  aug: "aug",
-  maj7: "maj7",
-  min7: "m7",
-  dom7: "7",
-  dim7: "dim7",
-  m7b5: "m7b5",
-  minMaj7: "mMaj7",
-  aug7: "aug7",
-  augMaj7: "augMaj7",
-  majb5: "maj(b5)",
-  "6": "6",
-  min6: "m6",
-  "6/9": "6/9",
-  sus2: "sus2",
-  sus4: "sus4",
-  add9: "add9",
-  add11: "add11",
-  maj9: "maj9",
-  min9: "m9",
-  dom9: "9",
-  "7b9": "7b9",
-  "7#9": "7#9",
-  "7#11": "7#11",
-  "7b13": "7b13",
-  "11": "11",
-  "13": "13",
-  "5": "5"
-};
-function pitchClass6(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function makeSpelledChord(root, quality, bass) {
-  const chord = makeChord(
-    noteToPitchClass(root),
-    quality,
-    bass === void 0 ? void 0 : noteToPitchClass(bass)
-  );
-  chord.rootSpelling = { letter: root.letter, alter: root.alter };
-  if (bass !== void 0) {
-    chord.bassSpelling = { letter: bass.letter, alter: bass.alter };
-  }
-  return chord;
-}
-function parseChordSymbol(text) {
-  const trimmed = text.trim();
-  const rootMatch = ROOT_RE.exec(trimmed);
-  if (!rootMatch) {
-    throw new Error(`Invalid chord symbol: ${text}`);
-  }
-  const rootToken = rootMatch[0];
-  const rootNote = parseNote(rootToken);
-  const rest = trimmed.slice(rootToken.length);
-  const slashIndex = rest.lastIndexOf("/");
-  if (slashIndex !== -1) {
-    const before = rest.slice(0, slashIndex);
-    const after = rest.slice(slashIndex + 1);
-    const beforeQuality = QUALITY_MAP[before];
-    if (beforeQuality !== void 0 && BASS_RE.test(after)) {
-      return makeSpelledChord(rootNote, beforeQuality, parseNote(after));
-    }
-  }
-  const quality = QUALITY_MAP[rest];
-  if (quality === void 0) {
-    throw new Error(`Unrecognized chord quality: ${text}`);
-  }
-  return makeSpelledChord(rootNote, quality);
-}
-function pitchClassName(pc, hint, flats) {
-  if (flats === void 0 && hint !== void 0 && noteToPitchClass(hint) === pc) {
-    return formatNote(hint);
-  }
-  const note = midiToNote(60 + pc, flats ? "flat" : "sharp");
-  return formatNote({ letter: note.letter, alter: note.alter });
-}
-function formatChordSymbol(chord, opts) {
-  const rootPc = pitchClass6(chord.rootPc);
-  const rootName = pitchClassName(rootPc, chord.rootSpelling, opts?.flats);
-  const suffix = CANONICAL_SUFFIX[chord.quality];
-  let symbol = `${rootName}${suffix}`;
-  if (chord.bassPc !== void 0 && pitchClass6(chord.bassPc) !== rootPc) {
-    symbol += `/${pitchClassName(pitchClass6(chord.bassPc), chord.bassSpelling, opts?.flats)}`;
-  }
-  return symbol;
-}
-function transposeChordSymbol(text, semitones, opts) {
-  const chord = parseChordSymbol(text);
-  const transposed = { ...chord, rootPc: pitchClass6(chord.rootPc + semitones) };
-  if (chord.bassPc !== void 0) {
-    transposed.bassPc = pitchClass6(chord.bassPc + semitones);
-  }
-  return formatChordSymbol(transposed, opts);
-}
-
-// src/theory/voicing/internal.ts
-var DEFAULT_MAX_SPACING = 12;
-var VIOLATION_PENALTY = 1e3;
-var MISSING_TONE_PENALTY = 500;
-var POOR_DOUBLING_PENALTY = 4;
-var MAX_CANDIDATES = 4e3;
-function pitchClass7(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function pitchesForPc(pc, range) {
-  const result = [];
-  for (let midi = Math.ceil(range.min); midi <= range.max; midi += 1) {
-    if (pitchClass7(midi) === pc) {
-      result.push(midi);
-    }
-  }
-  const center = (range.min + range.max) / 2;
-  return result.sort((a, b) => {
-    const da = Math.abs(a - center);
-    const db = Math.abs(b - center);
-    return da === db ? a - b : da - db;
-  });
-}
-function enumerateVoicings(chord, ranges, maxSpacing) {
-  const chordPcs = chordPitchClasses(chord);
-  const bassPc = pitchClass7(chord.bassPc ?? chord.rootPc);
-  const results = [];
-  const current = [];
-  const build = (voice) => {
-    if (results.length >= MAX_CANDIDATES) {
-      return;
-    }
-    if (voice === ranges.length) {
-      results.push([...current]);
-      return;
-    }
-    const range = ranges[voice];
-    if (range === void 0) {
-      return;
-    }
-    const pcs = voice === 0 ? [bassPc] : chordPcs;
-    const prev = current[voice - 1];
-    for (const pc of pcs) {
-      for (const pitch of pitchesForPc(pc, range)) {
-        if (prev !== void 0) {
-          if (pitch < prev) {
-            continue;
-          }
-          const spacingLimit = voice === 1 ? maxSpacing + 12 : maxSpacing;
-          if (pitch - prev > spacingLimit) {
-            continue;
-          }
-        }
-        current.push(pitch);
-        build(voice + 1);
-        current.pop();
-      }
-    }
-  };
-  build(0);
-  return results;
-}
-function structuralPenalty(pitches, chord) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const pitch of pitches) {
-    const pc = pitchClass7(pitch);
-    counts.set(pc, (counts.get(pc) ?? 0) + 1);
-  }
-  let penalty = 0;
-  for (const pc of chordPitchClasses(chord)) {
-    if (!counts.has(pc)) {
-      penalty += MISSING_TONE_PENALTY;
-    }
-  }
-  const rootPc = pitchClass7(chord.rootPc);
-  const fifthPc = pitchClass7(chord.rootPc + 7);
-  for (const [pc, count] of counts) {
-    if (count > 1 && pc !== rootPc && pc !== fifthPc) {
-      penalty += (count - 1) * POOR_DOUBLING_PENALTY;
-    }
-  }
-  return penalty;
-}
-function violationCount(prev, cur, maxSpacing) {
-  let count = 0;
-  for (let lower = 0; lower < cur.length; lower += 1) {
-    for (let upper = lower + 1; upper < cur.length; upper += 1) {
-      const prevLower = prev[lower];
-      const prevUpper = prev[upper];
-      const curLower = cur[lower];
-      const curUpper = cur[upper];
-      if (prevLower === void 0 || prevUpper === void 0 || curLower === void 0 || curUpper === void 0) {
-        continue;
-      }
-      if (createsParallelPerfect(prevUpper, curUpper, prevLower, curLower)) {
-        count += 1;
-      }
-      if (createsVoiceCrossing(curUpper, curLower)) {
-        count += 1;
-      }
-      if (upper === lower + 1) {
-        if (createsVoiceOverlap(prevUpper, curUpper, prevLower, curLower)) {
-          count += 1;
-        }
-        if (lower > 0 && exceedsSpacing(curUpper, curLower, maxSpacing)) {
-          count += 1;
-        }
-      }
-    }
-  }
-  return count;
-}
-
-// src/theory/voicing/satb.ts
-var SATB_RANGES = [
-  { min: 40, max: 60 },
-  { min: 48, max: 67 },
-  { min: 55, max: 74 },
-  { min: 60, max: 79 }
-];
-var DERIVED_LOW = 40;
-var DERIVED_HIGH = 79;
-var DERIVED_SPAN = 19;
-function resolveRanges(opts) {
-  if (opts?.ranges !== void 0) {
-    if (opts.ranges.length === 0) {
-      throw new Error("ranges must contain at least one voice range");
-    }
-    assertGenerationBudget(opts.ranges.length, "voice ranges", 128);
-    return opts.ranges.map((range, index) => {
-      assertFiniteNumber(range.min, `ranges[${index}].min`);
-      assertFiniteNumber(range.max, `ranges[${index}].max`);
-      if (range.min > range.max) {
-        throw new RangeError(`ranges[${index}].min must not exceed max`);
-      }
-      assertGenerationBudget(
-        Math.floor(range.max) - Math.ceil(range.min) + 1,
-        `ranges[${index}] span`,
-        4096
-      );
-      return { ...range };
-    });
-  }
-  const voices = opts?.voices ?? 4;
-  assertPositiveInt(voices, "voices", 128);
-  if (voices === 4) {
-    return SATB_RANGES.map((range) => ({ ...range }));
-  }
-  if (voices === 1) {
-    return [{ min: DERIVED_LOW, max: DERIVED_HIGH }];
-  }
-  const ranges = [];
-  for (let i = 0; i < voices; i += 1) {
-    const min = Math.round(
-      DERIVED_LOW + i * (DERIVED_HIGH - DERIVED_SPAN - DERIVED_LOW) / (voices - 1)
-    );
-    ranges.push({ min, max: min + DERIVED_SPAN });
-  }
-  return ranges;
-}
-function voiceChord(chord, opts) {
-  const ranges = resolveRanges(opts);
-  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;
-  assertFiniteNumber(maxSpacing, "maxSpacing");
-  if (maxSpacing < 0) throw new RangeError("maxSpacing must be non-negative");
-  const candidates = enumerateVoicings(chord, ranges, maxSpacing);
-  let best;
-  let bestScore = Number.POSITIVE_INFINITY;
-  for (const candidate of candidates) {
-    let score = structuralPenalty(candidate, chord);
-    for (let i = 0; i < candidate.length; i += 1) {
-      const pitch = candidate[i];
-      const range = ranges[i];
-      if (pitch === void 0 || range === void 0) {
-        continue;
-      }
-      score += Math.abs(pitch - (range.min + range.max) / 2);
-    }
-    if (score < bestScore) {
-      bestScore = score;
-      best = candidate;
-    }
-  }
-  if (best === void 0) {
-    throw new Error("no voicing satisfies the given ranges");
-  }
-  return best;
-}
-function voiceProgression(chords, opts) {
-  assertGenerationBudget(chords.length * 4e3, "voiced progression search");
-  const ranges = resolveRanges(opts);
-  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;
-  assertFiniteNumber(maxSpacing, "maxSpacing");
-  if (maxSpacing < 0) throw new RangeError("maxSpacing must be non-negative");
-  const result = [];
-  let prev;
-  for (const chord of chords) {
-    if (prev === void 0) {
-      prev = voiceChord(chord, opts);
-      result.push(prev);
-      continue;
-    }
-    const candidates = enumerateVoicings(chord, ranges, maxSpacing);
-    let best;
-    let bestScore = Number.POSITIVE_INFINITY;
-    for (const candidate of candidates) {
-      const score = structuralPenalty(candidate, chord) + voiceLeadingCost(prev, candidate) + VIOLATION_PENALTY * violationCount(prev, candidate, maxSpacing);
-      if (score < bestScore) {
-        bestScore = score;
-        best = candidate;
-      }
-    }
-    if (best === void 0) {
-      throw new Error("no voicing satisfies the given ranges");
-    }
-    result.push(best);
-    prev = best;
-  }
-  return result;
-}
-
-// src/theory/voicing/leading.ts
-var HIDDEN_PERFECT_PENALTY = 6;
-function voiceLeadingCost(from, to) {
-  if (from.length !== to.length) {
-    return Number.POSITIVE_INFINITY;
-  }
-  let total = 0;
-  for (let i = 0; i < from.length; i += 1) {
-    const a = from[i];
-    const b = to[i];
-    if (a === void 0 || b === void 0) {
-      continue;
-    }
-    total += Math.abs(b - a);
-  }
-  if (from.length >= 2) {
-    const bassPrev = from[0];
-    const bassCur = to[0];
-    const sopPrev = from[from.length - 1];
-    const sopCur = to[to.length - 1];
-    if (bassPrev !== void 0 && bassCur !== void 0 && sopPrev !== void 0 && sopCur !== void 0 && createsHiddenParallelPerfect(bassPrev, bassCur, sopPrev, sopCur)) {
-      total += HIDDEN_PERFECT_PENALTY;
-    }
-  }
-  return total;
-}
-function nextVoicing(current, chord, opts) {
-  const ranges = opts?.ranges !== void 0 || opts?.voices !== void 0 ? resolveRanges(opts) : current.map((pitch) => {
-    const centre = Math.min(127, Math.max(0, pitch));
-    return { min: Math.max(0, centre - 12), max: Math.min(127, centre + 12) };
-  });
-  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;
-  const candidates = enumerateVoicings(chord, ranges, maxSpacing);
-  let best;
-  let bestScore = Number.POSITIVE_INFINITY;
-  for (const candidate of candidates) {
-    const score = structuralPenalty(candidate, chord) + voiceLeadingCost(current, candidate) + VIOLATION_PENALTY * violationCount(current, candidate, maxSpacing);
-    if (score < bestScore) {
-      bestScore = score;
-      best = candidate;
-    }
-  }
-  if (best === void 0) {
-    throw new Error("no voicing satisfies the given ranges");
-  }
-  return best;
-}
-
-// src/theory/voicing/styled.ts
-var DEFAULT_STYLE_OCTAVE = 4;
-function dedupePcs(pcs) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const pc of pcs) {
-    if (!seen.has(pc)) {
-      seen.add(pc);
-      result.push(pc);
-    }
-  }
-  return result;
-}
-function lowestPitchAtOrAbove(pc, floor) {
-  return floor + ((pc - pitchClass7(floor)) % 12 + 12) % 12;
-}
-function nearestPc(target, pcs) {
-  let best = pcs[0] ?? target;
-  let bestDist = 12;
-  for (const pc of pcs) {
-    const dist = Math.min(((pc - target) % 12 + 12) % 12, ((target - pc) % 12 + 12) % 12);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = pc;
-    }
-  }
-  return best;
-}
-function voiceChordStyled(chord, opts) {
-  const style = opts?.style ?? "close";
-  const octave = opts?.octave ?? DEFAULT_STYLE_OCTAVE;
-  assertInteger(octave, "styled voicing octave", -10, 10);
-  if (opts?.topNote !== void 0) {
-    assertFiniteNumber(opts.topNote, "styled voicing topNote");
-  }
-  const base = 12 * (octave + 1);
-  const rootPc = pitchClass7(chord.rootPc);
-  const bassPc = pitchClass7(chord.bassPc ?? chord.rootPc);
-  const omitRoot = style === "rootless" || opts?.rootless === true;
-  let order = dedupePcs(chord.intervals.map((interval) => pitchClass7(chord.rootPc + interval)));
-  const bassIndex = order.indexOf(bassPc);
-  if (bassIndex > 0) {
-    order = [...order.slice(bassIndex), ...order.slice(0, bassIndex)];
-  } else if (bassIndex < 0) {
-    order = [bassPc, ...order];
-  }
-  if (style === "shell") {
-    const roles = order.map((pc) => chordToneRole(pc, chord));
-    const guide = roles.includes("seventh") ? "seventh" : roles.includes("sixth") ? "sixth" : "fifth";
-    order = order.filter((_pc, i) => {
-      const role = roles[i];
-      return _pc === bassPc || role === "root" || role === "third" || role === guide;
-    });
-  }
-  if (omitRoot) {
-    order = order.filter((pc) => pc !== rootPc || chord.bassPc !== void 0 && pc === bassPc);
-  }
-  if (order.length === 0) {
-    return [];
-  }
-  if (opts?.topNote !== void 0) {
-    const target = order.includes(pitchClass7(opts.topNote)) ? pitchClass7(opts.topNote) : nearestPc(pitchClass7(opts.topNote), order);
-    const targetIndex = order.indexOf(target);
-    order = [...order.slice(targetIndex + 1), ...order.slice(0, targetIndex + 1)];
-  }
-  const stack = [];
-  let prev;
-  for (const pc of order) {
-    if (prev === void 0) {
-      prev = lowestPitchAtOrAbove(pc, base);
-    } else {
-      let delta = ((pc - pitchClass7(prev)) % 12 + 12) % 12;
-      if (delta === 0) {
-        delta = 12;
-      }
-      prev += delta;
-    }
-    stack.push(prev);
-  }
-  if (style === "drop2" && stack.length >= 2) {
-    stack[stack.length - 2] = (stack[stack.length - 2] ?? 0) - 12;
-  } else if (style === "drop3" && stack.length >= 3) {
-    stack[stack.length - 3] = (stack[stack.length - 3] ?? 0) - 12;
-  }
-  if (chord.bassPc !== void 0) {
-    const bassIndexInStack = stack.findIndex((pitch) => pitchClass7(pitch) === bassPc);
-    if (bassIndexInStack >= 0) {
-      const otherLowest = Math.min(
-        ...stack.filter((_pitch, index) => index !== bassIndexInStack),
-        Number.POSITIVE_INFINITY
-      );
-      while ((stack[bassIndexInStack] ?? 0) >= otherLowest) {
-        stack[bassIndexInStack] = (stack[bassIndexInStack] ?? 0) - 12;
-      }
-    }
-  }
-  return stack.sort((a, b) => a - b);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BLUES_MASK,
-  CHROMATIC_MASK,
-  DORIAN_MASK,
-  HARMONIC_MINOR_MASK,
-  LOCRIAN_MASK,
-  LYDIAN_MASK,
-  MAJOR_MASK,
-  MAJOR_PENTATONIC_MASK,
-  MELODIC_MINOR_MASK,
-  MINOR_PENTATONIC_MASK,
-  MIXOLYDIAN_MASK,
-  NAMED_SCALES,
-  NATURAL_MINOR_MASK,
-  NoteSafety,
-  OCTATONIC_HALF_WHOLE_MASK,
-  OCTATONIC_WHOLE_HALF_MASK,
-  PHRYGIAN_MASK,
-  ReasonFlag,
-  SATB_RANGES,
-  WHOLE_TONE_MASK,
-  availableTensions,
-  avoidNotes,
-  chordFromDegree,
-  chordPitchClasses,
-  chordQualities,
-  chordScaleReport,
-  chordScales,
-  chordToneRole,
-  createsHiddenParallelPerfect,
-  createsParallelOctave,
-  createsParallelPerfect,
-  createsParallelUnison,
-  createsVerticalDissonance,
-  createsVoiceCrossing,
-  createsVoiceOverlap,
-  diatonicPitchClasses,
-  diatonicSeventh,
-  diatonicTriad,
-  enumerateSafePitches,
-  evaluateSafety,
-  exceedsSpacing,
-  formatChordSymbol,
-  isForbiddenMelodicLeap,
-  isLeadingToneResolution,
-  isScaleTone,
-  majorKey,
-  makeChord,
-  maskFromOffsets,
-  minorKey,
-  nearestScaleTone,
-  nextVoicing,
-  noteNames,
-  parseChordSymbol,
-  pitchToScaleDegree,
-  roleOf,
-  scaleByName,
-  scaleMatchesChord,
-  scaleTonesInDegreeOrder,
-  scalesForChanges,
-  spellChord,
-  spellPitchClass,
-  spellPitchClasses,
-  spellScale,
-  transposeChordSymbol,
-  voiceChord,
-  voiceChordStyled,
-  voiceLeadingCost,
-  voiceProgression
-});
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../chunk-T64C7ZD7.cjs');
+
+
+var _chunkFCANXBATcjs = require('../chunk-FCANXBAT.cjs');
+
+
+
+
+
+var _chunkQ6OP4U43cjs = require('../chunk-Q6OP4U43.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkLW53AHQUcjs = require('../chunk-LW53AHQU.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkFNDWXRRIcjs = require('../chunk-FNDWXRRI.cjs');
+require('../chunk-7MGZ7D62.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ALTERED_MASK = _chunkFNDWXRRIcjs.ALTERED_MASK; exports.BLUES_MASK = _chunkFNDWXRRIcjs.BLUES_MASK; exports.CHROMATIC_MASK = _chunkFNDWXRRIcjs.CHROMATIC_MASK; exports.DORIAN_MASK = _chunkFNDWXRRIcjs.DORIAN_MASK; exports.HARMONIC_MINOR_MASK = _chunkFNDWXRRIcjs.HARMONIC_MINOR_MASK; exports.LOCRIAN_MASK = _chunkFNDWXRRIcjs.LOCRIAN_MASK; exports.LOCRIAN_NATURAL2_MASK = _chunkFNDWXRRIcjs.LOCRIAN_NATURAL2_MASK; exports.LYDIAN_DOMINANT_MASK = _chunkFNDWXRRIcjs.LYDIAN_DOMINANT_MASK; exports.LYDIAN_MASK = _chunkFNDWXRRIcjs.LYDIAN_MASK; exports.MAJOR_MASK = _chunkFNDWXRRIcjs.MAJOR_MASK; exports.MAJOR_PENTATONIC_MASK = _chunkFNDWXRRIcjs.MAJOR_PENTATONIC_MASK; exports.MELODIC_MINOR_MASK = _chunkFNDWXRRIcjs.MELODIC_MINOR_MASK; exports.MINOR_PENTATONIC_MASK = _chunkFNDWXRRIcjs.MINOR_PENTATONIC_MASK; exports.MIXOLYDIAN_B13_MASK = _chunkFNDWXRRIcjs.MIXOLYDIAN_B13_MASK; exports.MIXOLYDIAN_MASK = _chunkFNDWXRRIcjs.MIXOLYDIAN_MASK; exports.NAMED_SCALES = _chunkFNDWXRRIcjs.NAMED_SCALES; exports.NATURAL_MINOR_MASK = _chunkFNDWXRRIcjs.NATURAL_MINOR_MASK; exports.NoteSafety = _chunkQ6OP4U43cjs.NoteSafety; exports.OCTATONIC_HALF_WHOLE_MASK = _chunkFNDWXRRIcjs.OCTATONIC_HALF_WHOLE_MASK; exports.OCTATONIC_WHOLE_HALF_MASK = _chunkFNDWXRRIcjs.OCTATONIC_WHOLE_HALF_MASK; exports.PHRYGIAN_DOMINANT_MASK = _chunkFNDWXRRIcjs.PHRYGIAN_DOMINANT_MASK; exports.PHRYGIAN_MASK = _chunkFNDWXRRIcjs.PHRYGIAN_MASK; exports.ReasonFlag = _chunkQ6OP4U43cjs.ReasonFlag; exports.SATB_RANGES = _chunkLW53AHQUcjs.SATB_RANGES; exports.WHOLE_TONE_MASK = _chunkFNDWXRRIcjs.WHOLE_TONE_MASK; exports.availableTensions = _chunkLW53AHQUcjs.availableTensions; exports.avoidNotes = _chunkLW53AHQUcjs.avoidNotes; exports.chordFromDegree = _chunkFNDWXRRIcjs.chordFromDegree; exports.chordPitchClasses = _chunkFNDWXRRIcjs.chordPitchClasses; exports.chordQualities = _chunkFNDWXRRIcjs.chordQualities; exports.chordScaleReport = _chunkLW53AHQUcjs.chordScaleReport; exports.chordScales = _chunkLW53AHQUcjs.chordScales; exports.chordToneRole = _chunkFNDWXRRIcjs.chordToneRole; exports.createsHiddenParallelPerfect = _chunkFNDWXRRIcjs.createsHiddenParallelPerfect; exports.createsParallelOctave = _chunkFNDWXRRIcjs.createsParallelOctave; exports.createsParallelPerfect = _chunkFNDWXRRIcjs.createsParallelPerfect; exports.createsParallelUnison = _chunkFNDWXRRIcjs.createsParallelUnison; exports.createsVerticalDissonance = _chunkFNDWXRRIcjs.createsVerticalDissonance; exports.createsVoiceCrossing = _chunkFNDWXRRIcjs.createsVoiceCrossing; exports.createsVoiceOverlap = _chunkFNDWXRRIcjs.createsVoiceOverlap; exports.diatonicPitchClasses = _chunkFNDWXRRIcjs.diatonicPitchClasses; exports.diatonicSeventh = _chunkFNDWXRRIcjs.diatonicSeventh; exports.diatonicTriad = _chunkFNDWXRRIcjs.diatonicTriad; exports.enumerateSafePitches = _chunkQ6OP4U43cjs.enumerateSafePitches; exports.evaluateSafety = _chunkQ6OP4U43cjs.evaluateSafety; exports.exceedsSpacing = _chunkFNDWXRRIcjs.exceedsSpacing; exports.formatChordSymbol = _chunkLW53AHQUcjs.formatChordSymbol; exports.intervalAboveRoot = _chunkFNDWXRRIcjs.intervalAboveRoot; exports.isChordMember = _chunkFNDWXRRIcjs.isChordMember; exports.isForbiddenMelodicLeap = _chunkFNDWXRRIcjs.isForbiddenMelodicLeap; exports.isLeadingToneResolution = _chunkFNDWXRRIcjs.isLeadingToneResolution; exports.isScaleTone = _chunkFNDWXRRIcjs.isScaleTone; exports.majorKey = _chunkFNDWXRRIcjs.majorKey; exports.makeChord = _chunkFNDWXRRIcjs.makeChord; exports.maskFromOffsets = _chunkFNDWXRRIcjs.maskFromOffsets; exports.minorKey = _chunkFNDWXRRIcjs.minorKey; exports.namedScaleMask = _chunkFNDWXRRIcjs.namedScaleMask; exports.nearestScaleTone = _chunkFNDWXRRIcjs.nearestScaleTone; exports.nextVoicing = _chunkLW53AHQUcjs.nextVoicing; exports.noteNames = _chunkLW53AHQUcjs.noteNames; exports.parseChordSymbol = _chunkLW53AHQUcjs.parseChordSymbol; exports.pitchToScaleDegree = _chunkFNDWXRRIcjs.pitchToScaleDegree; exports.requireScaleMask = _chunkFNDWXRRIcjs.requireScaleMask; exports.roleOf = _chunkFCANXBATcjs.roleOf; exports.scaleByName = _chunkFNDWXRRIcjs.scaleByName; exports.scaleMatchesChord = _chunkLW53AHQUcjs.scaleMatchesChord; exports.scaleTonesInDegreeOrder = _chunkFNDWXRRIcjs.scaleTonesInDegreeOrder; exports.scalesForChanges = _chunkLW53AHQUcjs.scalesForChanges; exports.spellChord = _chunkLW53AHQUcjs.spellChord; exports.spellChordFromRoot = _chunkLW53AHQUcjs.spellChordFromRoot; exports.spellPitch = _chunkLW53AHQUcjs.spellPitch; exports.spellPitchClass = _chunkLW53AHQUcjs.spellPitchClass; exports.spellPitchClasses = _chunkLW53AHQUcjs.spellPitchClasses; exports.spellScale = _chunkLW53AHQUcjs.spellScale; exports.transposeChord = _chunkFNDWXRRIcjs.transposeChord; exports.transposeChordSymbol = _chunkLW53AHQUcjs.transposeChordSymbol; exports.voiceChord = _chunkLW53AHQUcjs.voiceChord; exports.voiceChordStyled = _chunkLW53AHQUcjs.voiceChordStyled; exports.voiceLeadingCost = _chunkLW53AHQUcjs.voiceLeadingCost; exports.voiceProgression = _chunkLW53AHQUcjs.voiceProgression;
 //# sourceMappingURL=index.cjs.map