import { Box } from './box.js';
import { Style, Color, TextAlign } from './cascade.js';
import { IfcInline, Inline, BlockContainer, LayoutContext, IfcVacancy } from './flow.js';
import type { FaceMatch } from './font.js';
import type { HbFont, AllocatedUint16Array } from './harfbuzz.js';
export declare function nextGrapheme(text: string, index: number): number;
export declare function prevGrapheme(text: string, index: number): number;
export declare class Run extends Box {
    start: number;
    end: number;
    text: string;
    constructor(text: string, style: Style);
    get sym(): string;
    setRange(start: number, end: number): void;
    shift(n: number): void;
    isRun(): this is Run;
    get desc(): string;
    get wsCollapsible(): boolean;
    get sgUncollapsible(): boolean;
    get sgCollapsible(): boolean;
    mod(start: number, end: number, s: string): number;
    allCollapsible(): boolean;
}
export declare class Collapser {
    buf: string;
    runs: Run[];
    constructor(buf: string, runs: Run[]);
    mod(start: number, end: number, s: string): number;
    collapsibleRanges(filter: 'sgCollapsible' | 'wsCollapsible' | 'sgUncollapsible'): Generator<Run[], void, unknown>;
    modRanges(ranges: [number, number, string][]): void;
    stepOne(): void;
    stepTwo(): void;
    stepThree(): void;
    stepFour(): void;
    collapse(): void;
}
export type ShapingAttrs = {
    isEmoji: boolean;
    level: number;
    script: string;
    style: Style;
};
export declare function getFontMetrics(inline: Inline): InlineMetrics;
export declare const G_ID = 0;
export declare const G_CL = 1;
export declare const G_AX = 2;
export declare const G_AY = 3;
export declare const G_DX = 4;
export declare const G_DY = 5;
export declare const G_FL = 6;
export declare const G_SZ = 7;
export declare function langForScript(script: string): string;
export declare function getMetrics(style: Style, match: FaceMatch): InlineMetrics;
export declare function nextCluster(glyphs: Int32Array, index: number): number;
export declare function prevCluster(glyphs: Int32Array, index: number): number;
interface IfcRenderItem {
    end(): number;
    inlines: Inline[];
    attrs: ShapingAttrs;
}
declare class ShapedShim implements IfcRenderItem {
    offset: number;
    inlines: Inline[];
    attrs: ShapingAttrs;
    constructor(offset: number, inlines: Inline[], attrs: ShapingAttrs);
    end(): number;
}
type MeasureState = {
    glyphIndex: number;
    characterIndex: number;
    clusterStart: number;
    clusterEnd: number;
    clusterAdvance: number;
    isInk: boolean;
    done: boolean;
};
export type InlineMetrics = {
    ascenderBox: number;
    ascender: number;
    superscript: number;
    xHeight: number;
    subscript: number;
    descender: number;
    descenderBox: number;
};
export declare const EmptyInlineMetrics: Readonly<InlineMetrics>;
export declare class ShapedItem implements IfcRenderItem {
    paragraph: Paragraph;
    match: FaceMatch;
    glyphs: Int32Array;
    offset: number;
    length: number;
    attrs: ShapingAttrs;
    inlines: Inline[];
    constructor(paragraph: Paragraph, match: FaceMatch, glyphs: Int32Array, offset: number, length: number, attrs: ShapingAttrs);
    clone(): ShapedItem;
    split(offset: number): {
        needsReshape: boolean;
        right: ShapedItem;
    };
    reshape(walkBackwards: boolean): void;
    createMeasureState(direction?: 1 | -1): {
        glyphIndex: number;
        characterIndex: number;
        clusterStart: number;
        clusterEnd: number;
        clusterAdvance: number;
        isInk: boolean;
        done: boolean;
    };
    nextCluster(direction: 1 | -1, state: MeasureState): void;
    measureInsideCluster(state: MeasureState, ci: number): number;
    measure(ci?: number, direction?: 1 | -1, state?: {
        glyphIndex: number;
        characterIndex: number;
        clusterStart: number;
        clusterEnd: number;
        clusterAdvance: number;
        isInk: boolean;
        done: boolean;
    }): {
        advance: number;
        trailingWs: number;
    };
    collapseWhitespace(at: 'start' | 'end'): true | undefined;
    colorsStart(colors: [Color, number][]): number;
    colorsEnd(colors: [Color, number][]): number;
    end(): number;
    text(): string;
}
type LineItem = {
    value: ShapedItem | ShapedShim;
    next: LineItem | null;
    previous: LineItem | null;
};
declare class LineItemLinkedList {
    head: LineItem | null;
    tail: LineItem | null;
    constructor();
    clear(): void;
    transfer(): LineItemLinkedList;
    concat(items: LineItemLinkedList): void;
    rconcat(items: LineItemLinkedList): void;
    push(value: LineItem['value']): void;
    unshift(value: LineItem['value']): void;
    reverse(): void;
}
declare class LineWidthTracker {
    private inkSeen;
    private startWs;
    private startWsC;
    private ink;
    private endWs;
    private endWsC;
    private hyphen;
    constructor();
    addInk(width: number): void;
    addWs(width: number, isCollapsible: boolean): void;
    addHyphen(width: number): void;
    concat(width: LineWidthTracker): void;
    forFloat(): number;
    forWord(): number;
    asWord(): number;
    trimmed(): number;
    reset(): void;
}
export declare function baselineStep(parent: Inline, inline: Inline): number;
declare class AlignmentContext {
    ascender: number;
    descender: number;
    baselineShift: number;
    constructor(arg: InlineMetrics | AlignmentContext);
    stampMetrics(metrics: InlineMetrics): void;
    extend(ctx: AlignmentContext): void;
    stepIn(parent: Inline, inline: Inline): void;
    stepOut(parent: Inline, inline: Inline): void;
    reset(): void;
}
declare class LineCandidates extends LineItemLinkedList {
    width: LineWidthTracker;
    height: LineHeightTracker;
    constructor(ifc: IfcInline);
    clearContents(): void;
}
declare class LineHeightTracker {
    ifc: IfcInline;
    stack: Inline[];
    contextStack: AlignmentContext[];
    contextRoots: Map<Inline, AlignmentContext>;
    markedContextRoots: Inline[];
    ascender: number;
    descender: number;
    constructor(ifc: IfcInline);
    stampMetrics(metrics: InlineMetrics): void;
    pushInline(inline: Inline): void;
    popInline(): void;
    concat(height: LineHeightTracker): void;
    align(): {
        ascender: number;
        descender: number;
    };
    total(): number;
    totalWith(height: LineHeightTracker): number;
    reset(): void;
    clearContents(): void;
}
export declare class Linebox extends LineItemLinkedList {
    startOffset: number;
    paragraph: Paragraph;
    ascender: number;
    descender: number;
    endOffset: number;
    blockOffset: number;
    inlineOffset: number;
    width: number;
    contextRoots: Map<Inline, AlignmentContext>;
    constructor(start: number, paragraph: Paragraph);
    addCandidates(candidates: LineCandidates, endOffset: number): void;
    hasText(): boolean;
    hasAnything(): boolean;
    end(): number;
    height(): number;
    trimStart(): void;
    trimEnd(): void;
    reorderRange(start: LineItem | null, length: number): LineItemLinkedList;
    reorder(): void;
    postprocess(width: LineWidthTracker, height: LineHeightTracker, vacancy: IfcVacancy, textAlign: TextAlign): void;
}
type IfcMark = {
    position: number;
    isBreak: boolean;
    isBreakForced: boolean;
    isItemStart: boolean;
    isItemEnd: boolean;
    inlinePre: Inline | null;
    inlinePost: Inline | null;
    float: BlockContainer | null;
    advance: number;
    trailingWs: number;
    itemIndex: number;
    split: (this: IfcMark, mark: IfcMark) => void;
};
export declare function clearWordCache(): void;
export declare class Paragraph {
    ifc: IfcInline;
    string: string;
    buffer: AllocatedUint16Array;
    brokenItems: ShapedItem[];
    wholeItems: ShapedItem[];
    lineboxes: Linebox[];
    height: number;
    constructor(ifc: IfcInline, buffer: AllocatedUint16Array);
    destroy(): void;
    slice(start: number, end: number): string;
    split(itemIndex: number, offset: number): void;
    isInsideGraphemeBoundary(offset: number): boolean;
    length(): number;
    nlIterator(): {
        next(): {
            done: true;
        } | {
            done: false;
            value: {
                i: number;
            };
        };
    };
    itemize(): Generator<{
        i: number;
        attrs: ShapingAttrs;
    }, void, unknown>;
    shapePartWithWordCache(offset: number, length: number, font: HbFont, attrs: ShapingAttrs): Int32Array;
    shapePartWithoutWordCache(offset: number, length: number, font: HbFont, attrs: ShapingAttrs): Int32Array;
    shapePart(offset: number, length: number, match: FaceMatch, attrs: ShapingAttrs): Int32Array;
    getColors(): [Color, number][];
    shape(): void;
    createMarkIterator(): {
        next: () => {
            done: true;
        } | {
            done: false;
            value: IfcMark;
        };
    };
    createLineboxes(ctx: LayoutContext): void;
}
export declare function createParagraph(ifc: IfcInline): Paragraph;
export declare function createEmptyParagraph(ifc: IfcInline): Paragraph;
export {};