chordsheetjs 14.6.1 → 15.0.0

package/lib/pdf/chord.d.ts

@@ -0,0 +1,219 @@
+import Key from './key';
+import { Accidental, ChordType } from './constants';
+interface ChordProperties {
+    root?: Key | null;
+    suffix?: string | null;
+    quality?: string | null;
+    extensions?: string | null;
+    bass?: Key | null;
+    optional?: boolean;
+}
+export interface ChordConstructorOptions {
+    base?: string | number | null;
+    accidental?: Accidental | null;
+    suffix?: string | null;
+    quality?: string | null;
+    extensions?: string | null;
+    bassBase?: string | number | null;
+    bassAccidental?: Accidental | null;
+    root?: Key | null;
+    bass?: Key | null;
+    chordType?: ChordType | null;
+    optional?: boolean;
+}
+/**
+ * Represents a Chord, consisting of a root, suffix (quality) and bass
+ */
+declare class Chord implements ChordProperties {
+    bass: Key | null;
+    root: Key | null;
+    private _suffix;
+    private _quality;
+    private _extensions;
+    get suffix(): string | null;
+    get quality(): string | null;
+    get extensions(): string | null;
+    optional: boolean;
+    /**
+     * Tries to parse a chord string into a chord
+     * Any leading or trailing whitespace is removed first, so a chord like `  \n  E/G# \r ` is valid.
+     * @param chordString the chord string, eg `Esus4/G#` or `1sus4/#3`.
+     * @returns {Chord|null}
+     */
+    static parse(chordString: string): Chord | null;
+    static parseOrFail(chordString: string): Chord;
+    /**
+     * Returns a deep copy of the chord
+     * @returns {Chord}
+     */
+    clone(): Chord;
+    /**
+     * Converts the chord to a chord symbol, using the supplied key as a reference.
+     * For example, a numeric chord `#4` with reference key `E` will return the chord symbol `A#`.
+     * When the chord is already a chord symbol, it will return a clone of the object.
+     * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a
+     * numeric or numeral.
+     * @returns {Chord} the chord symbol
+     */
+    toChordSymbol(referenceKey?: Key | string | null): Chord;
+    /**
+     * Converts the chord to a chord symbol string, using the supplied key as a reference.
+     * For example, a numeric chord `#4` with reference key `E` will return the chord symbol `A#`.
+     * When the chord is already a chord symbol, it will return a string version of the chord.
+     * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a
+     * numeric or numeral.
+     * @returns {string} the chord symbol string
+     * @see {toChordSymbol}
+     */
+    toChordSymbolString(referenceKey?: Key | string | null): string;
+    /**
+     * Determines whether the chord is a chord symbol
+     * @returns {boolean}
+     */
+    isChordSymbol(): boolean;
+    /**
+     * Converts the chord to a chord solfege, using the supplied key as a reference.
+     * For example, a numeric chord `#4` with reference key `Mi` will return the chord symbol `La#`.
+     * When the chord is already a chord solfege, it will return a clone of the object.
+     * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a
+     * numeric or numeral.
+     * @returns {Chord} the chord solfege
+     */
+    toChordSolfege(referenceKey?: Key | string | null): Chord;
+    /**
+     * Converts the chord to a chord solfege string, using the supplied key as a reference.
+     * For example, a numeric chord `#4` with reference key `E` will return the chord solfege `A#`.
+     * When the chord is already a chord solfege, it will return a string version of the chord.
+     * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a
+     * numeric or numeral.
+     * @returns {string} the chord solfege string
+     * @see {toChordSolfege}
+     */
+    toChordSolfegeString(referenceKey?: Key | string | null): string;
+    /**
+     * Determines whether the chord is a chord solfege
+     * @returns {boolean}
+     */
+    isChordSolfege(): boolean;
+    /**
+     * Converts the chord to a numeric chord, using the supplied key as a reference.
+     * For example, a chord symbol A# with reference key E will return the numeric chord #4.
+     * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a chord symbol
+     * @returns {Chord} the numeric chord
+     */
+    toNumeric(referenceKey?: Key | string | null): Chord;
+    /**
+     * Converts the chord to a numeral chord, using the supplied key as a reference.
+     * For example, a chord symbol A# with reference key E will return the numeral chord #IV.
+     * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a chord symbol
+     * @returns {Chord} the numeral chord
+     */
+    toNumeral(referenceKey?: Key | string | null): Chord;
+    /**
+     * Converts the chord to a numeral chord string, using the supplied kye as a reference.
+     * For example, a chord symbol A# with reference key E will return the numeral chord #4.
+     * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a chord symbol
+     * @returns {string} the numeral chord string
+     * @see {toNumeral}
+     */
+    toNumeralString(referenceKey?: Key | string | null): string;
+    /**
+     * Determines whether the chord is numeric
+     * @returns {boolean}
+     */
+    isNumeric(): boolean;
+    /**
+     * Converts the chord to a numeric chord string, using the supplied kye as a reference.
+     * For example, a chord symbol A# with reference key E will return the numeric chord #4.
+     * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a chord symbol
+     * @returns {string} the numeric chord string
+     * @see {toNumeric}
+     */
+    toNumericString(referenceKey?: Key | string | null): string;
+    /**
+     * Determines whether the chord is a numeral
+     * @returns {boolean}
+     */
+    isNumeral(): boolean;
+    /**
+     * Converts the chord to a string, eg `Esus4/G#` or `1sus4/#3`
+     * @param {Object} [configuration={}] options
+     * @param {boolean} [configuration.useUnicodeModifier=false] Whether or not to use unicode modifiers.
+     * This will make `#` (sharp) look like `♯` and `b` (flat) look like `♭`
+     * @returns {string} the chord string
+     */
+    toString({ useUnicodeModifier }?: {
+        useUnicodeModifier?: boolean | undefined;
+    }): string;
+    /**
+     * Normalizes the chord root and bass notes:
+     * - Fab becomes Mi
+     * - Dob becomes Si
+     * - Si# becomes Do
+     * - Mi# becomes Fa
+     * - Fb becomes E
+     * - Cb becomes B
+     * - B# becomes C
+     * - E# becomes F
+     * - 4b becomes 3
+     * - 1b becomes 7
+     * - 7# becomes 1
+     * - 3# becomes 4
+     *
+     * Besides that it normalizes the suffix if `normalizeSuffix` is `true`.
+     * For example, `sus2` becomes `2`, `sus4` becomes `sus`.
+     * All suffix normalizations can be found in `src/normalize_mappings/suffix-mapping.txt`.
+     *
+     * When the chord is minor, bass notes are normalized off of the relative major
+     * of the root note. For example, `Em/A#` becomes `Em/Bb`.
+     * @param {Key|string} [key=null] the key to normalize to
+     * @param {Object} [options={}] options
+     * @param {boolean} [options.normalizeSuffix=true] whether to normalize the chord suffix after transposing
+     * @returns {Chord} the normalized chord
+     */
+    normalize(key?: Key | string | null, { normalizeSuffix }?: {
+        normalizeSuffix?: boolean;
+    }): Chord;
+    /**
+     * Switches to the specified accidental
+     * @param newAccidental the accidental to use: `'#'` or `'b'`
+     * @returns {Chord} the new, changed chord
+     */
+    useAccidental(newAccidental: Accidental): Chord;
+    /**
+     * @deprecated Use useAccidental instead
+     */
+    useModifier(newAccidental: Accidental): Chord;
+    /**
+     * Transposes the chord up by 1 semitone. Eg. A becomes A#, Eb becomes E
+     * @returns {Chord} the new, transposed chord
+     */
+    transposeUp(): Chord;
+    /**
+     * Transposes the chord down by 1 semitone. Eg. A# becomes A, E becomes Eb
+     * @returns {Chord} the new, transposed chord
+     */
+    transposeDown(): Chord;
+    /**
+     * Transposes the chord by the specified number of semitones
+     * @param delta de number of semitones
+     * @returns {Chord} the new, transposed chord
+     */
+    transpose(delta: number): Chord;
+    constructor(options: ChordConstructorOptions);
+    equals(otherChord: Chord): boolean;
+    static determineRoot(options: ChordConstructorOptions & {
+        suffix?: string | null;
+    }): Key | null;
+    static determineBass(options: ChordConstructorOptions): Key | null;
+    isMinor(): boolean;
+    makeMinor(): Chord;
+    set(properties: ChordProperties): Chord;
+    private determineSuffixProps;
+    private is;
+    private transform;
+    private get normalizedSuffix();
+    private prepareKeyForConversion;
+    private finalizeConvertedChord;
+}
+export default Chord;

package/lib/pdf/chord_definition/chord_definition.d.ts

@@ -0,0 +1,66 @@
+import { Fret, NonSoundingString, OpenFret } from '../constants';
+/**
+ * Checks whether the given fret is an open fret (unfingered, open string).
+ * @param fret - The fret to check.
+ * @returns `true` if the fret is an open fret, `false` otherwise.
+ */
+export declare function isOpenFret(fret: Fret): fret is OpenFret;
+/**
+ * Checks whether the given fret represents a non-sounding (muted/damped) string.
+ * @param fret - The fret to check.
+ * @returns `true` if the fret represents a non-sounding string, `false` otherwise.
+ */
+export declare function isNonSoundingString(fret: Fret): fret is NonSoundingString;
+/**
+ * Represents a chord definition.
+ *
+ * Definitions are made using the `{chord}` or `{define}` directive.
+ * A chord definitions overrides a previous chord definition for the exact same chord.
+ *
+ * @see https://chordpro.org/chordpro/directives-define/
+ * @see https://chordpro.org/chordpro/directives-chord/
+ */
+declare class ChordDefinition {
+    /**
+     * The chord name, e.g. `C`, `Dm`, `G7`.
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Defines the offset for the chord, which is the position of the topmost finger.
+     * The offset must be 1 or higher.
+     * @type {number}
+     */
+    baseFret: number;
+    /**
+     * Defines the string positions.
+     * Strings are enumerated from left (lowest) to right (highest), as they appear in the chord diagrams.
+     * Fret positions are relative to the offset minus one, so with base-fret 1 (the default),
+     * the topmost fret position is 1. With base-fret 3, fret position 1 indicates the 3rd position.
+     * `0` (zero) denotes an open string. Use `-1`, `N` or `x` to denote a non-sounding string.
+     * @type {Fret[]}
+     */
+    frets: Fret[];
+    /**
+     * defines finger settings. This part may be omitted.
+     *
+     * For the frets and the fingers positions, there must be exactly as many positions as there are strings,
+     * which is 6 by default. For the fingers positions, values corresponding to open or damped strings are ignored.
+     * Finger settings may be numeric (0 .. 9) or uppercase letters (A .. Z).
+     * Note that the values -, x, X, and N are used to designate a string without finger setting.
+     * @type {number[]}
+     */
+    fingers: number[];
+    constructor(name: string, baseFret: number, frets: Fret[], fingers?: number[]);
+    /**
+     * Parses a chord definition in the form of:
+     * - <name> base-fret <offset> frets <pos> <pos> … <pos>
+     * - <name> base-fret <offset> frets <pos> <pos> … <pos> fingers <pos> <pos> … <pos>
+     * @param chordDefinition
+     * @returns {ChordDefinition}
+     * @see https://chordpro.org/chordpro/directives-define/#common-usage
+     */
+    static parse(chordDefinition: string): ChordDefinition;
+    clone(): ChordDefinition;
+}
+export default ChordDefinition;

package/lib/pdf/chord_definition/chord_definition_set.d.ts

@@ -0,0 +1,12 @@
+import ChordDefinition from './chord_definition';
+export type DefinitionSet = Record<string, ChordDefinition>;
+declare class ChordDefinitionSet {
+    definitions: DefinitionSet;
+    constructor(definitions?: DefinitionSet);
+    get(chord: string): ChordDefinition | null;
+    withDefaults(): ChordDefinitionSet;
+    add(chord: string, definition: ChordDefinition): void;
+    has(chord: string): boolean;
+    clone(): ChordDefinitionSet;
+}
+export default ChordDefinitionSet;

package/lib/pdf/chord_diagram/chord_diagram.d.ts

@@ -0,0 +1,131 @@
+import { Renderer } from './renderer';
+import { FingerNumber, FretNumber, StringNumber } from '../constants';
+/**
+ * Represents a barre (bar) in a chord diagram, where one finger presses multiple strings at the same fret.
+ */
+export interface Barre {
+    /** The starting string number (lowest). */
+    from: StringNumber;
+    /** The ending string number (highest). */
+    to: StringNumber;
+    /** The fret position of the barre. */
+    fret: FretNumber;
+}
+type StringList = StringNumber[];
+/**
+ * Represents a finger position marker on a specific string and fret in a chord diagram.
+ */
+export interface StringMarker {
+    /** The string number where the finger is placed. */
+    string: StringNumber;
+    /** The fret number where the finger is placed. */
+    fret: FretNumber;
+    /** Optional finger number (1-4) used to press this position. */
+    finger?: FingerNumber;
+}
+/**
+ * Defines the structure of a chord diagram, including finger positions, barres, and string states.
+ */
+export interface ChordDiagramDefinition {
+    /** Array of barres in the chord. */
+    barres: Barre[];
+    /** The chord name displayed as the diagram title. */
+    chord: string;
+    /** Number of frets to display in the diagram. */
+    fretCount: number;
+    /** Array of finger position markers. */
+    markers: StringMarker[];
+    /** String numbers that are played open (unfingered). */
+    openStrings: StringList;
+    /** Total number of strings on the instrument. */
+    stringCount: number;
+    /** String numbers that are muted/not played. */
+    unusedStrings: StringList;
+    /** The starting fret position (1 for standard position, higher for transposed chords). */
+    baseFret: number;
+}
+/**
+ * Configuration options for rendering a chord diagram, controlling dimensions, colors, and visual styling.
+ */
+export interface ChordDiagramRenderingConfig {
+    /** Vertical position of the chord title. */
+    titleY: number;
+    /** Width of the guitar neck area. */
+    neckWidth: number;
+    /** Height of the guitar neck area. */
+    neckHeight: number;
+    /** Thickness of the nut (top bar) at the first fret. */
+    nutThickness: number;
+    /** Color of the nut. */
+    nutColor: number | string;
+    /** Thickness of regular fret bars. */
+    fretThickness: number;
+    /** Color of the fret lines. */
+    fretColor: number | string;
+    /** Color of the strings. */
+    stringColor: number | string;
+    /** Size of open/muted string indicators above the nut. */
+    stringIndicatorSize: number;
+    /** Size of finger position markers on the fretboard. */
+    fingerIndicatorSize: number;
+    /** Vertical offset adjustment for finger indicators. */
+    fingerIndicatorOffset: number;
+    /** Thickness of the string lines. */
+    stringThickness: number;
+    /** Thickness of the fret lines. */
+    fretLineThickness: number;
+    /** Line thickness for open string (circle) indicators. */
+    openStringIndicatorThickness: number;
+    /** Line thickness for muted string (X) indicators. */
+    unusedStringIndicatorThickness: number;
+    /** Line thickness for finger position markers. */
+    markerThickness: number;
+    /** Line thickness for barre indicators. */
+    barreThickness: number;
+    /** Font size for the chord title. */
+    titleFontSize: number;
+    /** Font size for the base fret number (when transposed). */
+    baseFretFontSize: number;
+    /** Font size for finger numbers below the diagram. */
+    fingerNumberFontSize: number;
+    /** Whether to display finger numbers below the diagram. */
+    showFingerNumbers: boolean;
+    /** Horizontal spacing between multiple diagrams. */
+    diagramSpacing: number;
+    /** Maximum number of diagrams per row (optional). */
+    maxDiagramsPerRow?: number | null;
+}
+/**
+ * Default configuration values for rendering chord diagrams.
+ */
+export declare const DefaultChordDiagramRenderingConfig: ChordDiagramRenderingConfig;
+/**
+ * Renders a visual chord diagram for guitar or similar stringed instruments.
+ *
+ * A chord diagram displays finger positions, barres, open strings, and muted strings
+ * on a graphical representation of the instrument's fretboard.
+ */
+declare class ChordDiagram {
+    chordDiagramDefinition: ChordDiagramDefinition;
+    renderer?: Renderer;
+    config: ChordDiagramRenderingConfig;
+    constructor(chordDiagramDefinition: Partial<ChordDiagramDefinition>, config?: Partial<ChordDiagramRenderingConfig>);
+    get neckX(): number;
+    get neckY(): number;
+    get stringIndicatorY(): number;
+    get fingerNumberIndicatorsY(): number;
+    get nutThicknessCorrection(): number;
+    render(renderer: Renderer): void;
+    renderTitle(renderer: Renderer): void;
+    renderStrings(renderer: Renderer): void;
+    renderNut(renderer: Renderer): void;
+    private renderTransposedNut;
+    private renderStandardNut;
+    renderFrets(renderer: Renderer): void;
+    renderOpenStringIndicators(renderer: Renderer): void;
+    renderUnusedStringIndicators(renderer: Renderer): void;
+    renderStringMarkers(renderer: Renderer): void;
+    renderBarres(renderer: Renderer): void;
+    renderFingerNumberIndicators(renderer: Renderer): void;
+}
+export default ChordDiagram;

package/lib/pdf/chord_diagram/js_pdf_renderer.d.ts

@@ -0,0 +1,40 @@
+import { DimensionOpts, FillColorOpts, FillOpts, PositionOpts, RadiusOpts, Renderer, SizeOpts, ThicknessOpts } from './renderer';
+import DocWrapper from '../formatter/pdf_formatter/doc_wrapper';
+import { ChordDiagramFontConfigurations } from '../formatter/configuration';
+/**
+ * Renderer implementation for drawing chord diagrams to a jsPDF document.
+ */
+declare class JsPDFRenderer implements Renderer {
+    #private;
+    doc: DocWrapper;
+    height: number;
+    width: number;
+    fonts: ChordDiagramFontConfigurations;
+    constructor(doc: DocWrapper, { x, y, width, fonts, }: {
+        x: number;
+        y: number;
+        width: number;
+        fonts: ChordDiagramFontConfigurations;
+    });
+    static calculateHeight(width: number): number;
+    circle({ x, y, size, fill, thickness, }: FillOpts & PositionOpts & SizeOpts & ThicknessOpts): void;
+    line({ x1, y1, x2, y2, thickness, color, }: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    } & ThicknessOpts & FillColorOpts): void;
+    rect({ x, y, width, height, fill, thickness, radius, color, }: DimensionOpts & FillOpts & PositionOpts & RadiusOpts & ThicknessOpts & FillColorOpts): void;
+    text(text: string, { fontStyle, x, y }: {
+        fontSize: number;
+        fontStyle?: string;
+        x: number;
+        y: number;
+    }): void;
+    private scale;
+    private tx;
+    private ty;
+    private withFontConfiguration;
+    private withLineWidth;
+}
+export default JsPDFRenderer;

package/lib/pdf/chord_diagram/renderer.d.ts

@@ -0,0 +1,43 @@
+export interface RadiusOpts {
+    radius: number;
+}
+export interface FillOpts {
+    fill?: boolean;
+}
+interface HeightOpts {
+    height: number;
+}
+export interface PositionOpts {
+    x: number;
+    y: number;
+}
+export interface SizeOpts {
+    size: number;
+}
+export interface ThicknessOpts {
+    thickness: number;
+}
+export interface FillColorOpts {
+    color?: number | string;
+}
+interface WidthOpts {
+    width: number;
+}
+export type DimensionOpts = WidthOpts & HeightOpts;
+export interface Renderer {
+    circle({ x, y, size, fill, thickness, }: FillOpts & PositionOpts & SizeOpts & ThicknessOpts): void;
+    line({ x1, y1, x2, y2, thickness, }: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    } & ThicknessOpts & FillColorOpts): void;
+    rect({ x, y, width, height, fill, thickness, radius, }: DimensionOpts & FillOpts & PositionOpts & RadiusOpts & ThicknessOpts): void;
+    text(text: string, { fontSize, fontStyle, x, y, }: {
+        fontSize: number;
+        fontStyle?: string;
+        x: number;
+        y: number;
+    }): void;
+}
+export {};

package/lib/pdf/chord_parsing_error.d.ts

@@ -0,0 +1,2 @@
+export default class ChordParsingError extends Error {
+}

package/lib/pdf/chord_sheet/ast_component.d.ts

@@ -0,0 +1,11 @@
+import type Line from './line';
+import TraceInfo from './trace_info';
+declare abstract class AstComponent {
+    parentLine: Line | null;
+    line: number | null;
+    column: number | null;
+    offset: number | null;
+    protected constructor(traceInfo?: TraceInfo | null);
+    abstract clone(): AstComponent;
+}
+export default AstComponent;

package/lib/pdf/chord_sheet/ast_type.d.ts

@@ -0,0 +1,9 @@
+import ChordLyricsPair from './chord_lyrics_pair';
+import Comment from './comment';
+import Evaluatable from './chord_pro/evaluatable';
+import Literal from './chord_pro/literal';
+import SoftLineBreak from './soft_line_break';
+import Tag from './tag';
+import Ternary from './chord_pro/ternary';
+type AstType = ChordLyricsPair | Comment | Tag | Ternary | Evaluatable | Literal | SoftLineBreak;
+export default AstType;

package/lib/pdf/chord_sheet/chord_lyrics_pair.d.ts

@@ -0,0 +1,60 @@
+import Chord from '../chord';
+import Key from '../key';
+import type Line from './line';
+import { Accidental } from '../constants';
+/**
+ * Represents a chord with the corresponding (partial) lyrics
+ */
+declare class ChordLyricsPair {
+    chords: string;
+    lyrics: string | null;
+    annotation: string | null;
+    isRhythmSymbol: boolean;
+    parentLine: Line | null;
+    private _chordObj;
+    /**
+     * Initialises a ChordLyricsPair
+     * @param {string} chords The chords
+     * @param {string | null} lyrics The lyrics
+     * @param {string | null} annotation The annotation
+     * @param {Chord | null} chordObj Optional pre-parsed Chord object
+     * @param {boolean} isRhythmSymbol Whether this pair represents a rhythm symbol
+     */
+    constructor(chords?: string, lyrics?: string | null, annotation?: string | null, chordObj?: Chord | null, isRhythmSymbol?: boolean);
+    /** Returns the Chord object if available, otherwise parses from string */
+    get chord(): Chord | null;
+    /**
+     * Indicates whether a ChordLyricsPair should be visible in a formatted chord sheet (except for ChordPro sheets)
+     * @returns {boolean}
+     */
+    isRenderable(): boolean;
+    /**
+     * Indicates whether the ChordLyricsPair has non-empty lyrics.
+     */
+    hasLyrics(): boolean;
+    /**
+     * Returns a deep copy of the ChordLyricsPair, useful when programmatically transforming a song
+     * @returns {ChordLyricsPair}
+     */
+    clone(): ChordLyricsPair;
+    toString(): string;
+    set({ chords, lyrics, annotation, chordObj, isRhythmSymbol, }: {
+        chords?: string;
+        lyrics?: string;
+        annotation?: string;
+        chordObj?: Chord | null;
+        isRhythmSymbol?: boolean;
+    }): ChordLyricsPair;
+    setLyrics(lyrics: string): ChordLyricsPair;
+    setAnnotation(annotation: string): ChordLyricsPair;
+    transpose(delta: number, key?: string | Key | null, { normalizeChordSuffix }?: {
+        normalizeChordSuffix: boolean;
+    }): ChordLyricsPair;
+    useAccidental(accidental: Accidental): ChordLyricsPair;
+    /**
+     * @deprecated Use useAccidental instead
+     */
+    useModifier(accidental: Accidental): ChordLyricsPair;
+    changeChord(func: (chord: Chord) => Chord): ChordLyricsPair;
+}
+export default ChordLyricsPair;

package/lib/pdf/chord_sheet/chord_pro/composite.d.ts

@@ -0,0 +1,11 @@
+import Evaluatable from './evaluatable';
+import Metadata from '../metadata';
+declare class Composite extends Evaluatable {
+    expressions: Evaluatable[];
+    variable: string | null;
+    constructor(expressions: Evaluatable[], variable?: string | null);
+    evaluate(metadata: Metadata, metadataSeparator: string): string;
+    isRenderable(): boolean;
+    clone(): Composite;
+}
+export default Composite;

package/lib/pdf/chord_sheet/chord_pro/evaluatable.d.ts

@@ -0,0 +1,7 @@
+import AstComponent from '../ast_component';
+import Metadata from '../metadata';
+declare abstract class Evaluatable extends AstComponent {
+    abstract evaluate(_metadata: Metadata, _metadataSeparator: string, _variable?: string | null): string;
+    abstract clone(): Evaluatable;
+}
+export default Evaluatable;

package/lib/pdf/chord_sheet/chord_pro/evaluation_error.d.ts

@@ -0,0 +1,7 @@
+declare class EvaluationError extends Error {
+    line: number | null;
+    column: number | null;
+    offset: number | null;
+    constructor(message: string, line?: number | null, column?: number | null, offset?: number | null);
+}
+export default EvaluationError;

package/lib/pdf/chord_sheet/chord_pro/literal.d.ts

@@ -0,0 +1,9 @@
+import Evaluatable from './evaluatable';
+declare class Literal extends Evaluatable {
+    string: string;
+    constructor(string: string);
+    evaluate(): string;
+    isRenderable(): boolean;
+    clone(): Literal;
+}
+export default Literal;

package/lib/pdf/chord_sheet/chord_pro/ternary.d.ts

@@ -0,0 +1,29 @@
+import Evaluatable from './evaluatable';
+import Metadata from '../metadata';
+import TraceInfo from '../trace_info';
+export type TernaryProperties = TraceInfo & {
+    variable?: string | null;
+    valueTest?: string | null;
+    trueExpression?: Evaluatable[];
+    falseExpression?: Evaluatable[];
+};
+declare class Ternary extends Evaluatable {
+    variable: string | null;
+    valueTest: string | null;
+    trueExpression: Evaluatable[];
+    falseExpression: Evaluatable[];
+    constructor({ variable, valueTest, trueExpression, falseExpression, line, column, offset, }: TernaryProperties);
+    /**
+     * Evaluate the meta expression
+     * @param {Metadata} metadata The metadata object to use for evaluating the expression
+     * @param {string} [metadataSeparator=null] The metadata separator to use if necessary
+     * @returns {string} The evaluated expression
+     */
+    evaluate(metadata: Metadata, metadataSeparator: string, upperContext?: string | null): string;
+    evaluateToString(value: string[] | string, metadataSeparator: string): string;
+    evaluateWithVariable(metadata: Metadata, metadataSeparator: string): string;
+    evaluateForTruthyValue(metadata: Metadata, metadataSeparator: string, value: string | string[]): string;
+    isRenderable(): boolean;
+    clone(): Ternary;
+}
+export default Ternary;