@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/harfbuzz/enums.js

@@ -35,7 +35,7 @@ export var BufferClusterLevelT;
 (function (BufferClusterLevelT) {
     /**
      * Return cluster values grouped by graphemes into
-     * monotone order.
+     *   monotone order.
      */
     BufferClusterLevelT[BufferClusterLevelT["MONOTONE_GRAPHEMES"] = 0] = "MONOTONE_GRAPHEMES";
     /** Return cluster values grouped into monotone order. */
@@ -46,7 +46,7 @@ export var BufferClusterLevelT;
     BufferClusterLevelT[BufferClusterLevelT["GRAPHEMES"] = 3] = "GRAPHEMES";
     /**
      * Default cluster level,
-     * equal to `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES`.
+     *   equal to `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES`.
      */
     BufferClusterLevelT[BufferClusterLevelT["DEFAULT"] = 0] = "DEFAULT";
 })(BufferClusterLevelT || (BufferClusterLevelT = {}));
@@ -87,20 +87,20 @@ export var DirectionT;
  * Regarding these various memory-modes:
  *
  * - In no case shall the HarfBuzz client modify memory
- * that is passed to HarfBuzz in a blob.  If there is
- * any such possibility, `HB_MEMORY_MODE_DUPLICATE` should be used
- * such that HarfBuzz makes a copy immediately,
+ *   that is passed to HarfBuzz in a blob.  If there is
+ *   any such possibility, `HB_MEMORY_MODE_DUPLICATE` should be used
+ *   such that HarfBuzz makes a copy immediately,
  *
  * - Use `HB_MEMORY_MODE_READONLY` otherwise, unless you really really
- * really know what you are doing,
+ *   really know what you are doing,
  *
  * - `HB_MEMORY_MODE_WRITABLE` is appropriate if you really made a
- * copy of data solely for the purpose of passing to
- * HarfBuzz and doing that just once (no reuse!),
+ *   copy of data solely for the purpose of passing to
+ *   HarfBuzz and doing that just once (no reuse!),
  *
  * - If the font is mmap()ed, it's okay to use
- * `HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE`, however, using that mode
- * correctly is very tricky.  Use `HB_MEMORY_MODE_READONLY` instead.
+ *   `HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE`, however, using that mode
+ *   correctly is very tricky.  Use `HB_MEMORY_MODE_READONLY` instead.
  */
 export var MemoryModeT;
 (function (MemoryModeT) {
@@ -108,12 +108,12 @@ export var MemoryModeT;
     MemoryModeT[MemoryModeT["DUPLICATE"] = 0] = "DUPLICATE";
     /**
      * HarfBuzz client will never modify the data,
-     * and HarfBuzz will never modify the data.
+     *     and HarfBuzz will never modify the data.
      */
     MemoryModeT[MemoryModeT["READONLY"] = 1] = "READONLY";
     /**
      * HarfBuzz client made a copy of the data solely
-     * for HarfBuzz, so HarfBuzz may modify the data.
+     *     for HarfBuzz, so HarfBuzz may modify the data.
      */
     MemoryModeT[MemoryModeT["WRITABLE"] = 2] = "WRITABLE";
     /** See above */
@@ -488,19 +488,19 @@ export var PaintExtendT;
 (function (PaintExtendT) {
     /**
      * Outside the defined interval,
-     * the color of the closest color stop is used.
+     *   the color of the closest color stop is used.
      */
     PaintExtendT[PaintExtendT["PAD"] = 0] = "PAD";
     /**
      * The color line is repeated over
-     * repeated multiples of the defined interval
+     *   repeated multiples of the defined interval
      */
     PaintExtendT[PaintExtendT["REPEAT"] = 1] = "REPEAT";
     /**
      * The color line is repeated over
-     * repeated intervals, as for the repeat mode.
-     * However, in each repeated interval, the ordering of
-     * color stops is the reverse of the adjacent interval.
+     *      repeated intervals, as for the repeat mode.
+     *      However, in each repeated interval, the ordering of
+     *      color stops is the reverse of the adjacent interval.
      */
     PaintExtendT[PaintExtendT["REFLECT"] = 2] = "REFLECT";
 })(PaintExtendT || (PaintExtendT = {}));
@@ -514,9 +514,7 @@ export var PaintExtendT;
  */
 export var UnicodeCombiningClassT;
 (function (UnicodeCombiningClassT) {
-    /**
-     * Spacing and enclosing marks; also many vowel and consonant signs, even if nonspacing
-     */
+    /** Spacing and enclosing marks; also many vowel and consonant signs, even if nonspacing */
     UnicodeCombiningClassT[UnicodeCombiningClassT["NOT_REORDERED"] = 0] = "NOT_REORDERED";
     /** Marks which overlay a base letter or symbol */
     UnicodeCombiningClassT[UnicodeCombiningClassT["OVERLAY"] = 1] = "OVERLAY";
@@ -1204,9 +1202,7 @@ export var AatLayoutFeatureSelectorT;
     /** for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE */
     AatLayoutFeatureSelectorT[AatLayoutFeatureSelectorT["B_AAT_LAYOUT_FEATURE_SELECTOR_FULL_WIDTH_CJK_ROMAN"] = 3] = "B_AAT_LAYOUT_FEATURE_SELECTOR_FULL_WIDTH_CJK_ROMAN";
 })(AatLayoutFeatureSelectorT || (AatLayoutFeatureSelectorT = {}));
-/**
- * The possible feature types defined for AAT shaping, from Apple Font Feature Registry.
- */
+/** The possible feature types defined for AAT shaping, from Apple Font Feature Registry. */
 export var AatLayoutFeatureTypeT;
 (function (AatLayoutFeatureTypeT) {
     /** Initial, unset feature type */
@@ -1309,19 +1305,19 @@ export var BufferDiffFlagsT;
     BufferDiffFlagsT[BufferDiffFlagsT["EQUAL"] = 0] = "EQUAL";
     /**
      * buffers with different
-     * #hb_buffer_content_type_t.
+     *     #hb_buffer_content_type_t.
      */
     BufferDiffFlagsT[BufferDiffFlagsT["CONTENT_TYPE_MISMATCH"] = 1] = "CONTENT_TYPE_MISMATCH";
     /** buffers with differing length. */
     BufferDiffFlagsT[BufferDiffFlagsT["LENGTH_MISMATCH"] = 2] = "LENGTH_MISMATCH";
     /**
      * `.notdef` glyph is present in the
-     * reference buffer.
+     *     reference buffer.
      */
     BufferDiffFlagsT[BufferDiffFlagsT["NOTDEF_PRESENT"] = 4] = "NOTDEF_PRESENT";
     /**
      * dotted circle glyph is present
-     * in the reference buffer.
+     *     in the reference buffer.
      */
     BufferDiffFlagsT[BufferDiffFlagsT["DOTTED_CIRCLE_PRESENT"] = 8] = "DOTTED_CIRCLE_PRESENT";
     /** difference in #hb_glyph_info_t.codepoint */
@@ -1340,69 +1336,67 @@ export var BufferFlagsT;
     BufferFlagsT[BufferFlagsT["DEFAULT"] = 0] = "DEFAULT";
     /**
      * flag indicating that special handling of the beginning
-     * of text paragraph can be applied to this buffer. Should usually
-     * be set, unless you are passing to the buffer only part
-     * of the text without the full context.
+     *                      of text paragraph can be applied to this buffer. Should usually
+     *                      be set, unless you are passing to the buffer only part
+     *                      of the text without the full context.
      */
     BufferFlagsT[BufferFlagsT["BOT"] = 1] = "BOT";
     /**
      * flag indicating that special handling of the end of text
-     * paragraph can be applied to this buffer, similar to
-     * `HB_BUFFER_FLAG_BOT`.
+     *                      paragraph can be applied to this buffer, similar to
+     *                      `HB_BUFFER_FLAG_BOT`.
      */
     BufferFlagsT[BufferFlagsT["EOT"] = 2] = "EOT";
     /**
      * flag indication that character with Default_Ignorable
-     * Unicode property should use the corresponding glyph
-     * from the font, instead of hiding them (done by
-     * replacing them with the space glyph and zeroing the
-     * advance width.)  This flag takes precedence over
-     * `HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES`.
+     *                      Unicode property should use the corresponding glyph
+     *                      from the font, instead of hiding them (done by
+     *                      replacing them with the space glyph and zeroing the
+     *                      advance width.)  This flag takes precedence over
+     *                      `HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES`.
      */
     BufferFlagsT[BufferFlagsT["PRESERVE_DEFAULT_IGNORABLES"] = 4] = "PRESERVE_DEFAULT_IGNORABLES";
     /**
      * flag indication that character with Default_Ignorable
-     * Unicode property should be removed from glyph string
-     * instead of hiding them (done by replacing them with the
-     * space glyph and zeroing the advance width.)
-     * `HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES` takes
-     * precedence over this flag. Since: 1.8.0
+     *                      Unicode property should be removed from glyph string
+     *                      instead of hiding them (done by replacing them with the
+     *                      space glyph and zeroing the advance width.)
+     *                      `HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES` takes
+     *                      precedence over this flag. Since: 1.8.0
      */
     BufferFlagsT[BufferFlagsT["REMOVE_DEFAULT_IGNORABLES"] = 8] = "REMOVE_DEFAULT_IGNORABLES";
     /**
      * flag indicating that a dotted circle should
-     * not be inserted in the rendering of incorrect
-     * character sequences (such at <0905 093E>). Since: 2.4.0
+     *                      not be inserted in the rendering of incorrect
+     *                      character sequences (such at <0905 093E>). Since: 2.4.0
      */
     BufferFlagsT[BufferFlagsT["DO_NOT_INSERT_DOTTED_CIRCLE"] = 16] = "DO_NOT_INSERT_DOTTED_CIRCLE";
     /**
      * flag indicating that the hb_shape() call and its variants
-     * should perform various verification processes on the results
-     * of the shaping operation on the buffer.  If the verification
-     * fails, then either a buffer message is sent, if a message
-     * handler is installed on the buffer, or a message is written
-     * to standard error.  In either case, the shaping result might
-     * be modified to show the failed output. Since: 3.4.0
+     *                      should perform various verification processes on the results
+     *                      of the shaping operation on the buffer.  If the verification
+     *                      fails, then either a buffer message is sent, if a message
+     *                      handler is installed on the buffer, or a message is written
+     *                      to standard error.  In either case, the shaping result might
+     *                      be modified to show the failed output. Since: 3.4.0
      */
     BufferFlagsT[BufferFlagsT["VERIFY"] = 32] = "VERIFY";
     /**
      * flag indicating that the `HB_GLYPH_FLAG_UNSAFE_TO_CONCAT`
-     * glyph-flag should be produced by the shaper. By default
-     * it will not be produced since it incurs a cost. Since: 4.0.0
+     *                      glyph-flag should be produced by the shaper. By default
+     *                      it will not be produced since it incurs a cost. Since: 4.0.0
      */
     BufferFlagsT[BufferFlagsT["PRODUCE_UNSAFE_TO_CONCAT"] = 64] = "PRODUCE_UNSAFE_TO_CONCAT";
     /**
      * flag indicating that the `HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL`
-     * glyph-flag should be produced by the shaper. By default
-     * it will not be produced. Since: 5.1.0
+     *                      glyph-flag should be produced by the shaper. By default
+     *                      it will not be produced. Since: 5.1.0
      */
     BufferFlagsT[BufferFlagsT["PRODUCE_SAFE_TO_INSERT_TATWEEL"] = 128] = "PRODUCE_SAFE_TO_INSERT_TATWEEL";
     /** All currently defined flags: Since: 4.4.0 */
     BufferFlagsT[BufferFlagsT["DEFINED"] = 255] = "DEFINED";
 })(BufferFlagsT || (BufferFlagsT = {}));
-/**
- * Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs().
- */
+/** Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs(). */
 export var BufferSerializeFlagsT;
 (function (BufferSerializeFlagsT) {
     /** serialize glyph names, clusters and positions. */
@@ -1419,7 +1413,7 @@ export var BufferSerializeFlagsT;
     BufferSerializeFlagsT[BufferSerializeFlagsT["GLYPH_FLAGS"] = 16] = "GLYPH_FLAGS";
     /**
      * do not serialize glyph advances,
-     * glyph offsets will reflect absolute glyph positions. Since: 1.8.0
+     *  glyph offsets will reflect absolute glyph positions. Since: 1.8.0
      */
     BufferSerializeFlagsT[BufferSerializeFlagsT["NO_ADVANCES"] = 32] = "NO_ADVANCES";
     /** All currently defined flags. Since: 4.4.0 */
@@ -1443,89 +1437,89 @@ export var GlyphFlagsT;
 (function (GlyphFlagsT) {
     /**
      * Indicates that if input text is broken at the
-     * beginning of the cluster this glyph is part of,
-     * then both sides need to be re-shaped, as the
-     * result might be different.
-     * On the flip side, it means that when this
-     * flag is not present, then it is safe to break
-     * the glyph-run at the beginning of this
-     * cluster, and the two sides will represent the
-     * exact same result one would get if breaking
-     * input text at the beginning of this cluster
-     * and shaping the two sides separately.
-     * This can be used to optimize paragraph
-     * layout, by avoiding re-shaping of each line
-     * after line-breaking.
+     * 				   beginning of the cluster this glyph is part of,
+     * 				   then both sides need to be re-shaped, as the
+     * 				   result might be different.
+     * 				   On the flip side, it means that when this
+     * 				   flag is not present, then it is safe to break
+     * 				   the glyph-run at the beginning of this
+     * 				   cluster, and the two sides will represent the
+     * 				   exact same result one would get if breaking
+     * 				   input text at the beginning of this cluster
+     * 				   and shaping the two sides separately.
+     * 				   This can be used to optimize paragraph
+     * 				   layout, by avoiding re-shaping of each line
+     * 				   after line-breaking.
      */
     GlyphFlagsT[GlyphFlagsT["UNSAFE_TO_BREAK"] = 1] = "UNSAFE_TO_BREAK";
     /**
      * Indicates that if input text is changed on one
-     * side of the beginning of the cluster this glyph
-     * is part of, then the shaping results for the
-     * other side might change.
-     * Note that the absence of this flag will NOT by
-     * itself mean that it IS safe to concat text.
-     * Only two pieces of text both of which clear of
-     * this flag can be concatenated safely.
-     * This can be used to optimize paragraph
-     * layout, by avoiding re-shaping of each line
-     * after line-breaking, by limiting the
-     * reshaping to a small piece around the
-     * breaking position only, even if the breaking
-     * position carries the
-     * #HB_GLYPH_FLAG_UNSAFE_TO_BREAK or when
-     * hyphenation or other text transformation
-     * happens at line-break position, in the following
-     * way:
-     * 1. Iterate back from the line-break position
-     * until the first cluster start position that is
-     * NOT unsafe-to-concat, 2. shape the segment from
-     * there till the end of line, 3. check whether the
-     * resulting glyph-run also is clear of the
-     * unsafe-to-concat at its start-of-text position;
-     * if it is, just splice it into place and the line
-     * is shaped; If not, move on to a position further
-     * back that is clear of unsafe-to-concat and retry
-     * from there, and repeat.
-     * At the start of next line a similar algorithm can
-     * be implemented. That is: 1. Iterate forward from
-     * the line-break position until the first cluster
-     * start position that is NOT unsafe-to-concat, 2.
-     * shape the segment from beginning of the line to
-     * that position, 3. check whether the resulting
-     * glyph-run also is clear of the unsafe-to-concat
-     * at its end-of-text position; if it is, just splice
-     * it into place and the beginning is shaped; If not,
-     * move on to a position further forward that is clear
-     * of unsafe-to-concat and retry up to there, and repeat.
-     * A slight complication will arise in the
-     * implementation of the algorithm above,
-     * because while our buffer API has a way to
-     * return flags for position corresponding to
-     * start-of-text, there is currently no position
-     * corresponding to end-of-text.  This limitation
-     * can be alleviated by shaping more text than needed
-     * and looking for unsafe-to-concat flag within text
-     * clusters.
-     * The #HB_GLYPH_FLAG_UNSAFE_TO_BREAK flag will
-     * always imply this flag.
-     * To use this flag, you must enable the buffer flag
-     * `HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT` during
-     * shaping, otherwise the buffer flag will not be
-     * reliably produced.
-     * Since: 4.0.0
+     * 				   side of the beginning of the cluster this glyph
+     * 				   is part of, then the shaping results for the
+     * 				   other side might change.
+     * 				   Note that the absence of this flag will NOT by
+     * 				   itself mean that it IS safe to concat text.
+     * 				   Only two pieces of text both of which clear of
+     * 				   this flag can be concatenated safely.
+     * 				   This can be used to optimize paragraph
+     * 				   layout, by avoiding re-shaping of each line
+     * 				   after line-breaking, by limiting the
+     * 				   reshaping to a small piece around the
+     * 				   breaking position only, even if the breaking
+     * 				   position carries the
+     * 				   #HB_GLYPH_FLAG_UNSAFE_TO_BREAK or when
+     * 				   hyphenation or other text transformation
+     * 				   happens at line-break position, in the following
+     * 				   way:
+     * 				   1. Iterate back from the line-break position
+     * 				   until the first cluster start position that is
+     * 				   NOT unsafe-to-concat, 2. shape the segment from
+     * 				   there till the end of line, 3. check whether the
+     * 				   resulting glyph-run also is clear of the
+     * 				   unsafe-to-concat at its start-of-text position;
+     * 				   if it is, just splice it into place and the line
+     * 				   is shaped; If not, move on to a position further
+     * 				   back that is clear of unsafe-to-concat and retry
+     * 				   from there, and repeat.
+     * 				   At the start of next line a similar algorithm can
+     * 				   be implemented. That is: 1. Iterate forward from
+     * 				   the line-break position until the first cluster
+     * 				   start position that is NOT unsafe-to-concat, 2.
+     * 				   shape the segment from beginning of the line to
+     * 				   that position, 3. check whether the resulting
+     * 				   glyph-run also is clear of the unsafe-to-concat
+     * 				   at its end-of-text position; if it is, just splice
+     * 				   it into place and the beginning is shaped; If not,
+     * 				   move on to a position further forward that is clear
+     * 				   of unsafe-to-concat and retry up to there, and repeat.
+     * 				   A slight complication will arise in the
+     * 				   implementation of the algorithm above,
+     * 				   because while our buffer API has a way to
+     * 				   return flags for position corresponding to
+     * 				   start-of-text, there is currently no position
+     * 				   corresponding to end-of-text.  This limitation
+     * 				   can be alleviated by shaping more text than needed
+     * 				   and looking for unsafe-to-concat flag within text
+     * 				   clusters.
+     * 				   The #HB_GLYPH_FLAG_UNSAFE_TO_BREAK flag will
+     * 				   always imply this flag.
+     * 			   To use this flag, you must enable the buffer flag
+     * 			   `HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT` during
+     * 			   shaping, otherwise the buffer flag will not be
+     * 			   reliably produced.
+     * 				   Since: 4.0.0
      */
     GlyphFlagsT[GlyphFlagsT["UNSAFE_TO_CONCAT"] = 2] = "UNSAFE_TO_CONCAT";
     /**
      * In scripts that use elongation (Arabic,
-     * Mongolian, Syriac, etc.), this flag signifies
-     * that it is safe to insert a U+0640 TATWEEL
-     * character before this cluster for elongation.
-     * This flag does not determine the
-     * script-specific elongation places, but only
-     * when it is safe to do the elongation without
-     * interrupting text shaping.
-     * Since: 5.1.0
+     * 				   Mongolian, Syriac, etc.), this flag signifies
+     * 				   that it is safe to insert a U+0640 TATWEEL
+     * 				   character before this cluster for elongation.
+     * 				   This flag does not determine the
+     * 				   script-specific elongation places, but only
+     * 				   when it is safe to do the elongation without
+     * 				   interrupting text shaping.
+     * 				   Since: 5.1.0
      */
     GlyphFlagsT[GlyphFlagsT["SAFE_TO_INSERT_TATWEEL"] = 4] = "SAFE_TO_INSERT_TATWEEL";
     /** All the currently defined flags. */
@@ -1536,23 +1530,21 @@ export var OtColorPaletteFlagsT;
 (function (OtColorPaletteFlagsT) {
     /**
      * Default indicating that there is nothing special
-     * to note about a color palette.
+     *   to note about a color palette.
      */
     OtColorPaletteFlagsT[OtColorPaletteFlagsT["DEFAULT"] = 0] = "DEFAULT";
     /**
      * Flag indicating that the color
-     * palette is appropriate to use when displaying the font on a light background such as white.
+     *   palette is appropriate to use when displaying the font on a light background such as white.
      */
     OtColorPaletteFlagsT[OtColorPaletteFlagsT["USABLE_WITH_LIGHT_BACKGROUND"] = 1] = "USABLE_WITH_LIGHT_BACKGROUND";
     /**
      * Flag indicating that the color
-     * palette is appropriate to use when displaying the font on a dark background such as black.
+     *   palette is appropriate to use when displaying the font on a dark background such as black.
      */
     OtColorPaletteFlagsT[OtColorPaletteFlagsT["USABLE_WITH_DARK_BACKGROUND"] = 2] = "USABLE_WITH_DARK_BACKGROUND";
 })(OtColorPaletteFlagsT || (OtColorPaletteFlagsT = {}));
-/**
- * Baseline tags from [Baseline Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/baselinetags) registry.
- */
+/** Baseline tags from [Baseline Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/baselinetags) registry. */
 export var OtLayoutBaselineTagT;
 (function (OtLayoutBaselineTagT) {
     /**
@@ -1607,9 +1599,7 @@ export var OtMathGlyphPartFlagsT;
      */
     OtMathGlyphPartFlagsT[OtMathGlyphPartFlagsT["OT_MATH_GLYPH_PART_FLAG_EXTENDER"] = 1] = "OT_MATH_GLYPH_PART_FLAG_EXTENDER";
 })(OtMathGlyphPartFlagsT || (OtMathGlyphPartFlagsT = {}));
-/**
- * Known metadata tags from https://docs.microsoft.com/en-us/typography/opentype/spec/meta
- */
+/** Known metadata tags from https://docs.microsoft.com/en-us/typography/opentype/spec/meta */
 export var OtMetaTagT;
 (function (OtMetaTagT) {
     /**
@@ -2057,9 +2047,7 @@ export var ScriptT;
     /** No script set */
     ScriptT[ScriptT["B_SCRIPT_INVALID"] = 0] = "B_SCRIPT_INVALID";
 })(ScriptT || (ScriptT = {}));
-/**
- * Defined by [OpenType Design-Variation Axis Tag Registry](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg).
- */
+/** Defined by [OpenType Design-Variation Axis Tag Registry](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg). */
 export var StyleTagT;
 (function (StyleTagT) {
     /**

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

@@ -4,6 +4,4 @@ export declare class FaceT extends NativeObject {
     static readonly glibTypeName: string;
     static readonly objectType: "boxed";
     constructor();
-    protected createPtr(_init: Record<string, unknown>): unknown;
-    static fromPtr(ptr: unknown): FaceT;
 }

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

@@ -6,15 +6,7 @@ export class FaceT extends NativeObject {
     static objectType = "boxed";
     constructor() {
         super();
-        this.id = this.createPtr({});
-    }
-    createPtr(_init) {
-        return null;
-    }
-    static fromPtr(ptr) {
-        const instance = Object.create(FaceT.prototype);
-        instance.id = ptr;
-        return instance;
+        this.id = null;
     }
 }
 registerNativeClass(FaceT);

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

@@ -16,8 +16,6 @@ export declare class FeatureT extends NativeObject {
     static readonly glibTypeName: string;
     static readonly objectType: "boxed";
     constructor(init?: FeatureTInit);
-    protected createPtr(init: FeatureTInit): unknown;
-    static fromPtr(ptr: unknown): FeatureT;
     /**
      * Converts a #hb_feature_t into a `NULL`-terminated string in the format
      * understood by hb_feature_from_string(). The client in responsible for
@@ -25,8 +23,6 @@ export declare class FeatureT extends NativeObject {
      *
      * Note that the feature value will be omitted if it is '1', but the
      * string won't include any whitespace.
-     * @param buf - output string
-     * @param size - the allocated size of `buf`
      */
     String(buf: Ref<string[]>, size: Ref<number>): void;
     /** The #hb_tag_t tag of the feature */

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

@@ -14,22 +14,25 @@ export class FeatureT extends NativeObject {
     static objectType = "boxed";
     constructor(init = {}) {
         super();
-        this.id = this.createPtr(init);
-    }
-    createPtr(init) {
-        const ptr = alloc(24, "hb_feature_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
+        this.id = alloc(24, "hb_feature_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
         if (init.value !== undefined)
-            write(ptr, { type: "int", size: 32, unsigned: true }, 8, init.value);
+            write(this.id, {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            }, 8, init.value);
         if (init.start !== undefined)
-            write(ptr, { type: "int", size: 32, unsigned: true }, 12, init.start);
+            write(this.id, {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            }, 12, init.start);
         if (init.end !== undefined)
-            write(ptr, { type: "int", size: 32, unsigned: true }, 16, init.end);
-        return ptr;
-    }
-    static fromPtr(ptr) {
-        const instance = Object.create(FeatureT.prototype);
-        instance.id = ptr;
-        return instance;
+            write(this.id, {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            }, 16, init.end);
     }
     /**
      * Converts a #hb_feature_t into a `NULL`-terminated string in the format
@@ -38,15 +41,13 @@ export class FeatureT extends NativeObject {
      *
      * Note that the feature value will be omitted if it is '1', but the
      * string won't include any whitespace.
-     * @param buf - output string
-     * @param size - the allocated size of `buf`
      */
     String(buf, size) {
         call("libharfbuzz-gobject.so.0,libharfbuzz.so.0", "hb_feature_to_string", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "hb_feature_t",
                     lib: "libharfbuzz-gobject.so.0,libharfbuzz.so.0",
                 },
@@ -55,22 +56,40 @@ export class FeatureT extends NativeObject {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "array", itemType: { type: "string" } },
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "string",
+                            ownership: "full",
+                        },
+                        listType: "array",
+                        ownership: "full",
+                    },
                 },
                 value: buf,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
                 },
                 value: size,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /** The #hb_tag_t tag of the feature */
     get tag() {
-        return read(this.id, { type: "int", size: 64, unsigned: true }, 0);
+        return read(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 0);
     }
     /**
      * The value of the feature. 0 disables the feature, non-zero (usually
@@ -78,24 +97,48 @@ export class FeatureT extends NativeObject {
      * 'salt') the `value` is a one based index into the alternates.
      */
     get value() {
-        return read(this.id, { type: "int", size: 32, unsigned: true }, 8);
+        return read(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        }, 8);
     }
     set value(value) {
-        write(this.id, { type: "int", size: 32, unsigned: true }, 8, value);
+        write(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        }, 8, value);
     }
     /** the cluster to start applying this feature setting (inclusive). */
     get start() {
-        return read(this.id, { type: "int", size: 32, unsigned: true }, 12);
+        return read(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        }, 12);
     }
     set start(value) {
-        write(this.id, { type: "int", size: 32, unsigned: true }, 12, value);
+        write(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        }, 12, value);
     }
     /** the cluster to end applying this feature setting (exclusive). */
     get end() {
-        return read(this.id, { type: "int", size: 32, unsigned: true }, 16);
+        return read(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        }, 16);
     }
     set end(value) {
-        write(this.id, { type: "int", size: 32, unsigned: true }, 16, value);
+        write(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        }, 16, value);
     }
 }
 registerNativeClass(FeatureT);

package/dist/generated/harfbuzz/font-extents-t.d.ts

@@ -0,0 +1,5 @@
+import { NativeObject } from "../../native/base.js";
+/** Stub class for font_extents_t (opaque type not fully generated) */
+export declare class FontExtentsT extends NativeObject {
+    static readonly objectType: "boxed";
+}