@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/glib/string.js

@@ -1,12 +1,35 @@
 import { call, read, write } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Bytes } from "./bytes.js";
+/**
+ * A `GString` is an object that handles the memory management of a C string.
+ *
+ * The emphasis of `GString` is on text, typically UTF-8. Crucially, the "str" member
+ * of a `GString` is guaranteed to have a trailing nul character, and it is therefore
+ * always safe to call functions such as `strchr()` or `strdup()` on it.
+ *
+ * However, a `GString` can also hold arbitrary binary data, because it has a "len" member,
+ * which includes any possible embedded nul characters in the data. Conceptually then,
+ * `GString` is like a `GByteArray` with the addition of many convenience methods for
+ * text, and a guaranteed nul terminator.
+ */
 export class String {
     ptr;
     constructor(...args) {
         const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
         this.ptr = this.createPtr(_args);
     }
+    /**
+     * Creates a new #GString with `len` bytes of the `init` buffer.
+     * Because a length is provided, `init` need not be nul-terminated,
+     * and can contain embedded nul bytes.
+     *
+     * Since this function does not stop at nul bytes, it is the caller's
+     * responsibility to ensure that `init` has at least `len` addressable
+     * bytes.
+     * @param init - initial contents of the string
+     * @param len - length of `init` to use
+     */
     static newLen(init, len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_new_len", [
             {
@@ -20,6 +43,14 @@ export class String {
         ], { type: "boxed", borrowed: true, innerType: "String" });
         return getObject(ptr, String);
     }
+    /**
+     * Creates a new #GString, initialized with the given string.
+     *
+     * After this call, `init` belongs to the #GString and may no longer be
+     * modified by the caller. The memory of `init` has to be dynamically
+     * allocated and will eventually be freed with g_free().
+     * @param init - initial text used as the string.
+     */
     static newTake(init) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_new_take", [
             {
@@ -30,6 +61,12 @@ export class String {
         ], { type: "boxed", borrowed: true, innerType: "String" });
         return getObject(ptr, String);
     }
+    /**
+     * Creates a new #GString, with enough space for `dfl_size` bytes. This is useful if you are going to add a lot of
+     * text to the string and don't want it to be reallocated
+     * too often.
+     * @param dflSize - the default size of the space allocated to hold the string
+     */
     static sizedNew(dflSize) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_sized_new", [
             {
@@ -49,6 +86,11 @@ export class String {
             },
         ], { type: "boxed", borrowed: true, innerType: "GString" });
     }
+    /**
+     * Adds a string onto the end of a #GString, expanding
+     * it if necessary.
+     * @param val - the string to append onto the end of @string
+     */
     append(val) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_append", [
             {
@@ -67,6 +109,11 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Adds a byte onto the end of a #GString, expanding
+     * it if necessary.
+     * @param c - the byte to append onto the end of @string
+     */
     appendC(c) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_append_c", [
             {
@@ -85,6 +132,18 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Appends `len` bytes of `val` to @string.
+     *
+     * If `len` is positive, `val` may contain embedded nuls and need
+     * not be nul-terminated. It is the caller's responsibility to
+     * ensure that `val` has at least `len` addressable bytes.
+     *
+     * If `len` is negative, `val` must be nul-terminated and `len` is considered to request the entire string length. This
+     * makes g_string_append_len() equivalent to g_string_append().
+     * @param val - bytes to append
+     * @param len - number of bytes of `val` to use, or -1 for all of @val
+     */
     appendLen(val, len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_append_len", [
             {
@@ -107,6 +166,11 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Converts a Unicode character into UTF-8, and appends it
+     * to the string.
+     * @param wc - a Unicode character
+     */
     appendUnichar(wc) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_append_unichar", [
             {
@@ -125,6 +189,13 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Appends `unescaped` to @string, escaping any characters that
+     * are reserved in URIs using URI-style escape sequences.
+     * @param unescaped - a string
+     * @param reservedCharsAllowed - a string of reserved characters allowed
+     * @param allowUtf8 - set %TRUE if the escaped string may include UTF8 characters
+     */
     appendUriEscaped(unescaped, reservedCharsAllowed, allowUtf8) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_append_uri_escaped", [
             {
@@ -151,6 +222,9 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Converts all uppercase ASCII letters to lowercase ASCII letters.
+     */
     asciiDown() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_ascii_down", [
             {
@@ -165,6 +239,9 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Converts all lowercase ASCII letters to uppercase ASCII letters.
+     */
     asciiUp() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_ascii_up", [
             {
@@ -179,6 +256,13 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Copies the bytes from a string into a #GString,
+     * destroying any previous contents. It is rather like
+     * the standard strcpy() function, except that you do not
+     * have to worry about having enough space to copy the string.
+     * @param rval - the string to copy into @string
+     */
     assign(rval) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_assign", [
             {
@@ -197,6 +281,12 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Copies the [struct@GLib.String] instance and its contents.
+     *
+     * This will preserve the allocation length of the [struct@GLib.String] in the
+     * copy.
+     */
     copy() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_copy", [
             {
@@ -211,6 +301,9 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Converts a #GString to lowercase.
+     */
     down() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_down", [
             {
@@ -225,6 +318,11 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Compares two strings for equality, returning %TRUE if they are equal.
+     * For use with #GHashTable.
+     * @param v2 - another #GString
+     */
     equal(v2) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_equal", [
             {
@@ -242,6 +340,12 @@ export class String {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Removes `len` bytes from a #GString, starting at position @pos.
+     * The rest of the #GString is shifted down to fill the gap.
+     * @param pos - the position of the content to remove
+     * @param len - the number of bytes to remove, or -1 to remove all
+     */
     erase(pos, len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_erase", [
             {
@@ -264,6 +368,16 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Frees the memory allocated for the #GString.
+     * If `free_segment` is %TRUE it also frees the character data.  If
+     * it's %FALSE, the caller gains ownership of the buffer and must
+     * free it after use with g_free().
+     *
+     * Instead of passing %FALSE to this function, consider using
+     * g_string_free_and_steal().
+     * @param freeSegment - if %TRUE, the actual character data is freed as well
+     */
     free(freeSegment) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_free", [
             {
@@ -276,6 +390,12 @@ export class String {
             },
         ], { type: "string" });
     }
+    /**
+     * Frees the memory allocated for the #GString.
+     *
+     * The caller gains ownership of the buffer and
+     * must free it after use with g_free().
+     */
     freeAndSteal() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_free_and_steal", [
             {
@@ -284,6 +404,16 @@ export class String {
             },
         ], { type: "string" });
     }
+    /**
+     * Transfers ownership of the contents of `string` to a newly allocated
+     * #GBytes.  The #GString structure itself is deallocated, and it is
+     * therefore invalid to use `string` after invoking this function.
+     *
+     * Note that while #GString ensures that its buffer always has a
+     * trailing nul character (not reflected in its "len"), the returned
+     * #GBytes does not include this extra nul; i.e. it has length exactly
+     * equal to the "len" member.
+     */
     freeToBytes() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_free_to_bytes", [
             {
@@ -298,6 +428,9 @@ export class String {
         });
         return getObject(ptr, Bytes);
     }
+    /**
+     * Creates a hash code for @str; for use with #GHashTable.
+     */
     hash() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_hash", [
             {
@@ -306,6 +439,12 @@ export class String {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Inserts a copy of a string into a #GString,
+     * expanding it if necessary.
+     * @param pos - the position to insert the copy of the string
+     * @param val - the string to insert
+     */
     insert(pos, val) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_insert", [
             {
@@ -328,6 +467,11 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Inserts a byte into a #GString, expanding it if necessary.
+     * @param pos - the position to insert the byte
+     * @param c - the byte to insert
+     */
     insertC(pos, c) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_insert_c", [
             {
@@ -350,6 +494,20 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Inserts `len` bytes of `val` into `string` at @pos.
+     *
+     * If `len` is positive, `val` may contain embedded nuls and need
+     * not be nul-terminated. It is the caller's responsibility to
+     * ensure that `val` has at least `len` addressable bytes.
+     *
+     * If `len` is negative, `val` must be nul-terminated and `len` is considered to request the entire string length.
+     *
+     * If `pos` is -1, bytes are inserted at the end of the string.
+     * @param pos - position in `string` where insertion should
+     * @param val - bytes to insert
+     * @param len - number of bytes of `val` to insert, or -1 for all of @val
+     */
     insertLen(pos, val, len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_insert_len", [
             {
@@ -376,6 +534,12 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Converts a Unicode character into UTF-8, and insert it
+     * into the string at the given position.
+     * @param pos - the position at which to insert character, or -1
+     * @param wc - a Unicode character
+     */
     insertUnichar(pos, wc) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_insert_unichar", [
             {
@@ -398,6 +562,11 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Overwrites part of a string, lengthening it if necessary.
+     * @param pos - the position at which to start overwriting
+     * @param val - the string that will overwrite the `string` starting at @pos
+     */
     overwrite(pos, val) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_overwrite", [
             {
@@ -420,6 +589,13 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Overwrites part of a string, lengthening it if necessary.
+     * This function will work with embedded nuls.
+     * @param pos - the position at which to start overwriting
+     * @param val - the string that will overwrite the `string` starting at @pos
+     * @param len - the number of bytes to write from @val
+     */
     overwriteLen(pos, val, len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_overwrite_len", [
             {
@@ -446,6 +622,11 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Adds a string on to the start of a #GString,
+     * expanding it if necessary.
+     * @param val - the string to prepend on the start of @string
+     */
     prepend(val) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_prepend", [
             {
@@ -464,6 +645,11 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Adds a byte onto the start of a #GString,
+     * expanding it if necessary.
+     * @param c - the byte to prepend on the start of the #GString
+     */
     prependC(c) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_prepend_c", [
             {
@@ -482,6 +668,18 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Prepends `len` bytes of `val` to @string.
+     *
+     * If `len` is positive, `val` may contain embedded nuls and need
+     * not be nul-terminated. It is the caller's responsibility to
+     * ensure that `val` has at least `len` addressable bytes.
+     *
+     * If `len` is negative, `val` must be nul-terminated and `len` is considered to request the entire string length. This
+     * makes g_string_prepend_len() equivalent to g_string_prepend().
+     * @param val - bytes to prepend
+     * @param len - number of bytes in `val` to prepend, or -1 for all of @val
+     */
     prependLen(val, len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_prepend_len", [
             {
@@ -504,6 +702,11 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Converts a Unicode character into UTF-8, and prepends it
+     * to the string.
+     * @param wc - a Unicode character
+     */
     prependUnichar(wc) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_prepend_unichar", [
             {
@@ -522,6 +725,20 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Replaces the string `find` with the string `replace` in a #GString up to
+     * `limit` times. If the number of instances of `find` in the #GString is
+     * less than @limit, all instances are replaced. If `limit` is `0`,
+     * all instances of `find` are replaced.
+     *
+     * If `find` is the empty string, since versions 2.69.1 and 2.68.4 the
+     * replacement will be inserted no more than once per possible position
+     * (beginning of string, end of string and between characters). This did
+     * not work correctly in earlier versions.
+     * @param find - the string to find in @string
+     * @param replace - the string to insert in place of @find
+     * @param limit - the maximum instances of `find` to replace with @replace, or `0` for
+     */
     replace(find, replace, limit) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_replace", [
             {
@@ -542,6 +759,14 @@ export class String {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Sets the length of a #GString. If the length is less than
+     * the current length, the string will be truncated. If the
+     * length is greater than the current length, the contents
+     * of the newly added area are undefined. (However, as
+     * always, string->str[string->len] will be a nul byte.)
+     * @param len - the new length
+     */
     setSize(len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_set_size", [
             {
@@ -560,6 +785,10 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Cuts off the end of the GString, leaving the first `len` bytes.
+     * @param len - the new size of @string
+     */
     truncate(len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_truncate", [
             {
@@ -578,6 +807,9 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * Converts a #GString to uppercase.
+     */
     up() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_string_up", [
             {
@@ -592,15 +824,28 @@ export class String {
         });
         return getObject(ptr, String);
     }
+    /**
+     * points to the character data. It may move as text is added.
+     * The `str` field is null-terminated and so
+     * can be used as an ordinary C string.
+     */
     get str() {
         return read(this.ptr, { type: "string" }, 0);
     }
+    /**
+     * contains the length of the string, not including the
+     * terminating nul byte.
+     */
     get len() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 8);
     }
     set len(value) {
         write(this.ptr, { type: "int", size: 64, unsigned: true }, 8, value);
     }
+    /**
+     * the number of bytes that can be stored in the
+     * string before it needs to be reallocated. May be larger than @len.
+     */
     get allocatedLen() {
         return read(this.ptr, { type: "int", size: 64, unsigned: true }, 16);
     }

package/dist/generated/glib/strv-builder.d.ts

@@ -1,12 +1,84 @@
+/**
+ * `GStrvBuilder` is a helper object to build a %NULL-terminated string arrays.
+ *
+ * The following example shows how to build a two element array:
+ *
+ * ```c
+ * g_autoptr(GStrvBuilder) builder = g_strv_builder_new ();
+ * g_strv_builder_add (builder, "hello");
+ * g_strv_builder_add (builder, "world");
+ *
+ * g_auto(GStrv) array = g_strv_builder_end (builder);
+ *
+ * g_assert_true (g_strv_equal (array, (const char *[]) { "hello", "world", NULL }));
+ * ```
+ */
 export declare class StrvBuilder {
     ptr: unknown;
+    /**
+     * Creates a new #GStrvBuilder with a reference count of 1.
+     * Use g_strv_builder_unref() on the returned value when no longer needed.
+     */
     constructor();
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Add a string to the end of the array.
+     *
+     * Since 2.68
+     * @param value - a string.
+     */
     add(value: string): void;
+    /**
+     * Appends all the strings in the given vector to the builder.
+     *
+     * Since 2.70
+     * @param value - the vector of strings to add
+     */
     addv(value: string[]): void;
+    /**
+     * Ends the builder process and returns the constructed NULL-terminated string
+     * array. The returned value should be freed with g_strfreev() when no longer
+     * needed.
+     */
     end(): string[];
+    /**
+     * Atomically increments the reference count of `builder` by one.
+     * This function is thread-safe and may be called from any thread.
+     */
     ref(): StrvBuilder;
+    /**
+     * Add a string to the end of the array. After `value` belongs to the
+     * #GStrvBuilder and may no longer be modified by the caller.
+     *
+     * Since 2.80
+     * @param value - a string.
+     */
     take(value: string): void;
+    /**
+     * Decreases the reference count on @builder.
+     *
+     * In the event that there are no more references, releases all memory
+     * associated with the #GStrvBuilder.
+     */
     unref(): void;
+    /**
+     * Decreases the reference count on the string vector builder, and returns
+     * its contents as a `NULL`-terminated string array.
+     *
+     * This function is especially useful for cases where it's not possible
+     * to use `g_autoptr()`.
+     *
+     * ```c
+     * GStrvBuilder *builder = g_strv_builder_new ();
+     * g_strv_builder_add (builder, "hello");
+     * g_strv_builder_add (builder, "world");
+     *
+     * GStrv array = g_strv_builder_unref_to_strv (builder);
+     *
+     * g_assert_true (g_strv_equal (array, (const char *[]) { "hello", "world", NULL }));
+     *
+     * g_strfreev (array);
+     * ```
+     */
     unrefToStrv(): string[];
 }

package/dist/generated/glib/strv-builder.js

@@ -1,13 +1,38 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * `GStrvBuilder` is a helper object to build a %NULL-terminated string arrays.
+ *
+ * The following example shows how to build a two element array:
+ *
+ * ```c
+ * g_autoptr(GStrvBuilder) builder = g_strv_builder_new ();
+ * g_strv_builder_add (builder, "hello");
+ * g_strv_builder_add (builder, "world");
+ *
+ * g_auto(GStrv) array = g_strv_builder_end (builder);
+ *
+ * g_assert_true (g_strv_equal (array, (const char *[]) { "hello", "world", NULL }));
+ * ```
+ */
 export class StrvBuilder {
     ptr;
+    /**
+     * Creates a new #GStrvBuilder with a reference count of 1.
+     * Use g_strv_builder_unref() on the returned value when no longer needed.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
     createPtr(_args) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_strv_builder_new", [], { type: "boxed", borrowed: true, innerType: "GStrvBuilder" });
     }
+    /**
+     * Add a string to the end of the array.
+     *
+     * Since 2.68
+     * @param value - a string.
+     */
     add(value) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_strv_builder_add", [
             {
@@ -20,6 +45,12 @@ export class StrvBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Appends all the strings in the given vector to the builder.
+     *
+     * Since 2.70
+     * @param value - the vector of strings to add
+     */
     addv(value) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_strv_builder_addv", [
             {
@@ -32,6 +63,11 @@ export class StrvBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Ends the builder process and returns the constructed NULL-terminated string
+     * array. The returned value should be freed with g_strfreev() when no longer
+     * needed.
+     */
     end() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_strv_builder_end", [
             {
@@ -40,6 +76,10 @@ export class StrvBuilder {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Atomically increments the reference count of `builder` by one.
+     * This function is thread-safe and may be called from any thread.
+     */
     ref() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_strv_builder_ref", [
             {
@@ -54,6 +94,13 @@ export class StrvBuilder {
         });
         return getObject(ptr, StrvBuilder);
     }
+    /**
+     * Add a string to the end of the array. After `value` belongs to the
+     * #GStrvBuilder and may no longer be modified by the caller.
+     *
+     * Since 2.80
+     * @param value - a string.
+     */
     take(value) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_strv_builder_take", [
             {
@@ -66,6 +113,12 @@ export class StrvBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Decreases the reference count on @builder.
+     *
+     * In the event that there are no more references, releases all memory
+     * associated with the #GStrvBuilder.
+     */
     unref() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_strv_builder_unref", [
             {
@@ -74,6 +127,25 @@ export class StrvBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Decreases the reference count on the string vector builder, and returns
+     * its contents as a `NULL`-terminated string array.
+     *
+     * This function is especially useful for cases where it's not possible
+     * to use `g_autoptr()`.
+     *
+     * ```c
+     * GStrvBuilder *builder = g_strv_builder_new ();
+     * g_strv_builder_add (builder, "hello");
+     * g_strv_builder_add (builder, "world");
+     *
+     * GStrv array = g_strv_builder_unref_to_strv (builder);
+     *
+     * g_assert_true (g_strv_equal (array, (const char *[]) { "hello", "world", NULL }));
+     *
+     * g_strfreev (array);
+     * ```
+     */
     unrefToStrv() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_strv_builder_unref_to_strv", [
             {