@libraz/libcantus 0.9.0

package/src/progression/index.ts

@@ -0,0 +1,336 @@
+import type { ChordQuality } from '../chord/index.js';
+import { diatonicTriad } from '../chord/index.js';
+import { scaleTonesInDegreeOrder } from '../scale/index.js';
+import type { KeyScale } from '../types.js';
+
+/** Broad production style a progression preset suits. */
+export type ProgStyle = 'minimal' | 'dance' | 'idol' | 'rock';
+
+/** Harmonic-function role of a progression as a whole. */
+export type ProgFunction = 'loop' | 'tensionBuild' | 'cadenceStrong' | 'stable';
+
+/** A named chord-progression preset expressed in scale degrees. */
+export type ProgressionPreset = {
+  id: string;
+  name: string;
+  degrees: number[];
+  functional: ProgFunction;
+  styles: ProgStyle[];
+};
+
+/** A chord placed on the timeline by {@link generateProgression}. */
+export type GeneratedChord = {
+  rootPc: number;
+  quality: ChordQuality;
+  startBeat: number;
+  bassPc?: number;
+  /** 0-based scale degree of the chord root, when known. */
+  degree?: number;
+  /** True when the chord is a secondary dominant tonicizing another degree. */
+  secondaryDominant?: boolean;
+};
+
+/** Options controlling {@link generateProgression}. */
+export type GenerateProgressionOptions = {
+  key: KeyScale;
+  style: ProgStyle;
+  bars: number;
+  presetId?: string;
+  ext?: ChordQuality | 'auto';
+  reharmonize?: boolean;
+  seed?: number;
+};
+
+const PRESETS: ProgressionPreset[] = [
+  {
+    id: 'fourChordPop',
+    name: 'Four Chord Pop',
+    degrees: [0, 4, 5, 3],
+    functional: 'loop',
+    styles: ['minimal', 'dance', 'idol'],
+  },
+  {
+    id: 'pop1',
+    name: 'Pop 1',
+    degrees: [0, 5, 3, 4],
+    functional: 'loop',
+    styles: ['minimal', 'dance', 'idol'],
+  },
+  {
+    id: 'axis',
+    name: 'Axis',
+    degrees: [5, 3, 0, 4],
+    functional: 'loop',
+    styles: ['minimal', 'dance', 'idol', 'rock'],
+  },
+  {
+    id: 'pop2',
+    name: 'Pop 2',
+    degrees: [3, 0, 4, 5],
+    functional: 'loop',
+    styles: ['minimal', 'dance', 'idol'],
+  },
+  {
+    id: 'classic',
+    name: 'Classic',
+    degrees: [0, 3, 4, 0],
+    functional: 'cadenceStrong',
+    styles: ['dance', 'idol', 'rock'],
+  },
+  {
+    id: 'pop3',
+    name: 'Pop 3',
+    degrees: [0, 3, 5, 4],
+    functional: 'loop',
+    styles: ['minimal', 'dance', 'idol'],
+  },
+  {
+    id: 'royalRoad',
+    name: 'Royal Road',
+    degrees: [3, 4, 2, 5],
+    functional: 'tensionBuild',
+    styles: ['dance', 'idol'],
+  },
+  {
+    id: 'minor1',
+    name: 'Minor 1',
+    degrees: [5, 4, 3, 4],
+    functional: 'tensionBuild',
+    styles: ['idol', 'rock'],
+  },
+  {
+    id: 'minor2',
+    name: 'Minor 2',
+    degrees: [5, 3, 4, 0],
+    functional: 'tensionBuild',
+    styles: ['idol', 'rock'],
+  },
+  {
+    id: 'pop4',
+    name: 'Pop 4',
+    degrees: [0, 4, 2, 3],
+    functional: 'loop',
+    styles: ['minimal', 'dance', 'idol'],
+  },
+  {
+    id: 'pop5',
+    name: 'Pop 5',
+    degrees: [0, 2, 3, 4],
+    functional: 'stable',
+    styles: ['minimal', 'dance', 'idol'],
+  },
+  {
+    id: 'rock1',
+    name: 'Rock 1',
+    degrees: [0, 10, 3, 0],
+    functional: 'tensionBuild',
+    styles: ['rock'],
+  },
+  {
+    id: 'rock2',
+    name: 'Rock 2',
+    degrees: [0, 3, 10, 0],
+    functional: 'tensionBuild',
+    styles: ['rock'],
+  },
+  {
+    id: 'extended4',
+    name: 'Extended 4',
+    degrees: [0, 4, 5, 2],
+    functional: 'stable',
+    styles: ['minimal', 'dance'],
+  },
+  {
+    id: 'minor3',
+    name: 'Minor 3',
+    degrees: [5, 0, 4, 3],
+    functional: 'loop',
+    styles: ['dance', 'idol'],
+  },
+  {
+    id: 'aeolianPop',
+    name: 'Aeolian Pop',
+    degrees: [5, 8, 10, 0],
+    functional: 'tensionBuild',
+    styles: ['minimal', 'dance', 'idol', 'rock'],
+  },
+  {
+    id: 'animeHighEnergy1',
+    name: 'Anime High Energy 1',
+    degrees: [5, 2, 3, 0],
+    functional: 'loop',
+    styles: ['dance', 'idol'],
+  },
+  {
+    id: 'jazzPop',
+    name: 'Jazz Pop',
+    degrees: [1, 4, 0, 5],
+    functional: 'cadenceStrong',
+    styles: ['minimal', 'dance'],
+  },
+  {
+    id: 'animeHighEnergy2',
+    name: 'Anime High Energy 2',
+    degrees: [5, 1, 4, 0],
+    functional: 'cadenceStrong',
+    styles: ['dance', 'idol'],
+  },
+  {
+    id: 'cityPop',
+    name: 'City Pop',
+    degrees: [0, 5, 1, 4],
+    functional: 'stable',
+    styles: ['minimal', 'dance'],
+  },
+  {
+    id: 'extended5',
+    name: 'Extended 5',
+    degrees: [0, 4, 5, 2, 3],
+    functional: 'loop',
+    styles: ['minimal', 'dance', 'idol'],
+  },
+  {
+    id: 'neapolitanPop',
+    name: 'Neapolitan Pop',
+    degrees: [5, 12, 13, 4, 0],
+    functional: 'cadenceStrong',
+    styles: ['minimal', 'dance', 'idol'],
+  },
+];
+
+/** Chromatic semitone offset from the tonic for borrowed (non-diatonic) degrees. */
+const BORROWED_OFFSET: Record<number, number> = {
+  8: 8, // bVI
+  10: 10, // bVII
+  11: 3, // bIII
+  12: 5, // iv
+  13: 1, // bII
+  14: 6, // #IV
+};
+
+/** All built-in progression presets. */
+export function progressions(): ProgressionPreset[] {
+  return PRESETS.map((p) => ({ ...p, degrees: [...p.degrees], styles: [...p.styles] }));
+}
+
+/** Presets whose style list includes the given style. */
+export function progressionsByStyle(style: ProgStyle): ProgressionPreset[] {
+  return progressions().filter((p) => p.styles.includes(style));
+}
+
+/** Deterministic 32-bit PRNG producing a float in [0, 1). */
+function mulberry32(seed: number): () => number {
+  let state = seed >>> 0;
+  return () => {
+    state = (state + 0x6d2b79f5) >>> 0;
+    let t = state;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** Root pitch class of a scale degree in the given key, including borrowed degrees. */
+function degreeToRootPc(degree: number, key: KeyScale): number {
+  if (degree >= 0 && degree <= 6) {
+    const tones = scaleTonesInDegreeOrder(key);
+    return tones.length > 0 ? (tones[degree % tones.length] ?? key.rootPc % 12) : key.rootPc % 12;
+  }
+  const offset = BORROWED_OFFSET[degree] ?? 0;
+  return ((((key.rootPc % 12) + offset) % 12) + 12) % 12;
+}
+
+/**
+ * Diatonic (or borrowed) triad quality of a degree in the given key.
+ *
+ * Diatonic degrees (0-6) take their scale-correct triad quality, so non-major
+ * keys yield diatonic chords. Borrowed degrees keep their fixed chromatic
+ * qualities (`#IV` diminished, `iv` minor, the rest major).
+ */
+function autoQuality(degree: number, key: KeyScale): ChordQuality {
+  if (degree >= 0 && degree <= 6) {
+    return diatonicTriad(degree, key).quality;
+  }
+  if (degree === 14) {
+    return 'dim';
+  }
+  if (degree === 12) {
+    return 'min';
+  }
+  return 'maj';
+}
+
+/**
+ * Generate a chord progression laid out one chord per bar.
+ *
+ * A preset is chosen by `presetId` when given, otherwise deterministically from
+ * the presets matching `style`, seeded by `seed`. The preset's degrees cycle to
+ * fill `bars`; each bar is four beats, so `startBeat` is `barIndex * 4`. Chord
+ * roots come from the key's diatonic scale-degree mapping. When `ext` is
+ * omitted or `'auto'`, each chord takes its diatonic triad quality; otherwise
+ * `ext` is forced on every chord. When `reharmonize` is set, some chords are
+ * deterministically replaced with the secondary dominant (V7) of the following
+ * chord, flagged with `secondaryDominant`.
+ *
+ * @param opts Generation options.
+ * @returns One chord per bar in timeline order.
+ */
+export function generateProgression(opts: GenerateProgressionOptions): GeneratedChord[] {
+  const seed = opts.seed ?? 0;
+  let preset: ProgressionPreset | undefined;
+  if (opts.presetId !== undefined) {
+    preset = PRESETS.find((p) => p.id === opts.presetId);
+  }
+  if (preset === undefined) {
+    const pool = PRESETS.filter((p) => p.styles.includes(opts.style));
+    const candidates = pool.length > 0 ? pool : PRESETS;
+    const rng = mulberry32(seed);
+    const index = Math.floor(rng() * candidates.length) % candidates.length;
+    preset = candidates[index] ?? PRESETS[0];
+  }
+  const degrees = preset?.degrees ?? [0];
+  const chords: GeneratedChord[] = [];
+  for (let bar = 0; bar < opts.bars; bar += 1) {
+    const degree = degrees[bar % degrees.length] ?? 0;
+    const quality =
+      opts.ext !== undefined && opts.ext !== 'auto' ? opts.ext : autoQuality(degree, opts.key);
+    const chord: GeneratedChord = {
+      rootPc: degreeToRootPc(degree, opts.key),
+      quality,
+      startBeat: bar * 4,
+      degree: degree >= 0 && degree <= 6 ? degree : undefined,
+    };
+    chords.push(chord);
+  }
+
+  if (opts.reharmonize) {
+    const tonicPc = (((opts.key.rootPc % 12) + 12) % 12) as number;
+    const rrng = mulberry32((seed ^ 0x9e3779b9) >>> 0);
+    for (let i = 0; i < chords.length - 1; i += 1) {
+      const cur = chords[i];
+      const next = chords[i + 1];
+      if (!cur || !next) {
+        continue;
+      }
+      const domRoot = (next.rootPc + 7) % 12;
+      const targetsTonic = (next.rootPc - tonicPc + 12) % 12 === 0;
+      const alreadySecondary = cur.rootPc === domRoot && cur.quality === 'dom7';
+      // A secondary dominant inserted at i-1 resolves onto this chord; replacing
+      // it here would orphan that dominant.
+      const isResolutionTarget = chords[i - 1]?.secondaryDominant === true;
+      if (targetsTonic || alreadySecondary || isResolutionTarget) {
+        continue;
+      }
+      if (rrng() < 0.5) {
+        chords[i] = {
+          rootPc: domRoot,
+          quality: 'dom7',
+          startBeat: cur.startBeat,
+          secondaryDominant: true,
+        };
+      }
+    }
+  }
+
+  return chords;
+}

package/src/random/index.ts

@@ -0,0 +1,41 @@
+/**
+ * Deterministic seeded pseudo-random number generation shared across the
+ * generative modules (rhythm, drums, bass, groove, counter-melody). A single
+ * mulberry32 core exposes the small set of samplers those modules need; given a
+ * seed the stream is fully reproducible.
+ */
+
+/** A deterministic PRNG with the sampling helpers the generators need. */
+export type Rng = {
+  /** Next float in [0, 1). */
+  next: () => number;
+  /** True with probability `p`. */
+  prob: (p: number) => boolean;
+  /** Integer in the inclusive range [lo, hi]. */
+  range: (lo: number, hi: number) => number;
+  /** Float in [lo, hi). */
+  float: (lo: number, hi: number) => number;
+};
+
+/**
+ * Create a seeded PRNG (mulberry32) exposing the shared samplers.
+ *
+ * @param seed The 32-bit seed; the same seed always yields the same stream.
+ * @returns The seeded generator.
+ */
+export function createRng(seed: number): Rng {
+  let state = seed >>> 0;
+  const next = () => {
+    state = (state + 0x6d2b79f5) >>> 0;
+    let t = state;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+  return {
+    next,
+    prob: (p) => next() < p,
+    range: (lo, hi) => lo + Math.floor(next() * (hi - lo + 1)),
+    float: (lo, hi) => lo + next() * (hi - lo),
+  };
+}

package/src/reharmony/index.ts

@@ -0,0 +1,299 @@
+/**
+ * Reharmonization: chord substitution, modal-interchange palettes, and negative
+ * harmony. These transforms take an existing chord (or a key) and propose
+ * alternative harmonies that preserve a chosen relationship — a shared function,
+ * a common tone, a tonicizing dominant, or a reflection across the key axis.
+ *
+ * Roots are pitch classes (0..11); no spelled key signature is required.
+ */
+
+import {
+  type Chord,
+  type ChordQuality,
+  chordPitchClasses,
+  diatonicTriad,
+  makeChord,
+} from '../chord/index.js';
+import { detectChordBest } from '../detect/index.js';
+import {
+  type BorrowedSource,
+  borrowedSource,
+  chordToRoman,
+  functionOf,
+  type HarmonicFunction,
+  isDiatonic,
+  parallelKey,
+} from '../functional/index.js';
+import { scaleTonesInDegreeOrder } from '../scale/index.js';
+import type { KeyScale } from '../types.js';
+
+/** Reduce a value to a pitch class in [0, 11]. */
+function mod12(n: number): number {
+  return ((n % 12) + 12) % 12;
+}
+
+/** The kind of substitution relationship a candidate realizes. */
+export type SubstitutionType =
+  | 'tritone'
+  | 'relative'
+  | 'borrowed'
+  | 'chromatic-mediant'
+  | 'secondary-dominant';
+
+/** A proposed chord substitution with its relationship, numeral, and function. */
+export type Substitution = {
+  chord: Chord;
+  type: SubstitutionType;
+  roman: string;
+  function: HarmonicFunction;
+};
+
+/** Options controlling which substitutions {@link substituteChord} returns. */
+export type SubstituteOptions = {
+  /**
+   * Melody pitch classes that must remain chord tones. When given, only
+   * substitutions whose pitch classes contain every listed pitch class are
+   * kept, so the melody stays consonant against the new harmony.
+   */
+  melodyPcs?: number[];
+};
+
+/** Whether the chord's template carries a given interval (mod 12). */
+function hasInterval(chord: Chord, semitone: number): boolean {
+  return chord.intervals.some((iv) => mod12(iv) === semitone);
+}
+
+/** Whether a chord is a dominant type: a major third with a minor seventh. */
+function isDominantType(chord: Chord): boolean {
+  return hasInterval(chord, 4) && hasInterval(chord, 10);
+}
+
+/**
+ * A chord that can be tonicized: it has a perfect fifth and a third but is not
+ * itself a dominant seventh (which is an unstable, tonicizing sonority rather
+ * than a stable target).
+ */
+function isStableTarget(chord: Chord): boolean {
+  const hasFifth = hasInterval(chord, 7);
+  const hasThird = hasInterval(chord, 3) || hasInterval(chord, 4);
+  return hasFifth && hasThird && !isDominantType(chord);
+}
+
+/** The triad pitch classes (root, third, fifth) implied by a chord's template. */
+function triadPitchClasses(chord: Chord): number[] {
+  const third = hasInterval(chord, 4) ? 4 : hasInterval(chord, 3) ? 3 : 4;
+  const fifth = hasInterval(chord, 8) ? 8 : hasInterval(chord, 6) ? 6 : 7;
+  return [mod12(chord.rootPc), mod12(chord.rootPc + third), mod12(chord.rootPc + fifth)];
+}
+
+/** Count the pitch classes shared between two pitch-class sets. */
+function commonToneCount(a: number[], b: number[]): number {
+  const set = new Set(b);
+  return a.filter((pc) => set.has(pc)).length;
+}
+
+/** The diatonic triads of a key, one per scale degree. */
+function diatonicTriadsOf(key: KeyScale): Chord[] {
+  const degrees = scaleTonesInDegreeOrder(key).length;
+  const triads: Chord[] = [];
+  for (let degree = 0; degree < degrees; degree += 1) {
+    triads.push(diatonicTriad(degree, key));
+  }
+  return triads;
+}
+
+/** Whether two chords share the same root pitch class and quality. */
+function sameChord(a: Chord, b: Chord): boolean {
+  return mod12(a.rootPc) === mod12(b.rootPc) && a.quality === b.quality;
+}
+
+/** Root offsets (semitones) that form a third above or below a root. */
+const THIRD_OFFSETS = [3, 4, 8, 9] as const;
+
+/**
+ * Propose substitutions for a chord within a key.
+ *
+ * Candidates are generated by several relationships and deduplicated against the
+ * original chord and each other:
+ *
+ * - `tritone`: for a dominant-type chord, the dominant seventh a tritone away.
+ * - `secondary-dominant`: for a stable target, the dominant seventh a fifth
+ *   above its root (tonicizing it).
+ * - `relative`: a diatonic triad a third away that shares two common tones.
+ * - `borrowed`: a triad from the parallel mode with the same harmonic function.
+ * - `chromatic-mediant`: a major/minor triad a third away sharing one common
+ *   tone.
+ *
+ * Each result carries its Roman numeral and harmonic function in `key`. When
+ * `opts.melodyPcs` is given, only substitutions whose pitch classes contain all
+ * of those pitch classes are returned.
+ *
+ * @param chord The chord to reharmonize.
+ * @param key The prevailing key.
+ * @param opts Optional melody-preservation constraint.
+ * @returns The deduplicated substitution candidates.
+ */
+export function substituteChord(
+  chord: Chord,
+  key: KeyScale,
+  opts?: SubstituteOptions,
+): Substitution[] {
+  const original = triadPitchClasses(chord);
+  const candidates: { chord: Chord; type: SubstitutionType }[] = [];
+
+  // Tritone substitution: only for dominant-type chords.
+  if (isDominantType(chord)) {
+    candidates.push({ chord: makeChord(mod12(chord.rootPc + 6), 'dom7'), type: 'tritone' });
+  }
+
+  // Secondary dominant: the V7 tonicizing a stable target.
+  if (isStableTarget(chord)) {
+    candidates.push({
+      chord: makeChord(mod12(chord.rootPc + 7), 'dom7'),
+      type: 'secondary-dominant',
+    });
+  }
+
+  // Relative: a diatonic triad a third away sharing two common tones.
+  for (const triad of diatonicTriadsOf(key)) {
+    const offset = mod12(triad.rootPc - chord.rootPc);
+    if (
+      (THIRD_OFFSETS as readonly number[]).includes(offset) &&
+      commonToneCount(original, chordPitchClasses(triad)) === 2
+    ) {
+      candidates.push({ chord: triad, type: 'relative' });
+    }
+  }
+
+  // Borrowed: a parallel-mode triad sharing the original's harmonic function.
+  const targetFunction = functionOf(chord, key);
+  for (const triad of diatonicTriadsOf(parallelKey(key))) {
+    if (functionOf(triad, key) === targetFunction && !isDiatonic(triad, key)) {
+      candidates.push({ chord: triad, type: 'borrowed' });
+    }
+  }
+
+  // Chromatic mediants: major/minor triads a third away sharing one common tone.
+  for (const offset of THIRD_OFFSETS) {
+    for (const quality of ['maj', 'min'] as const) {
+      const mediant = makeChord(mod12(chord.rootPc + offset), quality);
+      if (
+        commonToneCount(original, chordPitchClasses(mediant)) === 1 &&
+        !isDiatonic(mediant, key)
+      ) {
+        candidates.push({ chord: mediant, type: 'chromatic-mediant' });
+      }
+    }
+  }
+
+  const melodyPcs = opts?.melodyPcs?.map(mod12);
+  const seen = new Set<string>();
+  const results: Substitution[] = [];
+  for (const candidate of candidates) {
+    if (sameChord(candidate.chord, chord)) {
+      continue;
+    }
+    const dedupeKey = `${mod12(candidate.chord.rootPc)}:${candidate.chord.quality}`;
+    if (seen.has(dedupeKey)) {
+      continue;
+    }
+    seen.add(dedupeKey);
+    if (melodyPcs !== undefined) {
+      const pcs = new Set(chordPitchClasses(candidate.chord));
+      if (!melodyPcs.every((pc) => pcs.has(pc))) {
+        continue;
+      }
+    }
+    results.push({
+      chord: candidate.chord,
+      type: candidate.type,
+      roman: chordToRoman(candidate.chord, key),
+      function: functionOf(candidate.chord, key),
+    });
+  }
+  return results;
+}
+
+/** A borrowed chord in the modal-interchange palette of a key. */
+export type BorrowedChord = {
+  chord: Chord;
+  roman: string;
+  source: BorrowedSource;
+};
+
+/**
+ * The modal-interchange palette of a key.
+ *
+ * Lists the diatonic triads of the {@link parallelKey} that are not diatonic to
+ * `key` (the classic borrowed chords such as `iv`, `bVI`, and `bVII` in a major
+ * key), plus the Neapolitan (a major triad on the flat second degree). Each
+ * carries its Roman numeral and {@link borrowedSource} relative to `key`.
+ *
+ * @param key The prevailing key.
+ * @returns The borrowed-chord palette.
+ */
+export function modalInterchangePalette(key: KeyScale): BorrowedChord[] {
+  const palette: BorrowedChord[] = [];
+  const seen = new Set<string>();
+  const add = (chord: Chord) => {
+    const dedupeKey = `${mod12(chord.rootPc)}:${chord.quality}`;
+    if (seen.has(dedupeKey)) {
+      return;
+    }
+    seen.add(dedupeKey);
+    palette.push({
+      chord,
+      roman: chordToRoman(chord, key),
+      source: borrowedSource(chord, key),
+    });
+  };
+
+  for (const triad of diatonicTriadsOf(parallelKey(key))) {
+    if (!isDiatonic(triad, key)) {
+      add(triad);
+    }
+  }
+  // The Neapolitan (major triad on b2) sits outside both parallel modes, so it
+  // is added explicitly — unless b2 is already diatonic (e.g. in a Phrygian key,
+  // where it is a native chord rather than a borrowing).
+  const neapolitan = makeChord(mod12(key.rootPc + 1), 'maj');
+  if (!isDiatonic(neapolitan, key)) {
+    add(neapolitan);
+  }
+  return palette;
+}
+
+/**
+ * Reflect a chord across the tonic–dominant axis of a key (negative harmony).
+ *
+ * Every pitch class `p` maps to `(2*T + 7 - p) mod 12`, where `T` is the key
+ * tonic — the reflection that swaps the tonic with the dominant. The mirrored
+ * pitch classes (including the bass, if set) are reassembled into a chord by
+ * {@link detectChordBest}; when no chord is recognized, the mirrored root and
+ * the original quality are used as a fallback.
+ *
+ * @param chord The chord to reflect.
+ * @param key The prevailing key.
+ * @returns The negative-harmony counterpart of the chord.
+ */
+export function negativeHarmonyMirror(chord: Chord, key: KeyScale): Chord {
+  const tonic = mod12(key.rootPc);
+  const mirror = (p: number) => mod12(2 * tonic + 7 - p);
+  const pcs = chordPitchClasses(chord).map(mirror);
+  const bassPc = chord.bassPc !== undefined ? mirror(chord.bassPc) : undefined;
+  // Place the mirrored bass an octave below so it is recognized as the lowest
+  // note and preserved through detection.
+  const pitches = bassPc !== undefined ? [bassPc - 12, ...pcs] : pcs;
+  const detected = detectChordBest(pitches);
+  if (detected) {
+    // Without an input bass the mirrored tones are octave-less, so detection may
+    // read the lowest pitch class as a slash bass and report a spurious
+    // inversion. Restore the recognized chord to root position in that case.
+    if (bassPc === undefined && detected.bassPc !== undefined) {
+      return makeChord(detected.rootPc, detected.quality);
+    }
+    return detected;
+  }
+  const quality: ChordQuality = chord.quality;
+  return makeChord(mirror(chord.rootPc), quality, bassPc);
+}