@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/harfbuzz/glyph-info-t.d.ts

@@ -1,11 +1,32 @@
 export interface GlyphInfoTInit {
     cluster?: number;
 }
+/**
+ * The #hb_glyph_info_t is the structure that holds information about the
+ * glyphs and their relation to input text.
+ */
 export declare class GlyphInfoT {
     ptr: unknown;
     constructor(init?: GlyphInfoTInit);
     protected createPtr(init: GlyphInfoTInit): unknown;
+    /**
+     * either a Unicode code point (before shaping) or a glyph index
+     * (after shaping).
+     */
     get codepoint(): number;
+    /**
+     * the index of the character in the original text that corresponds
+     * to this #hb_glyph_info_t, or whatever the client passes to
+     * hb_buffer_add(). More than one #hb_glyph_info_t can have the same
+     * `cluster` value, if they resulted from the same character (e.g. one
+     * to many glyph substitution), and when more than one character gets
+     * merged in the same glyph (e.g. many to one glyph substitution) the
+     * #hb_glyph_info_t will have the smallest cluster value of them.
+     * By default some characters are merged into the same cluster
+     * (e.g. combining marks have the same cluster as their bases)
+     * even if they are separate glyphs, hb_buffer_set_cluster_level()
+     * allow selecting more fine-grained cluster handling.
+     */
     get cluster(): number;
     set cluster(value: number);
 }

package/dist/generated/harfbuzz/glyph-info-t.js

@@ -1,4 +1,8 @@
 import { alloc, read, write } from "@gtkx/native";
+/**
+ * The #hb_glyph_info_t is the structure that holds information about the
+ * glyphs and their relation to input text.
+ */
 export class GlyphInfoT {
     ptr;
     constructor(init = {}) {
@@ -10,9 +14,26 @@ export class GlyphInfoT {
             write(ptr, { type: "int", size: 32, unsigned: true }, 8, init.cluster);
         return ptr;
     }
+    /**
+     * either a Unicode code point (before shaping) or a glyph index
+     * (after shaping).
+     */
     get codepoint() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 0);
     }
+    /**
+     * the index of the character in the original text that corresponds
+     * to this #hb_glyph_info_t, or whatever the client passes to
+     * hb_buffer_add(). More than one #hb_glyph_info_t can have the same
+     * `cluster` value, if they resulted from the same character (e.g. one
+     * to many glyph substitution), and when more than one character gets
+     * merged in the same glyph (e.g. many to one glyph substitution) the
+     * #hb_glyph_info_t will have the smallest cluster value of them.
+     * By default some characters are merged into the same cluster
+     * (e.g. combining marks have the same cluster as their bases)
+     * even if they are separate glyphs, hb_buffer_set_cluster_level()
+     * allow selecting more fine-grained cluster handling.
+     */
     get cluster() {
         return read(this.ptr, { type: "int", size: 32, unsigned: true }, 8);
     }

package/dist/generated/harfbuzz/glyph-position-t.d.ts

@@ -1,9 +1,30 @@
+/**
+ * The #hb_glyph_position_t is the structure that holds the positions of the
+ * glyph in both horizontal and vertical directions. All positions in
+ * #hb_glyph_position_t are relative to the current point.
+ */
 export declare class GlyphPositionT {
     ptr: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    /**
+     * how much the line advances after drawing this glyph when setting
+     * text in horizontal direction.
+     */
     get xAdvance(): number;
+    /**
+     * how much the line advances after drawing this glyph when setting
+     * text in vertical direction.
+     */
     get yAdvance(): number;
+    /**
+     * how much the glyph moves on the X-axis before drawing it, this
+     * should not affect how much the line advances.
+     */
     get xOffset(): number;
+    /**
+     * how much the glyph moves on the Y-axis before drawing it, this
+     * should not affect how much the line advances.
+     */
     get yOffset(): number;
 }

package/dist/generated/harfbuzz/glyph-position-t.js

@@ -1,4 +1,9 @@
 import { alloc, read } from "@gtkx/native";
+/**
+ * The #hb_glyph_position_t is the structure that holds the positions of the
+ * glyph in both horizontal and vertical directions. All positions in
+ * #hb_glyph_position_t are relative to the current point.
+ */
 export class GlyphPositionT {
     ptr;
     constructor() {
@@ -7,15 +12,31 @@ export class GlyphPositionT {
     createPtr(_init) {
         return alloc(32, "hb_glyph_position_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
     }
+    /**
+     * how much the line advances after drawing this glyph when setting
+     * text in horizontal direction.
+     */
     get xAdvance() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 0);
     }
+    /**
+     * how much the line advances after drawing this glyph when setting
+     * text in vertical direction.
+     */
     get yAdvance() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 8);
     }
+    /**
+     * how much the glyph moves on the X-axis before drawing it, this
+     * should not affect how much the line advances.
+     */
     get xOffset() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 16);
     }
+    /**
+     * how much the glyph moves on the Y-axis before drawing it, this
+     * should not affect how much the line advances.
+     */
     get yOffset() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 24);
     }

package/dist/generated/harfbuzz/map-t.d.ts

@@ -1,3 +1,4 @@
+/** Data type for holding integer-to-integer hash maps. */
 export declare class MapT {
     ptr: unknown;
     constructor();

package/dist/generated/harfbuzz/map-t.js

@@ -1,3 +1,4 @@
+/** Data type for holding integer-to-integer hash maps. */
 export class MapT {
     ptr;
     constructor() {

package/dist/generated/harfbuzz/ot-math-glyph-part-t.d.ts

@@ -1,11 +1,21 @@
 import { OtMathGlyphPartFlagsT } from "./enums.js";
+/**
+ * Data type to hold information for a "part" component of a math-variant glyph.
+ * Large variants for stretchable math glyphs (such as parentheses) can be constructed
+ * on the fly from parts.
+ */
 export declare class OtMathGlyphPartT {
     ptr: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    /** The glyph index of the variant part */
     get glyph(): number;
+    /** The length of the connector on the starting side of the variant part */
     get startConnectorLength(): number;
+    /** The length of the connector on the ending side of the variant part */
     get endConnectorLength(): number;
+    /** The total advance of the part */
     get fullAdvance(): number;
+    /** #hb_ot_math_glyph_part_flags_t flags for the part */
     get flags(): OtMathGlyphPartFlagsT;
 }

package/dist/generated/harfbuzz/ot-math-glyph-part-t.js

@@ -1,4 +1,9 @@
 import { alloc, read } from "@gtkx/native";
+/**
+ * Data type to hold information for a "part" component of a math-variant glyph.
+ * Large variants for stretchable math glyphs (such as parentheses) can be constructed
+ * on the fly from parts.
+ */
 export class OtMathGlyphPartT {
     ptr;
     constructor() {
@@ -7,18 +12,23 @@ export class OtMathGlyphPartT {
     createPtr(_init) {
         return alloc(40, "hb_ot_math_glyph_part_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
     }
+    /** The glyph index of the variant part */
     get glyph() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 0);
     }
+    /** The length of the connector on the starting side of the variant part */
     get startConnectorLength() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 8);
     }
+    /** The length of the connector on the ending side of the variant part */
     get endConnectorLength() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 16);
     }
+    /** The total advance of the part */
     get fullAdvance() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 24);
     }
+    /** #hb_ot_math_glyph_part_flags_t flags for the part */
     get flags() {
         return read(this.ptr, { type: "int", size: 32, unsigned: false }, 32);
     }

package/dist/generated/harfbuzz/ot-math-glyph-variant-t.d.ts

@@ -1,7 +1,10 @@
+/** Data type to hold math-variant information for a glyph. */
 export declare class OtMathGlyphVariantT {
     ptr: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    /** The glyph index of the variant */
     get glyph(): number;
+    /** The advance width of the variant */
     get advance(): number;
 }

package/dist/generated/harfbuzz/ot-math-glyph-variant-t.js

@@ -1,4 +1,5 @@
 import { alloc, read } from "@gtkx/native";
+/** Data type to hold math-variant information for a glyph. */
 export class OtMathGlyphVariantT {
     ptr;
     constructor() {
@@ -7,9 +8,11 @@ export class OtMathGlyphVariantT {
     createPtr(_init) {
         return alloc(16, "hb_ot_math_glyph_variant_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
     }
+    /** The glyph index of the variant */
     get glyph() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 0);
     }
+    /** The advance width of the variant */
     get advance() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 8);
     }

package/dist/generated/harfbuzz/ot-var-axis-info-t.d.ts

@@ -5,19 +5,34 @@ export interface OtVarAxisInfoTInit {
     defaultValue?: number;
     maxValue?: number;
 }
+/**
+ * Data type for holding variation-axis values.
+ *
+ * The minimum, default, and maximum values are in un-normalized, user scales.
+ *
+ * <note>Note: at present, the only flag defined for `flags` is
+ * #HB_OT_VAR_AXIS_FLAG_HIDDEN.</note>
+ */
 export declare class OtVarAxisInfoT {
     ptr: unknown;
     constructor(init?: OtVarAxisInfoTInit);
     protected createPtr(init: OtVarAxisInfoTInit): unknown;
+    /** Index of the axis in the variation-axis array */
     get axisIndex(): number;
     set axisIndex(value: number);
+    /** The #hb_tag_t tag identifying the design variation of the axis */
     get tag(): number;
+    /** The `name` table Name ID that provides display names for the axis */
     get nameId(): number;
+    /** The #hb_ot_var_axis_flags_t flags for the axis */
     get flags(): OtVarAxisFlagsT;
+    /** The minimum value on the variation axis that the font covers */
     get minValue(): number;
     set minValue(value: number);
+    /** The position on the variation axis corresponding to the font's defaults */
     get defaultValue(): number;
     set defaultValue(value: number);
+    /** The maximum value on the variation axis that the font covers */
     get maxValue(): number;
     set maxValue(value: number);
 }

package/dist/generated/harfbuzz/ot-var-axis-info-t.js

@@ -1,4 +1,12 @@
 import { alloc, read, write } from "@gtkx/native";
+/**
+ * Data type for holding variation-axis values.
+ *
+ * The minimum, default, and maximum values are in un-normalized, user scales.
+ *
+ * <note>Note: at present, the only flag defined for `flags` is
+ * #HB_OT_VAR_AXIS_FLAG_HIDDEN.</note>
+ */
 export class OtVarAxisInfoT {
     ptr;
     constructor(init = {}) {
@@ -16,33 +24,40 @@ export class OtVarAxisInfoT {
             write(ptr, { type: "float", size: 32 }, 40, init.maxValue);
         return ptr;
     }
+    /** Index of the axis in the variation-axis array */
     get axisIndex() {
         return read(this.ptr, { type: "int", size: 32, unsigned: true }, 0);
     }
     set axisIndex(value) {
         write(this.ptr, { type: "int", size: 32, unsigned: true }, 0, value);
     }
+    /** The #hb_tag_t tag identifying the design variation of the axis */
     get tag() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 8);
     }
+    /** The `name` table Name ID that provides display names for the axis */
     get nameId() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 16);
     }
+    /** The #hb_ot_var_axis_flags_t flags for the axis */
     get flags() {
         return read(this.ptr, { type: "int", size: 32, unsigned: false }, 24);
     }
+    /** The minimum value on the variation axis that the font covers */
     get minValue() {
         return read(this.ptr, { type: "float", size: 32 }, 32);
     }
     set minValue(value) {
         write(this.ptr, { type: "float", size: 32 }, 32, value);
     }
+    /** The position on the variation axis corresponding to the font's defaults */
     get defaultValue() {
         return read(this.ptr, { type: "float", size: 32 }, 36);
     }
     set defaultValue(value) {
         write(this.ptr, { type: "float", size: 32 }, 36, value);
     }
+    /** The maximum value on the variation axis that the font covers */
     get maxValue() {
         return read(this.ptr, { type: "float", size: 32 }, 40);
     }

package/dist/generated/harfbuzz/paint-funcs-t.d.ts

@@ -1,3 +1,25 @@
+/**
+ * Glyph paint callbacks.
+ *
+ * The callbacks assume that the caller maintains a stack
+ * of current transforms, clips and intermediate surfaces,
+ * as evidenced by the pairs of push/pop callbacks. The
+ * push/pop calls will be properly nested, so it is fine
+ * to store the different kinds of object on a single stack.
+ *
+ * Not all callbacks are required for all kinds of glyphs.
+ * For rendering COLRv0 or non-color outline glyphs, the
+ * gradient callbacks are not needed, and the composite
+ * callback only needs to handle simple alpha compositing
+ * (#HB_PAINT_COMPOSITE_MODE_SRC_OVER).
+ *
+ * The paint-image callback is only needed for glyphs
+ * with image blobs in the CBDT, sbix or SVG tables.
+ *
+ * The custom-palette-color callback is only necessary if
+ * you want to override colors from the font palette with
+ * custom colors.
+ */
 export declare class PaintFuncsT {
     ptr: unknown;
     constructor();

package/dist/generated/harfbuzz/paint-funcs-t.js

@@ -1,3 +1,25 @@
+/**
+ * Glyph paint callbacks.
+ *
+ * The callbacks assume that the caller maintains a stack
+ * of current transforms, clips and intermediate surfaces,
+ * as evidenced by the pairs of push/pop callbacks. The
+ * push/pop calls will be properly nested, so it is fine
+ * to store the different kinds of object on a single stack.
+ *
+ * Not all callbacks are required for all kinds of glyphs.
+ * For rendering COLRv0 or non-color outline glyphs, the
+ * gradient callbacks are not needed, and the composite
+ * callback only needs to handle simple alpha compositing
+ * (#HB_PAINT_COMPOSITE_MODE_SRC_OVER).
+ *
+ * The paint-image callback is only needed for glyphs
+ * with image blobs in the CBDT, sbix or SVG tables.
+ *
+ * The custom-palette-color callback is only necessary if
+ * you want to override colors from the font palette with
+ * custom colors.
+ */
 export class PaintFuncsT {
     ptr;
     constructor() {

package/dist/generated/harfbuzz/segment-properties-t.d.ts

@@ -1,9 +1,17 @@
 import { DirectionT, ScriptT } from "./enums.js";
+/**
+ * The structure that holds various text properties of an #hb_buffer_t. Can be
+ * set and retrieved using hb_buffer_set_segment_properties() and
+ * hb_buffer_get_segment_properties(), respectively.
+ */
 export declare class SegmentPropertiesT {
     ptr: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    /** the #hb_direction_t of the buffer, see hb_buffer_set_direction(). */
     get direction(): DirectionT;
+    /** the #hb_script_t of the buffer, see hb_buffer_set_script(). */
     get script(): ScriptT;
+    /** the #hb_language_t of the buffer, see hb_buffer_set_language(). */
     get language(): number;
 }

package/dist/generated/harfbuzz/segment-properties-t.js

@@ -1,4 +1,9 @@
 import { alloc, read } from "@gtkx/native";
+/**
+ * The structure that holds various text properties of an #hb_buffer_t. Can be
+ * set and retrieved using hb_buffer_set_segment_properties() and
+ * hb_buffer_get_segment_properties(), respectively.
+ */
 export class SegmentPropertiesT {
     ptr;
     constructor() {
@@ -7,12 +12,15 @@ export class SegmentPropertiesT {
     createPtr(_init) {
         return alloc(24, "hb_segment_properties_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
     }
+    /** the #hb_direction_t of the buffer, see hb_buffer_set_direction(). */
     get direction() {
         return read(this.ptr, { type: "int", size: 32, unsigned: false }, 0);
     }
+    /** the #hb_script_t of the buffer, see hb_buffer_set_script(). */
     get script() {
         return read(this.ptr, { type: "int", size: 32, unsigned: false }, 8);
     }
+    /** the #hb_language_t of the buffer, see hb_buffer_set_language(). */
     get language() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 16);
     }

package/dist/generated/harfbuzz/set-t.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Data type for holding a set of integers. #hb_set_t's are
+ * used to gather and contain glyph IDs, Unicode code
+ * points, and various other collections of discrete
+ * values.
+ */
 export declare class SetT {
     ptr: unknown;
     constructor();

package/dist/generated/harfbuzz/set-t.js

@@ -1,3 +1,9 @@
+/**
+ * Data type for holding a set of integers. #hb_set_t's are
+ * used to gather and contain glyph IDs, Unicode code
+ * points, and various other collections of discrete
+ * values.
+ */
 export class SetT {
     ptr;
     constructor() {

package/dist/generated/harfbuzz/shape-plan-t.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Data type for holding a shaping plan.
+ *
+ * Shape plans contain information about how HarfBuzz will shape a
+ * particular text segment, based on the segment's properties and the
+ * capabilities in the font face in use.
+ *
+ * Shape plans can be queried about how shaping will perform, given a set
+ * of specific input parameters (script, language, direction, features,
+ * etc.).
+ */
 export declare class ShapePlanT {
     ptr: unknown;
     constructor();

package/dist/generated/harfbuzz/shape-plan-t.js

@@ -1,3 +1,14 @@
+/**
+ * Data type for holding a shaping plan.
+ *
+ * Shape plans contain information about how HarfBuzz will shape a
+ * particular text segment, based on the segment's properties and the
+ * capabilities in the font face in use.
+ *
+ * Shape plans can be queried about how shaping will perform, given a set
+ * of specific input parameters (script, language, direction, features,
+ * etc.).
+ */
 export class ShapePlanT {
     ptr;
     constructor() {

package/dist/generated/harfbuzz/unicode-funcs-t.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Data type containing a set of virtual methods used for
+ * accessing various Unicode character properties.
+ *
+ * HarfBuzz provides a default function for each of the
+ * methods in #hb_unicode_funcs_t. Client programs can implement
+ * their own replacements for the individual Unicode functions, as
+ * needed, and replace the default by calling the setter for a
+ * method.
+ */
 export declare class UnicodeFuncsT {
     ptr: unknown;
     constructor();

package/dist/generated/harfbuzz/unicode-funcs-t.js

@@ -1,3 +1,13 @@
+/**
+ * Data type containing a set of virtual methods used for
+ * accessing various Unicode character properties.
+ *
+ * HarfBuzz provides a default function for each of the
+ * methods in #hb_unicode_funcs_t. Client programs can implement
+ * their own replacements for the individual Unicode functions, as
+ * needed, and replace the default by calling the setter for a
+ * method.
+ */
 export class UnicodeFuncsT {
     ptr;
     constructor() {

package/dist/generated/harfbuzz/user-data-key-t.d.ts

@@ -1,3 +1,4 @@
+/** Data structure for holding user-data keys. */
 export declare class UserDataKeyT {
     ptr: unknown;
     constructor();

package/dist/generated/harfbuzz/user-data-key-t.js

@@ -1,4 +1,5 @@
 import { alloc } from "@gtkx/native";
+/** Data structure for holding user-data keys. */
 export class UserDataKeyT {
     ptr;
     constructor() {

package/dist/generated/pango/attr-iterator.d.ts

@@ -3,15 +3,63 @@ import { AttrType } from "./enums.js";
 import { Attribute } from "./attribute.js";
 import { FontDescription } from "./font-description.js";
 import { Language } from "./language.js";
+/**
+ * A `PangoAttrIterator` is used to iterate through a `PangoAttrList`.
+ *
+ * A new iterator is created with [method@Pango.AttrList.get_iterator].
+ * Once the iterator is created, it can be advanced through the style
+ * changes in the text using [method@Pango.AttrIterator.next]. At each
+ * style change, the range of the current style segment and the attributes
+ * currently in effect can be queried.
+ */
 export declare class AttrIterator {
     ptr: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    /**
+     * Copy a `PangoAttrIterator`.
+     */
     copy(): AttrIterator;
+    /**
+     * Destroy a `PangoAttrIterator` and free all associated memory.
+     */
     destroy(): void;
+    /**
+     * Find the current attribute of a particular type
+     * at the iterator location.
+     *
+     * When multiple attributes of the same type overlap,
+     * the attribute whose range starts closest to the
+     * current location is used.
+     * @param type - the type of attribute to find
+     */
     get(type: AttrType): Attribute | null;
+    /**
+     * Gets a list of all attributes at the current position of the
+     * iterator.
+     */
     getAttrs(): Attribute[];
+    /**
+     * Get the font and other attributes at the current
+     * iterator position.
+     * @param desc - a `PangoFontDescription` to fill in with the current
+     * @param language - location to store language tag
+     * @param extraAttrs - location in which to store a list of non-font attributes
+     */
     getFont(desc: FontDescription, language?: Ref<Language> | null, extraAttrs?: Ref<Attribute[]> | null): void;
+    /**
+     * Advance the iterator until the next change of style.
+     */
     next(): boolean;
+    /**
+     * Get the range of the current segment.
+     *
+     * Note that the stored return values are signed, not unsigned
+     * like the values in `PangoAttribute`. To deal with this API
+     * oversight, stored return values that wouldn't fit into
+     * a signed integer are clamped to %G_MAXINT.
+     * @param start - location to store the start of the range
+     * @param end - location to store the end of the range
+     */
     range(start: Ref<number>, end: Ref<number>): void;
 }