Class Chord

An immutable chord: a root pitch class, quality, interval template, and optional slash bass, optionally carrying a Key context. Analysis methods (roman, function, analyze, ...) use an explicitly passed key first and fall back to the carried context.

Example

import { Chord } from '@libraz/libcantus';
Chord.parse('Cmaj7').invert(1).symbol(); // 'Cmaj7/E' (third in the bass)

Constructors

constructor

new Chord(data: ChordData, key?: KeyLike): Chord
Wrap a plain chord object.
Parameters
- data: ChordData
  The chord; it is copied, never retained or mutated.
- Optionalkey: KeyLike
  Optional key context for analysis methods, in whatever form the caller holds it: a key name, a plain key/scale, or a Key.
Returns Chord
- Defined in src/model/chord.ts:239

Accessors

rootPc

get rootPc(): number
The root pitch class (0..11).

Returns number
- Defined in src/model/chord.ts:462

quality

get quality(): ChordQuality
The chord quality.

Returns ChordQuality
- Defined in src/model/chord.ts:467

intervals

get intervals(): number[]
A copy of the semitone offsets above the root.

Returns number[]
- Defined in src/model/chord.ts:472

bassPc

get bassPc(): number | undefined
The slash-chord bass pitch class, or undefined in root position.

Returns number | undefined
- Defined in src/model/chord.ts:477

data

get data(): ChordData
A copy of the underlying plain chord object, including the spellings derived from any attached key.

Returns ChordData
- Defined in src/model/chord.ts:485

spec

get spec(): ChordSpec
The chord read structurally: the triad it is built on, its seventh, and the alterations, additions and omissions on top of them.

The reading comes from the tones themselves, so a chord no symbol names — a detected pitch set, a custom interval template — still describes itself; only a template with no structural reading at all falls back to the one its quality names.

Returns ChordSpec
Throws
If the chord's template has no reading and its quality is unknown.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('Cmaj7').spec.base; // 'maj'
Chord.parse('C/E').spec.bassPc; // 4
```
- Defined in src/model/chord.ts:506

key

get key(): Key | undefined
The carried key context, if any.

Returns Key | undefined
- Defined in src/model/chord.ts:511

Methods

`Static`of

of(root: string | number, quality: ChordQuality, bass?: string | number): Chord
Build a chord from a root and quality.
Parameters
- root: string | number
  Root as a note name (e.g. 'Eb') or a pitch class.
- quality: ChordQuality
  The chord quality.
- Optionalbass: string | number
  Optional slash-chord bass, as a note name (e.g. 'Bb') or a pitch class. A named bass keeps its own spelling.
Returns Chord
The chord (without key context).
- Defined in src/model/chord.ts:280

`Static`fromData

fromData(data: ChordData): Chord
Wrap an existing plain chord object.
Parameters
- data: ChordData
  The plain chord.
Returns Chord
The wrapped chord (without key context).
- Defined in src/model/chord.ts:304

`Static`fromJSON

fromJSON(data: ChordData): Chord
Rebuild a chord from its Chord.toJSON output.

The key context is not serialized, so the result carries none; re-attach one with Chord.withKey.
Parameters
- data: ChordData
  The serialized chord.
Returns Chord
The wrapped chord.
- Defined in src/model/chord.ts:317

`Static`fromFiguredBass

fromFiguredBass(bass: NoteLike, figures: string, key: KeyLike): Chord
The chord a figured bass names: a bass note, the figures written under it, and the key that supplies every interval the figures leave unaltered.

The inverse of Chord.figuredBass, and a static because the figures build a chord rather than read one. The result carries the given bass as its slash bass, so an inversion reads as one wherever a bass is measured against a root, and it keeps the letters the figures asked for. A moving figure such as 4-3 yields the chord it resolves into.

No key context is attached — the key here decides what the figures mean, not how the chord is later analyzed — so use Chord.withKey to carry one on.
Parameters
- bass: NoteLike
  The bass note, spelled, as a note name, a MIDI number, or a Note; its octave, if any, is not used.
- figures: string
  The figures written under the bass; empty for an unfigured note.
- key: KeyLike
  The prevailing key; a key name, a plain key/scale, or a Key.
Returns Chord
The chord the figures name (without key context).
Throws
If the figures are malformed or name no chord, if the key is not heptatonic, or if the figures sound a chord no ChordQuality names.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.fromFiguredBass('B', '6', 'C major').symbol(); // 'G/B'
Chord.fromFiguredBass('G', 'n', 'C minor').symbol(); // 'G'
```
- Defined in src/model/chord.ts:352

`Static`parse

parse(symbol: string, opts?: NoteNameOptions): Chord
Parse a lead-sheet chord symbol (e.g. 'Cmaj7', 'F#m7b5', 'C/G').

A symbol is English unless a system is asked for: unlike Key.parse, which reads the notation system off the name, 'B' here is always the B natural until 'german' says otherwise.
Parameters
- symbol: string
  The chord symbol.
- Optionalopts: NoteNameOptions
  system reads the root and bass in that notation system instead of English.
Returns Chord
The chord (without key context).
Throws
If the root or quality is not recognized. Use Chord.tryParse where failure is ordinary, such as a chord field read on every keystroke.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('H7', { system: 'german' }).symbol(); // 'B7'
```
- Defined in src/model/chord.ts:379

`Static`tryParse

tryParse(symbol: string, opts?: NoteNameOptions): ParseResult<Chord>
Parse a lead-sheet chord symbol, reporting failure instead of throwing it.

The same reading as Chord.parse, for the callers where a symbol that does not parse yet is the normal state of the input rather than a fault: a chord field can show what is wrong with what has been typed so far without a try around every keystroke.
Parameters
- symbol: string
  The chord symbol.
- Optionalopts: NoteNameOptions
  system reads the root and bass in that notation system instead of English.
Returns ParseResult<Chord>
The chord (without key context), or the error explaining why the text is not one.
Example
```
import { Chord } from '@libraz/libcantus';
const result = Chord.tryParse('Cmaj7(#11)');
result.ok ? result.value.symbol() : result.error.message; // 'Cmaj7#11'
```
- Defined in src/model/chord.ts:403

`Static`detect

detect(pitches: readonly number[], opts?: DetectChordOptions): Chord[]
Identify the chords matching a set of pitches, best interpretation first.
Parameters
- pitches: readonly number[]
  MIDI pitches or bare pitch classes.
- Optionalopts: DetectChordOptions
  How to interpret the input; see DetectChordOptions.
Returns Chord[]
Ranked chord interpretations (may be empty).
- Defined in src/model/chord.ts:415

`Static`detectMatches

detectMatches(
pitches: readonly number[],
opts?: DetectChordOptions,
): { chord: Chord; match: ChordMatch }[]
Identify the chords matching a set of pitches, keeping each match's recognition metadata beside the chord.

Chord.detect discards the confidence signals a recognition UI needs — whether the set matched exactly, which chord tones were missing, which input notes were foreign, and which inversion the bass implies.
Parameters
- pitches: readonly number[]
  MIDI pitches or bare pitch classes.
- Optionalopts: DetectChordOptions
  How to interpret the input; see DetectChordOptions.
Returns { chord: Chord; match: ChordMatch }[]
Ranked interpretations, each with its chord and its match record.
Example
```
import { Chord } from '@libraz/libcantus';
const [best] = Chord.detectMatches([60, 64, 67]);
best?.match.exact; // true
```
- Defined in src/model/chord.ts:439

`Static`detectBest

detectBest(pitches: readonly number[], opts?: DetectChordOptions): Chord | null
The single best chord interpretation of a pitch set.
Parameters
- pitches: readonly number[]
  MIDI pitches or bare pitch classes.
- Optionalopts: DetectChordOptions
  How to interpret the input; see DetectChordOptions.
Returns Chord | null
The top-ranked chord, or null when nothing matches.
- Defined in src/model/chord.ts:456

withKey

withKey(key: KeyLike): Chord
A copy of this chord carrying the given key context.

Only a spelling the caller supplied (via Chord.parse, Chord.of with a named root, or plain data carrying a hint) survives; a spelling that came from a previously attached key is re-derived, so re-keying a progression during a modulation does not keep the old key's letters and the order of withKey calls does not affect the result.
Parameters
- key: KeyLike
  The key context to attach; a key name, a plain key/scale, or a Key.
Returns Chord
The new chord.
- Defined in src/model/chord.ts:528

pitchClasses

pitchClasses(opts?: { includeBass?: boolean }): number[]
The chord's sorted, deduplicated pitch classes.

A slash bass is one of them, because the chord sounds it.
Parameters
- Optionalopts: { includeBass?: boolean }
  Set includeBass: false to enumerate the interval template alone, leaving a slash bass out.
Returns number[]
Pitch classes ascending in [0, 11].
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('F/G').pitchClasses(); // [0, 5, 7, 9]
Chord.parse('F/G').pitchClasses({ includeBass: false }); // [0, 5, 9]
```
- Defined in src/model/chord.ts:547

contains

contains(pitch: number): boolean
Whether a pitch is one of the chord's tones, ignoring octave.

A slash bass counts, as it does in Chord.pitchClasses: the chord sounds it.
Parameters
- pitch: number
  A MIDI pitch or a bare pitch class.
Returns boolean
True when the pitch class belongs to the chord.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('Cmaj7').contains(64); // true
Chord.parse('Cmaj7').contains(62); // false
```
- Defined in src/model/chord.ts:566

roleOf

roleOf(pitch: number): ChordToneRole | null
A pitch's harmonic role in the chord: root, third, fifth, sixth, or seventh.

The role follows the pitch's interval above the root, so it answers for the chord's own template rather than for the interval alone: the diminished fifth of a half-diminished seventh is its fifth, while the same interval over a chord that already has a perfect fifth is a #11 tension and has no basic role.
Parameters
- pitch: number
  A MIDI pitch or a bare pitch class.
Returns ChordToneRole | null
The chord-tone role, or null when the pitch is a tension or a foreign note.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('Cmaj7').roleOf(67); // 'fifth'
Chord.parse('Cmaj7').roleOf(62); // null
```
- Defined in src/model/chord.ts:590

roman

roman(key?: KeyLike, opts?: ChordToRomanOptions): string
The chord's Roman numeral in a key.
Parameters
- Optionalkey: KeyLike
  Key to analyze in, as a key name, a plain key/scale, or a Key; falls back to the carried context.
- Optionalopts: ChordToRomanOptions
  Applied-numeral rendering options.
Returns string
The Roman numeral string.

Throws
If no key is given and none is carried.
- Defined in src/model/chord.ts:603

explain

explain(key?: KeyLike, opts?: ExplainRomanOptions): RomanExplanation
The chord's Roman numeral together with the reasoning behind it: the degree its root was read as, the quality that set the numeral's case and suffix, and what became of the bass.

The numeral is exactly the one Chord.roman gives for the same arguments, so this is that method with its rationale attached — for teaching material, and for any interface whose users argue with the analysis. Ask for alternatives to see the numerals the other option settings would have rendered, and why this one was rendered instead.
Parameters
- Optionalkey: KeyLike
  Key to analyze in; a key name, a plain key/scale, or a Key. Falls back to the carried context.
- Optionalopts: ExplainRomanOptions
  The rendering options Chord.roman takes, plus alternatives to collect the readings this one turned down; see ExplainRomanOptions.
Returns RomanExplanation
The numeral, its rationale, and the rejected readings.
Throws
If no key is given and none is carried.
Example
```
import { Chord, Key } from '@libraz/libcantus';
Chord.parse('G7').explain(Key.major('C')).roman; // 'V7'
Chord.parse('D7').explain('C major', { alternatives: true }).alternatives.length;
```
- Defined in src/model/chord.ts:632

function

function(key?: KeyLike): HarmonicFunction
The chord's harmonic function (tonic / subdominant / dominant) in a key.
Parameters
- Optionalkey: KeyLike
  Key to analyze in, as a key name, a plain key/scale, or a Key; falls back to the carried context.
Returns HarmonicFunction
The harmonic function.

Throws
If no key is given and none is carried.
- Defined in src/model/chord.ts:644

analyze

analyze(key?: KeyLike, opts?: AnalyzeChordOptions): ChordAnalysis
Full functional analysis: function, borrowing, Roman numeral, and the rationale behind them.
Parameters
- Optionalkey: KeyLike
  Key to analyze in, as a key name, a plain key/scale, or a Key; falls back to the carried context.
- Optionalopts: AnalyzeChordOptions
  Applied-numeral rendering options, plus alternatives to collect the readings this analysis turned down; see AnalyzeChordOptions.
Returns ChordAnalysis
The chord analysis.
Throws
If no key is given and none is carried.
Example
```
import { Chord, Key } from '@libraz/libcantus';
Chord.parse('D7').analyze(Key.major('C'), { alternatives: true }).alternatives.length;
```
- Defined in src/model/chord.ts:665

isBorrowed

isBorrowed(key?: KeyLike): boolean
Whether the chord is borrowed from the parallel mode (modal interchange).
Parameters
- Optionalkey: KeyLike
  Key to analyze in, as a key name, a plain key/scale, or a Key; falls back to the carried context.
Returns boolean
True if the chord is borrowed.

Throws
If no key is given and none is carried.
- Defined in src/model/chord.ts:677

borrowedSource

borrowedSource(key?: KeyLike): BorrowedSource
The origin of a non-diatonic chord (parallel mode or Neapolitan), or null.
Parameters
- Optionalkey: KeyLike
  Key to analyze in, as a key name, a plain key/scale, or a Key; falls back to the carried context.
Returns BorrowedSource
The borrowing source, or null.

Throws
If no key is given and none is carried.
- Defined in src/model/chord.ts:689

figuredBass

figuredBass(key?: KeyLike): string
The chord written as the figures a bass would carry under it: 6, 64, 7, 65, 43, 42, or nothing at all for a root-position triad, with an accidental on any interval the key does not already give.

The bass the figures are measured above is the chord's own slash bass, or its root in root position.
Parameters
- Optionalkey: KeyLike
  Key deciding which intervals need no accidental; a key name, a plain key/scale, or a Key. Falls back to the carried context.
Returns string
The figures, as realizeFiguredBass reads them.
Throws
If no key is given and none is carried, if the key is not heptatonic, or if no figure names the chord — its bass is not one of its tones, its tones do not stack in diatonic thirds above that bass, or it is an added-tone or extended chord the notation has no abbreviation for.
Example
```
import { Chord, Key } from '@libraz/libcantus';
Chord.parse('G/B').figuredBass(Key.major('C')); // '6'
Chord.parse('G7/D').figuredBass('C major'); // '43'
```
- Defined in src/model/chord.ts:715

substitutions

substitutions(key?: KeyLike, opts?: SubstituteOptions): Substitution[]
The chords that can stand in for this one in a key: its tritone substitute, the diatonic triads a third away that share two of its tones, the parallel-mode chords with its harmonic function, and its chromatic mediants.

Each candidate carries the relationship it realizes, its Roman numeral, and its harmonic function in the key.
Parameters
- Optionalkey: KeyLike
  Key the substitution is read in; a key name, a plain key/scale, or a Key. Falls back to the carried context.
- Optionalopts: SubstituteOptions
  Set melodyPcs to the pitch classes a melody holds over this chord, so only substitutions that keep every one of them a chord tone are proposed.
Returns Substitution[]
The deduplicated candidates; the chords are plain data, spelled the way the key writes them.
Throws
If no key is given and none is carried.
Example
```
import { Chord, Key } from '@libraz/libcantus';
const subs = Chord.parse('G7').withKey(Key.major('C')).substitutions();
subs.find((sub) => sub.type === 'tritone')?.chord.rootPc; // 1
```
- Defined in src/model/chord.ts:743

modalInterchange

modalInterchange(key?: KeyLike): BorrowedChord[]
The modal-interchange palette of the chord's key: the parallel mode's triads that the key itself does not contain, plus the Neapolitan, each with its Roman numeral and its borrowing source.

The palette belongs to the key rather than to this chord, so it is the same list for every chord in it; it is reachable here because a chord is where a caller looking for somewhere else to go already is.
Parameters
- Optionalkey: KeyLike
  Key to borrow into; a key name, a plain key/scale, or a Key. Falls back to the carried context.
Returns BorrowedChord[]
The borrowed chords, spelled the way the mode they come from writes them.
Throws
If no key is given and none is carried.
Example
```
import { Chord, formatChordSymbol, Key } from '@libraz/libcantus';
const palette = Chord.parse('C').withKey(Key.major('C')).modalInterchange();
palette.map((borrowed) => formatChordSymbol(borrowed.chord));
// ['Cm', 'Ddim', 'Eb', 'Fm', 'Gm', 'Ab', 'Bb', 'Db']
```
- Defined in src/model/chord.ts:769

symbol

symbol(opts?: ChordSymbolOptions): string
The chord rendered as a lead-sheet symbol (e.g. 'Cmaj7', 'F#m7', 'C/G').
Parameters
- Optionalopts: ChordSymbolOptions
  Set flats: true to spell the root/bass with flats, or system to write them in another notation system.
Returns string
The chord symbol.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('Bb7').symbol({ system: 'german' }); // 'B7'
```
- Defined in src/model/chord.ts:785

voice

voice(opts?: VoicingOptions): number[]
Realize the chord as one MIDI pitch per voice, ascending.

A chord that carries a key passes it to the voicer, so the leading tone is not doubled; an explicit opts.key overrides it.
Parameters
- Optionalopts: VoicingOptions
  Voicing options; defaults to four SATB voices.
Returns number[]
MIDI pitches, ascending, one per voice.

Throws
If no voicing fits the given ranges.
- Defined in src/model/chord.ts:799

styledVoicing

styledVoicing(opts?: StyledVoicingOptions): number[]
Realize the chord as a single styled voicing (close, drop2, drop3, shell, or rootless), optionally constraining the top voice.
Parameters
- Optionalopts: StyledVoicingOptions
  Styled-voicing options; defaults to a close-position voicing.
Returns number[]
MIDI pitches, ascending.
- Defined in src/model/chord.ts:814

negativeHarmony

negativeHarmony(key?: KeyLike): Chord
The negative-harmony mirror of the chord about the key's tonic–dominant axis (major becomes minor and vice versa).
Parameters
- Optionalkey: KeyLike
  Key providing the reflection axis, as a key name, a plain key/scale, or a Key; falls back to the carried context.
Returns Chord
The mirrored chord, keeping any key context.

Throws
If no key is given and none is carried.
- Defined in src/model/chord.ts:827

secondaryDominant

secondaryDominant(): Chord
The V7 that tonicizes this chord: a dominant seventh a perfect fifth above this chord's root.

The target is the chord itself, so no key is involved and a borrowed or chromatic chord gets its dominant as readily as a diatonic one. A root spelling this chord supplied moves with the root, so Eb gives Bb7.

Returns Chord
The secondary dominant, keeping any key context.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('Eb').secondaryDominant().symbol(); // 'Bb7'
```
- Defined in src/model/chord.ts:851

invert

invert(n: number): Chord
The n-th inversion: a copy whose bass is the chord tone n steps above the root in the interval template (invert(1) puts the third in the bass). n wraps around the template length; negative values count backwards.

invert(0) (and any n that wraps to it) is root position, so it carries no slash bass and equals the original chord.
Parameters
- n: number
  The inversion number.
Returns Chord
The inverted chord, keeping any key context.

Throws
If the chord has no intervals.
- Defined in src/model/chord.ts:869

transpose

transpose(semitones: number): Chord
Transpose the chord by a number of semitones.

The quality and interval template are carried over, so a chord that a symbol round-trip could not express — a custom interval set, an inversion — survives. A carried key moves with the chord, so the transposed chord keeps the same degree and function inside the transposed key.
Parameters
- semitones: number
  The signed semitone offset.
Returns Chord
The transposed chord, in the transposed key when one is carried.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('C/G').transpose(2).symbol(); // 'D/A'
```
- Defined in src/model/chord.ts:904

transposeBy

transposeBy(interval: IntervalLike): Chord
Transpose the chord by a spelled interval.

Unlike Chord.transpose, which picks letters from a semitone count, the interval's diatonic number decides them: a C chord up an augmented fourth is F#, up a diminished fifth Gb. As with the semitone form, the quality and interval template are carried over and a carried key moves with the chord.
Parameters
- interval: IntervalLike
  An interval name (e.g. 'A4', '-m3'), plain interval data, or an Interval; a descending interval moves down.
Returns Chord
The transposed chord, in the transposed key when one is carried.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('C').transposeBy('A4').symbol(); // 'F#'
Chord.parse('C').transposeBy('d5').symbol(); // 'Gb'
```
- Defined in src/model/chord.ts:944

scales

scales(): ChordScaleMatch[]
The named scales that fit over this chord, best fit first, rooted on the chord root.

Only the scales of NAMED_SCALES are ranked: chord-scale theory is a Western practice, so the scales of WORLD_SCALES are left out rather than offered as answers over a chord.

Returns ChordScaleMatch[]
The matching scales.
- Defined in src/model/chord.ts:974

scaleReport

scaleReport(limit?: number): ChordScaleReportEntry[]
The scales that fit over this chord, each with the tones it does not state sorted by what may be done with them: the ones to avoid outright, the ones a line may pass through, and the ones that may be added freely as color.

Chord.scales ranks the same scales in the same order; this is that ranking read as playing advice, so a caller does not have to pair it with Chord.avoidNotes and Chord.tensions once per scale.
Parameters
- Optionallimit: number
  Greatest number of scales to report; all of them by default.
Returns ChordScaleReportEntry[]
One entry per reported scale, best fit first; see ChordScaleReportEntry.
Throws
If limit is not a positive integer.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.of('C', 'maj7').scaleReport(1)[0]?.passing; // [5]
```
- Defined in src/model/chord.ts:997

tensions

tensions(scaleName: ScaleNameInput, opts?: AvailableTensionsOptions): number[]
The available tensions (usable non-chord, non-avoid scale tones) of a scale over this chord.
Parameters
- scaleName: ScaleNameInput
  A scale of NAMED_SCALES, or one of its aliases, rooted on the chord root. The scales of WORLD_SCALES are refused here as they are by Chord.scales: chord-scale theory is a Western practice, and a scale from another tradition offered over a chord would read as an answer while being a category error.
- Optionalopts: AvailableTensionsOptions
  Set resolvesTo to the plain chord this one resolves to, so a dominant resolving down a fifth onto a minor tonic takes the tensions that resolution makes available; see AvailableTensionsOptions.
Returns number[]
Tension pitch classes, ascending in [0, 11].
Throws
If scaleName is not one of the named scales or their aliases.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.of('G', 'dom7').tensions('phrygianDominant', {
  resolvesTo: Chord.of('C', 'min').data,
}); // [3, 8]
```
- Defined in src/model/chord.ts:1023

avoidNotes

avoidNotes(scaleName: ScaleNameInput, opts?: AvoidNotesOptions): number[]
The avoid notes (scale tones a semitone above a chord tone) of a scale over this chord.
Parameters
- scaleName: ScaleNameInput
  A scale of NAMED_SCALES, or one of its aliases, rooted on the chord root. The scales of WORLD_SCALES are refused here as they are by Chord.scales: chord-scale theory is a Western practice, and a scale from another tradition offered over a chord would read as an answer while being a category error.
- Optionalopts: AvoidNotesOptions
  Set use: 'melodic' to judge a line rather than a voicing, so a tone a line may pass through is not counted; see AvoidNotesOptions.
Returns number[]
Avoid-note pitch classes, ascending in [0, 11].
Throws
If scaleName is not one of the named scales or their aliases.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.of('C', 'maj7').avoidNotes('ionian'); // [5]
Chord.of('C', 'maj7').avoidNotes('ionian', { use: 'melodic' }); // []
```
- Defined in src/model/chord.ts:1048

spell

spell(key?: KeyLike): Note[]
Spell the chord tones with letter names, root first, in the key's spelling.

A chord that already knows how its root is spelled — one from Chord.parse, or Chord.of with a named root — can spell itself with no key at all; a key is only needed to choose a spelling for a bare pitch class.

A slash bass outside the chord tones is appended, so the spelled notes are the notes the chord sounds — the same set Chord.pitchClasses reports.
Parameters
- Optionalkey: KeyLike
  Key providing the spelled tonic, as a key name, a plain key/scale, or a Key — the tonic its letters are spelled from is derived from the key rather than asked of the caller. Falls back to the carried context, then to the chord's own root spelling.
Returns Note[]
Spelled octave-less notes in the chord's own (tertian) order, with any foreign slash bass last.

Throws
If no key is given, none is carried, and the chord has no root spelling of its own.
- Defined in src/model/chord.ts:1073

progressionTo

progressionTo(...others: Chord[]): Progression
Start a progression with this chord followed by others, carrying this chord's key context (if any).
Parameters
- ...others: Chord[]
  The chords following this one.
Returns Progression
The progression.
- Defined in src/model/chord.ts:1110

span

span(startBeat: number): ChordSpan
The chord placed at a beat, as the ChordSpan the arrangement and generation functions take.

The interval template is recorded only when it departs from the one the quality names, so a standard chord yields the same span it always did while a custom template is not lost. Key context and spelling hints are not part of a span and are left behind.
Parameters
- startBeat: number
  Beat the chord starts on.
Returns ChordSpan
The span describing this chord at that beat.
Throws
If startBeat is not finite, or the chord's quality is unknown.
Example
```
import { Chord } from '@libraz/libcantus';
Chord.parse('Cmaj7').span(4); // { rootPc: 0, quality: 'maj7', startBeat: 4 }
```
- Defined in src/model/chord.ts:1132

equals

equals(other: Chord): boolean
Whether another chord has the same root, quality, intervals, and bass. Key context is not compared.
Parameters
- other: Chord
  The chord to compare.
Returns boolean
True if the chord data is identical.
- Defined in src/model/chord.ts:1143

toJSON

toJSON(): ChordData
The plain chord data, for JSON serialization.

Returns ChordData
A copy of the underlying plain chord object.
- Defined in src/model/chord.ts:1160

toString

toString(): string
The chord symbol, so a template literal or a log line reads as the chord.

Returns string
The symbol, e.g. 'Cmaj7'.
- Defined in src/model/chord.ts:1171

Class Chord

Example

Index

Constructors

Accessors

Methods

Constructors

constructor

Parameters

Returns Chord

Accessors

rootPc

Returns number

quality

Returns ChordQuality

intervals

Returns number[]

bassPc

Returns number | undefined

data

Returns ChordData

spec

Returns ChordSpec

Throws

Example

key

Returns Key | undefined

Methods

Staticof

Parameters

Returns Chord

StaticfromData

Parameters

Returns Chord

StaticfromJSON

Parameters

Returns Chord

StaticfromFiguredBass

Parameters

Returns Chord

Throws

Example

Staticparse

Parameters

Returns Chord

Throws

Example

StatictryParse

Parameters

Returns ParseResult<Chord>

Example

Staticdetect

Parameters

Returns Chord[]

StaticdetectMatches

Parameters

Returns { chord: Chord; match: ChordMatch }[]

Example

StaticdetectBest

Parameters

Returns Chord | null

withKey

Parameters

Returns Chord

pitchClasses

Parameters

Returns number[]

Example

contains

Parameters

Returns boolean

Example

roleOf

Parameters

Returns ChordToneRole | null

Example

roman

Parameters

Returns string

Throws

`Static`of

`Static`fromData

`Static`fromJSON

`Static`fromFiguredBass

`Static`parse

`Static`tryParse

`Static`detect

`Static`detectMatches

`Static`detectBest