@libraz/libcantus 0.9.5 → 1.0.1

package/dist/index-alrRninU.d.cts

@@ -1,199 +0,0 @@
-import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.cjs';
-import { a as ChordQuality, C as Chord } from './index-oTQbYYIs.cjs';
-
-/**
- * Recognition: infer a chord name from a set of pitches, or a key from a set of
- * pitch classes. This is the inverse direction of the chord/scale builders,
- * which only go name -> notes.
- */
-
-/**
- * A candidate chord interpretation of a pitch set.
- *
- * @category Recognition
- */
-type ChordMatch = {
-    rootPc: number;
-    quality: ChordQuality;
-    /** Chord tones absent from the input (an incomplete voicing). */
-    missingPcs: number[];
-    /** Input pitch classes not belonging to the chord. */
-    extraPcs: number[];
-    /** True when the input pitch-class set equals the chord exactly. */
-    exact: boolean;
-    /**
-     * Inversion implied by a known bass: 0 for root position, 1..n for an
-     * inversion. Null when no inversion can be named — either the input is an
-     * unordered pitch-class set with no bass, or the bass is not a chord tone (a
-     * pedal or passing bass), in which case `bassPc` still reports it.
-     */
-    inversion: number | null;
-    /** Bass pitch class when the lowest note is not the root. */
-    bassPc?: number;
-};
-/**
- * Input interpretation for {@link detectChord} and {@link detectChordBest}.
- *
- * @category Recognition
- */
-type DetectChordOptions = {
-    /**
-     * `midi` uses the numerically lowest pitch as bass; `pitchClass` treats the
-     * input as unordered. `auto` (default) selects pitch-class mode only when all
-     * values lie in 0..11.
-     */
-    input?: 'auto' | 'midi' | 'pitchClass';
-    /** Explicit bass pitch class, including for an unordered pitch-class set. */
-    bassPc?: number;
-};
-/**
- * A candidate key interpretation of a pitch-class set.
- *
- * @category Recognition
- */
-type KeyMatch = {
-    /** The scale that scored best for this tonic and mode, `variant` included. */
-    key: KeyScale;
-    mode: 'major' | 'minor';
-    /** Which scale form `key` uses; minor keys pick the best-scoring of the three. */
-    variant: KeyVariant;
-    /**
-     * Fraction of the distinct input pitch classes that belong to `key`, in
-     * [0, 1]. Measured against the returned scale, so it always agrees with
-     * `isScaleTone(pc, match.key)`. This is a coverage figure, not the ranking:
-     * see `score`.
-     */
-    fit: number;
-    /**
-     * The value the results are ranked by, in [0, 1.5]. Unlike `fit` it counts
-     * every occurrence rather than every distinct pitch class, so a repeated tone
-     * weighs more, and it adds half a count per sounding of the tonic itself to
-     * break ties between keys that contain the same notes.
-     */
-    score: number;
-};
-/**
- * Which form of a scale a {@link KeyMatch} settled on.
- *
- * @category Recognition
- */
-type KeyVariant = 'major' | 'natural' | 'harmonic' | 'melodic';
-/**
- * Input weighting for {@link detectKey}.
- *
- * @category Recognition
- */
-type DetectKeyOptions = {
-    /**
-     * How much each pitch counts toward the histogram, one entry per pitch.
-     * Defaults to one per pitch, which weighs a thirty-second-note ornament as
-     * heavily as the whole note under it. {@link detectKeyFromNotes} supplies
-     * duration times velocity, matching how chord inference weighs its own
-     * histogram.
-     */
-    weights?: readonly number[];
-    /**
-     * Upper bound on the input pitches processed by this detection call.
-     *
-     * @defaultValue {@link DEFAULT_GENERATION_BUDGET}
-     */
-    budget?: number;
-};
-/**
- * Identify chords matching a set of pitches.
- *
- * Every input pitch class is tried as a root against every known chord quality.
- * A match is reported when all of the chord's tones are present in the input, or
- * when the only absent tone is the perfect fifth (a common omission in shell
- * voicings); matches are ranked best-first by fewest extra notes, then fewest
- * missing notes, then most specific (largest) chord. An exact match (no extras,
- * no missing) is flagged and ranked first.
- *
- * @param pitches MIDI pitches or bare pitch classes (octave-agnostic).
- * @returns Ranked chord interpretations (may be empty).
- * @example
- * ```ts
- * import { detectChord } from '@libraz/libcantus';
- * const matches = detectChord([60, 64, 67]); // C E G
- * matches[0]; // { rootPc: 0, quality: 'maj', exact: true, ... }
- * ```
- * @category Recognition
- */
-declare function detectChord(pitches: readonly number[], opts?: DetectChordOptions): ChordMatch[];
-/**
- * The single best chord interpretation of a pitch set, or null if none.
- *
- * @param pitches MIDI pitches or bare pitch classes.
- * @returns The top-ranked chord, or null when nothing matches.
- * @example
- * ```ts
- * import { detectChordBest } from '@libraz/libcantus';
- * detectChordBest([60, 64, 67]); // C major triad: { rootPc: 0, quality: 'maj', ... }
- * ```
- * @category Recognition
- */
-declare function detectChordBest(pitches: readonly number[], opts?: DetectChordOptions): Chord | null;
-/**
- * Rank major and minor keys by how well they contain a set of pitch classes.
- *
- * Ranking is by `score`, which counts repetitions and adds a tonic weight so
- * that, among equally-fitting keys, the one whose root is actually sounded is
- * preferred. Minor candidates are scored against the natural, harmonic, and
- * melodic minor variants and keep the best of the three, so a minor cadence
- * containing the leading tone still resolves to its own tonic; the winning
- * variant is what `key` and `variant` report, so `fit` describes the scale the
- * caller receives. Returns all 24 keys ranked best-first, or an empty array for
- * an empty input (mirroring {@link detectChord}).
- *
- * @param pitches MIDI pitches or bare pitch classes.
- * @returns Ranked key interpretations (empty for an empty input).
- * @example
- * ```ts
- * import { detectKey } from '@libraz/libcantus';
- * const keys = detectKey([60, 62, 64, 65, 67, 69, 71]); // C major scale
- * keys[0].mode; // 'major', with keys[0].key.rootPc === 0
- * ```
- * @category Recognition
- */
-declare function detectKey(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch[];
-/**
- * Rank keys by how well they contain a set of note events, weighting each note
- * by how much of the music it actually occupies.
- *
- * {@link detectKey} counts every pitch once, which lets a run of fast ornamental
- * notes outvote the sustained harmony that establishes the key. This weighs
- * each note by duration times velocity, the same measure chord inference uses,
- * so the two agree on what the music emphasises. Notes that never sound (zero
- * or negative duration) are ignored.
- *
- * @param notes The note events to weigh.
- * @param opts Budget for processing imported note events.
- * @returns Ranked key interpretations (empty when nothing sounds).
- * @example
- * ```ts
- * import { detectKeyFromNotes } from '@libraz/libcantus';
- * detectKeyFromNotes([{ pitch: 60, startBeat: 0, durationBeat: 4 }])[0]?.key.rootPc; // 0
- * ```
- * @category Recognition
- */
-declare function detectKeyFromNotes(notes: readonly NoteEvent[], opts?: Omit<DetectKeyOptions, 'weights'>): KeyMatch[];
-/**
- * The single best key interpretation of a pitch set.
- *
- * The counterpart of {@link detectChordBest}: the ranked list is the general
- * answer, but a caller that just wants "what key is this" should not have to
- * index into it and assert the result is there.
- *
- * @param pitches MIDI pitches or bare pitch classes.
- * @param opts How to weigh the input; see {@link DetectKeyOptions}.
- * @returns The top-ranked key, or null when nothing sounds.
- * @example
- * ```ts
- * import { detectKeyBest } from '@libraz/libcantus';
- * detectKeyBest([0, 2, 4, 5, 7, 9, 11])?.mode; // 'major'
- * ```
- * @category Recognition
- */
-declare function detectKeyBest(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch | null;
-
-export { type ChordMatch as C, type DetectChordOptions as D, type KeyMatch as K, type DetectKeyOptions as a, type KeyVariant as b, detectChordBest as c, detectChord as d, detectKey as e, detectKeyBest as f, detectKeyFromNotes as g };

package/dist/index-oTQbYYIs.d.cts

@@ -1,242 +0,0 @@
-import { K as KeyScale } from './types-BN6_Q9Kl.cjs';
-
-/**
- * Chord quality identifiers understood by the chord builder.
- *
- * @category Chords
- */
-type ChordQuality = 'maj' | 'min' | 'dim' | 'aug' | 'maj7' | 'min7' | 'dom7' | 'dim7' | 'm7b5' | 'minMaj7' | 'minMaj9' | 'minMaj11' | 'minMaj13' | 'aug7' | 'augMaj7' | 'majb5' | '6' | 'min6' | '6/9' | 'sus2' | 'sus4' | 'add9' | 'add11' | 'maj9' | 'min9' | 'dom9' | '7b9' | '7#9' | '7#11' | '7b13' | '11' | '13' | '5' | '7sus4' | '7b5' | '7alt' | '13b9' | 'maj13' | 'maj7#11' | 'min11' | 'min13' | 'minAdd9' | 'min6/9';
-/**
- * The basic role a chord tone plays: the degrees a chord's own template names.
- *
- * The shared vocabulary behind {@link chordToneRole}, the harmony layer's
- * `HarmonyRole`, and the voice analyser's labels, so the three cannot drift.
- *
- * @category Chords
- */
-type ChordToneRole = 'root' | 'third' | 'fifth' | 'sixth' | 'seventh';
-/**
- * A bare spelled pitch used as an enharmonic hint: a diatonic letter
- * (0..6 = C..B) plus a chromatic alteration (-2 double-flat .. +2 double-sharp).
- * Mirrors the letter/alter half of the pitch module's `Note` without an octave.
- *
- * @category Chords
- */
-type PitchSpelling = {
-    letter: number;
-    alter: number;
-};
-/**
- * A chord expressed as a root pitch class plus semitone offsets.
- *
- * `rootSpelling`/`bassSpelling` are optional enharmonic hints recorded by
- * parsers (e.g. `parseChordSymbol('Bb7')`) so formatters can reproduce the
- * original spelling instead of defaulting to sharps. Consumers may ignore
- * them; a hint is only trusted when its pitch class still matches the
- * corresponding `rootPc`/`bassPc`.
- *
- * @category Chords
- */
-type Chord = {
-    rootPc: number;
-    quality: ChordQuality;
-    intervals: number[];
-    bassPc?: number;
-    rootSpelling?: PitchSpelling;
-    bassSpelling?: PitchSpelling;
-};
-/**
- * A chord positioned in time: a root pitch class and quality placed at a beat,
- * with optional harmonic-analysis hints. Serves as the neutral exchange record
- * between progression generators and timeline analysers.
- *
- * @category Composition
- */
-type ChordSpan = {
-    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;
-};
-/**
- * A chord occupying a half-open beat span `[startBeat, endBeat)`.
- *
- * The exchange record between anything that lays chords out in time — a
- * timeline analysis, a bass-line plan, an accompaniment generator — so those
- * surfaces share one definition instead of agreeing by coincidence.
- *
- * @category Composition
- */
-type ChordSegment = {
-    startBeat: number;
-    endBeat: number;
-    chord: Chord;
-};
-/**
- * All chord qualities the builder understands, in declaration order.
- *
- * The order is stable but carries no meaning: it is neither alphabetical nor
- * sorted by template size. {@link detectChord} uses it as its final tie-break,
- * so it is part of the observable behaviour and does not get reshuffled
- * casually — but do not read it as a ranking.
- *
- * @category Chords
- */
-declare function chordQualities(): ChordQuality[];
-/**
- * Build a chord rooted on a diatonic scale degree.
- *
- * The root pitch class is the degree's diatonic pitch class in `key`; the
- * quality's interval template is attached unchanged. Degrees beyond the scale
- * length wrap around.
- *
- * @param degree 0-based scale degree of the chord root.
- * @param ext Chord quality to apply.
- * @param key Key context supplying the diatonic root.
- * @returns The constructed chord.
- *
- * @category Chords
- */
-declare function chordFromDegree(degree: number, ext: ChordQuality, key: KeyScale): Chord;
-/**
- * Build a chord from an explicit root pitch class and quality.
- *
- * @param rootPc Root pitch class (0..11).
- * @param quality Chord quality supplying the interval template.
- * @param bassPc Optional slash-chord bass pitch class.
- * @returns The constructed chord.
- *
- * @example
- * ```ts
- * import { makeChord } from '@libraz/libcantus';
- * const cmaj7 = makeChord(0, 'maj7');
- * // { rootPc: 0, quality: 'maj7', intervals: [0, 4, 7, 11] }
- * ```
- *
- * @category Chords
- */
-declare function makeChord(rootPc: number, quality: ChordQuality, bassPc?: number): Chord;
-/**
- * Transpose a chord by a number of semitones.
- *
- * The interval template is carried over untouched, so a chord whose intervals
- * were customised keeps them, and a slash bass moves with the root. Enharmonic
- * spelling hints are dropped rather than shifted: the letter a transposed root
- * should take depends on the destination key, which a semitone count does not
- * carry. Pass the result through {@link spellChord} to respell it.
- *
- * @param chord The chord to transpose.
- * @param semitones The signed semitone offset.
- * @returns The transposed chord.
- * @throws If `semitones` is not finite.
- *
- * @example
- * ```ts
- * import { formatChordSymbol, parseChordSymbol, transposeChord } from '@libraz/libcantus';
- * formatChordSymbol(transposeChord(parseChordSymbol('C/G'), 2)); // 'D/A'
- * ```
- *
- * @category Chords
- */
-declare function transposeChord(chord: Chord, semitones: number): Chord;
-/**
- * Get the sorted, deduplicated pitch classes of a chord.
- *
- * A slash bass is one of them: `F/G` sounds a G, the voicers put it in the
- * bass, and a set that omitted it would not re-detect as the chord it came
- * from. Pass `includeBass: false` to enumerate the interval template alone.
- *
- * @param chord The chord to enumerate.
- * @param opts Set `includeBass: false` to omit a slash bass.
- * @returns The chord's pitch classes, sorted ascending in [0, 11].
- *
- * @example
- * ```ts
- * import { makeChord, chordPitchClasses } from '@libraz/libcantus';
- * chordPitchClasses(makeChord(0, 'maj7')); // [0, 4, 7, 11]
- * chordPitchClasses(makeChord(5, 'maj', 7)); // [0, 5, 7, 9] — F/G, G included
- * ```
- *
- * @category Chords
- */
-declare function chordPitchClasses(chord: Chord, opts?: {
-    includeBass?: boolean;
-}): number[];
-/**
- * A pitch's interval class above the chord root, in [0, 11].
- *
- * The shared reading of "where does this pitch sit in the chord", used by the
- * safety evaluator and the voice analyser alike so they cannot disagree.
- *
- * @param pitch MIDI pitch or bare pitch class.
- * @param chord The chord providing the root reference.
- * @returns The interval class above the root.
- * @category Chords
- */
-declare function intervalAboveRoot(pitch: number, chord: Chord): number;
-/**
- * Whether a pitch is one of a chord's tones, ignoring octave.
- *
- * @param pitch MIDI pitch or bare pitch class.
- * @param chord The chord, or null for no sounding harmony.
- * @returns True when the pitch class belongs to the chord.
- * @category Chords
- */
-declare function isChordMember(pitch: number, chord: Chord | null): boolean;
-/**
- * Determine a pitch's harmonic role within a chord.
- *
- * The role is derived from the pitch's interval above the chord root, reduced
- * modulo 12. A major sixth (9) reads as a `sixth` for sixth chords but as a
- * `seventh` for a diminished-seventh chord; ninths and other tensions have no
- * basic role and return null.
- *
- * @param pitch MIDI pitch or bare pitch class.
- * @param chord The chord providing the root reference.
- * @returns The chord-tone role, or null if the pitch has no basic role.
- *
- * @category Chords
- */
-declare function chordToneRole(pitch: number, chord: Chord): ChordToneRole | null;
-/**
- * Build the diatonic triad rooted on a scale degree by stacking scale thirds.
- *
- * Unlike {@link chordFromDegree}, the chord quality is derived from the scale
- * rather than supplied, so degrees yield their scale-correct triads (e.g. a
- * diminished triad on the leading tone of a major key).
- *
- * @param degree 0-based scale degree of the chord root.
- * @param key Key/scale context.
- * @returns The diatonic triad.
- * @throws If the scale is not heptatonic. Stacking thirds means skipping every
- *   other degree, which only lands on a triad when there are seven of them, so
- *   the pentatonic, blues, whole-tone, octatonic and chromatic scales have no
- *   diatonic triad; use {@link chordFromDegree} with an explicit quality there.
- *
- * @example
- * ```ts
- * import { majorKey, diatonicTriad } from '@libraz/libcantus';
- * const tonic = diatonicTriad(0, majorKey(0)); // C major triad (degree 0 of C major)
- * ```
- *
- * @category Chords
- */
-declare function diatonicTriad(degree: number, key: KeyScale): Chord;
-/**
- * Build the diatonic seventh chord rooted on a scale degree.
- *
- * @param degree 0-based scale degree of the chord root.
- * @param key Key/scale context.
- * @returns The diatonic seventh chord.
- * @throws If the scale is not heptatonic, for the reason given on
- *   {@link diatonicTriad}.
- *
- * @category Chords
- */
-declare function diatonicSeventh(degree: number, key: KeyScale): Chord;
-
-export { type Chord as C, type PitchSpelling as P, type ChordQuality as a, type ChordSegment as b, type ChordSpan as c, type ChordToneRole as d, chordFromDegree as e, chordPitchClasses as f, chordQualities as g, chordToneRole as h, diatonicSeventh as i, diatonicTriad as j, intervalAboveRoot as k, isChordMember as l, makeChord as m, transposeChord as t };