@libraz/libcantus 1.0.1 → 1.2.0

package/dist/chunk-OE6WK2Y2.cjs

@@ -1,1577 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkQ2WGKJNNcjs = require('./chunk-Q2WGKJNN.cjs');
-
-// src/analyze/detect/modes.ts
-var MODAL_CANDIDATES = Object.freeze([
-  { scaleName: "dorian", mode: "minor", mask: _chunkUADYAYATcjs.DORIAN_MASK, substitutions: [[8, 9]] },
-  { scaleName: "phrygian", mode: "minor", mask: _chunkUADYAYATcjs.PHRYGIAN_MASK, substitutions: [[2, 1]] },
-  { scaleName: "lydian", mode: "major", mask: _chunkUADYAYATcjs.LYDIAN_MASK, substitutions: [[5, 6]] },
-  { scaleName: "mixolydian", mode: "major", mask: _chunkUADYAYATcjs.MIXOLYDIAN_MASK, substitutions: [[11, 10]] },
-  {
-    scaleName: "locrian",
-    mode: "minor",
-    mask: _chunkUADYAYATcjs.LOCRIAN_MASK,
-    substitutions: [
-      [2, 1],
-      [7, 6]
-    ]
-  }
-]);
-var MODAL_SCALE_NAMES = Object.freeze(
-  MODAL_CANDIDATES.map((candidate) => candidate.scaleName)
-);
-function modalProfileVector(profile, candidate) {
-  const parent = candidate.mode === "major" ? profile.major : profile.minor;
-  const vector = [...parent];
-  for (const [replaced, replacing] of candidate.substitutions) {
-    vector[replacing] = _nullishCoalesce(parent[replaced], () => ( 0));
-    vector[replaced] = _nullishCoalesce(parent[replacing], () => ( 0));
-  }
-  return vector;
-}
-function resolveModalCandidates(modes) {
-  if (modes === void 0 || modes === false) {
-    return [];
-  }
-  if (modes === true) {
-    return MODAL_CANDIDATES;
-  }
-  if (!Array.isArray(modes)) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("modes must be a boolean or an array of mode names");
-  }
-  const requested = new Set(modes);
-  for (const name of requested) {
-    if (!MODAL_SCALE_NAMES.some((known) => known === name)) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-        `unknown mode '${String(name)}'; expected one of ${MODAL_SCALE_NAMES.join(", ")}`
-      );
-    }
-  }
-  return MODAL_CANDIDATES.filter((candidate) => requested.has(candidate.scaleName));
-}
-
-// src/analyze/detect/profiles.ts
-var KRUMHANSL_KESSLER_PROFILE = {
-  major: [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88],
-  minor: [6.33, 2.68, 3.52, 5.38, 2.6, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17]
-};
-var TEMPERLEY_KOSTKA_PAYNE_PROFILE = {
-  major: [0.748, 0.06, 0.488, 0.082, 0.67, 0.46, 0.096, 0.715, 0.104, 0.366, 0.057, 0.4],
-  minor: [0.712, 0.084, 0.474, 0.618, 0.049, 0.46, 0.105, 0.747, 0.404, 0.067, 0.133, 0.33]
-};
-var FLAT_SCALE_PROFILE = {
-  major: [1.5, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1],
-  minor: [1.5, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0]
-};
-var PROFILE_LENGTH = 12;
-var SCORE_QUANTUM = 1e12;
-var NAMED_PROFILES = {
-  krumhansl: KRUMHANSL_KESSLER_PROFILE,
-  temperley: TEMPERLEY_KOSTKA_PAYNE_PROFILE,
-  flat: FLAT_SCALE_PROFILE
-};
-function assertProfileVector(vector, name) {
-  if (vector.length !== PROFILE_LENGTH) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`${name} must have ${PROFILE_LENGTH} entries`);
-  }
-  for (let index = 0; index < vector.length; index += 1) {
-    const value = vector[index];
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`${name}[${index}] must be a finite number`);
-    }
-  }
-}
-function resolveKeyProfile(profile) {
-  if (profile === void 0) {
-    return KRUMHANSL_KESSLER_PROFILE;
-  }
-  if (typeof profile === "string") {
-    const named = NAMED_PROFILES[profile];
-    if (named === void 0) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-        `unknown key profile '${profile}'; expected one of ${Object.keys(NAMED_PROFILES).join(", ")}`
-      );
-    }
-    return named;
-  }
-  if (typeof profile !== "object" || profile === null) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("profile must be a profile name or a { major, minor } pair");
-  }
-  const { major, minor } = profile;
-  if (!Array.isArray(major) || !Array.isArray(minor)) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("profile must carry a major and a minor vector");
-  }
-  assertProfileVector(major, "profile.major");
-  assertProfileVector(minor, "profile.minor");
-  return { major, minor };
-}
-function normalizedDot(dist, vector, tonic) {
-  let dot = 0;
-  let distSquares = 0;
-  let profileSquares = 0;
-  for (let pc = 0; pc < PROFILE_LENGTH; pc += 1) {
-    const d = _nullishCoalesce(dist[pc], () => ( 0));
-    const p = _nullishCoalesce(vector[(pc - tonic + PROFILE_LENGTH) % PROFILE_LENGTH], () => ( 0));
-    dot += d * p;
-    distSquares += d * d;
-    profileSquares += p * p;
-  }
-  const norm = Math.sqrt(distSquares * profileSquares);
-  return norm > 0 ? dot / norm : 0;
-}
-function profileScore(dist, vector, tonic) {
-  let distSum = 0;
-  let profileSum = 0;
-  for (let pc = 0; pc < PROFILE_LENGTH; pc += 1) {
-    distSum += _nullishCoalesce(dist[pc], () => ( 0));
-    profileSum += _nullishCoalesce(vector[pc], () => ( 0));
-  }
-  const distMean = distSum / PROFILE_LENGTH;
-  const profileMean = profileSum / PROFILE_LENGTH;
-  let covariance = 0;
-  let distVariance = 0;
-  let profileVariance = 0;
-  for (let pc = 0; pc < PROFILE_LENGTH; pc += 1) {
-    const d = (_nullishCoalesce(dist[pc], () => ( 0))) - distMean;
-    const p = (_nullishCoalesce(vector[(pc - tonic + PROFILE_LENGTH) % PROFILE_LENGTH], () => ( 0))) - profileMean;
-    covariance += d * p;
-    distVariance += d * d;
-    profileVariance += p * p;
-  }
-  const denominator = Math.sqrt(distVariance * profileVariance);
-  const raw = denominator > 0 ? covariance / denominator : normalizedDot(dist, vector, tonic);
-  if (!Number.isFinite(raw)) {
-    return 0;
-  }
-  const clamped = Math.min(1, Math.max(-1, raw));
-  return Math.round(clamped * SCORE_QUANTUM) / SCORE_QUANTUM;
-}
-
-// src/analyze/detect/index.ts
-function uniquePitchClasses(pitches) {
-  return [...new Set(pitches.map(_chunkQ2WGKJNNcjs.pitchClassOf))].sort((a, b) => a - b);
-}
-function assertPitches(pitches, name, budget = void 0) {
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, pitches.length, name, budget);
-  for (let index = 0; index < pitches.length; index += 1) {
-    _chunkQ2WGKJNNcjs.assertMidiPitch.call(void 0, _nullishCoalesce(pitches[index], () => ( Number.NaN)), `pitches[${index}]`);
-  }
-}
-function detectChord(pitches, opts = {}) {
-  assertPitches(pitches, "chord detection pitches");
-  if (opts.bassPc !== void 0) _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, 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 ? _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, opts.bassPc) : inputKind === "midi" ? _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitches.reduce((lowest, pitch) => Math.min(lowest, pitch), Infinity)) : void 0;
-  const inputSet = new Set(input);
-  const matches = [];
-  const qualities = _chunkUADYAYATcjs.chordQualities.call(void 0, );
-  const toneCounts = new Map(
-    qualities.map((quality) => [quality, _chunkUADYAYATcjs.chordPitchClasses.call(void 0, _chunkUADYAYATcjs.makeChord.call(void 0, 0, quality)).length])
-  );
-  for (const rootPc of input) {
-    for (const quality of qualities) {
-      const chord = _chunkUADYAYATcjs.makeChord.call(void 0, rootPc, quality);
-      const tones = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord);
-      const toneSet = new Set(tones);
-      const missingPcs = tones.filter((pc) => !inputSet.has(pc));
-      const fifthPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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 = _nullishCoalesce(toneCounts.get(a.quality), () => ( 0));
-    const bSize = _nullishCoalesce(toneCounts.get(b.quality), () => ( 0));
-    return bSize - aSize;
-  });
-  return matches;
-}
-function detectChordBest(pitches, opts = {}) {
-  const best = detectChord(pitches, opts)[0];
-  if (!best) {
-    return null;
-  }
-  return _chunkUADYAYATcjs.makeChord.call(void 0, best.rootPc, best.quality, best.bassPc);
-}
-var MINOR_VARIANTS = [
-  { variant: "natural", mask: _chunkUADYAYATcjs.NATURAL_MINOR_MASK, scaleName: "naturalMinor" },
-  { variant: "harmonic", mask: _chunkUADYAYATcjs.HARMONIC_MINOR_MASK, scaleName: "harmonicMinor" },
-  { variant: "melodic", mask: _chunkUADYAYATcjs.MELODIC_MINOR_MASK, scaleName: "melodicMinor" }
-];
-var MAJOR_VARIANTS = [
-  { variant: "major", mask: _chunkUADYAYATcjs.MAJOR_MASK, scaleName: "major" }
-];
-var SCALE_NAME_ORDER = [
-  "major",
-  "naturalMinor",
-  "harmonicMinor",
-  "melodicMinor",
-  "dorian",
-  "phrygian",
-  "lydian",
-  "mixolydian",
-  "locrian"
-];
-function scaleNameRank(name) {
-  return SCALE_NAME_ORDER.indexOf(name);
-}
-var EXPLAINED_RIVALS = 3;
-var SCORE_DIGITS = 2;
-var MAX_SCORE_DIGITS = 6;
-function quoteScores(rival, winner) {
-  let digits = SCORE_DIGITS;
-  while (digits < MAX_SCORE_DIGITS && rival.toFixed(digits) === winner.toFixed(digits)) {
-    digits += 1;
-  }
-  return `${rival.toFixed(digits)} against ${winner.toFixed(digits)}`;
-}
-function keyLabel(match) {
-  const tonic = _chunkQ2WGKJNNcjs.formatNote.call(void 0, _chunkUADYAYATcjs.spelledKeyOf.call(void 0, match.key).tonic);
-  const scale = match.scaleName.replace(/([A-Z])/g, " $1").toLowerCase();
-  return `${tonic} ${scale}`;
-}
-function describeKeyMatch(match, inputSize) {
-  const inScale = Math.round(match.fit * inputSize);
-  return `${keyLabel(match)}: profile correlation ${match.score.toFixed(SCORE_DIGITS)}, with ${inScale} of ${inputSize} input pitch classes in the scale`;
-}
-function keyRivalReason(winner, rival) {
-  if (rival.score !== winner.score) {
-    return `Ranked below on profile correlation (${quoteScores(rival.score, winner.score)})`;
-  }
-  if (rival.fit !== winner.fit) {
-    return "Tied on correlation, ranked below on the share of the input its scale covers";
-  }
-  if (rival.key.rootPc !== winner.key.rootPc) {
-    return "Tied on correlation and coverage, ranked below by tonic pitch class";
-  }
-  return "Tied on correlation and coverage on the same tonic, ranked below by scale, which takes major before the minor forms and the modes last";
-}
-function explainMatches(results, inputSize) {
-  for (const match of results) {
-    match.rationale = describeKeyMatch(match, inputSize);
-  }
-  const winner = results[0];
-  if (winner === void 0) {
-    return;
-  }
-  winner.alternatives = results.slice(1, EXPLAINED_RIVALS + 1).map((rival) => ({ label: keyLabel(rival), reason: keyRivalReason(winner, rival) }));
-}
-function detectKey(pitches, opts = {}) {
-  assertPitches(pitches, "key detection pitches", opts.budget);
-  const weights = opts.weights;
-  if (weights !== void 0 && weights.length !== pitches.length) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("weights must have one entry per pitch");
-  }
-  const profile = resolveKeyProfile(opts.profile);
-  const modalCandidates = resolveModalCandidates(opts.modes).map((candidate) => ({
-    candidate,
-    vector: modalProfileVector(profile, candidate)
-  }));
-  const counts = /* @__PURE__ */ new Map();
-  let total = 0;
-  for (let index = 0; index < pitches.length; index += 1) {
-    const weight = weights === void 0 ? 1 : _nullishCoalesce(weights[index], () => ( 0));
-    _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, weight, `weights[${index}]`);
-    if (weight <= 0) {
-      continue;
-    }
-    const pc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _nullishCoalesce(pitches[index], () => ( 0)));
-    counts.set(pc, (_nullishCoalesce(counts.get(pc), () => ( 0))) + weight);
-    total += weight;
-  }
-  if (total === 0) {
-    return [];
-  }
-  const input = [...counts.keys()];
-  const dist = new Array(12).fill(0);
-  for (const [pc, count] of counts) {
-    dist[pc] = count;
-  }
-  const results = [];
-  for (let tonic = 0; tonic < 12; tonic += 1) {
-    for (const mode of ["major", "minor"]) {
-      const vector = mode === "major" ? profile.major : profile.minor;
-      const score = profileScore(dist, vector, tonic);
-      const variants = mode === "major" ? MAJOR_VARIANTS : MINOR_VARIANTS;
-      let covered = Number.NEGATIVE_INFINITY;
-      let inScale = 0;
-      let best = variants[0];
-      for (const candidate of variants) {
-        let candidateCovered = 0;
-        let candidateInScale = 0;
-        for (const [pc, count] of counts) {
-          const offset = (pc - tonic + 12) % 12;
-          if (candidate.mask >> offset & 1) {
-            candidateCovered += count;
-            candidateInScale += 1;
-          }
-        }
-        if (candidateCovered > covered) {
-          covered = candidateCovered;
-          inScale = candidateInScale;
-          best = candidate;
-        }
-      }
-      results.push({
-        key: { rootPc: tonic, modeMask12: best.mask },
-        mode,
-        variant: best.variant,
-        scaleName: best.scaleName,
-        fit: inScale / input.length,
-        score
-      });
-    }
-    for (const { candidate, vector } of modalCandidates) {
-      let inScale = 0;
-      for (const pc of counts.keys()) {
-        if (candidate.mask >> (pc - tonic + 12) % 12 & 1) {
-          inScale += 1;
-        }
-      }
-      results.push({
-        key: { rootPc: tonic, modeMask12: candidate.mask },
-        mode: candidate.mode,
-        variant: "modal",
-        scaleName: candidate.scaleName,
-        fit: inScale / input.length,
-        score: profileScore(dist, vector, tonic)
-      });
-    }
-  }
-  results.sort((a, b) => {
-    if (a.score !== b.score) {
-      return b.score - a.score;
-    }
-    if (a.fit !== b.fit) {
-      return b.fit - a.fit;
-    }
-    if (a.key.rootPc !== b.key.rootPc) {
-      return a.key.rootPc - b.key.rootPc;
-    }
-    return scaleNameRank(a.scaleName) - scaleNameRank(b.scaleName);
-  });
-  if (opts.explain === true) {
-    explainMatches(results, input.length);
-  }
-  return results;
-}
-var DEFAULT_VELOCITY = 100;
-function detectKeyFromNotes(notes, opts = {}) {
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, notes, "key detection notes", {
-    allowNonPositiveDuration: true,
-    budget: opts.budget
-  });
-  const sounding = notes.filter((note) => note.durationBeat > 0);
-  return detectKey(
-    sounding.map((note) => note.pitch),
-    {
-      weights: sounding.map((note) => note.durationBeat * (_nullishCoalesce(note.velocity, () => ( DEFAULT_VELOCITY)))),
-      profile: opts.profile,
-      modes: opts.modes,
-      explain: opts.explain,
-      budget: opts.budget
-    }
-  );
-}
-function detectKeyBest(pitches, opts = {}) {
-  return _nullishCoalesce(detectKey(pitches, opts)[0], () => ( null));
-}
-
-// src/analyze/functional/internal.ts
-function isMinorScale(key) {
-  const minorThirdBit = key.modeMask12 >> 3 & 1;
-  const majorThirdBit = key.modeMask12 >> 4 & 1;
-  return Boolean(minorThirdBit) && !majorThirdBit;
-}
-function parallelScale(key) {
-  return {
-    rootPc: _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc),
-    modeMask12: isMinorScale(key) ? _chunkUADYAYATcjs.MAJOR_MASK : _chunkUADYAYATcjs.NATURAL_MINOR_MASK
-  };
-}
-function degreeRootPc(degreeNumber, key) {
-  const tones = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, key);
-  if (tones.length === 0) {
-    return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc);
-  }
-  const index = ((degreeNumber - 1) % tones.length + tones.length) % tones.length;
-  return _nullishCoalesce(tones[index], () => ( _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc)));
-}
-function loweredDegrees(key) {
-  const tones = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, key);
-  const out = /* @__PURE__ */ new Set();
-  if (tones.length !== 7) {
-    return out;
-  }
-  const major = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, { rootPc: _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunkUADYAYATcjs.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 && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, majorTone - tone) === 1) {
-      out.add(index + 1);
-    }
-  }
-  return out;
-}
-function romanReference(key) {
-  return _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, key).length === 7 ? key : _chunkUADYAYATcjs.majorKey.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc));
-}
-function isDiatonicChord(chord, key) {
-  return _chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord).every((pc) => _chunkUADYAYATcjs.isScaleTone.call(void 0, pc, key));
-}
-function hasMajorThird(chord) {
-  return chord.intervals.some((interval) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, interval) === 4);
-}
-function isNeapolitan(chord, key) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 1 && chord.quality === "maj" && !isDiatonicChord(chord, key);
-}
-function isAppliedDominantSonority(chord) {
-  const has = (semitones) => chord.intervals.some((i) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, i) === semitones);
-  return chord.quality === "maj" || has(4) && has(10);
-}
-
-// src/analyze/functional/augmented-sixth.ts
-var KINDS = ["italian", "french", "german"];
-var BASS_ABOVE_TONIC = 8;
-var TONES_ABOVE_BASS = {
-  italian: [0, 4, 10],
-  french: [0, 4, 6, 10],
-  german: [0, 4, 7, 10]
-};
-var SPELLED_ABOVE_BASS = {
-  italian: ["P1", "M3", "A6"].map((name) => _chunkQ2WGKJNNcjs.parseInterval.call(void 0, name)),
-  french: ["P1", "M3", "A4", "A6"].map((name) => _chunkQ2WGKJNNcjs.parseInterval.call(void 0, name)),
-  german: ["P1", "M3", "P5", "A6"].map((name) => _chunkQ2WGKJNNcjs.parseInterval.call(void 0, name))
-};
-var BASS_INTERVAL = _chunkQ2WGKJNNcjs.parseInterval.call(void 0, "m6");
-var CHORD_SHAPE = {
-  italian: { rootAboveBass: 0, quality: "dom7", intervals: [0, 4, 10] },
-  french: { rootAboveBass: 6, quality: "7b5", intervals: [0, 4, 6, 10] },
-  german: { rootAboveBass: 0, quality: "dom7", intervals: [0, 4, 7, 10] }
-};
-var KIND_BY_SYMBOL = /* @__PURE__ */ new Map([
-  ["It6", "italian"],
-  ["Fr6", "french"],
-  ["Ger6", "german"],
-  // The German sixth's figures over its bass are 6/5; both spellings are in use.
-  ["Ger65", "german"]
-]);
-var SYMBOL_BY_KIND = {
-  italian: "It6",
-  french: "Fr6",
-  german: "Ger6"
-};
-function bassPcOf(key) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc + BASS_ABOVE_TONIC);
-}
-function bareSpelling(note) {
-  return { letter: note.letter, alter: note.alter };
-}
-function spelledInChordOrder(kind, tonic) {
-  const tones = spelledFromTonic(kind, tonic);
-  const rootIndex = TONES_ABOVE_BASS[kind].indexOf(CHORD_SHAPE[kind].rootAboveBass);
-  return [...tones.slice(rootIndex), ...tones.slice(0, rootIndex)];
-}
-function augmentedSixthChord(kind, key) {
-  return augmentedSixthOn(kind, _chunkUADYAYATcjs.toKeyScale.call(void 0, key));
-}
-function augmentedSixthOn(kind, key) {
-  const checked = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
-  const shape = CHORD_SHAPE[checked];
-  const bassPc = bassPcOf(key);
-  const chord = _chunkUADYAYATcjs.makeChord.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, bassPc + shape.rootAboveBass), shape.quality, bassPc);
-  chord.intervals = [...shape.intervals];
-  const tonic = _chunkUADYAYATcjs.spelledKeyOf.call(void 0, key).tonic;
-  const bass = _chunkQ2WGKJNNcjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
-  const tones = spelledInChordOrder(checked, tonic);
-  const [root = bass] = tones;
-  chord.rootSpelling = bareSpelling(root);
-  chord.bassSpelling = bareSpelling(bass);
-  chord.toneSpellings = tones.map(bareSpelling);
-  return chord;
-}
-function kindOfPitchClasses(pcs, bass) {
-  for (const kind of KINDS) {
-    const tones = TONES_ABOVE_BASS[kind];
-    if (pcs.size === tones.length && tones.every((tone) => pcs.has(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, bass + tone)))) {
-      return kind;
-    }
-  }
-  return null;
-}
-function spellingId(note) {
-  return `${_chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, note.letter)}:${note.alter}`;
-}
-function spellsAugmentedSixth(chord, kind, key) {
-  const tonic = _chunkUADYAYATcjs.spelledKeyOf.call(void 0, key).tonic;
-  const written = new Set(_chunkUADYAYATcjs.spellChord.call(void 0, chord, tonic, key).map(spellingId));
-  const tones = spelledFromTonic(kind, tonic).map(spellingId);
-  return written.size === tones.length && tones.every((tone) => written.has(tone));
-}
-function augmentedSixthKind(chord, key) {
-  return augmentedSixthKindOf(_chunkUADYAYATcjs.toChordData.call(void 0, chord), _chunkUADYAYATcjs.toKeyScale.call(void 0, key));
-}
-function augmentedSixthKindOf(chord, key) {
-  const bass = bassPcOf(key);
-  if (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== bass) {
-    return null;
-  }
-  const kind = kindOfPitchClasses(new Set(_chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord)), bass);
-  if (kind === null || !spellsAugmentedSixth(chord, kind, key)) {
-    return null;
-  }
-  return kind;
-}
-function augmentedSixthFromPitchClasses(pcs, bassPc, key) {
-  return augmentedSixthOverBass(pcs, bassPc, _chunkUADYAYATcjs.toKeyScale.call(void 0, key));
-}
-function augmentedSixthOverBass(pcs, bassPc, key) {
-  const bass = bassPcOf(key);
-  if (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, bassPc) !== bass) {
-    return null;
-  }
-  const kind = kindOfPitchClasses(new Set(pcs.map(_chunkQ2WGKJNNcjs.pitchClassOf)), bass);
-  return kind === null ? null : augmentedSixthOn(kind, key);
-}
-function spellAugmentedSixth(kind, tonic) {
-  return spelledFromTonic(kind, _chunkQ2WGKJNNcjs.toNoteData.call(void 0, tonic));
-}
-function spelledFromTonic(kind, tonic) {
-  const checked = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
-  const bass = _chunkQ2WGKJNNcjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
-  return SPELLED_ABOVE_BASS[checked].map((interval) => _chunkQ2WGKJNNcjs.transposeByInterval.call(void 0, bass, interval));
-}
-function augmentedSixthFromSymbol(symbol, key) {
-  const kind = KIND_BY_SYMBOL.get(symbol);
-  return kind === void 0 ? null : augmentedSixthOn(kind, key);
-}
-function augmentedSixthSymbol(chord, key) {
-  const kind = augmentedSixthKindOf(chord, key);
-  return kind === null ? null : SYMBOL_BY_KIND[kind];
-}
-
-// src/analyze/functional/borrowed.ts
-function isMinorScaleAlteration(chord, key) {
-  if (!isMinorScale(key)) return false;
-  const alteredKey = { rootPc: _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunkUADYAYATcjs.HARMONIC_MINOR_MASK };
-  if (isDiatonicChord(chord, alteredKey)) return true;
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 11 && isDiatonicChord(chord, { rootPc: _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunkUADYAYATcjs.MELODIC_MINOR_MASK });
-}
-function isBorrowed(chord, key) {
-  if (isDiatonicChord(chord, key)) {
-    return false;
-  }
-  if (isNeapolitan(chord, key)) {
-    return true;
-  }
-  if (isMinorScaleAlteration(chord, key)) {
-    return false;
-  }
-  return isDiatonicChord(chord, parallelScale(key));
-}
-function borrowedSourceOf(chord, key) {
-  if (isDiatonicChord(chord, key)) {
-    return null;
-  }
-  if (isNeapolitan(chord, key)) return "neapolitan";
-  if (isBorrowed(chord, key)) {
-    return isMinorScale(key) ? "parallelMajor" : "parallelMinor";
-  }
-  return null;
-}
-function isBorrowedChord(chord, key) {
-  return isBorrowed(_chunkUADYAYATcjs.toChordData.call(void 0, chord), _chunkUADYAYATcjs.toKeyScale.call(void 0, key));
-}
-function borrowedSource(chord, key) {
-  return borrowedSourceOf(_chunkUADYAYATcjs.toChordData.call(void 0, chord), _chunkUADYAYATcjs.toKeyScale.call(void 0, key));
-}
-
-// src/analyze/functional/cadence.ts
-var DOMINANT_DEGREE = 5;
-var SUBMEDIANT_DEGREE = 6;
-function degreeOffset(degreeNumber, key) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, degreeRootPc(degreeNumber, romanReference(key)) - key.rootPc);
-}
-function thirdBelongsToKey(chord, key) {
-  return chord.intervals.some(
-    (interval) => (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, interval) === 3 || _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, interval) === 4) && _chunkUADYAYATcjs.isScaleTone.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc + interval), key)
-  );
-}
-function deceptiveTargets(key) {
-  const submediant = degreeOffset(SUBMEDIANT_DEGREE, key);
-  if (isMinorScale(key)) {
-    return [submediant];
-  }
-  const borrowed = degreeOffset(SUBMEDIANT_DEGREE, parallelScale(key));
-  return borrowed === submediant ? [submediant] : [submediant, borrowed];
-}
-function restsOnDominant(to, key) {
-  if (hasMajorThird(to)) {
-    return true;
-  }
-  const dominantPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc + degreeOffset(DOMINANT_DEGREE, key));
-  const leadingToneDominant = _chunkUADYAYATcjs.isScaleTone.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, dominantPc + 4), key);
-  return !leadingToneDominant && thirdBelongsToKey(to, key);
-}
-function isLeadingToneDiminished(chord) {
-  return chord.quality === "dim" || chord.quality === "dim7" || chord.quality === "m7b5";
-}
-function isDominantOf(chord, key) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 7 && hasMajorThird(chord);
-}
-function isLeadingToneOf(chord, key) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 11 && isLeadingToneDiminished(chord);
-}
-function isTonicSixFour(chord, key) {
-  if (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) !== 0 || chord.bassPc === void 0) {
-    return false;
-  }
-  const isTriad = chord.intervals.length === 3 && chord.intervals.some((interval) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, interval) === 7);
-  return isTriad && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.bassPc - chord.rootPc) === 7;
-}
-function isCadentialSixFour(chord, next, key) {
-  return isTonicSixFour(chord, key) && isDominantOf(next, key) && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _nullishCoalesce(next.bassPc, () => ( next.rootPc)));
-}
-function outerPitches(voicing) {
-  let bass;
-  let soprano;
-  for (const pitch of voicing) {
-    if (!Number.isFinite(pitch)) {
-      continue;
-    }
-    if (bass === void 0 || pitch < bass) {
-      bass = pitch;
-    }
-    if (soprano === void 0 || pitch > soprano) {
-      soprano = pitch;
-    }
-  }
-  return { bass, soprano };
-}
-function bassPcOf2(chord, voicedBass) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _nullishCoalesce(_nullishCoalesce(voicedBass, () => ( chord.bassPc)), () => ( chord.rootPc)));
-}
-function cadenceType(from, to, key, fromBassPc, toBassPc) {
-  const tonic = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc);
-  const fromOffset = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, from.rootPc - tonic);
-  const toOffset = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, to.rootPc - tonic);
-  if (isCadentialSixFour(from, to, key)) {
-    return null;
-  }
-  const dominant = isDominantOf(from, key);
-  if ((dominant || isLeadingToneOf(from, key)) && toOffset === 0) {
-    return "authentic";
-  }
-  if (fromOffset === 5 && toOffset === 0) {
-    return "plagal";
-  }
-  if (fromOffset === 10 && toOffset === 0 && hasMajorThird(from)) {
-    return "modal";
-  }
-  if (dominant && deceptiveTargets(key).includes(toOffset)) {
-    return "deceptive";
-  }
-  const dominantOffset = degreeOffset(DOMINANT_DEGREE, key);
-  const half = toOffset === dominantOffset && restsOnDominant(to, key) && fromOffset !== dominantOffset;
-  if (half && isMinorScale(key) && fromOffset === 5 && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, fromBassPc - tonic) === 8 && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, toBassPc - tonic) === 7) {
-    return "phrygian";
-  }
-  return half ? "half" : null;
-}
-function authenticStrength(leadingTone, rootPosition, voiced, soprano) {
-  if (leadingTone || !rootPosition) {
-    return "imperfect";
-  }
-  if (!voiced) {
-    return null;
-  }
-  return soprano === "root" ? "perfect" : "imperfect";
-}
-function imperfectReason(facts) {
-  if (facts.leadingTone) {
-    return "the dominant root never sounds under the leading-tone chord";
-  }
-  if (!facts.rootPosition) {
-    return "a chord stands on something other than its own root";
-  }
-  return "the soprano does not land on the tonic";
-}
-function describeNonCadence(facts) {
-  if (facts.withinSixFour) {
-    return "No cadence: the tonic six-four stands on the dominant already, so its resolution is one harmony moving inside itself rather than a motion between two";
-  }
-  if (facts.fromOffset === facts.toOffset) {
-    return "No cadence: the harmony repeats, so there is no root motion to cadence with";
-  }
-  if (facts.toOffset === 0) {
-    return "No cadence: the tonic is approached by none of the chords that cadence onto it";
-  }
-  if (facts.onFifthDegree) {
-    return "No cadence: the arrival stands on the fifth degree but sounds no third the key rests on, so it is not the dominant a half cadence comes to";
-  }
-  return "No cadence: the motion arrives on neither the tonic nor the dominant";
-}
-function describeCadence(facts) {
-  let text;
-  switch (facts.type) {
-    case "authentic": {
-      const approach = facts.leadingTone ? "leading-tone chord" : "dominant";
-      const head = `Authentic cadence: the ${approach} resolves onto the tonic`;
-      text = facts.strength === "perfect" ? `${head}, perfect with both chords on their roots and the tonic in the soprano` : facts.strength === "imperfect" ? `${head}, imperfect because ${imperfectReason(facts)}` : `${head}; no voicing names the soprano, so it is graded neither perfect nor imperfect`;
-      break;
-    }
-    case "plagal":
-      text = "Plagal cadence: the subdominant falls onto the tonic";
-      break;
-    case "modal":
-      text = "Modal cadence: the major triad on the subtonic rises onto the tonic with no leading tone";
-      break;
-    case "deceptive":
-      text = "Deceptive cadence: the dominant resolves onto the submediant in place of the tonic";
-      break;
-    case "phrygian":
-      text = "Phrygian cadence: the bass falls a semitone from the lowered submediant onto the dominant, and the motion rests there";
-      break;
-    case "half":
-      text = "Half cadence: the motion comes to rest on the dominant";
-      break;
-    case null:
-      text = describeNonCadence(facts);
-      break;
-  }
-  if (facts.evaded) {
-    text = `${text}; the tonic arrives inverted, so the arrival the ear was promised is withheld`;
-  }
-  return facts.sixFour ? `${text}; the dominant was reached as a cadential six-four, a double appoggiatura over the same bass, so the cadence begins there rather than at the dominant's own arrival` : text;
-}
-function cadenceAlternatives(facts) {
-  const out = [];
-  if (facts.type === "deceptive") {
-    out.push({
-      label: "authentic",
-      reason: "The dominant was prepared, but the arrival is the submediant rather than the tonic"
-    });
-  } else if (facts.type !== "authentic" && facts.toOffset === 0) {
-    out.push({
-      label: "authentic",
-      reason: "The arrival is the tonic, but the chord before it is neither the dominant nor a leading-tone chord"
-    });
-  }
-  if (facts.type === "authentic" && facts.strength !== "perfect") {
-    out.push({
-      label: "perfect authentic",
-      reason: facts.strength === null ? "The chords meet every condition a voicing can be judged without, but no voicing names the soprano" : `The cadence is authentic, but ${imperfectReason(facts)}`
-    });
-  }
-  if (facts.type === "half" && facts.minor && facts.fromOffset === 5) {
-    out.push({
-      label: "phrygian",
-      reason: "The dominant is approached from the subdominant, but the bass does not fall a semitone from the lowered submediant onto it"
-    });
-  }
-  if (facts.type === null && facts.onFifthDegree && facts.fromOffset !== facts.toOffset) {
-    out.push({
-      label: "half",
-      reason: "The arrival stands on the fifth degree, but a half cadence rests on the dominant the key has: the major third, or the mode's own third where that dominant carries no leading tone"
-    });
-  }
-  return out;
-}
-function detectCadence(from, to, key, opts = {}) {
-  const { approach, ...rest } = opts;
-  return cadenceBetween(
-    _chunkUADYAYATcjs.toChordData.call(void 0, from),
-    _chunkUADYAYATcjs.toChordData.call(void 0, to),
-    _chunkUADYAYATcjs.toKeyScale.call(void 0, key),
-    approach === void 0 ? rest : { ...rest, approach: _chunkUADYAYATcjs.toChordData.call(void 0, approach) }
-  );
-}
-function cadenceBetween(from, to, key, opts = {}) {
-  const [fromVoicing, toVoicing] = _nullishCoalesce(opts.voicing, () => ( []));
-  const fromOuter = outerPitches(_nullishCoalesce(fromVoicing, () => ( [])));
-  const toOuter = outerPitches(_nullishCoalesce(toVoicing, () => ( [])));
-  const fromBassPc = bassPcOf2(from, fromOuter.bass);
-  const toBassPc = bassPcOf2(to, toOuter.bass);
-  const toRootPosition = toBassPc === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, to.rootPc);
-  const rootPosition = fromBassPc === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, from.rootPc) && toRootPosition;
-  const soprano = toOuter.soprano === void 0 ? null : _chunkUADYAYATcjs.chordToneRole.call(void 0, toOuter.soprano, to);
-  const type = cadenceType(from, to, key, fromBassPc, toBassPc);
-  const leadingTone = isLeadingToneOf(from, key);
-  const facts = {
-    type,
-    strength: type === "authentic" ? authenticStrength(leadingTone, rootPosition, toOuter.soprano !== void 0, soprano) : null,
-    rootPosition,
-    // The dominant resolved, but onto an inverted tonic: the arrival the ear was
-    // promised is the one it does not get.
-    evaded: type === "authentic" && !toRootPosition,
-    leadingTone,
-    fromOffset: _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, from.rootPc - key.rootPc),
-    toOffset: _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc),
-    minor: isMinorScale(key),
-    onFifthDegree: _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc) === degreeOffset(DOMINANT_DEGREE, key),
-    sixFour: opts.approach !== void 0 && isCadentialSixFour(opts.approach, from, key),
-    withinSixFour: isCadentialSixFour(from, to, key)
-  };
-  const result = {
-    type: facts.type,
-    strength: facts.strength,
-    rootPosition: facts.rootPosition,
-    evaded: facts.evaded,
-    rationale: describeCadence(facts),
-    alternatives: opts.alternatives === true ? cadenceAlternatives(facts) : []
-  };
-  if (soprano !== null) {
-    result.soprano = soprano;
-  }
-  return result;
-}
-
-// 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" },
-  minMaj9: { lower: true, suffix: "maj9" },
-  minMaj11: { lower: true, suffix: "maj11" },
-  minMaj13: { lower: true, suffix: "maj13" },
-  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" },
-  "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(
-    ([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 (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
-  }
-  const glyphText = _nullishCoalesce(match[2], () => ( ""));
-  if (glyphText !== glyphText.toUpperCase() && glyphText !== glyphText.toLowerCase()) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`Roman numeral must use one case: ${text}`);
-  }
-  const accidental = match[1] === "b" ? -1 : match[1] === "#" ? 1 : 0;
-  const glyph = glyphText.toUpperCase();
-  const degreeNumber = ROMAN_TO_DEGREE[glyph];
-  if (degreeNumber === void 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
-  }
-  const isUpper = glyphText[0] === _optionalChain([glyphText, 'access', _ => _[0], 'optionalAccess', _2 => _2.toUpperCase, 'call', _3 => _3()]);
-  const suffix = _nullishCoalesce(match[3], () => ( ""));
-  const frame = romanReference(key);
-  const redundantFlat = accidental === -1 && loweredDegrees(frame).has(degreeNumber);
-  const diatonicRootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 
-    degreeRootPc(degreeNumber, frame) + (redundantFlat ? 0 : accidental)
-  );
-  const rootForQuality = (quality2) => accidental === 0 && degreeNumber === 7 && loweredDegrees(frame).has(7) && (quality2 === "dim" || quality2 === "dim7") ? _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, diatonicRootPc + 1) : diatonicRootPc;
-  const canonical = SUFFIX_QUALITY.get(`${isUpper ? "u" : "l"}:${suffix}`);
-  if (canonical !== void 0) {
-    return { rootPc: rootForQuality(canonical), quality: canonical, inversion: 0 };
-  }
-  const parsedSuffix = /^(o|°|dim|ø|\+|aug)?(maj7|M7)?(65|64|43|42|7|6|2)?$/.exec(suffix);
-  if (!parsedSuffix) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`Unsupported suffix "${suffix}" in Roman numeral: ${text}`);
-  }
-  const qualityMarker = _nullishCoalesce(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 = _nullishCoalesce(parsedSuffix[3], () => ( ""));
-  if (figures !== "" && !INVERSION_FIGURES.has(figures)) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-      `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: rootForQuality(quality), quality, inversion };
-}
-var NEAPOLITAN_SIXTH = "N6";
-function chromaticSymbolChord(text, key) {
-  if (text === NEAPOLITAN_SIXTH) {
-    const rootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc + 1);
-    return _chunkUADYAYATcjs.makeChord.call(void 0, rootPc, "maj", _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, rootPc + 4));
-  }
-  return augmentedSixthFromSymbol(text, key);
-}
-function chordFromParsed(parsed) {
-  const chord = _chunkUADYAYATcjs.makeChord.call(void 0, parsed.rootPc, parsed.quality);
-  if (parsed.inversion > 0 && parsed.inversion < chord.intervals.length) {
-    chord.bassPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, parsed.rootPc + (_nullishCoalesce(chord.intervals[parsed.inversion], () => ( 0))));
-  }
-  return chord;
-}
-function romanToChord(text, key) {
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const trimmed = text.trim().replace(/(\d)\/(?=\d)/g, "$1");
-  const slash = trimmed.indexOf("/");
-  if (slash >= 0) {
-    const applied = trimmed.slice(0, slash);
-    const target = trimmed.slice(slash + 1);
-    const targetRoot = parseSimpleRoman(target, scale).rootPc;
-    const localKey = _chunkUADYAYATcjs.majorKey.call(void 0, targetRoot);
-    return _nullishCoalesce(chromaticSymbolChord(applied, localKey), () => ( chordFromParsed(parseSimpleRoman(applied, localKey))));
-  }
-  return _nullishCoalesce(chromaticSymbolChord(trimmed, scale), () => ( chordFromParsed(parseSimpleRoman(trimmed, scale))));
-}
-function romanStyle(quality) {
-  return ROMAN_STYLE[quality];
-}
-function romanSpelling(rootPc, key) {
-  const tones = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, romanReference(key));
-  const diatonic = tones.indexOf(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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) && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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 (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) - 1) === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, rootPc)) {
-      return { degreeNumber: degreeNumber2, accidental: "b" };
-    }
-  }
-  for (let i = 0; i < tones.length; i += 1) {
-    if (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, rootPc)) {
-      return { degreeNumber: i + 1, accidental: "#" };
-    }
-  }
-  const [degreeNumber, accidental] = _nullishCoalesce(OFFSET_SPELLING[_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, rootPc - key.rootPc)], () => ( [1, ""]));
-  return { degreeNumber, accidental };
-}
-function seventhDegreeAccidental(accidental, degreeNumber, quality, key) {
-  if (degreeNumber !== 7 || quality !== "dim" && quality !== "dim7" || !loweredDegrees(romanReference(key)).has(7)) {
-    return accidental;
-  }
-  if (accidental === "#") {
-    return "";
-  }
-  return accidental === "" ? "b" : 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 numeralFor(degreeNumber, lower) {
-  const glyph = ROMAN[degreeNumber - 1];
-  if (glyph === void 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`no Roman numeral for scale degree ${degreeNumber}`);
-  }
-  return lower ? glyph.toLowerCase() : glyph;
-}
-var LEADING_TONE_QUALITIES = /* @__PURE__ */ new Set(["dim", "dim7", "m7b5"]);
-function degreeTriad(tones, index) {
-  const root = _nullishCoalesce(tones[index], () => ( 0));
-  return {
-    third: _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[(index + 2) % tones.length], () => ( 0))) - root),
-    fifth: _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, (_nullishCoalesce(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 = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, 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 !== 7) {
-      continue;
-    }
-    const expectedRoot = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, targetRoot + (dominant ? 7 : -1));
-    if (expectedRoot === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc)) {
-      return { degreeNumber: index + 1, rootPc: targetRoot, lower: triad.third === 3 };
-    }
-  }
-  return null;
-}
-function chordToRoman(chord, key, opts = {}) {
-  return renderRoman(_chunkUADYAYATcjs.toChordData.call(void 0, chord), _chunkUADYAYATcjs.toKeyScale.call(void 0, key), opts).roman;
-}
-function renderRoman(chord, key, opts) {
-  const augmented = augmentedSixthSymbol(chord, key);
-  if (augmented !== null) {
-    return { roman: augmented, derivation: { kind: "augmentedSixth" } };
-  }
-  if (opts.applied === true && !isDiatonicChord(chord, key)) {
-    const target = appliedTarget(chord, key);
-    if (target !== null) {
-      const local = renderRoman(chord, _chunkUADYAYATcjs.majorKey.call(void 0, target.rootPc), {}).roman;
-      const numeral = numeralFor(target.degreeNumber, target.lower);
-      return {
-        roman: `${local}/${numeral}`,
-        derivation: { kind: "applied", target: numeral }
-      };
-    }
-  }
-  const { degreeNumber, accidental: spelledAccidental } = romanSpelling(chord.rootPc, key);
-  const { lower, suffix } = romanStyle(chord.quality);
-  const cased = numeralFor(degreeNumber, lower);
-  const accidental = seventhDegreeAccidental(spelledAccidental, degreeNumber, chord.quality, key);
-  let inversion = 0;
-  let bass = "root";
-  if (chord.bassPc !== void 0) {
-    const idx = chord.intervals.findIndex((iv) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc + iv) === chord.bassPc);
-    if (idx > 0) {
-      inversion = idx;
-    } else if (idx < 0) {
-      bass = "foreign";
-    }
-  }
-  if (opts.neapolitan === true && inversion === 1 && isNeapolitan(chord, key)) {
-    return { roman: NEAPOLITAN_SIXTH, derivation: { kind: "neapolitan" } };
-  }
-  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 {
-        roman: `${accidental}${cased}${baseMarker(chord.quality)}${figure}`,
-        derivation: {
-          kind: "degree",
-          degreeNumber,
-          accidental,
-          quality: chord.quality,
-          bass: "figured",
-          figure
-        }
-      };
-    }
-    bass = "unfigurable";
-  }
-  return {
-    roman: `${accidental}${cased}${suffix}`,
-    derivation: { kind: "degree", degreeNumber, accidental, quality: chord.quality, bass }
-  };
-}
-var DEGREE_NAMES = ["first", "second", "third", "fourth", "fifth", "sixth", "seventh"];
-function describeDegree(degreeNumber, accidental) {
-  const name = _nullishCoalesce(DEGREE_NAMES[degreeNumber - 1], () => ( `${degreeNumber}th`));
-  if (accidental === "") {
-    return `the root is the ${name} degree of the key`;
-  }
-  const direction = accidental === "b" ? "lowered" : "raised";
-  return `the root is chromatic, spelled as the ${name} degree ${direction} a semitone`;
-}
-function describeBass(bass, figure) {
-  switch (bass) {
-    case "root":
-      return "and the chord stands on its own root";
-    case "figured":
-      return figure === void 0 ? "and the bass is an inversion" : `and the bass is an inversion, figured ${figure}`;
-    case "unfigurable":
-      return "and the bass names no lossless figure for this quality, so the numeral is written in root position";
-    case "foreign":
-      return "and the bass is not a chord tone, so the numeral names the upper chord alone";
-  }
-}
-var SIX_FOUR_NOTE = "; on the dominant bass this chord is heard as a double appoggiatura over the dominant rather than as a tonic of its own, which only the chords around it settle";
-function describeRoman(roman, derivation) {
-  switch (derivation.kind) {
-    case "augmentedSixth":
-      return `${roman}: an augmented sixth, which no numeral spells, standing on the lowered submediant`;
-    case "applied":
-      return `${roman}: an applied chord, named in the local key its target degree ${derivation.target} makes a tonic`;
-    case "neapolitan":
-      return `${roman}: the first-inversion Neapolitan under its figured name, the chord bII6 also spells`;
-    case "degree": {
-      const text = `${roman}: ${describeDegree(derivation.degreeNumber, derivation.accidental)}, the case and suffix come from the ${derivation.quality} quality, ${describeBass(derivation.bass, derivation.figure)}`;
-      const tonicSixFour = derivation.degreeNumber === 1 && derivation.accidental === "" && derivation.figure === "64";
-      return tonicSixFour ? `${text}${SIX_FOUR_NOTE}` : text;
-    }
-  }
-}
-function romanAlternatives(chord, key, opts) {
-  const emitted = renderRoman(chord, key, opts).roman;
-  const out = [];
-  const flippedApplied = renderRoman(chord, key, {
-    ...opts,
-    applied: opts.applied !== true
-  }).roman;
-  if (flippedApplied !== emitted) {
-    out.push({
-      label: flippedApplied,
-      reason: opts.applied === true ? "Naming the root against the home key is always a correct spelling; `applied` asked for the tonicizing reading instead" : "Whether a chromatic dominant is genuinely applied is a reading only the caller can make, so the root is named against the home key unless `applied` asks otherwise"
-    });
-  }
-  const flippedNeapolitan = renderRoman(chord, key, {
-    ...opts,
-    neapolitan: opts.neapolitan !== true
-  }).roman;
-  if (flippedNeapolitan !== emitted) {
-    out.push({
-      label: flippedNeapolitan,
-      reason: "Both spellings name the same chord, so which one to write is a house-style choice `neapolitan` settles"
-    });
-  }
-  return out;
-}
-function explainRoman(chord, key, opts = {}) {
-  const data = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const { roman, derivation } = renderRoman(data, scale, opts);
-  return {
-    roman,
-    rationale: describeRoman(roman, derivation),
-    alternatives: opts.alternatives === true ? romanAlternatives(data, scale, opts) : []
-  };
-}
-
-// src/analyze/functional/rationale.ts
-function capitalize(text) {
-  return text.charAt(0).toUpperCase() + text.slice(1);
-}
-
-// 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
-];
-var MINOR_FUNCTION_BY_OFFSET = [
-  "tonic",
-  "subdominant",
-  "subdominant",
-  "tonic",
-  "dominant",
-  "subdominant",
-  "dominant",
-  "dominant",
-  "tonic",
-  "tonic",
-  "subdominant",
-  "dominant"
-];
-function isMinorKey(key) {
-  return isMinorScale(_chunkUADYAYATcjs.toKeyScale.call(void 0, key));
-}
-function functionOf(chord, key) {
-  return functionWithReason(_chunkUADYAYATcjs.toChordData.call(void 0, chord), _chunkUADYAYATcjs.toKeyScale.call(void 0, key)).function;
-}
-function degreeFunction(chord, key) {
-  const functions = isMinorScale(key) ? MINOR_FUNCTION_BY_OFFSET : FUNCTION_BY_OFFSET;
-  return _nullishCoalesce(functions[_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc)], () => ( "tonic"));
-}
-function functionWithReason(chord, key) {
-  const offset = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc);
-  if (isNeapolitan(chord, key)) {
-    return { function: "subdominant", reason: "neapolitan" };
-  }
-  if (augmentedSixthKindOf(chord, key) !== null) {
-    return { function: "subdominant", reason: "augmentedSixth" };
-  }
-  if (isAppliedDominant(chord, key)) {
-    return { function: "dominant", reason: "applied" };
-  }
-  if (!isMinorScale(key) && hasMajorThird(chord) && (offset === 8 || offset === 10)) {
-    return { function: "subdominant", reason: "flatSideMajor" };
-  }
-  return { function: degreeFunction(chord, key), reason: "degree" };
-}
-function isAppliedDominant(chord, key) {
-  if (isDiatonicChord(chord, key)) {
-    return false;
-  }
-  const root = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc);
-  const resolvesTo = (step) => _chunkUADYAYATcjs.isScaleTone.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, root + step), key);
-  if (isAppliedDominantSonority(chord)) {
-    return chord.quality === "maj" ? resolvesTo(5) : resolvesTo(5) || resolvesTo(11);
-  }
-  return isDiminishedQuality(chord.quality) && resolvesTo(1);
-}
-var FUNCTION_REASON_PHRASE = {
-  neapolitan: "the Neapolitan, an altered predominant on the lowered second degree",
-  augmentedSixth: "an augmented sixth, an altered predominant resolving outward onto the dominant",
-  applied: "an applied dominant sonority resolving onto a diatonic degree",
-  flatSideMajor: "a major triad on the flat side, the borrowed cadence chord"
-};
-var BORROWED_SOURCE_PHRASE = {
-  parallelMinor: "borrowed from the parallel minor",
-  parallelMajor: "borrowed from the parallel major",
-  neapolitan: "belonging to neither parallel mode"
-};
-function describeChord(fn, reason, roman, source) {
-  const head = reason === "degree" ? `${capitalize(fn)}: ${roman} takes the ${fn} function of its degree in the key` : `${capitalize(fn)}: ${roman} is ${FUNCTION_REASON_PHRASE[reason]}`;
-  return source === null || reason === "neapolitan" ? head : `${head}, ${BORROWED_SOURCE_PHRASE[source]}`;
-}
-function functionAlternatives(chord, key, reason, accepted) {
-  const out = [];
-  if (reason === "degree") {
-    if (isAppliedDominantSonority(chord) && isDiatonicChord(chord, key)) {
-      out.push({
-        label: "applied dominant",
-        reason: "The chord is diatonic to the key, so it keeps the function of its degree rather than tonicizing another"
-      });
-    }
-  } else {
-    const byDegree = degreeFunction(chord, key);
-    if (byDegree !== accepted) {
-      out.push({
-        label: `${byDegree} by scale degree`,
-        reason: `The degree the root stands on reads as ${byDegree}, but the chord is ${FUNCTION_REASON_PHRASE[reason]}`
-      });
-    }
-  }
-  if (augmentedSixthKindOf(chord, key) === "german") {
-    out.push({
-      label: "tritone substitute",
-      reason: "The German sixth sounds a dominant seventh, but the lowered submediant under it fixes the reading as an augmented sixth"
-    });
-  }
-  return out;
-}
-function isDiatonic(chord, key) {
-  return isDiatonicChord(_chunkUADYAYATcjs.toChordData.call(void 0, chord), _chunkUADYAYATcjs.toKeyScale.call(void 0, key));
-}
-function parallelKey(key) {
-  return parallelScale(_chunkUADYAYATcjs.toKeyScale.call(void 0, key));
-}
-function isDiminishedQuality(quality) {
-  return quality === "dim" || quality === "dim7" || quality === "m7b5";
-}
-function analyzeChord(chord, key, opts = {}) {
-  const data = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const source = borrowedSourceOf(data, scale);
-  const { function: fn, reason } = functionWithReason(data, scale);
-  const roman = renderRoman(data, scale, opts).roman;
-  return {
-    function: fn,
-    borrowed: source !== null,
-    source,
-    roman,
-    rationale: describeChord(fn, reason, roman, source),
-    alternatives: opts.alternatives === true ? [
-      ...functionAlternatives(data, scale, reason, fn),
-      ...romanAlternatives(data, scale, opts)
-    ] : []
-  };
-}
-function secondaryDominant(targetDegree, key) {
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const degreeCount = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, scale).length;
-  _chunkQ2WGKJNNcjs.assertInteger.call(void 0, targetDegree, "targetDegree", 1, degreeCount);
-  const targetRoot = degreeRootPc(targetDegree, scale);
-  return _chunkUADYAYATcjs.makeChord.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, targetRoot + 7), "dom7");
-}
-function secondaryDominantOf(target) {
-  const data = _chunkUADYAYATcjs.toChordData.call(void 0, target);
-  _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, data.rootPc, "target chord rootPc");
-  const dominant = _chunkUADYAYATcjs.makeChord.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, data.rootPc + 7), "dom7");
-  if (data.rootSpelling !== void 0) {
-    const moved = _chunkQ2WGKJNNcjs.transposeNote.call(void 0, data.rootSpelling, 7);
-    dominant.rootSpelling = { letter: moved.letter, alter: moved.alter };
-  }
-  return dominant;
-}
-
-// src/analyze/functional/pivot.ts
-var HEPTATONIC_DEGREES = 7;
-function pivotChords(from, to) {
-  return pivotsBetween(_chunkUADYAYATcjs.toKeyScale.call(void 0, from), _chunkUADYAYATcjs.toKeyScale.call(void 0, to));
-}
-function pivotsBetween(from, to) {
-  if (_chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, from).length !== HEPTATONIC_DEGREES) {
-    return [];
-  }
-  const pivots = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (let degree = 1; degree <= HEPTATONIC_DEGREES; degree += 1) {
-    const chord = stackedTriad(degree, from);
-    if (chord === null || !isDiatonicChord(chord, to)) {
-      continue;
-    }
-    const identity = `${chord.rootPc}:${chord.quality}`;
-    if (seen.has(identity)) {
-      continue;
-    }
-    seen.add(identity);
-    pivots.push({
-      chord,
-      romanFrom: renderRoman(chord, from, {}).roman,
-      romanTo: renderRoman(chord, to, {}).roman
-    });
-  }
-  return pivots;
-}
-function stackedTriad(degree, key) {
-  try {
-    return _chunkUADYAYATcjs.diatonicTriad.call(void 0, degree, key);
-  } catch (error) {
-    if (error instanceof _chunkQ2WGKJNNcjs.InvalidInputError) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.MODAL_SCALE_NAMES = MODAL_SCALE_NAMES; exports.resolveKeyProfile = resolveKeyProfile; exports.profileScore = profileScore; exports.detectChord = detectChord; exports.detectChordBest = detectChordBest; exports.detectKey = detectKey; exports.detectKeyFromNotes = detectKeyFromNotes; exports.detectKeyBest = detectKeyBest; exports.augmentedSixthChord = augmentedSixthChord; exports.augmentedSixthKind = augmentedSixthKind; exports.augmentedSixthFromPitchClasses = augmentedSixthFromPitchClasses; exports.spellAugmentedSixth = spellAugmentedSixth; exports.isBorrowedChord = isBorrowedChord; exports.borrowedSource = borrowedSource; exports.isCadentialSixFour = isCadentialSixFour; exports.detectCadence = detectCadence; exports.romanToChord = romanToChord; exports.chordToRoman = chordToRoman; exports.explainRoman = explainRoman; exports.isMinorKey = isMinorKey; exports.functionOf = functionOf; exports.isDiatonic = isDiatonic; exports.parallelKey = parallelKey; exports.analyzeChord = analyzeChord; exports.secondaryDominant = secondaryDominant; exports.secondaryDominantOf = secondaryDominantOf; exports.pivotChords = pivotChords;
-//# sourceMappingURL=chunk-OE6WK2Y2.cjs.map