modern-font/dist/index.d.mts

JavaScript Font Codec.

type DataType = 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32' | 'float32' | 'float64' | 'fixed' | 'longDateTime' | 'char';
declare const dataTypeToByteLength: Record<DataType, number>;
interface Column {
    name: string;
    type: DataType;
    offset: number;
    byteLength: number;
    size?: number;
    default?: any;
}
declare class FontDataView extends DataView<ArrayBuffer> {
    littleEndian?: boolean | undefined;
    cursor: number;
    readInt8: (byteOffset?: number) => number;
    readInt16: (byteOffset?: number, littleEndian?: boolean) => number;
    readInt32: (byteOffset?: number, littleEndian?: boolean) => number;
    readUint8: (byteOffset?: number) => number;
    readUint16: (byteOffset?: number, littleEndian?: boolean) => number;
    readUint32: (byteOffset?: number, littleEndian?: boolean) => number;
    readFloat32: (byteOffset?: number, littleEndian?: boolean) => number;
    readFloat64: (byteOffset?: number, littleEndian?: boolean) => number;
    writeInt8: (value: number, byteOffset?: number) => this;
    writeInt16: (value: number, byteOffset?: number, littleEndian?: boolean) => this;
    writeInt32: (value: number, byteOffset?: number, littleEndian?: boolean) => this;
    writeUint8: (value: number, byteOffset?: number) => this;
    writeUint16: (value: number, byteOffset?: number, littleEndian?: boolean) => this;
    writeUint32: (value: number, byteOffset?: number, littleEndian?: boolean) => this;
    writeFloat32: (value: number, byteOffset?: number, littleEndian?: boolean) => this;
    writeFloat64: (value: number, byteOffset?: number, littleEndian?: boolean) => this;
    constructor(source: BufferSource, byteOffset?: number, byteLength?: number, littleEndian?: boolean | undefined);
    readColumn(column: Column): any;
    writeColumn(column: Column, value: any): any;
    read(type: DataType, byteOffset?: number, littleEndian?: boolean | undefined): any;
    readUint24(byteOffset?: number): number;
    readBytes(byteOffset: number, length?: number): number[];
    readString(byteOffset: number, length?: number): string;
    readFixed(byteOffset?: number, littleEndian?: boolean): number;
    readLongDateTime(byteOffset?: number, littleEndian?: boolean): Date;
    readChar(byteOffset: number): string;
    write(type: DataType, value: any, byteOffset?: number, littleEndian?: boolean | undefined): any;
    writeString(str?: string, byteOffset?: number): this;
    writeChar(value: string, byteOffset?: number): this;
    writeFixed(value: number, byteOffset?: number): this;
    writeLongDateTime(value: any, byteOffset?: number): this;
    writeBytes(value: BufferSource | number[], byteOffset?: number): this;
    seek(byteOffset: number): this;
}

type ColumnOptions = DataType | (Partial<Column> & {
    type: DataType;
});
interface FontDataViewDefinition {
    columns: Column[];
    byteLength: number;
}
declare function defineColumn(options: ColumnOptions): (target: any, name: PropertyKey) => void;
declare class FontDataObject {
    view: FontDataView;
    constructor(source: BufferSource, byteOffset?: number, byteLength?: number, littleEndian?: boolean);
}

declare abstract class BaseFont extends FontDataObject {
    abstract format: string;
    abstract mimeType: string;
    get buffer(): ArrayBuffer;
    toBuffer(): ArrayBuffer;
    toBlob(): Blob;
    toFontFace(family: string): FontFace;
}

declare class TableDirectory extends FontDataObject {
    tag: string;
    checkSum: number;
    offset: number;
    length: number;
    constructor(buffer: BufferSource, byteOffset?: number);
}

declare class SFNTTable extends FontDataObject {
    protected _sfnt: SFNT;
    setSFNT(sfnt: SFNT): this;
    getSFNT(): SFNT;
}

interface CmapSubtable {
    platformID: number;
    platformSpecificID: number;
    offset: number;
}
/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6cmap.html
 */
declare class Cmap extends SFNTTable {
    version: number;
    numberSubtables: number;
    static from(unicodeToGlyphIndexMap: Map<number, number>): Cmap;
    _unicodeToGlyphIndexMap?: Map<number, number>;
    get unicodeToGlyphIndexMap(): Map<number, number>;
    _glyphIndexToUnicodesMap?: Map<number, number[]>;
    get glyphIndexToUnicodesMap(): Map<number, number[]>;
    readSubtables(): (CmapSubtable & {
        format: number;
        view: any;
    })[];
    readunicodeToGlyphIndexMap(): Map<number, number>;
}

interface GlyphPoint {
    x: number;
    y: number;
    onCurve?: boolean;
    lastPointOfContour?: boolean;
}
declare class GlyfGlyph extends Glyph {
    numberOfContours: number;
    xMin: number;
    xMax: number;
    yMin: number;
    yMax: number;
    endPointIndices: number[];
    instructionLength: number;
    instructions: number[];
    points: GlyphPoint[];
    protected _parseContours(points: GlyphPoint[]): GlyphPoint[][];
    protected _transformPoints(points: GlyphPoint[], transform: Omit<GlyphComponent, 'glyphIndex'>): GlyphPoint[];
    protected _parseGlyphCoordinate(glyf: Glyf, flag: number, previousValue: number, shortVectorBitMask: number, sameBitMask: number): number;
    parse(glyf: Glyf, offset: number, glyphs: GlyfGlyphSet): void;
}

type GlyphOrLoader = Glyph | undefined;
declare abstract class GlyphSet {
    protected _sfnt: SFNT;
    protected _items: GlyphOrLoader[];
    constructor(_sfnt: SFNT);
    protected abstract _get(index: number): Glyph;
    get(index: number): Glyph;
}

declare class GlyfGlyphSet extends GlyphSet {
    get length(): number;
    protected _get(index: number): GlyfGlyph;
}

declare const componentFlags: {
    ARG_1_AND_2_ARE_WORDS: number;
    ARGS_ARE_XY_VALUES: number;
    ROUND_XY_TO_GRID: number;
    WE_HAVE_A_SCALE: number;
    RESERVED: number;
    MORE_COMPONENTS: number;
    WE_HAVE_AN_X_AND_Y_SCALE: number;
    WE_HAVE_A_TWO_BY_TWO: number;
    WE_HAVE_INSTRUCTIONS: number;
    USE_MY_METRICS: number;
    OVERLAP_COMPOUND: number;
    SCALED_COMPONENT_OFFSET: number;
    UNSCALED_COMPONENT_OFFSET: number;
};
/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6glyf.html
 */
declare class Glyf extends SFNTTable {
    static from(glyphs: DataView[]): Glyf;
    protected _glyphs?: GlyfGlyphSet;
    get glyphs(): GlyfGlyphSet;
}

/**
 * @link https://learn.microsoft.com/zh-cn/typography/opentype/spec/gpos
 */
declare class Gpos extends SFNTTable {
}

/**
 * @link https://learn.microsoft.com/zh-cn/typography/opentype/spec/gsub
 */
declare class Gsub extends SFNTTable {
    majorVersion: number;
    minorVersion: number;
    scriptListOffset: number;
    featureListOffset: number;
    lookupListOffset: number;
    featureVariationsOffset: number;
}

/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6head.html
 */
declare class Head extends SFNTTable {
    version: number;
    fontRevision: number;
    checkSumAdjustment: number;
    magickNumber: number;
    flags: number;
    unitsPerEm: number;
    created: Date;
    modified: Date;
    xMin: number;
    yMin: number;
    xMax: number;
    yMax: number;
    macStyle: number;
    lowestRecPPEM: number;
    fontDirectionHint: number;
    indexToLocFormat: number;
    glyphDataFormat: number;
    constructor(buffer?: BufferSource, byteOffset?: number);
}

/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6hhea.html
 */
declare class Hhea extends SFNTTable {
    version: number;
    ascent: number;
    descent: number;
    lineGap: number;
    advanceWidthMax: number;
    minLeftSideBearing: number;
    minRightSideBearing: number;
    xMaxExtent: number;
    caretSlopeRise: number;
    caretSlopeRun: number;
    caretOffset: number;
    reserved: number[];
    metricDataFormat: number;
    numOfLongHorMetrics: number;
    constructor(buffer?: BufferSource, byteOffset?: number);
}

interface HMetric {
    advanceWidth: number;
    leftSideBearing: number;
}
/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6hmtx.html
 */
declare class Hmtx extends SFNTTable {
    static from(metrics: HMetric[]): Hmtx;
    protected _metrics?: HMetric[];
    get metrics(): HMetric[];
    readMetrics(): HMetric[];
}

/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6kern.html
 */
declare class Kern extends SFNTTable {
}

/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6loca.html
 */
declare class Loca extends SFNTTable {
    static from(locations: number[], indexToLocFormat?: number): Loca;
    protected _locations?: number[];
    get locations(): number[];
    readLocations(): number[];
}

/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6maxp.html
 */
declare class Maxp extends SFNTTable {
    version: number;
    numGlyphs: number;
    maxPoints: number;
    maxContours: number;
    maxComponentPoints: number;
    maxComponentContours: number;
    maxZones: number;
    maxTwilightPoints: number;
    maxStorage: number;
    maxFunctionDefs: number;
    maxInstructionDefs: number;
    maxStackElements: number;
    maxSizeOfInstructions: number;
    maxComponentElements: number;
    maxComponentDepth: number;
    constructor(buffer?: BufferSource, byteOffset?: number);
}

/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6name.html
 */
declare class Name extends SFNTTable {
    format: number;
    count: number;
    stringOffset: number;
    protected _names?: Record<string, any>;
    get names(): Record<string, any>;
    readNames(): Record<string, any>;
}

/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6OS2.html
 */
declare class Os2 extends SFNTTable {
    version: number;
    xAvgCharWidth: number;
    usWeightClass: number;
    usWidthClass: number;
    fsType: number;
    ySubscriptXSize: number;
    ySubscriptYSize: number;
    ySubscriptXOffset: number;
    ySubscriptYOffset: number;
    ySuperscriptXSize: number;
    ySuperscriptYSize: number;
    ySuperscriptXOffset: number;
    ySuperscriptYOffset: number;
    yStrikeoutSize: number;
    yStrikeoutPosition: number;
    sFamilyClass: number;
    bFamilyType: number;
    bSerifStyle: number;
    bWeight: number;
    bProportion: number;
    bContrast: number;
    bStrokeVariation: number;
    bArmStyle: number;
    bLetterform: number;
    bMidline: number;
    bXHeight: number;
    ulUnicodeRange: number[];
    achVendID: string;
    fsSelection: number;
    usFirstCharIndex: number;
    usLastCharIndex: number;
    sTypoAscender: number;
    sTypoDescender: number;
    sTypoLineGap: number;
    usWinAscent: number;
    usWinDescent: number;
    ulCodePageRange: number[];
    sxHeight: number;
    sCapHeight: number;
    usDefaultChar: number;
    usBreakChar: number;
    usMaxContext: number;
    get fontPANOSE(): number[];
}

/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6post.html
 */
declare class Post extends SFNTTable {
    format: number;
    italicAngle: number;
    underlinePosition: number;
    underlineThickness: number;
    isFixedPitch: number;
    minMemType42: number;
    maxMemType42: number;
    minMemType1: number;
    maxMemType1: number;
    constructor(buffer?: BufferSource, byteOffset?: number, byteLength?: number);
}

/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6vhea.html
 */
declare class Vhea extends SFNTTable {
    version: number;
    vertTypoAscender: number;
    vertTypoDescender: number;
    vertTypoLineGap: number;
    advanceHeightMax: number;
    minTopSideBearing: number;
    minBottomSideBearing: number;
    yMaxExtent: number;
    caretSlopeRise: number;
    caretSlopeRun: number;
    caretOffset: number;
    reserved: number[];
    metricDataFormat: number;
    numOfLongVerMetrics: number;
    constructor(buffer?: BufferSource, byteOffset?: number);
}

interface VMetric {
    advanceHeight: number;
    topSideBearing: number;
}
/**
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6vmtx.html
 */
declare class Vmtx extends SFNTTable {
    static from(metrics: VMetric[]): Vmtx;
    protected _metrics?: VMetric[];
    get metrics(): VMetric[];
    readMetrics(): VMetric[];
}

type SFNTTableTag = 'cmap' | 'head' | 'hhea' | 'hmtx' | 'maxp' | 'name' | 'OS/2' | 'post' | 'glyf' | 'loca' | 'CFF ' | 'BASE' | 'CBDT' | 'CBLC' | 'CFF2' | 'COLR' | 'CPAL' | 'DSIG' | 'EBDT' | 'EBLC' | 'EBSC' | 'GDEF' | 'GPOS' | 'GSUB' | 'gasp' | 'JSTF' | 'kern' | 'LTSH' | 'MATH' | 'MERG' | 'Sbix' | 'SVG ' | 'VDMX' | 'vhea' | 'vmtx' | 'VORG' | 'hdmx' | 'fpgm' | 'prep' | 'cvt ' | 'avar' | 'fvar' | 'gvar' | 'HVAR' | 'MVAR' | 'STAT' | 'VVAR' | string;
declare function defineSFNTTable(tag: SFNTTableTag, prop?: string): (constructor: any) => void;
declare class SFNT {
    cmap: Cmap;
    head: Head;
    hhea: Hhea;
    hmtx: Hmtx;
    maxp: Maxp;
    name: Name;
    os2: Os2;
    post: Post;
    loca: Loca;
    glyf: Glyf;
    cff: Cff;
    gpos?: Gpos;
    gsub?: Gsub;
    kern?: Kern;
    vhea?: Vhea;
    vmtx?: Vmtx;
    static tableDefinitions: Map<string, {
        tag: string;
        prop: string;
        class: new (...args: any[]) => SFNTTable;
    }>;
    tables: Map<string, SFNTTable>;
    tableViews: Map<string, DataView<ArrayBufferLike>>;
    get hasGlyf(): boolean;
    get names(): Record<string, any>;
    get unitsPerEm(): number;
    get ascender(): number;
    get descender(): number;
    get createdTimestamp(): Date;
    get modifiedTimestamp(): Date;
    get numGlyphs(): number;
    get unicodes(): Map<number, number[]>;
    get glyphs(): GlyphSet;
    charToGlyphIndex(char: string): number;
    charToGlyph(char: string): Glyph;
    textToGlyphIndexes(text: string): number[];
    textToGlyphs(text: string): Glyph[];
    getPathCommands(text: string, x: number, y: number, fontSize?: number, options?: GlyphPathCommandOptions): GlyphPathCommand[];
    getAdvanceWidth(text: string, fontSize?: number, options?: GlyphPathCommandOptions): number;
    forEachGlyph(text: string, x: number | undefined, y: number | undefined, fontSize: number | undefined, options: (GlyphPathCommandOptions & {
        letterSpacing?: number;
        tracking?: number;
    }) | undefined, callback: (glyph: Glyph, x: number, y: number, fontSize: number, options: GlyphPathCommandOptions) => void): number;
    constructor(tableViews: Record<SFNTTableTag, DataView> | Map<SFNTTableTag, DataView>);
    clone(): SFNT;
    delete(tag: SFNTTableTag): this;
    set(tag: SFNTTableTag, table: SFNTTable): this;
    get(tag: SFNTTableTag): SFNTTable | undefined;
}

interface GlyphOptions {
    index?: number;
    name?: string | null;
    unicode?: number;
    unicodes?: number[];
    advanceWidth?: number;
    leftSideBearing?: number;
}
interface GlyphComponent {
    glyphIndex: number;
    dx: number;
    dy: number;
    xScale?: number;
    scale01?: number;
    scale10?: number;
    yScale?: number;
    matchedPoints?: number[];
}
type GlyphPathCommand = {
    type: 'M';
    x: number;
    y: number;
} | {
    type: 'L';
    x: number;
    y: number;
} | {
    type: 'Q';
    x1: number;
    y1: number;
    x: number;
    y: number;
} | {
    type: 'C';
    x1: number;
    y1: number;
    x2: number;
    y2: number;
    x: number;
    y: number;
} | {
    type: 'Z';
};
interface GlyphPathCommandOptions {
    xScale?: number;
    yScale?: number;
}
declare class Glyph {
    index: number;
    name: string | null;
    unicode: number;
    unicodes: number[];
    advanceWidth: number;
    leftSideBearing: number;
    isComposite: boolean;
    components: GlyphComponent[];
    pathCommands: GlyphPathCommand[];
    constructor(options: GlyphOptions);
    getPathCommands(x?: number, y?: number, fontSize?: number, options?: GlyphPathCommandOptions, sfnt?: SFNT): GlyphPathCommand[];
}

declare class CffGlyph extends Glyph {
    parse(cff: Cff, code: number[], glyphs: CffGlyphSet): void;
}

declare class CffGlyphSet extends GlyphSet {
    get length(): number;
    protected _get(index: number): CffGlyph;
}

declare abstract class CffIndex<T extends string | number[]> extends FontDataObject {
    count: number;
    offsetSize: number;
    protected abstract _isString: boolean;
    objectOffset: number;
    endOffset: number;
    protected _offsets?: number[];
    get offsets(): number[];
    protected _objects?: T[];
    get objects(): T[];
    constructor(source: BufferSource, byteOffset?: number, byteLength?: number, littleEndian?: boolean);
    protected _init(): void;
    readOffsets(): number[];
    readObjects(): T[];
    get(index: number): T;
}
declare class CffNumberIndex extends CffIndex<number[]> {
    protected _isString: boolean;
}
declare class CffStringIndex extends CffIndex<string> {
    protected _isString: boolean;
}

type CffDictPropType = 'string' | 'number' | 'number[]';
interface CffDictProp {
    type: CffDictPropType;
    operator: number;
    default?: any;
}
declare class CffDict extends FontDataObject {
    protected _dict?: Record<number, number[]>;
    get dict(): Record<number, number[]>;
    protected _stringIndex?: CffIndex<string>;
    setStringIndex(val: CffIndex<string>): this;
    protected _readFloatOperand(): number;
    protected _readOperand(b0: number): number;
    protected _readDict(): Record<number, number[]>;
    _getProp(prop: CffDictProp): any;
    _setProp(_prop: CffDictProp, _value: any): void;
}

declare class CffPrivateDict extends CffDict {
    subrs: number;
    defaultWidthX: number;
    nominalWidthX: number;
}

declare class CffTopDict extends CffDict {
    version: string;
    notice: string;
    copyright: string;
    fullName: string;
    familyName: string;
    weight: string;
    isFixedPitch: number;
    italicAngle: number;
    underlinePosition: number;
    underlineThickness: number;
    paintType: number;
    charstringType: number;
    fontMatrix: number[];
    uniqueId: number;
    fontBBox: number[];
    strokeWidth: number;
    xuid: number;
    charset: number;
    encoding: number;
    charStrings: number;
    private: number[];
}

/**
 * @link https://www.microsoft.com/typography/OTSPEC/cff.htm
 */
declare class Cff extends SFNTTable {
    majorVersion: number;
    minorVersion: number;
    headerSize: number;
    offsetSize: number;
    nameIndex: CffStringIndex;
    topDictIndex: CffNumberIndex;
    stringIndex: CffStringIndex;
    globalSubrIndex: CffNumberIndex;
    charStringsIndex: CffNumberIndex;
    protected _glyphs?: CffGlyphSet;
    get glyphs(): CffGlyphSet;
    get gsubrs(): number[][];
    get gsubrsBias(): number;
    topDict: CffTopDict;
    privateDict?: CffPrivateDict;
    subrsIndex?: CffNumberIndex;
    get defaultWidthX(): number;
    get nominalWidthX(): number;
    get subrs(): number[][];
    get subrsBias(): number;
    charset: string[];
    encoding: string[];
    constructor(source: BufferSource, byteOffset?: number, byteLength?: number, littleEndian?: boolean);
    protected _init(): void;
    protected _readCharset(start: number, nGlyphs: number, strings: string[]): string[];
    protected _readEncoding(start: number): Record<number, number>;
    protected _calcSubroutineBias(subrs: number[][]): number;
}

interface CmapSegment {
    start: number;
    startId: number;
    end: number;
    delta: number;
}
declare function createCmapSegments(unicodeToGlyphIndexMap: Map<number, number>, bound?: number): CmapSegment[];

declare class CmapSubtableFormat0 extends FontDataObject {
    format: 0;
    length: number;
    language: number;
    glyphIndexArray: number[];
    constructor(buffer?: BufferSource, byteOffset?: number);
    static from(unicodeToGlyphIndexMap: Map<number, number>): CmapSubtableFormat0;
    getUnicodeToGlyphIndexMap(): Map<number, number>;
}

declare class CmapSubtableFormat2 extends FontDataObject {
    format: 2;
    length: number;
    language: number;
    get subHeaderKeys(): number[];
    get maxSubHeaderKey(): number;
    get subHeaders(): {
        firstCode: number;
        entryCount: number;
        idDelta: number;
        idRangeOffset: number;
    }[];
    get glyphIndexArray(): number[];
    getUnicodeToGlyphIndexMap(numGlyphs: number): Map<number, number>;
}

declare class CmapSubtableFormat4 extends FontDataObject {
    format: 4;
    length: number;
    language: number;
    segCountX2: number;
    searchRange: number;
    entrySelector: number;
    rangeShift: number;
    get endCode(): number[];
    set endCode(value: number[]);
    get reservedPad(): number;
    set reservedPad(value: number);
    get startCode(): number[];
    set startCode(value: number[]);
    get idDelta(): number[];
    set idDelta(value: number[]);
    get idRangeOffsetCursor(): number;
    get idRangeOffset(): number[];
    set idRangeOffset(value: number[]);
    get glyphIndexArrayCursor(): number;
    get glyphIndexArray(): number[];
    static from(unicodeToGlyphIndexMap: Map<number, number>): CmapSubtableFormat4;
    getUnicodeToGlyphIndexMap(): Map<number, number>;
}

declare class CmapSubtableFormat6 extends FontDataObject {
    format: 6;
    length: number;
    language: number;
    firstCode: number;
    entryCount: number;
    get glyphIndexArray(): number[];
    getUnicodeToGlyphIndexMap(): Map<number, number>;
}

declare class CmapSubtableFormat12 extends FontDataObject {
    format: 12;
    reserved: number;
    length: number;
    language: number;
    nGroups: number;
    get groups(): {
        startCharCode: number;
        endCharCode: number;
        startGlyphCode: number;
    }[];
    static from(unicodeToGlyphIndexMap: Map<number, number>): CmapSubtableFormat12;
    getUnicodeToGlyphIndexMap(): Map<number, number>;
}

interface VarSelectorRecord {
    varSelector: number;
    defaultUVSOffset: number;
    unicodeValueRanges: UnicodeValueRange[];
    nonDefaultUVSOffset: number;
    uVSMappings: VSMappings[];
}
interface UnicodeValueRange {
    startUnicodeValue: number;
    additionalCount: number;
}
interface VSMappings {
    unicodeValue: number;
    glyphID: number;
}
declare class CmapSubtableFormat14 extends FontDataObject {
    format: 14;
    length: number;
    numVarSelectorRecords: number;
    getVarSelectorRecords(): VarSelectorRecord[];
    getUnicodeToGlyphIndexMap(): Map<number, number>;
}

/**
 * TrueType
 *
 * @link https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6.html
 */
declare class TTF extends BaseFont {
    format: string;
    mimeType: string;
    scalerType: number;
    numTables: number;
    searchRange: number;
    entrySelector: number;
    rangeShift: number;
    protected _sfnt?: SFNT;
    get sfnt(): SFNT;
    static signature: Set<number>;
    static is(source: BufferSource | number): boolean;
    static checksum(source: BufferSource): number;
    static from(sfnt: SFNT): TTF;
    getDirectories(): TableDirectory[];
    createSFNT(): SFNT;
}

/**
 * @link http://www.w3.org/Submission/EOT
 */
declare class EOT extends BaseFont {
    format: string;
    mimeType: string;
    EOTSize: number;
    FontDataSize: number;
    Version: number;
    Flags: number;
    FontPANOSE: number[];
    Charset: number;
    Italic: number;
    Weight: number;
    fsType: number;
    MagicNumber: number;
    UnicodeRange: number[];
    CodePageRange: number[];
    CheckSumAdjustment: number;
    Reserved: number[];
    Padding1: number;
    static from(ttf: TTF): EOT;
}

/**
 * OpenType
 */
declare class OTF extends TTF {
    format: string;
    mimeType: string;
    static signature: Set<number>;
    static from(sfnt: SFNT): OTF;
}

declare class WOFFTableDirectoryEntry extends FontDataObject {
    tag: string;
    offset: number;
    compLength: number;
    origLength: number;
    origChecksum: number;
    constructor(buffer: BufferSource, byteOffset?: number);
}

/**
 * WOFF
 *
 * @link https://www.w3.org/submissions/WOFF
 */
declare class WOFF extends BaseFont {
    format: string;
    mimeType: string;
    signature: number;
    flavor: number;
    length: number;
    numTables: number;
    reserved: number;
    totalSFNTSize: number;
    majorVersion: number;
    minorVersion: number;
    metaOffset: number;
    metaLength: number;
    metaOrigLength: number;
    privOffset: number;
    privLength: number;
    get subfontFormat(): 'TrueType' | 'OpenType' | 'Open';
    protected _sfnt?: SFNT;
    get sfnt(): SFNT;
    static signature: Set<number>;
    static is(source: BufferSource | number): boolean;
    static checkSum(source: BufferSource): number;
    static from(sfnt: SFNT, rest?: ArrayBuffer): WOFF;
    getDirectories(): WOFFTableDirectoryEntry[];
    createSFNT(): SFNT;
}

type SFNTFont = TTF | WOFF | OTF;

type Font = SFNTFont | EOT;

interface FontRequest {
    url: string;
    when: Promise<ArrayBuffer>;
    cancel: () => void;
}
type FontURL = string;
interface FontObject {
    src: string;
    family?: string | string[];
}
type FontSource = FontURL | FontObject;
interface FontLoadedResult extends FontObject {
    buffer: ArrayBuffer;
    familySet: Set<string>;
    getFont: () => Font | undefined;
    getSFNT: () => SFNT | undefined;
}
interface FontLoadOptions extends RequestInit {
    injectFontFace?: boolean;
    injectStyleTag?: boolean;
    cancelOther?: boolean;
    noAdd?: boolean;
}
declare class Fonts {
    static defaultRequestInit: Partial<FontLoadOptions>;
    fallbackFont?: FontLoadedResult;
    loading: Map<string, FontRequest>;
    loaded: Map<string, FontLoadedResult>;
    familyToUrl: Map<string, string>;
    setFallbackFont(loadedFont: FontLoadedResult): void;
    loadFallbackFont(source: FontSource, options?: FontLoadOptions): Promise<void>;
    protected _createRequest(url: string, requestInit: RequestInit): FontRequest;
    injectFontFace(family: string, data: ArrayBuffer): this;
    injectStyleTag(family: string, url: string): this;
    protected _parseUrls(familyOrUrl: string): string[];
    get(familyOrUrl?: string): FontLoadedResult | undefined;
    set(family: string, font: FontLoadedResult): this;
    delete(familyOrUrl: string): this;
    clear(): this;
    protected _parseFamilies(family: string | string[] | undefined): string[];
    load(source: FontSource, options?: FontLoadOptions): Promise<FontLoadedResult>;
    waitUntilLoad(): Promise<void>;
}
declare const fonts: Fonts;

declare function parseFont<T extends Font = Font>(source: BufferSource): T;
declare function parseFont<T extends Font = Font>(source: BufferSource, orFail: false): T | undefined;

declare function parseSFNTFont<T extends SFNTFont = SFNTFont>(source: BufferSource): T;
declare function parseSFNTFont<T extends SFNTFont = SFNTFont>(source: BufferSource, orFail: false): T | undefined;

declare function minifyFont<T extends (TTF | WOFF | ArrayBuffer)>(source: T, subset: string): T;

interface MinimizedGlyph extends HMetric, VMetric {
    rawGlyphIndex: number;
    glyphIndex: number;
    unicodes: number[];
    view: DataView;
}
declare function minifyGlyphs(sfnt: SFNT, subset: string): MinimizedGlyph[];

declare function minifySFNT(sfnt: SFNT, subset: string): SFNT;

export { BaseFont, Cff, Cmap, CmapSubtableFormat0, CmapSubtableFormat12, CmapSubtableFormat14, CmapSubtableFormat2, CmapSubtableFormat4, CmapSubtableFormat6, EOT, FontDataObject, FontDataView, Fonts, Glyf, Glyph, GlyphSet, Gpos, Gsub, Head, Hhea, Hmtx, Kern, Loca, Maxp, Name, Os2, Post, SFNT, TTF, TableDirectory, Vhea, Vmtx, WOFF, WOFFTableDirectoryEntry, componentFlags, createCmapSegments, dataTypeToByteLength, defineColumn, defineSFNTTable, fonts, minifyFont, minifyGlyphs, minifySFNT, parseFont, parseSFNTFont };
export type { CmapSegment, CmapSubtable, Column, ColumnOptions, DataType, Font, FontDataViewDefinition, FontLoadOptions, FontLoadedResult, FontObject, FontRequest, FontSource, FontURL, GlyphComponent, GlyphOptions, GlyphOrLoader, GlyphPathCommand, GlyphPathCommandOptions, HMetric, MinimizedGlyph, SFNTFont, SFNTTableTag, UnicodeValueRange, VMetric, VSMappings, VarSelectorRecord };