chordsheetjs 14.6.1 → 15.0.0

package/lib/pdf/key.d.ts

@@ -0,0 +1,124 @@
+import { Accidental, AccidentalMaybe, ChordType } from './constants';
+interface KeyProperties {
+    grade?: number | null;
+    number?: number | null;
+    type?: ChordType;
+    minor?: boolean;
+    accidental?: Accidental | null;
+    referenceKeyGrade?: number | null;
+    referenceKeyMode?: string | null;
+    preferredAccidental?: Accidental | null;
+    explicitAccidental?: boolean;
+}
+interface ConstructorOptions {
+    grade?: number | null;
+    number?: number | null;
+    minor: boolean;
+    type: ChordType;
+    accidental: Accidental | null;
+    referenceKeyGrade?: number | null;
+    referenceKeyMode?: string | null;
+    originalKeyString?: string | null;
+    preferredAccidental: Accidental | null;
+    explicitAccidental?: boolean;
+}
+/**
+ * Represents a key, such as Eb (symbol), #3 (numeric) or VII (numeral).
+ *
+ * The only function considered public API is `Key.distance`
+ */
+declare class Key implements KeyProperties {
+    grade: number | null;
+    number: number | null;
+    accidental: Accidental | null;
+    type: ChordType;
+    get unicodeAccidental(): string | null;
+    /** @deprecated Use unicodeAccidental instead */
+    get unicodeModifier(): string | null;
+    /** @deprecated Use accidental instead */
+    get modifier(): Accidental | null;
+    /** @deprecated Use preferredAccidental instead */
+    get preferredModifier(): Accidental | null;
+    minor: boolean;
+    referenceKeyGrade: number | null;
+    referenceKeyMode: string | null;
+    originalKeyString: string | null;
+    preferredAccidental: Accidental | null;
+    explicitAccidental: boolean;
+    static parse(keyString: string | null): null | Key;
+    static parseAsType(trimmed: string, keyType: ChordType): Key | null;
+    static resolve({ key, keyType, minor, accidental, }: {
+        key: string | number;
+        keyType: ChordType;
+        minor: string | boolean;
+        accidental: Accidental | null;
+    }): Key | null;
+    static getNumberFromKey(keyString: string, keyType: ChordType): number;
+    static keyWithAccidental(key: string, accidental: Accidental | null, type: ChordType): string;
+    /** @deprecated Use keyWithAccidental instead */
+    static keyWithModifier(key: string, accidental: Accidental | null, type: ChordType): string;
+    static toGrade(key: string, accidental: AccidentalMaybe, type: ChordType, isMinor: boolean): number | null;
+    static isMinor(key: string, keyType: ChordType, minor: string | undefined | boolean): boolean;
+    static parseOrFail(keyString: string | null): Key;
+    static wrap(keyStringOrObject: Key | string | null): Key | null;
+    static wrapOrFail(keyStringOrObject?: Key | string | null): Key;
+    static toString(keyStringOrObject: Key | string): string;
+    /**
+     * Calculates the distance in semitones between one key and another.
+     * @param {Key | string} oneKey the key
+     * @param {Key | string} otherKey the other key
+     * @return {number} the distance in semitones
+     */
+    static distance(oneKey: Key | string, otherKey: Key | string): number;
+    constructor({ grade, number, minor, type, accidental, referenceKeyGrade, referenceKeyMode, originalKeyString, preferredAccidental, explicitAccidental, }: ConstructorOptions);
+    distanceTo(otherKey: Key | string): number;
+    get effectiveGrade(): number;
+    isMinor(): boolean;
+    makeMinor(): Key;
+    get relativeMajor(): Key;
+    get relativeMinor(): Key;
+    toMajor(): Key;
+    clone(): Key;
+    private ensureGrade;
+    private calculateGradeFromNumber;
+    toChordSymbol(key: Key | string | null, referenceKeyWasMinor?: boolean): Key;
+    toChordSolfege(key: Key | string | null, referenceKeyWasMinor?: boolean): Key;
+    private convertToChordType;
+    private handleMinorKeyConversion;
+    toChordSymbolString(key: Key): string;
+    toChordSolfegeString(key: Key): string;
+    is(type: ChordType): boolean;
+    isNumeric(): boolean;
+    isChordSymbol(): boolean;
+    isChordSolfege(): boolean;
+    isNumeral(): boolean;
+    equals(otherKey: Key): boolean;
+    static equals(oneKey: Key | null, otherKey: Key | null): boolean;
+    toNumeric(key?: Key | string | null): Key;
+    toNumericString(key?: Key | null): string;
+    toNumeral(key?: Key | string | null): Key;
+    toNumeralString(key?: Key | null): string;
+    toString({ showMinor, useUnicodeModifier }?: {
+        showMinor?: boolean | undefined;
+        useUnicodeModifier?: boolean | undefined;
+    }): string;
+    get note(): string;
+    private getNoteForNumber;
+    get minorSign(): "" | "m";
+    private isNaturalMinor;
+    transpose(delta: number): Key;
+    changeGrade(delta: any): Key;
+    transposeUp(): Key;
+    transposeDown(): Key;
+    canBeFlat(): boolean;
+    canBeSharp(): boolean;
+    setGrade(newGrade: number): Key;
+    static shiftGrade(grade: number): number;
+    useAccidental(newAccidental: Accidental | null): Key;
+    /** @deprecated Use useAccidental instead */
+    useModifier(newAccidental: Accidental | null): Key;
+    normalize(): Key;
+    normalizeEnharmonics(key: Key | string | null): Key;
+    private set;
+}
+export default Key;

package/lib/pdf/key_config.d.ts

@@ -0,0 +1,3 @@
+export declare const majorKeys: Record<'symbol' | 'solfege', string[]>;
+export declare const minorKeys: Record<'symbol' | 'solfege', string[]>;
+export declare const capos: Record<'symbol' | 'solfege', Record<string, Record<string, string>>>;

package/lib/pdf/layout/engine/condition.d.ts

@@ -0,0 +1,25 @@
+import { ConditionalRule } from '../../formatter/configuration';
+declare class Condition {
+    rule: ConditionalRule;
+    metadata: Record<string, any>;
+    constructor(rule: ConditionalRule, metadata: Record<string, any>);
+    evaluate(): boolean;
+    private evaluateSingleCondition;
+    private all;
+    private and;
+    private contains;
+    private equals;
+    private exists;
+    private firstPage;
+    private greaterThan;
+    private greaterThanEqual;
+    private in;
+    private lastPage;
+    private lessThan;
+    private lessThanEqual;
+    private like;
+    private notEquals;
+    private notIn;
+    private or;
+}
+export default Condition;

package/lib/pdf/layout/engine/dimensions.d.ts

@@ -0,0 +1,33 @@
+import { ColumnConfig, Margins, MeasurementBasedLayoutConfig } from '../../formatter/configuration';
+declare class Dimensions {
+    pageWidth: number;
+    pageHeight: number;
+    layoutConfig: MeasurementBasedLayoutConfig;
+    columns: ColumnConfig;
+    constructor(pageWidth: number, pageHeight: number, layoutConfig: MeasurementBasedLayoutConfig, columns: ColumnConfig);
+    get margins(): Margins;
+    get minX(): number;
+    get maxX(): number;
+    get minY(): number;
+    get maxY(): number;
+    /**
+     * Calculates the optimal number of columns based on available width and column constraints
+     */
+    calculateOptimalColumnCount(availableWidth: number, columnSpacing: number, minColumnWidth?: number, maxColumnWidth?: number): number;
+    private findMaxColumnsWithinBounds;
+    private evaluateColumnCount;
+    private fitMaxColumnsWithMinWidth;
+    private fitMaxColumns;
+    /**
+     * Calculates the effective column spacing, adjusting it when columns would exceed maxColumnWidth
+     * Note: Single columns are not constrained by maxColumnWidth and use full available width
+     * When only minColumnWidth is specified, columns expand to fill available space equally
+     */
+    calculateEffectiveColumnSpacing(columnCount: number, availableWidth: number, baseColumnSpacing: number, maxColumnWidth?: number, minColumnWidth?: number): number;
+    private calculateAdjustedSpacing;
+    get effectiveColumnCount(): number;
+    get effectiveColumnSpacing(): number;
+    get availableSpace(): number;
+    get columnWidth(): number;
+}
+export default Dimensions;

package/lib/pdf/layout/engine/index.d.ts

@@ -0,0 +1,7 @@
+export { LayoutEngine } from './layout_engine';
+export { ItemProcessor } from './item_processor';
+export { LayoutFactory } from './layout_factory';
+export { LineBreaker } from './line_breaker';
+export * from './layout_helpers';
+export { BreakPoint, MeasuredItem, LineLayout, LayoutConfig, ParagraphLayoutResult, } from './types';
+export { ParagraphSplitter } from './paragraph_splitter';

package/lib/pdf/layout/engine/item_processor.d.ts

@@ -0,0 +1,70 @@
+import ChordLyricsPair from '../../chord_sheet/chord_lyrics_pair';
+import Line from '../../chord_sheet/line';
+import { Measurer } from '../measurement';
+import SoftLineBreak from '../../chord_sheet/soft_line_break';
+import Song from '../../chord_sheet/song';
+import Tag from '../../chord_sheet/tag';
+import { LayoutConfig, MeasuredItem } from './types';
+/**
+ * Processes and measures different types of items in a chord sheet
+ */
+export declare class ItemProcessor {
+    readonly measurer: Measurer;
+    readonly config: LayoutConfig;
+    private readonly song;
+    constructor(measurer: Measurer, config: LayoutConfig, song: Song);
+    /**
+     * Measure all items in a line
+     */
+    measureLineItems(line: Line, lyricsOnly?: boolean): MeasuredItem[];
+    /**
+     * Process a chord-lyrics pair
+     */
+    processChordLyricsPair(pair: ChordLyricsPair, nextItemParam: any, line: Line, lyricsOnly?: boolean): MeasuredItem[];
+    private handleLyricsOnlyMode;
+    private cleanNextItemHyphens;
+    private processSplitItems;
+    private processSingleSplitItem;
+    private measureChordLyricsPair;
+    private getAdjustedChordsAndLyrics;
+    private renderChordText;
+    private calculateMeasurements;
+    private getAdjustedChordWidth;
+    /**
+     * Process a soft line break
+     */
+    processSoftLineBreak(softLineBreak: SoftLineBreak): MeasuredItem;
+    /**
+     * Process a tag (comment or section delimiter)
+     */
+    processTag(tag: Tag): MeasuredItem[];
+    private createMeasuredTagItem;
+    /**
+     * Split a measured item if it doesn't fit in the available width
+     */
+    splitMeasuredItem(item: MeasuredItem, availableWidth: number): [MeasuredItem, MeasuredItem | null];
+    /**
+     * Removes hyphens from lyrics for lyrics-only mode
+     */
+    removeHyphens(lyrics: string): string;
+    /**
+     * Split a chord-lyrics pair at natural break points (commas)
+     */
+    splitChordLyricsPair(pair: ChordLyricsPair, lyricsOnly?: boolean): (ChordLyricsPair | SoftLineBreak)[];
+    /**
+     * Find the next item with lyrics
+     */
+    findNextItemWithLyrics(currentLine: MeasuredItem[], items: MeasuredItem[], index: number): MeasuredItem | null;
+    /**
+     * Capitalize the first word of lyrics
+     */
+    capitalizeFirstWord(lyrics: string): string;
+    /**
+     * Get the width of a space character
+     */
+    private getSpaceWidth;
+    /**
+     * Get chord spacing as a string of spaces
+     */
+    private getChordSpacingAsSpaces;
+}

package/lib/pdf/layout/engine/layout_engine.d.ts

@@ -0,0 +1,67 @@
+import { Measurer } from '../measurement';
+import Song from '../../chord_sheet/song';
+import { LayoutConfig, ParagraphLayoutResult } from './types';
+/**
+ * Engine for layout calculations
+ */
+export declare class LayoutEngine {
+    private song;
+    private measurer;
+    private config;
+    private paragraphSplitter;
+    private itemProcessor;
+    private layoutFactory;
+    private lineBreaker;
+    private sectionCache;
+    constructor(song: Song, measurer: Measurer, config: LayoutConfig);
+    /**
+     * Normalize section label by removing repeat indicators like "(2x)", "(3x)", etc.
+     * @param label The section label to normalize
+     * @returns The normalized label
+     */
+    private normalizeSectionLabel;
+    /**
+     * Get the cache key for a section based on its normalized label
+     * @param paragraph The paragraph to get the cache key for
+     * @returns The cache key or null if the paragraph doesn't have a label
+     */
+    private getSectionCacheKey;
+    private extractLabelFromFirstItem;
+    /**
+     * Process repeated sections by modifying the song's bodyParagraphs array
+     * This is called in the constructor to preprocess the song before layout computation
+     */
+    private processRepeatedSections;
+    private processParagraph;
+    private shouldSkipParagraphIndex;
+    private addUncachedParagraph;
+    private handleParagraphWithCacheKey;
+    private cacheFirstOccurrence;
+    private handleRepeatedSection;
+    private handleTitleOnlyMode;
+    private collectTitleParagraphs;
+    private shouldIncludeTitle;
+    private resolveTitleOnlyParagraph;
+    private handleFullMode;
+    private buildFullModeLines;
+    private consolidateTitles;
+    private addTitleSeparator;
+    private buildTitleSeparatorItems;
+    private createTitleOnlyParagraph;
+    private cloneParagraph;
+    private cloneItem;
+    /**
+     * Compute layouts for all paragraphs in the song
+     */
+    computeParagraphLayouts(): ParagraphLayoutResult[];
+    private processParagraphLayout;
+    private computeLineTypeCounts;
+    private shouldSkipParagraphLayout;
+    private adjustParagraphLayouts;
+    private calculateNextSimulationState;
+    private addParagraphLayout;
+    /**
+     * Compute layout for a single paragraph
+     */
+    private computeParagraphLayout;
+}

package/lib/pdf/layout/engine/layout_factory.d.ts

@@ -0,0 +1,22 @@
+import Line from '../../chord_sheet/line';
+import { LayoutConfig, LineLayout, MeasuredItem } from './types';
+/**
+ * Factory for creating different types of layouts
+ */
+export declare class LayoutFactory {
+    private readonly config;
+    constructor(config: LayoutConfig);
+    /**
+     * Create a line layout from measured items
+     */
+    createLineLayout(items: MeasuredItem[], line: Line): LineLayout;
+    private analyzeLineContent;
+    private determineLineType;
+    private calculateLineHeight;
+    private getBaseHeightAndFont;
+    private addFontHeight;
+    /**
+     * Create a column break line layout
+     */
+    createColumnBreakLayout(): LineLayout;
+}

package/lib/pdf/layout/engine/layout_helpers.d.ts

@@ -0,0 +1,35 @@
+import { LayoutConfig, LineLayout } from './types';
+/**
+ * Create a column break line layout
+ */
+export declare function createColumnBreakLineLayout(): LineLayout;
+/**
+ * Calculate the total height of a set of line layouts
+ */
+export declare function calculateTotalHeight(lineLayouts: LineLayout[][]): number;
+/**
+ * Check if a line layout represents a column break
+ */
+export declare function isColumnBreakLayout(lineLayout: LineLayout[]): boolean;
+/**
+ * Update the position based on layout content
+ */
+export declare function updatePosition(layout: LineLayout[], currentY: number, currentColumn: number, config: LayoutConfig): {
+    newY: number;
+    newColumn: number;
+};
+/**
+ * Count different types of lines within layouts
+ */
+export declare function countLineTypes(lineLayouts: LineLayout[][]): {
+    chordLyricPairLines: number;
+    commentLines: number;
+    sectionLabelLines: number;
+    tagLines: number;
+    emptyLines: number;
+    nonLyricLines: number;
+};
+/**
+ * Determine if a paragraph should be skipped in lyrics-only mode
+ */
+export declare function shouldSkipParagraph(lineLayouts: LineLayout[][], lyricsOnly?: boolean): boolean;

package/lib/pdf/layout/engine/line_breaker.d.ts

@@ -0,0 +1,54 @@
+import { ItemProcessor } from './item_processor';
+import { LayoutFactory } from './layout_factory';
+import Line from '../../chord_sheet/line';
+import { LineLayout } from './types';
+/**
+ * Handles breaking lines into layouts based on available width
+ */
+export declare class LineBreaker {
+    private readonly itemProcessor;
+    private readonly layoutFactory;
+    constructor(itemProcessor: ItemProcessor, layoutFactory: LayoutFactory);
+    /**
+     * Break a line into layouts that fit within the available width
+     */
+    breakLineIntoLayouts(line: Line, availableWidth: number, lyricsOnly?: boolean): LineLayout[];
+    /**
+     * Recursively break content into layouts that fit within the available width
+     */
+    private breakContent;
+    /**
+     * Handle content with no soft breaks
+     */
+    private handleNoSoftBreaks;
+    /**
+     * Consolidate consecutive soft line breaks into single breaks
+     */
+    private consolidateConsecutiveSoftBreaks;
+    private skipConsecutiveSoftBreaks;
+    private findBreakIndex;
+    private handleOversizedFirstItem;
+    private analyzeContent;
+    private shouldReturnSingleLayout;
+    private splitAtBestSoftBreak;
+    private removeTrailingComma;
+    /**
+     * Calculate the total width of items up to (but not including) the given index
+     */
+    private getWidthUpToIndex;
+    /**
+     * Remeasure the width of lyrics after modification
+     */
+    private remeasureLyrics;
+    /**
+     * Recalculate the full chord-lyric pair width (similar to ItemProcessor logic)
+     */
+    private recalculateChordLyricWidth;
+    private measureChordAndLyricWidths;
+    private adjustChordWidth;
+    private shouldSkipChordSpacing;
+    /**
+     * Capitalize the first letter of the next item with lyrics
+     */
+    private capitalizeNextItem;
+}

package/lib/pdf/layout/engine/paragraph_splitter/index.d.ts

@@ -0,0 +1,5 @@
+export { ParagraphSplitter } from './paragraph_splitter';
+export { ParagraphSplitStrategy } from '../types';
+export { ThreeOrLessLinesParagraphSplitStrategy } from './strategies/three_or_less_lines_paragraph_split_strategy';
+export { FourLinesParagraphSplitStrategy } from './strategies/four_lines_paragraph_split_strategy';
+export { FiveOrMoreLinesParagraphSplitStrategy } from './strategies/five_or_more_lines_paragraph_split_strategy';

package/lib/pdf/layout/engine/paragraph_splitter/paragraph_splitter.d.ts

@@ -0,0 +1,5 @@
+import { LineLayout } from '../types';
+export declare class ParagraphSplitter {
+    splitParagraph(lineLayouts: LineLayout[][], currentY: number, columnStartY: number, columnBottomY: number, chordLyricLineCount: number): LineLayout[][];
+    private createStrategy;
+}

package/lib/pdf/layout/engine/paragraph_splitter/strategies/five_or_more_lines_paragraph_split_strategy.d.ts

@@ -0,0 +1,14 @@
+import { LineLayout, ParagraphSplitStrategy } from '../../types';
+export declare class FiveOrMoreLinesParagraphSplitStrategy implements ParagraphSplitStrategy {
+    private chordLyricLineCount;
+    private totalChordLyricPairLines;
+    constructor(chordLyricLineCount: number);
+    splitParagraph(lineLayouts: LineLayout[][], currentY: number, columnStartY: number, columnBottomY: number): LineLayout[][];
+    private trySplitParagraph;
+    private selectSplit;
+    private buildSplitResult;
+    private flattenLineLayouts;
+    private findAcceptableSplits;
+    private partitionLineLayouts;
+    private partitionReducer;
+}

package/lib/pdf/layout/engine/paragraph_splitter/strategies/four_lines_paragraph_split_strategy.d.ts

@@ -0,0 +1,8 @@
+import { LineLayout, ParagraphSplitStrategy } from '../../types';
+export declare class FourLinesParagraphSplitStrategy implements ParagraphSplitStrategy {
+    splitParagraph(lineLayouts: LineLayout[][], currentY: number, columnStartY: number, columnBottomY: number): LineLayout[][];
+    private findSplitMetadata;
+    private summarizeLineLayout;
+    private buildSplitResult;
+    private prependColumnBreakIfNeeded;
+}

package/lib/pdf/layout/engine/paragraph_splitter/strategies/three_or_less_lines_paragraph_split_strategy.d.ts

@@ -0,0 +1,4 @@
+import { LineLayout, ParagraphSplitStrategy } from '../../types';
+export declare class ThreeOrLessLinesParagraphSplitStrategy implements ParagraphSplitStrategy {
+    splitParagraph(lineLayouts: LineLayout[][], currentY: number, columnStartY: number, columnBottomY: number): LineLayout[][];
+}

package/lib/pdf/layout/engine/title_separator_tag.d.ts

@@ -0,0 +1,8 @@
+import Tag from '../../chord_sheet/tag';
+declare class TitleSeparatorTag extends Tag {
+    constructor();
+    get value(): string;
+    set value(newValue: string);
+    clone(): Tag;
+}
+export default TitleSeparatorTag;

package/lib/pdf/layout/engine/types.d.ts

@@ -0,0 +1,98 @@
+import ChordLyricsPair from '../../chord_sheet/chord_lyrics_pair';
+import { FontConfiguration } from '../../formatter/configuration';
+import Line from '../../chord_sheet/line';
+import SoftLineBreak from '../../chord_sheet/soft_line_break';
+import Tag from '../../chord_sheet/tag';
+export interface Measurer {
+    measureTextWidth(text: string, font: {
+        size: number;
+        lineHeight?: number;
+    }): number;
+    measureTextHeight(text: string, font: {
+        size: number;
+        lineHeight?: number;
+    }): number;
+    splitTextToSize(text: string, maxWidth: number, font: {
+        size: number;
+        lineHeight?: number;
+    }): string[];
+}
+/**
+ * Represents a break point in text for line wrapping
+ */
+export interface BreakPoint {
+    index: number;
+    type: 'space' | 'hyphen' | 'comma' | 'other';
+}
+/**
+ * Represents a measured chord-lyrics pair with position information
+ */
+export interface MeasuredItem {
+    item: ChordLyricsPair | Tag | SoftLineBreak | null;
+    width: number;
+    chordHeight?: number;
+    chordLyricWidthDifference?: number;
+}
+/**
+ * Represents a single line in the layout
+ */
+export interface LineLayout {
+    type: 'ChordLyricsPair' | 'Comment' | 'SectionLabel' | 'Tag' | 'Empty';
+    lineHeight: number;
+    items: MeasuredItem[];
+    line: Line;
+}
+/**
+ * Represents a paragraph in the layout
+ */
+/**
+ * Complete layout for a song
+ */
+/**
+ * Configuration for the layout engine
+ */
+export interface LayoutConfig {
+    width: number;
+    fonts: {
+        chord: FontConfiguration;
+        lyrics: FontConfiguration;
+        comment: FontConfiguration;
+        sectionLabel: FontConfiguration;
+    };
+    chordSpacing: number;
+    chordLyricSpacing: number;
+    linePadding: number;
+    useUnicodeModifiers: boolean;
+    normalizeChords: boolean;
+    minY: number;
+    columnWidth: number;
+    columnCount?: number;
+    columnSpacing: number;
+    minColumnWidth?: number;
+    maxColumnWidth?: number;
+    paragraphSpacing: number;
+    columnBottomY: number;
+    displayLyricsOnly?: boolean;
+    decapo: boolean;
+    repeatedSections?: 'hide' | 'title_only' | 'lyrics_only' | 'full';
+}
+export interface ParagraphLayoutResult {
+    units: LineLayout[][];
+    addSpacing: boolean;
+    sectionType: string;
+}
+/**
+ * Strategy interface for paragraph splitting
+ */
+export interface ParagraphSplitStrategy {
+    /**
+     * Split a paragraph into parts that fit within column constraints
+     *
+     * @param lineLayouts - The layout of the paragraph to split
+     * @param currentY - Current vertical position in the column
+     * @param columnStartY - The starting Y position of columns
+     * @param columnBottomY - The bottom Y position of columns
+     * @returns The layout with column breaks inserted as needed
+     */
+    splitParagraph(lineLayouts: LineLayout[][], currentY: number, columnStartY: number, columnBottomY: number): LineLayout[][];
+}

package/lib/pdf/layout/measurement/canvas_measurer.d.ts

@@ -0,0 +1,18 @@
+import { FontConfiguration } from '../../formatter/configuration';
+import { BaseMeasurer, TextDimensions } from './measurer';
+/**
+ * Measures text using Canvas API
+ */
+export declare class CanvasMeasurer extends BaseMeasurer {
+    private canvas;
+    private context;
+    constructor();
+    /**
+     * Sets font configuration on the canvas context
+     * @param fontConfig The font configuration to apply
+     */
+    private setFont;
+    measureText(text: string, fontConfig: FontConfiguration): TextDimensions;
+    splitTextToSize(text: string, maxWidth: number, fontConfig: FontConfiguration): string[];
+    private measureWidth;
+}

package/lib/pdf/layout/measurement/dom_measurer.d.ts

@@ -0,0 +1,21 @@
+import { FontConfiguration } from '../../formatter/configuration';
+import { BaseMeasurer, TextDimensions } from './measurer';
+/**
+ * Measures text using DOM elements
+ */
+export declare class DomMeasurer extends BaseMeasurer {
+    private measureElement;
+    constructor();
+    /**
+     * Cleans up the DOM element when no longer needed
+     */
+    dispose(): void;
+    /**
+     * Sets font configuration on the measurement element
+     * @param fontConfig The font configuration to apply
+     */
+    private setFont;
+    measureText(text: string, fontConfig: FontConfiguration): TextDimensions;
+    splitTextToSize(text: string, maxWidth: number, fontConfig: FontConfiguration): string[];
+    private measureWidth;
+}

package/lib/pdf/layout/measurement/index.d.ts

@@ -0,0 +1,4 @@
+export * from './measurer';
+export * from './js_pdf_measurer';
+export * from './canvas_measurer';
+export * from './dom_measurer';

package/lib/pdf/layout/measurement/js_pdf_measurer.d.ts

@@ -0,0 +1,12 @@
+import DocWrapper from '../../formatter/pdf_formatter/doc_wrapper';
+import { FontConfiguration } from '../../formatter/configuration';
+import { BaseMeasurer, TextDimensions } from './measurer';
+/**
+ * Measures text using jsPDF
+ */
+export declare class JsPdfMeasurer extends BaseMeasurer {
+    private doc;
+    constructor(doc: DocWrapper);
+    measureText(text: string, fontConfig: FontConfiguration): TextDimensions;
+    splitTextToSize(text: string, maxWidth: number, fontConfig: FontConfiguration): string[];
+}