chordsheetjs 14.6.1 → 15.0.0

package/lib/pdf/formatter/configuration/base_configuration.d.ts

@@ -0,0 +1,58 @@
+import { ContentType } from '../../serialized_types';
+import Key from '../../key';
+export type Delegate = (_string: string) => string;
+export declare const defaultDelegate: Delegate;
+export interface MetadataRule {
+    match: string | string[] | RegExp | ((key: string) => boolean);
+    visible?: boolean;
+    sortMethod?: 'preserve' | 'alphabetical' | 'custom';
+    customSort?: (a: string, b: string) => number;
+}
+export interface MetadataConfiguration {
+    separator: string;
+    order: (string | MetadataRule)[];
+}
+export interface InstrumentConfiguration {
+    type?: string;
+    description?: string;
+    tuning?: string;
+}
+export interface UserConfigurationProperties {
+    name?: string;
+    fullname?: string;
+}
+export declare const defaultMetadataConfiguration: MetadataConfiguration;
+export interface DelegatesConfiguration {
+    abc: Delegate;
+    ly: Delegate;
+    svg: Delegate;
+    tab: Delegate;
+    grid: Delegate;
+}
+export declare const defaultDelegatesConfiguration: DelegatesConfiguration;
+export interface BaseFormatterConfiguration {
+    decapo: boolean;
+    delegates: Partial<Record<ContentType, Delegate>>;
+    evaluate: boolean;
+    expandChorusDirective: boolean;
+    instrument: InstrumentConfiguration | null;
+    key: Key | null;
+    metadata: MetadataConfiguration;
+    normalizeChords: boolean;
+    useUnicodeModifiers: boolean;
+    user: UserConfigurationProperties | null;
+}
+export type ConfigurationProperties = Record<string, any> & Partial<{
+    decapo: boolean;
+    delegates: Partial<DelegatesConfiguration>;
+    evaluate: boolean;
+    expandChorusDirective: boolean;
+    instrument: Partial<InstrumentConfiguration>;
+    key: Key | string | null;
+    metadata: Partial<MetadataConfiguration>;
+    normalizeChords: boolean;
+    useUnicodeModifiers: boolean;
+    user: Partial<UserConfigurationProperties>;
+}>;
+export declare const defaultBaseConfiguration: BaseFormatterConfiguration;
+export default BaseFormatterConfiguration;

package/lib/pdf/formatter/configuration/default_config_manager.d.ts

@@ -0,0 +1,31 @@
+import { BaseFormatterConfiguration } from './base_configuration';
+import { HTMLFormatterConfiguration } from './html_configuration';
+import { MeasuredHtmlFormatterConfiguration } from './measured_html_configuration';
+import { MeasurementBasedFormatterConfiguration } from './measurement_based_configuration';
+import { PDFFormatterConfiguration } from './pdf_configuration';
+/**
+ * Build the inheritance chain for a formatter type
+ * @param formatterType The formatter type to build the chain for
+ * @returns Array of formatter types in inheritance order (base first)
+ */
+export declare const buildInheritanceChain: (formatterType: string) => string[];
+/**
+ * Get the default configuration for a specific formatter type
+ * This dynamically composes the full default configuration by merging
+ * the defaults from all levels in the inheritance chain
+ * @param formatterType The formatter type to get defaults for
+ * @returns The fully composed default configuration
+ */
+export declare const getDefaultConfig: <T extends BaseFormatterConfiguration>(formatterType: string) => T;
+export declare const getBaseDefaultConfig: () => BaseFormatterConfiguration;
+export declare const getHTMLDefaultConfig: () => HTMLFormatterConfiguration;
+export declare const getMeasurementDefaultConfig: () => MeasurementBasedFormatterConfiguration;
+export declare const getPDFDefaultConfig: () => PDFFormatterConfiguration;
+export declare const getMeasuredHtmlDefaultConfig: () => MeasuredHtmlFormatterConfiguration;
+/**
+ * Register a new formatter type with its specific defaults and inheritance chain
+ * @param formatterType The formatter type to register
+ * @param specificDefaults The formatter-specific default settings
+ * @param inheritsFrom Array of formatter types this one inherits from (in order)
+ */
+export declare const registerFormatterType: (formatterType: string, specificDefaults?: Record<string, any>, inheritsFrom?: string[]) => void;

package/lib/pdf/formatter/configuration/html_configuration.d.ts

@@ -0,0 +1,37 @@
+import { BaseFormatterConfiguration, ConfigurationProperties } from './base_configuration';
+import { PangoRenderer } from '../../pango/pango_helpers';
+export type CSS = Record<string, string | number>;
+export interface HtmlTemplateCssClasses {
+    annotation: string;
+    chord: string;
+    chordSheet: string;
+    column: string;
+    comment: string;
+    emptyLine: string;
+    image: string;
+    label: string;
+    labelWrapper: string;
+    line: string;
+    literal: string;
+    literalContents: string;
+    lyrics: string;
+    paragraph: string;
+    rhythmSymbol: string;
+    row: string;
+    subtitle: string;
+    title: string;
+}
+export interface HTMLFormatterConfiguration extends BaseFormatterConfiguration {
+    cssClasses: HtmlTemplateCssClasses;
+    customCSS?: CSS;
+    pangoRenderer?: PangoRenderer;
+    renderBlankLines?: boolean;
+}
+export declare const defaultCssClasses: HtmlTemplateCssClasses;
+export interface HTMLConfigurationProperties extends ConfigurationProperties {
+    cssClasses?: Partial<HtmlTemplateCssClasses>;
+    customCSS?: CSS;
+    pangoRenderer?: PangoRenderer;
+    renderBlankLines?: boolean;
+}
+export declare const htmlSpecificDefaults: Partial<HTMLFormatterConfiguration>;

package/lib/pdf/formatter/configuration/index.d.ts

@@ -0,0 +1,13 @@
+import { BaseFormatterConfiguration, ConfigurationProperties, Delegate, DelegatesConfiguration, InstrumentConfiguration, MetadataConfiguration, UserConfigurationProperties, defaultBaseConfiguration, defaultDelegate, defaultDelegatesConfiguration, defaultMetadataConfiguration } from './base_configuration';
+import { CSS, HTMLConfigurationProperties, HTMLFormatterConfiguration, HtmlTemplateCssClasses, defaultCssClasses, htmlSpecificDefaults } from './html_configuration';
+import { Alignment, ChordDiagramFontConfigurations, ChordDiagramOverrides, ChordDiagramsConfig, ColumnConfig, ConditionRule, ConditionalRule, Dimension, FontConfiguration, FontConfigurations, FontSection, ILayoutContentItem, LayoutContentItem, LayoutContentItemWithImage, LayoutContentItemWithLine, LayoutContentItemWithTemplate, LayoutContentItemWithText, LayoutContentItemWithValue, LayoutItem, LayoutSection, LineLayout, LineStyle, Margins, MeasuredItem, MeasurementBasedFormatterConfiguration, MeasurementBasedLayoutConfig, MeasurerType, Position, SectionDisplay, SectionTypeConfig, SectionsConfig, SingleCondition, defaultFontConfigurations, defaultMeasurementBasedLayout, measurementSpecificDefaults } from './measurement_based_configuration';
+import { MeasuredHtmlConfigurationProperties, MeasuredHtmlFormatterConfiguration, MeasuredHtmlLayoutConfig, measuredHtmlSpecificDefaults } from './measured_html_configuration';
+import { PDFConfigurationProperties, PDFFormatterConfiguration, PDFLayoutConfig, pdfSpecificDefaults } from './pdf_configuration';
+import { getDefaultConfig, getHTMLDefaultConfig, getMeasuredHtmlDefaultConfig, getPDFDefaultConfig } from './default_config_manager';
+type Configuration = BaseFormatterConfiguration;
+/**
+ * Legacy configuration function for backward compatibility
+ */
+export declare function configure(config: ConfigurationProperties): Configuration;
+export { Delegate, defaultDelegate, MetadataConfiguration, InstrumentConfiguration, UserConfigurationProperties, defaultMetadataConfiguration, DelegatesConfiguration, defaultDelegatesConfiguration, ConfigurationProperties, defaultBaseConfiguration, Margins, FontSection, LayoutSection, Alignment, MeasurerType, ConditionRule, SingleCondition, ConditionalRule, Position, Dimension, FontConfiguration, FontConfigurations, ChordDiagramFontConfigurations, defaultFontConfigurations, SectionDisplay, SectionTypeConfig, ColumnConfig, SectionsConfig, ILayoutContentItem, LayoutContentItem, LayoutContentItemWithText, LayoutContentItemWithValue, LayoutContentItemWithTemplate, LayoutContentItemWithImage, LineStyle, LayoutContentItemWithLine, LayoutItem, ChordDiagramOverrides, ChordDiagramsConfig, MeasuredItem, LineLayout, MeasurementBasedLayoutConfig, defaultMeasurementBasedLayout, measurementSpecificDefaults, MeasurementBasedFormatterConfiguration, MeasuredHtmlLayoutConfig, MeasuredHtmlFormatterConfiguration, MeasuredHtmlConfigurationProperties, measuredHtmlSpecificDefaults, CSS, HtmlTemplateCssClasses, HTMLFormatterConfiguration, defaultCssClasses, HTMLConfigurationProperties, htmlSpecificDefaults, PDFLayoutConfig, PDFFormatterConfiguration, PDFConfigurationProperties, pdfSpecificDefaults, BaseFormatterConfiguration, Configuration, getDefaultConfig, getHTMLDefaultConfig, getMeasuredHtmlDefaultConfig, getPDFDefaultConfig, };
+export default Configuration;

package/lib/pdf/formatter/configuration/measured_html_configuration.d.ts

@@ -0,0 +1,38 @@
+import { MeasurementBasedConfigurationProperties, MeasurementBasedFormatterConfiguration, MeasurementBasedLayoutConfig, SectionsConfig } from './measurement_based_configuration';
+export interface MeasuredHtmlLayoutConfig extends MeasurementBasedLayoutConfig {
+    header: MeasurementBasedLayoutConfig['header'];
+    footer: MeasurementBasedLayoutConfig['footer'];
+    sections: SectionsConfig;
+}
+export interface MeasuredHtmlFormatterConfiguration extends MeasurementBasedFormatterConfiguration {
+    version: string;
+    layout: MeasuredHtmlLayoutConfig;
+    pageSize: {
+        width: number;
+        height: number;
+    };
+    cssClassPrefix?: string;
+    additionalCss?: string;
+    cssClasses?: {
+        container?: string;
+        page?: string;
+        chord?: string;
+        lyrics?: string;
+        sectionLabel?: string;
+        comment?: string;
+        header?: string;
+        footer?: string;
+    };
+}
+export interface MeasuredHtmlConfigurationProperties extends MeasurementBasedConfigurationProperties {
+    version?: string;
+    layout?: Partial<MeasuredHtmlLayoutConfig>;
+    pageSize?: {
+        width?: number;
+        height?: number;
+    };
+    cssClassPrefix?: string;
+    additionalCss?: string;
+    cssClasses?: Record<string, string>;
+}
+export declare const measuredHtmlSpecificDefaults: Partial<MeasuredHtmlFormatterConfiguration>;

package/lib/pdf/formatter/configuration/measurement_based_configuration.d.ts

@@ -0,0 +1,204 @@
+import type { ImageCompression } from 'jspdf';
+import { ChordDiagramRenderingConfig } from '../../chord_diagram/chord_diagram';
+import Item from '../../chord_sheet/item';
+import { ParagraphType } from '../../constants';
+import { BaseFormatterConfiguration, ConfigurationProperties } from './base_configuration';
+import { ChordLyricsPair, Comment, Line, SoftLineBreak, Tag } from '../../index';
+export interface Margins {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+export type FontSection = 'title' | 'subtitle' | 'metadata' | 'text' | 'chord' | 'comment' | 'annotation' | 'sectionLabel';
+export type LayoutSection = 'header' | 'footer';
+export type Alignment = 'left' | 'center' | 'right' | number;
+export type MeasurerType = 'canvas' | 'dom' | 'jspdf';
+export type ConditionRule = Partial<{
+    equals: any;
+    not_equals: any;
+    greater_than: number;
+    greater_than_equal: number;
+    less_than: number;
+    less_than_equal: number;
+    like: string;
+    contains: string;
+    in: any[];
+    not_in: any[];
+    all: any[];
+    exists: boolean;
+    first: boolean;
+    last: boolean;
+}>;
+export type SingleCondition = Record<string, ConditionRule>;
+export type ConditionalRule = Partial<{
+    and: SingleCondition[];
+    or: SingleCondition[];
+}> | SingleCondition;
+export interface Position {
+    x: Alignment;
+    y: number;
+    width?: number;
+    height?: number;
+    offsetX?: number;
+    clip?: boolean;
+    ellipsis?: boolean;
+}
+export interface Dimension {
+    width: number;
+    height: number;
+}
+export interface FontConfiguration {
+    name: string;
+    style: string;
+    weight?: string | number;
+    size: number;
+    lineHeight?: number;
+    color: string | number;
+    underline?: boolean;
+    inherit?: string;
+    textTransform?: string;
+    textDecoration?: string;
+    letterSpacing?: string;
+}
+export type FontConfigurations = Record<FontSection, FontConfiguration>;
+export type ChordDiagramFontConfigurations = Record<'title' | 'fingerings' | 'baseFret', FontConfiguration>;
+export declare const defaultFontConfigurations: FontConfigurations;
+export interface SectionDisplay {
+    labelStyle?: 'uppercase';
+    showLabel?: boolean;
+    lyricsOnly?: boolean;
+    indent?: number;
+    compact?: boolean;
+    repeatedSections?: 'hide' | 'title_only' | 'lyrics_only' | 'full';
+}
+export interface SectionTypeConfig {
+    fonts?: FontConfigurations;
+    display?: SectionDisplay;
+    overrides?: {
+        condition: ConditionalRule;
+        display: Partial<SectionDisplay>;
+    }[];
+}
+export interface ColumnConfig {
+    columnCount?: number;
+    columnSpacing: number;
+    minColumnWidth?: number;
+    maxColumnWidth?: number;
+}
+export interface SectionsConfig {
+    global: {
+        columnWidth: number;
+        spacingBottom?: number;
+        spacingAfter?: number;
+        chordLyricSpacing: number;
+        linePadding: number;
+        paragraphSpacing?: number;
+        chordSpacing: number;
+    } & ColumnConfig;
+    base: SectionTypeConfig;
+    types?: Record<ParagraphType, SectionTypeConfig | undefined>;
+}
+export interface ILayoutContentItem {
+    type: string;
+    position: Position;
+    condition?: ConditionalRule;
+}
+export interface LayoutContentItemWithText extends ILayoutContentItem {
+    type: 'text';
+    style: FontConfiguration;
+    value?: string;
+    template?: string;
+    cssClass?: string;
+    elementStyle?: Record<string, string>;
+}
+export interface LayoutContentItemWithValue extends LayoutContentItemWithText {
+    value: string;
+}
+export interface LayoutContentItemWithTemplate extends LayoutContentItemWithText {
+    template: string;
+}
+export interface LayoutContentItemWithImage extends ILayoutContentItem {
+    type: 'image';
+    src: string;
+    position: Position;
+    compression: ImageCompression;
+    size: Dimension;
+    alias?: string;
+    rotation?: number;
+}
+export interface LineStyle {
+    color: string;
+    width: number;
+    dash?: number[];
+}
+export interface LayoutContentItemWithLine {
+    type: 'line';
+    style: LineStyle;
+    position: {
+        x?: number;
+        y: number;
+        width: number | 'auto';
+        height?: number;
+    };
+    condition?: ConditionalRule;
+}
+export type LayoutContentItem = LayoutContentItemWithValue | LayoutContentItemWithTemplate | LayoutContentItemWithImage | LayoutContentItemWithLine;
+export interface LayoutItem {
+    height: number;
+    content: LayoutContentItem[];
+}
+export interface ChordDiagramOverrides {
+    hide?: boolean;
+    definition?: string;
+}
+export interface ChordDiagramsConfig {
+    enabled: boolean;
+    renderingConfig?: ChordDiagramRenderingConfig;
+    definitions?: {
+        hiddenChords: string[];
+    };
+    overrides?: {
+        global?: Record<string, ChordDiagramOverrides>;
+        byKey?: Record<string, Record<string, ChordDiagramOverrides>>;
+    };
+    fonts: ChordDiagramFontConfigurations;
+}
+export interface MeasuredItem {
+    item: ChordLyricsPair | Comment | SoftLineBreak | Tag | Item | null;
+    width: number;
+    chordLyricWidthDifference?: number;
+    chordHeight?: number;
+    adjustedChord?: string;
+}
+export interface LineLayout {
+    type: 'ChordLyricsPair' | 'Comment' | 'Tag' | 'ColumnBreak' | 'SectionLabel';
+    items: MeasuredItem[];
+    lineHeight: number;
+    line?: Line;
+}
+export interface MeasurementBasedLayoutConfig {
+    global: {
+        margins: Margins;
+    };
+    header: LayoutItem;
+    footer: LayoutItem;
+    sections?: SectionsConfig;
+    chordDiagrams?: ChordDiagramsConfig;
+}
+export declare const defaultMeasurementBasedLayout: MeasurementBasedLayoutConfig;
+export declare const measurementSpecificDefaults: {
+    fonts: FontConfigurations;
+    measurer: string;
+    layout: MeasurementBasedLayoutConfig;
+};
+export interface MeasurementBasedFormatterConfiguration extends BaseFormatterConfiguration {
+    fonts: FontConfigurations;
+    measurer: MeasurerType;
+    layout: MeasurementBasedLayoutConfig;
+}
+export interface MeasurementBasedConfigurationProperties extends ConfigurationProperties {
+    fonts?: Partial<FontConfigurations>;
+    measurer?: MeasurerType;
+    layout?: Partial<MeasurementBasedLayoutConfig>;
+}

package/lib/pdf/formatter/configuration/pdf_configuration.d.ts

@@ -0,0 +1,16 @@
+import { ChordDiagramsConfig, MeasurementBasedConfigurationProperties, MeasurementBasedFormatterConfiguration, MeasurementBasedLayoutConfig, SectionsConfig } from './measurement_based_configuration';
+export interface PDFLayoutConfig extends MeasurementBasedLayoutConfig {
+    header: MeasurementBasedLayoutConfig['header'];
+    footer: MeasurementBasedLayoutConfig['footer'];
+    sections: SectionsConfig;
+    chordDiagrams: ChordDiagramsConfig;
+}
+export interface PDFFormatterConfiguration extends MeasurementBasedFormatterConfiguration {
+    version: string;
+    layout: PDFLayoutConfig;
+}
+export interface PDFConfigurationProperties extends MeasurementBasedConfigurationProperties {
+    version?: string;
+    layout?: Partial<PDFLayoutConfig>;
+}
+export declare const pdfSpecificDefaults: Partial<PDFFormatterConfiguration>;

package/lib/pdf/formatter/formatter.d.ts

@@ -0,0 +1,38 @@
+import { BaseFormatterConfiguration } from './configuration/base_configuration';
+import { DeepPartial } from '../utilities';
+/**
+ * Base formatter class that provides configuration handling for all formatters
+ */
+declare class Formatter<T extends BaseFormatterConfiguration = BaseFormatterConfiguration> {
+    configuration: T;
+    /**
+     * Instantiate
+     * @param {DeepPartial<T>} [configuration={}] options
+     * @param {boolean} [configuration.evaluate=false] Whether or not to evaluate meta expressions.
+     * For more info about meta expressions, see: https://bit.ly/2SC9c2u
+     * @param {object} [configuration.metadata={}]
+     * @param {string} [configuration.metadata.separator=", "] The separator to be used when rendering a
+     * metadata value that has multiple values. See: https://bit.ly/2SC9c2u
+     * @param {Key|string} [configuration.key=null] The key to use for rendering. The chord sheet will be
+     * transposed from the song's original key (as indicated by the `{key}` directive) to the specified key.
+     * Note that transposing will only work if the original song key is set.
+     * @param {boolean} [configuration.expandChorusDirective=false] Whether or not to expand `{chorus}` directives
+     * by rendering the last defined chorus inline after the directive.
+     * @param {boolean} [configuration.useUnicodeModifiers=false] Whether or not to use unicode flat and sharp
+     * symbols.
+     * @param {boolean} [configuration.normalizeChords=true] Whether or not to automatically normalize chords
+     */
+    constructor(configuration?: DeepPartial<T>);
+    /**
+     * Configure the formatter with new options
+     * @param {DeepPartial<T>} config New configuration options
+     * @returns {this} The formatter instance for chaining
+     */
+    configure(config: DeepPartial<T>): this;
+    /**
+     * Get the default configuration for this formatter type
+     * Should be implemented by subclasses to return the appropriate default configuration
+     */
+    protected getDefaultConfiguration(): T;
+}
+export default Formatter;

package/lib/pdf/formatter/formatting_context.d.ts

@@ -0,0 +1,7 @@
+import { BaseFormatterConfiguration } from './configuration';
+import Metadata from '../chord_sheet/metadata';
+interface FormattingContext {
+    configuration: BaseFormatterConfiguration;
+    metadata: Metadata;
+}
+export default FormattingContext;

package/lib/pdf/formatter/html_div_formatter.d.ts

@@ -0,0 +1,9 @@
+import HtmlFormatter, { CSS, Template } from './html_formatter';
+/**
+ * Formats a song into HTML. It uses DIVs to align lyrics with chords, which makes it useful for responsive web pages.
+ */
+declare class HtmlDivFormatter extends HtmlFormatter {
+    get template(): Template;
+    get defaultCss(): CSS;
+}
+export default HtmlDivFormatter;

package/lib/pdf/formatter/html_formatter.d.ts

@@ -0,0 +1,60 @@
+import Formatter from './formatter';
+import Metadata from '../chord_sheet/metadata';
+import Paragraph from '../chord_sheet/paragraph';
+import Song from '../chord_sheet/song';
+import { HTMLFormatterConfiguration, HtmlTemplateCssClasses } from './configuration';
+export interface HtmlTemplateArgs {
+    configuration: HTMLFormatterConfiguration;
+    song: Song;
+    metadata: Metadata;
+    renderBlankLines?: boolean;
+    bodyParagraphs: Paragraph[];
+}
+export type Template = (_args: HtmlTemplateArgs) => string;
+export type CSS = Record<string, Record<string, string>>;
+export declare const defaultCssClasses: HtmlTemplateCssClasses;
+/**
+ * Acts as a base class for HTML formatters
+ */
+declare abstract class HtmlFormatter extends Formatter<HTMLFormatterConfiguration> {
+    /**
+     * Get the default configuration for HTML formatter
+     * Uses the HTML-specific default configuration from the configuration manager
+     */
+    protected getDefaultConfiguration(): HTMLFormatterConfiguration;
+    /**
+     * Formats a song into HTML.
+     * @param {Song} song The song to be formatted
+     * @returns {string} The HTML string
+     */
+    format(song: Song): string;
+    /**
+     * Generates basic CSS, optionally scoped within the provided selector, to use with the HTML output
+     *
+     * For example, execute cssString('.chordSheetViewer') will result in CSS like:
+     *
+     *     .chordSheetViewer .paragraph {
+     *       margin-bottom: 1em;
+     *     }
+     *
+     * @param scope the CSS scope to use, for example `.chordSheetViewer`
+     * @returns {string} the CSS string
+     */
+    cssString(scope?: string): string;
+    /**
+     * Basic CSS, in object style à la useStyles, to use with the HTML output
+     * For a CSS string see {@link cssString}
+     *
+     * Example:
+     *
+     *     '.paragraph': {
+     *       marginBottom: '1em'
+     *     }
+     *
+     * @return {Object.<string, Object.<string, string>>} the CSS object
+     */
+    get cssObject(): CSS;
+    abstract get defaultCss(): CSS;
+    abstract get template(): Template;
+}
+export default HtmlFormatter;

package/lib/pdf/formatter/html_table_formatter.d.ts

@@ -0,0 +1,10 @@
+import HtmlFormatter, { CSS, Template } from './html_formatter';
+/**
+ * Formats a song into HTML. It uses TABLEs to align lyrics with chords, which makes the HTML for things like
+ * PDF conversion.
+ */
+declare class HtmlTableFormatter extends HtmlFormatter {
+    get template(): Template;
+    get defaultCss(): CSS;
+}
+export default HtmlTableFormatter;

package/lib/pdf/formatter/measured_html_formatter.d.ts

@@ -0,0 +1,43 @@
+import { MeasuredHtmlFormatterConfiguration } from './configuration';
+import MeasurementBasedFormatter from './measurement_based_formatter';
+import Song from '../chord_sheet/song';
+declare type HTMLElement = any;
+/**
+ * MeasuredHtmlFormatter formats a song into HTML with absolute positioning.
+ */
+declare class MeasuredHtmlFormatter extends MeasurementBasedFormatter<MeasuredHtmlFormatterConfiguration> {
+    private song;
+    private renderer;
+    private readonly container;
+    /**
+     * Creates a new HTML formatter
+     * @param container The HTML container element to render into
+     */
+    constructor(container: HTMLElement);
+    /**
+     * Get the default configuration for HTML formatter
+     */
+    protected getDefaultConfiguration(): MeasuredHtmlFormatterConfiguration;
+    /**
+     * Formats a song into HTML with absolute positioning.
+     * @param song - The song to format.
+     */
+    format(song: Song): void;
+    /**
+     * Create the layout engine with the appropriate configuration
+     */
+    private createLayoutEngine;
+    /**
+     * Gets the HTML output
+     */
+    getHTML(): HTMLElement;
+    /**
+     * Generates HTML as a string
+     */
+    getHTMLString(): string;
+    /**
+     * Clean up resources when the formatter is no longer needed
+     */
+    dispose(): void;
+}
+export default MeasuredHtmlFormatter;

package/lib/pdf/formatter/measurement_based_formatter.d.ts

@@ -0,0 +1,19 @@
+import { DeepPartial } from '../utilities';
+import Formatter from './formatter';
+import { MeasurementBasedFormatterConfiguration } from './configuration';
+/**
+ * Base formatter for formatters that need measurements to position elements
+ */
+declare abstract class MeasurementBasedFormatter<T extends MeasurementBasedFormatterConfiguration = MeasurementBasedFormatterConfiguration> extends Formatter<T> {
+    /**
+     * Instantiate a measurement-based formatter.
+     * @param configuration - The formatter configuration.
+     */
+    constructor(configuration?: DeepPartial<T>);
+    /**
+     * Get the default configuration for this formatter type
+     * Uses the measurement-based default configuration
+     */
+    protected getDefaultConfiguration(): T;
+}
+export default MeasurementBasedFormatter;

package/lib/pdf/formatter/pdf_formatter/doc_wrapper.d.ts

@@ -0,0 +1,53 @@
+import { ImageCompression, jsPDFOptions } from 'jspdf';
+import { PdfConstructor } from './types';
+import { FontConfiguration, LineStyle } from '../configuration';
+declare class DocWrapper {
+    currentPage: number;
+    fontConfiguration: FontConfiguration;
+    totalPages: number;
+    doc: any;
+    static setup(docConstructor: PdfConstructor, options?: jsPDFOptions): DocWrapper;
+    constructor(DocConstructor: PdfConstructor, options: jsPDFOptions);
+    get pageSize(): {
+        width: number;
+        height: number;
+    };
+    save(filename: string): void;
+    output(): any;
+    eachPage(callback: () => void): void;
+    newPage(): void;
+    setPage(page: number): void;
+    setFont(fontName: string, fontStyle?: string, fontWeight?: string | number): void;
+    getFont(): any;
+    getFontSize(): any;
+    getFillColor(): any;
+    setFillColor(color: number | string): void;
+    setFontStyle(styleConfig: FontConfiguration): void;
+    setFontSize(size: number): void;
+    withFontConfiguration(fontConfiguration: FontConfiguration | null, callback: () => any): any;
+    setTextColor(color: string | number): void;
+    getTextDimensions(text: string, fontStyle?: FontConfiguration): {
+        w: number;
+        h: number;
+    };
+    getTextWidth(text: string, fontStyle?: FontConfiguration): number;
+    getTextHeight(text: string, fontStyle?: FontConfiguration): number;
+    getSpaceWidth(): number;
+    text(text: string, x: number, y: number, style?: FontConfiguration): void;
+    setDrawColor(color: number | string): void;
+    setLineWidth(width: number): void;
+    splitTextToSize(text: string | null, maxWidth: number, fontStyle?: FontConfiguration): any;
+    addImage(imageData: string, format: string, x: number, y: number, width: number, height: number, alias?: string, compression?: ImageCompression, rotation?: number): void;
+    setLineStyle(style: LineStyle): void;
+    resetDash(): void;
+    line(x1: number, y1: number, x2: number, y2: number): void;
+    circle(x: number, y: number, r: number, style?: string | null): void;
+    roundedRect(x: number, y: number, w: number, h: number, rx: number, ry: number, style?: string | null): void;
+    rect(x: number, y: number, w: number, h: number, style?: string | null): void;
+    withDrawColor(drawColor: number | string, callback: () => void): void;
+    withFillColor(fillColor: number | string, callback: () => void): void;
+    withFontSize(fontSize: number, callback: () => void): void;
+    withLineWidth(lineWidth: number, callback: () => void): void;
+    private addFonts;
+}
+export default DocWrapper;