chordsheetjs 14.6.1 → 15.0.0

package/lib/pdf/normalize_mappings/enharmonic-normalize.d.ts

@@ -0,0 +1,2 @@
+declare const enharmonics: Record<string, Record<string, string>>;
+export default enharmonics;

package/lib/pdf/normalize_mappings/suffix-normalize-mapping.d.ts

@@ -0,0 +1,2 @@
+declare const mapping: Record<string, string>;
+export default mapping;

package/lib/pdf/pango/pango_helpers.d.ts

@@ -0,0 +1,6 @@
+export declare function stripPangoMarkup(text: string): string;
+export interface PangoRenderer {
+    convert(text: string): string;
+}
+export declare function pangoToHtml(text: string): string;
+export declare const defaultPangoRenderer: PangoRenderer;

package/lib/pdf/parser/chord/peg_parser.d.ts

@@ -0,0 +1,55 @@
+export interface FilePosition {
+    offset: number;
+    line: number;
+    column: number;
+}
+export interface FileRange {
+    start: FilePosition;
+    end: FilePosition;
+    source: string;
+}
+export interface LiteralExpectation {
+    type: "literal";
+    text: string;
+    ignoreCase: boolean;
+}
+export interface ClassParts extends Array<string | ClassParts> {
+}
+export interface ClassExpectation {
+    type: "class";
+    parts: ClassParts;
+    inverted: boolean;
+    ignoreCase: boolean;
+}
+export interface AnyExpectation {
+    type: "any";
+}
+export interface EndExpectation {
+    type: "end";
+}
+export interface OtherExpectation {
+    type: "other";
+    description: string;
+}
+export type Expectation = LiteralExpectation | ClassExpectation | AnyExpectation | EndExpectation | OtherExpectation;
+export declare class PeggySyntaxError extends Error {
+    static buildMessage(expected: Expectation[], found: string | null): string;
+    message: string;
+    expected: Expectation[];
+    found: string | null;
+    location: FileRange;
+    name: string;
+    constructor(message: string, expected: Expectation[], found: string | null, location: FileRange);
+    format(sources: {
+        grammarSource?: string;
+        text: string;
+    }[]): string;
+}
+export interface ParseOptions {
+    filename?: string;
+    startRule?: string;
+    tracer?: any;
+    [key: string]: any;
+}
+export type ParseFunction = (input: string, options?: ParseOptions) => any;
+export declare const parse: ParseFunction;

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

@@ -0,0 +1,55 @@
+export interface FilePosition {
+    offset: number;
+    line: number;
+    column: number;
+}
+export interface FileRange {
+    start: FilePosition;
+    end: FilePosition;
+    source: string;
+}
+export interface LiteralExpectation {
+    type: "literal";
+    text: string;
+    ignoreCase: boolean;
+}
+export interface ClassParts extends Array<string | ClassParts> {
+}
+export interface ClassExpectation {
+    type: "class";
+    parts: ClassParts;
+    inverted: boolean;
+    ignoreCase: boolean;
+}
+export interface AnyExpectation {
+    type: "any";
+}
+export interface EndExpectation {
+    type: "end";
+}
+export interface OtherExpectation {
+    type: "other";
+    description: string;
+}
+export type Expectation = LiteralExpectation | ClassExpectation | AnyExpectation | EndExpectation | OtherExpectation;
+export declare class PeggySyntaxError extends Error {
+    static buildMessage(expected: Expectation[], found: string | null): string;
+    message: string;
+    expected: Expectation[];
+    found: string | null;
+    location: FileRange;
+    name: string;
+    constructor(message: string, expected: Expectation[], found: string | null, location: FileRange);
+    format(sources: {
+        grammarSource?: string;
+        text: string;
+    }[]): string;
+}
+export interface ParseOptions {
+    filename?: string;
+    startRule?: string;
+    tracer?: any;
+    [key: string]: any;
+}
+export type ParseFunction = (input: string, options?: ParseOptions) => any;
+export declare const parse: ParseFunction;

package/lib/pdf/parser/chord_pro/helpers.d.ts

@@ -0,0 +1,15 @@
+import { SerializedChordLyricsPair, SerializedItem, SerializedLine, SerializedSoftLineBreak, SerializedTag } from '../../serialized_types';
+import { FileRange } from './peg_parser';
+export declare function buildLine(items: any[]): SerializedLine;
+export declare function buildSection(startTag: SerializedTag, endTag: SerializedTag, content: string): SerializedLine[];
+export declare function buildTag(name: string, value: Partial<{
+    value: string | null;
+    attributes: Record<string, string>;
+}> | null, selector: {
+    value: string | null;
+    isNegated: boolean;
+} | null, location: FileRange): SerializedTag;
+export declare function stringSplitReplace(string: string, search: string, replaceMatch: (subString: string) => any, replaceRest?: (subString: string) => any): any[];
+export declare function applySoftLineBreaks(lyrics: string): SerializedChordLyricsPair[];
+export declare function breakChordLyricsPairOnSoftLineBreak(chords: string, lyrics: string): (SerializedChordLyricsPair | SerializedSoftLineBreak)[];
+export declare function combineChordLyricsPairs(items: SerializedItem[], chopFirstWord?: boolean): SerializedItem[];

package/lib/pdf/parser/chord_pro/peg_parser.d.ts

@@ -0,0 +1,55 @@
+export interface FilePosition {
+    offset: number;
+    line: number;
+    column: number;
+}
+export interface FileRange {
+    start: FilePosition;
+    end: FilePosition;
+    source: string;
+}
+export interface LiteralExpectation {
+    type: "literal";
+    text: string;
+    ignoreCase: boolean;
+}
+export interface ClassParts extends Array<string | ClassParts> {
+}
+export interface ClassExpectation {
+    type: "class";
+    parts: ClassParts;
+    inverted: boolean;
+    ignoreCase: boolean;
+}
+export interface AnyExpectation {
+    type: "any";
+}
+export interface EndExpectation {
+    type: "end";
+}
+export interface OtherExpectation {
+    type: "other";
+    description: string;
+}
+export type Expectation = LiteralExpectation | ClassExpectation | AnyExpectation | EndExpectation | OtherExpectation;
+export declare class PeggySyntaxError extends Error {
+    static buildMessage(expected: Expectation[], found: string | null): string;
+    message: string;
+    expected: Expectation[];
+    found: string | null;
+    location: FileRange;
+    name: string;
+    constructor(message: string, expected: Expectation[], found: string | null, location: FileRange);
+    format(sources: {
+        grammarSource?: string;
+        text: string;
+    }[]): string;
+}
+export interface ParseOptions {
+    filename?: string;
+    startRule?: string;
+    tracer?: any;
+    [key: string]: any;
+}
+export type ParseFunction = (input: string, options?: ParseOptions) => any;
+export declare const parse: ParseFunction;

package/lib/pdf/parser/chord_pro_parser.d.ts

@@ -0,0 +1,32 @@
+import ParserWarning from './parser_warning';
+import Song from '../chord_sheet/song';
+import { ParseOptions } from './chord_pro/peg_parser';
+export type ChordProParserOptions = ParseOptions & {
+    softLineBreaks?: boolean;
+    chopFirstWord?: boolean;
+};
+/**
+ * Parses a ChordPro chord sheet
+ */
+declare class ChordProParser {
+    song?: Song;
+    /**
+     * All warnings raised during parsing the chord sheet
+     * @member
+     * @type {ParserWarning[]}
+     */
+    get warnings(): ParserWarning[];
+    /**
+     * Parses a ChordPro chord sheet into a song
+     * @param {string} chordSheet the ChordPro chord sheet
+     * @param {ChordProParserOptions} options Parser options.
+     * @param {ChordProParserOptions.softLineBreaks} options.softLineBreaks=false If true, a backslash
+     * followed by * a space is treated as a soft line break
+     * @param {ChordProParserOptions.chopFirstWord} options.chopFirstWord=true If true, only the first lyric
+     * word is paired with the chord, the rest of the lyric is put in a separate chord lyric pair
+     * @see https://peggyjs.org/documentation.html#using-the-parser
+     * @returns {Song} The parsed song
+     */
+    parse(chordSheet: string, options?: ChordProParserOptions): Song;
+}
+export default ChordProParser;

package/lib/pdf/parser/chord_sheet_parser.d.ts

@@ -0,0 +1,57 @@
+import ChordLyricsPair from '../chord_sheet/chord_lyrics_pair';
+import Line from '../chord_sheet/line';
+import Song from '../chord_sheet/song';
+import SongBuilder from '../song_builder';
+/**
+ * Parses a normal chord sheet
+ *
+ * ChordSheetParser is deprecated, please use ChordsOverWordsParser.
+ *
+ * ChordsOverWordsParser aims to support any kind of chord, whereas ChordSheetParser lacks
+ * support for many variations. Besides that, some chordpro feature have been ported back
+ * to ChordsOverWordsParser, which adds some interesting functionality.
+ */
+declare class ChordSheetParser {
+    processingText: boolean;
+    preserveWhitespace: boolean;
+    song: Song;
+    songBuilder: SongBuilder;
+    songLine: Line | null;
+    chordLyricsPair: ChordLyricsPair | null;
+    lines: string[];
+    currentLine: number;
+    lineCount: number;
+    /**
+     * Instantiate a chord sheet parser
+     * ChordSheetParser is deprecated, please use ChordsOverWordsParser.
+     * @param {Object} [options={}] options
+     * @param {boolean} [options.preserveWhitespace=true] whether to preserve trailing whitespace for chords
+     * @deprecated
+     */
+    constructor({ preserveWhitespace }?: {
+        preserveWhitespace?: boolean;
+    }, showDeprecationWarning?: boolean);
+    /**
+     * Parses a chord sheet into a song
+     * @param {string} chordSheet The ChordPro chord sheet
+     * @param {Object} [options={}] Optional parser options
+     * @param {Song} [options.song=null] The {@link Song} to store the song data in
+     * @returns {Song} The parsed song
+     */
+    parse(chordSheet: string, { song }?: {
+        song?: Song;
+    }): Song;
+    endOfSong(): void;
+    parseLine(line: any): void;
+    parseNonEmptyLine(line: any): void;
+    initialize(document: any, song?: Song | null): void;
+    readLine(): string;
+    hasNextLine(): boolean;
+    parseLyricsWithChords(chordsLine: any, lyricsLine: any): void;
+    processCharacters(chordsLine: any, lyricsLine: any): number;
+    mapLyricsCharacter(columnMap: number[], column: number, lyricsLine: string, lastIndex: number): number;
+    addCharacter(chr: any, nextChar: any): void;
+    shouldAddCharacterToChords(nextChar: any): any;
+    ensureChordLyricsPairInitialized(): void;
+}
+export default ChordSheetParser;

package/lib/pdf/parser/chords_over_words/helpers.d.ts

@@ -0,0 +1,33 @@
+import { SerializedChord, SerializedLine } from '../../serialized_types';
+type CarriageReturn = '\r';
+type LineFeed = '\n';
+type CarriageReturnLineFeed = '\r\n';
+type NewLine = CarriageReturn | LineFeed | CarriageReturnLineFeed;
+type Lyrics = string;
+type Chord = {
+    column: number;
+    value: string;
+} & SerializedChord;
+interface RhythmSymbol {
+    type: 'symbol';
+    value: '/' | '|' | '-' | 'x';
+    column: number;
+}
+interface NoChord {
+    type: 'noChord';
+    value: string;
+    column: number;
+}
+type DirectionLine = SerializedLine;
+type InlineMetadata = SerializedLine;
+interface ChordsLine {
+    type: 'chordsLine';
+    items: (Chord | RhythmSymbol | NoChord)[];
+}
+interface LyricsLine {
+    type: 'lyricsLine';
+    content: Lyrics;
+}
+type ChordSheetLine = DirectionLine | InlineMetadata | ChordsLine | LyricsLine;
+export declare function composeChordSheetContents(newLine: NewLine | null, lines: ChordSheetLine[], trailingLine: ChordSheetLine | null, chopFirstWord: boolean): SerializedLine[];
+export {};

package/lib/pdf/parser/chords_over_words/peg_parser.d.ts

@@ -0,0 +1,55 @@
+export interface FilePosition {
+    offset: number;
+    line: number;
+    column: number;
+}
+export interface FileRange {
+    start: FilePosition;
+    end: FilePosition;
+    source: string;
+}
+export interface LiteralExpectation {
+    type: "literal";
+    text: string;
+    ignoreCase: boolean;
+}
+export interface ClassParts extends Array<string | ClassParts> {
+}
+export interface ClassExpectation {
+    type: "class";
+    parts: ClassParts;
+    inverted: boolean;
+    ignoreCase: boolean;
+}
+export interface AnyExpectation {
+    type: "any";
+}
+export interface EndExpectation {
+    type: "end";
+}
+export interface OtherExpectation {
+    type: "other";
+    description: string;
+}
+export type Expectation = LiteralExpectation | ClassExpectation | AnyExpectation | EndExpectation | OtherExpectation;
+export declare class PeggySyntaxError extends Error {
+    static buildMessage(expected: Expectation[], found: string | null): string;
+    message: string;
+    expected: Expectation[];
+    found: string | null;
+    location: FileRange;
+    name: string;
+    constructor(message: string, expected: Expectation[], found: string | null, location: FileRange);
+    format(sources: {
+        grammarSource?: string;
+        text: string;
+    }[]): string;
+}
+export interface ParseOptions {
+    filename?: string;
+    startRule?: string;
+    tracer?: any;
+    [key: string]: any;
+}
+export type ParseFunction = (input: string, options?: ParseOptions) => any;
+export declare const parse: ParseFunction;

package/lib/pdf/parser/chords_over_words_parser.d.ts

@@ -0,0 +1,67 @@
+import ParserWarning from './parser_warning';
+import Song from '../chord_sheet/song';
+import { ParseOptions } from './chords_over_words/peg_parser';
+export type ChordsOverWordsParserOptions = ParseOptions & {
+    softLineBreaks?: boolean;
+    chopFirstWord?: boolean;
+};
+/**
+ * Parses a chords over words sheet into a song
+ *
+ * It support "regular" chord sheets:
+ *
+ *            Am         C/G        F          C
+ *     Let it be, let it be, let it be, let it be
+ *     C                G              F  C/E Dm C
+ *     Whisper words of wisdom, let it be
+ *
+ * Additionally, some chordpro features have been "ported back". For example, you can use chordpro directives:
+ *
+ *     {title: Let it be}
+ *     {key: C}
+ *     Chorus 1:
+ *            Am
+ *     Let it be
+ *
+ * For convenience, you can leave out the brackets:
+ *
+ *     title: Let it be
+ *     Chorus 1:
+ *            Am
+ *     Let it be
+ *
+ * You can even use a markdown style frontmatter separator to separate the header from the song:
+ *
+ *     title: Let it be
+ *     key: C
+ *     ---
+ *     Chorus 1:
+ *            Am         C/G        F          C
+ *     Let it be, let it be, let it be, let it be
+ *     C                G              F  C/E Dm C
+ *     Whisper words of wisdom, let it be
+ *
+ * `ChordsOverWordsParser` is the better version of `ChordSheetParser`, which is deprecated.
+ */
+declare class ChordsOverWordsParser {
+    song?: Song;
+    /**
+     * All warnings raised during parsing the chord sheet
+     * @member
+     * @type {ParserWarning[]}
+     */
+    get warnings(): ParserWarning[];
+    /**
+     * Parses a chords over words sheet into a song
+     * @param {string} chordSheet the chords over words sheet
+     * @param {ChordsOverWordsParserOptions} options Parser options.
+     * @param {ChordsOverWordsParserOptions.softLineBreaks} options.softLineBreaks=false If true, a backslash
+     * followed by a space is treated as a soft line break
+     * @param {ChordsOverWordsParserOptions.chopFirstWord} options.chopFirstWord=true If true, only the first lyric
+     * word is paired with the chord, the rest of the lyric is put in a separate chord lyric pair
+     * @see https://peggyjs.org/documentation.html#using-the-parser
+     * @returns {Song} The parsed song
+     */
+    parse(chordSheet: string, options?: ChordsOverWordsParserOptions): Song;
+}
+export default ChordsOverWordsParser;

package/lib/pdf/parser/null_tracer.d.ts

@@ -0,0 +1,4 @@
+declare class NullTracer {
+    trace(): void;
+}
+export default NullTracer;

package/lib/pdf/parser/parser_helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function isWideCharacter(ch: string): boolean;
+export declare function buildVisualColumnMap(lyricsLine: string): number[];
+export declare function chopFirstWord(string: string): (string | null)[];

package/lib/pdf/parser/parser_warning.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Represents a parser warning, currently only used by ChordProParser.
+ */
+declare class ParserWarning {
+    /**
+     * The warning message
+     * @member
+     * @type {string}
+     */
+    message: string;
+    /**
+     * The chord sheet line number on which the warning occurred
+     * @member
+     * @type {number}
+     */
+    lineNumber: number | null;
+    /**
+     * The chord sheet column on which the warning occurred
+     * @member
+     * @type {number}
+     */
+    column: number | null;
+    /**
+     * @hideconstructor
+     */
+    constructor(message: string, lineNumber: number | null, column: number | null);
+    /**
+     * Returns a stringified version of the warning
+     * @returns {string} The string warning
+     */
+    toString(): string;
+}
+export default ParserWarning;

package/lib/pdf/parser/ultimate_guitar_parser.d.ts

@@ -0,0 +1,46 @@
+import ChordSheetParser from './chord_sheet_parser';
+/**
+ * Parses an Ultimate Guitar chord sheet with metadata
+ * Inherits from {@link ChordSheetParser}
+ */
+declare class UltimateGuitarParser extends ChordSheetParser {
+    currentSectionType: string | null;
+    pendingRepeatNotation: string | null;
+    /**
+     * Instantiate a chord sheet parser
+     * @param {Object} [options={}] options
+     * @param {boolean} [options.preserveWhitespace=true] whether to preserve trailing whitespace for chords
+     */
+    constructor({ preserveWhitespace }?: {
+        preserveWhitespace?: boolean;
+    });
+    parseLine(line: string): void;
+    private parseRegularLine;
+    parseNonEmptyLine(line: string): void;
+    private parseChordLineWithNextLine;
+    private unreadLine;
+    private isNonLyricsLine;
+    private parseChordsOnly;
+    parseLyricsWithChords(chordsLine: string, lyricsLine: string): void;
+    processCharacters(chordsLine: string, lyricsLine: string): number;
+    addCharacter(chr: string, nextChar: string): void;
+    shouldAddCharacterToChords(nextChar: string): boolean;
+    ensureChordLyricsPairInitialized(): void;
+    private extractRepeatNotation;
+    private applyRepeatNotation;
+    parseUGMetadata(line: string): boolean;
+    private extractCapoValue;
+    parseVerseDirective(line: string): boolean;
+    parseChorusDirective(line: string): boolean;
+    parseBridgeDirective(line: string): boolean;
+    parsePartDirective(line: string): boolean;
+    parseMetadata(line: string): boolean;
+    isSectionEnd(): boolean;
+    endOfSong(): void;
+    startSection(sectionType: string, label: string): void;
+    endSection({ addNewLine }?: {
+        addNewLine?: boolean | undefined;
+    }): void;
+    startNewLine(): void;
+}
+export default UltimateGuitarParser;

package/lib/pdf/pdf.d.ts

@@ -0,0 +1,2 @@
+export { default as PdfFormatter } from './formatter/pdf_formatter';
+export { JsPdfMeasurer } from './layout/measurement';

package/lib/pdf/rendering/html/html_doc_wrapper.d.ts

@@ -0,0 +1,82 @@
+import { DomMeasurer } from '../../layout/measurement';
+import { FontConfiguration } from '../../formatter/configuration';
+declare type HTMLElement = any;
+/**
+ * HtmlWrapper is responsible for managing the DOM elements for the chord sheet
+ */
+declare class HtmlDocWrapper {
+    container: HTMLElement;
+    pages: HTMLElement[];
+    currentPage: number;
+    totalPages: number;
+    pageSize: {
+        width: number;
+        height: number;
+    };
+    measurer: DomMeasurer;
+    constructor(container: HTMLElement, pageSize: {
+        width: number;
+        height: number;
+    });
+    /**
+     * Creates a new page in the container
+     */
+    createPage(): HTMLElement;
+    get pageStyles(): Record<string, string>;
+    /**
+     * Creates a new page and advances to it
+     */
+    newPage(): void;
+    /**
+     * Sets the current page
+     */
+    setPage(pageNumber: number): void;
+    /**
+     * Gets the current page element
+     */
+    getCurrentPage(): HTMLElement;
+    /**
+     * Adds an element to the current page at the specified position
+     */
+    addElement(element: HTMLElement, x: number, y: number): void;
+    /**
+     * Gets text dimensions using the DOM measurer
+     */
+    getTextDimensions(text: string, font: FontConfiguration): {
+        w: number;
+        h: number;
+    };
+    /**
+     * Gets text width using the DOM measurer
+     */
+    getTextWidth(text: string, font: FontConfiguration): number;
+    /**
+     * Splits text to fit within a maximum width
+     */
+    splitTextToSize(text: string, maxWidth: number, font: FontConfiguration): string[];
+    /**
+     * Sets the font style (no-op in HTML renderer)
+     */
+    setFontStyle(_font: FontConfiguration): void;
+    /**
+     * Sets line style for drawing (no-op in HTML renderer)
+     */
+    setLineStyle(_style: any): void;
+    /**
+     * Resets line dash style (no-op in HTML renderer)
+     */
+    resetDash(): void;
+    /**
+     * Executes a callback for each page
+     */
+    eachPage(callback: (page: HTMLElement, index: number) => void): void;
+    /**
+     * Gets the container element
+     */
+    getContainer(): HTMLElement;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}
+export default HtmlDocWrapper;

package/lib/pdf/rendering/html/html_element_styler.d.ts

@@ -0,0 +1,58 @@
+import { FontConfiguration } from '../../formatter/configuration';
+import { PositionedElement } from '../renderer';
+declare type HTMLElement = any;
+declare type CSSStyleDeclaration = any;
+/**
+ * Configuration for HTML element styling
+ */
+export interface HtmlStylerConfig {
+    cssClassPrefix?: string;
+    cssClasses?: Record<string, string>;
+}
+/**
+ * Handles styling of HTML elements for the positioned HTML renderer.
+ * Extracted to improve modularity and reduce file size.
+ */
+export declare class HtmlElementStyler {
+    private config;
+    constructor(config: HtmlStylerConfig);
+    /**
+     * Gets the CSS class prefix
+     */
+    get prefix(): string;
+    /**
+     * Applies styles to an HTML element based on its positioned element data
+     */
+    applyElementStyle(htmlElement: HTMLElement, element: PositionedElement): void;
+    /**
+     * Gets conditional CSS styles from font configuration
+     */
+    getConditionalStyles(style: FontConfiguration): Partial<CSSStyleDeclaration>;
+    /**
+     * Gets type-specific styles for different element types
+     */
+    getTypeSpecificStyles(element: PositionedElement): Partial<CSSStyleDeclaration>;
+    /**
+     * Gets chord-specific styles
+     */
+    chordStyles(element: PositionedElement): Partial<CSSStyleDeclaration>;
+    /**
+     * Applies font styles to an HTML element
+     */
+    applyFontStyle(element: HTMLElement, style: FontConfiguration): void;
+    /**
+     * Applies ellipsis styling to an element
+     */
+    applyEllipsisStyle(element: HTMLElement, width: number): void;
+    /**
+     * Creates a class name string with the configured prefix
+     */
+    createClassName(...classes: (string | undefined)[]): string;
+    /**
+     * Gets the custom CSS class for an element type if configured
+     */
+    getCustomClass(elementType: string): string | undefined;
+    private getNormalizedFontStyles;
+    private normalizeColor;
+}
+export default HtmlElementStyler;