@libraz/libcantus 0.9.2 → 0.9.4

package/dist/{chunk-LN7ZZMD2.js → chunk-KMHOICIY.js}

@@ -8,23 +8,202 @@ import {
   isScaleTone,
   majorKey,
   makeChord,
-  minorKey,
   scaleTonesInDegreeOrder
-} from "./chunk-7Y7WF64D.js";
+} from "./chunk-D2FAJBYL.js";
+import {
+  InvalidInputError,
+  assertFiniteNumber,
+  assertGenerationBudget,
+  assertInteger,
+  pitchClassOf
+} from "./chunk-XEBG3G53.js";
 
-// src/analyze/functional/internal.ts
-function mod12(n) {
-  return (n % 12 + 12) % 12;
+// src/analyze/detect/index.ts
+function uniquePitchClasses(pitches) {
+  return [...new Set(pitches.map(pitchClassOf))].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 ? pitchClassOf(opts.bassPc) : inputKind === "midi" ? pitchClassOf(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 = pitchClassOf(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) => pitchClassOf(rootPc + iv) === bassPc);
+      const inversion = bassPc === void 0 || bassIndex < 0 ? null : bassIndex;
+      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);
+}
+var MINOR_VARIANTS = [
+  { variant: "natural", mask: NATURAL_MINOR_MASK },
+  { variant: "harmonic", mask: HARMONIC_MINOR_MASK },
+  { variant: "melodic", mask: MELODIC_MINOR_MASK }
+];
+var MAJOR_VARIANTS = [{ variant: "major", mask: MAJOR_MASK }];
+function detectKey(pitches, opts = {}) {
+  assertPitches(pitches);
+  const input = uniquePitchClasses(pitches);
+  if (input.length === 0) {
+    return [];
+  }
+  const weights = opts.weights;
+  if (weights !== void 0 && weights.length !== pitches.length) {
+    throw new InvalidInputError("weights must have one entry per pitch");
+  }
+  const counts = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (let index = 0; index < pitches.length; index += 1) {
+    const weight = weights === void 0 ? 1 : weights[index] ?? 0;
+    assertFiniteNumber(weight, `weights[${index}]`);
+    if (weight <= 0) {
+      continue;
+    }
+    const pc = pitchClassOf(pitches[index] ?? 0);
+    counts.set(pc, (counts.get(pc) ?? 0) + weight);
+    total += weight;
+  }
+  if (total === 0) {
+    return [];
+  }
+  const results = [];
+  for (let tonic = 0; tonic < 12; tonic += 1) {
+    for (const mode of ["major", "minor"]) {
+      const variants = mode === "major" ? MAJOR_VARIANTS : MINOR_VARIANTS;
+      let inScale = 0;
+      let weighted = Number.NEGATIVE_INFINITY;
+      let best = variants[0];
+      for (const candidate of variants) {
+        let variantInScale = 0;
+        let variantWeighted = 0;
+        for (const pc of input) {
+          const offset = (pc - tonic + 12) % 12;
+          if (candidate.mask >> offset & 1) {
+            variantInScale += 1;
+          }
+        }
+        for (const [pc, count] of counts) {
+          const offset = (pc - tonic + 12) % 12;
+          if (candidate.mask >> offset & 1) {
+            variantWeighted += count;
+          }
+        }
+        if (variantWeighted > weighted) {
+          weighted = variantWeighted;
+          inScale = variantInScale;
+          best = candidate;
+        }
+      }
+      weighted += (counts.get(tonic) ?? 0) * 0.5;
+      results.push({
+        key: { rootPc: tonic, modeMask12: best.mask },
+        mode,
+        variant: best.variant,
+        fit: inScale / input.length,
+        score: weighted / total
+      });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results;
+}
+var DEFAULT_VELOCITY = 100;
+function detectKeyFromNotes(notes) {
+  const sounding = notes.filter((note) => note.durationBeat > 0);
+  return detectKey(
+    sounding.map((note) => note.pitch),
+    { weights: sounding.map((note) => note.durationBeat * (note.velocity ?? DEFAULT_VELOCITY)) }
+  );
 }
+function detectKeyBest(pitches, opts = {}) {
+  return detectKey(pitches, opts)[0] ?? null;
+}
+
+// src/analyze/functional/internal.ts
 function degreeRootPc(degreeNumber, key) {
   const tones = scaleTonesInDegreeOrder(key);
   if (tones.length === 0) {
-    return mod12(key.rootPc);
+    return pitchClassOf(key.rootPc);
+  }
+  const index = ((degreeNumber - 1) % tones.length + tones.length) % tones.length;
+  return tones[index] ?? pitchClassOf(key.rootPc);
+}
+function loweredDegrees(key) {
+  const tones = scaleTonesInDegreeOrder(key);
+  const out = /* @__PURE__ */ new Set();
+  if (tones.length !== 7) {
+    return out;
+  }
+  const major = scaleTonesInDegreeOrder({ rootPc: pitchClassOf(key.rootPc), modeMask12: MAJOR_MASK });
+  for (let index = 0; index < 7; index += 1) {
+    const tone = tones[index];
+    const majorTone = major[index];
+    if (tone !== void 0 && majorTone !== void 0 && pitchClassOf(majorTone - tone) === 1) {
+      out.add(index + 1);
+    }
   }
-  return tones[(degreeNumber - 1) % tones.length] ?? mod12(key.rootPc);
+  return out;
+}
+function romanReference(key) {
+  return scaleTonesInDegreeOrder(key).length === 7 ? key : majorKey(pitchClassOf(key.rootPc));
 }
 function isNeapolitan(chord, key) {
-  return mod12(chord.rootPc - key.rootPc) === 1 && chord.quality === "maj";
+  return pitchClassOf(chord.rootPc - key.rootPc) === 1 && chord.quality === "maj";
 }
 
 // src/analyze/functional/roman.ts
@@ -95,7 +274,17 @@ var ROMAN_STYLE = {
   "7b13": { lower: false, suffix: "7b13" },
   "11": { lower: false, suffix: "11" },
   "13": { lower: false, suffix: "13" },
-  "5": { lower: false, suffix: "5" }
+  "5": { lower: false, suffix: "5" },
+  "7sus4": { lower: false, suffix: "7sus4" },
+  "7b5": { lower: false, suffix: "7b5" },
+  "7alt": { lower: false, suffix: "7alt" },
+  "13b9": { lower: false, suffix: "13b9" },
+  maj13: { lower: false, suffix: "maj13" },
+  "maj7#11": { lower: false, suffix: "maj7#11" },
+  min11: { lower: true, suffix: "11" },
+  min13: { lower: true, suffix: "13" },
+  minAdd9: { lower: true, suffix: "add9" },
+  "min6/9": { lower: true, suffix: "69" }
 };
 var SUFFIX_QUALITY = new Map(
   Object.entries(ROMAN_STYLE).map(
@@ -126,28 +315,37 @@ function parseInversion(figures) {
 function parseSimpleRoman(text, key) {
   const match = /^([b#]?)([iIvV]+)(.*)$/.exec(text.trim());
   if (!match) {
-    throw new Error(`Invalid Roman numeral: ${text}`);
+    throw new InvalidInputError(`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}`);
+    throw new InvalidInputError(`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 frame = romanReference(key);
+  const redundantFlat = accidental === -1 && loweredDegrees(frame).has(degreeNumber);
+  const rootPc = pitchClassOf(degreeRootPc(degreeNumber, frame) + (redundantFlat ? 0 : accidental));
   const canonical = SUFFIX_QUALITY.get(`${isUpper ? "u" : "l"}:${suffix}`);
   if (canonical !== void 0) {
     return { rootPc, quality: canonical, inversion: 0 };
   }
-  const isDim = /o|°|dim/.test(suffix);
-  const isAug = /\+|aug/.test(suffix);
-  const isHalfDim = /ø/.test(suffix);
-  const explicitMaj7 = /maj7|M7/.test(suffix);
-  const figures = suffix.replace(/maj7|M7/g, "").replace(/[^0-9]/g, "");
+  const parsedSuffix = /^(o|°|dim|ø|\+|aug)?(maj7|M7)?(65|64|43|42|7|6|2)?$/.exec(suffix);
+  if (!parsedSuffix) {
+    throw new InvalidInputError(`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}`);
+    throw new InvalidInputError(
+      `Unsupported figured-bass or extension "${figures}" in Roman numeral: ${text}`
+    );
   }
   const { inversion, seventh } = parseInversion(figures);
   const hasSeventh = explicitMaj7 || seventh || isHalfDim;
@@ -176,7 +374,7 @@ function parseSimpleRoman(text, key) {
 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));
+    chord.bassPc = pitchClassOf(parsed.rootPc + (chord.intervals[parsed.inversion] ?? 0));
   }
   return chord;
 }
@@ -196,26 +394,32 @@ function romanStyle(quality) {
   return ROMAN_STYLE[quality];
 }
 function romanSpelling(rootPc, key) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const diatonic = tones.indexOf(mod12(rootPc));
+  const tones = scaleTonesInDegreeOrder(romanReference(key));
+  const diatonic = tones.indexOf(pitchClassOf(rootPc));
   if (diatonic >= 0) {
     return { degreeNumber: diatonic + 1, accidental: "" };
   }
+  const lowered = loweredDegrees(romanReference(key));
+  for (let i = 0; i < tones.length; i += 1) {
+    if (lowered.has(i + 1) && pitchClassOf((tones[i] ?? 0) + 1) === pitchClassOf(rootPc)) {
+      return { degreeNumber: i + 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)) {
+    if (pitchClassOf((tones[i] ?? 0) - 1) === pitchClassOf(rootPc)) {
       return { degreeNumber: degreeNumber2, accidental: "b" };
     }
   }
   for (let i = 0; i < tones.length; i += 1) {
-    if (mod12((tones[i] ?? 0) + 1) === mod12(rootPc)) {
+    if (pitchClassOf((tones[i] ?? 0) + 1) === pitchClassOf(rootPc)) {
       return { degreeNumber: i + 1, accidental: "#" };
     }
   }
-  const [degreeNumber, accidental] = OFFSET_SPELLING[mod12(rootPc - key.rootPc)] ?? [1, ""];
+  const [degreeNumber, accidental] = OFFSET_SPELLING[pitchClassOf(rootPc - key.rootPc)] ?? [1, ""];
   return { degreeNumber, accidental };
 }
 function baseMarker(quality) {
@@ -249,14 +453,65 @@ var SEVENTH_FIGURE_QUALITIES = /* @__PURE__ */ new Set([
   "aug7",
   "augMaj7"
 ]);
-function chordToRoman(chord, key) {
+function numeralFor(degreeNumber, lower) {
+  const glyph = ROMAN[degreeNumber - 1];
+  if (glyph === void 0) {
+    throw new InvalidInputError(`no Roman numeral for scale degree ${degreeNumber}`);
+  }
+  return lower ? glyph.toLowerCase() : glyph;
+}
+function isDiatonicChord(chord, key) {
+  return chordPitchClasses(chord).every((pc) => isScaleTone(pc, key));
+}
+function isAppliedDominantSonority(chord) {
+  const has = (semitones) => chord.intervals.some((i) => pitchClassOf(i) === semitones);
+  return chord.quality === "maj" || has(4) && has(10);
+}
+var LEADING_TONE_QUALITIES = /* @__PURE__ */ new Set(["dim", "dim7", "m7b5"]);
+function degreeTriad(tones, index) {
+  const root = tones[index] ?? 0;
+  return {
+    third: pitchClassOf((tones[(index + 2) % tones.length] ?? 0) - root),
+    fifth: pitchClassOf((tones[(index + 4) % tones.length] ?? 0) - root)
+  };
+}
+function appliedTarget(chord, key) {
+  const dominant = isAppliedDominantSonority(chord);
+  const leadingTone = LEADING_TONE_QUALITIES.has(chord.quality);
+  if (!dominant && !leadingTone) {
+    return null;
+  }
+  const tones = scaleTonesInDegreeOrder(romanReference(key));
+  for (let index = 1; index < tones.length; index += 1) {
+    const targetRoot = tones[index];
+    if (targetRoot === void 0) {
+      continue;
+    }
+    const triad = degreeTriad(tones, index);
+    if (triad.fifth === 6) {
+      continue;
+    }
+    const expectedRoot = pitchClassOf(targetRoot + (dominant ? 7 : -1));
+    if (expectedRoot === pitchClassOf(chord.rootPc)) {
+      return { degreeNumber: index + 1, rootPc: targetRoot, lower: triad.third === 3 };
+    }
+  }
+  return null;
+}
+function chordToRoman(chord, key, opts = {}) {
+  if (opts.applied === true && !isDiatonicChord(chord, key)) {
+    const target = appliedTarget(chord, key);
+    if (target !== null) {
+      const local = chordToRoman(chord, majorKey(target.rootPc));
+      return `${local}/${numeralFor(target.degreeNumber, target.lower)}`;
+    }
+  }
   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;
+  const cased = numeralFor(degreeNumber, lower);
   let inversion = 0;
   if (chord.bassPc !== void 0) {
-    const idx = chord.intervals.findIndex((iv) => mod12(chord.rootPc + iv) === chord.bassPc);
+    const idx = chord.intervals.findIndex((iv) => pitchClassOf(chord.rootPc + iv) === chord.bassPc);
     if (idx > 0) {
       inversion = idx;
     }
@@ -272,7 +527,7 @@ function 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 });
+  return isMinorKey(key) && isDiatonic(chord, { rootPc: pitchClassOf(key.rootPc), modeMask12: HARMONIC_MINOR_MASK });
 }
 function isBorrowedChord(chord, key) {
   if (isDiatonic(chord, key)) {
@@ -291,7 +546,7 @@ function borrowedSource(chord, key) {
     return "neapolitan";
   }
   if (isBorrowedChord(chord, key)) {
-    return isMinorKey(key) ? "parallel-major" : "parallel-minor";
+    return isMinorKey(key) ? "parallelMajor" : "parallelMinor";
   }
   return null;
 }
@@ -329,14 +584,35 @@ function isMinorKey(key) {
   return Boolean(hasMinorThird) && !hasMajorThird2;
 }
 function functionOf(chord, key) {
-  return FUNCTION_BY_OFFSET[mod12(chord.rootPc - key.rootPc)] ?? "tonic";
+  const offset = pitchClassOf(chord.rootPc - key.rootPc);
+  if (isNeapolitan(chord, key)) {
+    return "subdominant";
+  }
+  if (isAppliedDominant(chord, key)) {
+    return "dominant";
+  }
+  if (!isMinorKey(key) && hasMajorThird(chord) && (offset === 8 || offset === 10)) {
+    return "subdominant";
+  }
+  return FUNCTION_BY_OFFSET[offset] ?? "tonic";
+}
+function isAppliedDominant(chord, key) {
+  if (isDiatonic(chord, key)) {
+    return false;
+  }
+  const root = pitchClassOf(chord.rootPc);
+  const resolvesTo = (step) => isScaleTone(pitchClassOf(root + step), key);
+  if (hasMajorThird(chord) && chord.intervals.some((i) => pitchClassOf(i) === 10)) {
+    return resolvesTo(5) || resolvesTo(11);
+  }
+  return isDiminishedQuality(chord.quality) && resolvesTo(1);
 }
 function isDiatonic(chord, key) {
   return chordPitchClasses(chord).every((pc) => isScaleTone(pc, key));
 }
 function parallelKey(key) {
   return {
-    rootPc: mod12(key.rootPc),
+    rootPc: pitchClassOf(key.rootPc),
     modeMask12: isMinorKey(key) ? MAJOR_MASK : NATURAL_MINOR_MASK
   };
 }
@@ -344,40 +620,28 @@ 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);
+  return chord.intervals.some((interval) => pitchClassOf(interval) === 4);
 }
 function analyzeChord(chord, key) {
   const source = borrowedSource(chord, key);
   return {
-    function: qualityAwareFunction(chord, key),
+    function: functionOf(chord, key),
     borrowed: source !== null,
     source,
     roman: chordToRoman(chord, key)
   };
 }
 function secondaryDominant(targetDegree, key) {
+  assertInteger(targetDegree, "targetDegree", 0, 6);
   const targetRoot = degreeRootPc(targetDegree + 1, key);
-  return makeChord(mod12(targetRoot + 7), "dom7");
+  return makeChord(pitchClassOf(targetRoot + 7), "dom7");
 }
 
 // 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 tonic = pitchClassOf(key.rootPc);
+  const fromOffset = pitchClassOf(from.rootPc - tonic);
+  const toOffset = pitchClassOf(to.rootPc - tonic);
   const deceptiveTargets = isMinorKey(key) ? [8] : [8, 9];
   if (fromOffset === 7 && toOffset === 0) {
     return "authentic";
@@ -394,124 +658,12 @@ function detectCadence(from, to, key) {
   return null;
 }
 
-// src/analyze/detect/index.ts
-function pitchClass(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function uniquePitchClasses(pitches) {
-  return [...new Set(pitches.map(pitchClass))].sort((a, b) => a - b);
-}
-function detectChord(pitches) {
-  const input = uniquePitchClasses(pitches);
-  if (input.length === 0) {
-    return [];
-  }
-  const bassPc = pitchClass(Math.min(...pitches));
-  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 = pitchClass(rootPc + 7);
-      if (missingPcs.length > 1 || missingPcs.length === 1 && missingPcs[0] !== fifthPc) {
-        continue;
-      }
-      const extraPcs = input.filter((pc) => !toneSet.has(pc));
-      const bassIndex = chord.intervals.findIndex((iv) => pitchClass(rootPc + iv) === bassPc);
-      const inversion = bassIndex > 0 ? bassIndex : 0;
-      const match = {
-        rootPc,
-        quality,
-        missingPcs,
-        extraPcs,
-        exact: extraPcs.length === 0 && missingPcs.length === 0,
-        inversion
-      };
-      if (inversion > 0) {
-        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) {
-  const best = detectChord(pitches)[0];
-  if (!best) {
-    return null;
-  }
-  return makeChord(best.rootPc, best.quality, best.bassPc);
-}
-var MINOR_MASK_VARIANTS = [NATURAL_MINOR_MASK, HARMONIC_MINOR_MASK, MELODIC_MINOR_MASK];
-function detectKey(pitches) {
-  const input = uniquePitchClasses(pitches);
-  if (input.length === 0) {
-    return [];
-  }
-  const counts = /* @__PURE__ */ new Map();
-  for (const pc of pitches.map(pitchClass)) {
-    counts.set(pc, (counts.get(pc) ?? 0) + 1);
-  }
-  const total = pitches.length;
-  const results = [];
-  for (let tonic = 0; tonic < 12; tonic += 1) {
-    for (const mode of ["major", "minor"]) {
-      const key = mode === "major" ? majorKey(tonic) : minorKey(tonic);
-      const masks = mode === "major" ? [MAJOR_MASK] : MINOR_MASK_VARIANTS;
-      let inScale = 0;
-      let weighted = Number.NEGATIVE_INFINITY;
-      for (const mask of masks) {
-        let variantInScale = 0;
-        let variantWeighted = 0;
-        for (const pc of input) {
-          const offset = (pc - tonic + 12) % 12;
-          if (mask >> offset & 1) {
-            variantInScale += 1;
-          }
-        }
-        for (const [pc, count] of counts) {
-          const offset = (pc - tonic + 12) % 12;
-          if (mask >> offset & 1) {
-            variantWeighted += count;
-          }
-        }
-        if (variantWeighted > weighted) {
-          weighted = variantWeighted;
-          inScale = variantInScale;
-        }
-      }
-      weighted += (counts.get(tonic) ?? 0) * 0.5;
-      results.push({
-        key,
-        mode,
-        fit: inScale / input.length,
-        score: weighted / total
-      });
-    }
-  }
-  results.sort((a, b) => b.score - a.score);
-  return results.map(({ key, mode, fit }) => ({ key, mode, fit }));
-}
-
 export {
+  detectChord,
+  detectChordBest,
+  detectKey,
+  detectKeyFromNotes,
+  detectKeyBest,
   romanToChord,
   chordToRoman,
   isMinorKey,
@@ -522,9 +674,6 @@ export {
   secondaryDominant,
   isBorrowedChord,
   borrowedSource,
-  detectCadence,
-  detectChord,
-  detectChordBest,
-  detectKey
+  detectCadence
 };
-//# sourceMappingURL=chunk-LN7ZZMD2.js.map
+//# sourceMappingURL=chunk-KMHOICIY.js.map