harfbuzzjs

//#region src/helpers.d.ts type ValueOf<T> = T[keyof T]; //#endregion //#region src/types.d.ts interface FontExtents { ascender: number; descender: number; lineGap: number; } interface GlyphExtents { xBearing: number; yBearing: number; width: number; height: number; } interface GlyphInfo { /** Either a Unicode code point (before shaping) or a glyph index (after shaping). */ codepoint: number; /** The cluster index of the glyph. */ cluster: number; /** Glyph flags, a combination of {@link GlyphFlag} values. */ flags: number; } interface GlyphPosition { /** The x advance of the glyph. */ xAdvance: number; /** The y advance of the glyph. */ yAdvance: number; /** The x offset of the glyph. */ xOffset: number; /** The y offset of the glyph. */ yOffset: number; } interface SvgPathCommand { type: string; values: number[]; } interface AxisInfo { min: number; default: number; max: number; } interface NameEntry { nameId: number; language: string; } interface FeatureNameIds { uiLabelNameId?: number; uiTooltipTextNameId?: number; sampleTextNameId?: number; paramUiLabelNameIds: number[]; } interface TraceEntry { m: string; t: unknown[]; glyphs: boolean; } /** EmscriptenModule extended with MODULARIZE runtime methods. */ interface HarfBuzzModule extends EmscriptenModule { wasmExports: Record<string, (...args: any[]) => any>; addFunction(func: (...args: any[]) => any, signature: string): number; removeFunction(funcPtr: number): void; stackSave(): number; stackAlloc(size: number): number; stackRestore(ptr: number): void; } declare const GlyphFlag: { readonly UNSAFE_TO_BREAK: 1; readonly UNSAFE_TO_CONCAT: 2; readonly SAFE_TO_INSERT_TATWEEL: 4; readonly DEFINED: 7; }; type GlyphFlag = ValueOf<typeof GlyphFlag>; //#endregion //#region src/blob.d.ts /** * An object representing a {@link https://harfbuzz.github.io/harfbuzz-hb-blob.html | HarfBuzz blob}. * A blob wraps a chunk of binary data, typically the contents of a font file. */ declare class Blob { readonly ptr: number; /** * @param data Binary font data. */ constructor(data: ArrayBuffer); } //#endregion //#region src/face.d.ts declare const GlyphClass: { readonly UNCLASSIFIED: 0; readonly BASE_GLYPH: 1; readonly LIGATURE: 2; readonly MARK: 3; readonly COMPONENT: 4; }; type GlyphClass = ValueOf<typeof GlyphClass>; /** * An object representing a {@link https://harfbuzz.github.io/harfbuzz-hb-face.html | HarfBuzz face}. * A face represents a single face in a binary font file and is the * foundation for creating Font objects used in text shaping. */ declare class Face { readonly ptr: number; readonly upem: number; /** * @param blob A Blob containing font data. * @param index The index of the font in the blob. (0 for most files, * or a 0-indexed font number if the `blob` came from a font collection file.) */ constructor(blob: Blob, index?: number); /** @internal Wrap an existing face pointer. */ constructor(existingPtr: number); /** * Return the binary contents of an OpenType table. * @param table Table name * @returns A Uint8Array of the table data, or undefined if the table is not found. */ referenceTable(table: string): Uint8Array | undefined; /** * Return variation axis infos. * @returns A dictionary mapping axis tags to {min, default, max} values. */ getAxisInfos(): Record<string, AxisInfo>; /** * Return unicodes the face supports. * @returns A Uint32Array of supported Unicode code points. */ collectUnicodes(): Uint32Array; /** * Return all scripts enumerated in the specified face's * GSUB table or GPOS table. * @param table The table to query, either "GSUB" or "GPOS". * @returns An array of 4-character script tag strings. */ getTableScriptTags(table: "GSUB" | "GPOS"): string[]; /** * Return all features enumerated in the specified face's * GSUB table or GPOS table. * @param table The table to query, either "GSUB" or "GPOS". * @returns An array of 4-character feature tag strings. */ getTableFeatureTags(table: "GSUB" | "GPOS"): string[]; /** * Return language tags in the given face's GSUB or GPOS table, underneath * the specified script index. * @param table The table to query, either "GSUB" or "GPOS". * @param scriptIndex The index of the script to query. * @returns An array of 4-character language tag strings. */ getScriptLanguageTags(table: "GSUB" | "GPOS", scriptIndex: number): string[]; /** * Return all features in the specified face's GSUB table or GPOS table, * underneath the specified script and language. * @param table The table to query, either "GSUB" or "GPOS". * @param scriptIndex The index of the script to query. * @param languageIndex The index of the language to query. * @returns An array of 4-character feature tag strings. */ getLanguageFeatureTags(table: "GSUB" | "GPOS", scriptIndex: number, languageIndex: number): string[]; /** * Fetches a list of all lookups enumerated for the specified feature, in * the specified face's GSUB table or GPOS table. * @param table The table to query, either "GSUB" or "GPOS". * @param featureIndex The index of the requested feature. * @returns An array of lookup indexes. */ getFeatureLookups(table: "GSUB" | "GPOS", featureIndex: number): number[]; /** * Get the GDEF class of the requested glyph. * @param glyph The glyph to get the class of. * @returns The {@link GlyphClass} of the glyph. */ getGlyphClass(glyph: number): GlyphClass; /** * Return all names in the specified face's name table. * @returns An array of {nameId, language} entries. */ listNames(): NameEntry[]; /** * Get the name of the specified face. * @param nameId The ID of the name to get. * @param language The language of the name to get. * @returns The name string. */ getName(nameId: number, language: string): string; /** * Get the name IDs of the specified feature. * @param table The table to query, either "GSUB" or "GPOS". * @param featureIndex The index of the feature to query. * @returns An object with name IDs, or undefined if not found. */ getFeatureNameIds(table: "GSUB" | "GPOS", featureIndex: number): FeatureNameIds | undefined; } //#endregion //#region src/buffer.d.ts declare const BufferContentType: { readonly INVALID: 0; readonly UNICODE: 1; readonly GLYPHS: 2; }; type BufferContentType = ValueOf<typeof BufferContentType>; declare const BufferSerializeFlag: { readonly DEFAULT: 0; readonly NO_CLUSTERS: 1; readonly NO_POSITIONS: 2; readonly NO_GLYPH_NAMES: 4; readonly GLYPH_EXTENTS: 8; readonly GLYPH_FLAGS: 16; readonly NO_ADVANCES: 32; readonly DEFINED: 63; }; type BufferSerializeFlag = ValueOf<typeof BufferSerializeFlag>; declare const BufferFlag: { readonly DEFAULT: 0; readonly BOT: 1; readonly EOT: 2; readonly PRESERVE_DEFAULT_IGNORABLES: 4; readonly REMOVE_DEFAULT_IGNORABLES: 8; readonly DO_NOT_INSERT_DOTTED_CIRCLE: 16; readonly VERIFY: 32; readonly PRODUCE_UNSAFE_TO_CONCAT: 64; readonly PRODUCE_SAFE_TO_INSERT_TATWEEL: 128; readonly DEFINED: 255; }; type BufferFlag = ValueOf<typeof BufferFlag>; declare const Direction: { readonly INVALID: 0; readonly LTR: 4; readonly RTL: 5; readonly TTB: 6; readonly BTT: 7; }; type Direction = ValueOf<typeof Direction>; declare const ClusterLevel: { readonly MONOTONE_GRAPHEMES: 0; readonly MONOTONE_CHARACTERS: 1; readonly CHARACTERS: 2; readonly GRAPHEMES: 3; readonly DEFAULT: 0; }; type ClusterLevel = ValueOf<typeof ClusterLevel>; declare const BufferSerializeFormat: { readonly INVALID: 0; readonly TEXT: number; readonly JSON: number; }; type BufferSerializeFormat = ValueOf<typeof BufferSerializeFormat>; /** * An object representing a {@link https://harfbuzz.github.io/harfbuzz-hb-buffer.html | HarfBuzz buffer}. * A buffer holds the input text and its properties before shaping, and the * output glyphs and their information after shaping. */ declare class Buffer { readonly ptr: number; /** * @param existingPtr @internal Wrap an existing buffer pointer. */ constructor(existingPtr?: number); /** * Appends a character with the Unicode value of `codePoint` to the buffer, * and gives it the initial cluster value of `cluster`. Clusters can be any * thing the client wants, they are usually used to refer to the index of the * character in the input text stream and are output in the `cluster` field * of {@link GlyphInfo}. * * This function does not check the validity of `codePoint`, it is up to the * caller to ensure it is a valid Unicode code point. * @param codePoint A Unicode code point. * @param cluster The cluster value of `codePoint`. */ add(codePoint: number, cluster: number): void; /** * Add text to the buffer. * @param text Text to be added to the buffer. * @param itemOffset The offset of the first character to add to the buffer. * @param itemLength The number of characters to add to the buffer, or omit for the end of text. */ addText(text: string, itemOffset?: number, itemLength?: number): void; /** * Add code points to the buffer. * @param codePoints Array of code points to be added to the buffer. * @param itemOffset The offset of the first code point to add to the buffer. * @param itemLength The number of code points to add to the buffer, or omit for the end of the array. */ addCodePoints(codePoints: number[], itemOffset?: number, itemLength?: number): void; /** * Set buffer script, language and direction. * * This needs to be done before shaping. */ guessSegmentProperties(): void; /** * Set buffer direction explicitly. * @param dir A {@link Direction} value. */ setDirection(dir: Direction): void; /** * Set buffer flags explicitly. * @param flags A combination of {@link BufferFlag} values (OR them together). */ setFlags(flags: number): void; /** * Set buffer language explicitly. * @param language The buffer language */ setLanguage(language: string): void; /** * Set buffer script explicitly. * @param script The buffer script */ setScript(script: string): void; /** * Set the HarfBuzz clustering level. * * Affects the cluster values returned from shaping. * @param level A {@link ClusterLevel} value. See the HarfBuzz manual chapter on Clusters. */ setClusterLevel(level: ClusterLevel): void; /** Reset the buffer to its initial status. */ reset(): void; /** * Similar to reset(), but does not clear the Unicode functions and the * replacement code point. */ clearContents(): void; /** * Set message func. * @param func The function to set. It receives the buffer, font, and message * string as arguments. Returning false will skip this shaping step and move * to the next one. */ setMessageFunc(func: (buffer: Buffer, font: Font, message: string) => boolean): void; /** * Get the the number of items in the buffer. * @returns The buffer length. */ getLength(): number; /** * Get the glyph information from the buffer. * @returns An array of {@link GlyphInfo} objects. */ getGlyphInfos(): GlyphInfo[]; /** * Get the glyph positions from the buffer. * @returns An array of {@link GlyphPosition} objects. */ getGlyphPositions(): GlyphPosition[]; /** * Get the glyph information and positions from the buffer. * @returns The glyph information and positions. * * The glyph information is returned as an array of objects with the * properties from getGlyphInfos and getGlyphPositions combined. */ getGlyphInfosAndPositions(): (GlyphInfo & Partial<GlyphPosition>)[]; /** * Update the glyph positions in the buffer. * WARNING: Do not use unless you know what you are doing. */ updateGlyphPositions(positions: GlyphPosition[]): void; /** * Serialize the buffer contents to a string. * @param options Serialization options: * - `font`: the font to use for serialization; * - `start`: the starting index of the glyphs (default `0`); * - `end`: the ending index of the glyphs (default end of buffer); * - `format`: a {@link BufferSerializeFormat} value (default `TEXT`); * - `flags`: a combination of {@link BufferSerializeFlag} values (default `0`). * @returns The serialized buffer contents. */ serialize(options?: { font?: Font; start?: number; end?: number; format?: BufferSerializeFormat; flags?: number; }): string; /** * Return the buffer content type. * * @returns The buffer content type as a {@link BufferContentType} value. */ getContentType(): BufferContentType; } //#endregion //#region src/font-funcs.d.ts /** * An object representing {@link https://harfbuzz.github.io/harfbuzz-hb-font.html | HarfBuzz font functions}. * Font functions define the methods used by a Font for lower-level queries * like glyph advances and extents. HarfBuzz provides built-in default * implementations which can be selectively overridden. */ declare class FontFuncs { readonly ptr: number; constructor(); /** * Set the font's glyph extents function. * @param func The callback receives a Font and glyph ID. It should return * an object with xBearing, yBearing, width, and height, or undefined on failure. */ setGlyphExtentsFunc(func: (font: Font, glyph: number) => GlyphExtents | undefined): void; /** * Set the font's glyph from name function. * @param func The callback receives a Font and glyph name. It should return * the glyph ID, or undefined on failure. */ setGlyphFromNameFunc(func: (font: Font, name: string) => number | undefined): void; /** * Set the font's glyph horizontal advance function. * @param func The callback receives a Font and glyph ID. It should return * the horizontal advance of the glyph. */ setGlyphHAdvanceFunc(func: (font: Font, glyph: number) => number): void; /** * Set the font's glyph vertical advance function. * @param func The callback receives a Font and glyph ID. It should return * the vertical advance of the glyph. */ setGlyphVAdvanceFunc(func: (font: Font, glyph: number) => number): void; /** * Set the font's glyph horizontal origin function. * @param func The callback receives a Font and glyph ID. It should return * the [x, y] horizontal origin of the glyph, or undefined on failure. */ setGlyphHOriginFunc(func: (font: Font, glyph: number) => [number, number] | undefined): void; /** * Set the font's glyph vertical origin function. * @param func The callback receives a Font and glyph ID. It should return * the [x, y] vertical origin of the glyph, or undefined on failure. */ setGlyphVOriginFunc(func: (font: Font, glyph: number) => [number, number] | undefined): void; /** * Set the font's glyph horizontal kerning function. * @param func The callback receives a Font, first glyph ID, and second glyph ID. * It should return the horizontal kerning of the glyphs. */ setGlyphHKerningFunc(func: (font: Font, firstGlyph: number, secondGlyph: number) => number): void; /** * Set the font's glyph name function. * @param func The callback receives a Font and glyph ID. It should return * the name of the glyph, or undefined on failure. */ setGlyphNameFunc(func: (font: Font, glyph: number) => string | undefined): void; /** * Set the font's nominal glyph function. * @param func The callback receives a Font and unicode code point. It should * return the nominal glyph of the unicode, or undefined on failure. */ setNominalGlyphFunc(func: (font: Font, unicode: number) => number | undefined): void; /** * Set the font's variation glyph function. * @param func The callback receives a Font, unicode code point, and variation * selector. It should return the variation glyph, or undefined on failure. */ setVariationGlyphFunc(func: (font: Font, unicode: number, variationSelector: number) => number | undefined): void; /** * Set the font's horizontal extents function. * @param func The callback receives a Font. It should return an object with * ascender, descender, and lineGap, or undefined on failure. */ setFontHExtentsFunc(func: (font: Font) => FontExtents | undefined): void; /** * Set the font's vertical extents function. * @param func The callback receives a Font. It should return an object with * ascender, descender, and lineGap, or undefined on failure. */ setFontVExtentsFunc(func: (font: Font) => FontExtents | undefined): void; } //#endregion //#region src/variation.d.ts /** * A {@link https://harfbuzz.github.io/harfbuzz-hb-common.html#hb-variation-t | HarfBuzz variation}. * * Data type for holding variation data. Registered OpenType variation-axis * tags are listed in * {@link https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg | OpenType Axis Tag Registry}. */ declare class Variation { /** The tag of the variation-axis name. */ tag: string; /** The value of the variation axis. */ value: number; constructor(tag: string, value?: number); /** * Parses a string into a Variation. * * The format for specifying variation settings follows. All valid CSS * font-variation-settings values other than `normal` and `inherited` are * also accepted, though, not documented below. * * The format is a tag, optionally followed by an equals sign, followed by a * number. For example `wght=500`, or `slnt=-7.5`. * * @param str The string to parse. * @returns A Variation, or undefined if the string is not a valid variation. */ static fromString(str: string): Variation | undefined; /** * Converts the variation to a string in the format understood by * {@link Variation.fromString}. * * Note that the string won't include any whitespace. * * @returns The variation string. */ toString(): string; /** @internal Write this variation into the given hb_variation_t pointer. */ writeTo(ptr: number): void; } //#endregion //#region src/font.d.ts /** * An object representing a {@link https://harfbuzz.github.io/harfbuzz-hb-font.html | HarfBuzz font}. * A font represents a face at a specific size and with certain other * parameters (pixels-per-em, variation settings) specified. Fonts are the * primary input to the shaping process. */ declare class Font { readonly ptr: number; private _face?; private drawPtrs; /** * @param face A Face to create the font from. */ constructor(face: Face); /** @internal Wrap an existing font pointer. */ constructor(existingPtr: number); /** The {@link Face} associated with this font. */ get face(): Face; /** * Create a sub font that inherits this font's properties. * @returns A new Font object representing the sub font. */ subFont(): Font; /** * Return font horizontal extents. * @returns Object with ascender, descender, and lineGap properties. */ hExtents(): FontExtents; /** * Return font vertical extents. * @returns Object with ascender, descender, and lineGap properties. */ vExtents(): FontExtents; /** * Return glyph name. * @param glyphId ID of the requested glyph in the font. * @returns The glyph name string. */ glyphName(glyphId: number): string; /** * Return a glyph as an SVG path string. * @param glyphId ID of the requested glyph in the font. * @returns SVG path data string. */ glyphToPath(glyphId: number): string; /** * Return glyph horizontal advance. * @param glyphId ID of the requested glyph in the font. * @returns The horizontal advance width. */ glyphHAdvance(glyphId: number): number; /** * Return glyph vertical advance. * @param glyphId ID of the requested glyph in the font. * @returns The vertical advance height. */ glyphVAdvance(glyphId: number): number; /** * Return glyph horizontal origin. * @param glyphId ID of the requested glyph in the font. * @returns [x, y] origin coordinates, or undefined if not available. */ glyphHOrigin(glyphId: number): [number, number] | undefined; /** * Return glyph vertical origin. * @param glyphId ID of the requested glyph in the font. * @returns [x, y] origin coordinates, or undefined if not available. */ glyphVOrigin(glyphId: number): [number, number] | undefined; /** * Return glyph extents. * @param glyphId ID of the requested glyph in the font. * @returns An object with xBearing, yBearing, width, and height, or undefined. */ glyphExtents(glyphId: number): GlyphExtents | undefined; /** * Fetches the glyph ID for a Unicode code point in the specified * font, with an optional variation selector. * * If `variationSelector` is 0, it is equivalent to * {@link Font.nominalGlyph}; otherwise it is equivalent to * {@link Font.variationGlyph}. * * @param unicode The Unicode code point to query. * @param variationSelector A variation-selector code point. * @returns The glyph ID, or undefined if not found. */ glyph(unicode: number, variationSelector?: number): number | undefined; /** * Fetches the nominal glyph ID for a Unicode code point in the * specified font. * * This version of the function should not be used to fetch glyph IDs * for code points modified by variation selectors. For variation-selector * support, use {@link Font.variationGlyph} or {@link Font.glyph}. * * @param unicode The Unicode code point to query. * @returns The glyph ID, or undefined if not found. */ nominalGlyph(unicode: number): number | undefined; /** * Fetches the glyph ID for a Unicode code point when followed by * by the specified variation-selector code point, in the specified * font. * * @param unicode The Unicode code point to query. * @param variationSelector The variation-selector code point to query. * @returns The glyph ID, or undefined if not found. */ variationGlyph(unicode: number, variationSelector: number): number | undefined; /** * Return glyph ID from name. * @param name Name of the requested glyph in the font. * @returns The glyph ID, or undefined if not found. */ glyphFromName(name: string): number | undefined; /** * Return a glyph as a JSON path string * based on format described on https://svgwg.org/specs/paths/#InterfaceSVGPathSegment * @param glyphId ID of the requested glyph in the font. * @returns An array of path segment objects with type and values. */ glyphToJson(glyphId: number): SvgPathCommand[]; /** * Set the font's scale factor, affecting the position values returned from * shaping. * @param xScale Units to scale in the X dimension. * @param yScale Units to scale in the Y dimension. */ setScale(xScale: number, yScale: number): void; /** * Applies a list of font-variation settings to a font. * * Note that this overrides all existing variations set on the font. * Axes not included in `variations` will be effectively set to their * default values. * * @param variations Array of variation settings to apply. */ setVariations(variations: Variation[]): void; /** Set the font's font functions. */ setFuncs(fontFuncs: FontFuncs): void; /** * Fetches the optical bound of a glyph positioned at the margin of text. * The direction identifies which edge of the glyph to query. * @param lookupIndex Index of the feature lookup to query. * @param direction Edge of the glyph to query. * @param glyph A glyph id. * @returns Adjustment value. Negative values mean the glyph will stick out of the margin. */ getLookupOpticalBound(lookupIndex: number, direction: Direction, glyph: number): number; } //#endregion //#region src/feature.d.ts /** * A {@link https://harfbuzz.github.io/harfbuzz-hb-common.html#hb-feature-t | HarfBuzz feature}. * * The structure that holds information about requested feature application. * The feature will be applied with the given value to all glyphs which are in * clusters between {@link Feature.start} (inclusive) and {@link Feature.end} * (exclusive). Setting `start` to `0` and `end` to `0xffffffff` specifies that * the feature always applies to the entire buffer. */ declare class Feature { /** * Special setting for {@link Feature.start} to apply the feature from the * start of the buffer. */ static readonly GLOBAL_START = 0; /** * Special setting for {@link Feature.end} to apply the feature from to the * end of the buffer. */ static readonly GLOBAL_END = 4294967295; /** The tag of the feature. */ tag: string; /** * The value of the feature. `0` disables the feature, non-zero (usually `1`) * enables the feature. For features implemented as lookup type 3 (like * `salt`) the value is a one-based index into the alternates. */ value: number; /** The cluster to start applying this feature setting (inclusive). */ start: number; /** The cluster to end applying this feature setting (exclusive). */ end: number; constructor(tag: string, value?: number, start?: number, end?: number); /** * Parses a string into a Feature. * * The format for specifying feature strings follows. All valid CSS * font-feature-settings values other than `normal` and the global values are * also accepted, though not documented below. CSS string escapes are not * supported. * * The range indices refer to the positions between Unicode characters. The * position before the first character is always 0. * * The format is Python-esque. Here is how it all works: * * | Syntax | Value | Start | End | Meaning | * | ------------- | ----- | ----- | --- | -------------------------------- | * | `kern` | 1 | 0 | ∞ | Turn feature on | * | `+kern` | 1 | 0 | ∞ | Turn feature on | * | `-kern` | 0 | 0 | ∞ | Turn feature off | * | `kern=0` | 0 | 0 | ∞ | Turn feature off | * | `kern=1` | 1 | 0 | ∞ | Turn feature on | * | `aalt=2` | 2 | 0 | ∞ | Choose 2nd alternate | * | `kern[]` | 1 | 0 | ∞ | Turn feature on | * | `kern[:]` | 1 | 0 | ∞ | Turn feature on | * | `kern[5:]` | 1 | 5 | ∞ | Turn feature on, partial | * | `kern[:5]` | 1 | 0 | 5 | Turn feature on, partial | * | `kern[3:5]` | 1 | 3 | 5 | Turn feature on, range | * | `kern[3]` | 1 | 3 | 3+1 | Turn feature on, single char | * | `aalt[3:5]=2` | 2 | 3 | 5 | Turn 2nd alternate on for range | * * @param str The string to parse. * @returns A Feature, or undefined if the string is not a valid feature. */ static fromString(str: string): Feature | undefined; /** * Converts the feature to a string in the format understood by * {@link Feature.fromString}. * * Note that the feature value will be omitted if it is `1`, but the string * won't include any whitespace. * * @returns The feature string. */ toString(): string; /** @internal Write this feature into the given hb_feature_t pointer. */ writeTo(ptr: number): void; } //#endregion //#region src/shape.d.ts declare const TracePhase: { readonly DONT_STOP: 0; readonly GSUB: 1; readonly GPOS: 2; }; type TracePhase = ValueOf<typeof TracePhase>; /** * Shape a buffer with a given font. * * Converts the Unicode text in the buffer into positioned glyphs. * The buffer is modified in place. * * @param font The Font to shape with. * @param buffer The Buffer containing text to shape, suitably prepared * (text added, segment properties set). * @param features An array of {@link Feature} values to apply. */ declare function shape(font: Font, buffer: Buffer, features?: Feature[]): void; /** * Shape a buffer with a given font, returning a JSON trace of the shaping process. * * This function supports "partial shaping", where the shaping process is * terminated after a given lookup ID is reached. * * @param font The Font to shape with. * @param buffer The Buffer containing text to shape, suitably prepared. * @param features An array of {@link Feature} values to apply. * @param stop_at A lookup ID at which to terminate shaping. * @param stop_phase The {@link TracePhase} at which to stop shaping. * @returns An array of trace entries, each with a message, serialized glyphs, and phase info. */ declare function shapeWithTrace(font: Font, buffer: Buffer, features: Feature[], stop_at: number, stop_phase: TracePhase): TraceEntry[]; /** * Return the HarfBuzz version. * @returns An object with major, minor, and micro version numbers. */ declare function version(): { major: number; minor: number; micro: number; }; /** * Return the HarfBuzz version as a string. * @returns A version string in the form "major.minor.micro". */ declare function versionString(): string; /** * Convert an OpenType script tag to HarfBuzz script. * @param tag The tag to convert. * @returns The script. */ declare function otTagToScript(tag: string): string; /** * Convert an OpenType language tag to HarfBuzz language. * @param tag The tag to convert. * @returns The language. */ declare function otTagToLanguage(tag: string): string; //#endregion export { AxisInfo, Blob, Buffer, BufferContentType, BufferFlag, BufferSerializeFlag, BufferSerializeFormat, ClusterLevel, Direction, Face, Feature, FeatureNameIds, Font, FontExtents, FontFuncs, GlyphClass, GlyphExtents, GlyphFlag, GlyphInfo, GlyphPosition, HarfBuzzModule, NameEntry, SvgPathCommand, TraceEntry, TracePhase, Variation, otTagToLanguage, otTagToScript, shape, shapeWithTrace, version, versionString };