@libraz/libcantus 0.9.3 → 0.9.4

package/dist/model/index.cjs

@@ -1,2574 +1,20 @@
-"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);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/model/index.ts
-var model_exports = {};
-__export(model_exports, {
-  Chord: () => Chord,
-  Interval: () => Interval,
-  Key: () => Key,
-  Note: () => Note,
-  Progression: () => Progression
-});
-module.exports = __toCommonJS(model_exports);
 
-// 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/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 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 };
-}
+var _chunkNVE34YGZcjs = require('../chunk-NVE34YGZ.cjs');
+require('../chunk-ZEJR4TKL.cjs');
+require('../chunk-CAN76NCU.cjs');
+require('../chunk-LW53AHQU.cjs');
+require('../chunk-FNDWXRRI.cjs');
+require('../chunk-7MGZ7D62.cjs');
 
-// 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/analyze/detect/index.ts
-function pitchClass3(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function uniquePitchClasses(pitches) {
-  return [...new Set(pitches.map(pitchClass3))].sort((a, b) => a - b);
-}
-function assertPitches(pitches) {
-  assertGenerationBudget(pitches.length, "detection pitches");
-  for (let index = 0; index < pitches.length; index += 1) {
-    assertFiniteNumber(pitches[index] ?? Number.NaN, `pitches[${index}]`);
-  }
-}
-function detectChord(pitches, opts = {}) {
-  assertPitches(pitches);
-  if (opts.bassPc !== void 0) assertFiniteNumber(opts.bassPc, "bassPc");
-  const input = uniquePitchClasses(pitches);
-  if (input.length === 0) {
-    return [];
-  }
-  const inputKind = opts.input === void 0 || opts.input === "auto" ? pitches.every((pitch) => Number.isInteger(pitch) && pitch >= 0 && pitch <= 11) ? "pitchClass" : "midi" : opts.input;
-  const bassPc = opts.bassPc !== void 0 ? pitchClass3(opts.bassPc) : inputKind === "midi" ? pitchClass3(pitches.reduce((lowest, pitch) => Math.min(lowest, pitch), Infinity)) : void 0;
-  const inputSet = new Set(input);
-  const matches = [];
-  const qualities = chordQualities();
-  for (const rootPc of input) {
-    for (const quality of qualities) {
-      const chord = makeChord(rootPc, quality);
-      const tones = chordPitchClasses(chord);
-      const toneSet = new Set(tones);
-      const missingPcs = tones.filter((pc) => !inputSet.has(pc));
-      const fifthPc = pitchClass3(rootPc + 7);
-      if (missingPcs.length > 1 || missingPcs.length === 1 && missingPcs[0] !== fifthPc) {
-        continue;
-      }
-      const extraPcs = input.filter((pc) => !toneSet.has(pc));
-      const bassIndex = bassPc === void 0 ? -1 : chord.intervals.findIndex((iv) => pitchClass3(rootPc + iv) === bassPc);
-      const inversion = bassPc === void 0 ? null : bassIndex > 0 ? bassIndex : 0;
-      const match = {
-        rootPc,
-        quality,
-        missingPcs,
-        extraPcs,
-        exact: extraPcs.length === 0 && missingPcs.length === 0,
-        inversion
-      };
-      if (bassPc !== void 0 && bassPc !== rootPc) {
-        match.bassPc = bassPc;
-      }
-      matches.push(match);
-    }
-  }
-  matches.sort((a, b) => {
-    if (a.extraPcs.length !== b.extraPcs.length) {
-      return a.extraPcs.length - b.extraPcs.length;
-    }
-    if (a.missingPcs.length !== b.missingPcs.length) {
-      return a.missingPcs.length - b.missingPcs.length;
-    }
-    if (a.inversion === 0 !== (b.inversion === 0)) {
-      return a.inversion === 0 ? -1 : 1;
-    }
-    const aSize = chordPitchClasses(makeChord(a.rootPc, a.quality)).length;
-    const bSize = chordPitchClasses(makeChord(b.rootPc, b.quality)).length;
-    return bSize - aSize;
-  });
-  return matches;
-}
-function detectChordBest(pitches, opts = {}) {
-  const best = detectChord(pitches, opts)[0];
-  if (!best) {
-    return null;
-  }
-  return makeChord(best.rootPc, best.quality, best.bassPc);
-}
 
-// src/analyze/functional/internal.ts
-function mod12(n) {
-  return (n % 12 + 12) % 12;
-}
-function degreeRootPc(degreeNumber, key) {
-  const tones = scaleTonesInDegreeOrder(key);
-  if (tones.length === 0) {
-    return mod12(key.rootPc);
-  }
-  return tones[(degreeNumber - 1) % tones.length] ?? mod12(key.rootPc);
-}
-function isNeapolitan(chord, key) {
-  return mod12(chord.rootPc - key.rootPc) === 1 && chord.quality === "maj";
-}
 
-// src/analyze/functional/roman.ts
-var ROMAN = ["I", "II", "III", "IV", "V", "VI", "VII"];
-var ROMAN_TO_DEGREE = {
-  I: 1,
-  II: 2,
-  III: 3,
-  IV: 4,
-  V: 5,
-  VI: 6,
-  VII: 7
-};
-var OFFSET_SPELLING = [
-  [1, ""],
-  [2, "b"],
-  [2, ""],
-  [3, "b"],
-  [3, ""],
-  [4, ""],
-  [4, "#"],
-  [5, ""],
-  [6, "b"],
-  [6, ""],
-  [7, "b"],
-  [7, ""]
-];
-function seventhQuality(base, halfDim) {
-  if (halfDim) {
-    return "m7b5";
-  }
-  if (base === "dim") {
-    return "dim7";
-  }
-  if (base === "aug") {
-    return "aug7";
-  }
-  return base === "maj" ? "dom7" : "min7";
-}
-var INVERSION_FIGURES = /* @__PURE__ */ new Set(["6", "64", "65", "43", "42", "2", "7"]);
-var ROMAN_STYLE = {
-  maj: { lower: false, suffix: "" },
-  min: { lower: true, suffix: "" },
-  dim: { lower: true, suffix: "o" },
-  aug: { lower: false, suffix: "+" },
-  maj7: { lower: false, suffix: "maj7" },
-  min7: { lower: true, suffix: "7" },
-  dom7: { lower: false, suffix: "7" },
-  dim7: { lower: true, suffix: "o7" },
-  m7b5: { lower: true, suffix: "\xF87" },
-  minMaj7: { lower: true, suffix: "maj7" },
-  aug7: { lower: false, suffix: "+7" },
-  augMaj7: { lower: false, suffix: "+maj7" },
-  majb5: { lower: false, suffix: "b5" },
-  "6": { lower: false, suffix: "add6" },
-  min6: { lower: true, suffix: "add6" },
-  "6/9": { lower: false, suffix: "69" },
-  sus2: { lower: false, suffix: "sus2" },
-  sus4: { lower: false, suffix: "sus4" },
-  add9: { lower: false, suffix: "add9" },
-  add11: { lower: false, suffix: "add11" },
-  maj9: { lower: false, suffix: "maj9" },
-  min9: { lower: true, suffix: "9" },
-  dom9: { lower: false, suffix: "9" },
-  "7b9": { lower: false, suffix: "7b9" },
-  "7#9": { lower: false, suffix: "7#9" },
-  "7#11": { lower: false, suffix: "7#11" },
-  "7b13": { lower: false, suffix: "7b13" },
-  "11": { lower: false, suffix: "11" },
-  "13": { lower: false, suffix: "13" },
-  "5": { lower: false, suffix: "5" }
-};
-var SUFFIX_QUALITY = new Map(
-  Object.entries(ROMAN_STYLE).map(
-    ([quality, style]) => [`${style.lower ? "l" : "u"}:${style.suffix}`, quality]
-  )
-);
-function parseInversion(figures) {
-  if (figures === "65") {
-    return { inversion: 1, seventh: true };
-  }
-  if (figures === "43") {
-    return { inversion: 2, seventh: true };
-  }
-  if (figures === "42" || figures === "2") {
-    return { inversion: 3, seventh: true };
-  }
-  if (figures === "7") {
-    return { inversion: 0, seventh: true };
-  }
-  if (figures === "64") {
-    return { inversion: 2, seventh: false };
-  }
-  if (figures === "6") {
-    return { inversion: 1, seventh: false };
-  }
-  return { inversion: 0, seventh: false };
-}
-function parseSimpleRoman(text, key) {
-  const match = /^([b#]?)([iIvV]+)(.*)$/.exec(text.trim());
-  if (!match) {
-    throw new Error(`Invalid Roman numeral: ${text}`);
-  }
-  const accidental = match[1] === "b" ? -1 : match[1] === "#" ? 1 : 0;
-  const glyph = (match[2] ?? "").toUpperCase();
-  const degreeNumber = ROMAN_TO_DEGREE[glyph];
-  if (degreeNumber === void 0) {
-    throw new Error(`Invalid Roman numeral: ${text}`);
-  }
-  const isUpper = (match[2] ?? "")[0] === (match[2] ?? "")[0]?.toUpperCase();
-  const suffix = match[3] ?? "";
-  const rootPc = mod12(degreeRootPc(degreeNumber, key) + accidental);
-  const canonical = SUFFIX_QUALITY.get(`${isUpper ? "u" : "l"}:${suffix}`);
-  if (canonical !== void 0) {
-    return { rootPc, quality: canonical, inversion: 0 };
-  }
-  const parsedSuffix = /^(o|°|dim|ø|\+|aug)?(maj7|M7)?(65|64|43|42|7|6|2)?$/.exec(suffix);
-  if (!parsedSuffix) {
-    throw new Error(`Unsupported suffix "${suffix}" in Roman numeral: ${text}`);
-  }
-  const qualityMarker = parsedSuffix[1] ?? "";
-  const isDim = qualityMarker === "o" || qualityMarker === "\xB0" || qualityMarker === "dim";
-  const isAug = qualityMarker === "+" || qualityMarker === "aug";
-  const isHalfDim = qualityMarker === "\xF8";
-  const explicitMaj7 = parsedSuffix[2] !== void 0;
-  const figures = parsedSuffix[3] ?? "";
-  if (figures !== "" && !INVERSION_FIGURES.has(figures)) {
-    throw new Error(`Unsupported figured-bass or extension "${figures}" in Roman numeral: ${text}`);
-  }
-  const { inversion, seventh } = parseInversion(figures);
-  const hasSeventh = explicitMaj7 || seventh || isHalfDim;
-  let base;
-  if (isDim || isHalfDim) {
-    base = "dim";
-  } else if (isAug) {
-    base = "aug";
-  } else {
-    base = isUpper ? "maj" : "min";
-  }
-  let quality;
-  if (explicitMaj7) {
-    quality = base === "min" ? "minMaj7" : base === "aug" ? "augMaj7" : "maj7";
-  } else if (hasSeventh) {
-    quality = seventhQuality(base, isHalfDim);
-  } else if (base === "dim") {
-    quality = "dim";
-  } else if (base === "aug") {
-    quality = "aug";
-  } else {
-    quality = base;
-  }
-  return { rootPc, quality, inversion };
-}
-function chordFromParsed(parsed) {
-  const chord = makeChord(parsed.rootPc, parsed.quality);
-  if (parsed.inversion > 0 && parsed.inversion < chord.intervals.length) {
-    chord.bassPc = mod12(parsed.rootPc + (chord.intervals[parsed.inversion] ?? 0));
-  }
-  return chord;
-}
-function romanToChord(text, key) {
-  const trimmed = text.trim();
-  const slash = trimmed.indexOf("/");
-  if (slash >= 0) {
-    const applied = trimmed.slice(0, slash);
-    const target = trimmed.slice(slash + 1);
-    const targetRoot = parseSimpleRoman(target, key).rootPc;
-    const localKey = majorKey(targetRoot);
-    return chordFromParsed(parseSimpleRoman(applied, localKey));
-  }
-  return chordFromParsed(parseSimpleRoman(trimmed, key));
-}
-function romanStyle(quality) {
-  return ROMAN_STYLE[quality];
-}
-function romanSpelling(rootPc, key) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const diatonic = tones.indexOf(mod12(rootPc));
-  if (diatonic >= 0) {
-    return { degreeNumber: diatonic + 1, accidental: "" };
-  }
-  for (let i = 0; i < tones.length; i += 1) {
-    const degreeNumber2 = i + 1;
-    if (degreeNumber2 === 1 || degreeNumber2 === 5) {
-      continue;
-    }
-    if (mod12((tones[i] ?? 0) - 1) === mod12(rootPc)) {
-      return { degreeNumber: degreeNumber2, accidental: "b" };
-    }
-  }
-  for (let i = 0; i < tones.length; i += 1) {
-    if (mod12((tones[i] ?? 0) + 1) === mod12(rootPc)) {
-      return { degreeNumber: i + 1, accidental: "#" };
-    }
-  }
-  const [degreeNumber, accidental] = OFFSET_SPELLING[mod12(rootPc - key.rootPc)] ?? [1, ""];
-  return { degreeNumber, accidental };
-}
-function baseMarker(quality) {
-  if (quality === "dim" || quality === "dim7") {
-    return "o";
-  }
-  if (quality === "m7b5") {
-    return "\xF8";
-  }
-  if (quality === "aug" || quality === "aug7") {
-    return "+";
-  }
-  if (quality === "augMaj7") {
-    return "+maj7";
-  }
-  if (quality === "maj7" || quality === "minMaj7") {
-    return "maj7";
-  }
-  return "";
-}
-var TRIAD_FIGURES = { 1: "6", 2: "64" };
-var SEVENTH_FIGURES = { 1: "65", 2: "43", 3: "42" };
-var TRIAD_FIGURE_QUALITIES = /* @__PURE__ */ new Set(["maj", "min", "dim", "aug"]);
-var SEVENTH_FIGURE_QUALITIES = /* @__PURE__ */ new Set([
-  "maj7",
-  "min7",
-  "dom7",
-  "dim7",
-  "m7b5",
-  "minMaj7",
-  "aug7",
-  "augMaj7"
-]);
-function chordToRoman(chord, key) {
-  const { degreeNumber, accidental } = romanSpelling(chord.rootPc, key);
-  const { lower, suffix } = romanStyle(chord.quality);
-  const numeral = ROMAN[degreeNumber - 1] ?? "I";
-  const cased = lower ? numeral.toLowerCase() : numeral;
-  let inversion = 0;
-  if (chord.bassPc !== void 0) {
-    const idx = chord.intervals.findIndex((iv) => mod12(chord.rootPc + iv) === chord.bassPc);
-    if (idx > 0) {
-      inversion = idx;
-    }
-  }
-  if (inversion > 0) {
-    const figure = SEVENTH_FIGURE_QUALITIES.has(chord.quality) ? SEVENTH_FIGURES[inversion] : TRIAD_FIGURE_QUALITIES.has(chord.quality) ? TRIAD_FIGURES[inversion] : void 0;
-    if (figure !== void 0) {
-      return `${accidental}${cased}${baseMarker(chord.quality)}${figure}`;
-    }
-  }
-  return `${accidental}${cased}${suffix}`;
-}
 
-// src/analyze/functional/function.ts
-var FUNCTION_BY_OFFSET = [
-  "tonic",
-  // 0  I
-  "subdominant",
-  // 1  bII (Neapolitan)
-  "subdominant",
-  // 2  ii
-  "tonic",
-  // 3  bIII
-  "tonic",
-  // 4  iii
-  "subdominant",
-  // 5  IV
-  "dominant",
-  // 6  #IV / bV
-  "dominant",
-  // 7  V
-  "subdominant",
-  // 8  bVI
-  "tonic",
-  // 9  vi
-  "subdominant",
-  // 10 bVII
-  "dominant"
-  // 11 vii
-];
-function isMinorKey(key) {
-  const hasMinorThird = key.modeMask12 >> 3 & 1;
-  const hasMajorThird2 = key.modeMask12 >> 4 & 1;
-  return Boolean(hasMinorThird) && !hasMajorThird2;
-}
-function functionOf(chord, key) {
-  return FUNCTION_BY_OFFSET[mod12(chord.rootPc - key.rootPc)] ?? "tonic";
-}
-function isDiatonic(chord, key) {
-  return chordPitchClasses(chord).every((pc) => isScaleTone(pc, key));
-}
-function parallelKey(key) {
-  return {
-    rootPc: mod12(key.rootPc),
-    modeMask12: isMinorKey(key) ? MAJOR_MASK : NATURAL_MINOR_MASK
-  };
-}
-function isDiminishedQuality(quality) {
-  return quality === "dim" || quality === "dim7" || quality === "m7b5";
-}
-function hasMajorThird(chord) {
-  return chord.intervals.some((interval) => mod12(interval) === 4);
-}
-function qualityAwareFunction(chord, key) {
-  const offset = mod12(chord.rootPc - key.rootPc);
-  if (isDiminishedQuality(chord.quality) && (offset === 11 || offset === 6)) {
-    return "dominant";
-  }
-  if (isNeapolitan(chord, key)) {
-    return "subdominant";
-  }
-  if (!isMinorKey(key) && hasMajorThird(chord) && (offset === 8 || offset === 10)) {
-    return "subdominant";
-  }
-  return functionOf(chord, key);
-}
-function analyzeChord(chord, key) {
-  const source = borrowedSource(chord, key);
-  return {
-    function: qualityAwareFunction(chord, key),
-    borrowed: source !== null,
-    source,
-    roman: chordToRoman(chord, key)
-  };
-}
 
-// src/analyze/functional/borrowed.ts
-function isHarmonicMinorAlteration(chord, key) {
-  return isMinorKey(key) && isDiatonic(chord, { rootPc: mod12(key.rootPc), modeMask12: HARMONIC_MINOR_MASK });
-}
-function isBorrowedChord(chord, key) {
-  if (isDiatonic(chord, key)) {
-    return false;
-  }
-  if (isHarmonicMinorAlteration(chord, key)) {
-    return false;
-  }
-  return isDiatonic(chord, parallelKey(key));
-}
-function borrowedSource(chord, key) {
-  if (isDiatonic(chord, key)) {
-    return null;
-  }
-  if (isNeapolitan(chord, key)) {
-    return "neapolitan";
-  }
-  if (isBorrowedChord(chord, key)) {
-    return isMinorKey(key) ? "parallel-major" : "parallel-minor";
-  }
-  return null;
-}
-
-// src/analyze/functional/cadence.ts
-function detectCadence(from, to, key) {
-  const tonic = mod12(key.rootPc);
-  const fromOffset = mod12(from.rootPc - tonic);
-  const toOffset = mod12(to.rootPc - tonic);
-  const deceptiveTargets = isMinorKey(key) ? [8] : [8, 9];
-  if (fromOffset === 7 && toOffset === 0) {
-    return "authentic";
-  }
-  if (fromOffset === 5 && toOffset === 0) {
-    return "plagal";
-  }
-  if (fromOffset === 7 && deceptiveTargets.includes(toOffset)) {
-    return "deceptive";
-  }
-  if (toOffset === 7 && fromOffset !== 7) {
-    return "half";
-  }
-  return null;
-}
-
-// src/generate/reharmony/index.ts
-function mod122(n) {
-  return (n % 12 + 12) % 12;
-}
-function negativeHarmonyMirror(chord, key) {
-  const tonic = mod122(key.rootPc);
-  const mirror = (p) => mod122(2 * tonic + 7 - p);
-  const pcs = chordPitchClasses(chord).map(mirror);
-  const bassPc = chord.bassPc !== void 0 ? mirror(chord.bassPc) : void 0;
-  const pitches = bassPc !== void 0 ? [bassPc - 12, ...pcs] : pcs;
-  const detected = detectChordBest(pitches);
-  if (detected) {
-    if (bassPc === void 0 && detected.bassPc !== void 0) {
-      return makeChord(detected.rootPc, detected.quality);
-    }
-    return detected;
-  }
-  const quality = chord.quality;
-  return makeChord(mirror(chord.rootPc), quality, bassPc);
-}
-
-// src/theory/chordscale/index.ts
-function pitchClass4(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 = pitchClass4(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 = pitchClass4(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 = pitchClass4(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(pitchClass4(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 = pitchClass4(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);
-}
-
-// 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 mod123(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 mod123(natural + note.alter);
-}
-function noteToMidi(note) {
-  if (note.octave === void 0) {
-    throw new Error("noteToMidi requires an octave");
-  }
-  const natural = LETTER_SEMITONES[mod7(note.letter)] ?? 0;
-  return (note.octave + 1) * 12 + 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 = mod123(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 };
-}
-var SIMPLE_REFERENCE = [0, 0, 2, 4, 5, 7, 9, 11];
-function isPerfectNumber(simpleNumber) {
-  return simpleNumber === 1 || simpleNumber === 4 || simpleNumber === 5;
-}
-function qualityFromSpan(numberValue, semitones) {
-  const octaves = Math.floor((numberValue - 1) / 7);
-  const simple = numberValue - 7 * octaves;
-  const reference = (SIMPLE_REFERENCE[simple] ?? 0) + 12 * octaves;
-  const delta = semitones - reference;
-  if (isPerfectNumber(simple)) {
-    if (delta === 0) {
-      return "P";
-    }
-    return delta > 0 ? "A".repeat(delta) : "d".repeat(-delta);
-  }
-  if (delta === 0) {
-    return "M";
-  }
-  if (delta === -1) {
-    return "m";
-  }
-  return delta > 0 ? "A".repeat(delta) : "d".repeat(-delta - 1);
-}
-function diatonicIndex(note) {
-  return mod7(note.letter) + 7 * (note.octave ?? 0);
-}
-function spelledInterval(a, b) {
-  const octaved = a.octave !== void 0 && b.octave !== void 0;
-  let letterSteps;
-  let semitones;
-  if (octaved) {
-    letterSteps = diatonicIndex(b) - diatonicIndex(a);
-    semitones = noteToMidi(b) - noteToMidi(a);
-  } else {
-    letterSteps = mod7(b.letter - a.letter);
-    let rawSemis = mod123(noteToPitchClass(b) - noteToPitchClass(a));
-    const reference = SIMPLE_REFERENCE[letterSteps + 1] ?? 0;
-    if (reference - rawSemis > 6) {
-      rawSemis += 12;
-    } else if (rawSemis - reference > 6) {
-      rawSemis -= 12;
-    }
-    semitones = rawSemis;
-  }
-  const absSteps = Math.abs(letterSteps);
-  const number = absSteps + 1;
-  const quality = qualityFromSpan(number, Math.abs(semitones));
-  return { number, quality, semitones };
-}
-
-// 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 mod124(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 = mod124(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 = mod124(naturalPc(tonic.letter) + tonic.alter);
-  const offset = mod124(pc - tonicPc);
-  const tones = scaleTonesInDegreeOrder(key);
-  if (isHeptatonic(key)) {
-    const degree = tones.indexOf(mod124(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) === mod124(pc)) {
-      return { letter, alter: 0 };
-    }
-  }
-  const belowLetter = mod72([0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6][mod124(pc)] ?? 0);
-  return { letter: belowLetter, alter: alterFor(belowLetter, pc) };
-}
-function spellScale(tonic, key) {
-  return scaleTonesInDegreeOrder(key).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 = mod124(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 = mod124(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);
-}
-
-// 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 pitchClass5(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 = pitchClass5(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 && pitchClass5(chord.bassPc) !== rootPc) {
-    symbol += `/${pitchClassName(pitchClass5(chord.bassPc), chord.bassSpelling, opts?.flats)}`;
-  }
-  return symbol;
-}
-
-// src/theory/counterpoint/index.ts
-function createsVoiceCrossing(upperPitch, lowerPitch) {
-  return upperPitch < lowerPitch;
-}
-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 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;
-}
-
-// 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 pitchClass6(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 (pitchClass6(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 = pitchClass6(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 = pitchClass6(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 = pitchClass6(chord.rootPc);
-  const fifthPc = pitchClass6(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;
-}
-
-// 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 - pitchClass6(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 = pitchClass6(chord.rootPc);
-  const bassPc = pitchClass6(chord.bassPc ?? chord.rootPc);
-  const omitRoot = style === "rootless" || opts?.rootless === true;
-  let order = dedupePcs(chord.intervals.map((interval) => pitchClass6(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(pitchClass6(opts.topNote)) ? pitchClass6(opts.topNote) : nearestPc(pitchClass6(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 - pitchClass6(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) => pitchClass6(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);
-}
-
-// src/model/shared.ts
-function mod125(n) {
-  return (n % 12 + 12) % 12;
-}
-function spellPitchClassBare(pc, spelling) {
-  const spelled = midiToNote(60 + mod125(pc), spelling);
-  return { letter: spelled.letter, alter: spelled.alter };
-}
-
-// src/model/note.ts
-function copyNote(data) {
-  const copy = { letter: data.letter, alter: data.alter };
-  if (data.octave !== void 0) {
-    copy.octave = data.octave;
-  }
-  return copy;
-}
-var Note = class _Note {
-  #data;
-  /**
-   * Wrap a plain note object.
-   *
-   * @param data The spelled note; it is copied, never retained or mutated.
-   */
-  constructor(data) {
-    this.#data = copyNote(data);
-  }
-  /**
-   * Parse scientific pitch notation (e.g. `'C#4'`, `'Bb'`, `'F##3'`).
-   *
-   * @param name The note text.
-   * @returns The parsed note.
-   * @throws If the text is not a valid note.
-   */
-  static of(name) {
-    return new _Note(parseNote(name));
-  }
-  /**
-   * Name a MIDI number (middle C = C4 = 60) as a note.
-   *
-   * @param midi The MIDI number.
-   * @param spelling Whether to prefer sharps or flats for black keys.
-   * @returns The spelled note, with octave.
-   */
-  static fromMidi(midi, spelling = "sharp") {
-    return new _Note(midiToNote(midi, spelling));
-  }
-  /**
-   * Wrap an existing plain note object.
-   *
-   * @param data The plain note.
-   * @returns The wrapped note.
-   */
-  static fromData(data) {
-    return new _Note(data);
-  }
-  /** The note rendered as scientific pitch notation, e.g. `'G4'` or `'Bb'`. */
-  get name() {
-    return formatNote(this.#data);
-  }
-  /** The pitch class (0..11), ignoring octave. */
-  get pitchClass() {
-    return noteToPitchClass(this.#data);
-  }
-  /**
-   * The MIDI number (middle C = C4 = 60).
-   *
-   * @throws If the note has no octave and therefore no fixed pitch.
-   */
-  get midi() {
-    if (this.#data.octave === void 0) {
-      throw new Error(`note ${this.name} has no octave, so it has no MIDI number`);
-    }
-    return noteToMidi(this.#data);
-  }
-  /** The diatonic letter number: 0..6 for C..B. */
-  get letter() {
-    return this.#data.letter;
-  }
-  /** The chromatic alteration in semitones: -1 flat, 0 natural, +1 sharp, ... */
-  get alter() {
-    return this.#data.alter;
-  }
-  /** The octave (scientific pitch notation), or undefined for a bare pitch class. */
-  get octave() {
-    return this.#data.octave;
-  }
-  /** A copy of the underlying plain note object. */
-  get data() {
-    return copyNote(this.#data);
-  }
-  /**
-   * Transpose by a signed number of semitones.
-   *
-   * When the note carries an octave the transposition happens in MIDI space and
-   * the result is spelled with a sharp preference. An octave-less note stays
-   * octave-less: only its pitch class is moved. Transposing by zero is the
-   * identity: the original spelling is preserved (no enharmonic respelling).
-   *
-   * @param semitones The signed semitone offset.
-   * @returns The transposed note.
-   */
-  transpose(semitones) {
-    if (semitones === 0) {
-      return new _Note(this.#data);
-    }
-    if (this.#data.octave !== void 0) {
-      return _Note.fromMidi(this.midi + semitones);
-    }
-    return new _Note(spellPitchClassBare(this.pitchClass + semitones, "sharp"));
-  }
-  /**
-   * The spelled interval from this note to another.
-   *
-   * @param other The second note.
-   * @returns The diatonic number, quality, and semitone span.
-   */
-  intervalTo(other) {
-    return spelledInterval(this.#data, other.#data);
-  }
-  /**
-   * Whether another note has the same letter, alteration, and octave.
-   *
-   * @param other The note to compare.
-   * @returns True if the spellings are identical.
-   */
-  equals(other) {
-    return this.#data.letter === other.#data.letter && this.#data.alter === other.#data.alter && this.#data.octave === other.#data.octave;
-  }
-  /**
-   * The plain note data, for JSON serialization.
-   *
-   * Private class fields do not serialize, so an explicit `toJSON` keeps
-   * `JSON.stringify(note)` from collapsing to `{}`.
-   *
-   * @returns A copy of the underlying plain note object.
-   */
-  toJSON() {
-    return this.data;
-  }
-};
-
-// src/model/progression.ts
-var Progression = class _Progression {
-  #chords;
-  #key;
-  /**
-   * Wrap a chord sequence.
-   *
-   * @param chords The chords in order; the array is copied.
-   * @param key Optional key context for analysis methods.
-   */
-  constructor(chords, key) {
-    this.#chords = [...chords];
-    this.#key = key;
-  }
-  /** A copy of the chord sequence. */
-  get chords() {
-    return [...this.#chords];
-  }
-  /** The carried key context, if any. */
-  get key() {
-    return this.#key;
-  }
-  /** The number of chords. */
-  get length() {
-    return this.#chords.length;
-  }
-  /**
-   * A copy of this progression with a chord appended.
-   *
-   * @param chord The chord to append.
-   * @returns The new progression.
-   */
-  add(chord) {
-    return new _Progression([...this.#chords, chord], this.#key);
-  }
-  /**
-   * A copy of this progression carrying the given key context.
-   *
-   * @param key The key context to attach.
-   * @returns The new progression.
-   */
-  withKey(key) {
-    return new _Progression(this.#chords, key);
-  }
-  /**
-   * Voice the progression with smooth voice leading.
-   *
-   * @param opts Voicing options; defaults to four SATB voices.
-   * @returns One ascending voicing (MIDI pitches) per chord.
-   * @throws If any chord admits no voicing within the given ranges.
-   */
-  voice(opts) {
-    return voiceProgression(
-      this.#chords.map((chord) => chord.data),
-      opts
-    );
-  }
-  /**
-   * The Roman numeral of each chord in a key.
-   *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns One numeral per chord.
-   * @throws If no key is given and none is carried.
-   */
-  roman(key) {
-    const resolved = this.#resolveKey(key);
-    return this.#chords.map((chord) => chord.roman(resolved));
-  }
-  /**
-   * The harmonic function of each chord in a key.
-   *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns One function per chord.
-   * @throws If no key is given and none is carried.
-   */
-  functions(key) {
-    const resolved = this.#resolveKey(key);
-    return this.#chords.map((chord) => chord.function(resolved));
-  }
-  /**
-   * Analyze every chord and classify the closing cadence.
-   *
-   * The cadence is detected on the final chord pair and is null when the
-   * progression has fewer than two chords.
-   *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns Per-chord analyses and the closing cadence.
-   * @throws If no key is given and none is carried.
-   */
-  analyze(key) {
-    const resolved = this.#resolveKey(key);
-    const chords = this.#chords.map((chord) => chord.analyze(resolved));
-    const from = this.#chords[this.#chords.length - 2];
-    const to = this.#chords[this.#chords.length - 1];
-    const cadence = from !== void 0 && to !== void 0 ? detectCadence(from.data, to.data, resolved.scale) : null;
-    return { chords, cadence };
-  }
-  /**
-   * The plain progression data, for JSON serialization.
-   *
-   * Private class fields do not serialize, so an explicit `toJSON` keeps
-   * `JSON.stringify(progression)` from collapsing to `{}`. The chords are
-   * emitted as plain data and the carried key, when present, as its own data.
-   *
-   * @returns The chord data sequence and the carried key, if any.
-   */
-  toJSON() {
-    return {
-      chords: this.#chords.map((chord) => chord.data),
-      key: this.#key?.toJSON()
-    };
-  }
-  /** Resolve the key for an analysis method: explicit first, then carried. */
-  #resolveKey(key) {
-    const resolved = key ?? this.#key;
-    if (resolved === void 0) {
-      throw new Error("progression has no key context; pass a Key or attach one with withKey()");
-    }
-    return resolved;
-  }
-};
-
-// src/model/chord.ts
-function copyChord(data) {
-  const copy = {
-    rootPc: data.rootPc,
-    quality: data.quality,
-    intervals: [...data.intervals]
-  };
-  if (data.bassPc !== void 0) {
-    copy.bassPc = data.bassPc;
-  }
-  if (data.rootSpelling !== void 0) {
-    copy.rootSpelling = { letter: data.rootSpelling.letter, alter: data.rootSpelling.alter };
-  }
-  if (data.bassSpelling !== void 0) {
-    copy.bassSpelling = { letter: data.bassSpelling.letter, alter: data.bassSpelling.alter };
-  }
-  return copy;
-}
-var Chord = class _Chord {
-  #data;
-  #key;
-  /**
-   * Wrap a plain chord object.
-   *
-   * @param data The chord; it is copied, never retained or mutated.
-   * @param key Optional key context for analysis methods.
-   */
-  constructor(data, key) {
-    const copy = copyChord(data);
-    if (copy.rootSpelling === void 0 && key !== void 0) {
-      copy.rootSpelling = spellPitchClass(copy.rootPc, key.tonic.data, key.scale);
-    }
-    this.#data = copy;
-    this.#key = key;
-  }
-  /**
-   * Build a chord from a root and quality.
-   *
-   * @param root Root as a note name (e.g. `'Eb'`) or a pitch class.
-   * @param quality The chord quality.
-   * @param bass Optional slash-chord bass pitch class.
-   * @returns The chord (without key context).
-   */
-  static of(root, quality, bass) {
-    if (typeof root === "string") {
-      const rootNote = Note.of(root);
-      const data = makeChord(rootNote.pitchClass, quality, bass);
-      data.rootSpelling = { letter: rootNote.letter, alter: rootNote.alter };
-      return new _Chord(data);
-    }
-    return new _Chord(makeChord(root, quality, bass));
-  }
-  /**
-   * Wrap an existing plain chord object.
-   *
-   * @param data The plain chord.
-   * @returns The wrapped chord (without key context).
-   */
-  static from(data) {
-    return new _Chord(data);
-  }
-  /**
-   * Parse a lead-sheet chord symbol (e.g. `'Cmaj7'`, `'F#m7b5'`, `'C/G'`).
-   *
-   * @param symbol The chord symbol.
-   * @returns The chord (without key context).
-   * @throws If the root or quality is not recognized.
-   */
-  static parse(symbol) {
-    return new _Chord(parseChordSymbol(symbol));
-  }
-  /**
-   * Identify the chords matching a set of pitches, best interpretation first.
-   *
-   * @param pitches MIDI pitches or bare pitch classes.
-   * @returns Ranked chord interpretations (may be empty).
-   */
-  static detect(pitches, opts) {
-    return detectChord(pitches, opts).map(
-      (match) => new _Chord(makeChord(match.rootPc, match.quality, match.bassPc))
-    );
-  }
-  /**
-   * The single best chord interpretation of a pitch set.
-   *
-   * @param pitches MIDI pitches or bare pitch classes.
-   * @returns The top-ranked chord, or null when nothing matches.
-   */
-  static detectBest(pitches, opts) {
-    const best = detectChordBest(pitches, opts);
-    return best === null ? null : new _Chord(best);
-  }
-  /** The root pitch class (0..11). */
-  get rootPc() {
-    return this.#data.rootPc;
-  }
-  /** The chord quality. */
-  get quality() {
-    return this.#data.quality;
-  }
-  /** A copy of the semitone offsets above the root. */
-  get intervals() {
-    return [...this.#data.intervals];
-  }
-  /** The slash-chord bass pitch class, or undefined in root position. */
-  get bassPc() {
-    return this.#data.bassPc;
-  }
-  /** A copy of the underlying plain chord object. */
-  get data() {
-    return copyChord(this.#data);
-  }
-  /** The carried key context, if any. */
-  get key() {
-    return this.#key;
-  }
-  /**
-   * A copy of this chord carrying the given key context.
-   *
-   * @param key The key context to attach.
-   * @returns The new chord.
-   */
-  withKey(key) {
-    return new _Chord(this.#data, key);
-  }
-  /**
-   * The chord's sorted, deduplicated pitch classes.
-   *
-   * @returns Pitch classes ascending in [0, 11].
-   */
-  pitchClasses() {
-    return chordPitchClasses(this.#data);
-  }
-  /**
-   * The chord's Roman numeral in a key.
-   *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns The Roman numeral string.
-   * @throws If no key is given and none is carried.
-   */
-  roman(key) {
-    return chordToRoman(this.#data, this.#resolveKey(key).scale);
-  }
-  /**
-   * The chord's harmonic function (tonic / subdominant / dominant) in a key.
-   *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns The harmonic function.
-   * @throws If no key is given and none is carried.
-   */
-  function(key) {
-    return functionOf(this.#data, this.#resolveKey(key).scale);
-  }
-  /**
-   * Full functional analysis: function, borrowing, and Roman numeral.
-   *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns The chord analysis.
-   * @throws If no key is given and none is carried.
-   */
-  analyze(key) {
-    return analyzeChord(this.#data, this.#resolveKey(key).scale);
-  }
-  /**
-   * Whether the chord is borrowed from the parallel mode (modal interchange).
-   *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns True if the chord is borrowed.
-   * @throws If no key is given and none is carried.
-   */
-  isBorrowed(key) {
-    return isBorrowedChord(this.#data, this.#resolveKey(key).scale);
-  }
-  /**
-   * The origin of a non-diatonic chord (parallel mode or Neapolitan), or null.
-   *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns The borrowing source, or null.
-   * @throws If no key is given and none is carried.
-   */
-  borrowedSource(key) {
-    return borrowedSource(this.#data, this.#resolveKey(key).scale);
-  }
-  /**
-   * The chord rendered as a lead-sheet symbol (e.g. `'Cmaj7'`, `'F#m7'`, `'C/G'`).
-   *
-   * @param opts Set `flats: true` to spell the root/bass with flats.
-   * @returns The chord symbol.
-   */
-  symbol(opts) {
-    return formatChordSymbol(this.#data, opts);
-  }
-  /**
-   * Realize the chord as one MIDI pitch per voice, ascending.
-   *
-   * @param opts Voicing options; defaults to four SATB voices.
-   * @returns MIDI pitches, ascending, one per voice.
-   * @throws If no voicing fits the given ranges.
-   */
-  voice(opts) {
-    return voiceChord(this.#data, opts);
-  }
-  /**
-   * Realize the chord as a single styled voicing (`close`, `drop2`, `drop3`,
-   * `shell`, or `rootless`), optionally constraining the top voice.
-   *
-   * @param opts Styled-voicing options; defaults to a close-position voicing.
-   * @returns MIDI pitches, ascending.
-   */
-  styledVoicing(opts) {
-    return voiceChordStyled(this.#data, opts);
-  }
-  /**
-   * The negative-harmony mirror of the chord about the key's tonic–dominant
-   * axis (major becomes minor and vice versa).
-   *
-   * @param key Key providing the reflection axis; falls back to the carried
-   *   context.
-   * @returns The mirrored chord, keeping any key context.
-   * @throws If no key is given and none is carried.
-   */
-  negativeHarmony(key) {
-    const resolved = this.#resolveKey(key);
-    return new _Chord(negativeHarmonyMirror(this.#data, resolved.scale), key ?? this.#key);
-  }
-  /**
-   * The n-th inversion: a copy whose bass is the chord tone `n` steps above the
-   * root in the interval template (`invert(1)` puts the third in the bass).
-   * `n` wraps around the template length; negative values count backwards.
-   *
-   * `invert(0)` (and any `n` that wraps to it) is root position, so it carries
-   * no slash bass and equals the original chord.
-   *
-   * @param n The inversion number.
-   * @returns The inverted chord, keeping any key context.
-   * @throws If the chord has no intervals.
-   */
-  invert(n) {
-    const intervals = this.#data.intervals;
-    const length = intervals.length;
-    if (length === 0) {
-      throw new Error("cannot invert a chord with no intervals");
-    }
-    const index = (n % length + length) % length;
-    const data = copyChord(this.#data);
-    if (index === 0) {
-      delete data.bassPc;
-      delete data.bassSpelling;
-    } else {
-      data.bassPc = mod125(this.#data.rootPc + (intervals[index] ?? 0));
-      const rootSpelling = data.rootSpelling ?? (this.#key ? spellPitchClass(data.rootPc, this.#key.tonic.data, this.#key.scale) : spellPitchClassBare(data.rootPc, "sharp"));
-      const bassSpelling = spellChordFromRoot(data, rootSpelling)[index];
-      if (bassSpelling !== void 0) {
-        data.bassSpelling = bassSpelling;
-      }
-    }
-    return new _Chord(data, this.#key);
-  }
-  /**
-   * The named scales that fit over this chord, best fit first, rooted on the
-   * chord root.
-   *
-   * @returns The matching scales.
-   */
-  scales() {
-    return chordScales(this.#data);
-  }
-  /**
-   * The available tensions (usable non-chord, non-avoid scale tones) of a
-   * scale over this chord.
-   *
-   * @param scaleName A named scale, rooted on the chord root.
-   * @returns Tension pitch classes, ascending in [0, 11].
-   */
-  tensions(scaleName) {
-    return availableTensions(this.#data, scaleName);
-  }
-  /**
-   * The avoid notes (scale tones a semitone above a chord tone) of a scale
-   * over this chord.
-   *
-   * @param scaleName A named scale, rooted on the chord root.
-   * @returns Avoid-note pitch classes, ascending in [0, 11].
-   */
-  avoidNotes(scaleName) {
-    return avoidNotes(this.#data, scaleName);
-  }
-  /**
-   * Spell the chord tones with letter names, root first, in the key's spelling.
-   *
-   * @param key Key providing the spelled tonic; falls back to the carried
-   *   context.
-   * @returns Spelled octave-less notes in the chord's own (tertian) order.
-   * @throws If no key is given and none is carried.
-   */
-  spell(key) {
-    const resolved = this.#resolveKey(key);
-    return spellChord(this.#data, resolved.tonic.data, resolved.scale).map(
-      (note) => new Note(note)
-    );
-  }
-  /**
-   * Start a progression with this chord followed by others, carrying this
-   * chord's key context (if any).
-   *
-   * @param others The chords following this one.
-   * @returns The progression.
-   */
-  progressionTo(...others) {
-    return new Progression([this, ...others], this.#key);
-  }
-  /**
-   * Whether another chord has the same root, quality, intervals, and bass.
-   * Key context is not compared.
-   *
-   * @param other The chord to compare.
-   * @returns True if the chord data is identical.
-   */
-  equals(other) {
-    const a = this.#data;
-    const b = other.#data;
-    return a.rootPc === b.rootPc && a.quality === b.quality && a.bassPc === b.bassPc && a.intervals.length === b.intervals.length && a.intervals.every((interval, i) => interval === b.intervals[i]);
-  }
-  /**
-   * The plain chord data, for JSON serialization.
-   *
-   * @returns A copy of the underlying plain chord object.
-   */
-  toJSON() {
-    return this.data;
-  }
-  /** Resolve the key for an analysis method: explicit first, then carried. */
-  #resolveKey(key) {
-    const resolved = key ?? this.#key;
-    if (resolved === void 0) {
-      throw new Error("chord has no key context; pass a Key or attach one with withKey()");
-    }
-    return resolved;
-  }
-};
-
-// src/model/interval.ts
-var Interval = class _Interval {
-  #number;
-  #quality;
-  #semitones;
-  constructor(numberValue, quality, semitones) {
-    this.#number = numberValue;
-    this.#quality = quality;
-    this.#semitones = semitones;
-  }
-  /**
-   * The spelled interval between two notes.
-   *
-   * @param a The first note.
-   * @param b The second note.
-   * @returns The interval from `a` to `b`.
-   */
-  static between(a, b) {
-    const spelled = a.intervalTo(b);
-    return new _Interval(spelled.number, spelled.quality, spelled.semitones);
-  }
-  /**
-   * Build an interval from explicit components.
-   *
-   * @param numberValue Diatonic size: 1 = unison, 2 = second, ... 8 = octave.
-   * @param quality Quality label: `'P'`, `'M'`, `'m'`, or repeated `'A'`/`'d'`.
-   * @param semitones Signed semitone span.
-   * @returns The interval.
-   */
-  static of(numberValue, quality, semitones) {
-    return new _Interval(numberValue, quality, semitones);
-  }
-  /** Diatonic size: 1 = unison, 2 = second, ... 8 = octave, and beyond. */
-  get number() {
-    return this.#number;
-  }
-  /** Quality label: `'P'`, `'M'`, `'m'`, or repeated `'A'`/`'d'`. */
-  get quality() {
-    return this.#quality;
-  }
-  /** Signed semitone span. */
-  get semitones() {
-    return this.#semitones;
-  }
-  /** A readable label composed of quality and number, e.g. `'P5'` or `'M3'`. */
-  get name() {
-    return `${this.#quality}${this.#number}`;
-  }
-  /**
-   * The plain interval data, for JSON serialization.
-   *
-   * Private class fields do not serialize, so an explicit `toJSON` keeps
-   * `JSON.stringify(interval)` from collapsing to `{}`.
-   *
-   * @returns The diatonic number, quality, and semitone span.
-   */
-  toJSON() {
-    return { number: this.#number, quality: this.#quality, semitones: this.#semitones };
-  }
-};
-
-// src/model/key.ts
-function resolveTonic(root, spelling) {
-  return typeof root === "string" ? Note.of(root) : new Note(spellPitchClassBare(root, spelling));
-}
-function accidentalLoad(tonic, scale) {
-  return spellScale(tonic, scale).reduce((sum, note) => sum + Math.abs(note.alter), 0);
-}
-function bestTonicForScale(rootPc, scale) {
-  const sharp = spellPitchClassBare(rootPc, "sharp");
-  const flat = spellPitchClassBare(rootPc, "flat");
-  if (sharp.letter === flat.letter && sharp.alter === flat.alter) {
-    return new Note(sharp);
-  }
-  return accidentalLoad(flat, scale) <= accidentalLoad(sharp, scale) ? new Note(flat) : new Note(sharp);
-}
-var Key = class _Key {
-  #scale;
-  #tonic;
-  /**
-   * Wrap a key/scale and its spelled tonic.
-   *
-   * @param scale The key/scale; its root is normalized to a pitch class.
-   * @param tonic The spelled tonic anchoring letter-name spelling.
-   */
-  constructor(scale, tonic) {
-    this.#scale = { rootPc: mod125(scale.rootPc), modeMask12: scale.modeMask12 };
-    this.#tonic = tonic;
-  }
-  /**
-   * A major key.
-   *
-   * @param root Tonic as a note name (e.g. `'Eb'`) or a pitch class; a numeric
-   *   root is spelled with whichever accidental side yields the fewest
-   *   accidentals across the scale.
-   * @returns The major key.
-   */
-  static major(root) {
-    if (typeof root === "string") {
-      const tonic = Note.of(root);
-      return new _Key(majorKey(tonic.pitchClass), tonic);
-    }
-    const scale = majorKey(root);
-    return new _Key(scale, bestTonicForScale(root, scale));
-  }
-  /**
-   * A natural-minor key.
-   *
-   * @param root Tonic as a note name or a pitch class; a numeric root is
-   *   spelled with whichever accidental side yields the fewest accidentals
-   *   across the scale.
-   * @returns The minor key.
-   */
-  static minor(root) {
-    if (typeof root === "string") {
-      const tonic = Note.of(root);
-      return new _Key(minorKey(tonic.pitchClass), tonic);
-    }
-    const scale = minorKey(root);
-    return new _Key(scale, bestTonicForScale(root, scale));
-  }
-  /**
-   * A key on a named scale (e.g. `'dorian'`, `'harmonicMinor'`).
-   *
-   * @param name The scale name, a key of the scale module's named-scale table.
-   * @param root Tonic as a note name or a pitch class.
-   * @returns The key.
-   * @throws If the name is not a known scale.
-   */
-  static named(name, root) {
-    const tonic = resolveTonic(root, "sharp");
-    return new _Key(scaleByName(name, tonic.pitchClass), tonic);
-  }
-  /**
-   * Wrap an existing `KeyScale`, synthesizing a spelled tonic when none is
-   * given (flat-preferred for minor-third scales, sharp-preferred otherwise).
-   *
-   * @param scale The key/scale to wrap.
-   * @param tonic Optional spelled tonic.
-   * @returns The key.
-   */
-  static of(scale, tonic) {
-    const spelled = tonic ?? new Note(spellPitchClassBare(scale.rootPc, isMinorKey(scale) ? "flat" : "sharp"));
-    return new _Key(scale, spelled);
-  }
-  /** A copy of the underlying plain `KeyScale`. */
-  get scale() {
-    return { rootPc: this.#scale.rootPc, modeMask12: this.#scale.modeMask12 };
-  }
-  /** The spelled tonic. */
-  get tonic() {
-    return this.#tonic;
-  }
-  /** The tonic pitch class (0..11). */
-  get rootPc() {
-    return this.#scale.rootPc;
-  }
-  /** Whether the scale has a minor third and no major third. */
-  get isMinor() {
-    return isMinorKey(this.#scale);
-  }
-  /**
-   * The scale's pitch classes in ascending scale-degree order (degree 0 first).
-   *
-   * @returns One pitch class per scale degree.
-   */
-  pitchClasses() {
-    return scaleTonesInDegreeOrder(this.#scale);
-  }
-  /**
-   * The spelled scale, one note per degree (e.g. C D E F G A B for C major).
-   *
-   * @returns Spelled octave-less notes in scale-degree order.
-   */
-  notes() {
-    return spellScale(this.#tonic.data, this.#scale).map((note) => new Note(note));
-  }
-  /**
-   * Alias of {@link Key.notes}.
-   *
-   * @returns Spelled octave-less notes in scale-degree order.
-   */
-  spell() {
-    return this.notes();
-  }
-  /**
-   * The spelled scale as letter-name strings.
-   *
-   * @returns One name per scale degree.
-   */
-  noteNames() {
-    return this.notes().map((note) => note.name);
-  }
-  /**
-   * Build a chord on a scale degree, carrying this key as context.
-   *
-   * With an explicit quality the quality's interval template is attached to the
-   * degree's diatonic root; without one the scale-correct diatonic triad is
-   * stacked (e.g. a diminished triad on the leading tone of a major key).
-   *
-   * @param degree 0-based scale degree of the chord root.
-   * @param quality Optional chord quality.
-   * @returns The chord, with this key attached.
-   */
-  chord(degree, quality) {
-    const data = quality === void 0 ? diatonicTriad(degree, this.#scale) : chordFromDegree(degree, quality, this.#scale);
-    return new Chord(data, this);
-  }
-  /**
-   * The diatonic triad on a scale degree, carrying this key as context.
-   *
-   * @param degree 0-based scale degree of the chord root.
-   * @returns The triad, with this key attached.
-   */
-  diatonicTriad(degree) {
-    return new Chord(diatonicTriad(degree, this.#scale), this);
-  }
-  /**
-   * The diatonic seventh chord on a scale degree, carrying this key as context.
-   *
-   * @param degree 0-based scale degree of the chord root.
-   * @returns The seventh chord, with this key attached.
-   */
-  diatonicSeventh(degree) {
-    return new Chord(diatonicSeventh(degree, this.#scale), this);
-  }
-  /**
-   * Build the chord denoted by a Roman numeral in this key (including applied
-   * chords such as `'V7/V'`), carrying this key as context.
-   *
-   * @param text The Roman numeral.
-   * @returns The chord, with this key attached.
-   * @throws If the numeral is not valid.
-   */
-  roman(text) {
-    return new Chord(romanToChord(text, this.#scale), this);
-  }
-  /**
-   * Whether a pitch belongs to the scale.
-   *
-   * @param x A MIDI pitch, bare pitch class, or note.
-   * @returns True if the pitch class is a scale tone.
-   */
-  contains(x) {
-    return isScaleTone(typeof x === "number" ? x : x.pitchClass, this.#scale);
-  }
-  /**
-   * The plain key data, for JSON serialization.
-   *
-   * Private class fields do not serialize, so an explicit `toJSON` keeps
-   * `JSON.stringify(key)` from collapsing to `{}`. The result pairs the
-   * `KeyScale` with the spelled tonic, enough to reconstruct the key via
-   * {@link Key.of}.
-   *
-   * @returns The key/scale and its spelled tonic.
-   */
-  toJSON() {
-    return { scale: this.scale, tonic: this.#tonic.data };
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Chord,
-  Interval,
-  Key,
-  Note,
-  Progression
-});
+exports.Chord = _chunkNVE34YGZcjs.Chord; exports.Interval = _chunkNVE34YGZcjs.Interval; exports.Key = _chunkNVE34YGZcjs.Key; exports.Note = _chunkNVE34YGZcjs.Note; exports.Progression = _chunkNVE34YGZcjs.Progression;
 //# sourceMappingURL=index.cjs.map