chordsheetjs 14.6.1 → 15.0.0

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

@@ -0,0 +1,21 @@
+import type Line from './line';
+/**
+ * Represents a comment. See https://www.chordpro.org/chordpro/chordpro-file-format-specification/#overview
+ */
+declare class Comment {
+    content: string;
+    parentLine: Line | null;
+    constructor(content: string);
+    /**
+     * Indicates whether a Comment should be visible in a formatted chord sheet (except for ChordPro sheets)
+     * @returns {boolean}
+     */
+    isRenderable(): boolean;
+    /**
+     * Returns a deep copy of the Comment, useful when programmatically transforming a song
+     * @returns {Comment}
+     */
+    clone(): Comment;
+    toString(): string;
+}
+export default Comment;

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

@@ -0,0 +1,47 @@
+import FontSize from './font_size';
+interface FontProperties {
+    font?: string | null;
+    size?: FontSize | null;
+    colour?: string | null;
+}
+declare class Font {
+    /**
+     * The font
+     * @member {string | null}
+     */
+    font: string | null;
+    /**
+     * The font size, expressed in either pixels or percentage.
+     * @member {FontSize | null}
+     */
+    size: FontSize | null;
+    /**
+     * The font color
+     * @member {string | null}
+     */
+    colour: string | null;
+    constructor({ font, size, colour }?: FontProperties);
+    clone(): Font;
+    /**
+     * Converts the font, size and color to a CSS string.
+     * If possible, font and size are combined to the `font` shorthand.
+     * If `font` contains double quotes (`"`) those will be converted to single quotes (`'`).
+     *
+     * @example
+     * // Returns "font-family: 'Times New Roman'"
+     * new Font({ font: '"Times New Roman"' }).toCssString()
+     * @example
+     * // Returns "color: red; font-family: Verdana"
+     * new Font({ font: 'Verdana', colour: 'red' }).toCssString()
+     * @example
+     * // Returns "font: 30px Verdana"
+     * new Font({ font: 'Verdana', size: '30' }).toCssString()
+     * @example
+     * // Returns "color: blue; font: 30% Verdana"
+     * new Font({ font: 'Verdana', size: '30%', colour: 'blue' }).toCssString()
+     *
+     * @return {string} The CSS string
+     */
+    toCssString(): string;
+}
+export default Font;

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

@@ -0,0 +1,33 @@
+type Size = 'px' | '%';
+declare class FontSize {
+    /**
+     * The size unit, either `"px"` or `"%"`
+     * @member {string}
+     */
+    unit: Size;
+    /**
+     * The font size
+     * @member {number}
+     */
+    fontSize: number;
+    constructor(fontSize: number, kind: Size);
+    clone(): FontSize;
+    multiply(percentage: any): FontSize;
+    /**
+     * Stringifies the font size by concatenating size and unit
+     *
+     * @example
+     * // Returns "30px"
+     * new FontSize(30, 'px').toString()
+     * @example
+     * // Returns "120%"
+     * new FontSize(120, '%').toString()
+     *
+     * @return {string} The font size
+     */
+    toString(): string;
+    static parse(fontSize: string, parent: FontSize | null): FontSize;
+    static parseNotANumber(parent: FontSize | null): FontSize;
+    static parsePercentage(parsedFontSize: number, parent: FontSize | null): FontSize;
+}
+export default FontSize;

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

@@ -0,0 +1,13 @@
+import Font from './font';
+import FontSize from './font_size';
+import Tag from './tag';
+declare class FontStack {
+    fontAndColourStacks: Record<string, string[]>;
+    sizeStacks: Record<string, FontSize[]>;
+    textFont: Font;
+    chordFont: Font;
+    applyTag(tag: Tag): void;
+    private pushOrPopTag;
+    private pushOrPopSizeTag;
+}
+export default FontStack;

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

@@ -0,0 +1,7 @@
+import ChordLyricsPair from './chord_lyrics_pair';
+import Comment from './comment';
+import Literal from './chord_pro/literal';
+import Tag from './tag';
+import Ternary from './chord_pro/ternary';
+type Item = ChordLyricsPair | Comment | Tag | Ternary | Literal;
+export default Item;

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

@@ -0,0 +1,130 @@
+import ChordLyricsPair from './chord_lyrics_pair';
+import Comment from './comment';
+import Font from './font';
+import Item from './item';
+import Tag from './tag';
+import { ContentType, PartTypes } from '../serialized_types';
+type MapItemFunc = (_item: Item) => Item | null;
+export type LineType = 'bridge' | 'chorus' | 'none' | 'tab' | 'verse' | ContentType | 'indeterminate' | PartTypes;
+/**
+ * Represents a line in a chord sheet, consisting of items of type ChordLyricsPair or Tag
+ */
+declare class Line {
+    /**
+     * The items ({@link ChordLyricsPair} or {@link Tag} or {@link Comment}) of which the line consists
+     * @type {Array.<(ChordLyricsPair|Tag|Comment)>}
+     */
+    items: Item[];
+    /**
+     * The line type, This is set by the ChordProParser when it read tags like {start_of_chorus} or {start_of_verse}
+     * It uses the following mapping to determine the line type from directives:
+     * - `start_of_abc` => {@link ABC}
+     * - `start_of_bridge` => {@link BRIDGE}
+     * - `start_of_chorus` => {@link CHORUS}
+     * - `start_of_grid` => {@link GRID}
+     * - `start_of_ly` => {@link LILYPOND}
+     * - `start_of_tab` => {@link TAB}
+     * - `start_of_verse` => {@link VERSE}
+     *
+     * There are two special cases:
+     * - {@link INDETERMINATE} when the paragraph lines do not have a consistent type
+     * - {@link NONE} when no type is derived
+     * @type {string}
+     */
+    type: string;
+    currentChordLyricsPair: ChordLyricsPair;
+    key: string | null;
+    transposeKey: string | null;
+    lineNumber: number | null;
+    selector: string | null;
+    selectorIsNegated: boolean;
+    /**
+     * The text font that applies to this line. Is derived from the directives:
+     * `textfont`, `textsize` and `textcolour`
+     * See: https://www.chordpro.org/chordpro/directives-props_text_legacy/
+     * @type {Font}
+     */
+    textFont: Font;
+    /**
+     * The chord font that applies to this line. Is derived from the directives:
+     * `chordfont`, `chordsize` and `chordcolour`
+     * See: https://www.chordpro.org/chordpro/directives-props_chord_legacy/
+     * @type {Font}
+     */
+    chordFont: Font;
+    constructor({ type, items }?: {
+        type: string;
+        items: Item[];
+    });
+    /**
+     * Indicates whether the line contains any items
+     * @returns {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     * Adds an item ({@link ChordLyricsPair} or {@link Tag}) to the line
+     * @param {ChordLyricsPair|Tag} item The item to be added
+     */
+    addItem(item: Item): void;
+    /**
+     * Indicates whether the line contains items that are renderable
+     * @returns {boolean}
+     */
+    hasRenderableItems(): boolean;
+    /**
+     * Returns a deep copy of the line and all of its items
+     * @returns {Line}
+     */
+    clone(): Line;
+    mapItems(func: MapItemFunc | null): Line;
+    /**
+     * Indicates whether the line type is {@link BRIDGE}
+     * @returns {boolean}
+     */
+    isBridge(): boolean;
+    /**
+     * Indicates whether the line type is {@link CHORUS}
+     * @returns {boolean}
+     */
+    isChorus(): boolean;
+    /**
+     * Indicates whether the line type is {@link GRID}
+     * @returns {boolean}
+     */
+    isGrid(): boolean;
+    /**
+     * Indicates whether the line type is {@link TAB}
+     * @returns {boolean}
+     */
+    isTab(): boolean;
+    /**
+     * Indicates whether the line type is {@link VERSE}
+     * @returns {boolean}
+     */
+    isVerse(): boolean;
+    /**
+     * Indicates whether the line type is {@link PART}
+     * @returns {boolean}
+     */
+    isPart(): boolean;
+    /**
+     * Indicates whether the line contains items that are renderable. Please use {@link hasRenderableItems}
+     * @deprecated
+     * @returns {boolean}
+     */
+    hasContent(): boolean;
+    addChordLyricsPair(chords?: ChordLyricsPair | string | null, lyrics?: null): ChordLyricsPair;
+    ensureChordLyricsPair(): void;
+    chords(chr: string): void;
+    lyrics(chr: string): void;
+    addTag(nameOrTag: Tag | string, value?: string | null): Tag;
+    addComment(content: Comment | string): Comment;
+    set(properties: {
+        type?: string;
+        items?: Item[];
+    }): Line;
+    get _tag(): Tag | null;
+    isSectionStart(): boolean;
+    isSectionEnd(): boolean;
+}
+export default Line;

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

@@ -0,0 +1,12 @@
+import Line from './line';
+import Song from './song';
+declare class LineExpander {
+    line: Line;
+    song: Song;
+    static expand(line: Line, song: Song): Line[];
+    constructor(line: Line, song: Song);
+    expand(): Line[];
+    private getLastChorusBefore;
+    private lineHasMoreThanChorusDirectives;
+}
+export default LineExpander;

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

@@ -0,0 +1,71 @@
+import MetadataAccessors from './metadata_accessors';
+type MetadataProvider = () => string | null;
+/**
+ * Stores song metadata. Properties can be accessed using the get() method:
+ *
+ * const metadata = new Metadata({ author: 'John' });
+ * metadata.get('author')   // => 'John'
+ *
+ * See {@link Metadata#get}
+ */
+declare class Metadata extends MetadataAccessors implements Iterable<[string, string | string[]]> {
+    metadata: Record<string, string | string[]>;
+    providers: Map<string, MetadataProvider>;
+    constructor(metadata?: Record<string, string | string[]> | Metadata);
+    merge(metadata?: Record<string, string | string[]> | Metadata): Metadata;
+    contains(key: string): boolean;
+    add(key: string, value: string): void;
+    appendValue(key: string, value: string): void;
+    setProvider(key: string, provider: MetadataProvider): void;
+    set(key: string, value: string | null): void;
+    getMetadataValue(name: string): string | string[] | null;
+    getSingleMetadataValue(name: string): string | null;
+    /**
+     * Reads a metadata value by key. This method supports simple value lookup, as well as fetching single array values.
+     *
+     * This method deprecates direct property access, eg: metadata['author']
+     *
+     * @example
+     * const metadata = new Metadata({ lyricist: 'Pete', author: ['John', 'Mary'] });
+     * metadata.get('lyricist') // => 'Pete'
+     * metadata.get('author')   // => ['John', 'Mary']
+     * metadata.get('author.1') // => 'John'
+     * metadata.get('author.2') // => 'Mary'
+     *
+     * Using a negative index will start counting at the end of the list:
+     *
+     * const metadata = new Metadata({ lyricist: 'Pete', author: ['John', 'Mary'] });
+     * metadata.get('author.-1') // => 'Mary'
+     * metadata.get('author.-2') // => 'John'
+     *
+     * @param prop the property name
+     * @returns {Array<String>|String} the metadata value(s). If there is only one value, it will return a String,
+     * else it returns an array of strings.
+     */
+    get(prop: string): string | string[] | null;
+    /**
+     * Returns all metadata values, including provider values and generated values like `_key`.
+     * @returns {Object.<string, string|string[]>} the metadata values
+     */
+    all(): Record<string, string | string[]>;
+    ownMetadata(): Record<string, string | string[]>;
+    [Symbol.iterator](): IterableIterator<[string, string | string[]]>;
+    /**
+     * Returns a single metadata value. If the actual value is an array, it returns the first value. Else, it returns
+     * the value.
+     * @ignore
+     * @param {string} prop the property name
+     * @returns {String} The metadata value
+     */
+    getSingle(prop: string): string | null;
+    parseArrayKey(prop: string): [string, number] | null;
+    getArrayItem(prop: string): string | null;
+    /**
+     * Returns a deep clone of this Metadata object
+     * @returns {Metadata} the cloned Metadata object
+     */
+    clone(): Metadata;
+    calculateKeyFromCapo(): string | null;
+    assign(metadata: Record<string, string | string[] | null>): void;
+}
+export default Metadata;

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

@@ -0,0 +1,18 @@
+declare abstract class MetadataAccessors {
+    abstract getMetadataValue(_name: string): string | string[] | null;
+    abstract getSingleMetadataValue(_name: string): string | null;
+    get key(): string | null;
+    get title(): string | null;
+    get subtitle(): string | null;
+    get capo(): string | string[] | null;
+    get duration(): string | null;
+    get tempo(): string | null;
+    get time(): string | string[] | null;
+    get year(): string | null;
+    get album(): string | string[] | null;
+    get copyright(): string | null;
+    get lyricist(): string | string[] | null;
+    get artist(): string | string[] | null;
+    get composer(): string | string[] | null;
+}
+export default MetadataAccessors;

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

@@ -0,0 +1,48 @@
+import Line from './line';
+/**
+ * Represents a paragraph of lines in a chord sheet
+ */
+declare class Paragraph {
+    /**
+     * The {@link Line} items of which the paragraph consists
+     * @member
+     * @type {Line[]}
+     */
+    lines: Line[];
+    addLine(line: any): void;
+    /**
+     * Indicates whether the paragraph only contains literals. If true, {@link contents} can be used to retrieve
+     * the paragraph contents as one string where lines are separated by newlines.
+     * @see {@link contents}
+     * @returns {boolean}
+     */
+    isLiteral(): boolean;
+    /**
+     * Returns the paragraph contents as one string where lines are separated by newlines
+     * @returns {string}
+     */
+    get contents(): string;
+    /**
+     * Returns the label of the paragraph. The label is the value of the first section delimiter tag
+     * in the first line.
+     * @returns {string|null}
+     */
+    get label(): string | null;
+    /**
+     * Tries to determine the common type for all lines. If the types for all lines are equal, it returns that type.
+     * If not, it returns {@link INDETERMINATE}
+     * For the possible values, see {@link Line.type}
+     * @returns {string}
+     */
+    get type(): string;
+    get selector(): string | null;
+    get selectorIsNegated(): boolean;
+    /**
+     * Indicates whether the paragraph contains lines with renderable items.
+     * @see {@link Line.hasRenderableItems}
+     * @returns {boolean}
+     */
+    hasRenderableItems(): boolean;
+    isEmpty(): boolean;
+}
+export default Paragraph;

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

@@ -0,0 +1,15 @@
+/**
+ * Represents a soft line break in the lyrics, typically rendered as a space or optional break point.
+ */
+declare class SoftLineBreak {
+    /**
+     * The content of the soft line break, defaults to a single space.
+     */
+    content: string;
+    constructor(content?: string);
+    /**
+     * Returns a copy of the SoftLineBreak.
+     */
+    clone(): SoftLineBreak;
+}
+export default SoftLineBreak;

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

@@ -0,0 +1,253 @@
+import Chord from '../chord';
+import ChordDefinition from '../chord_definition/chord_definition';
+import ChordDefinitionSet from '../chord_definition/chord_definition_set';
+import ChordLyricsPair from './chord_lyrics_pair';
+import Configuration from '../formatter/configuration';
+import FormattingContext from '../formatter/formatting_context';
+import Item from './item';
+import Key from '../key';
+import Line from './line';
+import Metadata from './metadata';
+import MetadataAccessors from './metadata_accessors';
+import Paragraph from './paragraph';
+import ParserWarning from '../parser/parser_warning';
+import { Accidental } from '../constants';
+type MapItemsCallback = (_item: Item) => Item | Item[] | null;
+/**
+ * Represents a song in a chord sheet. Currently a chord sheet can only have one song.
+ */
+declare class Song extends MetadataAccessors {
+    /**
+     * The {@link Line} items of which the song consists
+     * @member {Line[]}
+     */
+    lines: Line[];
+    _bodyLines: Line[] | null;
+    _bodyParagraphs: Paragraph[] | null;
+    _renderParagraphs: Paragraph[] | null;
+    warnings: ParserWarning[];
+    _metadata: Metadata | null;
+    /**
+     * Creates a new {Song} instance
+     * @param metadata {Record<string, string | string[]>|Metadata} predefined metadata
+     */
+    constructor(metadata?: Record<string, string | string[]> | Metadata | null);
+    /** Returns song lines, skipping leading empty/meta-only lines. @returns {Line[]} */
+    get bodyLines(): Line[];
+    /** Returns song paragraphs, skipping paragraphs with only empty lines. @returns {Paragraph[]} */
+    get bodyParagraphs(): Paragraph[];
+    get renderParagraphs(): Paragraph[];
+    set renderParagraphs(paragraphs: Paragraph[]);
+    selectRenderableItems(items: (Line | Paragraph)[]): (Line | Paragraph)[];
+    /** The {@link Paragraph} items of which the song consists @member {Paragraph[]} */
+    get paragraphs(): Paragraph[];
+    /** The body paragraphs with any `{chorus}` tag expanded into the targeted chorus */
+    get expandedBodyParagraphs(): Paragraph[];
+    filterParagraphs(paragraphs: Paragraph[], configuration: Configuration): Paragraph[];
+    linesToParagraphs(lines: Line[]): Paragraph[];
+    /** Returns a deep clone of the song @returns {Song} */
+    clone(): Song;
+    getMetadataValue(name: string): string | string[] | null;
+    getSingleMetadataValue(name: string): string | null;
+    /**
+     * Returns a copy of the song with the key value set to the specified key. It changes:
+     * - the value for `key` in the {@link metadata} set
+     * - any existing `key` directive
+     * @param {number|null} key the key. Passing `null` will:
+     * - remove the current key from {@link metadata}
+     * - remove any `key` directive
+     * @returns {Song} The changed song
+     */
+    setKey(key: string | number | null): Song;
+    /**
+     * Returns a copy of the song with the key value set to the specified capo. It changes:
+     * - the value for `capo` in the {@link metadata} set
+     * - any existing `capo` directive
+     * @param {number|null} capo the capo. Passing `null` will:
+     * - remove the current key from {@link metadata}
+     * - remove any `capo` directive
+     * @returns {Song} The changed song
+     */
+    setCapo(capo: number | null): Song;
+    private updateDirectives;
+    private changeOrDeleteDirectives;
+    private insertDirectives;
+    private findInsertIndex;
+    private isInsertionPoint;
+    private adjustInsertIndex;
+    private createMetadataLines;
+    private prepareLinesToInsert;
+    private spliceLines;
+    /**
+     * Transposes the song by the specified delta. It will:
+     * - transpose all chords, see: {@link Chord#transpose}
+     * - transpose the song key in {@link metadata}
+     * - update any existing `key` directive
+     * @param {number} delta The number of semitones (positive or negative) to transpose with
+     * @param {Object} [options={}] options
+     * @param {boolean} [options.normalizeChordSuffix=false] whether to normalize the chord suffixes after transposing
+     * @returns {Song} The transposed song
+     */
+    transpose(delta: number, { accidental, normalizeChordSuffix }?: {
+        accidental?: Accidental | null;
+        normalizeChordSuffix?: boolean;
+    }): Song;
+    private static transposeChordLyricsPair;
+    private static transposeLiteral;
+    /**
+     * Transposes the song up by one semitone. It will:
+     * - transpose all chords, see: {@link Chord#transpose}
+     * - transpose the song key in {@link metadata}
+     * - update any existing `key` directive
+     * @param {Object} [options={}] options
+     * @param {boolean} [options.normalizeChordSuffix=false] whether to normalize the chord suffixes after transposing
+     * @returns {Song} The transposed song
+     */
+    transposeUp({ normalizeChordSuffix }?: {
+        normalizeChordSuffix?: boolean;
+    }): Song;
+    /**
+     * Transposes the song down by one semitone. It will:
+     * - transpose all chords, see: {@link Chord#transpose}
+     * - transpose the song key in {@link metadata}
+     * - update any existing `key` directive
+     * @param {Object} [options={}] options
+     * @param {boolean} [options.normalizeChordSuffix=false] whether to normalize the chord suffixes after transposing
+     * @returns {Song} The transposed song
+     */
+    transposeDown({ normalizeChordSuffix }?: {
+        normalizeChordSuffix?: boolean;
+    }): Song;
+    /**
+     * Returns a copy of the song with the key set to the specified key. It changes:
+     * - the value for `key` in the {@link metadata} set
+     * - any existing `key` directive
+     * - all chords, those are transposed according to the distance between the current and the new key
+     * @param {string} newKey The new key.
+     * @returns {Song} The changed song
+     */
+    changeKey(newKey: string | Key): Song;
+    /**
+     * Returns a copy of the song with all chords changed to the specified accidental.
+     *
+     * Examples:
+     *
+     * ```js
+     * song.useAccidental('#');
+     * song.useAccidental('b');
+     * ```
+     *
+     * @param {Accidental} accidental the new accidental
+     * @returns {Song} the changed song
+     */
+    useAccidental(accidental: Accidental): Song;
+    /**
+     * @deprecated Use useAccidental instead
+     */
+    useModifier(accidental: Accidental): Song;
+    /**
+     * Returns a copy of the song with all chords normalized to the specified key. See {@link Chord#normalize}.
+     * @param key the key to normalize to
+     * @param options options
+     * @param options.normalizeSuffix whether to normalize the chord suffixes
+     */
+    normalizeChords(key?: Key | string | null, { normalizeSuffix }?: {
+        normalizeSuffix?: boolean;
+    }): Song;
+    mapChordLyricsPairs(func: (pair: ChordLyricsPair) => ChordLyricsPair): Song;
+    changeChords(func: (chord: Chord) => Chord): Song;
+    private static isMusicalSection;
+    private static mapChordsInLiteral;
+    get currentKey(): Key | null;
+    requireCurrentKey(): Key;
+    /**
+     * Returns a copy of the song with the directive value(s) set to the specified value(s).
+     * - when there is a matching directive in the song, it will update the directive
+     * - when there is no matching directive, it will be inserted
+     * If `value` is `null` it will act as a delete, any directive matching `name` will be removed.
+     *
+     * @example
+     * ```javascript
+     * song.changeMetadata('author', 'John');
+     * song.changeMetadata('composer', ['Jane', 'John']);
+     * song.changeMetadata('key', null); // Remove key directive
+     * ```
+     * @param name The directive name
+     * @param {string | string[] | null} value The value to set, or `null` to remove the directive
+     * @return {Song} The changed song
+     */
+    changeMetadata(name: string, value: string | string[] | null): Song;
+    /**
+     * Returns a copy of the song with the metadata changed. It will:
+     * - update the metadata
+     * - update any existing directive matching the metadata key
+     * - insert a new directive if it does not exist
+     * @example
+     * ```javascript
+     * song.changeMetadata({
+     *   author: 'John',
+     *   composer: ['Jane', 'John'],
+     *   key: null, // Remove key directive
+     * });
+     * ```
+     * @param {Record<string, string | string[] | null>} metadata The metadata to change
+     */
+    changeMetadata(metadata: Record<string, string | string[] | null>): Song;
+    addLine(line: Line): void;
+    /**
+     * Change the song contents inline. Return a new {@link Item} to replace it. Return `null` to remove it.
+     * @example
+     * // transpose all chords:
+     * song.mapItems((item) => {
+     *   if (item instanceof ChordLyricsPair) {
+     *     return item.transpose(2, 'D');
+     *   }
+     *
+     *   return item;
+     * });
+     * @param {MapItemsCallback} func the callback function
+     * @returns {Song} the changed song
+     */
+    mapItems(func: MapItemsCallback): Song;
+    foreachItem(func: (_item: Item) => void): void;
+    /**
+     * Returns all unique chords used in the song
+     * @returns {string[]} the chords
+     */
+    getChords(): string[];
+    /**
+     * Returns all chord definitions from the song.
+     * Definitions are made using the `{chord}` or `{define}` directive.
+     * A chord definitions overrides a previous chord definition for the exact same chord.
+     * @returns {Record<string, ChordDefinition>} the chord definitions
+     * @see https://chordpro.org/chordpro/directives-define/
+     * @see https://chordpro.org/chordpro/directives-chord/
+     */
+    getChordDefinitions(context?: FormattingContext): Record<string, ChordDefinition>;
+    /**
+     * The song's metadata. When there is only one value for an entry, the value is a string. Else, the value is
+     * an array containing all unique values for the entry.
+     * @type {Metadata}
+     */
+    get metadata(): Metadata;
+    getMetadata(configuration?: Configuration): Metadata;
+    get chordDefinitions(): ChordDefinitionSet;
+    /**
+     * Change the song contents inline. Return a new {@link Line} to replace it. Return `null` to remove it.
+     * @example
+     * // remove lines with only Tags:
+     * song.mapLines((line) => {
+     *   if (line.items.every(item => item instanceof Tag)) {
+     *     return null;
+     *   }
+     *
+     *   return line;
+     * });
+     * @param {MapLinesCallback} func the callback function
+     * @returns {Song} the changed song
+     */
+    mapLines(func: (_line: Line) => Line | null): Song;
+    private updateItem;
+    private removeItem;
+}
+export default Song;