interface HyphenationTrieNode {
    patterns: number[] | null;
    children: {
        [char: string]: HyphenationTrieNode;
    };
}

interface CacheStats {
    size: number;
}
declare class Cache<K, V> {
    private cache;
    get(key: K): V | undefined;
    has(key: K): boolean;
    set(key: K, value: V): void;
    delete(key: K): boolean;
    clear(): void;
    get size(): number;
    keys(): K[];
    getStats(): CacheStats;
}

declare class Vec2 {
    x: number;
    y: number;
    constructor(x?: number, y?: number);
    set(x: number, y: number): Vec2;
    clone(): Vec2;
    copy(v: Vec2): Vec2;
    add(v: Vec2): Vec2;
    sub(v: Vec2): Vec2;
    multiply(scalar: number): Vec2;
    divide(scalar: number): Vec2;
    length(): number;
    lengthSq(): number;
    normalize(): Vec2;
    dot(v: Vec2): number;
    distanceTo(v: Vec2): number;
    distanceToSquared(v: Vec2): number;
    equals(v: Vec2): boolean;
    angle(): number;
}
declare class Vec3 {
    x: number;
    y: number;
    z: number;
    constructor(x?: number, y?: number, z?: number);
    set(x: number, y: number, z: number): Vec3;
    clone(): Vec3;
    copy(v: Vec3): Vec3;
    add(v: Vec3): Vec3;
    sub(v: Vec3): Vec3;
    multiply(scalar: number): Vec3;
    divide(scalar: number): Vec3;
    length(): number;
    lengthSq(): number;
    normalize(): Vec3;
    dot(v: Vec3): number;
    cross(v: Vec3): Vec3;
    distanceTo(v: Vec3): number;
    distanceToSquared(v: Vec3): number;
    equals(v: Vec3): boolean;
}
interface BoundingBox {
    min: {
        x: number;
        y: number;
        z: number;
    };
    max: {
        x: number;
        y: number;
        z: number;
    };
}

interface HarfBuzzGlyph {
    g: number;
    cl: number;
    ax: number;
    ay: number;
    dx: number;
    dy: number;
    x?: number;
    y?: number;
    lineIndex: number;
    absoluteTextIndex: number;
}
interface GlyphCluster {
    text: string;
    glyphs: HarfBuzzGlyph[];
    position: Vec3;
}
type TextAlign = 'left' | 'center' | 'right' | 'justify';
type TextDirection = 'ltr' | 'rtl';
interface LineInfo {
    text: string;
    originalStart: number;
    originalEnd: number;
    xOffset: number;
    adjustmentRatio?: number;
    isLastLine?: boolean;
    naturalWidth?: number;
    endedWithHyphen?: boolean;
}
interface LoadedFont {
    hb: HarfBuzzAPI;
    fontBlob: HarfBuzzBlob;
    face: HarfBuzzFace;
    font: HarfBuzzFont;
    module: HarfBuzzModule;
    upem: number;
    metrics: ExtractedMetrics;
    fontVariations?: {
        [key: string]: number;
    };
    fontFeatures?: {
        [tag: string]: boolean | number;
    };
    isVariable?: boolean;
    variationAxes?: {
        [key: string]: VariationAxis;
    };
    availableFeatures?: string[];
    featureNames?: {
        [tag: string]: string;
    };
    _buffer?: ArrayBuffer;
}
interface HarfBuzzModule {
    addFunction: (func: Function, signature: string) => number;
    exports: any;
    removeFunction: (ptr: number) => void;
}
interface VariationAxis {
    min: number;
    default: number;
    max: number;
    name?: string;
}
interface HarfBuzzAPI {
    createBlob: (data: Uint8Array) => HarfBuzzBlob;
    createFace: (blob: HarfBuzzBlob, index: number) => HarfBuzzFace;
    createFont: (face: HarfBuzzFace) => HarfBuzzFont;
    createBuffer: () => HarfBuzzBuffer;
    shape: (font: HarfBuzzFont, buffer: HarfBuzzBuffer, features?: string) => void;
}
interface HarfBuzzBlob {
    destroy: () => void;
}
interface HarfBuzzFace {
    destroy: () => void;
    getAxisInfos: () => {
        [tag: string]: VariationAxis;
    };
}
interface HarfBuzzFont {
    ptr: number;
    destroy: () => void;
    setScale: (xScale: number, yScale: number) => void;
    setVariations: (variations: {
        [key: string]: number;
    }) => void;
}
interface HarfBuzzBuffer {
    addText: (text: string) => void;
    guessSegmentProperties: () => void;
    setDirection: (direction: string) => void;
    json: (font: HarfBuzzFont) => any[];
    destroy: () => void;
}
interface HarfBuzzInstance {
    hb: HarfBuzzAPI;
    module: HarfBuzzModule;
}
interface ExtractedMetrics {
    isCFF: boolean;
    unitsPerEm: number;
    hheaAscender: number | null;
    hheaDescender: number | null;
    hheaLineGap: number | null;
    typoAscender: number | null;
    typoDescender: number | null;
    typoLineGap: number | null;
    winAscent: number | null;
    winDescent: number | null;
    axisNames: {
        [tag: string]: string;
    } | null;
}
interface VerticalMetrics {
    ascender: number;
    descender: number;
    lineGap: number;
}
interface FontMetrics {
    ascender: number;
    descender: number;
    lineGap: number;
    unitsPerEm: number;
    naturalLineHeight: number;
}
interface Triangles {
    vertices: number[];
    indices: number[];
}
interface ProcessedGeometry {
    triangles: Triangles;
    contours: number[][];
    contoursAreBoundary?: boolean;
}
interface GlyphData {
    geometry: ProcessedGeometry;
    vertices: Float32Array;
    normals: Float32Array;
    indices: Uint32Array;
    bounds: {
        min: {
            x: number;
            y: number;
            z: number;
        };
        max: {
            x: number;
            y: number;
            z: number;
        };
    };
    useCount: number;
}
interface PathInfo {
    start: number;
    count: number;
}
interface GlyphGeometryInfo {
    textIndex: number;
    lineIndex: number;
    vertexStart: number;
    vertexCount: number;
    bounds: {
        min: {
            x: number;
            y: number;
            z: number;
        };
        max: {
            x: number;
            y: number;
            z: number;
        };
    };
    paths?: PathInfo[];
}
interface TextRange {
    start: number;
    end: number;
    originalText: string;
    bounds: {
        min: {
            x: number;
            y: number;
            z: number;
        };
        max: {
            x: number;
            y: number;
            z: number;
        };
    }[];
    glyphs: GlyphGeometryInfo[];
    lineIndices: number[];
}
interface TextQueryOptions {
    byText?: string[];
    byCharRange?: {
        start: number;
        end: number;
    }[];
}
interface TextGeometryInfo {
    vertices: Float32Array;
    normals: Float32Array;
    indices: Uint32Array;
    colors?: Float32Array;
    glyphAttributes?: {
        glyphCenter: Float32Array;
        glyphIndex: Float32Array;
        glyphLineIndex: Float32Array;
        glyphProgress: Float32Array;
        glyphBaselineY: Float32Array;
    };
    glyphs: GlyphGeometryInfo[];
    planeBounds: BoundingBox;
    stats: {
        trianglesGenerated: number;
        verticesGenerated: number;
        pointsRemovedByVisvalingam: number;
        originalPointCount: number;
    } & Partial<CacheStats & {
        hitRate: number;
        memoryUsageMB: number;
    }>;
    query(options: TextQueryOptions): TextRange[];
    coloredRanges?: ColoredRange[];
}
interface TextHandle extends TextGeometryInfo {
    getLoadedFont(): LoadedFont | undefined;
    getCacheSize(): number;
    clearCache(): void;
    measureTextWidth(text: string, letterSpacing?: number): number;
    update(options: Partial<TextOptions>): Promise<TextHandle>;
}
type OutlineSegmentType = 0 | 1 | 2;
interface OutlineSegment {
    type: OutlineSegmentType;
    contourId: number;
    p0: Vec2;
    p1: Vec2;
    p2?: Vec2;
    p3?: Vec2;
}
interface GlyphOutline {
    glyphId: number;
    textIndex: number;
    segments: OutlineSegment[];
    bounds: {
        min: {
            x: number;
            y: number;
        };
        max: {
            x: number;
            y: number;
        };
    };
}
interface TextLayoutData {
    lines: LineInfo[];
    scaledLineHeight: number;
    letterSpacing: number;
    align: string;
    direction: TextDirection;
    depth: number;
    size: number;
    pixelsPerFontUnit: number;
}
interface TextLayoutResult {
    clustersByLine: GlyphCluster[][];
    layoutData: TextLayoutData;
    options: TextOptions;
    loadedFont: LoadedFont;
    fontId: string;
}
interface TextLayoutHandle extends TextLayoutResult {
    getLoadedFont(): LoadedFont | undefined;
    measureTextWidth(text: string, letterSpacing?: number): number;
    update(options: Partial<TextOptions>): Promise<TextLayoutHandle>;
    dispose(): void;
}
interface ColorByRange {
    start: number;
    end: number;
    color: [number, number, number];
}
interface ColorOptions {
    default?: [number, number, number];
    byText?: {
        [text: string]: [number, number, number];
    };
    byCharRange?: ColorByRange[];
}
interface ColoredRange {
    start: number;
    end: number;
    originalText: string;
    color: [number, number, number];
    bounds: {
        min: {
            x: number;
            y: number;
            z: number;
        };
        max: {
            x: number;
            y: number;
            z: number;
        };
    }[];
    glyphs: GlyphGeometryInfo[];
    lineIndices: number[];
}
interface TextOptions {
    text: string;
    font: string | ArrayBuffer;
    size?: number;
    depth?: number;
    lineHeight?: number;
    letterSpacing?: number;
    perGlyphAttributes?: boolean;
    fontVariations?: {
        [key: string]: number;
    };
    fontFeatures?: {
        [tag: string]: boolean | number;
    };
    maxTextLength?: number;
    removeOverlaps?: boolean;
    curveSteps?: number;
    curveFidelity?: CurveFidelityConfig;
    geometryOptimization?: GeometryOptimizationOptions;
    layout?: LayoutOptions;
    color?: [number, number, number] | ColorOptions;
    /** Enable rotated RGSS-4 adaptive supersampling (4 samples per pixel). Takes effect when the GLSL rendering path is active. */
    adaptiveSupersampling?: boolean;
}
interface HyphenationPatternsMap {
    [language: string]: HyphenationTrieNode;
}
interface CurveFidelityConfig {
    distanceTolerance?: number;
    angleTolerance?: number;
    cuspLimit?: number;
    collinearityEpsilon?: number;
    recursionLimit?: number;
}
interface GeometryOptimizationOptions {
    enabled?: boolean;
    areaThreshold?: number;
}
interface LayoutOptions {
    width?: number;
    align?: TextAlign;
    direction?: TextDirection;
    respectExistingBreaks?: boolean;
    hyphenate?: boolean;
    language?: string;
    patternsPath?: string;
    tolerance?: number;
    pretolerance?: number;
    emergencyStretch?: number;
    autoEmergencyStretch?: number;
    hyphenationPatterns?: HyphenationPatternsMap;
    lefthyphenmin?: number;
    righthyphenmin?: number;
    linepenalty?: number;
    adjdemerits?: number;
    hyphenpenalty?: number;
    exhyphenpenalty?: number;
    doublehyphendemerits?: number;
}

declare global {
    interface Window {
        hbjs?: any;
        createHarfBuzz?: () => Promise<any>;
    }
}
declare class Text {
    private static patternCache;
    private static hbInitPromise;
    private static fontCache;
    private static fontLoadPromises;
    private static fontRefCounts;
    private static fontCacheMemoryBytes;
    private static maxFontCacheMemoryBytes;
    private static fontIdCounter;
    static enableWoff2(decoder: (data: ArrayBuffer | Uint8Array) => Uint8Array | Promise<Uint8Array>): void;
    private static stableStringify;
    private fontLoader;
    private loadedFont?;
    private currentFontId;
    private currentFontCacheKey?;
    private textShaper?;
    private textLayout?;
    private constructor();
    static setHarfBuzzPath(path: string): void;
    static setHarfBuzzBuffer(wasmBuffer: ArrayBuffer): void;
    static init(): Promise<HarfBuzzInstance>;
    static create(options: TextOptions): Promise<TextLayoutHandle>;
    private static retainFont;
    private static releaseFont;
    private static resolveFont;
    private static loadAndCacheFont;
    private static trackFontCacheAdd;
    private static trackFontCacheRemove;
    private static enforceFontCacheMemoryLimit;
    private static generateFontContentHash;
    private setLoadedFont;
    private releaseCurrentFont;
    private loadFont;
    private createLayout;
    private prepareHyphenation;
    private validateOptions;
    private updateFontVariations;
    private prepareLayout;
    getFontMetrics(): FontMetrics;
    static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
    static registerPattern(language: string, pattern: HyphenationTrieNode): void;
    static setMaxFontCacheMemoryMB(limitMB: number): void;
    getLoadedFont(): LoadedFont | undefined;
    measureTextWidth(text: string, letterSpacing?: number): number;
    private resetHelpers;
    destroy(): void;
}

declare class MeshGeometryBuilder {
    private geometryBuilder?;
    private textLayout?;
    private loadedFont;
    private fontId;
    constructor(loadedFont: LoadedFont, fontId: string);
    setFont(loadedFont: LoadedFont, fontId: string): void;
    build(layout: TextLayoutResult, options: TextOptions): TextGeometryInfo;
    getCacheSize(): number;
    clearCache(): void;
    reset(): void;
    private finalizeGeometry;
    private applyColorSystem;
    private calculateGlyphBounds;
    private createGlyphAttributes;
}

/**
 * @license
 * Anti-Grain Geometry - Version 2.4
 * Copyright (C) 2002-2005 Maxim Shemanarev (McSeem)
 *
 * This software is a partial port of the AGG library, specifically the adaptive
 * subdivision algorithm for polygonization. The original software was available
 * at http://www.antigrain.com and was distributed under the BSD 3-Clause License
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

declare const DEFAULT_CURVE_FIDELITY: CurveFidelityConfig;

interface FontDataExtraction {
    metrics: ExtractedMetrics;
    features: {
        tags: string[];
        names: {
            [tag: string]: string;
        };
    } | undefined;
}
declare class FontMetadataExtractor {
    static extractMetadata(fontBuffer: ArrayBuffer): ExtractedMetrics;
    static extractFeatureTags(fontBuffer: ArrayBuffer): {
        tags: string[];
        names: {
            [tag: string]: string;
        };
    } | undefined;
    private static extractFeatureDataFromTable;
    private static extractAxisNames;
    private static getNameFromNameTable;
    static extractAll(fontBuffer: ArrayBuffer): FontDataExtraction;
    private static buildNameIndex;
    private static getNameFromIndex;
    private static extractMetricsWithIndex;
    private static extractAxisNamesWithIndex;
    private static extractFeaturesWithIndex;
    private static extractFeatureData;
    private static tagToString;
    static getVerticalMetrics(metrics: ExtractedMetrics): VerticalMetrics;
    static getFontMetrics(metrics: ExtractedMetrics): FontMetrics;
}

declare const globalGlyphCache: Cache<string, GlyphData>;
declare function createGlyphCache(): Cache<string, GlyphData>;
declare const globalOutlineCache: Cache<string, GlyphOutline>;

interface GlyphDrawCollector {
    setPosition(x: number, y: number): void;
    updatePosition(dx: number, dy: number): void;
    onMoveTo(x: number, y: number): void;
    onLineTo(x: number, y: number): void;
    onQuadTo(cx: number, cy: number, x: number, y: number): void;
    onCubicTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): void;
    onClosePath(): void;
}
declare class DrawCallbackHandler {
    private moveTo_func;
    private lineTo_func;
    private quadTo_func;
    private cubicTo_func;
    private closePath_func;
    private drawFuncsPtr;
    private collector?;
    private position;
    setPosition(x: number, y: number): void;
    updatePosition(dx: number, dy: number): void;
    setCollector(collector: GlyphDrawCollector): void;
    createDrawFuncs(font: LoadedFont, collector: GlyphDrawCollector): void;
    getDrawFuncsPtr(): number;
    destroy(font: LoadedFont): void;
}
declare function getSharedDrawCallbackHandler(font: LoadedFont): DrawCallbackHandler;

declare class TextRangeQuery {
    private text;
    private glyphsByTextIndex;
    constructor(text: string, glyphs: GlyphGeometryInfo[]);
    execute(options: TextQueryOptions): TextRange[];
    private findByText;
    private findByCharRange;
    private createTextRange;
    private calculateBounds;
}

export { CacheStats, ColorByRange, ColorOptions, ColoredRange, CurveFidelityConfig, DEFAULT_CURVE_FIDELITY, DrawCallbackHandler, ExtractedMetrics, FontMetadataExtractor, FontMetrics, GeometryOptimizationOptions, GlyphCluster, GlyphData, GlyphDrawCollector, GlyphGeometryInfo, HarfBuzzAPI, HarfBuzzBlob, HarfBuzzBuffer, HarfBuzzFace, HarfBuzzFont, HarfBuzzInstance, HarfBuzzModule, HyphenationPatternsMap, HyphenationTrieNode, LayoutOptions, LineInfo, LoadedFont, MeshGeometryBuilder, PathInfo, ProcessedGeometry, Text, TextAlign, TextDirection, TextGeometryInfo, TextHandle, TextLayoutData, TextLayoutHandle, TextLayoutResult, TextOptions, TextQueryOptions, TextRange, TextRangeQuery, Triangles, VariationAxis, VerticalMetrics, createGlyphCache, getSharedDrawCallbackHandler, globalGlyphCache, globalOutlineCache };