@gtkx/ffi 0.8.0 → 0.9.0

package/dist/generated/glib/functions.js

@@ -879,47 +879,6 @@ export const asyncQueueNewFull = (itemFreeFunc) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
-/**
- * Specifies a function to be called at normal program termination.
- *
- * Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor
- * macro that maps to a call to the atexit() function in the C
- * library. This means that in case the code that calls g_atexit(),
- * i.e. atexit(), is in a DLL, the function will be called when the
- * DLL is detached from the program. This typically makes more sense
- * than that the function is called when the GLib DLL is detached,
- * which happened earlier when g_atexit() was a function in the GLib
- * DLL.
- *
- * The behaviour of atexit() in the context of dynamically loaded
- * modules is not formally specified and varies wildly.
- *
- * On POSIX systems, calling g_atexit() (or atexit()) in a dynamically
- * loaded module which is unloaded before the program terminates might
- * well cause a crash at program exit.
- *
- * Some POSIX systems implement atexit() like Windows, and have each
- * dynamically loaded module maintain an own atexit chain that is
- * called when the module is unloaded.
- *
- * On other POSIX systems, before a dynamically loaded module is
- * unloaded, the registered atexit functions (if any) residing in that
- * module are called, regardless where the code that registered them
- * resided. This is presumably the most robust approach.
- *
- * As can be seen from the above, for portability it's best to avoid
- * calling g_atexit() (or atexit()) except in the main executable of a
- * program.
- * @param func - the function to call on normal program termination.
- */
-export const atexit = (func) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_atexit", [
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-    ], { type: "undefined" });
-};
 /**
  * Atomically adds `val` to the value of @atomic.
  *
@@ -2474,68 +2433,6 @@ export const byteArraySizedNew = (reservedSize) => {
     });
     return getBoxed(ptr, ByteArray);
 };
-/**
- * Sorts a byte array, using `compare_func` which should be a
- * `qsort()`-style comparison function (returns less than zero for first
- * arg is less than second arg, zero for equal, greater than zero if
- * first arg is greater than second arg).
- *
- * If two array elements compare equal, their order in the sorted array
- * is undefined. If you want equal elements to keep their order (i.e.
- * you want a stable sort) you can write a comparison function that,
- * if two elements would otherwise compare equal, compares them by
- * their addresses.
- * @param array - a byte array
- * @param compareFunc - the comparison function
- */
-export const byteArraySort = (array, compareFunc) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_sort", [
-        {
-            type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GByteArray",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            },
-            value: array?.id ?? array,
-        },
-        {
-            type: { type: "callback" },
-            value: compareFunc,
-        },
-    ], { type: "undefined" });
-};
-/**
- * Like [func@GLib.ByteArray.sort], but the comparison function takes an extra
- * user data argument.
- * @param array - a byte array
- * @param compareFunc - the comparison function
- * @param userData - the data to pass to @compare_func
- */
-export const byteArraySortWithData = (array, compareFunc) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_sort_with_data", [
-        {
-            type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GByteArray",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            },
-            value: array?.id ?? array,
-        },
-        {
-            type: {
-                type: "callback",
-                trampoline: "compareDataFunc",
-                argTypes: [
-                    { type: "gobject", borrowed: true },
-                    { type: "gobject", borrowed: true },
-                ],
-            },
-            value: compareFunc,
-        },
-    ], { type: "undefined" });
-};
 /**
  * Frees the data in the array and resets the size to zero, while
  * the underlying array is preserved for use elsewhere and returned
@@ -2676,63 +2573,6 @@ export const checksumTypeGetLength = (checksumType) => {
         },
     ], { type: "int", size: 64, unsigned: false });
 };
-/**
- * Sets a function to be called when the child indicated by `pid` exits, at the priority @priority.
- *
- * If you obtain `pid` from [func@GLib.spawn_async] or
- * [func@GLib.spawn_async_with_pipes] you will need to pass
- * [flags@GLib.SpawnFlags.DO_NOT_REAP_CHILD] as a flag to the spawn function for
- * the child watching to work.
- *
- * In many programs, you will want to call [func@GLib.spawn_check_wait_status]
- * in the callback to determine whether or not the child exited
- * successfully.
- *
- * Also, note that on platforms where [type@GLib.Pid] must be explicitly closed
- * (see [func@GLib.spawn_close_pid]) `pid` must not be closed while the source
- * is still active.  Typically, you should invoke [func@GLib.spawn_close_pid]
- * in the callback function for the source.
- *
- * GLib supports only a single callback per process ID.
- * On POSIX platforms, the same restrictions mentioned for
- * [func@GLib.child_watch_source_new] apply to this function.
- *
- * This internally creates a main loop source using
- * [func@GLib.child_watch_source_new] and attaches it to the main loop context
- * using [method@GLib.Source.attach]. You can do these steps manually if you
- * need greater control.
- * @param priority - the priority of the idle source; typically this will be in the
- * @param pid - process to watch — on POSIX systems, this is the positive PID of a
- * @param _function - function to call
- * @param data - data to pass to @function
- * @param notify - function to call when the idle is removed
- */
-export const childWatchAddFull = (priority, pid, _function, data, notify) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_child_watch_add_full", [
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: priority,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: pid,
-        },
-        {
-            type: { type: "callback" },
-            value: _function,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: data,
-            optional: true,
-        },
-        {
-            type: { type: "callback", trampoline: "destroy" },
-            value: notify,
-            optional: true,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
 /**
  * Creates a new child watch source.
  *
@@ -3301,38 +3141,6 @@ export const creat = (filename, mode) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
-/**
- * Calls the given function for each data element of the datalist. The
- * function is called with each data element's #GQuark id and data,
- * together with the given `user_data` parameter. Note that this
- * function is NOT thread-safe. So unless `datalist` can be protected
- * from any modifications during invocation of this function, it should
- * not be called.
- *
- * `func` can make changes to @datalist, but the iteration will not
- * reflect changes made during the g_datalist_foreach() call, other
- * than skipping over elements that are removed.
- * @param datalist - a datalist.
- * @param func - the function to call for each data element.
- * @param userData - user data to pass to the function.
- */
-export const datalistForeach = (datalist, func, userData) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_datalist_foreach", [
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: datalist,
-        },
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-    ], { type: "undefined" });
-};
 /**
  * Gets a data element, using its string identifier. This is slower than
  * g_datalist_id_get_data() because it compares strings.
@@ -3464,36 +3272,6 @@ export const datasetDestroy = (datasetLocation) => {
         },
     ], { type: "undefined" });
 };
-/**
- * Calls the given function for each data element which is associated
- * with the given location. Note that this function is NOT thread-safe.
- * So unless `dataset_location` can be protected from any modifications
- * during invocation of this function, it should not be called.
- *
- * `func` can make changes to the dataset, but the iteration will not
- * reflect changes made during the g_dataset_foreach() call, other
- * than skipping over elements that are removed.
- * @param datasetLocation - the location identifying the dataset.
- * @param func - the function to call for each data element.
- * @param userData - user data to pass to the function.
- */
-export const datasetForeach = (datasetLocation, func, userData) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_dataset_foreach", [
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: datasetLocation,
-        },
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-    ], { type: "undefined" });
-};
 /**
  * Gets the data element corresponding to a #GQuark.
  * @param datasetLocation - the location identifying the dataset.
@@ -4099,88 +3877,6 @@ export const environUnsetenv = (variable, envp) => {
         },
     ], { type: "array", itemType: { type: "string" } });
 };
-/**
- * This function registers an extended #GError domain.
- * `error_type_name` will be duplicated. Otherwise does the same as
- * g_error_domain_register_static().
- * @param errorTypeName - string to create a #GQuark from
- * @param errorTypePrivateSize - size of the private error data in bytes
- * @param errorTypeInit - function initializing fields of the private error data
- * @param errorTypeCopy - function copying fields of the private error data
- * @param errorTypeClear - function freeing fields of the private error data
- */
-export const errorDomainRegister = (errorTypeName, errorTypePrivateSize, errorTypeInit, errorTypeCopy, errorTypeClear) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_error_domain_register", [
-        {
-            type: { type: "string" },
-            value: errorTypeName,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: errorTypePrivateSize,
-        },
-        {
-            type: { type: "callback" },
-            value: errorTypeInit,
-        },
-        {
-            type: { type: "callback" },
-            value: errorTypeCopy,
-        },
-        {
-            type: { type: "callback" },
-            value: errorTypeClear,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
-/**
- * This function registers an extended #GError domain.
- *
- * `error_type_name` should not be freed. `error_type_private_size` must
- * be greater than 0.
- *
- * `error_type_init` receives an initialized #GError and should then initialize
- * the private data.
- *
- * `error_type_copy` is a function that receives both original and a copy
- * #GError and should copy the fields of the private error data. The standard
- * #GError fields are already handled.
- *
- * `error_type_clear` receives the pointer to the error, and it should free the
- * fields of the private error data. It should not free the struct itself though.
- *
- * Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it
- * already takes care of passing valid information to this function.
- * @param errorTypeName - static string to create a #GQuark from
- * @param errorTypePrivateSize - size of the private error data in bytes
- * @param errorTypeInit - function initializing fields of the private error data
- * @param errorTypeCopy - function copying fields of the private error data
- * @param errorTypeClear - function freeing fields of the private error data
- */
-export const errorDomainRegisterStatic = (errorTypeName, errorTypePrivateSize, errorTypeInit, errorTypeCopy, errorTypeClear) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_error_domain_register_static", [
-        {
-            type: { type: "string" },
-            value: errorTypeName,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: errorTypePrivateSize,
-        },
-        {
-            type: { type: "callback" },
-            value: errorTypeInit,
-        },
-        {
-            type: { type: "callback" },
-            value: errorTypeCopy,
-        },
-        {
-            type: { type: "callback" },
-            value: errorTypeClear,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
 /**
  * Mark every file descriptor equal to or greater than `lowfd` to be closed
  * at the next `execve()` or similar, as if via the `FD_CLOEXEC` flag.
@@ -5785,154 +5481,6 @@ export const hashTableDestroy = (hashTable) => {
         },
     ], { type: "undefined" });
 };
-/**
- * Calls the given function for key/value pairs in the #GHashTable
- * until `predicate` returns %TRUE. The function is passed the key
- * and value of each pair, and the given `user_data` parameter. The
- * hash table may not be modified while iterating over it (you can't
- * add/remove items).
- *
- * Note, that hash tables are really only optimized for forward
- * lookups, i.e. g_hash_table_lookup(). So code that frequently issues
- * g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of
- * once per every entry in a hash table) should probably be reworked
- * to use additional or different data structures for reverse lookups
- * (keep in mind that an O(n) find/foreach operation issued for all n
- * values in a hash table ends up needing O(n*n) operations).
- * @param hashTable - a #GHashTable
- * @param predicate - function to test the key/value pairs for a certain property
- * @param userData - user data to pass to the function
- */
-export const hashTableFind = (hashTable, predicate, userData) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_find", [
-        {
-            type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GHashTable",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            },
-            value: hashTable?.id ?? hashTable,
-        },
-        {
-            type: { type: "callback" },
-            value: predicate,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-    ], { type: "int", size: 64, unsigned: true });
-};
-/**
- * Calls the given function for each of the key/value pairs in the
- * #GHashTable.  The function is passed the key and value of each
- * pair, and the given `user_data` parameter.  The hash table may not
- * be modified while iterating over it (you can't add/remove
- * items). To remove all items matching a predicate, use
- * g_hash_table_foreach_remove().
- *
- * The order in which g_hash_table_foreach() iterates over the keys/values in
- * the hash table is not defined.
- *
- * See g_hash_table_find() for performance caveats for linear
- * order searches in contrast to g_hash_table_lookup().
- * @param hashTable - a #GHashTable
- * @param func - the function to call for each key/value pair
- * @param userData - user data to pass to the function
- */
-export const hashTableForeach = (hashTable, func, userData) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_foreach", [
-        {
-            type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GHashTable",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            },
-            value: hashTable?.id ?? hashTable,
-        },
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-    ], { type: "undefined" });
-};
-/**
- * Calls the given function for each key/value pair in the
- * #GHashTable. If the function returns %TRUE, then the key/value
- * pair is removed from the #GHashTable. If you supplied key or
- * value destroy functions when creating the #GHashTable, they are
- * used to free the memory allocated for the removed keys and values.
- *
- * See #GHashTableIter for an alternative way to loop over the
- * key/value pairs in the hash table.
- * @param hashTable - a #GHashTable
- * @param func - the function to call for each key/value pair
- * @param userData - user data to pass to the function
- */
-export const hashTableForeachRemove = (hashTable, func, userData) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_foreach_remove", [
-        {
-            type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GHashTable",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            },
-            value: hashTable?.id ?? hashTable,
-        },
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
-/**
- * Calls the given function for each key/value pair in the
- * #GHashTable. If the function returns %TRUE, then the key/value
- * pair is removed from the #GHashTable, but no key or value
- * destroy functions are called.
- *
- * See #GHashTableIter for an alternative way to loop over the
- * key/value pairs in the hash table.
- * @param hashTable - a #GHashTable
- * @param func - the function to call for each key/value pair
- * @param userData - user data to pass to the function
- */
-export const hashTableForeachSteal = (hashTable, func, userData) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_foreach_steal", [
-        {
-            type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GHashTable",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            },
-            value: hashTable?.id ?? hashTable,
-        },
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
 /**
  * Inserts a new key and value into a #GHashTable.
  *
@@ -6401,28 +5949,6 @@ export const hookInsertBefore = (hookList, hook, sibling) => {
         },
     ], { type: "undefined" });
 };
-/**
- * Inserts a #GHook into a #GHookList, sorted by the given function.
- * @param hookList - a #GHookList
- * @param hook - the #GHook to insert
- * @param func - the comparison function used to sort the #GHook elements
- */
-export const hookInsertSorted = (hookList, hook, func) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hook_insert_sorted", [
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: hookList,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: hook,
-        },
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-    ], { type: "undefined" });
-};
 /**
  * Prepends a #GHook on the start of a #GHookList.
  * @param hookList - a #GHookList
@@ -6544,40 +6070,8 @@ export const hostnameToUnicode = (hostname) => {
     ], { type: "string" });
 };
 /**
- * Adds a function to be called whenever there are no higher priority
- * events pending.
- *
- * If the function returns [const@GLib.SOURCE_REMOVE] it is automatically
- * removed from the list of event sources and will not be called again.
- *
- * See main loop memory management for details
- * on how to handle the return value and memory management of @data.
- *
- * This internally creates a main loop source using [func@GLib.idle_source_new]
- * and attaches it to the global [struct@GLib.MainContext] using
- * [method@GLib.Source.attach], so the callback will be invoked in whichever
- * thread is running that main context. You can do these steps manually if you
- * need greater control or to use a custom main context.
- * @param priority - the priority of the idle source; typically this will be in the
- * @param _function - function to call
- * @param data - data to pass to @function
- * @param notify - function to call when the idle is removed
- */
-export const idleAddFull = (priority, _function) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_idle_add_full", [
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: priority,
-        },
-        {
-            type: { type: "callback", trampoline: "sourceFunc" },
-            value: _function,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
-/**
- * Removes the idle function with the given data.
- * @param data - the data for the idle source’s callback.
+ * Removes the idle function with the given data.
+ * @param data - the data for the idle source’s callback.
  */
 export const idleRemoveByData = (data) => {
     return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_idle_remove_by_data", [
@@ -6724,54 +6218,6 @@ export const internString = (string) => {
         },
     ], { type: "string", borrowed: true });
 };
-/**
- * Adds the #GIOChannel into the default main loop context
- * with the given priority.
- *
- * This internally creates a main loop source using g_io_create_watch()
- * and attaches it to the main loop context with g_source_attach().
- * You can do these steps manually if you need greater control.
- * @param channel - a #GIOChannel
- * @param priority - the priority of the #GIOChannel source
- * @param condition - the condition to watch for
- * @param func - the function to call when the condition is satisfied
- * @param userData - user data to pass to @func
- * @param notify - the function to call when the source is removed
- */
-export const ioAddWatchFull = (channel, priority, condition, func, notify, userData) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_io_add_watch_full", [
-        {
-            type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GIOChannel",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            },
-            value: channel?.id ?? channel,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: priority,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: condition,
-        },
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-        {
-            type: { type: "callback", trampoline: "destroy" },
-            value: notify,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
 /**
  * Converts an `errno` error number to a #GIOChannelError.
  * @param en - an `errno` error number, e.g. `EINVAL`
@@ -7186,79 +6632,6 @@ export const logSetFatalMask = (logDomain, fatalMask) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
-/**
- * Like [func@GLib.log_set_handler], but takes a destroy notify for the @user_data.
- *
- * This has no effect if structured logging is enabled; see
- * Using Structured Logging.
- *
- * The `log_domain` parameter can be set to `NULL` or an empty string to use the default
- * application domain.
- * @param logDomain - the log domain
- * @param logLevels - the log levels to apply the log handler for.
- * @param logFunc - the log handler function
- * @param userData - data passed to the log handler
- * @param destroy - destroy notify for @user_data, or `NULL`
- */
-export const logSetHandlerFull = (logLevels, logFunc, destroy, logDomain, userData) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_log_set_handler_full", [
-        {
-            type: { type: "string" },
-            value: logDomain,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: logLevels,
-        },
-        {
-            type: { type: "callback" },
-            value: logFunc,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-        {
-            type: { type: "callback", trampoline: "destroy" },
-            value: destroy,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
-/**
- * Set a writer function which will be called to format and write out each log
- * message.
- *
- * Each program should set a writer function, or the default writer
- * ([func@GLib.log_writer_default]) will be used.
- *
- * Libraries **must not** call this function — only programs are allowed to
- * install a writer function, as there must be a single, central point where
- * log messages are formatted and outputted.
- *
- * There can only be one writer function. It is an error to set more than one.
- * @param func - log writer function, which must not be `NULL`
- * @param userData - user data to pass to @func
- * @param userDataFree - function to free `user_data` once it’s
- */
-export const logSetWriterFunc = (func, userDataFree, userData) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_log_set_writer_func", [
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-        {
-            type: { type: "callback", trampoline: "destroy" },
-            value: userDataFree,
-        },
-    ], { type: "undefined" });
-};
 /**
  * Log a message with structured data.
  *
@@ -8839,45 +8212,6 @@ export const propagateError = (src, dest) => {
     if (dest)
         dest.value = getBoxed(dest.value, GError);
 };
-/**
- * This is just like the standard C [`qsort()`](man:qsort(3)) function, but
- * the comparison routine accepts a user data argument
- * (like [`qsort_r()`](man:qsort_r(3))).
- *
- * Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 2.32).
- * @param pbase - start of array to sort
- * @param totalElems - elements in the array
- * @param size - size of each element
- * @param compareFunc - function to compare elements
- * @param userData - data to pass to @compare_func
- */
-export const qsortWithData = (pbase, totalElems, size, compareFunc) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_qsort_with_data", [
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: pbase,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: totalElems,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: size,
-        },
-        {
-            type: {
-                type: "callback",
-                trampoline: "compareDataFunc",
-                argTypes: [
-                    { type: "gobject", borrowed: true },
-                    { type: "gobject", borrowed: true },
-                ],
-            },
-            value: compareFunc,
-        },
-    ], { type: "undefined" });
-};
 /**
  * Gets the #GQuark identifying the given (static) string. If the
  * string does not currently have an associated #GQuark, a new #GQuark
@@ -9622,36 +8956,6 @@ export const rmdir = (filename) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
-/**
- * Calls `func` for each item in the range (@begin, @end) passing
- * `user_data` to the function. `func` must not modify the sequence
- * itself.
- * @param begin - a #GSequenceIter
- * @param end - a #GSequenceIter
- * @param func - a #GFunc
- * @param userData - user data passed to @func
- */
-export const sequenceForeachRange = (begin, end, func, userData) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_sequence_foreach_range", [
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: begin,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: end,
-        },
-        {
-            type: { type: "callback" },
-            value: func,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-    ], { type: "undefined" });
-};
 /**
  * Returns the data that `iter` points to.
  * @param iter - a #GSequenceIter
@@ -9809,70 +9113,6 @@ export const sequenceSet = (iter, data) => {
         },
     ], { type: "undefined" });
 };
-/**
- * Moves the data pointed to by `iter` to a new position as indicated by
- * @cmp_func. This
- * function should be called for items in a sequence already sorted according
- * to `cmp_func` whenever some aspect of an item changes so that `cmp_func` may return different values for that item.
- *
- * `cmp_func` is called with two items of the @seq, and @cmp_data.
- * It should return 0 if the items are equal, a negative value if
- * the first item comes before the second, and a positive value if
- * the second item comes before the first.
- * @param iter - A #GSequenceIter
- * @param cmpFunc - the function used to compare items in the sequence
- * @param cmpData - user data passed to @cmp_func.
- */
-export const sequenceSortChanged = (iter, cmpFunc) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_sequence_sort_changed", [
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: iter,
-        },
-        {
-            type: {
-                type: "callback",
-                trampoline: "compareDataFunc",
-                argTypes: [
-                    { type: "gobject", borrowed: true },
-                    { type: "gobject", borrowed: true },
-                ],
-            },
-            value: cmpFunc,
-        },
-    ], { type: "undefined" });
-};
-/**
- * Like g_sequence_sort_changed(), but uses
- * a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
- * the compare function.
- *
- * `iter_cmp` is called with two iterators pointing into the #GSequence that
- * `iter` points into. It should
- * return 0 if the iterators are equal, a negative value if the first
- * iterator comes before the second, and a positive value if the second
- * iterator comes before the first.
- * @param iter - a #GSequenceIter
- * @param iterCmp - the function used to compare iterators in the sequence
- * @param cmpData - user data passed to @cmp_func
- */
-export const sequenceSortChangedIter = (iter, iterCmp, cmpData) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_sequence_sort_changed_iter", [
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: iter,
-        },
-        {
-            type: { type: "callback" },
-            value: iterCmp,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: cmpData,
-            optional: true,
-        },
-    ], { type: "undefined" });
-};
 /**
  * Swaps the items pointed to by `a` and @b. It is allowed for `a` and `b` to point into difference sequences.
  * @param a - a #GSequenceIter
@@ -10465,69 +9705,22 @@ export const spacedPrimesClosest = (num) => {
     ], { type: "int", size: 32, unsigned: true });
 };
 /**
- * Executes a child program asynchronously.
- *
- * See g_spawn_async_with_pipes_and_fds() for a full description; this function
- * simply calls the g_spawn_async_with_pipes() without any pipes, which in turn
- * calls g_spawn_async_with_pipes_and_fds().
- *
- * You should call g_spawn_close_pid() on the returned child process
- * reference when you don't need it any more.
- *
- * If you are writing a GTK application, and the program you are spawning is a
- * graphical application too, then to ensure that the spawned program opens its
- * windows on the right screen, you may want to use #GdkAppLaunchContext,
- * #GAppLaunchContext, or set the %DISPLAY environment variable.
+ * An old name for g_spawn_check_wait_status(), deprecated because its
+ * name is misleading.
  *
- * Note that the returned `child_pid` on Windows is a handle to the child
- * process and not its identifier. Process handles and process identifiers
- * are different concepts on Windows.
- * @param workingDirectory - child's current working
- * @param argv - child's argument vector
- * @param envp - child's environment, or %NULL to inherit parent's
- * @param flags - flags from #GSpawnFlags
- * @param childSetup - function to run
- * @param userData - user data for @child_setup
- * @param childPid - return location for child process reference, or %NULL
+ * Despite the name of the function, `wait_status` must be the wait status
+ * as returned by g_spawn_sync(), g_subprocess_get_status(), `waitpid()`,
+ * etc. On Unix platforms, it is incorrect for it to be the exit status
+ * as passed to `exit()` or returned by g_subprocess_get_exit_status() or
+ * `WEXITSTATUS()`.
+ * @param waitStatus - A status as returned from g_spawn_sync()
  */
-export const spawnAsync = (argv, flags, workingDirectory, envp, childSetup, userData, childPid) => {
+export const spawnCheckExitStatus = (waitStatus) => {
     const error = { value: null };
-    const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_async", [
-        {
-            type: { type: "string" },
-            value: workingDirectory,
-            optional: true,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: argv,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: envp,
-            optional: true,
-        },
+    const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_check_exit_status", [
         {
             type: { type: "int", size: 32, unsigned: false },
-            value: flags,
-        },
-        {
-            type: { type: "callback" },
-            value: childSetup,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: childPid,
-            optional: true,
+            value: waitStatus,
         },
         {
             type: {
@@ -10547,587 +9740,53 @@ export const spawnAsync = (argv, flags, workingDirectory, envp, childSetup, user
     return result;
 };
 /**
- * Executes a child program asynchronously.
+ * Set `error` if `wait_status` indicates the child exited abnormally
+ * (e.g. with a nonzero exit code, or via a fatal signal).
+ *
+ * The g_spawn_sync() and g_child_watch_add() family of APIs return the
+ * status of subprocesses encoded in a platform-specific way.
+ * On Unix, this is guaranteed to be in the same format waitpid() returns,
+ * and on Windows it is guaranteed to be the result of GetExitCodeProcess().
+ *
+ * Prior to the introduction of this function in GLib 2.34, interpreting
+ * `wait_status` required use of platform-specific APIs, which is problematic
+ * for software using GLib as a cross-platform layer.
+ *
+ * Additionally, many programs simply want to determine whether or not
+ * the child exited successfully, and either propagate a #GError or
+ * print a message to standard error. In that common case, this function
+ * can be used. Note that the error message in `error` will contain
+ * human-readable information about the wait status.
+ *
+ * The `domain` and `code` of `error` have special semantics in the case
+ * where the process has an "exit code", as opposed to being killed by
+ * a signal. On Unix, this happens if WIFEXITED() would be true of
+ * @wait_status. On Windows, it is always the case.
+ *
+ * The special semantics are that the actual exit code will be the
+ * code set in @error, and the domain will be %G_SPAWN_EXIT_ERROR.
+ * This allows you to differentiate between different exit codes.
+ *
+ * If the process was terminated by some means other than an exit
+ * status (for example if it was killed by a signal), the domain will be
+ * %G_SPAWN_ERROR and the code will be %G_SPAWN_ERROR_FAILED.
+ *
+ * This function just offers convenience; you can of course also check
+ * the available platform via a macro such as %G_OS_UNIX, and use
+ * WIFEXITED() and WEXITSTATUS() on `wait_status` directly. Do not attempt
+ * to scan or parse the error message string; it may be translated and/or
+ * change in future versions of GLib.
  *
- * Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
- * so no FD assignments are used.
- * @param workingDirectory - child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding
- * @param argv - child's argument vector, in the GLib file name encoding;
- * @param envp - child's environment, or %NULL to inherit parent's, in the GLib file name encoding
- * @param flags - flags from #GSpawnFlags
- * @param childSetup - function to run
- * @param userData - user data for @child_setup
- * @param childPid - return location for child process ID, or %NULL
- * @param stdinFd - file descriptor to use for child's stdin, or `-1`
- * @param stdoutFd - file descriptor to use for child's stdout, or `-1`
- * @param stderrFd - file descriptor to use for child's stderr, or `-1`
+ * Prior to version 2.70, g_spawn_check_exit_status() provides the same
+ * functionality, although under a misleading name.
+ * @param waitStatus - A platform-specific wait status as returned from g_spawn_sync()
  */
-export const spawnAsyncWithFds = (argv, flags, stdinFd, stdoutFd, stderrFd, workingDirectory, envp, childSetup, userData, childPid) => {
+export const spawnCheckWaitStatus = (waitStatus) => {
     const error = { value: null };
-    const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_async_with_fds", [
-        {
-            type: { type: "string" },
-            value: workingDirectory,
-            optional: true,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: argv,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: envp,
-            optional: true,
-        },
+    const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_check_wait_status", [
         {
             type: { type: "int", size: 32, unsigned: false },
-            value: flags,
-        },
-        {
-            type: { type: "callback" },
-            value: childSetup,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: childPid,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: stdinFd,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: stdoutFd,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: stderrFd,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: {
-                    type: "boxed",
-                    innerType: "GError",
-                    lib: "libglib-2.0.so.0",
-                },
-            },
-            value: error,
-        },
-    ], { type: "boolean" });
-    if (error.value !== null) {
-        throw new NativeError(error.value);
-    }
-    return result;
-};
-/**
- * Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
- * so no FD assignments are used.
- * @param workingDirectory - child's current working
- * @param argv - child's argument
- * @param envp - child's environment, or %NULL to inherit parent's, in the GLib file
- * @param flags - flags from #GSpawnFlags
- * @param childSetup - function to run
- * @param userData - user data for @child_setup
- * @param childPid - return location for child process ID, or %NULL
- * @param standardInput - return location for file descriptor to write to child's stdin, or %NULL
- * @param standardOutput - return location for file descriptor to read child's stdout, or %NULL
- * @param standardError - return location for file descriptor to read child's stderr, or %NULL
- */
-export const spawnAsyncWithPipes = (argv, flags, workingDirectory, envp, childSetup, userData, childPid, standardInput, standardOutput, standardError) => {
-    const error = { value: null };
-    const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_async_with_pipes", [
-        {
-            type: { type: "string" },
-            value: workingDirectory,
-            optional: true,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: argv,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: envp,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: flags,
-        },
-        {
-            type: { type: "callback" },
-            value: childSetup,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: childPid,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: standardInput,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: standardOutput,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: standardError,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: {
-                    type: "boxed",
-                    innerType: "GError",
-                    lib: "libglib-2.0.so.0",
-                },
-            },
-            value: error,
-        },
-    ], { type: "boolean" });
-    if (error.value !== null) {
-        throw new NativeError(error.value);
-    }
-    return result;
-};
-/**
- * Executes a child program asynchronously (your program will not
- * block waiting for the child to exit).
- *
- * The child program is specified by the only argument that must be
- * provided, @argv. `argv` should be a %NULL-terminated array of strings,
- * to be passed as the argument vector for the child. The first string
- * in `argv` is of course the name of the program to execute. By default,
- * the name of the program must be a full path. If `flags` contains the
- * %G_SPAWN_SEARCH_PATH flag, the `PATH` environment variable is used to
- * search for the executable. If `flags` contains the
- * %G_SPAWN_SEARCH_PATH_FROM_ENVP flag, the `PATH` variable from `envp` is used to search for the executable. If both the
- * %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP flags are
- * set, the `PATH` variable from `envp` takes precedence over the
- * environment variable.
- *
- * If the program name is not a full path and %G_SPAWN_SEARCH_PATH flag
- * is not used, then the program will be run from the current directory
- * (or @working_directory, if specified); this might be unexpected or even
- * dangerous in some cases when the current directory is world-writable.
- *
- * On Windows, note that all the string or string vector arguments to
- * this function and the other `g_spawn*()` functions are in UTF-8, the
- * GLib file name encoding. Unicode characters that are not part of
- * the system codepage passed in these arguments will be correctly
- * available in the spawned program only if it uses wide character API
- * to retrieve its command line. For C programs built with Microsoft's
- * tools it is enough to make the program have a `wmain()` instead of
- * `main()`. `wmain()` has a wide character argument vector as parameter.
- *
- * At least currently, mingw doesn't support `wmain()`, so if you use
- * mingw to develop the spawned program, it should call
- * g_win32_get_command_line() to get arguments in UTF-8.
- *
- * On Windows the low-level child process creation API `CreateProcess()`
- * doesn't use argument vectors, but a command line. The C runtime
- * library's `spawn*()` family of functions (which g_spawn_async_with_pipes()
- * eventually calls) paste the argument vector elements together into
- * a command line, and the C runtime startup code does a corresponding
- * reconstruction of an argument vector from the command line, to be
- * passed to `main()`. Complications arise when you have argument vector
- * elements that contain spaces or double quotes. The `spawn*()` functions
- * don't do any quoting or escaping, but on the other hand the startup
- * code does do unquoting and unescaping in order to enable receiving
- * arguments with embedded spaces or double quotes. To work around this
- * asymmetry, g_spawn_async_with_pipes() will do quoting and escaping on
- * argument vector elements that need it before calling the C runtime
- * `spawn()` function.
- *
- * The returned `child_pid` on Windows is a handle to the child
- * process, not its identifier. Process handles and process
- * identifiers are different concepts on Windows.
- *
- * `envp` is a %NULL-terminated array of strings, where each string
- * has the form `KEY=VALUE`. This will become the child's environment.
- * If `envp` is %NULL, the child inherits its parent's environment.
- *
- * `flags` should be the bitwise OR of any flags you want to affect the
- * function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that the
- * child will not automatically be reaped; you must use a child watch
- * (g_child_watch_add()) to be notified about the death of the child process,
- * otherwise it will stay around as a zombie process until this process exits.
- * Eventually you must call g_spawn_close_pid() on the @child_pid, in order to
- * free resources which may be associated with the child process. (On Unix,
- * using a child watch is equivalent to calling waitpid() or handling
- * the `SIGCHLD` signal manually. On Windows, calling g_spawn_close_pid()
- * is equivalent to calling `CloseHandle()` on the process handle returned
- * in @child_pid). See g_child_watch_add().
- *
- * Open UNIX file descriptors marked as `FD_CLOEXEC` will be automatically
- * closed in the child process. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that
- * other open file descriptors will be inherited by the child; otherwise all
- * descriptors except stdin/stdout/stderr will be closed before calling `exec()`
- * in the child. %G_SPAWN_SEARCH_PATH means that @argv[0] need not be an
- * absolute path, it will be looked for in the `PATH` environment
- * variable. %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an
- * absolute path, it will be looked for in the `PATH` variable from
- * @envp. If both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP
- * are used, the value from `envp` takes precedence over the environment.
- *
- * %G_SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's
- * standard input (by default, the child's standard input is attached to
- * `/dev/null`). %G_SPAWN_STDIN_FROM_DEV_NULL explicitly imposes the default
- * behavior. Both flags cannot be enabled at the same time and, in both cases,
- * the `stdin_pipe_out` argument is ignored.
- *
- * %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output
- * will be discarded (by default, it goes to the same location as the parent's
- * standard output). %G_SPAWN_CHILD_INHERITS_STDOUT explicitly imposes the
- * default behavior. Both flags cannot be enabled at the same time and, in
- * both cases, the `stdout_pipe_out` argument is ignored.
- *
- * %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error
- * will be discarded (by default, it goes to the same location as the parent's
- * standard error). %G_SPAWN_CHILD_INHERITS_STDERR explicitly imposes the
- * default behavior. Both flags cannot be enabled at the same time and, in
- * both cases, the `stderr_pipe_out` argument is ignored.
- *
- * It is valid to pass the same FD in multiple parameters (e.g. you can pass
- * a single FD for both `stdout_fd` and @stderr_fd, and include it in
- * `source_fds` too).
- *
- * `source_fds` and `target_fds` allow zero or more FDs from this process to be
- * remapped to different FDs in the spawned process. If `n_fds` is greater than
- * zero, `source_fds` and `target_fds` must both be non-%NULL and the same length.
- * Each FD in `source_fds` is remapped to the FD number at the same index in
- * @target_fds. The source and target FD may be equal to simply propagate an FD
- * to the spawned process. FD remappings are processed after standard FDs, so
- * any target FDs which equal @stdin_fd, `stdout_fd` or `stderr_fd` will overwrite
- * them in the spawned process.
- *
- * `source_fds` is supported on Windows since 2.72.
- *
- * %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of `argv` is
- * the file to execute, while the remaining elements are the actual
- * argument vector to pass to the file. Normally g_spawn_async_with_pipes()
- * uses @argv[0] as the file to execute, and passes all of `argv` to the child.
- *
- * `child_setup` and `user_data` are a function and user data. On POSIX
- * platforms, the function is called in the child after GLib has
- * performed all the setup it plans to perform (including creating
- * pipes, closing file descriptors, etc.) but before calling `exec()`.
- * That is, `child_setup` is called just before calling `exec()` in the
- * child. Obviously actions taken in this function will only affect
- * the child, not the parent.
- *
- * On Windows, there is no separate `fork()` and `exec()` functionality.
- * Child processes are created and run with a single API call,
- * `CreateProcess()`. There is no sensible thing `child_setup` could be used for on Windows so it is ignored and not called.
- *
- * If non-%NULL, `child_pid` will on Unix be filled with the child's
- * process ID. You can use the process ID to send signals to the child,
- * or to use g_child_watch_add() (or `waitpid()`) if you specified the
- * %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, `child_pid` will be
- * filled with a handle to the child process only if you specified the
- * %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child
- * process using the Win32 API, for example wait for its termination
- * with the `WaitFor*()` functions, or examine its exit code with
- * `GetExitCodeProcess()`. You should close the handle with `CloseHandle()`
- * or g_spawn_close_pid() when you no longer need it.
- *
- * If non-%NULL, the @stdin_pipe_out, @stdout_pipe_out, `stderr_pipe_out` locations will be filled with file descriptors for writing to the child's
- * standard input or reading from its standard output or standard error.
- * The caller of g_spawn_async_with_pipes() must close these file descriptors
- * when they are no longer in use. If these parameters are %NULL, the
- * corresponding pipe won't be created.
- *
- * If `stdin_pipe_out` is %NULL, the child's standard input is attached to
- * `/dev/null` unless %G_SPAWN_CHILD_INHERITS_STDIN is set.
- *
- * If `stderr_pipe_out` is NULL, the child's standard error goes to the same
- * location as the parent's standard error unless %G_SPAWN_STDERR_TO_DEV_NULL
- * is set.
- *
- * If `stdout_pipe_out` is NULL, the child's standard output goes to the same
- * location as the parent's standard output unless %G_SPAWN_STDOUT_TO_DEV_NULL
- * is set.
- *
- * `error` can be %NULL to ignore errors, or non-%NULL to report errors.
- * If an error is set, the function returns %FALSE. Errors are reported
- * even if they occur in the child (for example if the executable in
- * `@argv[0]` is not found). Typically the `message` field of returned
- * errors should be displayed to users. Possible errors are those from
- * the %G_SPAWN_ERROR domain.
- *
- * If an error occurs, @child_pid, @stdin_pipe_out, @stdout_pipe_out,
- * and `stderr_pipe_out` will not be filled with valid values.
- *
- * If `child_pid` is not %NULL and an error does not occur then the returned
- * process reference must be closed using g_spawn_close_pid().
- *
- * On modern UNIX platforms, GLib can use an efficient process launching
- * codepath driven internally by `posix_spawn()`. This has the advantage of
- * avoiding the fork-time performance costs of cloning the parent process
- * address space, and avoiding associated memory overcommit checks that are
- * not relevant in the context of immediately executing a distinct process.
- * This optimized codepath will be used provided that the following conditions
- * are met:
- *
- * 1. %G_SPAWN_DO_NOT_REAP_CHILD is set
- * 2. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN is set
- * 3. %G_SPAWN_SEARCH_PATH_FROM_ENVP is not set
- * 4. `working_directory` is %NULL
- * 5. `child_setup` is %NULL
- * 6. The program is of a recognised binary format, or has a shebang.
- * Otherwise, GLib will have to execute the program through the
- * shell, which is not done using the optimized codepath.
- *
- * If you are writing a GTK application, and the program you are spawning is a
- * graphical application too, then to ensure that the spawned program opens its
- * windows on the right screen, you may want to use #GdkAppLaunchContext,
- * #GAppLaunchContext, or set the `DISPLAY` environment variable.
- * @param workingDirectory - child's current working
- * @param argv - child's argument
- * @param envp - child's environment, or %NULL to inherit parent's, in the GLib file
- * @param flags - flags from #GSpawnFlags
- * @param childSetup - function to run
- * @param userData - user data for @child_setup
- * @param stdinFd - file descriptor to use for child's stdin, or `-1`
- * @param stdoutFd - file descriptor to use for child's stdout, or `-1`
- * @param stderrFd - file descriptor to use for child's stderr, or `-1`
- * @param sourceFds - array of FDs from the parent
- * @param targetFds - array of FDs to remap
- * @param nFds - number of FDs in `source_fds` and @target_fds
- * @param childPidOut - return location for child process ID, or %NULL
- * @param stdinPipeOut - return location for file descriptor to write to child's stdin, or %NULL
- * @param stdoutPipeOut - return location for file descriptor to read child's stdout, or %NULL
- * @param stderrPipeOut - return location for file descriptor to read child's stderr, or %NULL
- */
-export const spawnAsyncWithPipesAndFds = (argv, flags, stdinFd, stdoutFd, stderrFd, nFds, workingDirectory, envp, childSetup, userData, sourceFds, targetFds, childPidOut, stdinPipeOut, stdoutPipeOut, stderrPipeOut) => {
-    const error = { value: null };
-    const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_async_with_pipes_and_fds", [
-        {
-            type: { type: "string" },
-            value: workingDirectory,
-            optional: true,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: argv,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: envp,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: flags,
-        },
-        {
-            type: { type: "callback" },
-            value: childSetup,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: stdinFd,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: stdoutFd,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: stderrFd,
-        },
-        {
-            type: {
-                type: "array",
-                itemType: { type: "int", size: 32, unsigned: false },
-            },
-            value: sourceFds,
-            optional: true,
-        },
-        {
-            type: {
-                type: "array",
-                itemType: { type: "int", size: 32, unsigned: false },
-            },
-            value: targetFds,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: nFds,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: childPidOut,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: stdinPipeOut,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: stdoutPipeOut,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: stderrPipeOut,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: {
-                    type: "boxed",
-                    innerType: "GError",
-                    lib: "libglib-2.0.so.0",
-                },
-            },
-            value: error,
-        },
-    ], { type: "boolean" });
-    if (error.value !== null) {
-        throw new NativeError(error.value);
-    }
-    return result;
-};
-/**
- * An old name for g_spawn_check_wait_status(), deprecated because its
- * name is misleading.
- *
- * Despite the name of the function, `wait_status` must be the wait status
- * as returned by g_spawn_sync(), g_subprocess_get_status(), `waitpid()`,
- * etc. On Unix platforms, it is incorrect for it to be the exit status
- * as passed to `exit()` or returned by g_subprocess_get_exit_status() or
- * `WEXITSTATUS()`.
- * @param waitStatus - A status as returned from g_spawn_sync()
- */
-export const spawnCheckExitStatus = (waitStatus) => {
-    const error = { value: null };
-    const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_check_exit_status", [
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: waitStatus,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: {
-                    type: "boxed",
-                    innerType: "GError",
-                    lib: "libglib-2.0.so.0",
-                },
-            },
-            value: error,
-        },
-    ], { type: "boolean" });
-    if (error.value !== null) {
-        throw new NativeError(error.value);
-    }
-    return result;
-};
-/**
- * Set `error` if `wait_status` indicates the child exited abnormally
- * (e.g. with a nonzero exit code, or via a fatal signal).
- *
- * The g_spawn_sync() and g_child_watch_add() family of APIs return the
- * status of subprocesses encoded in a platform-specific way.
- * On Unix, this is guaranteed to be in the same format waitpid() returns,
- * and on Windows it is guaranteed to be the result of GetExitCodeProcess().
- *
- * Prior to the introduction of this function in GLib 2.34, interpreting
- * `wait_status` required use of platform-specific APIs, which is problematic
- * for software using GLib as a cross-platform layer.
- *
- * Additionally, many programs simply want to determine whether or not
- * the child exited successfully, and either propagate a #GError or
- * print a message to standard error. In that common case, this function
- * can be used. Note that the error message in `error` will contain
- * human-readable information about the wait status.
- *
- * The `domain` and `code` of `error` have special semantics in the case
- * where the process has an "exit code", as opposed to being killed by
- * a signal. On Unix, this happens if WIFEXITED() would be true of
- * @wait_status. On Windows, it is always the case.
- *
- * The special semantics are that the actual exit code will be the
- * code set in @error, and the domain will be %G_SPAWN_EXIT_ERROR.
- * This allows you to differentiate between different exit codes.
- *
- * If the process was terminated by some means other than an exit
- * status (for example if it was killed by a signal), the domain will be
- * %G_SPAWN_ERROR and the code will be %G_SPAWN_ERROR_FAILED.
- *
- * This function just offers convenience; you can of course also check
- * the available platform via a macro such as %G_OS_UNIX, and use
- * WIFEXITED() and WEXITSTATUS() on `wait_status` directly. Do not attempt
- * to scan or parse the error message string; it may be translated and/or
- * change in future versions of GLib.
- *
- * Prior to version 2.70, g_spawn_check_exit_status() provides the same
- * functionality, although under a misleading name.
- * @param waitStatus - A platform-specific wait status as returned from g_spawn_sync()
- */
-export const spawnCheckWaitStatus = (waitStatus) => {
-    const error = { value: null };
-    const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_check_wait_status", [
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: waitStatus,
+            value: waitStatus,
         },
         {
             type: {
@@ -11293,118 +9952,6 @@ export const spawnErrorQuark = () => {
 export const spawnExitErrorQuark = () => {
     return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_exit_error_quark", [], { type: "int", size: 32, unsigned: true });
 };
-/**
- * Executes a child synchronously (waits for the child to exit before returning).
- *
- * All output from the child is stored in `standard_output` and @standard_error,
- * if those parameters are non-%NULL. Note that you must set the
- * %G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when
- * passing %NULL for `standard_output` and @standard_error.
- *
- * If `wait_status` is non-%NULL, the platform-specific status of
- * the child is stored there; see the documentation of
- * g_spawn_check_wait_status() for how to use and interpret this.
- * On Unix platforms, note that it is usually not equal
- * to the integer passed to `exit()` or returned from `main()`.
- *
- * Note that it is invalid to pass %G_SPAWN_DO_NOT_REAP_CHILD in
- * @flags, and on POSIX platforms, the same restrictions as for
- * g_child_watch_source_new() apply.
- *
- * If an error occurs, no data is returned in @standard_output,
- * @standard_error, or @wait_status.
- *
- * This function calls g_spawn_async_with_pipes() internally; see that
- * function for full details on the other parameters and details on
- * how these functions work on Windows.
- * @param workingDirectory - child's current working
- * @param argv - child's argument vector, which must be non-empty and %NULL-terminated
- * @param envp - child's environment, or %NULL to inherit parent's
- * @param flags - flags from #GSpawnFlags
- * @param childSetup - function to run
- * @param userData - user data for @child_setup
- * @param standardOutput - return location for child output, or %NULL
- * @param standardError - return location for child error messages, or %NULL
- * @param waitStatus - return location for child wait status, as returned by waitpid(), or %NULL
- */
-export const spawnSync = (argv, flags, workingDirectory, envp, childSetup, userData, standardOutput, standardError, waitStatus) => {
-    const error = { value: null };
-    const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_spawn_sync", [
-        {
-            type: { type: "string" },
-            value: workingDirectory,
-            optional: true,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: argv,
-        },
-        {
-            type: { type: "array", itemType: { type: "string" } },
-            value: envp,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: flags,
-        },
-        {
-            type: { type: "callback" },
-            value: childSetup,
-            optional: true,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: {
-                    type: "array",
-                    itemType: { type: "int", size: 8, unsigned: true },
-                },
-            },
-            value: standardOutput,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: {
-                    type: "array",
-                    itemType: { type: "int", size: 8, unsigned: true },
-                },
-            },
-            value: standardError,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
-            },
-            value: waitStatus,
-            optional: true,
-        },
-        {
-            type: {
-                type: "ref",
-                innerType: {
-                    type: "boxed",
-                    innerType: "GError",
-                    lib: "libglib-2.0.so.0",
-                },
-            },
-            value: error,
-        },
-    ], { type: "boolean" });
-    if (error.value !== null) {
-        throw new NativeError(error.value);
-    }
-    return result;
-};
 /**
  * A wrapper for the POSIX stat() function. The stat() function
  * returns information about a file. On Windows the stat() function in
@@ -12443,103 +10990,6 @@ export const strvLength = (strArray) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
-/**
- * Creates a new test case.
- *
- * This function is similar to [func@GLib.test_create_case].
- * However the test is assumed to use no fixture, and test suites are
- * automatically created on the fly and added to the root fixture,
- * based on the /-separated portions of @testpath. The `test_data` argument will be passed as first argument to @test_func.
- *
- * If `testpath` includes the component "subprocess" anywhere in it,
- * the test will be skipped by default, and only run if explicitly
- * required via the `-p` command-line option or [func@GLib.test_trap_subprocess].
- *
- * No component of `testpath` may start with a dot (`.`) if the
- * [const@GLib.TEST_OPTION_ISOLATE_DIRS] option is being used;
- * and it is recommended to do so even if it isn’t.
- * @param testpath - a /-separated name for the test
- * @param testData - data for the @test_func
- * @param testFunc - the test function to invoke for this test
- */
-export const testAddDataFunc = (testpath, testFunc, testData) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_test_add_data_func", [
-        {
-            type: { type: "string" },
-            value: testpath,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: testData,
-            optional: true,
-        },
-        {
-            type: { type: "callback" },
-            value: testFunc,
-        },
-    ], { type: "undefined" });
-};
-/**
- * Creates a new test case.
- *
- * In contrast to [func@GLib.test_add_data_func], this function
- * is freeing `test_data` after the test run is complete.
- * @param testpath - a /-separated name for the test
- * @param testData - data for @test_func
- * @param testFunc - the test function to invoke for this test
- * @param dataFreeFunc - #GDestroyNotify for @test_data
- */
-export const testAddDataFuncFull = (testpath, testFunc, dataFreeFunc, testData) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_test_add_data_func_full", [
-        {
-            type: { type: "string" },
-            value: testpath,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: testData,
-            optional: true,
-        },
-        {
-            type: { type: "callback" },
-            value: testFunc,
-        },
-        {
-            type: { type: "callback", trampoline: "destroy" },
-            value: dataFreeFunc,
-        },
-    ], { type: "undefined" });
-};
-/**
- * Creates a new test case.
- *
- * This function is similar to [func@GLib.test_create_case].
- * However the test is assumed to use no fixture, and test suites are
- * automatically created on the fly and added to the root fixture,
- * based on the /-separated portions of @testpath.
- *
- * If `testpath` includes the component "subprocess" anywhere in it,
- * the test will be skipped by default, and only run if explicitly
- * required via the `-p` command-line option or [func@GLib.test_trap_subprocess].
- *
- * No component of `testpath` may start with a dot (`.`) if the
- * [const@GLib.TEST_OPTION_ISOLATE_DIRS] option is being used; and
- * it is recommended to do so even if it isn’t.
- * @param testpath - a /-separated name for the test
- * @param testFunc - the test function to invoke for this test
- */
-export const testAddFunc = (testpath, testFunc) => {
-    call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_test_add_func", [
-        {
-            type: { type: "string" },
-            value: testpath,
-        },
-        {
-            type: { type: "callback" },
-            value: testFunc,
-        },
-    ], { type: "undefined" });
-};
 export const testAssertExpectedMessagesInternal = (domain, file, line, func) => {
     call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_test_assert_expected_messages_internal", [
         {
@@ -13450,119 +11900,6 @@ export const timeValFromIso8601 = (isoDate, time_) => {
         },
     ], { type: "boolean" });
 };
-/**
- * Sets a function to be called at regular intervals, with the given
- * priority.
- *
- * The function is called repeatedly until it returns
- * [const@GLib.SOURCE_REMOVE], at which point the timeout is automatically
- * destroyed and
- * the function will not be called again.  The `notify` function is
- * called when the timeout is destroyed.  The first call to the
- * function will be at the end of the first @interval.
- *
- * Note that timeout functions may be delayed, due to the processing of other
- * event sources. Thus they should not be relied on for precise timing.
- * After each call to the timeout function, the time of the next
- * timeout is recalculated based on the current time and the given interval
- * (it does not try to ‘catch up’ time lost in delays).
- *
- * See main loop memory management for details
- * on how to handle the return value and memory management of @data.
- *
- * This internally creates a main loop source using
- * [func@GLib.timeout_source_new] and attaches it to the global
- * [struct@GLib.MainContext] using [method@GLib.Source.attach], so the callback
- * will be invoked in whichever thread is running that main context. You can do
- * these steps manually if you need greater control or to use a custom main
- * context.
- *
- * The interval given is in terms of monotonic time, not wall clock time.
- * See [func@GLib.get_monotonic_time].
- * @param priority - the priority of the timeout source; typically this will be in
- * @param interval - the time between calls to the function, in milliseconds
- * @param _function - function to call
- * @param data - data to pass to @function
- * @param notify - function to call when the timeout is removed
- */
-export const timeoutAddFull = (priority, interval, _function) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_timeout_add_full", [
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: priority,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: true },
-            value: interval,
-        },
-        {
-            type: { type: "callback", trampoline: "sourceFunc" },
-            value: _function,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
-/**
- * Sets a function to be called at regular intervals, with @priority.
- *
- * The function is called repeatedly until it returns [const@GLib.SOURCE_REMOVE],
- * at which point the timeout is automatically destroyed and
- * the function will not be called again.
- *
- * Unlike [func@GLib.timeout_add], this function operates at whole second
- * granularity. The initial starting point of the timer is determined by the
- * implementation and the implementation is expected to group multiple timers
- * together so that they fire all at the same time. To allow this grouping,
- * the `interval` to the first timer is rounded and can deviate up to one second
- * from the specified interval. Subsequent timer iterations will generally run
- * at the specified interval.
- *
- * Note that timeout functions may be delayed, due to the processing of other
- * event sources. Thus they should not be relied on for precise timing.
- * After each call to the timeout function, the time of the next
- * timeout is recalculated based on the current time and the given `interval`
- * See main loop memory management for details
- * on how to handle the return value and memory management of @data.
- *
- * If you want timing more precise than whole seconds, use
- * [func@GLib.timeout_add] instead.
- *
- * The grouping of timers to fire at the same time results in a more power
- * and CPU efficient behavior so if your timer is in multiples of seconds
- * and you don’t require the first timer exactly one second from now, the
- * use of [func@GLib.timeout_add_seconds] is preferred over
- * [func@GLib.timeout_add].
- *
- * This internally creates a main loop source using
- * [func@GLib.timeout_source_new_seconds] and attaches it to the main loop
- * context using [method@GLib.Source.attach]. You can do these steps manually
- * if you need greater control.
- *
- * It is safe to call this function from any thread.
- *
- * The interval given is in terms of monotonic time, not wall clock
- * time. See [func@GLib.get_monotonic_time].
- * @param priority - the priority of the timeout source; typically this will be in
- * @param interval - the time between calls to the function, in seconds
- * @param _function - function to call
- * @param data - data to pass to @function
- * @param notify - function to call when the timeout is removed
- */
-export const timeoutAddSecondsFull = (priority, interval, _function) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_timeout_add_seconds_full", [
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: priority,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: true },
-            value: interval,
-        },
-        {
-            type: { type: "callback", trampoline: "sourceFunc" },
-            value: _function,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
 /**
  * Creates a new timeout source.
  *
@@ -14559,49 +12896,6 @@ export const unicodeScriptToIso15924 = (script) => {
 export const unixErrorQuark = () => {
     return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_unix_error_quark", [], { type: "int", size: 32, unsigned: true });
 };
-/**
- * Sets a function to be called when the IO condition, as specified by
- * `condition` becomes true for @fd.
- *
- * This is the same as g_unix_fd_add(), except that it allows you to
- * specify a non-default priority and a provide a #GDestroyNotify for
- * @user_data.
- * @param priority - the priority of the source
- * @param fd - a file descriptor
- * @param condition - IO conditions to watch for on @fd
- * @param _function - a #GUnixFDSourceFunc
- * @param userData - data to pass to @function
- * @param notify - function to call when the idle is removed, or %NULL
- */
-export const unixFdAddFull = (priority, fd, condition, _function, notify, userData) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_unix_fd_add_full", [
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: priority,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: fd,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: condition,
-        },
-        {
-            type: { type: "callback" },
-            value: _function,
-        },
-        {
-            type: { type: "int", size: 64, unsigned: true },
-            value: userData,
-            optional: true,
-        },
-        {
-            type: { type: "callback", trampoline: "destroy" },
-            value: notify,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
 /**
  * Creates a #GSource to watch for a particular I/O condition on a file
  * descriptor.
@@ -14758,32 +13052,6 @@ export const unixSetFdNonblocking = (fd, nonblock) => {
     }
     return result;
 };
-/**
- * A convenience function for g_unix_signal_source_new(), which
- * attaches to the default #GMainContext.  You can remove the watch
- * using g_source_remove().
- * @param priority - the priority of the signal source. Typically this will be in
- * @param signum - Signal number
- * @param handler - Callback
- * @param userData - Data for @handler
- * @param notify - #GDestroyNotify for @handler
- */
-export const unixSignalAddFull = (priority, signum, handler) => {
-    return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_unix_signal_add_full", [
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: priority,
-        },
-        {
-            type: { type: "int", size: 32, unsigned: false },
-            value: signum,
-        },
-        {
-            type: { type: "callback", trampoline: "sourceFunc" },
-            value: handler,
-        },
-    ], { type: "int", size: 32, unsigned: true });
-};
 /**
  * Create a #GSource that will be dispatched upon delivery of the UNIX
  * signal @signum.  In GLib versions before 2.36, only `SIGHUP`, `SIGINT`,