@libraz/libcantus 1.0.1 → 1.2.0

package/dist/chunk-SGLEQVJH.cjs

@@ -0,0 +1,3329 @@
+"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 _chunk35NBV2FTcjs = require('./chunk-35NBV2FT.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk3R3QVKY5cjs = require('./chunk-3R3QVKY5.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkS5BKZZGMcjs = require('./chunk-S5BKZZGM.cjs');
+
+// src/analyze/detect/modes.ts
+var MODAL_CANDIDATES = Object.freeze([
+  { scaleName: "dorian", mode: "minor", mask: _chunk3R3QVKY5cjs.DORIAN_MASK, substitutions: [[8, 9]] },
+  { scaleName: "phrygian", mode: "minor", mask: _chunk3R3QVKY5cjs.PHRYGIAN_MASK, substitutions: [[2, 1]] },
+  { scaleName: "lydian", mode: "major", mask: _chunk3R3QVKY5cjs.LYDIAN_MASK, substitutions: [[5, 6]] },
+  { scaleName: "mixolydian", mode: "major", mask: _chunk3R3QVKY5cjs.MIXOLYDIAN_MASK, substitutions: [[11, 10]] },
+  {
+    scaleName: "locrian",
+    mode: "minor",
+    mask: _chunk3R3QVKY5cjs.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, _chunkS5BKZZGMcjs.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, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `unknown mode '${String(name)}'; expected one of ${MODAL_SCALE_NAMES.join(", ")}`
+      );
+    }
+  }
+  return MODAL_CANDIDATES.filter((candidate) => requested.has(candidate.scaleName));
+}
+
+// src/analyze/adjacency.ts
+var HUMANIZE_ADJACENCY = 0.05;
+function sameInstant(beat, other) {
+  return Math.abs(beat - other) <= _chunkS5BKZZGMcjs.BEAT_EPS;
+}
+function adjacent(prevEnd, nextStart) {
+  return Math.abs(nextStart - prevEnd) <= HUMANIZE_ADJACENCY;
+}
+function hasEnded(prevEnd, beat) {
+  return prevEnd <= beat + HUMANIZE_ADJACENCY;
+}
+
+// src/analyze/histogram.ts
+var MAX_VELOCITY = 127;
+var ACCENT_DIVISOR = 3;
+function noteWeight(note, beats, meter) {
+  const velocityFactor = note.velocity !== void 0 ? note.velocity / MAX_VELOCITY : 1;
+  const accent = meter === void 0 ? 1 : 1 + _chunkS5BKZZGMcjs.metricWeight.call(void 0, note.startBeat, meter) / ACCENT_DIVISOR;
+  return beats * velocityFactor * accent;
+}
+function bucketNotesBySlot(notes, grid, slotCount, opts) {
+  const buckets = Array.from({ length: slotCount }, () => []);
+  let memberships = 0;
+  for (const note of notes) {
+    const first = Math.max(0, Math.floor((note.startBeat - grid.origin) / grid.slotBeats));
+    const lastExclusive = Math.min(
+      slotCount,
+      Math.ceil((note.startBeat + note.durationBeat - grid.origin) / grid.slotBeats)
+    );
+    memberships += Math.max(0, lastExclusive - first);
+    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, memberships, opts.name, opts.budget);
+    for (let slot = first; slot < lastExclusive; slot += 1) {
+      _optionalChain([buckets, 'access', _2 => _2[slot], 'optionalAccess', _3 => _3.push, 'call', _4 => _4(note)]);
+    }
+  }
+  return buckets;
+}
+function windowWeights(notes, windowStart, windowEnd, meter) {
+  const weights = new Array(12).fill(0);
+  let lowestPitch = Number.POSITIVE_INFINITY;
+  for (const note of notes) {
+    const noteEnd = note.startBeat + note.durationBeat;
+    const overlap = Math.min(noteEnd, windowEnd) - Math.max(note.startBeat, windowStart);
+    if (overlap <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+      continue;
+    }
+    const onsetInWindow = note.startBeat >= windowStart - _chunkS5BKZZGMcjs.BEAT_EPS && note.startBeat < windowEnd - _chunkS5BKZZGMcjs.BEAT_EPS;
+    const pc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, note.pitch);
+    const weight = noteWeight(note, overlap, onsetInWindow ? meter : void 0);
+    weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + weight;
+    if (weight > _chunkS5BKZZGMcjs.BEAT_EPS && note.pitch < lowestPitch) {
+      lowestPitch = note.pitch;
+    }
+  }
+  let totalWeight = 0;
+  let maxWeight = 0;
+  for (const w of weights) {
+    totalWeight += w;
+    maxWeight = Math.max(maxWeight, w);
+  }
+  return { weights, totalWeight, maxWeight, lowestPitch };
+}
+
+// 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, _chunkS5BKZZGMcjs.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, _chunkS5BKZZGMcjs.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, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `unknown key profile '${profile}'; expected one of ${Object.keys(NAMED_PROFILES).join(", ")}`
+      );
+    }
+    return named;
+  }
+  if (typeof profile !== "object" || profile === null) {
+    throw new (0, _chunkS5BKZZGMcjs.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, _chunkS5BKZZGMcjs.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(_chunkS5BKZZGMcjs.pitchClassOf))].sort((a, b) => a - b);
+}
+function assertPitches(pitches, name, budget = void 0) {
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, pitches, name);
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, pitches.length, name, budget);
+  for (let index = 0; index < pitches.length; index += 1) {
+    _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, _nullishCoalesce(pitches[index], () => ( Number.NaN)), `pitches[${index}]`);
+  }
+}
+function detectChord(pitches, opts = {}) {
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  assertPitches(pitches, "chord detection pitches");
+  if (asked.bassPc !== void 0) _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, asked.bassPc, "bassPc");
+  const input = uniquePitchClasses(pitches);
+  if (input.length === 0) {
+    return [];
+  }
+  const inputKind = asked.input === void 0 || asked.input === "auto" ? pitches.every((pitch) => Number.isInteger(pitch) && pitch >= 0 && pitch <= 11) ? "pitchClass" : "midi" : asked.input;
+  const bassPc = asked.bassPc !== void 0 ? _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, asked.bassPc) : inputKind === "midi" ? _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitches.reduce((lowest, pitch) => Math.min(lowest, pitch), Infinity)) : void 0;
+  const inputSet = new Set(input);
+  const matches = [];
+  const qualities = _chunk3R3QVKY5cjs.chordQualities.call(void 0, );
+  const toneCounts = new Map(
+    qualities.map((quality) => [quality, _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, 0, quality)).length])
+  );
+  const qualityRank = new Map(qualities.map((quality, index) => [quality, index]));
+  for (const rootPc of input) {
+    for (const quality of qualities) {
+      const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, quality);
+      const tones = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord);
+      const toneSet = new Set(tones);
+      const missingPcs = tones.filter((pc) => !inputSet.has(pc));
+      const fifthPc = _chunkS5BKZZGMcjs.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) => _chunkS5BKZZGMcjs.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));
+    if (aSize !== bSize) {
+      return bSize - aSize;
+    }
+    const aRank = _nullishCoalesce(qualityRank.get(a.quality), () => ( qualities.length));
+    const bRank = _nullishCoalesce(qualityRank.get(b.quality), () => ( qualities.length));
+    if (aRank !== bRank) {
+      return aRank - bRank;
+    }
+    return a.rootPc - b.rootPc;
+  });
+  return matches;
+}
+function detectChordBest(pitches, opts = {}) {
+  const best = detectChord(pitches, opts)[0];
+  if (!best) {
+    return null;
+  }
+  return _chunk3R3QVKY5cjs.makeChord.call(void 0, best.rootPc, best.quality, best.bassPc);
+}
+var MINOR_VARIANTS = [
+  { variant: "natural", mask: _chunk3R3QVKY5cjs.NATURAL_MINOR_MASK, scaleName: "naturalMinor" },
+  { variant: "harmonic", mask: _chunk3R3QVKY5cjs.HARMONIC_MINOR_MASK, scaleName: "harmonicMinor" },
+  { variant: "melodic", mask: _chunk3R3QVKY5cjs.MELODIC_MINOR_MASK, scaleName: "melodicMinor" }
+];
+var MAJOR_VARIANTS = [
+  { variant: "major", mask: _chunk3R3QVKY5cjs.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 = _chunkS5BKZZGMcjs.formatNote.call(void 0, _chunk3R3QVKY5cjs.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 = {}) {
+  const asked = _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "opts");
+  assertPitches(pitches, "key detection pitches", asked.budget);
+  const weights = asked.weights;
+  if (weights !== void 0 && weights.length !== pitches.length) {
+    throw new (0, _chunkS5BKZZGMcjs.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));
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, weight, `weights[${index}]`);
+    if (weight <= 0) {
+      continue;
+    }
+    const pc = _chunkS5BKZZGMcjs.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;
+}
+function detectKeyFromNotes(notes, opts = {}) {
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "key detection notes", {
+    allowNonPositiveDuration: true,
+    budget: asked.budget
+  });
+  const sounding = notes.filter((note) => note.durationBeat > 0);
+  return detectKey(
+    sounding.map((note) => note.pitch),
+    {
+      weights: sounding.map((note) => noteWeight(note, note.durationBeat)),
+      profile: asked.profile,
+      modes: asked.modes,
+      explain: asked.explain,
+      budget: asked.budget
+    }
+  );
+}
+function detectKeyBest(pitches, opts = {}) {
+  return _nullishCoalesce(detectKey(pitches, opts)[0], () => ( null));
+}
+
+// src/analyze/functional/internal.ts
+function isMinorScale(key) {
+  return _chunk3R3QVKY5cjs.isMinorMask.call(void 0, key.modeMask12);
+}
+function parallelScale(key) {
+  return {
+    rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc),
+    modeMask12: isMinorScale(key) ? _chunk3R3QVKY5cjs.MAJOR_MASK : _chunk3R3QVKY5cjs.NATURAL_MINOR_MASK
+  };
+}
+function degreeRootPc(degreeNumber, key) {
+  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, key);
+  if (tones.length === 0) {
+    return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
+  }
+  const index = ((degreeNumber - 1) % tones.length + tones.length) % tones.length;
+  return _nullishCoalesce(tones[index], () => ( _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc)));
+}
+function loweredDegrees(key) {
+  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, key);
+  const out = /* @__PURE__ */ new Set();
+  if (tones.length !== 7) {
+    return out;
+  }
+  const major = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, { rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunk3R3QVKY5cjs.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 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, majorTone - tone) === 1) {
+      out.add(index + 1);
+    }
+  }
+  return out;
+}
+function romanReference(key) {
+  return _chunk3R3QVKY5cjs.heptatonicFrameOf.call(void 0, key);
+}
+
+// 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) => _chunkS5BKZZGMcjs.parseInterval.call(void 0, name)),
+  french: ["P1", "M3", "A4", "A6"].map((name) => _chunkS5BKZZGMcjs.parseInterval.call(void 0, name)),
+  german: ["P1", "M3", "P5", "A6"].map((name) => _chunkS5BKZZGMcjs.parseInterval.call(void 0, name))
+};
+var BASS_INTERVAL = _chunkS5BKZZGMcjs.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 _chunkS5BKZZGMcjs.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, key);
+}
+function augmentedSixthOn(kind, keyLike) {
+  const checked = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
+  const shape = CHORD_SHAPE[checked];
+  const { scale: key, tonic } = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
+  const bassPc = bassPcOf(key);
+  const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, bassPc + shape.rootAboveBass), shape.quality, bassPc);
+  chord.intervals = [...shape.intervals];
+  const bass = _chunkS5BKZZGMcjs.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(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, bass + tone)))) {
+      return kind;
+    }
+  }
+  return null;
+}
+function spellingId(note) {
+  return `${_chunkS5BKZZGMcjs.diatonicLetterOf.call(void 0, note.letter)}:${note.alter}`;
+}
+function spellsAugmentedSixth(chord, kind, key) {
+  const tonic = key.tonic;
+  const written = new Set(_chunk3R3QVKY5cjs.spellChord.call(void 0, chord, tonic, key.scale).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(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), key);
+}
+function augmentedSixthKindOf(chord, keyLike) {
+  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
+  const bass = bassPcOf(resolved.scale);
+  if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== bass) {
+    return null;
+  }
+  const kind = kindOfPitchClasses(new Set(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord)), bass);
+  if (kind === null || !spellsAugmentedSixth(chord, kind, resolved)) {
+    return null;
+  }
+  return kind;
+}
+function augmentedSixthFromPitchClasses(pcs, bassPc, key) {
+  return augmentedSixthOverBass(_chunkS5BKZZGMcjs.assertArray.call(void 0, pcs, "pcs"), bassPc, key);
+}
+function augmentedSixthOverBass(pcs, bassPc, keyLike) {
+  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
+  const bass = bassPcOf(resolved.scale);
+  if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, bassPc) !== bass) {
+    return null;
+  }
+  const kind = kindOfPitchClasses(new Set(pcs.map(_chunkS5BKZZGMcjs.pitchClassOf)), bass);
+  return kind === null ? null : augmentedSixthOn(kind, resolved);
+}
+function spellAugmentedSixth(kind, tonic) {
+  return spelledFromTonic(kind, _chunkS5BKZZGMcjs.toNoteData.call(void 0, tonic));
+}
+function spelledFromTonic(kind, tonic) {
+  const checked = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
+  const bass = _chunkS5BKZZGMcjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
+  return SPELLED_ABOVE_BASS[checked].map((interval) => _chunkS5BKZZGMcjs.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/cadence.ts
+var SUBDOMINANT_DEGREE = 4;
+var DOMINANT_DEGREE = 5;
+var SUBMEDIANT_DEGREE = 6;
+function degreeOffset(degreeNumber, key) {
+  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, degreeRootPc(degreeNumber, romanReference(key)) - key.rootPc);
+}
+function thirdBelongsToKey(chord, key) {
+  return chord.intervals.some(
+    (interval) => (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, interval) === 3 || _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, interval) === 4) && _chunk3R3QVKY5cjs.isScaleTone.call(void 0, _chunkS5BKZZGMcjs.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 (_chunk3R3QVKY5cjs.hasMajorThird.call(void 0, to) || _chunk3R3QVKY5cjs.isDominantChordOf.call(void 0, to, key)) {
+    return true;
+  }
+  if (_chunk3R3QVKY5cjs.scaleSystemOf.call(void 0, key) !== "modal") {
+    return false;
+  }
+  const dominantPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc + degreeOffset(DOMINANT_DEGREE, key));
+  const leadingToneDominant = _chunk3R3QVKY5cjs.isScaleTone.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, dominantPc + 4), key);
+  return !leadingToneDominant && thirdBelongsToKey(to, key);
+}
+function isTonicSixFour(chord, key) {
+  if (_chunkS5BKZZGMcjs.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) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, interval) === 7);
+  return isTriad && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.bassPc - chord.rootPc) === 7;
+}
+function isCadentialSixFour(chord, next, key) {
+  return isTonicSixFour(chord, key) && _chunk3R3QVKY5cjs.isDominantChordOf.call(void 0, next, key) && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) === _chunkS5BKZZGMcjs.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 _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(_nullishCoalesce(voicedBass, () => ( chord.bassPc)), () => ( chord.rootPc)));
+}
+function cadenceType(from, to, key, fromBassPc, toBassPc) {
+  const tonic = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
+  const fromOffset = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, from.rootPc - tonic);
+  const toOffset = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, to.rootPc - tonic);
+  const dominant = _chunk3R3QVKY5cjs.isDominantChordOf.call(void 0, from, key);
+  if ((dominant || _chunk3R3QVKY5cjs.isLeadingToneChordOf.call(void 0, from, key)) && toOffset === 0) {
+    return "authentic";
+  }
+  if (fromOffset === degreeOffset(SUBDOMINANT_DEGREE, key) && toOffset === 0) {
+    return "plagal";
+  }
+  if (fromOffset === 10 && toOffset === 0 && _chunk3R3QVKY5cjs.hasMajorThird.call(void 0, 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 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, fromBassPc - tonic) === 8 && _chunkS5BKZZGMcjs.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.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 = facts.withinSixFour ? "Half cadence: the motion comes to rest on the dominant, which the tonic six-four standing on its bass was already sounding" : "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 } = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  return cadenceBetween(
+    _chunk3R3QVKY5cjs.toChordData.call(void 0, from),
+    _chunk3R3QVKY5cjs.toChordData.call(void 0, to),
+    _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key),
+    approach === void 0 ? rest : { ...rest, approach: _chunk3R3QVKY5cjs.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 === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, to.rootPc);
+  const rootPosition = fromBassPc === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, from.rootPc) && toRootPosition;
+  const soprano = toOuter.soprano === void 0 ? null : _chunk3R3QVKY5cjs.chordToneRole.call(void 0, toOuter.soprano, to);
+  const type = cadenceType(from, to, key, fromBassPc, toBassPc);
+  const leadingTone = _chunk3R3QVKY5cjs.isLeadingToneChordOf.call(void 0, 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: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, from.rootPc - key.rootPc),
+    toOffset: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc),
+    minor: isMinorScale(key),
+    onFifthDegree: _chunkS5BKZZGMcjs.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/borrowed.ts
+function isMinorScaleAlteration(chord, key) {
+  if (!isMinorScale(key)) return false;
+  const alteredKey = { rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunk3R3QVKY5cjs.HARMONIC_MINOR_MASK };
+  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, alteredKey)) return true;
+  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 11 && _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, { rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunk3R3QVKY5cjs.MELODIC_MINOR_MASK });
+}
+function isBorrowed(chord, key) {
+  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
+    return false;
+  }
+  if (_chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
+    return true;
+  }
+  if (isMinorScaleAlteration(chord, key)) {
+    return false;
+  }
+  return _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, parallelScale(key));
+}
+function borrowedSourceOf(chord, key) {
+  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
+    return null;
+  }
+  if (_chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) return "neapolitan";
+  if (isBorrowed(chord, key)) {
+    return isMinorScale(key) ? "parallelMajor" : "parallelMinor";
+  }
+  return null;
+}
+function isBorrowedChord(chord, key) {
+  return isBorrowed(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+}
+function borrowedSource(chord, key) {
+  return borrowedSourceOf(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+}
+
+// src/analyze/functional/tonicization.ts
+function isTonicizableRoot(rootPc, key) {
+  return _chunk3R3QVKY5cjs.tonicizableDegrees.call(void 0, key).some((degree) => degree.rootPc === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc));
+}
+function appliedTarget(chord, key) {
+  const dominant = _chunk3R3QVKY5cjs.hasDominantSonority.call(void 0, chord);
+  const leadingTone = _chunk3R3QVKY5cjs.LEADING_TONE_QUALITIES.has(chord.quality);
+  if (!dominant && !leadingTone) {
+    return null;
+  }
+  return _chunk3R3QVKY5cjs.appliedDominantTarget.call(void 0, chord.rootPc + (dominant ? 5 : 1), key);
+}
+function isAppliedDominant(chord, key) {
+  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
+    return false;
+  }
+  const source = borrowedSourceOf(chord, key);
+  if (source === "parallelMajor" || source === "parallelMinor") {
+    return false;
+  }
+  return pointsAtTonicizableDegree(chord, key);
+}
+function pointsAtTonicizableDegree(chord, key) {
+  if (appliedTarget(chord, key) !== null) {
+    return true;
+  }
+  return _chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, chord) && isTonicizableRoot(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - 1), key);
+}
+
+// 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, _chunkS5BKZZGMcjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
+  }
+  const glyphText = _nullishCoalesce(match[2], () => ( ""));
+  if (glyphText !== glyphText.toUpperCase() && glyphText !== glyphText.toLowerCase()) {
+    throw new (0, _chunkS5BKZZGMcjs.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, _chunkS5BKZZGMcjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
+  }
+  const isUpper = glyphText[0] === _optionalChain([glyphText, 'access', _5 => _5[0], 'optionalAccess', _6 => _6.toUpperCase, 'call', _7 => _7()]);
+  const suffix = _nullishCoalesce(match[3], () => ( ""));
+  const frame = romanReference(key);
+  const redundantFlat = accidental === -1 && loweredDegrees(frame).has(degreeNumber);
+  const diatonicRootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 
+    degreeRootPc(degreeNumber, frame) + (redundantFlat ? 0 : accidental)
+  );
+  const rootForQuality = (quality2) => accidental === 0 && degreeNumber === 7 && loweredDegrees(frame).has(7) && _chunk3R3QVKY5cjs.LEADING_TONE_QUALITIES.has(quality2) ? _chunkS5BKZZGMcjs.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, _chunkS5BKZZGMcjs.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, _chunkS5BKZZGMcjs.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 = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.scale.rootPc + 1);
+    return _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, "maj", _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + 4));
+  }
+  return augmentedSixthFromSymbol(text, key);
+}
+function tonicizedKey(targetRoot, key) {
+  return _chunk3R3QVKY5cjs.resolveKey.call(void 0, {
+    scale: _chunk3R3QVKY5cjs.majorKey.call(void 0, targetRoot),
+    tonic: _chunk3R3QVKY5cjs.spellPitchClass.call(void 0, targetRoot, key.tonic, key.scale)
+  });
+}
+function augmentedSixthTarget(chord, key) {
+  if (_chunk3R3QVKY5cjs.chordToneSpellings.call(void 0, chord) === void 0) {
+    return null;
+  }
+  for (const degree of _chunk3R3QVKY5cjs.tonicizableDegrees.call(void 0, key.scale)) {
+    if (degree.degreeNumber === 1) {
+      continue;
+    }
+    if (augmentedSixthSymbol(chord, tonicizedKey(degree.rootPc, key)) !== null) {
+      return degree;
+    }
+  }
+  return null;
+}
+function chordFromParsed(parsed) {
+  const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, parsed.rootPc, parsed.quality);
+  if (parsed.inversion > 0 && parsed.inversion < chord.intervals.length) {
+    chord.bassPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, parsed.rootPc + (_nullishCoalesce(chord.intervals[parsed.inversion], () => ( 0))));
+  }
+  return chord;
+}
+function romanToChord(text, key) {
+  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, key);
+  const scale = resolved.scale;
+  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 = tonicizedKey(targetRoot, resolved);
+    return _nullishCoalesce(chromaticSymbolChord(applied, localKey), () => ( chordFromParsed(parseSimpleRoman(applied, localKey.scale))));
+  }
+  return _nullishCoalesce(chromaticSymbolChord(trimmed, resolved), () => ( chordFromParsed(parseSimpleRoman(trimmed, scale))));
+}
+function romanStyle(quality) {
+  return ROMAN_STYLE[quality];
+}
+function romanSpelling(rootPc, key) {
+  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, romanReference(key));
+  const diatonic = tones.indexOf(_chunkS5BKZZGMcjs.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) && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkS5BKZZGMcjs.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 (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) - 1) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc)) {
+      return { degreeNumber: degreeNumber2, accidental: "b" };
+    }
+  }
+  for (let i = 0; i < tones.length; i += 1) {
+    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc)) {
+      return { degreeNumber: i + 1, accidental: "#" };
+    }
+  }
+  const [degreeNumber, accidental] = _nullishCoalesce(OFFSET_SPELLING[_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc - key.rootPc)], () => ( [1, ""]));
+  return { degreeNumber, accidental };
+}
+function seventhDegreeAccidental(accidental, degreeNumber, quality, key) {
+  if (degreeNumber !== 7 || !_chunk3R3QVKY5cjs.LEADING_TONE_QUALITIES.has(quality) || !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, _chunkS5BKZZGMcjs.InvalidInputError)(`no Roman numeral for scale degree ${degreeNumber}`);
+  }
+  return lower ? glyph.toLowerCase() : glyph;
+}
+function chordToRoman(chord, key, opts = {}) {
+  return renderRoman(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), key, _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts")).roman;
+}
+function renderRoman(chord, keyLike, opts) {
+  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
+  const key = resolved.scale;
+  const augmented = augmentedSixthSymbol(chord, resolved);
+  if (augmented !== null) {
+    return { roman: augmented, derivation: { kind: "augmentedSixth" } };
+  }
+  if (opts.applied === true) {
+    const target = _nullishCoalesce(augmentedSixthTarget(chord, resolved), () => ( (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key) ? null : appliedTarget(chord, key))));
+    if (target !== null) {
+      const local = renderRoman(chord, tonicizedKey(target.rootPc, resolved), {}).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) => _chunkS5BKZZGMcjs.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 && _chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, 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,
+          literalAccidental: spelledAccidental,
+          quality: chord.quality,
+          bass: "figured",
+          figure
+        }
+      };
+    }
+    bass = "unfigurable";
+  }
+  return {
+    roman: `${accidental}${cased}${suffix}`,
+    derivation: {
+      kind: "degree",
+      degreeNumber,
+      accidental,
+      literalAccidental: spelledAccidental,
+      quality: chord.quality,
+      bass
+    }
+  };
+}
+var DEGREE_NAMES = ["first", "second", "third", "fourth", "fifth", "sixth", "seventh"];
+function describeDegree(degreeNumber, accidental, literal) {
+  const name = _nullishCoalesce(DEGREE_NAMES[degreeNumber - 1], () => ( `${degreeNumber}th`));
+  if (accidental !== literal) {
+    return literal === "" ? `the root is the ${name} degree of the key, written with a flat because the bare numeral is reserved by convention for the raised leading tone above it` : `the root is the raised leading tone, a semitone above the ${name} degree of the key, which the bare numeral denotes by convention`;
+  }
+  if (literal === "") {
+    return `the root is the ${name} degree of the key`;
+  }
+  const direction = literal === "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, derivation.literalAccidental)}, 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 asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const { roman, derivation } = renderRoman(data, key, asked);
+  return {
+    roman,
+    rationale: describeRoman(roman, derivation),
+    alternatives: asked.alternatives === true ? romanAlternatives(data, key, asked) : []
+  };
+}
+
+// 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",
+  // 0  i
+  "subdominant",
+  // 1  bII (Neapolitan)
+  "subdominant",
+  // 2  iio
+  "tonic",
+  // 3  III
+  "tonic",
+  // 4  #III, the chromatic mediant
+  "subdominant",
+  // 5  iv
+  "dominant",
+  // 6  #iv / bv
+  "dominant",
+  // 7  V
+  "tonic",
+  // 8  VI
+  "tonic",
+  // 9  #VI
+  "subdominant",
+  // 10 VII
+  "dominant"
+  // 11 viio
+];
+function isMinorKey(key) {
+  return isMinorScale(_chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+}
+function functionOf(chord, key) {
+  return functionWithReason(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key)).function;
+}
+function degreeFunction(chord, key) {
+  const functions = isMinorScale(key) ? MINOR_FUNCTION_BY_OFFSET : FUNCTION_BY_OFFSET;
+  return _nullishCoalesce(functions[_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc)], () => ( "tonic"));
+}
+function functionWithReason(chord, key) {
+  const offset = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc);
+  if (_chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, 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) && !_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key) && _chunk3R3QVKY5cjs.hasMajorThird.call(void 0, chord) && (offset === 8 || offset === 10)) {
+    return { function: "subdominant", reason: "flatSideMajor" };
+  }
+  return { function: degreeFunction(chord, key), reason: "degree" };
+}
+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 (pointsAtTonicizableDegree(chord, key) && _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, 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 _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, _chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+}
+function parallelKey(key) {
+  return parallelScale(_chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+}
+function analyzeChord(chord, key, opts = {}) {
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
+  const source = borrowedSourceOf(data, scale);
+  const { function: fn, reason } = functionWithReason(data, scale);
+  const roman = renderRoman(data, scale, asked).roman;
+  return {
+    function: fn,
+    borrowed: source !== null,
+    source,
+    roman,
+    rationale: describeChord(fn, reason, roman, source),
+    alternatives: asked.alternatives === true ? [
+      ...functionAlternatives(data, scale, reason, fn),
+      ...romanAlternatives(data, scale, asked)
+    ] : []
+  };
+}
+function secondaryDominant(targetDegree, key) {
+  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
+  const degreeCount = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, scale).length;
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, targetDegree, "targetDegree", 1, degreeCount);
+  const targetRoot = degreeRootPc(targetDegree, scale);
+  return _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, targetRoot + 7), "dom7");
+}
+function secondaryDominantOf(target) {
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, target);
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, data.rootPc, "target chord rootPc");
+  const dominant = _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, data.rootPc + 7), "dom7");
+  if (data.rootSpelling !== void 0) {
+    const moved = _chunkS5BKZZGMcjs.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(_chunk3R3QVKY5cjs.toKeyScale.call(void 0, from), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, to));
+}
+function pivotsBetween(from, to) {
+  if (_chunk3R3QVKY5cjs.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 || !_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, 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 _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, key);
+  } catch (error) {
+    if (error instanceof _chunkS5BKZZGMcjs.InvalidInputError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// src/analyze/form/internal.ts
+function clamp01(value) {
+  return Math.min(1, Math.max(0, value));
+}
+function floorMod(value, modulus) {
+  return (value % modulus + modulus) % modulus;
+}
+function firstSoundingBeat(notes, fallback = 0) {
+  let first = Number.POSITIVE_INFINITY;
+  for (const note of notes) {
+    first = Math.min(first, note.startBeat);
+  }
+  return Number.isFinite(first) ? first : fallback;
+}
+function lastBarOf(meter, spanStart, spanEnd) {
+  const firstBar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, spanStart, meter);
+  const bar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, Math.max(spanStart, spanEnd), meter);
+  if (bar > firstBar && _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter) >= spanEnd - _chunkS5BKZZGMcjs.BEAT_EPS) {
+    return bar - 1;
+  }
+  return bar;
+}
+function sliceBars(notes, meter, spanStart, spanEnd, budget) {
+  const firstBar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, spanStart, meter);
+  const lastBar = lastBarOf(meter, spanStart, spanEnd);
+  const barCount = lastBar - firstBar + 1;
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, barCount, "form bars", budget);
+  const buckets = Array.from({ length: barCount }, () => []);
+  let memberships = 0;
+  for (const note of notes) {
+    const noteEnd = note.startBeat + note.durationBeat;
+    const from = Math.max(firstBar, _chunkS5BKZZGMcjs.barIndexAt.call(void 0, note.startBeat, meter));
+    const to = Math.min(lastBar, _chunkS5BKZZGMcjs.barIndexAt.call(void 0, Math.max(note.startBeat, noteEnd - _chunkS5BKZZGMcjs.BEAT_EPS), meter));
+    memberships += Math.max(0, to - from + 1);
+    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, memberships, "form note-to-bar memberships", budget);
+    for (let bar = from; bar <= to; bar += 1) {
+      _optionalChain([buckets, 'access', _8 => _8[bar - firstBar], 'optionalAccess', _9 => _9.push, 'call', _10 => _10(note)]);
+    }
+  }
+  const slices = [];
+  for (let bar = firstBar; bar <= lastBar; bar += 1) {
+    const startBeat = _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter);
+    const endBeat = _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar: bar + 1, beat: 0 }, meter);
+    const barNotes = _nullishCoalesce(buckets[bar - firstBar], () => ( []));
+    const { weights, totalWeight } = windowWeights(barNotes, startBeat, endBeat, meter);
+    slices.push({ index: bar, startBeat, endBeat, notes: barNotes, weights, totalWeight });
+  }
+  return slices;
+}
+function weightSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    const x = _nullishCoalesce(a[i], () => ( 0));
+    const y = _nullishCoalesce(b[i], () => ( 0));
+    dot += x * y;
+    normA += x * x;
+    normB += y * y;
+  }
+  if (normA <= _chunkS5BKZZGMcjs.BEAT_EPS && normB <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+    return 1;
+  }
+  if (normA <= _chunkS5BKZZGMcjs.BEAT_EPS || normB <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+    return 0;
+  }
+  return clamp01(dot / Math.sqrt(normA * normB));
+}
+function harmonicNovelty(slices, index) {
+  const current = slices[index];
+  if (current === void 0) {
+    return 0;
+  }
+  const previous = slices[index - 1];
+  if (previous === void 0) {
+    return current.index >= 0 ? 1 : 0;
+  }
+  return 1 - weightSimilarity(previous.weights, current.weights);
+}
+function combineEvidence(strengths) {
+  let remaining = 1;
+  for (const strength of strengths) {
+    remaining *= 1 - clamp01(strength);
+  }
+  return clamp01(1 - remaining);
+}
+
+// src/analyze/grid.ts
+function gridOriginOf(firstOnset, slotBeats) {
+  const startBeat = firstOnset < 0 && firstOnset > -HUMANIZE_ADJACENCY ? 0 : firstOnset;
+  return { origin: Math.floor(startBeat / slotBeats + _chunkS5BKZZGMcjs.BEAT_EPS) * slotBeats, startBeat };
+}
+function gridForNotes(notes, slotBeats) {
+  return gridOriginOf(firstSoundingBeat(notes), slotBeats);
+}
+function barGridStart(firstOnset, meter) {
+  return gridOriginOf(firstOnset, _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, firstOnset, meter)).startBeat;
+}
+
+// src/analyze/keys/index.ts
+var PITCH_CLASSES = 12;
+var EMPTY_WEIGHTS = {
+  weights: new Array(PITCH_CLASSES).fill(0),
+  totalWeight: 0,
+  maxWeight: 0,
+  lowestPitch: Number.POSITIVE_INFINITY
+};
+var MAX_METRIC_WEIGHT = 3;
+var MODULATION_COST = 0.15;
+var PAST_CONTEXT_SHARE = 0.5;
+var FUTURE_CONTEXT_SHARE = 0.25;
+var STRONG_BEAT_DISCOUNT = 0.4;
+var FIFTHS_DISTANCE_COST = 0.18;
+var KEY_CANDIDATES = (() => {
+  const candidates = [];
+  for (let rootPc = 0; rootPc < 12; rootPc += 1) {
+    candidates.push({ key: _chunk3R3QVKY5cjs.majorKey.call(void 0, rootPc), rootPc, minor: false });
+    candidates.push({ key: _chunk3R3QVKY5cjs.minorKey.call(void 0, rootPc), rootPc, minor: true });
+  }
+  return candidates;
+})();
+function fifthsOf(rootPc, minor) {
+  const majorRoot = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, minor ? rootPc + 3 : rootPc);
+  const raw = majorRoot * 7 % 12;
+  return raw > 6 ? raw - 12 : raw;
+}
+function fifthsDistance(a, b) {
+  const diff = Math.abs(a - b) % 12;
+  return Math.min(diff, 12 - diff);
+}
+var CANDIDATE_DISTANCE = KEY_CANDIDATES.map(
+  (from) => KEY_CANDIDATES.map(
+    (to) => fifthsDistance(fifthsOf(from.rootPc, from.minor), fifthsOf(to.rootPc, to.minor))
+  )
+);
+function chooseKeys(slots, changeCost, meter, budget) {
+  const count = KEY_CANDIDATES.length;
+  if (slots.length === 0) {
+    return [];
+  }
+  const back = _chunkS5BKZZGMcjs.allocateChoiceTable.call(void 0, slots.length, count, "key search choices", budget);
+  let costs = _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 1, count, "key search costs", budget);
+  let spare = _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 1, count, "key search costs", budget);
+  const opening = _nullishCoalesce(_optionalChain([slots, 'access', _11 => _11[0], 'optionalAccess', _12 => _12.scores]), () => ( []));
+  for (let c = 0; c < count; c += 1) {
+    costs[c] = -(_nullishCoalesce(opening[c], () => ( 0)));
+  }
+  for (let i = 1; i < slots.length; i += 1) {
+    const slot = slots[i];
+    const previous = costs;
+    const next = spare;
+    const accent = _chunkS5BKZZGMcjs.metricWeight.call(void 0, _nullishCoalesce(_optionalChain([slot, 'optionalAccess', _13 => _13.startBeat]), () => ( 0)), meter);
+    const metricFactor = 1 - STRONG_BEAT_DISCOUNT * accent / MAX_METRIC_WEIGHT;
+    const rowBase = i * count;
+    for (let to = 0; to < count; to += 1) {
+      let best2 = _nullishCoalesce(previous[to], () => ( Number.POSITIVE_INFINITY));
+      let bestFrom = to;
+      for (let from = 0; from < count; from += 1) {
+        if (from === to) {
+          continue;
+        }
+        const distance = _nullishCoalesce(_optionalChain([CANDIDATE_DISTANCE, 'access', _14 => _14[from], 'optionalAccess', _15 => _15[to]]), () => ( 0));
+        const penalty = changeCost * metricFactor * (1 + FIFTHS_DISTANCE_COST * distance);
+        const cost = (_nullishCoalesce(previous[from], () => ( Number.POSITIVE_INFINITY))) + penalty;
+        if (cost < best2) {
+          best2 = cost;
+          bestFrom = from;
+        }
+      }
+      back[rowBase + to] = bestFrom;
+      next[to] = best2 - (_nullishCoalesce(_optionalChain([slot, 'optionalAccess', _16 => _16.scores, 'access', _17 => _17[to]]), () => ( 0)));
+    }
+    costs = next;
+    spare = previous;
+  }
+  let best = 0;
+  for (let c = 1; c < count; c += 1) {
+    if ((_nullishCoalesce(costs[c], () => ( Number.POSITIVE_INFINITY))) < (_nullishCoalesce(costs[best], () => ( Number.POSITIVE_INFINITY)))) {
+      best = c;
+    }
+  }
+  const path = new Array(slots.length);
+  let current = best;
+  for (let i = slots.length - 1; i >= 0; i -= 1) {
+    path[i] = current;
+    if (i > 0) {
+      current = _nullishCoalesce(back[i * count + current], () => ( current));
+    }
+  }
+  return path;
+}
+function regionsFromPath(slots, path) {
+  const regions = [];
+  for (let i = 0; i < slots.length; i += 1) {
+    const last = regions[regions.length - 1];
+    const slot = slots[i];
+    if (slot === void 0) {
+      continue;
+    }
+    if (last !== void 0 && last.candidate === path[i]) {
+      last.endBeat = slot.endBeat;
+      last.toExclusive = i + 1;
+      continue;
+    }
+    regions.push({
+      startBeat: slot.startBeat,
+      endBeat: slot.endBeat,
+      candidate: _nullishCoalesce(path[i], () => ( 0)),
+      from: i,
+      toExclusive: i + 1
+    });
+  }
+  return regions;
+}
+function enforceMinimumRegion(slots, path, minBeats, budget) {
+  const chosen = [...path];
+  const initial = regionsFromPath(slots, chosen);
+  if (initial.length < 2) {
+    return chosen;
+  }
+  const candidates = KEY_CANDIDATES.length;
+  const totals = _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, slots.length, candidates, "key region scores", budget);
+  for (let i = 0; i < slots.length; i += 1) {
+    const scores = _nullishCoalesce(_optionalChain([slots, 'access', _18 => _18[i], 'optionalAccess', _19 => _19.scores]), () => ( []));
+    const base = i * candidates;
+    const previous = base - candidates;
+    for (let c = 0; c < candidates; c += 1) {
+      totals[base + c] = (i === 0 ? 0 : _nullishCoalesce(totals[previous + c], () => ( 0))) + (_nullishCoalesce(scores[c], () => ( 0)));
+    }
+  }
+  const scoreOver = (region, candidate) => (_nullishCoalesce(totals[(region.toExclusive - 1) * candidates + candidate], () => ( 0))) - (region.from === 0 ? 0 : _nullishCoalesce(totals[(region.from - 1) * candidates + candidate], () => ( 0)));
+  const nodes = initial.map(
+    (region) => ({ ...region, previous: void 0, next: void 0, merged: false })
+  );
+  for (let i = 0; i < nodes.length; i += 1) {
+    const node = nodes[i];
+    if (node === void 0) {
+      continue;
+    }
+    node.previous = nodes[i - 1];
+    node.next = nodes[i + 1];
+  }
+  const pending = new RegionHeap();
+  for (const node of nodes) {
+    pending.push(node);
+  }
+  for (; ; ) {
+    const region = pending.pop();
+    if (region === void 0) {
+      return chosen;
+    }
+    const length = region.endBeat - region.startBeat;
+    if (region.merged || length >= minBeats - _chunkS5BKZZGMcjs.BEAT_EPS) {
+      continue;
+    }
+    const previous = region.previous;
+    const next = region.next;
+    const before = previous !== void 0 && Math.abs(previous.endBeat - region.startBeat) < _chunkS5BKZZGMcjs.BEAT_EPS ? previous : void 0;
+    const after = next !== void 0 && Math.abs(next.startBeat - region.endBeat) < _chunkS5BKZZGMcjs.BEAT_EPS ? next : void 0;
+    if (before === void 0 && after === void 0) {
+      continue;
+    }
+    const left = _optionalChain([before, 'optionalAccess', _20 => _20.candidate]);
+    const right = _optionalChain([after, 'optionalAccess', _21 => _21.candidate]);
+    const winner = left === void 0 ? _nullishCoalesce(right, () => ( region.candidate)) : right === void 0 || scoreOver(region, left) >= scoreOver(region, right) ? left : right;
+    for (let i = region.from; i < region.toExclusive; i += 1) {
+      chosen[i] = winner;
+    }
+    region.candidate = winner;
+    let grown = region;
+    if (previous !== void 0 && previous.candidate === winner) {
+      grown = absorbNext(previous);
+    }
+    if (_optionalChain([grown, 'access', _22 => _22.next, 'optionalAccess', _23 => _23.candidate]) === winner) {
+      grown = absorbNext(grown);
+    }
+    pending.push(grown);
+  }
+}
+function absorbNext(region) {
+  const next = region.next;
+  if (next === void 0) {
+    return region;
+  }
+  region.endBeat = next.endBeat;
+  region.toExclusive = next.toExclusive;
+  region.next = next.next;
+  if (next.next !== void 0) {
+    next.next.previous = region;
+  }
+  next.merged = true;
+  return region;
+}
+var RegionHeap = class _RegionHeap {
+  #entries = [];
+  push(region) {
+    const entries = this.#entries;
+    entries.push({ region, length: region.endBeat - region.startBeat });
+    let index = entries.length - 1;
+    while (index > 0) {
+      const parent = index - 1 >> 1;
+      if (!_RegionHeap.#before(entries[index], entries[parent])) {
+        break;
+      }
+      _RegionHeap.#swap(entries, index, parent);
+      index = parent;
+    }
+  }
+  /** The shortest region still worth merging, skipping entries since spent. */
+  pop() {
+    const entries = this.#entries;
+    for (; ; ) {
+      const top = entries[0];
+      if (top === void 0) {
+        return void 0;
+      }
+      const last = entries.pop();
+      if (entries.length > 0 && last !== void 0) {
+        entries[0] = last;
+        this.#sink();
+      }
+      if (!top.region.merged && top.region.endBeat - top.region.startBeat === top.length) {
+        return top.region;
+      }
+    }
+  }
+  #sink() {
+    const entries = this.#entries;
+    let index = 0;
+    for (; ; ) {
+      const left = index * 2 + 1;
+      const right = left + 1;
+      let smallest = index;
+      if (left < entries.length && _RegionHeap.#before(entries[left], entries[smallest])) {
+        smallest = left;
+      }
+      if (right < entries.length && _RegionHeap.#before(entries[right], entries[smallest])) {
+        smallest = right;
+      }
+      if (smallest === index) {
+        return;
+      }
+      _RegionHeap.#swap(entries, index, smallest);
+      index = smallest;
+    }
+  }
+  static #before(a, b) {
+    if (a === void 0 || b === void 0) {
+      return a !== void 0;
+    }
+    return a.length === b.length ? a.region.from < b.region.from : a.length < b.length;
+  }
+  static #swap(entries, a, b) {
+    const left = entries[a];
+    const right = entries[b];
+    if (left !== void 0 && right !== void 0) {
+      entries[a] = right;
+      entries[b] = left;
+    }
+  }
+};
+function withRelations(regions) {
+  for (let i = 1; i < regions.length; i += 1) {
+    const previous = regions[i - 1];
+    const current = regions[i];
+    if (previous === void 0 || current === void 0) {
+      continue;
+    }
+    const relation = _chunk3R3QVKY5cjs.keyRelationBetween.call(void 0, previous.key, current.key);
+    if (relation !== null && relation !== "same") {
+      current.modulation = relation;
+    }
+  }
+  return regions;
+}
+function keyTimelineFromNotes(notes, opts = {}) {
+  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "key timeline meters");
+  const bar = _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, 0, meters);
+  const expectedKeyBeats = _nullishCoalesce(opts.expectedKeyBeats, () => ( bar * 4));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
+  const minKeyBeats = _nullishCoalesce(opts.minKeyBeats, () => ( bar));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
+  const budget = opts.budget;
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "key timeline notes", { allowNonPositiveDuration: true, budget });
+  const sounding = notes.filter((note) => note.durationBeat > 0);
+  const lastEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
+  const totalBeats = _nullishCoalesce(opts.totalBeats, () => ( lastEnd));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "key timeline totalBeats");
+  const slotBeats = Math.min(minKeyBeats, expectedKeyBeats);
+  const { origin, startBeat: musicStart } = gridForNotes(sounding, slotBeats);
+  const slotCount = Math.max(0, Math.ceil((totalBeats - origin) / slotBeats - _chunkS5BKZZGMcjs.BEAT_EPS));
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, slotCount * KEY_CANDIDATES.length, "key timeline slots", budget);
+  if (slotCount === 0 || sounding.length === 0) {
+    return [];
+  }
+  const profile = resolveKeyProfile(opts.profile);
+  const slotNotes = bucketNotesBySlot(sounding, { origin, slotBeats }, slotCount, {
+    name: "key timeline note-to-slot memberships",
+    budget
+  });
+  const slotWeights = [];
+  for (let i = 0; i < slotCount; i += 1) {
+    const startBeat = origin + i * slotBeats;
+    slotWeights.push(
+      windowWeights(
+        _nullishCoalesce(slotNotes[i], () => ( [])),
+        startBeat,
+        Math.min(startBeat + slotBeats, totalBeats),
+        meters
+      )
+    );
+  }
+  const slots = [];
+  let weightSum = 0;
+  let soundingSlots = 0;
+  for (let i = 0; i < slotCount; i += 1) {
+    const startBeat = origin + i * slotBeats;
+    const endBeat = Math.min(startBeat + slotBeats, totalBeats);
+    const own = _nullishCoalesce(slotWeights[i], () => ( EMPTY_WEIGHTS));
+    const before = _nullishCoalesce(slotWeights[i - 1], () => ( EMPTY_WEIGHTS));
+    const after = _nullishCoalesce(slotWeights[i + 1], () => ( EMPTY_WEIGHTS));
+    const weights = own.weights.map(
+      (weight, pc) => weight + PAST_CONTEXT_SHARE * (_nullishCoalesce(before.weights[pc], () => ( 0))) + FUTURE_CONTEXT_SHARE * (_nullishCoalesce(after.weights[pc], () => ( 0)))
+    );
+    const totalWeight = own.totalWeight;
+    const scores = KEY_CANDIDATES.map(
+      (candidate) => profileScore(weights, candidate.minor ? profile.minor : profile.major, candidate.rootPc) * totalWeight
+    );
+    slots.push({ startBeat, endBeat, scores, weight: totalWeight });
+    if (totalWeight > _chunkS5BKZZGMcjs.BEAT_EPS) {
+      weightSum += totalWeight;
+      soundingSlots += 1;
+    }
+  }
+  if (soundingSlots === 0) {
+    return [];
+  }
+  const meanSlotWeight = weightSum / soundingSlots;
+  const changeCost = MODULATION_COST * meanSlotWeight * (expectedKeyBeats / slotBeats);
+  const path = chooseKeys(slots, changeCost, meters, budget);
+  const grouped = regionsFromPath(slots, path);
+  const head = grouped[0];
+  const next = grouped[1];
+  if (head !== void 0 && next !== void 0 && head.endBeat - Math.max(head.startBeat, musicStart) < slotBeats - _chunkS5BKZZGMcjs.BEAT_EPS) {
+    next.startBeat = head.startBeat;
+    next.from = head.from;
+    grouped.shift();
+  }
+  const regions = grouped.map((region) => {
+    const candidate = KEY_CANDIDATES[region.candidate];
+    const key = _chunk3R3QVKY5cjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _24 => _24.key]), () => ( _chunk3R3QVKY5cjs.majorKey.call(void 0, 0))));
+    const startBeat = Math.max(region.startBeat, musicStart);
+    const weights = new Array(PITCH_CLASSES).fill(0);
+    for (let i = region.from; i < region.toExclusive; i += 1) {
+      const slot = slotWeights[i];
+      if (slot === void 0) {
+        continue;
+      }
+      for (let pc = 0; pc < PITCH_CLASSES; pc += 1) {
+        weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + (_nullishCoalesce(slot.weights[pc], () => ( 0)));
+      }
+    }
+    const correlation = profileScore(
+      weights,
+      _optionalChain([candidate, 'optionalAccess', _25 => _25.minor]) ? profile.minor : profile.major,
+      _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _26 => _26.rootPc]), () => ( 0))
+    );
+    return {
+      startBeat,
+      endBeat: region.endBeat,
+      key: _chunk3R3QVKY5cjs.resolveKey.call(void 0, key),
+      confidence: Math.max(0, correlation)
+    };
+  });
+  return withRelations(regions);
+}
+var CHORD_TONE_CREDIT = 1;
+var DOMINANT_CREDIT = 0.7;
+var TONIC_CREDIT = 0.4;
+var CADENCE_CREDIT = 0.6;
+var CHORD_MODULATION_COST = 0.6;
+function chordFitsKey(chord, candidate) {
+  const tones = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord);
+  if (tones.length === 0) {
+    return 0;
+  }
+  let inKey = 0;
+  for (const pc of tones) {
+    if (_chunk3R3QVKY5cjs.isScaleTone.call(void 0, pc, candidate.key)) {
+      inKey += 1;
+    }
+  }
+  let score = CHORD_TONE_CREDIT * ((inKey - (tones.length - inKey)) / tones.length);
+  const rootDegree = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - candidate.rootPc);
+  if (rootDegree === 7) {
+    if (_chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, chord)) {
+      score += DOMINANT_CREDIT;
+    } else if (chord.quality === "maj") {
+      score += DOMINANT_CREDIT * 0.5;
+    }
+  }
+  if (rootDegree === 0) {
+    score += TONIC_CREDIT;
+  }
+  return score;
+}
+function detectModulations(chords, opts = {}) {
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, chords, "modulation chord segments");
+  chords.forEach((segment, index) => {
+    _chunkS5BKZZGMcjs.assertRecord.call(void 0, segment, `modulation chord segments[${index}]`);
+  });
+  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "modulation meters");
+  const bar = _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, 0, meters);
+  const expectedKeyBeats = _nullishCoalesce(opts.expectedKeyBeats, () => ( bar * 4));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
+  const minKeyBeats = _nullishCoalesce(opts.minKeyBeats, () => ( bar));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
+    chords.length * KEY_CANDIDATES.length,
+    "modulation chord segments",
+    opts.budget
+  );
+  const sorted = [...chords].filter((segment) => segment.endBeat > segment.startBeat).sort((a, b) => a.startBeat - b.startBeat);
+  const lastChordEnd = sorted.reduce((end, segment) => Math.max(end, segment.endBeat), 0);
+  const totalBeats = _nullishCoalesce(opts.totalBeats, () => ( lastChordEnd));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "modulation totalBeats");
+  const ordered = sorted.map((segment) => ({ ...segment, endBeat: Math.min(segment.endBeat, totalBeats) })).filter((segment) => segment.endBeat > segment.startBeat);
+  if (ordered.length === 0) {
+    return [];
+  }
+  const slots = ordered.map((segment) => {
+    const length = segment.endBeat - segment.startBeat;
+    return {
+      startBeat: segment.startBeat,
+      endBeat: segment.endBeat,
+      // A chord that holds for two bars argues twice as hard as one that
+      // passes in half a bar, exactly as a heavier slot does in the note path.
+      scores: KEY_CANDIDATES.map((candidate) => chordFitsKey(segment.chord, candidate) * length),
+      weight: length
+    };
+  });
+  for (let i = 1; i < slots.length; i += 1) {
+    const arriving = _optionalChain([ordered, 'access', _27 => _27[i], 'optionalAccess', _28 => _28.chord]);
+    const approaching = _optionalChain([ordered, 'access', _29 => _29[i - 1], 'optionalAccess', _30 => _30.chord]);
+    const slot = slots[i];
+    if (arriving === void 0 || approaching === void 0 || slot === void 0) {
+      continue;
+    }
+    const isDominantMotion = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, approaching.rootPc - arriving.rootPc) === 7 && _chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, approaching);
+    if (!isDominantMotion) {
+      continue;
+    }
+    const length = slot.endBeat - slot.startBeat;
+    for (let c = 0; c < KEY_CANDIDATES.length; c += 1) {
+      const candidate = KEY_CANDIDATES[c];
+      if (candidate !== void 0 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, arriving.rootPc - candidate.rootPc) === 0) {
+        slot.scores[c] = (_nullishCoalesce(slot.scores[c], () => ( 0))) + CADENCE_CREDIT * length;
+      }
+    }
+  }
+  const changeCost = CHORD_MODULATION_COST * expectedKeyBeats;
+  const path = chooseKeys(slots, changeCost, meters, opts.budget);
+  const grouped = regionsFromPath(
+    slots,
+    enforceMinimumRegion(slots, path, Math.min(minKeyBeats, expectedKeyBeats), opts.budget)
+  );
+  const profile = resolveKeyProfile(opts.profile);
+  const regions = grouped.map((region) => {
+    const candidate = KEY_CANDIDATES[region.candidate];
+    const key = _chunk3R3QVKY5cjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _31 => _31.key]), () => ( _chunk3R3QVKY5cjs.majorKey.call(void 0, 0))));
+    const weights = new Array(PITCH_CLASSES).fill(0);
+    for (let i = region.from; i < region.toExclusive; i += 1) {
+      const segment = ordered[i];
+      if (segment === void 0) {
+        continue;
+      }
+      const overlap = segment.endBeat - segment.startBeat;
+      if (overlap <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+        continue;
+      }
+      for (const pc of _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, segment.chord)) {
+        weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + overlap;
+      }
+    }
+    const correlation = profileScore(
+      weights,
+      _optionalChain([candidate, 'optionalAccess', _32 => _32.minor]) ? profile.minor : profile.major,
+      _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _33 => _33.rootPc]), () => ( 0))
+    );
+    return {
+      startBeat: region.startBeat,
+      endBeat: region.endBeat,
+      key,
+      confidence: Math.max(0, correlation)
+    };
+  });
+  const last = regions[regions.length - 1];
+  if (last !== void 0 && totalBeats > last.endBeat) {
+    last.endBeat = totalBeats;
+  }
+  return attachPivots(withRelations(regions), ordered);
+}
+var THIRD_SEMITONES = [3, 4];
+var FIFTH_SEMITONES = [6, 7, 8];
+function triadCore(chord) {
+  const root = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc);
+  let third;
+  let fifth;
+  for (const interval of chord.intervals) {
+    if (interval < 0 || interval >= 12) {
+      continue;
+    }
+    if (third === void 0 && THIRD_SEMITONES.includes(interval)) {
+      third = interval;
+    } else if (fifth === void 0 && FIFTH_SEMITONES.includes(interval)) {
+      fifth = interval;
+    }
+  }
+  if (third === void 0 || fifth === void 0) {
+    return null;
+  }
+  return [root, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, root + third), _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, root + fifth)].sort((a, b) => a - b);
+}
+function lastChordFinishedBy(chords) {
+  const byEnd = chords.map((_, index) => index).sort((a, b) => (_nullishCoalesce(_optionalChain([chords, 'access', _34 => _34[a], 'optionalAccess', _35 => _35.endBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([chords, 'access', _36 => _36[b], 'optionalAccess', _37 => _37.endBeat]), () => ( 0))));
+  const latest = new Int32Array(byEnd.length);
+  let running = 0;
+  for (let i = 0; i < byEnd.length; i += 1) {
+    running = Math.max(running, _nullishCoalesce(byEnd[i], () => ( 0)));
+    latest[i] = running;
+  }
+  return (beat) => {
+    let low = 0;
+    let high = byEnd.length;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if ((_nullishCoalesce(_optionalChain([chords, 'access', _38 => _38[_nullishCoalesce(byEnd[mid], () => ( 0))], 'optionalAccess', _39 => _39.endBeat]), () => ( 0))) <= beat) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    return low === 0 ? void 0 : chords[_nullishCoalesce(latest[low - 1], () => ( 0))];
+  };
+}
+function sameTones(a, b) {
+  return a.length === b.length && a.every((pc, index) => pc === b[index]);
+}
+function attachPivots(regions, chords) {
+  if (regions.length < 2 || chords.length === 0) {
+    return regions;
+  }
+  const finished = lastChordFinishedBy(chords);
+  for (let i = 1; i < regions.length; i += 1) {
+    const previous = regions[i - 1];
+    const current = regions[i];
+    if (previous === void 0 || current === void 0) {
+      continue;
+    }
+    const last = finished(current.startBeat + _chunkS5BKZZGMcjs.BEAT_EPS);
+    if (last === void 0) {
+      continue;
+    }
+    const core = triadCore(last.chord);
+    if (core === null) {
+      continue;
+    }
+    const root = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, last.chord.rootPc);
+    const pivot = pivotChords(previous.key, current.key).find(
+      (entry) => entry.chord.rootPc === root && sameTones(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, entry.chord), core)
+    );
+    if (pivot !== void 0) {
+      current.pivot = pivot;
+    }
+  }
+  return regions;
+}
+function keyLookup(regions, fallback) {
+  return (beat) => {
+    let low = 0;
+    let high = regions.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if ((_nullishCoalesce(_optionalChain([regions, 'access', _40 => _40[middle], 'optionalAccess', _41 => _41.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
+        low = middle + 1;
+      } else {
+        high = middle;
+      }
+    }
+    const candidate = regions[low - 1];
+    return candidate !== void 0 && beat < candidate.endBeat ? candidate.key : fallback;
+  };
+}
+function prevailingKeyOf(regions) {
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, regions, "key regions");
+  const totals = /* @__PURE__ */ new Map();
+  for (const [index, given] of regions.entries()) {
+    const region = _chunkS5BKZZGMcjs.assertRecord.call(void 0, given, `key regions[${index}]`);
+    _chunkS5BKZZGMcjs.assertRecord.call(void 0, region.key, `key regions[${index}].key`);
+    const id = `${_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, region.key.scale.rootPc)}:${region.key.scale.modeMask12}`;
+    const entry = totals.get(id);
+    const length = Math.max(0, region.endBeat - region.startBeat);
+    if (entry === void 0) {
+      totals.set(id, { key: region.key, length });
+    } else {
+      entry.length += length;
+    }
+  }
+  let best = null;
+  let bestLength = -1;
+  for (const entry of totals.values()) {
+    if (entry.length > bestLength) {
+      bestLength = entry.length;
+      best = entry.key;
+    }
+  }
+  return best;
+}
+
+// src/analyze/voice/index.ts
+function keyScaleAt(key) {
+  if (typeof key === "function") {
+    return key;
+  }
+  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
+  return () => scale;
+}
+function toVoiceNotes(events) {
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, events, "voice notes", { allowNonPositiveDuration: true });
+  return events.map((event, index) => ({ ...event, id: index, originalIndex: index }));
+}
+function intervalAboveBass(pitch, others, chord) {
+  let bass = Number.POSITIVE_INFINITY;
+  for (const ov of others) {
+    bass = Math.min(bass, ov.pitch);
+  }
+  if (Number.isFinite(bass) && bass < pitch) {
+    return ((pitch - bass) % 12 + 12) % 12;
+  }
+  const ref = _nullishCoalesce(chord.bassPc, () => ( chord.rootPc));
+  return ((_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch) - _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, ref)) % 12 + 12) % 12;
+}
+var TENSION_DEGREE_BY_INTERVAL = {
+  1: 9,
+  2: 9,
+  3: 9,
+  5: 11,
+  6: 11,
+  8: 13,
+  9: 13
+};
+var NATURAL_TENSION_INTERVALS = /* @__PURE__ */ new Set([2, 5, 9]);
+function tensionDegree(ic) {
+  return TENSION_DEGREE_BY_INTERVAL[ic];
+}
+function asSounded(chord) {
+  if (chord.bassPc === void 0) {
+    return chord;
+  }
+  return { ...chord, intervals: [...chord.intervals, _chunk3R3QVKY5cjs.intervalAboveRoot.call(void 0, chord.bassPc, chord)] };
+}
+function isStep(a, b) {
+  const d = Math.abs(a - b);
+  return d === 1 || d === 2;
+}
+var LEAP_SEMITONES = 3;
+function suspensionType(ic, delta) {
+  if (delta > 0) {
+    return ic === 1 || ic === 2 ? "sus2-3" : null;
+  }
+  if (ic === 2) {
+    return "sus9-8";
+  }
+  if (ic === 10 || ic === 11) {
+    return "sus7-6";
+  }
+  if (ic === 5 || ic === 6) {
+    return "sus4-3";
+  }
+  if (ic === 8 || ic === 9) {
+    return "sus6-5";
+  }
+  return null;
+}
+var STEP_RESOLUTION = 2;
+var NEAREST_CHORD_TONE_REACH = 12;
+function nearestChordTone(pitch, chord, maxDistance) {
+  for (let delta = 1; delta <= maxDistance; delta += 1) {
+    if (_chunk3R3QVKY5cjs.isChordMember.call(void 0, pitch - delta, chord)) {
+      return pitch - delta;
+    }
+    if (_chunk3R3QVKY5cjs.isChordMember.call(void 0, pitch + delta, chord)) {
+      return pitch + delta;
+    }
+  }
+  return void 0;
+}
+function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, voice, "voice notes", { allowNonPositiveDuration: true });
+  _chunkS5BKZZGMcjs.assertFunction.call(void 0, chordAtBeat2, "chordAtBeat");
+  _chunkS5BKZZGMcjs.assertFunction.call(void 0, otherVoicesAtBeat, "otherVoicesAtBeat");
+  const keyAt = keyScaleAt(key);
+  const result = [];
+  for (let i = 0; i < voice.length; i += 1) {
+    const note = voice[i];
+    if (!note) {
+      continue;
+    }
+    const prevNote = i > 0 ? voice[i - 1] : void 0;
+    const nextNote = i + 1 < voice.length ? voice[i + 1] : void 0;
+    const prevEnd = prevNote === void 0 ? Number.NEGATIVE_INFINITY : prevNote.startBeat + prevNote.durationBeat;
+    const noteEnd = note.startBeat + note.durationBeat;
+    const prev = prevNote !== void 0 && adjacent(prevEnd, note.startBeat) ? prevNote : void 0;
+    const next = nextNote !== void 0 && adjacent(noteEnd, nextNote.startBeat) ? nextNote : void 0;
+    const chord = chordAtBeat2(note.startBeat);
+    const labels = [];
+    const member = _chunk3R3QVKY5cjs.isChordMember.call(void 0, note.pitch, chord);
+    let handled = false;
+    if (chord && member) {
+      const role = _chunk3R3QVKY5cjs.chordToneRole.call(void 0, note.pitch, chord);
+      const degree = role === null ? tensionDegree(_chunk3R3QVKY5cjs.intervalAboveRoot.call(void 0, note.pitch, chord)) : void 0;
+      if (role) {
+        labels.push({ kind: "chordTone", role });
+        handled = true;
+      } else if (degree !== void 0) {
+        labels.push({ kind: "tension", degree });
+        handled = true;
+      } else {
+        const bassRole = _chunk3R3QVKY5cjs.chordToneRole.call(void 0, note.pitch, asSounded(chord));
+        if (bassRole !== null) {
+          labels.push({ kind: "chordTone", role: bassRole });
+          handled = true;
+        }
+      }
+    }
+    if (!handled && chord && prev && next) {
+      const prevChord = chordAtBeat2(prev.startBeat);
+      const prepared = prev.pitch === note.pitch && _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, prevChord);
+      const resolves = isStep(next.pitch, note.pitch);
+      const others = otherVoicesAtBeat(note.startBeat);
+      const verticallyDissonant = others.some(
+        (ov) => _chunk3R3QVKY5cjs.createsVerticalDissonance.call(void 0, note.pitch, ov.pitch, true)
+      );
+      if (prepared && verticallyDissonant && resolves) {
+        const ic = intervalAboveBass(note.pitch, others, chord);
+        const type = suspensionType(ic, next.pitch - note.pitch);
+        if (type !== null) {
+          labels.push({ kind: "suspension", type, resolveTo: next.pitch });
+          handled = true;
+        }
+      }
+    }
+    if (!handled && chord && prev && next) {
+      const prevMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
+      const nextMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, next.pitch, chordAtBeat2(next.startBeat));
+      const up = note.pitch - prev.pitch > 0;
+      const contInto = next.pitch - note.pitch > 0;
+      const sameDir = note.pitch !== prev.pitch && next.pitch !== note.pitch && up === contInto;
+      if (prevMember && nextMember && !member && isStep(note.pitch, prev.pitch) && isStep(next.pitch, note.pitch) && sameDir) {
+        labels.push({ kind: "passing" });
+        handled = true;
+      }
+    }
+    if (!handled && chord && prev && next && !member && prev.pitch === next.pitch && _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat)) && isStep(note.pitch, prev.pitch)) {
+      labels.push({ kind: "neighbor" });
+      handled = true;
+    }
+    if (!handled && chord && next && !member && note.pitch === next.pitch) {
+      const nextChord = chordAtBeat2(next.startBeat);
+      if (_chunk3R3QVKY5cjs.isChordMember.call(void 0, next.pitch, nextChord)) {
+        labels.push({ kind: "anticipation" });
+        handled = true;
+      }
+    }
+    if (!handled && chord && prev && next && !member) {
+      const prevMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
+      const nextMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, next.pitch, chordAtBeat2(next.startBeat));
+      const leapFromPrev = Math.abs(note.pitch - prev.pitch) >= LEAP_SEMITONES;
+      const stepToNext = isStep(next.pitch, note.pitch);
+      const opposite = note.pitch - prev.pitch > 0 !== next.pitch - note.pitch > 0;
+      if (prevMember && nextMember && leapFromPrev && stepToNext && opposite) {
+        labels.push({ kind: "appoggiatura", resolveTo: next.pitch });
+        handled = true;
+      }
+    }
+    if (!handled && chord && prev && next && !member) {
+      const prevMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
+      const nextMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, next.pitch, chordAtBeat2(next.startBeat));
+      const stepFromPrev = isStep(note.pitch, prev.pitch);
+      const leapToNext = Math.abs(next.pitch - note.pitch) >= LEAP_SEMITONES;
+      const opposite = note.pitch - prev.pitch > 0 !== next.pitch - note.pitch > 0;
+      if (prevMember && nextMember && stepFromPrev && leapToNext && opposite) {
+        labels.push({ kind: "escape" });
+        handled = true;
+      }
+    }
+    if (!handled && chord && !member) {
+      const ic = _chunk3R3QVKY5cjs.intervalAboveRoot.call(void 0, note.pitch, chord);
+      const degree = tensionDegree(ic);
+      const colours = NATURAL_TENSION_INTERVALS.has(ic) || chord.intervals.some((i2) => i2 === 10 || i2 === 11);
+      const avoid = ic === 5 && chord.intervals.includes(4) && !chord.intervals.includes(5) || ic === 11 && chord.intervals.includes(4) && chord.intervals.includes(10);
+      if (avoid) {
+        labels.push({ kind: "avoid" });
+        const resolveTo = nearestChordTone(note.pitch, chord, STEP_RESOLUTION);
+        if (resolveTo !== void 0) {
+          labels.push({ kind: "needsResolution", resolveTo });
+        }
+      } else if (degree !== void 0 && colours) {
+        labels.push({ kind: "tension", degree });
+      } else {
+        const resolveTo = nearestChordTone(note.pitch, chord, NEAREST_CHORD_TONE_REACH);
+        labels.push(
+          resolveTo === void 0 ? { kind: "avoid" } : { kind: "needsResolution", resolveTo }
+        );
+      }
+    }
+    if (next && _chunk3R3QVKY5cjs.isLeadingToneResolution.call(void 0, note.pitch, next.pitch, keyAt(next.startBeat))) {
+      labels.push({ kind: "leadingTone", resolveTo: next.pitch });
+    }
+    const analyzed = {
+      noteId: _nullishCoalesce(note.id, () => ( i)),
+      pitch: note.pitch,
+      startBeat: note.startBeat,
+      durationBeat: note.durationBeat,
+      labels,
+      rationale: describe(labels)
+    };
+    if (note.originalIndex !== void 0) {
+      analyzed.originalIndex = note.originalIndex;
+    }
+    result.push(analyzed);
+  }
+  return result;
+}
+function describe(labels) {
+  const primary = labels[0];
+  if (!primary) {
+    return "Unclassified note";
+  }
+  switch (primary.kind) {
+    case "chordTone":
+      return `Chord ${primary.role}`;
+    case "tension":
+      return `${primary.degree}th tension`;
+    case "avoid":
+      return "Avoid note";
+    case "passing":
+      return "Passing tone between chord tones";
+    case "neighbor":
+      return "Neighbor tone";
+    case "suspension":
+      return `Suspension (${primary.type})`;
+    case "appoggiatura":
+      return "Appoggiatura leaning on the harmony, resolving by step";
+    case "anticipation":
+      return "Anticipation of the next chord";
+    case "escape":
+      return "Escape tone";
+    case "needsResolution":
+      return "Unresolved dissonance";
+    case "leadingTone":
+      return "Leading tone resolving to the tonic";
+  }
+}
+
+// src/analyze/timeline/index.ts
+function assertChordTimeline(timeline, name = "timeline") {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, timeline, name);
+  _chunkS5BKZZGMcjs.assertFunction.call(void 0, read.at, `${name}.at`);
+  const segments = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.segments, `${name}.segments`);
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = _chunkS5BKZZGMcjs.assertRecord.call(void 0, segments[index], `${name}.segments[${index}]`);
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, segment.startBeat, `${name}.segments[${index}].startBeat`);
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, segment.endBeat, `${name}.segments[${index}].endBeat`);
+  }
+  return read;
+}
+function chordTimelineFromChords(chords, totalBeats) {
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, chords, "chords");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, chords.length, "timeline chords");
+  for (let index = 0; index < chords.length; index += 1) {
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, 
+      _nullishCoalesce(_optionalChain([chords, 'access', _42 => _42[index], 'optionalAccess', _43 => _43.startBeat]), () => ( Number.NaN)),
+      -Number.MAX_SAFE_INTEGER,
+      Number.MAX_SAFE_INTEGER,
+      `chords[${index}].startBeat`
+    );
+  }
+  const sorted = [...chords].filter((chord) => chord.startBeat < totalBeats).sort((a, b) => a.startBeat - b.startBeat);
+  const segments = sorted.map((gc, i) => {
+    const next = sorted[i + 1];
+    const nextBeat = next ? next.startBeat : totalBeats;
+    const endBeat = Math.min(totalBeats, Math.max(gc.startBeat, nextBeat));
+    return {
+      startBeat: gc.startBeat,
+      endBeat,
+      chord: _chunk3R3QVKY5cjs.chordFromSpan.call(void 0, gc)
+    };
+  }).filter((seg) => seg.endBeat > seg.startBeat);
+  return { at: segmentLookup(segments), segments };
+}
+function chordAtBeat(segments, beat) {
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, beat, "timeline query beat");
+  const candidate = segments[firstAfter(segments, beat) - 1];
+  return candidate !== void 0 && beat >= candidate.startBeat && beat < candidate.endBeat ? candidate.chord : null;
+}
+function firstAfter(segments, beat) {
+  let low = 0;
+  let high = segments.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if ((_nullishCoalesce(_optionalChain([segments, 'access', _44 => _44[middle], 'optionalAccess', _45 => _45.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
+      low = middle + 1;
+    } else {
+      high = middle;
+    }
+  }
+  return low;
+}
+function segmentStartingAt(segments, beat) {
+  const index = firstAfter(segments, beat);
+  for (const candidate of [segments[index - 1], segments[index]]) {
+    if (candidate !== void 0 && Math.abs(candidate.startBeat - beat) < _chunkS5BKZZGMcjs.BEAT_EPS) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function segmentLookup(segments) {
+  return (beat) => chordAtBeat(segments, beat);
+}
+var NOISE_THRESHOLD_RATIO = 0.2;
+var MAX_DETECTION_PCS = 6;
+var INEXACT_CONFIDENCE_FACTOR = 0.85;
+var DIATONIC_BONUS = 0.5;
+var EXACT_BONUS = 0.5;
+var EXTRA_TONE_PENALTY = 0.6;
+var OMITTED_TONE_PENALTY = 0.15;
+var BASS_ROOT_STANDING = 0.95;
+var OCTAVE = 12;
+function scoreMatch(match, weights, maxWeight, key, pedalPc) {
+  const rootWeight = maxWeight > 0 ? (_nullishCoalesce(weights[match.rootPc], () => ( 0))) / maxWeight : 0;
+  const rootStanding = match.inversion === 0 ? Math.max(rootWeight, BASS_ROOT_STANDING) : rootWeight;
+  const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, match.rootPc, match.quality);
+  const account = matchAccount(match, chord, pedalPc);
+  let score = rootStanding;
+  if (_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord).every((pc) => _chunk3R3QVKY5cjs.isScaleTone.call(void 0, pc, key))) {
+    score += DIATONIC_BONUS;
+  }
+  if (account.exact) {
+    score += EXACT_BONUS;
+  }
+  score -= EXTRA_TONE_PENALTY * account.extras;
+  score -= OMITTED_TONE_PENALTY * account.missing;
+  return score;
+}
+var SLASH_UPPER_QUALITIES = /* @__PURE__ */ new Set(["maj", "min"]);
+function isSlashReading(match, pedalPc) {
+  return pedalPc !== null && match.inversion === null && match.missingPcs.length === 0 && match.extraPcs.length === 1 && match.extraPcs[0] === pedalPc && SLASH_UPPER_QUALITIES.has(match.quality);
+}
+function namesAsExtension(chord, pc) {
+  return chord.intervals.some((iv) => iv >= OCTAVE && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc + iv) === pc);
+}
+function matchAccount(match, chord, pedalPc) {
+  const unvoiced = pedalPc !== null && namesAsExtension(chord, pedalPc) ? 1 : 0;
+  const named = isSlashReading(match, pedalPc) ? 1 : 0;
+  return {
+    extras: match.extraPcs.length - named + unvoiced,
+    missing: match.missingPcs.length + unvoiced,
+    exact: match.exact && unvoiced === 0
+  };
+}
+function bassSoundsOnlyBelow(notes, windowStart, windowEnd, bassPc) {
+  let upperFloor = Number.POSITIVE_INFINITY;
+  let highestBass = Number.NEGATIVE_INFINITY;
+  for (const note of notes) {
+    const overlap = Math.min(note.startBeat + note.durationBeat, windowEnd) - Math.max(note.startBeat, windowStart);
+    if (overlap <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+      continue;
+    }
+    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, note.pitch) === bassPc) {
+      highestBass = Math.max(highestBass, note.pitch);
+    } else {
+      upperFloor = Math.min(upperFloor, note.pitch);
+    }
+  }
+  return highestBass <= upperFloor;
+}
+function chordConfidence(chord, weights, totalWeight, exact) {
+  const tones = new Set(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord));
+  let chordWeight = 0;
+  for (let pc = 0; pc < 12; pc += 1) {
+    if (tones.has(pc)) {
+      chordWeight += _nullishCoalesce(weights[pc], () => ( 0));
+    }
+  }
+  const raw = totalWeight > 0 ? chordWeight / totalWeight : 0;
+  const confidence = Math.min(1, Math.max(0, raw));
+  return exact ? confidence : confidence * INEXACT_CONFIDENCE_FACTOR;
+}
+function analyzeWindow(notes, windowStart, windowEnd, meters, key) {
+  const { weights, totalWeight, maxWeight, lowestPitch } = windowWeights(
+    notes,
+    windowStart,
+    windowEnd,
+    meters
+  );
+  if (totalWeight <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+    return null;
+  }
+  const ranked = weights.map((weight, pc) => ({ pc, weight })).filter(({ weight }) => weight > 0).sort((a, b) => b.weight - a.weight || a.pc - b.pc);
+  const selected = ranked.filter(({ weight }) => weight >= maxWeight * NOISE_THRESHOLD_RATIO).slice(0, MAX_DETECTION_PCS).map(({ pc }) => pc);
+  const bassPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, lowestPitch);
+  const hasBass = selected.includes(bassPc);
+  const detectionPitches = hasBass ? selected.map((pc) => pc === bassPc ? pc : pc + 12) : selected;
+  const pedalPc = hasBass && bassSoundsOnlyBelow(notes, windowStart, windowEnd, bassPc) ? bassPc : null;
+  const matches = detectChord(detectionPitches, { input: hasBass ? "midi" : "pitchClass" });
+  let bestMatch = null;
+  let bestScore = Number.NEGATIVE_INFINITY;
+  for (const match of matches) {
+    const score = scoreMatch(match, weights, maxWeight, _chunk3R3QVKY5cjs.scaleOf.call(void 0, key), pedalPc);
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = match;
+    }
+  }
+  if (bestMatch) {
+    const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);
+    const account = matchAccount(
+      bestMatch,
+      _chunk3R3QVKY5cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality),
+      pedalPc
+    );
+    const reading = {
+      chord: shared(chord),
+      confidence: chordConfidence(chord, weights, totalWeight, account.exact)
+    };
+    const augmented = hasBass ? augmentedSixthFromPitchClasses(selected, bassPc, key) : null;
+    if (augmented !== null) {
+      reading.augmented = {
+        chord: shared(augmented),
+        confidence: chordConfidence(augmented, weights, totalWeight, true)
+      };
+    }
+    return reading;
+  }
+  return null;
+}
+function shared(chord) {
+  Object.freeze(chord.intervals);
+  return Object.freeze(chord);
+}
+var DOMINANT_ABOVE_TONIC = 7;
+function resolvesOntoDominant(readings, index, key) {
+  const dominantPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc + DOMINANT_ABOVE_TONIC);
+  const candidate = _optionalChain([readings, 'access', _46 => _46[index], 'optionalAccess', _47 => _47.chord]);
+  for (let i = index + 1; i < readings.length; i += 1) {
+    const next = readings[i];
+    if (!next) {
+      continue;
+    }
+    const chord = next.chord;
+    if (candidate !== void 0 && sameChord(chord, candidate)) {
+      continue;
+    }
+    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== dominantPc) {
+      return false;
+    }
+    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc) === dominantPc) {
+      return true;
+    }
+  }
+  return true;
+}
+function sameChord(a, b) {
+  return a.rootPc === b.rootPc && a.quality === b.quality && a.bassPc === b.bassPc;
+}
+var SEGMENTATION_QUALITIES = [
+  "maj",
+  "min",
+  "dim",
+  "aug",
+  "dom7",
+  "maj7",
+  "min7",
+  "m7b5",
+  "dim7",
+  "sus4",
+  "6",
+  "min6"
+];
+var LEXICON_SIZE = 12 * SEGMENTATION_QUALITIES.length;
+var LEXICON_ROOTS = new Int32Array(LEXICON_SIZE);
+var LEXICON_TONE_START = new Int32Array(LEXICON_SIZE + 1);
+var LEXICON_TONES = (() => {
+  const tones = [];
+  let candidate = 0;
+  for (let rootPc = 0; rootPc < 12; rootPc += 1) {
+    for (const quality of SEGMENTATION_QUALITIES) {
+      LEXICON_ROOTS[candidate] = rootPc;
+      LEXICON_TONE_START[candidate] = tones.length;
+      tones.push(..._chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, quality)));
+      candidate += 1;
+    }
+  }
+  LEXICON_TONE_START[candidate] = tones.length;
+  return Int32Array.from(tones);
+})();
+var OUTSIDE_TONE_PENALTY = 1;
+var MISSING_TONE_PENALTY = 0.5;
+var ROOT_PRESENCE_BONUS = 0.3;
+var CHANGE_COST = 0.35;
+var STRONG_BEAT_DISCOUNT2 = 0.5;
+var MAX_METRIC_WEIGHT2 = 3;
+function candidateScore(candidate, weights, totalWeight) {
+  const first = _nullishCoalesce(LEXICON_TONE_START[candidate], () => ( 0));
+  const last = _nullishCoalesce(LEXICON_TONE_START[candidate + 1], () => ( first));
+  let covered = 0;
+  let missing = 0;
+  for (let index = first; index < last; index += 1) {
+    const weight = _nullishCoalesce(weights[_nullishCoalesce(LEXICON_TONES[index], () => ( 0))], () => ( 0));
+    covered += weight;
+    if (weight <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+      missing += 1;
+    }
+  }
+  const outside = totalWeight - covered;
+  const averageToneWeight = totalWeight / (last - first);
+  return covered - OUTSIDE_TONE_PENALTY * outside - MISSING_TONE_PENALTY * missing * averageToneWeight + ROOT_PRESENCE_BONUS * (_nullishCoalesce(weights[_nullishCoalesce(LEXICON_ROOTS[candidate], () => ( 0))], () => ( 0)));
+}
+function beatOfSlot(grid, index) {
+  return grid.origin + index * grid.slotBeats;
+}
+function slotOfBeat(grid, beat) {
+  return (beat - grid.origin) / grid.slotBeats;
+}
+function createBoundaryTables(slotCount, budget) {
+  return {
+    scores: _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, slotCount, LEXICON_SIZE, "timeline window scores", budget),
+    back: _chunkS5BKZZGMcjs.allocateChoiceTable.call(void 0, slotCount, LEXICON_SIZE, "timeline window choices", budget),
+    costs: _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 1, LEXICON_SIZE, "timeline window costs", budget),
+    spare: _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 1, LEXICON_SIZE, "timeline window costs", budget),
+    path: _chunkS5BKZZGMcjs.allocateChoiceTable.call(void 0, slotCount, 1, "timeline window path", budget)
+  };
+}
+function scoreSlot(tables, slot, index) {
+  const base = index * LEXICON_SIZE;
+  if (slot.totalWeight <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+    tables.scores.fill(0, base, base + LEXICON_SIZE);
+    return;
+  }
+  for (let c = 0; c < LEXICON_SIZE; c += 1) {
+    tables.scores[base + c] = candidateScore(c, slot.weights, slot.totalWeight);
+  }
+}
+function chooseBoundaries(tables, from, to, grid, meters, changeCost) {
+  const width = to - from;
+  if (width <= 0) {
+    return [];
+  }
+  const { scores, back, path } = tables;
+  let costs = tables.costs;
+  let next = tables.spare;
+  for (let c = 0; c < LEXICON_SIZE; c += 1) {
+    costs[c] = -(_nullishCoalesce(scores[from * LEXICON_SIZE + c], () => ( 0)));
+  }
+  for (let i = 1; i < width; i += 1) {
+    let cheapest = Number.POSITIVE_INFINITY;
+    let cheapestIndex = 0;
+    for (let c = 0; c < LEXICON_SIZE; c += 1) {
+      const cost = _nullishCoalesce(costs[c], () => ( Number.POSITIVE_INFINITY));
+      if (cost < cheapest) {
+        cheapest = cost;
+        cheapestIndex = c;
+      }
+    }
+    const slotStart = beatOfSlot(grid, from + i);
+    const accent = _chunkS5BKZZGMcjs.metricWeight.call(void 0, slotStart, meters);
+    const penalty = changeCost * (1 - STRONG_BEAT_DISCOUNT2 * accent / MAX_METRIC_WEIGHT2);
+    const rowBase = (from + i) * LEXICON_SIZE;
+    const change = cheapest + penalty;
+    for (let c = 0; c < LEXICON_SIZE; c += 1) {
+      const stay = _nullishCoalesce(costs[c], () => ( Number.POSITIVE_INFINITY));
+      const carried = stay <= change ? stay : change;
+      back[rowBase + c] = stay <= change ? c : cheapestIndex;
+      next[c] = carried - (_nullishCoalesce(scores[rowBase + c], () => ( 0)));
+    }
+    const previous = costs;
+    costs = next;
+    next = previous;
+  }
+  let best = 0;
+  for (let c = 1; c < LEXICON_SIZE; c += 1) {
+    if ((_nullishCoalesce(costs[c], () => ( Number.POSITIVE_INFINITY))) < (_nullishCoalesce(costs[best], () => ( Number.POSITIVE_INFINITY)))) {
+      best = c;
+    }
+  }
+  let current = best;
+  for (let i = width - 1; i >= 0; i -= 1) {
+    path[from + i] = current;
+    if (i > 0) {
+      current = _nullishCoalesce(back[(from + i) * LEXICON_SIZE + current], () => ( current));
+    }
+  }
+  const spans = [];
+  let runStart = 0;
+  for (let i = 1; i <= width; i += 1) {
+    if (i === width || path[from + i] !== path[from + runStart]) {
+      spans.push({
+        startBeat: beatOfSlot(grid, from + runStart),
+        endBeat: beatOfSlot(grid, from + i)
+      });
+      runStart = i;
+    }
+  }
+  return spans;
+}
+function slotBeatsWithin(gridUnit, minChordBeats, harmonicRhythm) {
+  const resolution = Math.min(minChordBeats, harmonicRhythm);
+  const divisions = Math.max(1, Math.ceil(gridUnit / resolution - _chunkS5BKZZGMcjs.BEAT_EPS));
+  return gridUnit / divisions;
+}
+function gridSpans(slotCount, grid) {
+  return Array.from({ length: slotCount }, (_, i) => ({
+    startBeat: beatOfSlot(grid, i),
+    endBeat: beatOfSlot(grid, i + 1)
+  }));
+}
+function dynamicSpans(slotWeights, tables, grid, harmonicRhythm, meters) {
+  const slotBeats = grid.slotBeats;
+  const slotCount = slotWeights.length;
+  let soundingSlots = 0;
+  let weightSum = 0;
+  for (let i = 0; i < slotCount; i += 1) {
+    const weight = _nullishCoalesce(_optionalChain([slotWeights, 'access', _48 => _48[i], 'optionalAccess', _49 => _49.totalWeight]), () => ( 0));
+    if (weight > _chunkS5BKZZGMcjs.BEAT_EPS) {
+      soundingSlots += 1;
+      weightSum += weight;
+    }
+  }
+  if (soundingSlots === 0) {
+    return [];
+  }
+  const meanSlotWeight = weightSum / soundingSlots;
+  const changeCost = CHANGE_COST * meanSlotWeight * (harmonicRhythm / slotBeats);
+  const silent = slotWeights.map((slot) => slot.totalWeight <= _chunkS5BKZZGMcjs.BEAT_EPS);
+  const breaks = new Array(slotCount).fill(false);
+  for (let i = 0; i < slotCount; ) {
+    if (!silent[i]) {
+      i += 1;
+      continue;
+    }
+    let end = i;
+    while (end < slotCount && silent[end]) {
+      end += 1;
+    }
+    if ((end - i) * slotBeats >= harmonicRhythm - _chunkS5BKZZGMcjs.BEAT_EPS) {
+      for (let k = i; k < end; k += 1) {
+        breaks[k] = true;
+      }
+    }
+    i = end;
+  }
+  const spans = [];
+  for (let i = 0; i < slotCount; ) {
+    if (breaks[i]) {
+      i += 1;
+      continue;
+    }
+    let end = i;
+    while (end < slotCount && !breaks[end]) {
+      end += 1;
+    }
+    spans.push(...chooseBoundaries(tables, i, end, grid, meters, changeCost));
+    i = end;
+  }
+  return spans;
+}
+function notesOfSpan(slotNotes, span, grid) {
+  const first = Math.round(slotOfBeat(grid, span.startBeat));
+  const lastExclusive = Math.round(slotOfBeat(grid, span.endBeat));
+  if (lastExclusive - first === 1) {
+    return [..._nullishCoalesce(slotNotes[first], () => ( []))];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = first; i < lastExclusive; i += 1) {
+    for (const note of _nullishCoalesce(slotNotes[i], () => ( []))) {
+      seen.add(note);
+    }
+  }
+  return [...seen];
+}
+function chordTimelineFromNotes(notes, opts = {}) {
+  return analyzeTimeline(notes, opts).result;
+}
+var DIRTY_SLOT_MARGIN = 1;
+function dirtySlotsFor(evidence, startBeat, endBeat) {
+  const first = Math.floor(slotOfBeat(evidence.grid, startBeat)) - DIRTY_SLOT_MARGIN;
+  const lastExclusive = Math.ceil(slotOfBeat(evidence.grid, endBeat)) + DIRTY_SLOT_MARGIN;
+  return {
+    from: Math.max(0, Math.min(evidence.slotCount, first)),
+    to: Math.max(0, Math.min(evidence.slotCount, lastExclusive))
+  };
+}
+function spanIsClean(grid, span, dirtyFrom, dirtyTo) {
+  const first = Math.round(slotOfBeat(grid, span.startBeat));
+  const lastExclusive = Math.round(slotOfBeat(grid, span.endBeat));
+  return lastExclusive <= dirtyFrom || first >= dirtyTo;
+}
+function keyId(key) {
+  return `${key.rootPc}:${key.modeMask12}`;
+}
+function windowId(startBeat, endBeat, key) {
+  return `${startBeat}|${endBeat}|${keyId(key)}`;
+}
+function evidenceFits(previous, grid, slotCount, totalBeats, segmentation, harmonicRhythm, keyGiven) {
+  return previous.grid.origin === grid.origin && previous.grid.slotBeats === grid.slotBeats && previous.slotCount === slotCount && previous.totalBeats === totalBeats && previous.segmentation === segmentation && previous.harmonicRhythm === harmonicRhythm && previous.keyGiven === keyGiven;
+}
+function analyzeTimeline(notes, opts = {}, previous, dirty) {
+  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "timeline meters");
+  const harmonicRhythm = _nullishCoalesce(opts.harmonicRhythm, () => ( _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, 0, meters)));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
+  const segmentation = _nullishCoalesce(opts.segmentation, () => ( "dynamic"));
+  const gridUnit = _chunkS5BKZZGMcjs.metricGridUnit.call(void 0, meters);
+  const minChordBeats = _nullishCoalesce(opts.minChordBeats, () => ( gridUnit));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, minChordBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minChordBeats");
+  const budget = opts.budget;
+  const noteOptions = { allowNonPositiveDuration: true, budget };
+  if (opts.pickupBeats !== void 0) {
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "timeline pickupBeats");
+    noteOptions.minStartBeat = -opts.pickupBeats;
+  }
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "timeline notes", noteOptions);
+  const sounding = _chunk35NBV2FTcjs.sortedNoteEvents.call(void 0, notes.filter((note) => note.durationBeat > 0));
+  const lastNoteEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
+  const totalBeats = _nullishCoalesce(opts.totalBeats, () => ( lastNoteEnd));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  const slotBeats = segmentation === "grid" ? harmonicRhythm : slotBeatsWithin(gridUnit, minChordBeats, harmonicRhythm);
+  const { origin, startBeat: musicStart } = gridForNotes(sounding, slotBeats);
+  const grid = { origin, slotBeats };
+  const slotCount = Math.max(0, Math.ceil((totalBeats - grid.origin) / slotBeats - _chunkS5BKZZGMcjs.BEAT_EPS));
+  const dynamic = segmentation === "dynamic";
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
+    dynamic ? slotCount * LEXICON_SIZE : slotCount,
+    "timeline windows",
+    budget
+  );
+  const keys = opts.key !== void 0 ? [
+    {
+      startBeat: musicStart,
+      endBeat: totalBeats,
+      key: _chunk3R3QVKY5cjs.resolveKey.call(void 0, opts.key),
+      confidence: 1
+    }
+  ] : keyTimelineFromNotes(sounding, { meters, totalBeats, budget });
+  const prevailingKey = _nullishCoalesce(prevailingKeyOf(keys), () => ( _chunk3R3QVKY5cjs.resolveKey.call(void 0, _chunk3R3QVKY5cjs.majorKey.call(void 0, 0))));
+  const keyAt = keyLookup(keys, prevailingKey);
+  const scaleAt = (beat) => _chunk3R3QVKY5cjs.scaleOf.call(void 0, keyAt(beat));
+  const segments = [];
+  const segmentConfidence = [];
+  const slotNotes = bucketNotesBySlot(sounding, grid, slotCount, {
+    name: "timeline note-to-window memberships",
+    budget
+  });
+  const carried = previous !== void 0 && dirty !== void 0 && previous.tables !== void 0 && evidenceFits(
+    previous,
+    grid,
+    slotCount,
+    totalBeats,
+    segmentation,
+    harmonicRhythm,
+    opts.key !== void 0
+  ) ? previous : void 0;
+  const dirtyFrom = carried === void 0 ? 0 : Math.max(0, _nullishCoalesce(_optionalChain([dirty, 'optionalAccess', _50 => _50.from]), () => ( 0)));
+  const dirtyTo = carried === void 0 ? slotCount : Math.min(slotCount, _nullishCoalesce(_optionalChain([dirty, 'optionalAccess', _51 => _51.to]), () => ( slotCount)));
+  const tables = _nullishCoalesce(_optionalChain([carried, 'optionalAccess', _52 => _52.tables]), () => ( createBoundaryTables(dynamic ? slotCount : 0, budget)));
+  if (carried !== void 0) {
+    carried.tables = void 0;
+  }
+  const slotWeights = new Array(slotCount);
+  for (let i = 0; i < slotCount; i += 1) {
+    const reusable = i < dirtyFrom || i >= dirtyTo ? _optionalChain([carried, 'optionalAccess', _53 => _53.slotWeights, 'access', _54 => _54[i]]) : void 0;
+    if (reusable !== void 0) {
+      slotWeights[i] = reusable;
+      continue;
+    }
+    const start = beatOfSlot(grid, i);
+    const weights = windowWeights(
+      _nullishCoalesce(slotNotes[i], () => ( [])),
+      start,
+      Math.min(start + slotBeats, totalBeats),
+      meters
+    );
+    slotWeights[i] = weights;
+    if (dynamic) {
+      scoreSlot(tables, weights, i);
+    }
+  }
+  const spans = segmentation === "grid" ? gridSpans(slotCount, grid) : dynamicSpans(slotWeights, tables, grid, harmonicRhythm, meters);
+  const windows = /* @__PURE__ */ new Map();
+  const readings = [];
+  const readingKeys = [];
+  const readingBounds = [];
+  for (const span of spans) {
+    const start = Math.max(span.startBeat, musicStart);
+    const end = Math.min(span.endBeat, totalBeats);
+    const spanKey = scaleAt(start);
+    const spanKeyWhole = keyAt(start);
+    const id = windowId(start, end, spanKey);
+    const cached = carried !== void 0 && spanIsClean(grid, span, dirtyFrom, dirtyTo) ? carried.windows.get(id) : void 0;
+    const inferred = cached !== void 0 ? cached : analyzeWindow(notesOfSpan(slotNotes, span, grid), start, end, meters, spanKeyWhole);
+    windows.set(id, inferred);
+    readings.push(inferred);
+    readingKeys.push(spanKey);
+    readingBounds.push({ start, end });
+  }
+  for (let i = 0; i < readings.length; i += 1) {
+    const offered = _optionalChain([readings, 'access', _55 => _55[i], 'optionalAccess', _56 => _56.augmented]);
+    const spanKey = readingKeys[i];
+    if (offered !== void 0 && spanKey !== void 0 && resolvesOntoDominant(readings, i, spanKey)) {
+      readings[i] = offered;
+    }
+  }
+  for (let i = 0; i < readings.length; i += 1) {
+    const inferred = readings[i];
+    const bounds = readingBounds[i];
+    if (!inferred || bounds === void 0) {
+      continue;
+    }
+    const { start, end } = bounds;
+    const last = segments[segments.length - 1];
+    if (last && sameChord(last.chord, inferred.chord) && Math.abs(last.endBeat - start) < _chunkS5BKZZGMcjs.BEAT_EPS) {
+      const lastLength = last.endBeat - last.startBeat;
+      const length = end - start;
+      const lastConfidence = _nullishCoalesce(segmentConfidence[segmentConfidence.length - 1], () => ( 0));
+      segmentConfidence[segmentConfidence.length - 1] = (lastConfidence * lastLength + inferred.confidence * length) / (lastLength + length);
+      last.endBeat = end;
+    } else {
+      segments.push({ startBeat: start, endBeat: end, chord: inferred.chord });
+      segmentConfidence.push(inferred.confidence);
+    }
+  }
+  return {
+    result: {
+      timeline: { at: segmentLookup(segments), segments },
+      keys: attachPivots(keys, segments),
+      prevailingKey,
+      segmentConfidence
+    },
+    evidence: {
+      grid,
+      slotCount,
+      totalBeats,
+      segmentation,
+      harmonicRhythm,
+      keyGiven: opts.key !== void 0,
+      slotWeights,
+      tables,
+      windows
+    }
+  };
+}
+function detectCadences(timeline, key) {
+  assertChordTimeline(timeline);
+  const keyAt = keyScaleAt(key);
+  const hits = [];
+  for (let i = 1; i < timeline.segments.length; i += 1) {
+    const prev = timeline.segments[i - 1];
+    const cur = timeline.segments[i];
+    if (!prev || !cur) {
+      continue;
+    }
+    if (Math.abs(cur.startBeat - prev.endBeat) > _chunkS5BKZZGMcjs.BEAT_EPS) {
+      continue;
+    }
+    const before = timeline.segments[i - 2];
+    const approach = before !== void 0 && Math.abs(prev.startBeat - before.endBeat) <= _chunkS5BKZZGMcjs.BEAT_EPS ? before.chord : void 0;
+    const key2 = keyAt(cur.startBeat);
+    const cadence = detectCadence(prev.chord, cur.chord, key2, {
+      ...approach === void 0 ? {} : { approach }
+    });
+    if (cadence.type === null) {
+      continue;
+    }
+    if (cadence.type === "half" && isCadentialSixFour(prev.chord, cur.chord, key2)) {
+      const next = timeline.segments[i + 1];
+      if (next !== void 0 && Math.abs(next.startBeat - cur.endBeat) <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+        const onward = detectCadence(cur.chord, next.chord, keyAt(next.startBeat)).type;
+        if (onward === "authentic" || onward === "deceptive") {
+          continue;
+        }
+      }
+    }
+    hits.push({ atBeat: cur.startBeat, cadence, from: prev.chord, to: cur.chord });
+  }
+  return hits;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.HUMANIZE_ADJACENCY = HUMANIZE_ADJACENCY; exports.sameInstant = sameInstant; exports.adjacent = adjacent; exports.hasEnded = hasEnded; exports.windowWeights = windowWeights; exports.MODAL_SCALE_NAMES = MODAL_SCALE_NAMES; 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.isCadentialSixFour = isCadentialSixFour; exports.detectCadence = detectCadence; exports.isBorrowedChord = isBorrowedChord; exports.borrowedSource = borrowedSource; exports.isAppliedDominant = isAppliedDominant; 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; exports.clamp01 = clamp01; exports.floorMod = floorMod; exports.firstSoundingBeat = firstSoundingBeat; exports.lastBarOf = lastBarOf; exports.sliceBars = sliceBars; exports.weightSimilarity = weightSimilarity; exports.harmonicNovelty = harmonicNovelty; exports.combineEvidence = combineEvidence; exports.gridForNotes = gridForNotes; exports.barGridStart = barGridStart; exports.keyTimelineFromNotes = keyTimelineFromNotes; exports.detectModulations = detectModulations; exports.attachPivots = attachPivots; exports.keyLookup = keyLookup; exports.prevailingKeyOf = prevailingKeyOf; exports.keyScaleAt = keyScaleAt; exports.toVoiceNotes = toVoiceNotes; exports.analyzeVoice = analyzeVoice; exports.assertChordTimeline = assertChordTimeline; exports.chordTimelineFromChords = chordTimelineFromChords; exports.chordAtBeat = chordAtBeat; exports.segmentStartingAt = segmentStartingAt; exports.chordTimelineFromNotes = chordTimelineFromNotes; exports.dirtySlotsFor = dirtySlotsFor; exports.analyzeTimeline = analyzeTimeline; exports.detectCadences = detectCadences;
+//# sourceMappingURL=chunk-SGLEQVJH.cjs.map