@libraz/libcantus 0.9.4 → 1.0.0

package/dist/chunk-INHVXP6Z.js

@@ -0,0 +1,3053 @@
+import {
+  InvalidInputError,
+  assertDegree,
+  assertFiniteNumber,
+  assertFiniteSemitones,
+  assertGenerationBudget,
+  assertInteger,
+  assertMidiPitch,
+  assertOneOf,
+  clampToMidi,
+  diatonicLetterOf,
+  formatNote,
+  isConsonantInterval,
+  midiToNote,
+  naturalPitchClassOf,
+  noteToMidi,
+  noteToPitchClass,
+  parseFailure,
+  parseKeyName,
+  parseNote,
+  pitchClassOf,
+  spelledInterval,
+  toNoteData,
+  transposeNote,
+  tryParseNote,
+  unwrapParse
+} from "./chunk-VTI6FOLB.js";
+
+// src/theory/scale/masks.ts
+function maskFromOffsets(offsets) {
+  let mask = 1;
+  for (const [index, offset] of offsets.entries()) {
+    assertInteger(offset, `offsets[${index}]`);
+    mask |= 1 << (offset % 12 + 12) % 12;
+  }
+  return mask;
+}
+var MAJOR_MASK = 2741;
+var NATURAL_MINOR_MASK = 1453;
+var HARMONIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 8, 11]);
+var MELODIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 11]);
+var DORIAN_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 10]);
+var PHRYGIAN_MASK = maskFromOffsets([0, 1, 3, 5, 7, 8, 10]);
+var LYDIAN_MASK = maskFromOffsets([0, 2, 4, 6, 7, 9, 11]);
+var MIXOLYDIAN_MASK = maskFromOffsets([0, 2, 4, 5, 7, 9, 10]);
+var LOCRIAN_MASK = maskFromOffsets([0, 1, 3, 5, 6, 8, 10]);
+var MAJOR_PENTATONIC_MASK = maskFromOffsets([0, 2, 4, 7, 9]);
+var MINOR_PENTATONIC_MASK = maskFromOffsets([0, 3, 5, 7, 10]);
+var BLUES_MASK = maskFromOffsets([0, 3, 5, 6, 7, 10]);
+var WHOLE_TONE_MASK = maskFromOffsets([0, 2, 4, 6, 8, 10]);
+var OCTATONIC_HALF_WHOLE_MASK = maskFromOffsets([0, 1, 3, 4, 6, 7, 9, 10]);
+var OCTATONIC_WHOLE_HALF_MASK = maskFromOffsets([0, 2, 3, 5, 6, 8, 9, 11]);
+var CHROMATIC_MASK = 4095;
+var LYDIAN_DOMINANT_MASK = maskFromOffsets([0, 2, 4, 6, 7, 9, 10]);
+var MIXOLYDIAN_B13_MASK = maskFromOffsets([0, 2, 4, 5, 7, 8, 10]);
+var LOCRIAN_NATURAL2_MASK = maskFromOffsets([0, 2, 3, 5, 6, 8, 10]);
+var ALTERED_MASK = maskFromOffsets([0, 1, 3, 4, 6, 8, 10]);
+var PHRYGIAN_DOMINANT_MASK = maskFromOffsets([0, 1, 4, 5, 7, 8, 10]);
+var MIYAKO_BUSHI_MASK = maskFromOffsets([0, 1, 5, 7, 8]);
+var RITSU_MASK = maskFromOffsets([0, 2, 5, 7, 9]);
+var RYUKYU_MASK = maskFromOffsets([0, 4, 5, 7, 11]);
+var DOUBLE_HARMONIC_MASK = maskFromOffsets([0, 1, 4, 5, 7, 8, 11]);
+var TODI_MASK = maskFromOffsets([0, 1, 3, 6, 7, 8, 11]);
+var MARWA_MASK = maskFromOffsets([0, 1, 4, 6, 7, 9, 11]);
+var PURVI_MASK = maskFromOffsets([0, 1, 4, 6, 7, 8, 11]);
+var NAMED_SCALES = Object.freeze({
+  major: MAJOR_MASK,
+  ionian: MAJOR_MASK,
+  naturalMinor: NATURAL_MINOR_MASK,
+  aeolian: NATURAL_MINOR_MASK,
+  harmonicMinor: HARMONIC_MINOR_MASK,
+  melodicMinor: MELODIC_MINOR_MASK,
+  dorian: DORIAN_MASK,
+  phrygian: PHRYGIAN_MASK,
+  lydian: LYDIAN_MASK,
+  mixolydian: MIXOLYDIAN_MASK,
+  locrian: LOCRIAN_MASK,
+  lydianDominant: LYDIAN_DOMINANT_MASK,
+  mixolydianB13: MIXOLYDIAN_B13_MASK,
+  locrianNatural2: LOCRIAN_NATURAL2_MASK,
+  altered: ALTERED_MASK,
+  phrygianDominant: PHRYGIAN_DOMINANT_MASK,
+  majorPentatonic: MAJOR_PENTATONIC_MASK,
+  minorPentatonic: MINOR_PENTATONIC_MASK,
+  blues: BLUES_MASK,
+  wholeTone: WHOLE_TONE_MASK,
+  octatonicHalfWhole: OCTATONIC_HALF_WHOLE_MASK,
+  octatonicWholeHalf: OCTATONIC_WHOLE_HALF_MASK,
+  chromatic: CHROMATIC_MASK
+});
+var WORLD_SCALES = Object.freeze({
+  /** Miyako-bushi (都節), the hemitonic pentatonic of Japanese art music. */
+  miyakoBushi: MIYAKO_BUSHI_MASK,
+  /** Ritsu (律), the anhemitonic pentatonic of Japanese court music and chant. */
+  ritsu: RITSU_MASK,
+  /**
+   * Min'yō (民謡), the pentatonic of Japanese folk song, called inaka-bushi
+   * (田舎節) opposite miyako-bushi. The same five pitch classes as the minor
+   * pentatonic.
+   */
+  minyo: MINOR_PENTATONIC_MASK,
+  /** Ryūkyū (琉球), the pentatonic of Okinawan music. */
+  ryukyu: RYUKYU_MASK,
+  /** Maqam Ajam of Arabic practice; the same pitch classes as the major scale. */
+  ajam: MAJOR_MASK,
+  /**
+   * Maqam Nahawand of Arabic practice; the same pitch classes as the natural
+   * minor, though practice raises the seventh degree at a cadence.
+   */
+  nahawand: NATURAL_MINOR_MASK,
+  /** Maqam Kurd of Arabic practice; the same pitch classes as the phrygian mode. */
+  kurd: PHRYGIAN_MASK,
+  /**
+   * Maqam Hijaz of Arabic practice; the same pitch classes as the phrygian
+   * dominant. Played intonation stretches the augmented second beyond its
+   * tempered size, which is the sound the mask cannot carry.
+   */
+  hijaz: PHRYGIAN_DOMINANT_MASK,
+  /** Maqam Hijazkar of Arabic practice: Hijaz over Hijaz, with two augmented seconds. */
+  hijazkar: DOUBLE_HARMONIC_MASK,
+  /** Thaat Bilaval of Hindustani classical music; the same pitch classes as the major scale. */
+  bilaval: MAJOR_MASK,
+  /** Thaat Khamaj; the same pitch classes as the mixolydian mode. */
+  khamaj: MIXOLYDIAN_MASK,
+  /** Thaat Kafi; the same pitch classes as the dorian mode. */
+  kafi: DORIAN_MASK,
+  /** Thaat Asavari; the same pitch classes as the natural minor. */
+  asavari: NATURAL_MINOR_MASK,
+  /** Thaat Bhairavi; the same pitch classes as the phrygian mode. */
+  bhairavi: PHRYGIAN_MASK,
+  /** Thaat Bhairav, with komal Re and komal Dha against a natural third and seventh. */
+  bhairav: DOUBLE_HARMONIC_MASK,
+  /** Thaat Kalyan; the same pitch classes as the lydian mode. */
+  kalyan: LYDIAN_MASK,
+  /** Thaat Marwa, with komal Re and tivra Ma. */
+  marwa: MARWA_MASK,
+  /** Thaat Purvi, Marwa's komal Dha counterpart. */
+  purvi: PURVI_MASK,
+  /** Thaat Todi, with komal Re, komal Ga, komal Dha and tivra Ma. */
+  todi: TODI_MASK
+});
+var SCALE_ALIASES = Object.freeze({
+  /** Inaka-bushi (田舎節), the name the in/yō pairing gives the min'yō scale. */
+  inakaBushi: "minyo",
+  /** The Okinawan scale, the usual English name for the ryūkyū scale. */
+  okinawan: "ryukyu",
+  /** Turkish spelling of Hijaz. */
+  hicaz: "hijaz",
+  /** The English-language scale-list name for the Hijazkar/Bhairav set. */
+  doubleHarmonic: "hijazkar",
+  /** Transliteration variant of Bilaval. */
+  bilawal: "bilaval",
+  /** Transliteration variant of Marwa. */
+  marva: "marwa",
+  /** Transliteration variant of Purvi. */
+  poorvi: "purvi"
+});
+function resolveScaleName(name) {
+  if (Object.hasOwn(NAMED_SCALES, name)) {
+    return name;
+  }
+  if (Object.hasOwn(WORLD_SCALES, name)) {
+    return name;
+  }
+  return Object.hasOwn(SCALE_ALIASES, name) ? SCALE_ALIASES[name] : void 0;
+}
+function namedScaleMask(name) {
+  const canonical = resolveScaleName(name);
+  if (canonical === void 0) {
+    return void 0;
+  }
+  return Object.hasOwn(NAMED_SCALES, canonical) ? NAMED_SCALES[canonical] : WORLD_SCALES[canonical];
+}
+function requireScaleMask(name, label = "scale") {
+  const mask = namedScaleMask(name);
+  if (mask === void 0) {
+    throw new InvalidInputError(`Unknown ${label}: ${String(name)}`);
+  }
+  return mask;
+}
+
+// src/theory/scale/key.ts
+function majorKey(rootPc) {
+  return { rootPc: pitchClassOf(rootPc), modeMask12: MAJOR_MASK };
+}
+function minorKey(rootPc) {
+  return { rootPc: pitchClassOf(rootPc), modeMask12: NATURAL_MINOR_MASK };
+}
+function scaleByName(name, rootPc) {
+  return { rootPc: pitchClassOf(rootPc), modeMask12: requireScaleMask(name) };
+}
+
+// src/theory/scale/coerce.ts
+function normalizedKeyScale(scale) {
+  assertInteger(scale.modeMask12, "key.modeMask12", 1, CHROMATIC_MASK);
+  if ((scale.modeMask12 & 1) === 0) {
+    throw new InvalidInputError(
+      `key.modeMask12 must include its root; received ${scale.modeMask12}`
+    );
+  }
+  assertInteger(scale.rootPc, "key.rootPc");
+  return { rootPc: pitchClassOf(scale.rootPc), modeMask12: scale.modeMask12 };
+}
+function toKeyScale(value) {
+  if (typeof value === "string") {
+    const name = parseKeyName(value);
+    const rootPc = noteToPitchClass(name.tonic);
+    return name.mode === "major" ? majorKey(rootPc) : minorKey(rootPc);
+  }
+  if (typeof value === "object" && value !== null) {
+    const data = "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON().scale : value;
+    if (typeof data === "object" && data !== null) {
+      return normalizedKeyScale(data);
+    }
+  }
+  throw new InvalidInputError(`key must be a key name or a key/scale; received ${typeof value}`);
+}
+
+// src/theory/scale/degrees.ts
+function scaleOffset(pitch, key) {
+  return (pitchClassOf(pitch) - pitchClassOf(key.rootPc) + 12) % 12;
+}
+function inScale(pitch, scale) {
+  return (scale.modeMask12 >> scaleOffset(pitch, scale) & 1) === 1;
+}
+function isScaleTone(pitch, key) {
+  return inScale(pitch, key);
+}
+function nearestScaleTone(pitch, key) {
+  const scale = toKeyScale(key);
+  const base = clampToMidi(Math.round(pitch), "pitch");
+  for (let distance = 0; distance < 12; distance += 1) {
+    const lower = base - distance;
+    if (lower >= 0 && inScale(lower, scale)) {
+      return lower;
+    }
+    const higher = base + distance;
+    if (higher <= 127 && inScale(higher, scale)) {
+      return higher;
+    }
+  }
+  return base;
+}
+function scaleOffsets(key) {
+  const offsets = [];
+  for (let n = 0; n < 12; n += 1) {
+    if ((key.modeMask12 >> n & 1) === 1) {
+      offsets.push(n);
+    }
+  }
+  return offsets;
+}
+function scaleLadderPosition(pitch, key) {
+  const offsets = scaleOffsets(key);
+  const size = offsets.length;
+  if (size === 0) {
+    return { rung: 0, offset: 0 };
+  }
+  const relative = pitch - pitchClassOf(key.rootPc);
+  const octave = Math.floor(relative / 12);
+  const within = relative - octave * 12;
+  let degree = 0;
+  for (let n = 0; n < size; n += 1) {
+    if ((offsets[n] ?? 0) <= within) {
+      degree = n;
+    }
+  }
+  return { rung: octave * size + degree, offset: within - (offsets[degree] ?? 0) };
+}
+function scaleLadderPitch(rung, key) {
+  const offsets = scaleOffsets(key);
+  const size = offsets.length;
+  if (size === 0) {
+    return pitchClassOf(key.rootPc);
+  }
+  const octave = Math.floor(rung / size);
+  const degree = rung - octave * size;
+  return pitchClassOf(key.rootPc) + octave * 12 + (offsets[degree] ?? 0);
+}
+function shiftByScaleDegrees(pitch, degrees, key) {
+  const steps = Math.trunc(degrees);
+  if (steps === 0) {
+    return pitch;
+  }
+  const { rung, offset } = scaleLadderPosition(pitch, key);
+  return scaleLadderPitch(rung + steps, key) + offset;
+}
+function pitchToScaleDegree(pitch, key) {
+  const scale = toKeyScale(key);
+  const offset = scaleOffset(pitch, scale);
+  if ((scale.modeMask12 >> offset & 1) === 0) {
+    return -1;
+  }
+  let degree = 1;
+  for (let n = 0; n < offset; n += 1) {
+    if ((scale.modeMask12 >> n & 1) === 1) {
+      degree += 1;
+    }
+  }
+  return degree;
+}
+function diatonicPitchClasses(key) {
+  const scale = key;
+  const root = pitchClassOf(scale.rootPc);
+  const pcs = [];
+  for (let n = 0; n < 12; n += 1) {
+    if ((scale.modeMask12 >> n & 1) === 1) {
+      pcs.push((root + n) % 12);
+    }
+  }
+  return pcs.sort((a, b) => a - b);
+}
+function scaleTonesInDegreeOrder(key) {
+  const scale = key;
+  const root = pitchClassOf(scale.rootPc);
+  const pcs = [];
+  for (let n = 0; n < 12; n += 1) {
+    if ((scale.modeMask12 >> n & 1) === 1) {
+      pcs.push((root + n) % 12);
+    }
+  }
+  return pcs;
+}
+
+// src/theory/scale/signature.ts
+var LETTER_FIFTHS = [0, 2, 4, -1, 1, 3, 5];
+var FIFTHS_LETTERS = [3, 0, 4, 1, 5, 2, 6];
+var FIFTHS_PER_ALTERATION = 7;
+var MINOR_MODE_OFFSET = -3;
+var MAX_FIFTHS = 12;
+function rotateMask(mask, semitones) {
+  const steps = (semitones % 12 + 12) % 12;
+  return (mask >> steps | mask << 12 - steps) & 4095;
+}
+var DIATONIC_MODE_OFFSETS = /* @__PURE__ */ new Map([
+  [rotateMask(MAJOR_MASK, 5), 1],
+  // lydian
+  [MAJOR_MASK, 0],
+  // ionian / major
+  [rotateMask(MAJOR_MASK, 7), -1],
+  // mixolydian
+  [rotateMask(MAJOR_MASK, 2), -2],
+  // dorian
+  [rotateMask(MAJOR_MASK, 9), MINOR_MODE_OFFSET],
+  // aeolian / natural minor
+  [rotateMask(MAJOR_MASK, 4), -4],
+  // phrygian
+  [rotateMask(MAJOR_MASK, 11), -5]
+  // locrian
+]);
+function hasMinorThird(modeMask12) {
+  return (modeMask12 >> 3 & 1) === 1 && (modeMask12 >> 4 & 1) === 0;
+}
+function modeOffset(key) {
+  const diatonic = DIATONIC_MODE_OFFSETS.get(key.modeMask12);
+  if (diatonic !== void 0) {
+    return diatonic;
+  }
+  return hasMinorThird(key.modeMask12) ? MINOR_MODE_OFFSET : 0;
+}
+function isSignatureKey(key) {
+  return DIATONIC_MODE_OFFSETS.has(key.modeMask12) || key.modeMask12 === HARMONIC_MINOR_MASK || key.modeMask12 === MELODIC_MINOR_MASK;
+}
+function keySignatureFifths(tonic, key) {
+  const note = toNoteData(tonic);
+  const scale = key;
+  const letter = diatonicLetterOf(note.letter);
+  assertInteger(note.alter, "tonic.alter");
+  assertInteger(scale.modeMask12, "key.modeMask12", 1, 4095);
+  return (LETTER_FIFTHS[letter] ?? 0) + FIFTHS_PER_ALTERATION * note.alter + modeOffset(scale);
+}
+function keyFromFifths(fifths, mode = "major") {
+  assertInteger(fifths, "fifths", -MAX_FIFTHS, MAX_FIFTHS);
+  const which = assertOneOf(mode, ["major", "minor"], "mode");
+  const index = fifths + 1 + (which === "minor" ? -MINOR_MODE_OFFSET : 0);
+  const letter = FIFTHS_LETTERS[(index % 7 + 7) % 7] ?? 0;
+  const alter = Math.floor(index / 7);
+  const rootPc = pitchClassOf(naturalPitchClassOf(letter) + alter);
+  return {
+    tonic: { letter, alter },
+    key: which === "minor" ? minorKey(rootPc) : majorKey(rootPc)
+  };
+}
+
+// src/theory/scale/relations.ts
+var ENHARMONIC_FIFTHS = 12;
+var MAX_CONVENTIONAL_FIFTHS = 7;
+var DOUBLE_ACCIDENTAL = 2;
+var MINOR_TONIC_FIFTHS = 3;
+var FLATTEST_TONIC_FIFTHS = -MAX_CONVENTIONAL_FIFTHS;
+var SHARPEST_TONIC_FIFTHS = MAX_CONVENTIONAL_FIFTHS + MINOR_TONIC_FIFTHS;
+function isMinorMode(modeMask12) {
+  return (modeMask12 >> 3 & 1) === 1 && (modeMask12 >> 4 & 1) === 0;
+}
+function assertModeMask(key, name = "key") {
+  return assertInteger(key.modeMask12, `${name}.modeMask12`, 1, CHROMATIC_MASK);
+}
+function modeOf(key) {
+  return isMinorMode(assertModeMask(key)) ? "minor" : "major";
+}
+function oppositeMode(mode) {
+  return mode === "major" ? "minor" : "major";
+}
+function soundsLike(a, b) {
+  return pitchClassOf(a.rootPc) === pitchClassOf(b.rootPc) && isMinorMode(a.modeMask12) === isMinorMode(b.modeMask12);
+}
+function spelledLike(a, b) {
+  return diatonicLetterOf(a.letter) === diatonicLetterOf(b.letter) && a.alter === b.alter;
+}
+function tonicCost(tonic, key) {
+  let doubles = 0;
+  let accidentals = 0;
+  for (const note of spellScale(tonic, key)) {
+    const alter = Math.abs(note.alter);
+    accidentals += alter;
+    if (alter >= DOUBLE_ACCIDENTAL) {
+      doubles += 1;
+    }
+  }
+  return { doubles, accidentals, fifths: Math.abs(keySignatureFifths(tonic, key)) };
+}
+function spellsBetter(a, b, signatureKey) {
+  const order = signatureKey ? ["fifths", "doubles", "accidentals"] : ["doubles", "accidentals", "fifths"];
+  for (const term of order) {
+    if (a[term] !== b[term]) {
+      return a[term] < b[term];
+    }
+  }
+  return false;
+}
+function spelledKeyOf(key) {
+  const scale = key;
+  const rootPc = pitchClassOf(scale.rootPc);
+  const signatureKey = isSignatureKey(scale);
+  let tonic = keyFromFifths(0).tonic;
+  let best;
+  for (let fifths = FLATTEST_TONIC_FIFTHS; fifths <= SHARPEST_TONIC_FIFTHS; fifths += 1) {
+    const candidate = keyFromFifths(fifths).tonic;
+    if (noteToPitchClass(candidate) !== rootPc) {
+      continue;
+    }
+    const cost = tonicCost(candidate, scale);
+    if (best === void 0 || spellsBetter(cost, best, signatureKey)) {
+      tonic = candidate;
+      best = cost;
+    }
+  }
+  return { tonic, key };
+}
+function relativeKeyOf(tonic, key) {
+  const scale = toKeyScale(key);
+  return keyFromFifths(keySignatureFifths(tonic, scale), oppositeMode(modeOf(scale)));
+}
+function parallelKeyOf(tonic, key) {
+  const note = toNoteData(tonic);
+  const mode = oppositeMode(modeOf(toKeyScale(key)));
+  const rootPc = noteToPitchClass(note);
+  return {
+    tonic: { letter: diatonicLetterOf(note.letter), alter: note.alter },
+    key: mode === "minor" ? minorKey(rootPc) : majorKey(rootPc)
+  };
+}
+function tonicPosition(tonic) {
+  return keySignatureFifths(tonic, majorKey(noteToPitchClass(tonic)));
+}
+function tonicFifths(tonic, mode) {
+  return tonicPosition(tonic) - (mode === "minor" ? MINOR_TONIC_FIFTHS : 0);
+}
+function isWrittenTonic(tonic, key) {
+  const position = tonicPosition(tonic);
+  if (position < FLATTEST_TONIC_FIFTHS || position > SHARPEST_TONIC_FIFTHS) {
+    return false;
+  }
+  return isSignatureKey(key) ? Math.abs(keySignatureFifths(tonic, key)) <= MAX_CONVENTIONAL_FIFTHS : tonicCost(tonic, key).doubles === 0;
+}
+function dominantKeyOf(tonic, key) {
+  const mode = modeOf(toKeyScale(key));
+  return keyFromFifths(tonicFifths(toNoteData(tonic), mode) + 1, mode);
+}
+function subdominantKeyOf(tonic, key) {
+  const mode = modeOf(toKeyScale(key));
+  return keyFromFifths(tonicFifths(toNoteData(tonic), mode) - 1, mode);
+}
+function enharmonicKeyOf(tonic, key) {
+  const note = toNoteData(tonic);
+  const scale = toKeyScale(key);
+  assertModeMask(scale);
+  for (const position of [
+    tonicPosition(note) - ENHARMONIC_FIFTHS,
+    tonicPosition(note) + ENHARMONIC_FIFTHS
+  ]) {
+    if (position < FLATTEST_TONIC_FIFTHS || position > SHARPEST_TONIC_FIFTHS) {
+      continue;
+    }
+    const spelled = keyFromFifths(position).tonic;
+    if (!isWrittenTonic(spelled, scale)) {
+      continue;
+    }
+    return {
+      tonic: spelled,
+      // The mask is the caller's; only the root is re-read, so a tonic that did
+      // not spell the mask's own root still comes back consistent.
+      key: { rootPc: noteToPitchClass(spelled), modeMask12: scale.modeMask12 }
+    };
+  }
+  return null;
+}
+function relativeOfDominantKeyOf(tonic, key) {
+  const dominant = dominantKeyOf(tonic, key);
+  return relativeKeyOf(dominant.tonic, dominant.key);
+}
+function relativeOfSubdominantKeyOf(tonic, key) {
+  const subdominant = subdominantKeyOf(tonic, key);
+  return relativeKeyOf(subdominant.tonic, subdominant.key);
+}
+var CLOSELY_RELATED = [
+  { relation: "relative", of: relativeKeyOf },
+  { relation: "parallel", of: parallelKeyOf },
+  { relation: "dominant", of: dominantKeyOf },
+  { relation: "subdominant", of: subdominantKeyOf },
+  { relation: "relativeOfDominant", of: relativeOfDominantKeyOf },
+  { relation: "relativeOfSubdominant", of: relativeOfSubdominantKeyOf }
+];
+function relatedKeysOf(tonic, key) {
+  const note = toNoteData(tonic);
+  const scale = toKeyScale(key);
+  return CLOSELY_RELATED.map(({ relation, of }) => ({ ...of(note, scale), relation }));
+}
+function keyRelationBetween(a, b) {
+  assertModeMask(a.key, "a.key");
+  assertModeMask(b.key, "b.key");
+  if (soundsLike(a.key, b.key)) {
+    return spelledLike(a.tonic, b.tonic) ? "same" : "enharmonic";
+  }
+  for (const { relation, of } of CLOSELY_RELATED) {
+    if (soundsLike(of(a.tonic, a.key).key, b.key)) {
+      return relation;
+    }
+  }
+  return null;
+}
+
+// src/theory/scale/system.ts
+var SCALE_SYSTEMS = Object.freeze({
+  major: "common-practice",
+  ionian: "common-practice",
+  naturalMinor: "common-practice",
+  aeolian: "common-practice",
+  harmonicMinor: "common-practice",
+  melodicMinor: "common-practice",
+  dorian: "modal",
+  phrygian: "modal",
+  lydian: "modal",
+  mixolydian: "modal",
+  locrian: "modal",
+  lydianDominant: "modal",
+  mixolydianB13: "modal",
+  locrianNatural2: "modal",
+  altered: "modal",
+  phrygianDominant: "modal",
+  majorPentatonic: "non-functional",
+  minorPentatonic: "non-functional",
+  blues: "non-functional",
+  wholeTone: "non-functional",
+  octatonicHalfWhole: "non-functional",
+  octatonicWholeHalf: "non-functional",
+  chromatic: "non-functional",
+  miyakoBushi: "non-functional",
+  ritsu: "non-functional",
+  minyo: "non-functional",
+  ryukyu: "non-functional",
+  ajam: "non-functional",
+  nahawand: "non-functional",
+  kurd: "non-functional",
+  hijaz: "non-functional",
+  hijazkar: "non-functional",
+  bilaval: "non-functional",
+  khamaj: "non-functional",
+  kafi: "non-functional",
+  asavari: "non-functional",
+  bhairavi: "non-functional",
+  bhairav: "non-functional",
+  kalyan: "non-functional",
+  marwa: "non-functional",
+  purvi: "non-functional",
+  todi: "non-functional"
+});
+var SYSTEM_BY_MASK = (() => {
+  const byMask = /* @__PURE__ */ new Map();
+  const names = [
+    ...Object.keys(NAMED_SCALES),
+    ...Object.keys(WORLD_SCALES)
+  ];
+  for (const name of names) {
+    const mask = Object.hasOwn(NAMED_SCALES, name) ? NAMED_SCALES[name] : WORLD_SCALES[name];
+    if (!byMask.has(mask)) {
+      byMask.set(mask, SCALE_SYSTEMS[name]);
+    }
+  }
+  return byMask;
+})();
+function scaleSystemOf(scale) {
+  if (typeof scale === "string") {
+    const canonical = resolveScaleName(scale);
+    if (canonical === void 0) {
+      throw new InvalidInputError(`Unknown scale: ${scale}`);
+    }
+    return SCALE_SYSTEMS[canonical];
+  }
+  return SYSTEM_BY_MASK.get(scale.modeMask12);
+}
+function supportsFunctionalHarmony(scale) {
+  return scaleSystemOf(scale) !== "non-functional";
+}
+
+// src/theory/chord/spec.ts
+var BASE_TONES = {
+  maj: [
+    [1, 0],
+    [3, 4],
+    [5, 7]
+  ],
+  min: [
+    [1, 0],
+    [3, 3],
+    [5, 7]
+  ],
+  dim: [
+    [1, 0],
+    [3, 3],
+    [5, 6]
+  ],
+  aug: [
+    [1, 0],
+    [3, 4],
+    [5, 8]
+  ],
+  sus2: [
+    [1, 0],
+    [3, 2],
+    [5, 7]
+  ],
+  sus4: [
+    [1, 0],
+    [3, 5],
+    [5, 7]
+  ],
+  power: [
+    [1, 0],
+    [5, 7]
+  ]
+};
+var SEVENTH_SEMITONES = { maj7: 11, min7: 10, dim7: 9 };
+var DEGREE_SEMITONES = { 6: 9, 9: 14, 11: 17, 13: 21 };
+var PERFECT_FIFTH = 7;
+var OMITTABLE_DEGREES = [1, 3, 5];
+var BASE_QUALITY = {
+  maj: "maj",
+  min: "min",
+  dim: "dim",
+  aug: "aug",
+  sus2: "sus2",
+  sus4: "sus4",
+  power: "5"
+};
+function parts(base, spec = {}) {
+  const built = {
+    rootPc: 0,
+    base,
+    alterations: (spec.alt ?? []).map(([degree, alter]) => ({ degree, alter })),
+    additions: [...spec.add ?? []],
+    omissions: [...spec.omit ?? []]
+  };
+  if (spec.seventh !== void 0) {
+    built.seventh = spec.seventh;
+  }
+  return built;
+}
+var QUALITY_SPECS = {
+  maj: parts("maj"),
+  min: parts("min"),
+  dim: parts("dim"),
+  aug: parts("aug"),
+  majb5: parts("maj", { alt: [[5, -1]] }),
+  maj7: parts("maj", { seventh: "maj7" }),
+  min7: parts("min", { seventh: "min7" }),
+  dom7: parts("maj", { seventh: "min7" }),
+  dim7: parts("dim", { seventh: "dim7" }),
+  m7b5: parts("dim", { seventh: "min7" }),
+  minMaj7: parts("min", { seventh: "maj7" }),
+  minMaj9: parts("min", { seventh: "maj7", alt: [[9, 0]] }),
+  minMaj11: parts("min", {
+    seventh: "maj7",
+    alt: [
+      [9, 0],
+      [11, 0]
+    ]
+  }),
+  minMaj13: parts("min", {
+    seventh: "maj7",
+    alt: [
+      [9, 0],
+      [13, 0]
+    ]
+  }),
+  aug7: parts("aug", { seventh: "min7" }),
+  augMaj7: parts("aug", { seventh: "maj7" }),
+  "6": parts("maj", { add: [6] }),
+  min6: parts("min", { add: [6] }),
+  "6/9": parts("maj", { add: [6, 9] }),
+  sus2: parts("sus2"),
+  sus4: parts("sus4"),
+  add9: parts("maj", { add: [9] }),
+  add11: parts("maj", { add: [11] }),
+  maj9: parts("maj", { seventh: "maj7", alt: [[9, 0]] }),
+  min9: parts("min", { seventh: "min7", alt: [[9, 0]] }),
+  dom9: parts("maj", { seventh: "min7", alt: [[9, 0]] }),
+  "7b9": parts("maj", { seventh: "min7", alt: [[9, -1]] }),
+  "7#9": parts("maj", { seventh: "min7", alt: [[9, 1]] }),
+  "7#11": parts("maj", { seventh: "min7", alt: [[11, 1]] }),
+  "7b13": parts("maj", { seventh: "min7", alt: [[13, -1]] }),
+  // The eleventh chord as a chart voices it: the third gives way to the
+  // eleventh a semitone above it rather than sounding against it.
+  "11": parts("maj", {
+    seventh: "min7",
+    alt: [
+      [9, 0],
+      [11, 0]
+    ],
+    omit: [3]
+  }),
+  "13": parts("maj", {
+    seventh: "min7",
+    alt: [
+      [9, 0],
+      [13, 0]
+    ]
+  }),
+  "5": parts("power"),
+  "7sus4": parts("sus4", { seventh: "min7" }),
+  "7b5": parts("maj", { seventh: "min7", alt: [[5, -1]] }),
+  // The altered dominant as it is voiced from a lead sheet: a dominant seventh
+  // with a raised fifth and a raised ninth. The full seven-note altered stack
+  // has no seven-letter spelling, so it is not what this symbol denotes.
+  "7alt": parts("aug", { seventh: "min7", alt: [[9, 1]] }),
+  "13b9": parts("maj", {
+    seventh: "min7",
+    alt: [
+      [9, -1],
+      [13, 0]
+    ]
+  }),
+  maj13: parts("maj", {
+    seventh: "maj7",
+    alt: [
+      [9, 0],
+      [13, 0]
+    ]
+  }),
+  "maj7#11": parts("maj", { seventh: "maj7", alt: [[11, 1]] }),
+  min11: parts("min", {
+    seventh: "min7",
+    alt: [
+      [9, 0],
+      [11, 0]
+    ]
+  }),
+  min13: parts("min", {
+    seventh: "min7",
+    alt: [
+      [9, 0],
+      [13, 0]
+    ]
+  }),
+  minAdd9: parts("min", { add: [9] }),
+  "min6/9": parts("min", { add: [6, 9] })
+};
+function normalizeChordSpec(spec) {
+  let base = spec.base;
+  const alterations = /* @__PURE__ */ new Map();
+  for (const alteration of spec.alterations ?? []) {
+    alterations.set(alteration.degree, alteration.alter);
+  }
+  const additions = new Set(spec.additions ?? []);
+  const omissions = new Set(spec.omissions ?? []);
+  const fifth = alterations.get(5);
+  if (fifth !== void 0) {
+    if (base === "aug") {
+      base = "maj";
+    } else if (base === "dim") {
+      base = "min";
+    }
+    if (fifth === 0) {
+      alterations.delete(5);
+    } else if (base === "maj" && fifth === 1) {
+      base = "aug";
+      alterations.delete(5);
+    } else if (base === "min" && fifth === -1) {
+      base = "dim";
+      alterations.delete(5);
+    }
+  }
+  if (spec.seventh === void 0) {
+    for (const [degree, alter] of [...alterations]) {
+      if (degree !== 5 && alter === 0) {
+        alterations.delete(degree);
+        additions.add(degree);
+      }
+    }
+  }
+  const normalized = {
+    rootPc: spec.rootPc,
+    base,
+    alterations: [...alterations].sort((a, b) => a[0] - b[0]).map(([degree, alter]) => ({ degree, alter })),
+    additions: [...additions].sort((a, b) => a - b),
+    omissions: [...omissions].sort((a, b) => a - b)
+  };
+  if (spec.seventh !== void 0) {
+    normalized.seventh = spec.seventh;
+  }
+  if (spec.bassPc !== void 0) {
+    normalized.bassPc = spec.bassPc;
+  }
+  return normalized;
+}
+function specIntervals(normalized) {
+  const tones = new Map(BASE_TONES[normalized.base]);
+  for (const { degree, alter } of normalized.alterations) {
+    if (degree === 5 && tones.has(5)) {
+      tones.set(5, PERFECT_FIFTH + alter);
+    }
+  }
+  for (const degree of normalized.omissions) {
+    tones.delete(degree);
+  }
+  const offsets = new Set(tones.values());
+  if (normalized.seventh !== void 0) {
+    offsets.add(SEVENTH_SEMITONES[normalized.seventh]);
+  }
+  for (const { degree, alter } of normalized.alterations) {
+    if (degree !== 5) {
+      offsets.add((DEGREE_SEMITONES[degree] ?? 0) + alter);
+    }
+  }
+  for (const degree of normalized.additions) {
+    offsets.add(DEGREE_SEMITONES[degree] ?? 0);
+  }
+  return [...offsets].sort((a, b) => a - b);
+}
+function chordSpecIntervals(spec) {
+  return specIntervals(assertChordSpec(spec));
+}
+var QUALITY_INTERVALS = Object.fromEntries(
+  Object.keys(QUALITY_SPECS).map((quality) => [
+    quality,
+    specIntervals(normalizeChordSpec(QUALITY_SPECS[quality]))
+  ])
+);
+function specKey(spec) {
+  const normalized = normalizeChordSpec(spec);
+  return [
+    normalized.base,
+    normalized.seventh ?? "",
+    normalized.alterations.map(({ degree, alter }) => `${alter}:${degree}`).join("."),
+    normalized.additions.join("."),
+    normalized.omissions.join(".")
+  ].join("|");
+}
+var QUALITY_BY_KEY = new Map(
+  Object.keys(QUALITY_SPECS).map((quality) => [
+    specKey(QUALITY_SPECS[quality]),
+    quality
+  ])
+);
+function chordSpecForQuality(quality, rootPc, bassPc) {
+  if (!Object.hasOwn(QUALITY_SPECS, quality)) {
+    throw new InvalidInputError(`Unknown chord quality: ${String(quality)}`);
+  }
+  const spec = normalizeChordSpec(QUALITY_SPECS[quality]);
+  spec.rootPc = rootPc;
+  if (bassPc !== void 0) {
+    spec.bassPc = bassPc;
+  }
+  return spec;
+}
+function exactChordSpecQuality(spec) {
+  return QUALITY_BY_KEY.get(specKey(spec));
+}
+function chordSpecQuality(spec) {
+  const checked = assertChordSpec(spec);
+  const exact = exactChordSpecQuality(checked);
+  if (exact !== void 0) {
+    return exact;
+  }
+  const offsets = new Set(specIntervals(checked));
+  let nearest;
+  let size = 0;
+  for (const quality of Object.keys(QUALITY_INTERVALS)) {
+    const template = QUALITY_INTERVALS[quality];
+    if (template.length > size && template.every((offset) => offsets.has(offset))) {
+      nearest = quality;
+      size = template.length;
+    }
+  }
+  return nearest ?? BASE_QUALITY[checked.base];
+}
+var EXTENSION_BY_SEMITONE = /* @__PURE__ */ new Map([
+  [13, { degree: 9, alter: -1 }],
+  [14, { degree: 9, alter: 0 }],
+  [15, { degree: 9, alter: 1 }],
+  [16, { degree: 11, alter: -1 }],
+  [17, { degree: 11, alter: 0 }],
+  [18, { degree: 11, alter: 1 }],
+  [20, { degree: 13, alter: -1 }],
+  [21, { degree: 13, alter: 0 }],
+  [22, { degree: 13, alter: 1 }]
+]);
+function sameOffsets(a, b) {
+  return a.length === b.length && a.every((offset, index) => offset === b[index]);
+}
+function chordSpecFromIntervals(intervals) {
+  const offsets = [...new Set(intervals)].sort((a, b) => a - b);
+  const has = (offset) => offsets.includes(offset);
+  const alterations = [];
+  const additions = [];
+  const omissions = [];
+  if (!has(0)) {
+    omissions.push(1);
+  }
+  const third = has(4) ? 4 : has(3) ? 3 : has(5) ? 5 : has(2) ? 2 : void 0;
+  const fifth = has(7) ? 7 : has(6) ? 6 : has(8) ? 8 : void 0;
+  let base = "maj";
+  if (third === 3) {
+    base = "min";
+  } else if (third === 5) {
+    base = "sus4";
+  } else if (third === 2) {
+    base = "sus2";
+  } else if (third === void 0) {
+    if (fifth === 7 && offsets.length === 2 && has(0)) {
+      base = "power";
+    } else {
+      omissions.push(3);
+    }
+  }
+  if (fifth === void 0) {
+    omissions.push(5);
+  } else if (fifth !== 7) {
+    if (base === "maj" && fifth === 8) {
+      base = "aug";
+    } else if (base === "min" && fifth === 6) {
+      base = "dim";
+    } else {
+      alterations.push({ degree: 5, alter: fifth === 6 ? -1 : 1 });
+    }
+  }
+  let seventh = has(11) ? "maj7" : has(10) ? "min7" : void 0;
+  if (has(9)) {
+    if (seventh === void 0 && base === "dim") {
+      seventh = "dim7";
+    } else {
+      additions.push(6);
+    }
+  }
+  for (const offset of offsets) {
+    if (offset <= 12) {
+      continue;
+    }
+    const extension = EXTENSION_BY_SEMITONE.get(offset);
+    if (extension === void 0) {
+      return void 0;
+    }
+    alterations.push(extension);
+  }
+  const spec = { rootPc: 0, base, alterations, additions, omissions };
+  if (seventh !== void 0) {
+    spec.seventh = seventh;
+  }
+  const normalized = normalizeChordSpec(spec);
+  return sameOffsets(specIntervals(normalized), offsets) ? normalized : void 0;
+}
+function assertPart(value, allowed, name) {
+  if (!allowed.includes(value)) {
+    throw new InvalidInputError(
+      `${name} must be one of ${allowed.join(", ")}; received ${JSON.stringify(value)}`
+    );
+  }
+  return value;
+}
+function assertDegreeIn(value, allowed, name) {
+  if (!allowed.includes(value)) {
+    throw new InvalidInputError(
+      `${name} must be one of ${allowed.join(", ")}; received ${String(value)}`
+    );
+  }
+  return value;
+}
+function assertDegreeList(value, allowed, name) {
+  if (!Array.isArray(value)) {
+    throw new InvalidInputError(`${name} must be an array; received ${typeof value}`);
+  }
+  for (const degree of value) {
+    assertDegreeIn(degree, allowed, name);
+  }
+}
+function assertChordSpec(spec) {
+  if (spec === null || typeof spec !== "object") {
+    throw new InvalidInputError(`chord spec must be an object; received ${typeof spec}`);
+  }
+  assertFiniteNumber(spec.rootPc, "chord spec rootPc");
+  if (spec.bassPc !== void 0) {
+    assertFiniteNumber(spec.bassPc, "chord spec bassPc");
+  }
+  assertPart(spec.base, Object.keys(BASE_TONES), "chord spec base");
+  if (spec.seventh !== void 0) {
+    assertPart(
+      spec.seventh,
+      Object.keys(SEVENTH_SEMITONES),
+      "chord spec seventh"
+    );
+  }
+  if (!Array.isArray(spec.alterations)) {
+    throw new InvalidInputError("chord spec alterations must be an array");
+  }
+  for (const alteration of spec.alterations) {
+    assertDegreeIn(alteration?.degree, [5, 9, 11, 13], "chord spec alteration degree");
+    assertDegreeIn(alteration.alter, [-1, 0, 1], "chord spec alteration");
+  }
+  assertDegreeList(spec.additions, [6, 9, 11, 13], "chord spec additions");
+  assertDegreeList(spec.omissions, OMITTABLE_DEGREES, "chord spec omissions");
+  return normalizeChordSpec(spec);
+}
+
+// src/theory/chord/index.ts
+var MAX_CHORD_INTERVAL = 127;
+function chordQualities() {
+  return Object.keys(QUALITY_INTERVALS);
+}
+function chordFromDegree(degree, ext, key) {
+  assertDegree(degree, "chord degree");
+  if (!Object.hasOwn(QUALITY_INTERVALS, ext)) {
+    throw new InvalidInputError(`Unknown chord quality: ${String(ext)}`);
+  }
+  const scale = toKeyScale(key);
+  const tones = scaleTonesInDegreeOrder(scale);
+  const length = tones.length;
+  const index = length > 0 ? (degree - 1) % length : 0;
+  const rootPc = tones[index] ?? pitchClassOf(scale.rootPc);
+  return { rootPc, quality: ext, intervals: [...QUALITY_INTERVALS[ext]] };
+}
+function makeChord(rootPc, quality, bassPc) {
+  assertFiniteNumber(rootPc, "chord rootPc");
+  if (bassPc !== void 0) {
+    assertFiniteNumber(bassPc, "chord bassPc");
+  }
+  if (!Object.hasOwn(QUALITY_INTERVALS, quality)) {
+    throw new InvalidInputError(`Unknown chord quality: ${String(quality)}`);
+  }
+  const chord = {
+    rootPc: pitchClassOf(rootPc),
+    quality,
+    intervals: [...QUALITY_INTERVALS[quality] ?? []]
+  };
+  if (bassPc !== void 0) {
+    chord.bassPc = pitchClassOf(bassPc);
+  }
+  return chord;
+}
+function chordFromSpec(spec) {
+  const checked = assertChordSpec(spec);
+  const chord = {
+    rootPc: pitchClassOf(checked.rootPc),
+    quality: chordSpecQuality(checked),
+    intervals: chordSpecIntervals(checked)
+  };
+  if (checked.bassPc !== void 0) {
+    chord.bassPc = pitchClassOf(checked.bassPc);
+  }
+  return chord;
+}
+function chordSpecOf(chord) {
+  assertFiniteNumber(chord.rootPc, "chord rootPc");
+  const rootPc = pitchClassOf(chord.rootPc);
+  const bassPc = chord.bassPc === void 0 ? void 0 : pitchClassOf(chord.bassPc);
+  const intervals = chord.intervals ?? [];
+  const read = intervals.length === 0 ? void 0 : chordSpecFromIntervals(intervals);
+  if (read === void 0) {
+    return chordSpecForQuality(chord.quality, rootPc, bassPc);
+  }
+  read.rootPc = rootPc;
+  if (bassPc !== void 0) {
+    read.bassPc = bassPc;
+  }
+  return read;
+}
+function copySpanIntervals(intervals) {
+  const name = "chord span intervals";
+  if (!Array.isArray(intervals)) {
+    throw new InvalidInputError(`${name} must be an array; received ${typeof intervals}`);
+  }
+  if (intervals.length === 0) {
+    throw new InvalidInputError(`${name} must name at least one interval`);
+  }
+  const copy = [];
+  for (let index = 0; index < intervals.length; index += 1) {
+    const interval = intervals[index];
+    if (interval === void 0) {
+      throw new InvalidInputError(
+        `${name}[${index}] must be a semitone offset; received undefined`
+      );
+    }
+    copy.push(
+      assertInteger(interval, `${name}[${index}]`, -MAX_CHORD_INTERVAL, MAX_CHORD_INTERVAL)
+    );
+  }
+  return copy;
+}
+function hasCustomIntervals(chord) {
+  return !matchesQualityIntervals(chord.quality, chord.intervals);
+}
+function chordFromSpan(span) {
+  const chord = makeChord(span.rootPc, span.quality, span.bassPc);
+  if (span.intervals !== void 0) {
+    chord.intervals = copySpanIntervals(span.intervals);
+  }
+  return chord;
+}
+function spanFromChord(chord, startBeat) {
+  assertFiniteNumber(startBeat, "chord span startBeat");
+  if (!Object.hasOwn(QUALITY_INTERVALS, chord.quality)) {
+    throw new InvalidInputError(`Unknown chord quality: ${String(chord.quality)}`);
+  }
+  const span = { rootPc: chord.rootPc, quality: chord.quality, startBeat };
+  if (chord.bassPc !== void 0) {
+    span.bassPc = chord.bassPc;
+  }
+  if (hasCustomIntervals(chord)) {
+    span.intervals = [...chord.intervals];
+  }
+  return span;
+}
+function transposeChord(chord, semitones) {
+  assertFiniteNumber(semitones, "semitones");
+  const steps = Math.round(semitones);
+  const moved = {
+    rootPc: pitchClassOf(chord.rootPc + steps),
+    quality: chord.quality,
+    intervals: [...chord.intervals]
+  };
+  if (chord.bassPc !== void 0) {
+    moved.bassPc = pitchClassOf(chord.bassPc + steps);
+  }
+  return moved;
+}
+function chordToneSpellings(chord) {
+  const hints = chord.toneSpellings;
+  if (hints === void 0 || hints.length !== chord.intervals.length) {
+    return void 0;
+  }
+  const usable = [];
+  for (let index = 0; index < hints.length; index += 1) {
+    const hint = hints[index];
+    const interval = chord.intervals[index];
+    if (hint === void 0 || interval === void 0) {
+      return void 0;
+    }
+    if (noteToPitchClass(hint) !== pitchClassOf(chord.rootPc + interval)) {
+      return void 0;
+    }
+    usable.push({ letter: diatonicLetterOf(hint.letter), alter: hint.alter });
+  }
+  return usable;
+}
+function chordPitchClasses(chord, opts = {}) {
+  const set = /* @__PURE__ */ new Set();
+  for (const interval of chord.intervals) {
+    set.add(pitchClassOf(chord.rootPc + interval));
+  }
+  if (opts.includeBass !== false && chord.bassPc !== void 0) {
+    set.add(pitchClassOf(chord.bassPc));
+  }
+  return [...set].sort((a, b) => a - b);
+}
+function intervalAboveRoot(pitch, chord) {
+  return ((pitchClassOf(pitch) - pitchClassOf(chord.rootPc)) % 12 + 12) % 12;
+}
+function isChordMember(pitch, chord) {
+  return chord === null ? false : chordPitchClasses(chord).includes(pitchClassOf(pitch));
+}
+function chordToneOffsets(chord) {
+  return new Set(chord.intervals.map((i) => (i % 12 + 12) % 12));
+}
+function chordToneRole(pitch, chord) {
+  const interval = (pitchClassOf(pitch) - pitchClassOf(chord.rootPc) + 12) % 12;
+  const tones = chordToneOffsets(chord);
+  if (interval === 0) {
+    return "root";
+  }
+  if (interval === 3 || interval === 4) {
+    return tones.has(interval) && (interval !== 3 || !tones.has(4)) ? "third" : null;
+  }
+  if (interval === 7) {
+    return tones.has(7) ? "fifth" : null;
+  }
+  if (interval === 6) {
+    return tones.has(6) && !tones.has(7) ? "fifth" : null;
+  }
+  if (interval === 8) {
+    return tones.has(8) && !tones.has(7) ? "fifth" : null;
+  }
+  if (interval === 9) {
+    const hasHigherSeventh = tones.has(10) || tones.has(11);
+    const isDiminishedSeventh = tones.has(3) && tones.has(6) && !hasHigherSeventh;
+    if (tones.has(9) && isDiminishedSeventh) {
+      return "seventh";
+    }
+    if (tones.has(9) && !hasHigherSeventh) {
+      return "sixth";
+    }
+    return null;
+  }
+  if (interval === 10 || interval === 11) {
+    return tones.has(interval) ? "seventh" : null;
+  }
+  return null;
+}
+function classifyTriad(thirdIc, fifthIc) {
+  if (thirdIc === 4 && fifthIc === 8) {
+    return "aug";
+  }
+  if (thirdIc === 4 && fifthIc === 6) {
+    return "majb5";
+  }
+  if (thirdIc === 3 && fifthIc === 6) {
+    return "dim";
+  }
+  if (thirdIc === 3) {
+    return "min";
+  }
+  return "maj";
+}
+function classifySeventh(thirdIc, fifthIc, seventhIc) {
+  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 9) {
+    return "dim7";
+  }
+  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 10) {
+    return "m7b5";
+  }
+  if (thirdIc === 3 && seventhIc === 11) {
+    return "minMaj7";
+  }
+  if (thirdIc === 3) {
+    return "min7";
+  }
+  if (fifthIc === 8 && seventhIc === 10) {
+    return "aug7";
+  }
+  if (fifthIc === 8 && seventhIc === 11) {
+    return "augMaj7";
+  }
+  if (fifthIc === 6 && seventhIc === 10) {
+    return "7b5";
+  }
+  if (seventhIc === 11) {
+    return "maj7";
+  }
+  return "dom7";
+}
+function matchesQualityIntervals(quality, intervals) {
+  const template = QUALITY_INTERVALS[quality];
+  return template.length === intervals.length && template.every((interval, index) => interval === intervals[index]);
+}
+function stackThirds(degree, key, size) {
+  assertDegree(degree, "chord degree");
+  const tones = scaleTonesInDegreeOrder(key);
+  const length = tones.length;
+  if (length !== 7) {
+    throw new InvalidInputError(
+      `diatonic chord stacking requires a heptatonic scale (received ${length} tones)`
+    );
+  }
+  const idx = (step) => (degree - 1 + step) % length;
+  const rootPc = tones[idx(0)] ?? pitchClassOf(key.rootPc);
+  const offsets = [0, 2, 4, 6].slice(0, size).map((step) => {
+    const pc = tones[idx(step)] ?? rootPc;
+    return ((pc - rootPc) % 12 + 12) % 12;
+  });
+  const thirdIc = offsets[1] ?? 4;
+  const fifthIc = offsets[2] ?? 7;
+  const quality = size === 3 ? classifyTriad(thirdIc, fifthIc) : classifySeventh(thirdIc, fifthIc, offsets[3] ?? 11);
+  if (!matchesQualityIntervals(quality, offsets)) {
+    throw new InvalidInputError(
+      `scale thirds at degree ${degree} produce unsupported intervals [${offsets.join(", ")}]`
+    );
+  }
+  return { rootPc, quality, intervals: offsets };
+}
+function diatonicTriad(degree, key) {
+  return stackThirds(degree, toKeyScale(key), 3);
+}
+function diatonicSeventh(degree, key) {
+  return stackThirds(degree, toKeyScale(key), 4);
+}
+
+// src/theory/spelling/index.ts
+var CHROMATIC_SPELLING = {
+  1: 1,
+  // b2
+  2: 1,
+  // M2
+  3: 2,
+  // b3
+  4: 2,
+  // M3
+  5: 3,
+  // P4
+  6: 3,
+  // #4
+  7: 4,
+  // P5
+  8: 5,
+  // b6
+  9: 5,
+  // #6 (raised sixth of a minor key)
+  10: 6,
+  // b7
+  11: 6
+  // #7 (raised leading tone of a minor key)
+};
+var CHROMATIC_SPELLING_FLAT = {
+  ...CHROMATIC_SPELLING,
+  6: 4
+  // b5
+};
+var CHROMATIC_SPELLING_SHARP = {
+  1: 0,
+  // #1
+  2: 1,
+  // M2
+  3: 1,
+  // #2
+  4: 2,
+  // M3
+  5: 3,
+  // P4
+  6: 3,
+  // #4
+  7: 4,
+  // P5
+  8: 4,
+  // #5
+  9: 5,
+  // M6
+  10: 5,
+  // #6
+  11: 6
+  // M7
+};
+function notePitchClass(note) {
+  return pitchClassOf(naturalPitchClassOf(note.letter) + note.alter);
+}
+function assertTonicOf(tonic, key, source) {
+  const tonicPc = notePitchClass(tonic);
+  const rootPc = pitchClassOf(key.rootPc);
+  if (tonicPc !== rootPc) {
+    const name = formatNote({ letter: diatonicLetterOf(tonic.letter), alter: tonic.alter });
+    throw new InvalidInputError(
+      `${source}: tonic ${name} sounds pitch class ${tonicPc}, not the key root ${rootPc}; pass a tonic that spells the key root, or take one from spelledKeyOf`
+    );
+  }
+}
+function alterFor(letter, pc) {
+  let d = pitchClassOf(pc - naturalPitchClassOf(letter));
+  if (d > 6) {
+    d -= 12;
+  }
+  return d;
+}
+function letterFor(tonic, degreeOffset, pc) {
+  if (degreeOffset === void 0) {
+    return void 0;
+  }
+  const letter = diatonicLetterOf(tonic.letter + degreeOffset);
+  return { letter, alter: alterFor(letter, pc) };
+}
+function pickSpelling(flat, sharp, preferFlat) {
+  if (flat === void 0 || sharp === void 0) {
+    return flat ?? sharp;
+  }
+  if (Math.abs(flat.alter) !== Math.abs(sharp.alter)) {
+    return Math.abs(flat.alter) < Math.abs(sharp.alter) ? flat : sharp;
+  }
+  return preferFlat ? flat : sharp;
+}
+function capChromaticAccidentals(preferred, alternative) {
+  return alternative !== void 0 && Math.abs(preferred.alter) - Math.abs(alternative.alter) >= 2 ? alternative : preferred;
+}
+var DIATONIC_LETTER_COUNT = 7;
+function isHeptatonic(key) {
+  return scaleTonesInDegreeOrder(key).length === DIATONIC_LETTER_COUNT;
+}
+function hasMinorThird2(key) {
+  const tones = scaleTonesInDegreeOrder(key);
+  const root = pitchClassOf(key.rootPc);
+  return tones.includes(pitchClassOf(root + 3)) && !tones.includes(pitchClassOf(root + 4));
+}
+function leansFlat(tonic, key) {
+  return tonic.alter < 0 || hasMinorThird2(key);
+}
+function gappedCandidates(tonic, offset, pc, preferFlat) {
+  const flat = letterFor(tonic, CHROMATIC_SPELLING_FLAT[offset], pc);
+  const sharp = letterFor(tonic, CHROMATIC_SPELLING_SHARP[offset], pc);
+  const preferred = pickSpelling(flat, sharp, preferFlat);
+  if (preferred === void 0) {
+    return [];
+  }
+  const alternative = preferred === flat ? sharp : flat;
+  return alternative === void 0 || alternative.letter === preferred.letter ? [preferred] : [preferred, alternative];
+}
+function assignDistinctLetters(candidates, reserved) {
+  let best;
+  let bestAlter = 0;
+  let bestDeviations = 0;
+  for (let choice = 0; choice < 1 << candidates.length; choice += 1) {
+    const picked = [];
+    let letters = reserved;
+    let alter = 0;
+    let deviations = 0;
+    for (const [index, options] of candidates.entries()) {
+      const preferred = options[0];
+      const note = options[choice >> index & 1] ?? preferred;
+      if (note === void 0 || (letters & 1 << note.letter) !== 0) {
+        break;
+      }
+      letters |= 1 << note.letter;
+      alter += Math.abs(note.alter);
+      deviations += note === preferred ? 0 : 1;
+      picked.push(note);
+    }
+    if (picked.length !== candidates.length) {
+      continue;
+    }
+    if (best === void 0 || alter < bestAlter || alter === bestAlter && deviations < bestDeviations) {
+      best = picked;
+      bestAlter = alter;
+      bestDeviations = deviations;
+    }
+  }
+  return best;
+}
+function spellGappedScale(tonic, key) {
+  const tones = scaleTonesInDegreeOrder(key);
+  if (tones.length > DIATONIC_LETTER_COUNT) {
+    return void 0;
+  }
+  const tonicPc = pitchClassOf(naturalPitchClassOf(tonic.letter) + tonic.alter);
+  const tonicNote = { letter: diatonicLetterOf(tonic.letter), alter: tonic.alter };
+  const preferFlat = leansFlat(tonic, key);
+  const rest = tones.filter((pc) => pitchClassOf(pc - tonicPc) !== 0);
+  const chosen = assignDistinctLetters(
+    rest.map((pc) => gappedCandidates(tonic, pitchClassOf(pc - tonicPc), pc, preferFlat)),
+    1 << tonicNote.letter
+  );
+  if (chosen === void 0) {
+    return void 0;
+  }
+  const spellings = /* @__PURE__ */ new Map([[tonicPc, tonicNote]]);
+  for (const [index, pc] of rest.entries()) {
+    const note = chosen[index];
+    if (note !== void 0) {
+      spellings.set(pitchClassOf(pc), note);
+    }
+  }
+  return spellings;
+}
+function spellByKey(pc, tonic, key) {
+  const tonicPc = pitchClassOf(naturalPitchClassOf(tonic.letter) + tonic.alter);
+  const offset = pitchClassOf(pc - tonicPc);
+  if (offset === 0) {
+    return { letter: diatonicLetterOf(tonic.letter), alter: tonic.alter };
+  }
+  const heptatonic = isHeptatonic(key);
+  if (heptatonic) {
+    const degree = scaleTonesInDegreeOrder(key).indexOf(pitchClassOf(pc));
+    if (degree >= 0) {
+      const letter = diatonicLetterOf(tonic.letter + degree);
+      return { letter, alter: alterFor(letter, pc) };
+    }
+    const degreeOffset = CHROMATIC_SPELLING[offset];
+    const preferred = letterFor(tonic, degreeOffset, pc);
+    if (preferred !== void 0) {
+      const flat = letterFor(tonic, CHROMATIC_SPELLING_FLAT[offset], pc);
+      const sharp = letterFor(tonic, CHROMATIC_SPELLING_SHARP[offset], pc);
+      const alternative = flat?.letter === preferred.letter ? sharp : sharp?.letter === preferred.letter ? flat : void 0;
+      return capChromaticAccidentals(preferred, alternative);
+    }
+  } else {
+    if (isScaleTone(pc, key)) {
+      const assigned = spellGappedScale(tonic, key)?.get(pitchClassOf(pc));
+      if (assigned !== void 0) {
+        return assigned;
+      }
+    }
+    const [preferred] = gappedCandidates(tonic, offset, pc, leansFlat(tonic, key));
+    if (preferred !== void 0) {
+      return preferred;
+    }
+  }
+  const belowLetter = diatonicLetterOf([0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6][pitchClassOf(pc)] ?? 0);
+  return { letter: belowLetter, alter: alterFor(belowLetter, pc) };
+}
+var CHORD_TONE_LETTER_STEPS = {
+  0: 0,
+  // root
+  3: 2,
+  // minor third
+  4: 2,
+  // major third
+  7: 4,
+  // perfect fifth
+  10: 6,
+  // minor seventh
+  11: 6
+  // major seventh
+};
+var MAX_CONTEXT_ALTER = 2;
+function chordToneSpelling(pc, chordRoot, tonic, key) {
+  if (chordRoot === void 0) {
+    return void 0;
+  }
+  const root = spellByKey(pitchClassOf(chordRoot), tonic, key);
+  return letterFor(root, CHORD_TONE_LETTER_STEPS[pitchClassOf(pc - chordRoot)], pc);
+}
+function neighbourSpelling(neighbour, gap, letterStep, pc, tonic, key) {
+  if (neighbour === void 0 || pitchClassOf(neighbour - pc) !== pitchClassOf(gap)) {
+    return void 0;
+  }
+  return letterFor(spellByKey(pitchClassOf(neighbour), tonic, key), letterStep, pc);
+}
+function refineByContext(pc, tonic, key, context, keySpelling) {
+  const tonicPc = pitchClassOf(naturalPitchClassOf(tonic.letter) + tonic.alter);
+  if (pitchClassOf(pc) === tonicPc || isScaleTone(pc, key)) {
+    return keySpelling;
+  }
+  const { chordRoot, previous, next } = context;
+  const candidates = [
+    // The sounding chord names the pitch by its interval above the root.
+    chordToneSpelling(pc, chordRoot, tonic, key),
+    // A semitone below what follows: the pitch is its leading tone, a letter down.
+    neighbourSpelling(next, 1, -1, pc, tonic, key),
+    // A semitone above what preceded: the pitch is that note inflected upward,
+    // so it keeps its letter and a chromatic ascent spells with sharps.
+    neighbourSpelling(previous, -1, 0, pc, tonic, key),
+    // A semitone above what follows: the pitch leans on it from a letter up,
+    // so a falling line spells with flats.
+    neighbourSpelling(next, -1, 1, pc, tonic, key),
+    // Failing that, a semitone below what preceded: that note inflected downward,
+    // again on its own letter.
+    neighbourSpelling(previous, 1, 0, pc, tonic, key)
+  ];
+  for (const candidate of candidates) {
+    if (candidate !== void 0 && Math.abs(candidate.alter) <= MAX_CONTEXT_ALTER) {
+      return candidate;
+    }
+  }
+  return keySpelling;
+}
+function spellPitchClass(pc, tonic, key, context) {
+  const note = toNoteData(tonic);
+  const scale = toKeyScale(key);
+  assertTonicOf(note, scale, "spellPitchClass");
+  return spelledPitchClass(pc, note, scale, context);
+}
+function spelledPitchClass(pc, tonic, key, context) {
+  const keySpelling = spellByKey(pc, tonic, key);
+  return context === void 0 ? keySpelling : refineByContext(pc, tonic, key, context, keySpelling);
+}
+function spellScale(tonic, key) {
+  const note = toNoteData(tonic);
+  const scale = key;
+  assertTonicOf(note, scale, "spellScale");
+  return scaleTonesInDegreeOrder(scale).map((pc) => spelledPitchClass(pc, note, scale));
+}
+function spellPitchClasses(pcs, tonic, key) {
+  const note = toNoteData(tonic);
+  const scale = toKeyScale(key);
+  assertTonicOf(note, scale, "spellPitchClasses");
+  return pcs.map((pc) => spelledPitchClass(pc, note, scale));
+}
+function chordLetterOffset(interval, chord) {
+  switch (interval) {
+    case 0:
+    case 12:
+      return 0;
+    case 1:
+    case 2:
+    case 13:
+    case 14:
+      return 1;
+    case 3:
+    case 4:
+    case 16:
+      return 2;
+    case 15:
+      return chord.intervals.some((i) => i === 3 || i === 4) ? 1 : 2;
+    case 5:
+    case 17:
+    case 18:
+      return 3;
+    case 6:
+    case 7:
+    case 8:
+    case 19:
+      return 4;
+    case 9:
+      return chord.quality === "dim7" ? 6 : 5;
+    case 20:
+    case 21:
+      return 5;
+    case 10:
+    case 11:
+    case 22:
+    case 23:
+      return 6;
+    default: {
+      const octaves = Math.floor(Math.max(0, interval) / 12);
+      const simple = pitchClassOf(interval);
+      const simpleOffset = [0, 1, 1, 2, 2, 3, 4, 4, 4, 5, 6, 6][simple] ?? 0;
+      return octaves * 7 + simpleOffset;
+    }
+  }
+}
+function hintedLetterOffsets(chord) {
+  const hints = chordToneSpellings(chord);
+  const rootHint = hints?.[chord.intervals.findIndex((interval) => pitchClassOf(interval) === 0)];
+  if (hints === void 0 || rootHint === void 0) {
+    return void 0;
+  }
+  return hints.map((hint) => diatonicLetterOf(hint.letter - rootHint.letter));
+}
+function spellChordFromRoot(chord, root) {
+  return chordTonesFromRoot(chord, toNoteData(root));
+}
+function chordTonesFromRoot(chord, root) {
+  if (pitchClassOf(naturalPitchClassOf(root.letter) + root.alter) !== pitchClassOf(chord.rootPc)) {
+    throw new InvalidInputError("chord root spelling must match chord.rootPc");
+  }
+  const hinted = hintedLetterOffsets(chord);
+  return chord.intervals.map((interval, index) => {
+    const letter = diatonicLetterOf(root.letter + (hinted?.[index] ?? chordLetterOffset(interval, chord)));
+    const pc = pitchClassOf(chord.rootPc + interval);
+    return { letter, alter: alterFor(letter, pc) };
+  });
+}
+function spellChord(chord, tonic, key) {
+  const note = toNoteData(tonic);
+  const scale = toKeyScale(key);
+  assertTonicOf(note, scale, "spellChord");
+  return chordTonesFromRoot(chord, chordRootSpelling(chord, note, scale));
+}
+function chordRootSpelling(chord, tonic, key) {
+  const hint = chord.rootSpelling;
+  if (hint !== void 0 && pitchClassOf(naturalPitchClassOf(hint.letter) + hint.alter) === pitchClassOf(chord.rootPc)) {
+    return { letter: diatonicLetterOf(hint.letter), alter: hint.alter };
+  }
+  return spelledPitchClass(chord.rootPc, tonic, key);
+}
+function spellPitch(pitch, tonic, key, context) {
+  const note = toNoteData(tonic);
+  const scale = toKeyScale(key);
+  assertTonicOf(note, scale, "spellPitch");
+  const rounded = Math.round(pitch);
+  const spelled = spelledPitchClass(pitchClassOf(rounded), note, scale, context);
+  const octave = (rounded - naturalPitchClassOf(spelled.letter) - spelled.alter) / 12 - 1;
+  return { letter: spelled.letter, alter: spelled.alter, octave };
+}
+function noteNames(notes) {
+  return notes.map((note) => formatNote(toNoteData(note)));
+}
+
+// src/theory/counterpoint/internal.ts
+function pitchOf(value) {
+  return typeof value === "number" ? value : noteToMidi(value);
+}
+function simpleIntervalNumber(numberValue) {
+  return (Math.abs(numberValue) - 1) % 7 + 1;
+}
+function classifySpelledInterval(interval, twoVoice = true) {
+  const simple = simpleIntervalNumber(interval.number);
+  const quality = interval.quality;
+  if (quality === "P") {
+    if (simple === 1 || simple === 5) {
+      return 0 /* PerfectConsonance */;
+    }
+    if (simple === 4) {
+      return twoVoice ? 2 /* Dissonance */ : 1 /* ImperfectConsonance */;
+    }
+    return 2 /* Dissonance */;
+  }
+  if ((quality === "M" || quality === "m") && (simple === 3 || simple === 6)) {
+    return 1 /* ImperfectConsonance */;
+  }
+  return 2 /* Dissonance */;
+}
+
+// src/theory/counterpoint/independence.ts
+function bothSound(slot) {
+  return slot.lead !== null && slot.counter !== null;
+}
+function attacksAt(index, notes, flags) {
+  if (flags !== void 0) {
+    return flags[index] === true;
+  }
+  const current = notes[index];
+  if (current === void 0 || current === null) {
+    return false;
+  }
+  const previous = index > 0 ? notes[index - 1] : void 0;
+  if (previous === void 0 || previous === null) {
+    return true;
+  }
+  return previous.letter !== current.letter || previous.alter !== current.alter || previous.octave !== current.octave;
+}
+function motionBetween(from, to) {
+  const leadMove = pitchOf(to.lead) - pitchOf(from.lead);
+  const counterMove = pitchOf(to.counter) - pitchOf(from.counter);
+  if (leadMove === 0 && counterMove === 0) {
+    return null;
+  }
+  if (leadMove === 0 || counterMove === 0) {
+    return "oblique";
+  }
+  if (leadMove > 0 !== counterMove > 0) {
+    return "contrary";
+  }
+  const before = simpleIntervalNumber(spelledInterval(from.counter, from.lead).number);
+  const after = simpleIntervalNumber(spelledInterval(to.counter, to.lead).number);
+  return before === after ? "parallel" : "similar";
+}
+function voiceIndependence(lead, counter, opts) {
+  if (lead.length !== counter.length) {
+    throw new InvalidInputError(
+      `voiceIndependence needs the two lines aligned slot for slot; received ${lead.length} and ${counter.length}`
+    );
+  }
+  for (const [name, flags] of [
+    ["leadAttacks", opts?.leadAttacks],
+    ["counterAttacks", opts?.counterAttacks]
+  ]) {
+    if (flags !== void 0 && flags.length !== lead.length) {
+      throw new InvalidInputError(
+        `voiceIndependence needs ${name} aligned slot for slot with the lines; received ${flags.length} and ${lead.length}`
+      );
+    }
+  }
+  const slots = lead.map((leadNote, index) => {
+    const counterNote = counter[index] ?? null;
+    return {
+      lead: leadNote,
+      counter: counterNote,
+      leadPitch: leadNote === null ? null : pitchOf(leadNote),
+      counterPitch: counterNote === null ? null : pitchOf(counterNote)
+    };
+  });
+  const counts = { contrary: 0, oblique: 0, similar: 0, parallel: 0 };
+  let moves = 0;
+  for (let index = 1; index < slots.length; index += 1) {
+    const from = slots[index - 1];
+    const to = slots[index];
+    if (from === void 0 || to === void 0 || !bothSound(from) || !bothSound(to)) {
+      continue;
+    }
+    const motion = motionBetween(from, to);
+    if (motion === null) {
+      continue;
+    }
+    counts[motion] += 1;
+    moves += 1;
+  }
+  let filled = 0;
+  let gaps = 0;
+  for (let index = 0; index < slots.length; index += 1) {
+    const leadHolds = !attacksAt(index, lead, opts?.leadAttacks);
+    if (!leadHolds) {
+      continue;
+    }
+    gaps += 1;
+    if (attacksAt(index, counter, opts?.counterAttacks)) {
+      filled += 1;
+    }
+  }
+  let sounding = 0;
+  let totalGap = 0;
+  let minGap = Number.POSITIVE_INFINITY;
+  let orderSum = 0;
+  let perfectRun = 0;
+  let longestPerfectRun = 0;
+  for (const slot of slots) {
+    if (slot.leadPitch === null || slot.counterPitch === null) {
+      perfectRun = 0;
+      continue;
+    }
+    sounding += 1;
+    const gap = slot.leadPitch - slot.counterPitch;
+    totalGap += Math.abs(gap);
+    minGap = Math.min(minGap, Math.abs(gap));
+    orderSum += Math.sign(gap);
+    const interval = spelledInterval(slot.counter, slot.lead);
+    const perfect = classifySpelledInterval(interval) === 0 /* PerfectConsonance */ || (opts?.countFourths ?? false) && interval.quality === "P" && simpleIntervalNumber(interval.number) === 4;
+    perfectRun = perfect ? perfectRun + 1 : 0;
+    longestPerfectRun = Math.max(longestPerfectRun, perfectRun);
+  }
+  const leadAbove = orderSum >= 0;
+  let crossings = 0;
+  for (const slot of slots) {
+    if (slot.leadPitch === null || slot.counterPitch === null) {
+      continue;
+    }
+    const gap = slot.leadPitch - slot.counterPitch;
+    if (gap !== 0 && gap > 0 !== leadAbove) {
+      crossings += 1;
+    }
+  }
+  return {
+    motion: {
+      contrary: moves === 0 ? 0 : counts.contrary / moves,
+      oblique: moves === 0 ? 0 : counts.oblique / moves,
+      similar: moves === 0 ? 0 : counts.similar / moves,
+      parallel: moves === 0 ? 0 : counts.parallel / moves
+    },
+    rhythmicComplementarity: gaps === 0 ? 0 : filled / gaps,
+    separation: {
+      mean: sounding === 0 ? 0 : totalGap / sounding,
+      min: sounding === 0 ? 0 : minGap
+    },
+    crossings,
+    longestPerfectRun,
+    sounding
+  };
+}
+
+// src/theory/counterpoint/index.ts
+function createsVoiceCrossing(upper, lower) {
+  return pitchOf(upper) < pitchOf(lower);
+}
+function createsVerticalDissonance(a, b, twoVoice) {
+  if (typeof a !== "number" && typeof b !== "number") {
+    return classifySpelledInterval(spelledInterval(a, b), twoVoice) === 2 /* Dissonance */;
+  }
+  return !isConsonantInterval(pitchOf(a) - pitchOf(b), twoVoice);
+}
+function isForbiddenMelodicLeap(prev, cur) {
+  if (typeof prev !== "number" && typeof cur !== "number") {
+    const interval = spelledInterval(prev, cur);
+    if (Math.abs(interval.semitones) > 12 || interval.number > 8) {
+      return true;
+    }
+    if (simpleIntervalNumber(interval.number) === 7) {
+      return true;
+    }
+    return isAlteredInterval(interval);
+  }
+  const semis = Math.abs(pitchOf(cur) - pitchOf(prev));
+  return semis === 6 || semis === 10 || semis === 11 || semis > 12;
+}
+function isAlteredInterval(interval) {
+  return interval.number >= 2 && (interval.quality.startsWith("A") || interval.quality[0] === "d");
+}
+function isAugmentedMelodicInterval(prev, cur) {
+  if (typeof prev === "number" || typeof cur === "number") {
+    return false;
+  }
+  const interval = spelledInterval(prev, cur);
+  return interval.number >= 2 && interval.quality.startsWith("A");
+}
+function simpleClass(semitones) {
+  return pitchClassOf(Math.abs(semitones));
+}
+function isPerfectClass(cls) {
+  return cls === 0 || cls === 7;
+}
+function similarMotion(aMove, bMove) {
+  return aMove !== 0 && bMove !== 0 && aMove > 0 === bMove > 0;
+}
+function bothVoicesMove(aMove, bMove) {
+  return aMove !== 0 && bMove !== 0;
+}
+function createsParallelPerfect(aPrev, aCur, bPrev, bCur) {
+  const a0 = pitchOf(aPrev);
+  const a1 = pitchOf(aCur);
+  const b0 = pitchOf(bPrev);
+  const b1 = pitchOf(bCur);
+  if (!bothVoicesMove(a1 - a0, b1 - b0)) {
+    return false;
+  }
+  const nowClass = simpleClass(a1 - b1);
+  const prevClass = simpleClass(a0 - b0);
+  return isPerfectClass(nowClass) && nowClass === prevClass;
+}
+function createsParallelOctave(aPrev, aCur, bPrev, bCur) {
+  const a0 = pitchOf(aPrev);
+  const a1 = pitchOf(aCur);
+  const b0 = pitchOf(bPrev);
+  const b1 = pitchOf(bCur);
+  if (!similarMotion(a1 - a0, b1 - b0)) {
+    return false;
+  }
+  return simpleClass(a1 - b1) === 0 && simpleClass(a0 - b0) === 0;
+}
+function createsParallelUnison(aPrev, aCur, bPrev, bCur) {
+  const a0 = pitchOf(aPrev);
+  const a1 = pitchOf(aCur);
+  const b0 = pitchOf(bPrev);
+  const b1 = pitchOf(bCur);
+  if (a1 === a0 || b1 === b0) {
+    return false;
+  }
+  return a1 === b1 && a0 === b0;
+}
+function createsHiddenParallelPerfect(aPrev, aCur, bPrev, bCur) {
+  const a0 = pitchOf(aPrev);
+  const a1 = pitchOf(aCur);
+  const b0 = pitchOf(bPrev);
+  const b1 = pitchOf(bCur);
+  const aMove = a1 - a0;
+  const bMove = b1 - b0;
+  if (!similarMotion(aMove, bMove)) {
+    return false;
+  }
+  const nowClass = simpleClass(a1 - b1);
+  const prevClass = simpleClass(a0 - b0);
+  if (!isPerfectClass(nowClass) || prevClass === nowClass) {
+    return false;
+  }
+  const upperMove = a1 >= b1 ? aMove : bMove;
+  if (Math.abs(upperMove) <= 2) {
+    return false;
+  }
+  return true;
+}
+function createsBattuta(aPrev, aCur, bPrev, bCur) {
+  const a0 = pitchOf(aPrev);
+  const a1 = pitchOf(aCur);
+  const b0 = pitchOf(bPrev);
+  const b1 = pitchOf(bCur);
+  const aMove = a1 - a0;
+  const bMove = b1 - b0;
+  if (!bothVoicesMove(aMove, bMove) || similarMotion(aMove, bMove)) {
+    return false;
+  }
+  if (simpleClass(a1 - b1) !== 0) {
+    return false;
+  }
+  const upperMove = a1 >= b1 ? aMove : bMove;
+  return upperMove < -2;
+}
+function createsVoiceOverlap(upperPrev, upperCur, lowerPrev, lowerCur) {
+  const u0 = pitchOf(upperPrev);
+  const u1 = pitchOf(upperCur);
+  const l0 = pitchOf(lowerPrev);
+  const l1 = pitchOf(lowerCur);
+  return u1 < l0 || l1 > u0;
+}
+function exceedsSpacing(upper, lower, maxSemitones = 12) {
+  return Math.abs(pitchOf(upper) - pitchOf(lower)) > maxSemitones;
+}
+function isLeadingToneResolution(prev, cur, key) {
+  const prevPitch = pitchOf(prev);
+  const curPitch = pitchOf(cur);
+  const tonic = pitchClassOf(key.rootPc);
+  const leading = (tonic + 11) % 12;
+  if (pitchClassOf(prevPitch) !== leading || pitchClassOf(curPitch) !== tonic) {
+    return false;
+  }
+  return curPitch > prevPitch && curPitch - prevPitch <= 2;
+}
+
+// src/theory/safety/index.ts
+var PROFILE_WEIGHTS = Object.freeze({
+  strict: Object.freeze({
+    imperfectConsonance: 2,
+    perfectConsonance: 0.5,
+    dissonance: -2,
+    chordTone: 1,
+    contraryMotion: 2,
+    obliqueMotion: 1,
+    similarMotion: -1,
+    parallelImperfect: 0,
+    stepwise: 1,
+    melodicDistance: -0.3,
+    forbiddenLeap: -6,
+    registerDrift: -0.02
+  }),
+  pop: Object.freeze({
+    imperfectConsonance: 2.5,
+    perfectConsonance: 1,
+    dissonance: -2,
+    chordTone: 1.5,
+    contraryMotion: 1.5,
+    obliqueMotion: 1.25,
+    similarMotion: 0,
+    parallelImperfect: 2,
+    stepwise: 0.75,
+    melodicDistance: -0.2,
+    forbiddenLeap: -6,
+    registerDrift: -0.02
+  })
+});
+var SAFETY_PROFILES = Object.keys(PROFILE_WEIGHTS);
+function profileWeights(profile, overrides) {
+  const base = PROFILE_WEIGHTS[assertOneOf(profile, SAFETY_PROFILES, "safety profile")];
+  return { ...base, ...overrides };
+}
+var NoteSafety = /* @__PURE__ */ ((NoteSafety2) => {
+  NoteSafety2[NoteSafety2["Safe"] = 0] = "Safe";
+  NoteSafety2[NoteSafety2["Warning"] = 1] = "Warning";
+  NoteSafety2[NoteSafety2["Dissonant"] = 2] = "Dissonant";
+  return NoteSafety2;
+})(NoteSafety || {});
+var ReasonFlag = /* @__PURE__ */ ((ReasonFlag2) => {
+  ReasonFlag2[ReasonFlag2["ChordTone"] = 1] = "ChordTone";
+  ReasonFlag2[ReasonFlag2["Tension"] = 2] = "Tension";
+  ReasonFlag2[ReasonFlag2["AvoidNote"] = 4] = "AvoidNote";
+  ReasonFlag2[ReasonFlag2["ScaleTone"] = 8] = "ScaleTone";
+  ReasonFlag2[ReasonFlag2["NonScale"] = 16] = "NonScale";
+  ReasonFlag2[ReasonFlag2["OutOfRange"] = 32] = "OutOfRange";
+  ReasonFlag2[ReasonFlag2["Tritone"] = 64] = "Tritone";
+  ReasonFlag2[ReasonFlag2["LargeLeap"] = 128] = "LargeLeap";
+  ReasonFlag2[ReasonFlag2["MinorSecond"] = 256] = "MinorSecond";
+  ReasonFlag2[ReasonFlag2["MajorSeventh"] = 512] = "MajorSeventh";
+  ReasonFlag2[ReasonFlag2["VerticalDissonance"] = 1024] = "VerticalDissonance";
+  ReasonFlag2[ReasonFlag2["ParallelPerfect"] = 2048] = "ParallelPerfect";
+  ReasonFlag2[ReasonFlag2["HiddenParallel"] = 4096] = "HiddenParallel";
+  ReasonFlag2[ReasonFlag2["VoiceCrossing"] = 8192] = "VoiceCrossing";
+  ReasonFlag2[ReasonFlag2["Suspension"] = 16384] = "Suspension";
+  ReasonFlag2[ReasonFlag2["NeedsResolution"] = 32768] = "NeedsResolution";
+  ReasonFlag2[ReasonFlag2["MelodicTritone"] = 65536] = "MelodicTritone";
+  return ReasonFlag2;
+})(ReasonFlag || {});
+var SUGGESTION_WINDOW = 12;
+var MAX_SUGGESTIONS = 3;
+var REASON_SEVERITY = [
+  [2 /* Tension */, 1 /* Warning */, 1 /* Warning */],
+  [4 /* AvoidNote */, 1 /* Warning */, 2 /* Dissonant */],
+  [8 /* ScaleTone */, 1 /* Warning */, 1 /* Warning */],
+  [16 /* NonScale */, 2 /* Dissonant */, 2 /* Dissonant */],
+  [32 /* OutOfRange */, 1 /* Warning */, 1 /* Warning */],
+  [64 /* Tritone */, 2 /* Dissonant */, 2 /* Dissonant */],
+  [65536 /* MelodicTritone */, 1 /* Warning */, 2 /* Dissonant */],
+  [128 /* LargeLeap */, 1 /* Warning */, 2 /* Dissonant */],
+  [1024 /* VerticalDissonance */, 2 /* Dissonant */, 2 /* Dissonant */],
+  [2048 /* ParallelPerfect */, 1 /* Warning */, 2 /* Dissonant */],
+  [4096 /* HiddenParallel */, 1 /* Warning */, 2 /* Dissonant */],
+  [8192 /* VoiceCrossing */, 1 /* Warning */, 2 /* Dissonant */],
+  [16384 /* Suspension */, 2 /* Dissonant */, 2 /* Dissonant */],
+  [32768 /* NeedsResolution */, 1 /* Warning */, 2 /* Dissonant */]
+];
+function minimumSafetyForReasons(reasons, profile) {
+  let minimum = 0 /* Safe */;
+  const severityIndex = profile === "strict" ? 2 : 1;
+  for (const entry of REASON_SEVERITY) {
+    if (reasons & entry[0]) {
+      minimum = Math.max(minimum, entry[severityIndex]);
+    }
+  }
+  return minimum;
+}
+function avoidsFourth(chord) {
+  return chord.intervals.includes(4) && !chord.intervals.includes(5);
+}
+function avoidsMajorSeventh(chord) {
+  return chord.intervals.includes(4) && chord.intervals.includes(10);
+}
+function isStructuralChordDissonance(a, b, chord) {
+  const rawClass = pitchClassOf(Math.abs(a - b));
+  const aOffset = intervalAboveRoot(a, chord);
+  const bOffset = intervalAboveRoot(b, chord);
+  const rootSeventh = aOffset === 0 && (bOffset === 10 || bOffset === 11) || bOffset === 0 && (aOffset === 10 || aOffset === 11);
+  if (rawClass !== 6 && !rootSeventh) {
+    return false;
+  }
+  return isChordMember(a, chord) && isChordMember(b, chord);
+}
+function stepResolution(pitch, chord) {
+  for (let delta = 1; delta <= 2; delta += 1) {
+    if (isChordMember(pitch - delta, chord)) {
+      return pitch - delta;
+    }
+  }
+  return void 0;
+}
+function evaluateSafety(q, opts = {}) {
+  assertSafetyContext(q);
+  assertMidiPitch(q.candidatePitch, "candidatePitch");
+  return evaluateInternal(q, opts.suggestions ?? true);
+}
+function assertSafetyContext(q) {
+  assertOneOf(q.profile, SAFETY_PROFILES, "safety profile");
+  if (q.prevPitch !== void 0) assertMidiPitch(q.prevPitch, "prevPitch");
+  if (q.vocalLow !== void 0) assertMidiPitch(q.vocalLow, "vocalLow");
+  if (q.vocalHigh !== void 0) assertMidiPitch(q.vocalHigh, "vocalHigh");
+  if (q.vocalLow !== void 0 && q.vocalHigh !== void 0 && q.vocalLow > q.vocalHigh) {
+    throw new InvalidInputError("vocalLow must not exceed vocalHigh");
+  }
+  if (!Array.isArray(q.otherVoices)) {
+    throw new InvalidInputError(`otherVoices must be an array; received ${typeof q.otherVoices}`);
+  }
+  assertGenerationBudget(q.otherVoices.length, "other voices");
+  for (let index = 0; index < q.otherVoices.length; index += 1) {
+    const voice = q.otherVoices[index];
+    if (!voice) continue;
+    assertMidiPitch(voice.pitch, `otherVoices[${index}].pitch`);
+    if (voice.prevPitch !== void 0) {
+      assertMidiPitch(voice.prevPitch, `otherVoices[${index}].prevPitch`);
+    }
+  }
+}
+function evaluateInternal(q, collectSuggestions) {
+  let reasons = 0;
+  let level = 0 /* Safe */;
+  let resolveTo;
+  const raise = (l) => {
+    if (l > level) {
+      level = l;
+    }
+  };
+  const avoidSeverity = q.profile === "strict" ? 2 /* Dissonant */ : 1 /* Warning */;
+  const parallelSeverity = avoidSeverity;
+  const pitch = q.candidatePitch;
+  if (q.vocalLow !== void 0 && pitch < q.vocalLow || q.vocalHigh !== void 0 && pitch > q.vocalHigh) {
+    reasons |= 32 /* OutOfRange */;
+    raise(1 /* Warning */);
+  }
+  const inScale2 = isScaleTone(pitch, q.key);
+  const chord = q.chord;
+  if (!inScale2 && (chord === null || !isChordMember(pitch, chord))) {
+    reasons |= 16 /* NonScale */;
+    raise(2 /* Dissonant */);
+  }
+  if (chord && isChordMember(pitch, chord)) {
+    reasons |= 1 /* ChordTone */;
+  } else if (chord) {
+    const ic = intervalAboveRoot(pitch, chord);
+    const isTension = ic === 2 || ic === 5 || ic === 9;
+    const avoid = ic === 5 && avoidsFourth(chord) || ic === 11 && avoidsMajorSeventh(chord);
+    if (avoid) {
+      reasons |= 4 /* AvoidNote */;
+      if (isTension) {
+        reasons |= 2 /* Tension */;
+      }
+      reasons |= 32768 /* NeedsResolution */;
+      resolveTo = stepResolution(pitch, chord);
+      raise(avoidSeverity);
+    } else if (isTension && inScale2) {
+      reasons |= 2 /* Tension */;
+      raise(1 /* Warning */);
+    } else if (inScale2) {
+      reasons |= 8 /* ScaleTone */;
+      raise(1 /* Warning */);
+    }
+  } else if (inScale2) {
+    reasons |= 8 /* ScaleTone */;
+    raise(1 /* Warning */);
+  }
+  if (chord && !isChordMember(pitch, chord)) {
+    const ic = intervalAboveRoot(pitch, chord);
+    const toneOffsets = chord.intervals.map((i) => (i % 12 + 12) % 12);
+    if (toneOffsets.some((t) => Math.abs(ic - t) === 6)) {
+      reasons |= 64 /* Tritone */;
+    }
+  }
+  if (q.prevPitch !== void 0) {
+    const pc = Math.abs(pitch - q.prevPitch) % 12;
+    if (pc === 6) {
+      reasons |= 65536 /* MelodicTritone */;
+      raise(q.profile === "strict" ? 2 /* Dissonant */ : 1 /* Warning */);
+    }
+    if (isForbiddenMelodicLeap(q.prevPitch, pitch)) {
+      reasons |= 128 /* LargeLeap */;
+      raise(parallelSeverity);
+    }
+    if (pc === 1) {
+      reasons |= 256 /* MinorSecond */;
+    }
+    if (pc === 11) {
+      reasons |= 512 /* MajorSeventh */;
+    }
+  }
+  if (q.strongBeat) {
+    const twoVoice = q.otherVoices.length === 1;
+    const prev = q.prevPitch;
+    for (const ov of q.otherVoices) {
+      if (!createsVerticalDissonance(pitch, ov.pitch, twoVoice)) {
+        continue;
+      }
+      if (chord && isStructuralChordDissonance(pitch, ov.pitch, chord)) {
+        continue;
+      }
+      reasons |= 1024 /* VerticalDissonance */;
+      raise(2 /* Dissonant */);
+      if (prev !== void 0 && pitch === prev && ov.prevPitch !== void 0 && !createsVerticalDissonance(prev, ov.prevPitch, twoVoice)) {
+        reasons |= 16384 /* Suspension */;
+      }
+    }
+  }
+  if (q.prevPitch !== void 0) {
+    const prev = q.prevPitch;
+    for (const ov of q.otherVoices) {
+      if (ov.prevPitch === void 0) {
+        continue;
+      }
+      if (createsParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
+        reasons |= 2048 /* ParallelPerfect */;
+        raise(parallelSeverity);
+      }
+      if (createsHiddenParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
+        reasons |= 4096 /* HiddenParallel */;
+        raise(parallelSeverity);
+      }
+      const crossedNow = pitch - ov.pitch;
+      const crossedPrev = prev - ov.prevPitch;
+      if (crossedNow !== 0 && crossedPrev !== 0 && crossedNow > 0 !== crossedPrev > 0) {
+        reasons |= 8192 /* VoiceCrossing */;
+        raise(parallelSeverity);
+      }
+    }
+  }
+  raise(minimumSafetyForReasons(reasons, q.profile));
+  const result = { safety: level, reasons, rationale: describe(reasons, q) };
+  if (resolveTo !== void 0) {
+    result.resolveTo = resolveTo;
+  }
+  if (collectSuggestions && level !== 0 /* Safe */) {
+    const suggestions = findSafeNearby(q, pitch);
+    if (suggestions.length > 0) {
+      result.suggestions = suggestions;
+    }
+  }
+  return result;
+}
+function findSafeNearby(q, candidate) {
+  const out = [];
+  for (let d = 1; d <= SUGGESTION_WINDOW; d += 1) {
+    for (const p of [candidate - d, candidate + d]) {
+      if (p < 0 || p > 127) {
+        continue;
+      }
+      if (evaluateInternal({ ...q, candidatePitch: p }, false).safety === 0 /* Safe */) {
+        out.push(p);
+        if (out.length >= MAX_SUGGESTIONS) {
+          return out;
+        }
+      }
+    }
+  }
+  return out;
+}
+var REASON_TEXT = [
+  [32 /* OutOfRange */, "Outside the target vocal range"],
+  [
+    16384 /* Suspension */,
+    "Prepared suspension \u2014 a held consonance now dissonant, awaiting resolution"
+  ],
+  [1024 /* VerticalDissonance */, "Dissonant against a sounding voice on a strong beat"],
+  [64 /* Tritone */, "Tritone against the sounding harmony"],
+  [65536 /* MelodicTritone */, "Melodic tritone leap"],
+  [4 /* AvoidNote */, "Avoid note \u2014 clashes with a chord tone a semitone away"],
+  [16 /* NonScale */, "Outside the key"],
+  [2048 /* ParallelPerfect */, "Parallel perfect interval with another voice"],
+  [4096 /* HiddenParallel */, "Hidden perfect interval by similar motion"],
+  [8192 /* VoiceCrossing */, "Crosses another voice"],
+  [128 /* LargeLeap */, "Leap wider than the profile allows"],
+  [32768 /* NeedsResolution */, "Dissonance awaiting a stepwise resolution"],
+  [2 /* Tension */, "Chord tension"],
+  [8 /* ScaleTone */, "Scale tone, not in the chord"],
+  [256 /* MinorSecond */, "Melodic semitone"],
+  [512 /* MajorSeventh */, "Melodic major seventh"],
+  [1 /* ChordTone */, "Chord tone"]
+];
+function severityOfReason(flag, profile) {
+  const entry = REASON_SEVERITY.find(([candidate]) => candidate === flag);
+  return entry === void 0 ? 0 /* Safe */ : entry[profile === "strict" ? 2 : 1];
+}
+function describe(reasons, q) {
+  let best;
+  let bestSeverity = -1;
+  for (const [flag, text] of REASON_TEXT) {
+    if (!(reasons & flag)) {
+      continue;
+    }
+    const severity = severityOfReason(flag, q.profile);
+    if (severity > bestSeverity) {
+      bestSeverity = severity;
+      best = text;
+    }
+  }
+  if (best !== void 0) {
+    return best;
+  }
+  return q.chord ? "Placeable" : "No chord context";
+}
+function enumerateSafePitches(q, pitchLow, pitchHigh) {
+  assertSafetyContext(q);
+  const chordTones = [];
+  const others = [];
+  assertMidiPitch(pitchLow, "pitchLow");
+  assertMidiPitch(pitchHigh, "pitchHigh");
+  if (pitchLow > pitchHigh) {
+    throw new InvalidInputError(
+      `pitchLow must not exceed pitchHigh; received ${pitchLow} > ${pitchHigh}`
+    );
+  }
+  assertGenerationBudget(pitchHigh - pitchLow + 1, "safe pitch candidates");
+  const low = Math.max(pitchLow, q.vocalLow ?? pitchLow);
+  const high = Math.min(pitchHigh, q.vocalHigh ?? pitchHigh);
+  for (let pitch = high; pitch >= low; pitch -= 1) {
+    const result = evaluateInternal({ ...q, candidatePitch: pitch }, false);
+    if (result.safety === 2 /* Dissonant */) {
+      continue;
+    }
+    if (result.reasons & 1 /* ChordTone */) {
+      chordTones.push(pitch);
+    } else {
+      others.push(pitch);
+    }
+  }
+  return [...chordTones, ...others];
+}
+
+// src/theory/symbol/index.ts
+var ROOT_RE = /^[A-Ga-g](?:#{1,2}|b{1,2}|x)?/;
+var BASS_RE = /^[A-Ga-g](?:#{1,2}|b{1,2}|x)?$/;
+var DEFAULT_SYSTEM = "english";
+var SYSTEM_PROBE = { letter: 0, alter: 0 };
+var QUALITY_MAP = {
+  "": "maj",
+  maj: "maj",
+  m: "min",
+  min: "min",
+  "-": "min",
+  dim: "dim",
+  "\xB0": "dim",
+  aug: "aug",
+  "+": "aug",
+  maj7: "maj7",
+  M7: "maj7",
+  \u0394: "maj7",
+  \u03947: "maj7",
+  m7: "min7",
+  min7: "min7",
+  "-7": "min7",
+  "7": "dom7",
+  dim7: "dim7",
+  "\xB07": "dim7",
+  m7b5: "m7b5",
+  \u00F8: "m7b5",
+  \u00F87: "m7b5",
+  min7b5: "m7b5",
+  mMaj7: "minMaj7",
+  mM7: "minMaj7",
+  minMaj7: "minMaj7",
+  mMaj9: "minMaj9",
+  mM9: "minMaj9",
+  minMaj9: "minMaj9",
+  mMaj11: "minMaj11",
+  mM11: "minMaj11",
+  minMaj11: "minMaj11",
+  mMaj13: "minMaj13",
+  mM13: "minMaj13",
+  minMaj13: "minMaj13",
+  aug7: "aug7",
+  "+7": "aug7",
+  "7#5": "aug7",
+  augMaj7: "augMaj7",
+  augM7: "augMaj7",
+  "+maj7": "augMaj7",
+  "+M7": "augMaj7",
+  majb5: "majb5",
+  "maj(b5)": "majb5",
+  "(b5)": "majb5",
+  "6": "6",
+  m6: "min6",
+  min6: "min6",
+  "6/9": "6/9",
+  "69": "6/9",
+  sus2: "sus2",
+  sus: "sus4",
+  sus4: "sus4",
+  add9: "add9",
+  add11: "add11",
+  maj9: "maj9",
+  M9: "maj9",
+  m9: "min9",
+  min9: "min9",
+  "9": "dom9",
+  "7b9": "7b9",
+  "7#9": "7#9",
+  "7#11": "7#11",
+  "7b13": "7b13",
+  "11": "11",
+  "13": "13",
+  "5": "5",
+  "7sus4": "7sus4",
+  "7sus": "7sus4",
+  "9sus4": "11",
+  "9sus": "11",
+  "7b5": "7b5",
+  "7alt": "7alt",
+  alt: "7alt",
+  "13b9": "13b9",
+  maj13: "maj13",
+  M13: "maj13",
+  "maj7#11": "maj7#11",
+  "M7#11": "maj7#11",
+  m11: "min11",
+  min11: "min11",
+  m13: "min13",
+  min13: "min13",
+  madd9: "minAdd9",
+  "min(add9)": "minAdd9",
+  "m(add9)": "minAdd9",
+  "6add9": "6/9",
+  "m6/9": "min6/9",
+  m69: "min6/9",
+  "min6/9": "min6/9",
+  // ASCII stand-ins for the degree and half-diminished glyphs, which most
+  // lead sheets and chord-chart text files use instead of the typographic ones.
+  o: "dim",
+  o7: "dim7",
+  h: "m7b5",
+  h7: "m7b5"
+};
+var CANONICAL_SUFFIX = {
+  maj: "",
+  min: "m",
+  dim: "dim",
+  aug: "aug",
+  maj7: "maj7",
+  min7: "m7",
+  dom7: "7",
+  dim7: "dim7",
+  m7b5: "m7b5",
+  minMaj7: "mMaj7",
+  minMaj9: "mMaj9",
+  minMaj11: "mMaj11",
+  minMaj13: "mMaj13",
+  aug7: "aug7",
+  augMaj7: "augMaj7",
+  majb5: "maj(b5)",
+  "6": "6",
+  min6: "m6",
+  "6/9": "6/9",
+  sus2: "sus2",
+  sus4: "sus4",
+  add9: "add9",
+  add11: "add11",
+  maj9: "maj9",
+  min9: "m9",
+  dom9: "9",
+  "7b9": "7b9",
+  "7#9": "7#9",
+  "7#11": "7#11",
+  "7b13": "7b13",
+  "11": "11",
+  "13": "13",
+  "5": "5",
+  "7sus4": "7sus4",
+  "7b5": "7b5",
+  "7alt": "7alt",
+  "13b9": "13b9",
+  maj13: "maj13",
+  "maj7#11": "maj7#11",
+  min11: "m11",
+  min13: "m13",
+  minAdd9: "madd9",
+  "min6/9": "m6/9"
+};
+function knownQuality(suffix) {
+  return Object.hasOwn(QUALITY_MAP, suffix) ? QUALITY_MAP[suffix] : void 0;
+}
+var BASE_TOKENS = [
+  ["sus2", "sus2"],
+  ["sus4", "sus4"],
+  ["sus", "sus4"],
+  ["min", "min"],
+  ["dim", "dim"],
+  ["aug", "aug"],
+  ["maj", "major"],
+  ["m", "min"],
+  ["-", "min"],
+  ["o", "dim"],
+  ["\xB0", "dim"],
+  ["+", "aug"],
+  ["M", "major"],
+  ["\u0394", "major"],
+  ["^", "major"]
+];
+var MAJOR_MARKERS = [
+  ["maj", "word"],
+  ["Maj", "word"],
+  ["M", "word"],
+  ["\u0394", "glyph"],
+  ["^", "glyph"]
+];
+var EXTENSION_NUMBERS = [13, 11, 9, 7, 6];
+var ADDED_DEGREES = {
+  "2": 9,
+  "4": 11,
+  "6": 6,
+  "9": 9,
+  "11": 11,
+  "13": 13
+};
+var ALTERABLE = { "5": 5, "9": 9, "11": 11, "13": 13 };
+var OMITTABLE = { "1": 1, "3": 3, "5": 5 };
+function matchToken(text, at, table) {
+  let found;
+  for (const [token, value] of table) {
+    if (text.startsWith(token, at) && (found === void 0 || at + token.length > found.next)) {
+      found = { value, next: at + token.length };
+    }
+  }
+  return found;
+}
+function matchNumber(text, at) {
+  for (const value of EXTENSION_NUMBERS) {
+    const token = String(value);
+    if (text.startsWith(token, at)) {
+      return { value, next: at + token.length };
+    }
+  }
+  return void 0;
+}
+function stackTo(draft, top) {
+  if (top === 6) {
+    draft.additions.add(6);
+    return;
+  }
+  draft.seventh = draft.major ? "maj7" : draft.base === "dim" ? "dim7" : "min7";
+  if (top >= 9) {
+    draft.alterations.set(9, 0);
+  }
+  if (top === 11) {
+    draft.alterations.set(11, 0);
+  }
+  if (top === 13) {
+    draft.alterations.set(13, 0);
+  }
+}
+function applyFigure(draft, text, at) {
+  const base = matchToken(text, at, [
+    ["sus2", "sus2"],
+    ["sus4", "sus4"],
+    ["sus", "sus4"]
+  ]);
+  if (base !== void 0) {
+    draft.base = base.value;
+    return base.next;
+  }
+  if (text.startsWith("alt", at)) {
+    draft.base = "aug";
+    draft.seventh = "min7";
+    draft.alterations.set(9, 1);
+    return at + 3;
+  }
+  if (text.startsWith("add", at)) {
+    const degree2 = matchNumberToken(text, at + 3, ADDED_DEGREES);
+    if (degree2 === void 0) {
+      return void 0;
+    }
+    draft.additions.add(degree2.value);
+    return degree2.next;
+  }
+  const omitted = matchToken(text, at, [
+    ["omit", 4],
+    ["no", 2]
+  ]);
+  if (omitted !== void 0) {
+    const degree2 = matchNumberToken(text, omitted.next, OMITTABLE);
+    if (degree2 === void 0) {
+      return void 0;
+    }
+    draft.omissions.add(degree2.value);
+    return degree2.next;
+  }
+  const accidental = matchToken(text, at, [
+    ["b", -1],
+    ["#", 1]
+  ]);
+  const from = accidental?.next ?? at;
+  const degree = matchNumberToken(text, from, ALTERABLE);
+  if (degree === void 0) {
+    return void 0;
+  }
+  draft.alterations.set(degree.value, accidental?.value ?? 0);
+  return degree.next;
+}
+function matchNumberToken(text, at, table) {
+  const entries = Object.entries(table).map(([token, value]) => [token, value]);
+  return matchToken(text, at, entries);
+}
+function structuralSpec(text) {
+  let core = "";
+  const groups = [];
+  let inside = false;
+  let buffer = "";
+  for (const char of text) {
+    if (char === "(") {
+      if (inside) {
+        return void 0;
+      }
+      inside = true;
+      buffer = "";
+    } else if (char === ")") {
+      if (!inside) {
+        return void 0;
+      }
+      inside = false;
+      groups.push(buffer);
+    } else if (inside) {
+      buffer += char;
+    } else {
+      core += char;
+    }
+  }
+  if (inside) {
+    return void 0;
+  }
+  const draft = {
+    base: "maj",
+    alterations: /* @__PURE__ */ new Map(),
+    additions: /* @__PURE__ */ new Set(),
+    omissions: /* @__PURE__ */ new Set(),
+    major: false
+  };
+  let at = 0;
+  const opening = matchToken(core, at, BASE_TOKENS);
+  let markerGlyph = false;
+  let markerAfterBase = false;
+  if (opening !== void 0) {
+    at = opening.next;
+    if (opening.value === "major") {
+      draft.major = true;
+      markerGlyph = core.startsWith("\u0394") || core.startsWith("^");
+    } else {
+      draft.base = opening.value;
+    }
+  }
+  if (!draft.major) {
+    const marker = matchToken(core, at, MAJOR_MARKERS);
+    if (marker !== void 0) {
+      draft.major = true;
+      markerGlyph = marker.value === "glyph";
+      markerAfterBase = opening !== void 0;
+      at = marker.next;
+    }
+  }
+  const number = matchNumber(core, at);
+  if (number !== void 0) {
+    at = number.next;
+    stackTo(draft, number.value);
+  } else if (draft.major && (markerGlyph || markerAfterBase)) {
+    draft.seventh = "maj7";
+  }
+  while (at < core.length) {
+    if (core[at] === "/" && at > 0 && at + 1 < core.length) {
+      at += 1;
+      continue;
+    }
+    const next = applyFigure(draft, core, at);
+    if (next === void 0 || next === at) {
+      return void 0;
+    }
+    at = next;
+  }
+  for (const group of groups) {
+    for (const figure of group.split(/[,/\s]+/)) {
+      if (figure.length === 0) {
+        continue;
+      }
+      const next = applyFigure(draft, figure, 0);
+      if (next !== figure.length) {
+        return void 0;
+      }
+    }
+  }
+  return {
+    rootPc: 0,
+    base: draft.base,
+    ...draft.seventh === void 0 ? {} : { seventh: draft.seventh },
+    alterations: [...draft.alterations].map(([degree, alter]) => ({ degree, alter })),
+    additions: [...draft.additions],
+    omissions: [...draft.omissions]
+  };
+}
+function suffixSpec(suffix) {
+  const quality = knownQuality(suffix);
+  return quality === void 0 ? structuralSpec(suffix) : chordSpecForQuality(quality, 0);
+}
+function assertNamingSystem(system) {
+  formatNote(SYSTEM_PROBE, { system });
+}
+function bareNote(text, system) {
+  const read = tryParseNote(text, { system });
+  if (!read.ok) {
+    return void 0;
+  }
+  return read.value.octave === void 0 ? read.value : void 0;
+}
+function rootSplits(text, system) {
+  if (system === "english") {
+    const match = text.match(ROOT_RE);
+    const token = match?.[0];
+    return token === void 0 ? [] : [{ root: parseNote(token, { system }), rest: text.slice(token.length) }];
+  }
+  assertNamingSystem(system);
+  const splits = [];
+  for (let end = text.length; end > 0; end -= 1) {
+    const root = bareNote(text.slice(0, end), system);
+    if (root !== void 0) {
+      splits.push({ root, rest: text.slice(end) });
+    }
+  }
+  return splits;
+}
+function bassNote(text, system) {
+  if (system === "english") {
+    return BASS_RE.test(text) ? parseNote(text, { system }) : void 0;
+  }
+  return bareNote(text, system);
+}
+function makeSpelledChord(root, spec, bass) {
+  const rooted = { ...spec, rootPc: noteToPitchClass(root) };
+  if (bass !== void 0) {
+    rooted.bassPc = noteToPitchClass(bass);
+  }
+  const chord = chordFromSpec(rooted);
+  chord.rootSpelling = { letter: root.letter, alter: root.alter };
+  if (bass !== void 0) {
+    chord.bassSpelling = { letter: bass.letter, alter: bass.alter };
+  }
+  return chord;
+}
+function chordAfterRoot(root, rest, system) {
+  const slashIndex = rest.lastIndexOf("/");
+  if (slashIndex !== -1) {
+    const slashSpec = suffixSpec(rest.slice(0, slashIndex));
+    const bass = slashSpec === void 0 ? void 0 : bassNote(rest.slice(slashIndex + 1), system);
+    if (slashSpec !== void 0 && bass !== void 0) {
+      return makeSpelledChord(root, slashSpec, bass);
+    }
+  }
+  const spec = suffixSpec(rest);
+  return spec === void 0 ? void 0 : makeSpelledChord(root, spec);
+}
+function parseChordSymbol(text, opts) {
+  return unwrapParse(tryParseChordSymbol(text, opts));
+}
+function tryParseChordSymbol(text, opts) {
+  try {
+    if (typeof text !== "string") {
+      throw new InvalidInputError(`chord symbol must be a string; received ${typeof text}`);
+    }
+    const system = opts?.system ?? DEFAULT_SYSTEM;
+    const trimmed = text.trim().replaceAll("\u266F", "#").replaceAll("\u266D", "b").replaceAll("\u{1D12A}", "x").replaceAll("\u{1D12B}", "bb").replaceAll("\u2206", "\u0394");
+    const splits = rootSplits(trimmed, system);
+    if (splits.length === 0) {
+      throw new InvalidInputError(`Invalid chord symbol: ${text}`);
+    }
+    for (const { root, rest } of splits) {
+      const chord = chordAfterRoot(root, rest, system);
+      if (chord !== void 0) {
+        return { ok: true, value: chord };
+      }
+    }
+    throw new InvalidInputError(`Unrecognized chord quality: ${text}`);
+  } catch (error) {
+    return parseFailure(error);
+  }
+}
+function normalizedChord(data) {
+  if (!Array.isArray(data.intervals)) {
+    throw new InvalidInputError("chord.intervals must be an array of semitone offsets");
+  }
+  const copy = {
+    rootPc: pitchClassOf(assertFiniteNumber(data.rootPc, "chord.rootPc")),
+    quality: data.quality,
+    // Each offset is checked rather than copied blind: a chord holding a NaN
+    // interval voices, spells and formats as a chord that looks real, and the
+    // failure surfaces wherever the number is finally used.
+    intervals: data.intervals.map(
+      (interval, index) => assertFiniteNumber(interval, `chord.intervals[${index}]`)
+    )
+  };
+  if (data.bassPc !== void 0) {
+    copy.bassPc = pitchClassOf(assertFiniteNumber(data.bassPc, "chord.bassPc"));
+  }
+  if (data.rootSpelling !== void 0) {
+    copy.rootSpelling = data.rootSpelling;
+  }
+  if (data.bassSpelling !== void 0) {
+    copy.bassSpelling = data.bassSpelling;
+  }
+  if (data.toneSpellings !== void 0) {
+    copy.toneSpellings = data.toneSpellings;
+  }
+  return copy;
+}
+function toChordData(value) {
+  if (typeof value === "string") {
+    return parseChordSymbol(value);
+  }
+  if (typeof value === "object" && value !== null) {
+    const data = "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : value;
+    return normalizedChord(data);
+  }
+  throw new InvalidInputError(
+    `chord must be a chord symbol or chord data; received ${typeof value}`
+  );
+}
+function symbolName(note, system) {
+  const name = formatNote(note, { system });
+  return system === "german" ? `${name.slice(0, 1).toUpperCase()}${name.slice(1)}` : name;
+}
+function pitchClassName(pc, hint, system, flats, inheritFlats) {
+  if (flats === void 0 && hint !== void 0 && noteToPitchClass(hint) === pc) {
+    return symbolName(hint, system);
+  }
+  const note = midiToNote(60 + pc, flats ?? inheritFlats ? "flat" : "sharp");
+  return symbolName({ letter: note.letter, alter: note.alter }, system);
+}
+var CORE_CANDIDATES = chordQualities().map((quality) => [quality, chordSpecForQuality(quality, 0)]).filter(([, spec]) => spec.alterations.every(({ degree, alter }) => degree === 5 || alter === 0));
+function carriesAlteration(spec, part) {
+  return spec.alterations.some(
+    ({ degree, alter }) => degree === part.degree && alter === part.alter
+  );
+}
+function coreQuality(spec) {
+  let core;
+  let named = -1;
+  for (const [quality, candidate] of CORE_CANDIDATES) {
+    const size = candidate.alterations.length + candidate.additions.length;
+    if (size <= named || candidate.base !== spec.base || candidate.seventh !== spec.seventh || !candidate.alterations.every((part) => carriesAlteration(spec, part)) || !candidate.additions.every((degree) => spec.additions.includes(degree)) || !candidate.omissions.every((degree) => spec.omissions.includes(degree))) {
+      continue;
+    }
+    core = quality;
+    named = size;
+  }
+  return core;
+}
+var BASE_SUFFIX = {
+  maj: "",
+  min: "m",
+  dim: "dim",
+  aug: "aug",
+  sus2: "sus2",
+  sus4: "sus4",
+  power: "5"
+};
+var SEVENTH_SUFFIX = { maj7: "maj7", min7: "7", dim7: "dim7" };
+var MAJOR_SEVENTH_AFTER_BASE = "Maj7";
+function builtCoreSuffix(spec) {
+  const base = BASE_SUFFIX[spec.base];
+  if (spec.seventh === void 0) {
+    return base;
+  }
+  const seventh = SEVENTH_SUFFIX[spec.seventh];
+  if (spec.base === "sus2" || spec.base === "sus4") {
+    return `${seventh}${base}`;
+  }
+  if (spec.base === "maj") {
+    return seventh;
+  }
+  return `${base}${spec.seventh === "maj7" ? MAJOR_SEVENTH_AFTER_BASE : seventh}`;
+}
+function figureText(spec, core) {
+  const figures = [];
+  for (const alteration of spec.alterations) {
+    if (core !== void 0 && carriesAlteration(core, alteration)) {
+      continue;
+    }
+    const { degree, alter } = alteration;
+    figures.push({ degree, text: `${alter < 0 ? "b" : alter > 0 ? "#" : ""}${degree}` });
+  }
+  for (const degree of spec.additions) {
+    if (core?.additions.includes(degree) !== true) {
+      figures.push({ degree, text: `add${degree}` });
+    }
+  }
+  return figures.sort((a, b) => a.degree - b.degree).map(({ text }) => text);
+}
+function specSuffix(spec) {
+  const named = exactChordSpecQuality(spec);
+  if (named !== void 0) {
+    return CANONICAL_SUFFIX[named];
+  }
+  const core = coreQuality(spec);
+  const coreSpec = core === void 0 ? void 0 : chordSpecForQuality(core, 0);
+  const text = core === void 0 ? builtCoreSuffix(spec) : CANONICAL_SUFFIX[core];
+  const figures = figureText(spec, coreSpec);
+  return figures.length === 0 ? text : `${text}(${figures.join(",")})`;
+}
+function formatChordSymbol(chord, opts) {
+  const data = toChordData(chord);
+  if (!Object.hasOwn(CANONICAL_SUFFIX, data.quality)) {
+    throw new InvalidInputError(`Unknown chord quality: ${String(data.quality)}`);
+  }
+  const system = opts?.system ?? DEFAULT_SYSTEM;
+  const rootPc = pitchClassOf(data.rootPc);
+  const rootHint = data.rootSpelling;
+  const rootName = pitchClassName(rootPc, rootHint, system, opts?.flats);
+  const suffix = specSuffix(chordSpecOf(data));
+  let symbol = `${rootName}${suffix}`;
+  if (data.bassPc !== void 0 && pitchClassOf(data.bassPc) !== rootPc) {
+    const inheritFlats = rootHint !== void 0 && noteToPitchClass(rootHint) === rootPc ? rootHint.alter < 0 : void 0;
+    const bassPc = pitchClassOf(data.bassPc);
+    symbol += `/${pitchClassName(bassPc, data.bassSpelling, system, opts?.flats, inheritFlats)}`;
+  }
+  return symbol;
+}
+function transposeChordSymbol(text, semitones, opts) {
+  assertFiniteSemitones(semitones);
+  const chord = parseChordSymbol(text, opts);
+  const transposed = { ...chord, rootPc: pitchClassOf(chord.rootPc + semitones) };
+  if (chord.rootSpelling !== void 0) {
+    const hint = transposeNote(chord.rootSpelling, semitones);
+    transposed.rootSpelling = { letter: hint.letter, alter: hint.alter };
+  }
+  if (chord.bassPc !== void 0) {
+    transposed.bassPc = pitchClassOf(chord.bassPc + semitones);
+  }
+  if (chord.bassSpelling !== void 0) {
+    const hint = transposeNote(chord.bassSpelling, semitones);
+    transposed.bassSpelling = { letter: hint.letter, alter: hint.alter };
+  }
+  return formatChordSymbol(transposed, opts);
+}
+
+export {
+  maskFromOffsets,
+  MAJOR_MASK,
+  NATURAL_MINOR_MASK,
+  HARMONIC_MINOR_MASK,
+  MELODIC_MINOR_MASK,
+  DORIAN_MASK,
+  PHRYGIAN_MASK,
+  LYDIAN_MASK,
+  MIXOLYDIAN_MASK,
+  LOCRIAN_MASK,
+  MAJOR_PENTATONIC_MASK,
+  MINOR_PENTATONIC_MASK,
+  BLUES_MASK,
+  WHOLE_TONE_MASK,
+  OCTATONIC_HALF_WHOLE_MASK,
+  OCTATONIC_WHOLE_HALF_MASK,
+  CHROMATIC_MASK,
+  LYDIAN_DOMINANT_MASK,
+  MIXOLYDIAN_B13_MASK,
+  LOCRIAN_NATURAL2_MASK,
+  ALTERED_MASK,
+  PHRYGIAN_DOMINANT_MASK,
+  MIYAKO_BUSHI_MASK,
+  RITSU_MASK,
+  RYUKYU_MASK,
+  DOUBLE_HARMONIC_MASK,
+  TODI_MASK,
+  MARWA_MASK,
+  PURVI_MASK,
+  NAMED_SCALES,
+  WORLD_SCALES,
+  SCALE_ALIASES,
+  resolveScaleName,
+  namedScaleMask,
+  requireScaleMask,
+  majorKey,
+  minorKey,
+  scaleByName,
+  toKeyScale,
+  isScaleTone,
+  nearestScaleTone,
+  scaleLadderPosition,
+  scaleLadderPitch,
+  shiftByScaleDegrees,
+  pitchToScaleDegree,
+  diatonicPitchClasses,
+  scaleTonesInDegreeOrder,
+  assertTonicOf,
+  spellPitchClass,
+  spellScale,
+  spellPitchClasses,
+  spellChordFromRoot,
+  spellChord,
+  spellPitch,
+  noteNames,
+  isSignatureKey,
+  keySignatureFifths,
+  keyFromFifths,
+  spelledKeyOf,
+  relativeKeyOf,
+  parallelKeyOf,
+  dominantKeyOf,
+  subdominantKeyOf,
+  enharmonicKeyOf,
+  relatedKeysOf,
+  keyRelationBetween,
+  SCALE_SYSTEMS,
+  scaleSystemOf,
+  supportsFunctionalHarmony,
+  chordSpecIntervals,
+  chordSpecQuality,
+  chordQualities,
+  chordFromDegree,
+  makeChord,
+  chordFromSpec,
+  chordSpecOf,
+  chordFromSpan,
+  spanFromChord,
+  transposeChord,
+  chordToneSpellings,
+  chordPitchClasses,
+  intervalAboveRoot,
+  isChordMember,
+  chordToneRole,
+  diatonicTriad,
+  diatonicSeventh,
+  simpleIntervalNumber,
+  classifySpelledInterval,
+  voiceIndependence,
+  createsVoiceCrossing,
+  createsVerticalDissonance,
+  isForbiddenMelodicLeap,
+  isAugmentedMelodicInterval,
+  createsParallelPerfect,
+  createsParallelOctave,
+  createsParallelUnison,
+  createsHiddenParallelPerfect,
+  createsBattuta,
+  createsVoiceOverlap,
+  exceedsSpacing,
+  isLeadingToneResolution,
+  PROFILE_WEIGHTS,
+  profileWeights,
+  NoteSafety,
+  ReasonFlag,
+  evaluateSafety,
+  enumerateSafePitches,
+  parseChordSymbol,
+  tryParseChordSymbol,
+  toChordData,
+  formatChordSymbol,
+  transposeChordSymbol
+};
+//# sourceMappingURL=chunk-INHVXP6Z.js.map