harfbuzzjs 0.10.3 → 1.0.0-beta.2

package/dist/index.d.mts

@@ -0,0 +1,749 @@
+//#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);
+  /**
+   * 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: string): 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: string): 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: string, 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: string, scriptIndex: number, languageIndex: number): string[];
+  /**
+   * 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: string, featureIndex: number): FeatureNameIds | undefined;
+}
+//#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 drawPtrs;
+  /**
+   * @param face A Face to create the font from.
+   */
+  constructor(face: Face);
+  /** @internal Wrap an existing font pointer. */
+  constructor(existingPtr: number);
+  /**
+   * 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;
+  /**
+   * 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;
+}
+//#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/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 };