@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/pango/functions.js

@@ -6,6 +6,13 @@ import { FontDescription } from "./font-description.js";
 import { Language } from "./language.js";
 import { TabArray } from "./tab-array.js";
 import * as GLib from "../glib/index.js";
+/**
+ * Create a new allow-breaks attribute.
+ *
+ * If breaks are disabled, the range will be kept in a
+ * single run, as far as possible.
+ * @param allowBreaks - %TRUE if we line breaks are allowed
+ */
 export const attrAllowBreaksNew = (allowBreaks) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_allow_breaks_new", [
         {
@@ -20,6 +27,10 @@ export const attrAllowBreaksNew = (allowBreaks) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new background alpha attribute.
+ * @param alpha - the alpha value, between 1 and 65536
+ */
 export const attrBackgroundAlphaNew = (alpha) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_background_alpha_new", [
         {
@@ -34,6 +45,12 @@ export const attrBackgroundAlphaNew = (alpha) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new background color attribute.
+ * @param red - the red value (ranging from 0 to 65535)
+ * @param green - the green value
+ * @param blue - the blue value
+ */
 export const attrBackgroundNew = (red, green, blue) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_background_new", [
         {
@@ -56,6 +73,13 @@ export const attrBackgroundNew = (red, green, blue) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new baseline displacement attribute.
+ *
+ * The effect of this attribute is to shift the baseline of a run,
+ * relative to the run of preceding run.
+ * @param shift - either a `PangoBaselineShift` enumeration value or an absolute value (> 1024)
+ */
 export const attrBaselineShiftNew = (shift) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_baseline_shift_new", [
         {
@@ -70,6 +94,18 @@ export const attrBaselineShiftNew = (shift) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Apply customization from attributes to the breaks in @attrs.
+ *
+ * The line breaks are assumed to have been produced
+ * by [func@Pango.default_break] and [func@Pango.tailor_break].
+ * @param text - text to break. Must be valid UTF-8
+ * @param length - length of text in bytes (may be -1 if `text` is nul-terminated)
+ * @param attrList - `PangoAttrList` to apply
+ * @param offset - Byte offset of `text` from the beginning of the paragraph
+ * @param attrs - array with one
+ * @param attrsLen - length of `attrs` array
+ */
 export const attrBreak = (text, length, attrList, offset, attrs, attrsLen) => {
     call("libpango-1.0.so.0", "pango_attr_break", [
         {
@@ -109,6 +145,15 @@ export const attrBreak = (text, length, attrList, offset, attrs, attrsLen) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Create a new font fallback attribute.
+ *
+ * If fallback is disabled, characters will only be
+ * used from the closest matching font on the system.
+ * No fallback will be done to other fonts on the system
+ * that might contain the characters in the text.
+ * @param enableFallback - %TRUE if we should fall back on other fonts
+ */
 export const attrFallbackNew = (enableFallback) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_fallback_new", [
         {
@@ -123,6 +168,10 @@ export const attrFallbackNew = (enableFallback) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font family attribute.
+ * @param family - the family or comma-separated list of families
+ */
 export const attrFamilyNew = (family) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_family_new", [
         {
@@ -137,6 +186,13 @@ export const attrFamilyNew = (family) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font description attribute.
+ *
+ * This attribute allows setting family, style, weight, variant,
+ * stretch, and size simultaneously.
+ * @param desc - the font description
+ */
 export const attrFontDescNew = (desc) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_font_desc_new", [
         {
@@ -156,6 +212,13 @@ export const attrFontDescNew = (desc) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font features tag attribute.
+ *
+ * You can use this attribute to select OpenType font features like small-caps,
+ * alternative glyphs, ligatures, etc. for fonts that support them.
+ * @param features - a string with OpenType font features, with the syntax of the [CSS
+ */
 export const attrFontFeaturesNew = (features) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_font_features_new", [
         {
@@ -170,6 +233,13 @@ export const attrFontFeaturesNew = (features) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font scale attribute.
+ *
+ * The effect of this attribute is to change the font size of a run,
+ * relative to the size of preceding run.
+ * @param scale - a `PangoFontScale` value, which indicates font size change relative
+ */
 export const attrFontScaleNew = (scale) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_font_scale_new", [
         {
@@ -184,6 +254,10 @@ export const attrFontScaleNew = (scale) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new foreground alpha attribute.
+ * @param alpha - the alpha value, between 1 and 65536
+ */
 export const attrForegroundAlphaNew = (alpha) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_foreground_alpha_new", [
         {
@@ -198,6 +272,12 @@ export const attrForegroundAlphaNew = (alpha) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new foreground color attribute.
+ * @param red - the red value (ranging from 0 to 65535)
+ * @param green - the green value
+ * @param blue - the blue value
+ */
 export const attrForegroundNew = (red, green, blue) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_foreground_new", [
         {
@@ -220,6 +300,10 @@ export const attrForegroundNew = (red, green, blue) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new gravity hint attribute.
+ * @param hint - the gravity hint value
+ */
 export const attrGravityHintNew = (hint) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_gravity_hint_new", [
         {
@@ -234,6 +318,10 @@ export const attrGravityHintNew = (hint) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new gravity attribute.
+ * @param gravity - the gravity value; should not be %PANGO_GRAVITY_AUTO
+ */
 export const attrGravityNew = (gravity) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_gravity_new", [
         {
@@ -248,6 +336,14 @@ export const attrGravityNew = (gravity) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new insert-hyphens attribute.
+ *
+ * Pango will insert hyphens when breaking lines in
+ * the middle of a word. This attribute can be used
+ * to suppress the hyphen.
+ * @param insertHyphens - %TRUE if hyphens should be inserted
+ */
 export const attrInsertHyphensNew = (insertHyphens) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_insert_hyphens_new", [
         {
@@ -262,6 +358,10 @@ export const attrInsertHyphensNew = (insertHyphens) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new language tag attribute.
+ * @param language - language tag
+ */
 export const attrLanguageNew = (language) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_language_new", [
         {
@@ -281,6 +381,10 @@ export const attrLanguageNew = (language) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new letter-spacing attribute.
+ * @param letterSpacing - amount of extra space to add between
+ */
 export const attrLetterSpacingNew = (letterSpacing) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_letter_spacing_new", [
         {
@@ -295,6 +399,15 @@ export const attrLetterSpacingNew = (letterSpacing) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Modify the height of logical line extents by a factor.
+ *
+ * This affects the values returned by
+ * [method@Pango.LayoutLine.get_extents],
+ * [method@Pango.LayoutLine.get_pixel_extents] and
+ * [method@Pango.LayoutIter.get_line_extents].
+ * @param factor - the scaling factor to apply to the logical height
+ */
 export const attrLineHeightNew = (factor) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_line_height_new", [
         {
@@ -309,6 +422,15 @@ export const attrLineHeightNew = (factor) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Override the height of logical line extents to be @height.
+ *
+ * This affects the values returned by
+ * [method@Pango.LayoutLine.get_extents],
+ * [method@Pango.LayoutLine.get_pixel_extents] and
+ * [method@Pango.LayoutIter.get_line_extents].
+ * @param height - the line height, in %PANGO_SCALE-ths of a point
+ */
 export const attrLineHeightNewAbsolute = (height) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_line_height_new_absolute", [
         {
@@ -323,6 +445,13 @@ export const attrLineHeightNewAbsolute = (height) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Deserializes a `PangoAttrList` from a string.
+ *
+ * This is the counterpart to [method@Pango.AttrList.to_string].
+ * See that functions for details about the format.
+ * @param text - a string
+ */
 export const attrListFromString = (text) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_list_from_string", [
         {
@@ -339,6 +468,15 @@ export const attrListFromString = (text) => {
         return null;
     return getObject(ptr, AttrList);
 };
+/**
+ * Create a new overline color attribute.
+ *
+ * This attribute modifies the color of overlines.
+ * If not set, overlines will use the foreground color.
+ * @param red - the red value (ranging from 0 to 65535)
+ * @param green - the green value
+ * @param blue - the blue value
+ */
 export const attrOverlineColorNew = (red, green, blue) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_overline_color_new", [
         {
@@ -361,6 +499,10 @@ export const attrOverlineColorNew = (red, green, blue) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new overline-style attribute.
+ * @param overline - the overline style
+ */
 export const attrOverlineNew = (overline) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_overline_new", [
         {
@@ -375,6 +517,10 @@ export const attrOverlineNew = (overline) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new baseline displacement attribute.
+ * @param rise - the amount that the text should be displaced vertically,
+ */
 export const attrRiseNew = (rise) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_rise_new", [
         {
@@ -389,6 +535,13 @@ export const attrRiseNew = (rise) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font size scale attribute.
+ *
+ * The base font for the affected text will have
+ * its size multiplied by @scale_factor.
+ * @param scaleFactor - factor to scale the font
+ */
 export const attrScaleNew = (scaleFactor) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_scale_new", [
         {
@@ -403,6 +556,12 @@ export const attrScaleNew = (scaleFactor) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Marks the range of the attribute as a single sentence.
+ *
+ * Note that this may require adjustments to word and
+ * sentence classification around the range.
+ */
 export const attrSentenceNew = () => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_sentence_new", [], {
         type: "boxed",
@@ -412,6 +571,16 @@ export const attrSentenceNew = () => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new shape attribute.
+ *
+ * A shape is used to impose a particular ink and logical
+ * rectangle on the result of shaping a particular glyph.
+ * This might be used, for instance, for embedding a picture
+ * or a widget inside a `PangoLayout`.
+ * @param inkRect - ink rectangle to assign to each character
+ * @param logicalRect - logical rectangle to assign to each character
+ */
 export const attrShapeNew = (inkRect, logicalRect) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_shape_new", [
         {
@@ -430,6 +599,18 @@ export const attrShapeNew = (inkRect, logicalRect) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Creates a new shape attribute.
+ *
+ * Like [func@Pango.AttrShape.new], but a user data pointer
+ * is also provided; this pointer can be accessed when later
+ * rendering the glyph.
+ * @param inkRect - ink rectangle to assign to each character
+ * @param logicalRect - logical rectangle to assign to each character
+ * @param data - user data pointer
+ * @param copyFunc - function to copy `data` when the
+ * @param destroyFunc - function to free `data` when the
+ */
 export const attrShapeNewWithData = (inkRect, logicalRect, data, copyFunc, destroyFunc) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_shape_new_with_data", [
         {
@@ -463,6 +644,11 @@ export const attrShapeNewWithData = (inkRect, logicalRect, data, copyFunc, destr
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new attribute that influences how invisible
+ * characters are rendered.
+ * @param flags - `PangoShowFlags` to apply
+ */
 export const attrShowNew = (flags) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_show_new", [
         {
@@ -477,6 +663,10 @@ export const attrShowNew = (flags) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font-size attribute in fractional points.
+ * @param size - the font size, in %PANGO_SCALE-ths of a point
+ */
 export const attrSizeNew = (size) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_size_new", [
         {
@@ -491,6 +681,10 @@ export const attrSizeNew = (size) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font-size attribute in device units.
+ * @param size - the font size, in %PANGO_SCALE-ths of a device unit
+ */
 export const attrSizeNewAbsolute = (size) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_size_new_absolute", [
         {
@@ -505,6 +699,10 @@ export const attrSizeNewAbsolute = (size) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font stretch attribute.
+ * @param stretch - the stretch
+ */
 export const attrStretchNew = (stretch) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_stretch_new", [
         {
@@ -519,6 +717,15 @@ export const attrStretchNew = (stretch) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new strikethrough color attribute.
+ *
+ * This attribute modifies the color of strikethrough lines.
+ * If not set, strikethrough lines will use the foreground color.
+ * @param red - the red value (ranging from 0 to 65535)
+ * @param green - the green value
+ * @param blue - the blue value
+ */
 export const attrStrikethroughColorNew = (red, green, blue) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_strikethrough_color_new", [
         {
@@ -541,6 +748,10 @@ export const attrStrikethroughColorNew = (red, green, blue) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new strike-through attribute.
+ * @param strikethrough - %TRUE if the text should be struck-through
+ */
 export const attrStrikethroughNew = (strikethrough) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_strikethrough_new", [
         {
@@ -555,6 +766,10 @@ export const attrStrikethroughNew = (strikethrough) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font slant style attribute.
+ * @param style - the slant style
+ */
 export const attrStyleNew = (style) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_style_new", [
         {
@@ -569,6 +784,11 @@ export const attrStyleNew = (style) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new attribute that influences how characters
+ * are transformed during shaping.
+ * @param transform - `PangoTextTransform` to apply
+ */
 export const attrTextTransformNew = (transform) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_text_transform_new", [
         {
@@ -583,6 +803,18 @@ export const attrTextTransformNew = (transform) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Fetches the attribute type name.
+ *
+ * The attribute type name is the string passed in
+ * when registering the type using
+ * [func@Pango.AttrType.register].
+ *
+ * The returned value is an interned string (see
+ * g_intern_string() for what that means) that should
+ * not be modified or freed.
+ * @param type - an attribute type ID to fetch the name for
+ */
 export const attrTypeGetName = (type) => {
     return call("libpango-1.0.so.0", "pango_attr_type_get_name", [
         {
@@ -591,6 +823,13 @@ export const attrTypeGetName = (type) => {
         },
     ], { type: "string", borrowed: true });
 };
+/**
+ * Allocate a new attribute type ID.
+ *
+ * The attribute type name can be accessed later
+ * by using [func@Pango.AttrType.get_name].
+ * @param name - an identifier for the type
+ */
 export const attrTypeRegister = (name) => {
     return call("libpango-1.0.so.0", "pango_attr_type_register", [
         {
@@ -599,6 +838,15 @@ export const attrTypeRegister = (name) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Create a new underline color attribute.
+ *
+ * This attribute modifies the color of underlines.
+ * If not set, underlines will use the foreground color.
+ * @param red - the red value (ranging from 0 to 65535)
+ * @param green - the green value
+ * @param blue - the blue value
+ */
 export const attrUnderlineColorNew = (red, green, blue) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_underline_color_new", [
         {
@@ -621,6 +869,10 @@ export const attrUnderlineColorNew = (red, green, blue) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new underline-style attribute.
+ * @param underline - the underline style
+ */
 export const attrUnderlineNew = (underline) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_underline_new", [
         {
@@ -635,6 +887,10 @@ export const attrUnderlineNew = (underline) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font variant attribute (normal or small caps).
+ * @param variant - the variant
+ */
 export const attrVariantNew = (variant) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_variant_new", [
         {
@@ -649,6 +905,10 @@ export const attrVariantNew = (variant) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Create a new font weight attribute.
+ * @param weight - the weight
+ */
 export const attrWeightNew = (weight) => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_weight_new", [
         {
@@ -663,6 +923,12 @@ export const attrWeightNew = (weight) => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Marks the range of the attribute as a single word.
+ *
+ * Note that this may require adjustments to word and
+ * sentence classification around the range.
+ */
 export const attrWordNew = () => {
     const ptr = call("libpango-1.0.so.0", "pango_attr_word_new", [], {
         type: "boxed",
@@ -672,6 +938,14 @@ export const attrWordNew = () => {
     });
     return getObject(ptr, Attribute);
 };
+/**
+ * Determines the bidirectional type of a character.
+ *
+ * The bidirectional type is specified in the Unicode Character Database.
+ *
+ * A simplified version of this function is available as [func@unichar_direction].
+ * @param ch - a Unicode character
+ */
 export const bidiTypeForUnichar = (ch) => {
     return call("libpango-1.0.so.0", "pango_bidi_type_for_unichar", [
         {
@@ -680,6 +954,17 @@ export const bidiTypeForUnichar = (ch) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Determines possible line, word, and character breaks
+ * for a string of Unicode text with a single analysis.
+ *
+ * For most purposes you may want to use [func@Pango.get_log_attrs].
+ * @param text - the text to process. Must be valid UTF-8
+ * @param length - length of `text` in bytes (may be -1 if `text` is nul-terminated)
+ * @param analysis - `PangoAnalysis` structure for @text
+ * @param attrs - an array to
+ * @param attrsLen - size of the array passed as @attrs
+ */
 export const _break = (text, length, analysis, attrs, attrsLen) => {
     call("libpango-1.0.so.0", "pango_break", [
         {
@@ -710,6 +995,22 @@ export const _break = (text, length, analysis, attrs, attrsLen) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * This is the default break algorithm.
+ *
+ * It applies rules from the [Unicode Line Breaking Algorithm](http://www.unicode.org/unicode/reports/tr14/)
+ * without language-specific tailoring, therefore the `analyis` argument is unused
+ * and can be %NULL.
+ *
+ * See [func@Pango.tailor_break] for language-specific breaks.
+ *
+ * See [func@Pango.attr_break] for attribute-based customization.
+ * @param text - text to break. Must be valid UTF-8
+ * @param length - length of text in bytes (may be -1 if `text` is nul-terminated)
+ * @param analysis - a `PangoAnalysis` structure for the @text
+ * @param attrs - logical
+ * @param attrsLen - size of the array passed as @attrs
+ */
 export const defaultBreak = (text, length, attrs, attrsLen, analysis) => {
     call("libpango-1.0.so.0", "pango_default_break", [
         {
@@ -741,6 +1042,27 @@ export const defaultBreak = (text, length, attrs, attrsLen, analysis) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Converts extents from Pango units to device units.
+ *
+ * The conversion is done by dividing by the %PANGO_SCALE factor and
+ * performing rounding.
+ *
+ * The `inclusive` rectangle is converted by flooring the x/y coordinates
+ * and extending width/height, such that the final rectangle completely
+ * includes the original rectangle.
+ *
+ * The `nearest` rectangle is converted by rounding the coordinates
+ * of the rectangle to the nearest device unit (pixel).
+ *
+ * The rule to which argument to use is: if you want the resulting device-space
+ * rectangle to completely contain the original rectangle, pass it in as
+ * @inclusive. If you want two touching-but-not-overlapping rectangles stay
+ * touching-but-not-overlapping after rounding to device units, pass them in
+ * as @nearest.
+ * @param inclusive - rectangle to round to pixels inclusively
+ * @param nearest - rectangle to round to nearest pixels
+ */
 export const extentsToPixels = (inclusive, nearest) => {
     call("libpango-1.0.so.0", "pango_extents_to_pixels", [
         {
@@ -759,6 +1081,12 @@ export const extentsToPixels = (inclusive, nearest) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Searches a string the first character that has a strong
+ * direction, according to the Unicode bidirectional algorithm.
+ * @param text - the text to process. Must be valid UTF-8
+ * @param length - length of `text` in bytes (may be -1 if `text` is nul-terminated)
+ */
 export const findBaseDir = (text, length) => {
     return call("libpango-1.0.so.0", "pango_find_base_dir", [
         {
@@ -771,6 +1099,24 @@ export const findBaseDir = (text, length) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Locates a paragraph boundary in @text.
+ *
+ * A boundary is caused by delimiter characters, such as
+ * a newline, carriage return, carriage return-newline pair,
+ * or Unicode paragraph separator character.
+ *
+ * The index of the run of delimiters is returned in
+ * @paragraph_delimiter_index. The index of the start of the
+ * next paragraph (index after all delimiters) is stored n
+ * @next_paragraph_start.
+ *
+ * If no delimiters are found, both `paragraph_delimiter_index` and `next_paragraph_start` are filled with the length of `text` (an index one off the end).
+ * @param text - UTF-8 text
+ * @param length - length of `text` in bytes, or -1 if nul-terminated
+ * @param paragraphDelimiterIndex - return location
+ * @param nextParagraphStart - return location for
+ */
 export const findParagraphBoundary = (text, length, paragraphDelimiterIndex, nextParagraphStart) => {
     call("libpango-1.0.so.0", "pango_find_paragraph_boundary", [
         {
@@ -799,6 +1145,61 @@ export const findParagraphBoundary = (text, length, paragraphDelimiterIndex, nex
         },
     ], { type: "undefined" });
 };
+/**
+ * Creates a new font description from a string representation.
+ *
+ * The string must have the form
+ *
+ * [FAMILY-LIST] [STYLE-OPTIONS] [SIZE] [VARIATIONS] [FEATURES]
+ *
+ * where FAMILY-LIST is a comma-separated list of families optionally
+ * terminated by a comma, STYLE_OPTIONS is a whitespace-separated list
+ * of words where each word describes one of style, variant, weight,
+ * stretch, or gravity, and SIZE is a decimal number (size in points)
+ * or optionally followed by the unit modifier "px" for absolute size.
+ *
+ * The following words are understood as styles:
+ * "Normal", "Roman", "Oblique", "Italic".
+ *
+ * The following words are understood as variants:
+ * "Small-Caps", "All-Small-Caps", "Petite-Caps", "All-Petite-Caps",
+ * "Unicase", "Title-Caps".
+ *
+ * The following words are understood as weights:
+ * "Thin", "Ultra-Light", "Extra-Light", "Light", "Semi-Light",
+ * "Demi-Light", "Book", "Regular", "Medium", "Semi-Bold", "Demi-Bold",
+ * "Bold", "Ultra-Bold", "Extra-Bold", "Heavy", "Black", "Ultra-Black",
+ * "Extra-Black".
+ *
+ * The following words are understood as stretch values:
+ * "Ultra-Condensed", "Extra-Condensed", "Condensed", "Semi-Condensed",
+ * "Semi-Expanded", "Expanded", "Extra-Expanded", "Ultra-Expanded".
+ *
+ * The following words are understood as gravity values:
+ * "Not-Rotated", "South", "Upside-Down", "North", "Rotated-Left",
+ * "East", "Rotated-Right", "West".
+ *
+ * The following words are understood as color values:
+ * "With-Color", "Without-Color".
+ *
+ * VARIATIONS is a comma-separated list of font variations
+ * of the form @‍axis1=value,axis2=value,...
+ *
+ * FEATURES is a comma-separated list of font features of the form
+ * \#‍feature1=value,feature2=value,...
+ * The =value part can be ommitted if the value is 1.
+ *
+ * Any one of the options may be absent. If FAMILY-LIST is absent, then
+ * the family_name field of the resulting font description will be
+ * initialized to %NULL. If STYLE-OPTIONS is missing, then all style
+ * options will be set to the default values. If SIZE is missing, the
+ * size in the resulting font description will be set to 0.
+ *
+ * A typical example:
+ *
+ * Cantarell Italic Light 15 @‍wght=200 #‍tnum=1
+ * @param str - string representation of a font description.
+ */
 export const fontDescriptionFromString = (str) => {
     const ptr = call("libpango-1.0.so.0", "pango_font_description_from_string", [
         {
@@ -813,6 +1214,23 @@ export const fontDescriptionFromString = (str) => {
     });
     return getObject(ptr, FontDescription);
 };
+/**
+ * Computes a `PangoLogAttr` for each character in @text.
+ *
+ * The `attrs` array must have one `PangoLogAttr` for
+ * each position in @text; if `text` contains N characters,
+ * it has N+1 positions, including the last position at the
+ * end of the text. `text` should be an entire paragraph;
+ * logical attributes can't be computed without context
+ * (for example you need to see spaces on either side of
+ * a word to know the word is a word).
+ * @param text - text to process. Must be valid UTF-8
+ * @param length - length in bytes of @text
+ * @param level - embedding level, or -1 if unknown
+ * @param language - language tag
+ * @param attrs - array with one
+ * @param attrsLen - length of `attrs` array
+ */
 export const getLogAttrs = (text, length, level, language, attrs, attrsLen) => {
     call("libpango-1.0.so.0", "pango_get_log_attrs", [
         {
@@ -852,6 +1270,13 @@ export const getLogAttrs = (text, length, level, language, attrs, attrsLen) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Returns the mirrored character of a Unicode character.
+ *
+ * Mirror characters are determined by the Unicode mirrored property.
+ * @param ch - a Unicode character
+ * @param mirroredCh - location to store the mirrored character
+ */
 export const getMirrorChar = (ch, mirroredCh) => {
     return call("libpango-1.0.so.0", "pango_get_mirror_char", [
         {
@@ -868,6 +1293,11 @@ export const getMirrorChar = (ch, mirroredCh) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Finds the gravity that best matches the rotation component
+ * in a `PangoMatrix`.
+ * @param matrix - a `PangoMatrix`
+ */
 export const gravityGetForMatrix = (matrix) => {
     return call("libpango-1.0.so.0", "pango_gravity_get_for_matrix", [
         {
@@ -882,6 +1312,18 @@ export const gravityGetForMatrix = (matrix) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Returns the gravity to use in laying out a `PangoItem`.
+ *
+ * The gravity is determined based on the script, base gravity, and hint.
+ *
+ * If `base_gravity` is %PANGO_GRAVITY_AUTO, it is first replaced with the
+ * preferred gravity of @script.  To get the preferred gravity of a script,
+ * pass %PANGO_GRAVITY_AUTO and %PANGO_GRAVITY_HINT_STRONG in.
+ * @param script - `PangoScript` to query
+ * @param baseGravity - base gravity of the paragraph
+ * @param hint - orientation hint
+ */
 export const gravityGetForScript = (script, baseGravity, hint) => {
     return call("libpango-1.0.so.0", "pango_gravity_get_for_script", [
         {
@@ -898,6 +1340,27 @@ export const gravityGetForScript = (script, baseGravity, hint) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Returns the gravity to use in laying out a single character
+ * or `PangoItem`.
+ *
+ * The gravity is determined based on the script, East Asian width,
+ * base gravity, and hint,
+ *
+ * This function is similar to [func@Pango.Gravity.get_for_script] except
+ * that this function makes a distinction between narrow/half-width and
+ * wide/full-width characters also. Wide/full-width characters always
+ * stand *upright*, that is, they always take the base gravity,
+ * whereas narrow/full-width characters are always rotated in vertical
+ * context.
+ *
+ * If `base_gravity` is %PANGO_GRAVITY_AUTO, it is first replaced with the
+ * preferred gravity of @script.
+ * @param script - `PangoScript` to query
+ * @param wide - %TRUE for wide characters as returned by g_unichar_iswide()
+ * @param baseGravity - base gravity of the paragraph
+ * @param hint - orientation hint
+ */
 export const gravityGetForScriptAndWidth = (script, wide, baseGravity, hint) => {
     return call("libpango-1.0.so.0", "pango_gravity_get_for_script_and_width", [
         {
@@ -918,6 +1381,14 @@ export const gravityGetForScriptAndWidth = (script, wide, baseGravity, hint) =>
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Converts a `PangoGravity` value to its natural rotation in radians.
+ *
+ * Note that [method@Pango.Matrix.rotate] takes angle in degrees, not radians.
+ * So, to call [method@Pango.Matrix,rotate] with the output of this function
+ * you should multiply it by (180. / G_PI).
+ * @param gravity - gravity to query, should not be %PANGO_GRAVITY_AUTO
+ */
 export const gravityToRotation = (gravity) => {
     return call("libpango-1.0.so.0", "pango_gravity_to_rotation", [
         {
@@ -926,6 +1397,15 @@ export const gravityToRotation = (gravity) => {
         },
     ], { type: "float", size: 64 });
 };
+/**
+ * Checks if a character that should not be normally rendered.
+ *
+ * This includes all Unicode characters with "ZERO WIDTH" in their name,
+ * as well as *bidi* formatting characters, and a few other ones.
+ *
+ * This is totally different from [func@GLib.unichar_iszerowidth] and is at best misnamed.
+ * @param ch - a Unicode character
+ */
 export const isZeroWidth = (ch) => {
     return call("libpango-1.0.so.0", "pango_is_zero_width", [
         {
@@ -934,6 +1414,26 @@ export const isZeroWidth = (ch) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Breaks a piece of text into segments with consistent directional
+ * level and font.
+ *
+ * Each byte of `text` will be contained in exactly one of the items in the
+ * returned list; the generated list of items will be in logical order (the
+ * start offsets of the items are ascending).
+ *
+ * `cached_iter` should be an iterator over `attrs` currently positioned
+ * at a range before or containing @start_index; `cached_iter` will be
+ * advanced to the range covering the position just after
+ * `start_index` + @length. (i.e. if itemizing in a loop, just keep passing
+ * in the same @cached_iter).
+ * @param context - a structure holding information that affects
+ * @param text - the text to itemize. Must be valid UTF-8
+ * @param startIndex - first byte in `text` to process
+ * @param length - the number of bytes (not characters) to process
+ * @param attrs - the set of attributes that apply to @text.
+ * @param cachedIter - Cached attribute iterator
+ */
 export const itemize = (context, text, startIndex, length, attrs, cachedIter) => {
     return call("libpango-1.0.so.0", "pango_itemize", [
         {
@@ -982,6 +1482,20 @@ export const itemize = (context, text, startIndex, length, attrs, cachedIter) =>
         borrowed: true,
     });
 };
+/**
+ * Like `pango_itemize()`, but with an explicitly specified base direction.
+ *
+ * The base direction is used when computing bidirectional levels.
+ * [func@itemize] gets the base direction from the `PangoContext`
+ * (see [method@Pango.Context.set_base_dir]).
+ * @param context - a structure holding information that affects
+ * @param baseDir - base direction to use for bidirectional processing
+ * @param text - the text to itemize.
+ * @param startIndex - first byte in `text` to process
+ * @param length - the number of bytes (not characters) to process
+ * @param attrs - the set of attributes that apply to @text.
+ * @param cachedIter - Cached attribute iterator
+ */
 export const itemizeWithBaseDir = (context, baseDir, text, startIndex, length, attrs, cachedIter) => {
     return call("libpango-1.0.so.0", "pango_itemize_with_base_dir", [
         {
@@ -1034,6 +1548,21 @@ export const itemizeWithBaseDir = (context, baseDir, text, startIndex, length, a
         borrowed: true,
     });
 };
+/**
+ * Convert a language tag to a `PangoLanguage`.
+ *
+ * The language tag must be in a RFC-3066 format. `PangoLanguage` pointers
+ * can be efficiently copied (copy the pointer) and compared with other
+ * language tags (compare the pointer.)
+ *
+ * This function first canonicalizes the string by converting it to
+ * lowercase, mapping '_' to '-', and stripping all characters other
+ * than letters and '-'.
+ *
+ * Use [func@Pango.Language.get_default] if you want to get the
+ * `PangoLanguage` for the current locale of the process.
+ * @param language - a string representing a language tag
+ */
 export const languageFromString = (language) => {
     const ptr = call("libpango-1.0.so.0", "pango_language_from_string", [
         {
@@ -1051,6 +1580,39 @@ export const languageFromString = (language) => {
         return null;
     return getObject(ptr, Language);
 };
+/**
+ * Returns the `PangoLanguage` for the current locale of the process.
+ *
+ * On Unix systems, this is the return value is derived from
+ * `setlocale (LC_CTYPE, NULL)`, and the user can
+ * affect this through the environment variables LC_ALL, LC_CTYPE or
+ * LANG (checked in that order). The locale string typically is in
+ * the form lang_COUNTRY, where lang is an ISO-639 language code, and
+ * COUNTRY is an ISO-3166 country code. For instance, sv_FI for
+ * Swedish as written in Finland or pt_BR for Portuguese as written in
+ * Brazil.
+ *
+ * On Windows, the C library does not use any such environment
+ * variables, and setting them won't affect the behavior of functions
+ * like ctime(). The user sets the locale through the Regional Options
+ * in the Control Panel. The C library (in the setlocale() function)
+ * does not use country and language codes, but country and language
+ * names spelled out in English.
+ * However, this function does check the above environment
+ * variables, and does return a Unix-style locale string based on
+ * either said environment variables or the thread's current locale.
+ *
+ * Your application should call `setlocale(LC_ALL, "")` for the user
+ * settings to take effect. GTK does this in its initialization
+ * functions automatically (by calling gtk_set_locale()).
+ * See the setlocale() manpage for more details.
+ *
+ * Note that the default language can change over the life of an application.
+ *
+ * Also note that this function will not do the right thing if you
+ * use per-thread locales with uselocale(). In that case, you should
+ * just call pango_language_from_string() yourself.
+ */
 export const languageGetDefault = () => {
     const ptr = call("libpango-1.0.so.0", "pango_language_get_default", [], {
         type: "boxed",
@@ -1060,6 +1622,19 @@ export const languageGetDefault = () => {
     });
     return getObject(ptr, Language);
 };
+/**
+ * Returns the list of languages that the user prefers.
+ *
+ * The list is specified by the `PANGO_LANGUAGE` or `LANGUAGE`
+ * environment variables, in order of preference. Note that this
+ * list does not necessarily include the language returned by
+ * [func@Pango.Language.get_default].
+ *
+ * When choosing language-specific resources, such as the sample
+ * text returned by [method@Pango.Language.get_sample_string],
+ * you should first try the default language, followed by the
+ * languages returned by this function.
+ */
 export const languageGetPreferred = () => {
     return call("libpango-1.0.so.0", "pango_language_get_preferred", [], {
         type: "array",
@@ -1077,6 +1652,18 @@ export const layoutDeserializeErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Return the bidirectional embedding levels of the input paragraph.
+ *
+ * The bidirectional embedding levels are defined by the [Unicode Bidirectional
+ * Algorithm](http://www.unicode.org/reports/tr9/).
+ *
+ * If the input base direction is a weak direction, the direction of the
+ * characters in the text will determine the final resolved direction.
+ * @param text - the text to itemize.
+ * @param length - the number of bytes (not characters) to process, or -1
+ * @param pbaseDir - input base direction, and output resolved direction.
+ */
 export const log2visGetEmbeddingLevels = (text, length, pbaseDir) => {
     return call("libpango-1.0.so.0", "pango_log2vis_get_embedding_levels", [
         {
@@ -1096,6 +1683,18 @@ export const log2visGetEmbeddingLevels = (text, length, pbaseDir) => {
         },
     ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
 };
+/**
+ * Finishes parsing markup.
+ *
+ * After feeding a Pango markup parser some data with [method@GLib.MarkupParseContext.parse],
+ * use this function to get the list of attributes and text out of the
+ * markup. This function will not free @context, use [method@GLib.MarkupParseContext.free]
+ * to do so.
+ * @param context - A valid parse context that was returned from [func@markup_parser_new]
+ * @param attrList - address of return location for a `PangoAttrList`
+ * @param text - address of return location for text with tags stripped
+ * @param accelChar - address of return location for accelerator char
+ */
 export const markupParserFinish = (context, attrList, text, accelChar) => {
     const error = { value: null };
     const result = call("libpango-1.0.so.0", "pango_markup_parser_finish", [
@@ -1150,6 +1749,30 @@ export const markupParserFinish = (context, attrList, text, accelChar) => {
     }
     return result;
 };
+/**
+ * Incrementally parses marked-up text to create a plain-text string
+ * and an attribute list.
+ *
+ * See the Pango Markup docs for details about the
+ * supported markup.
+ *
+ * If `accel_marker` is nonzero, the given character will mark the
+ * character following it as an accelerator. For example, `accel_marker` might be an ampersand or underscore. All characters marked
+ * as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute,
+ * and the first character so marked will be returned in @accel_char,
+ * when calling [func@markup_parser_finish]. Two `accel_marker` characters
+ * following each other produce a single literal `accel_marker` character.
+ *
+ * To feed markup to the parser, use [method@GLib.MarkupParseContext.parse]
+ * on the returned [struct@GLib.MarkupParseContext]. When done with feeding markup
+ * to the parser, use [func@markup_parser_finish] to get the data out
+ * of it, and then use [method@GLib.MarkupParseContext.free] to free it.
+ *
+ * This function is designed for applications that read Pango markup
+ * from streams. To simply parse a string containing Pango markup,
+ * the [func@Pango.parse_markup] API is recommended instead.
+ * @param accelMarker - character that precedes an accelerator, or 0 for none
+ */
 export const markupParserNew = (accelMarker) => {
     const ptr = call("libpango-1.0.so.0", "pango_markup_parser_new", [
         {
@@ -1164,6 +1787,23 @@ export const markupParserNew = (accelMarker) => {
     });
     return getObject(ptr, GLib.MarkupParseContext);
 };
+/**
+ * Parses an enum type and stores the result in @value.
+ *
+ * If `str` does not match the nick name of any of the possible values
+ * for the enum and is not an integer, %FALSE is returned, a warning
+ * is issued if `warn` is %TRUE, and a string representing the list of
+ * possible values is stored in @possible_values. The list is
+ * slash-separated, eg. "none/start/middle/end".
+ *
+ * If failed and `possible_values` is not %NULL, returned string should
+ * be freed using g_free().
+ * @param type - enum type to parse, eg. %PANGO_TYPE_ELLIPSIZE_MODE
+ * @param str - string to parse
+ * @param value - integer to store the result in
+ * @param warn - if %TRUE, issue a g_warning() on bad input
+ * @param possibleValues - place to store list of possible
+ */
 export const parseEnum = (type, warn, str, value, possibleValues) => {
     return call("libpango-1.0.so.0", "pango_parse_enum", [
         {
@@ -1194,6 +1834,30 @@ export const parseEnum = (type, warn, str, value, possibleValues) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Parses marked-up text to create a plain-text string and an attribute list.
+ *
+ * See the Pango Markup docs for details about the
+ * supported markup.
+ *
+ * If `accel_marker` is nonzero, the given character will mark the
+ * character following it as an accelerator. For example, `accel_marker` might be an ampersand or underscore. All characters marked
+ * as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute,
+ * and the first character so marked will be returned in @accel_char.
+ * Two `accel_marker` characters following each other produce a single
+ * literal `accel_marker` character.
+ *
+ * To parse a stream of pango markup incrementally, use [func@markup_parser_new].
+ *
+ * If any error happens, none of the output arguments are touched except
+ * for @error.
+ * @param markupText - markup to parse (see the Pango Markup docs)
+ * @param length - length of @markup_text, or -1 if nul-terminated
+ * @param accelMarker - character that precedes an accelerator, or 0 for none
+ * @param attrList - address of return location for a `PangoAttrList`
+ * @param text - address of return location for text with tags stripped
+ * @param accelChar - address of return location for accelerator char
+ */
 export const parseMarkup = (markupText, length, accelMarker, attrList, text, accelChar) => {
     const error = { value: null };
     const result = call("libpango-1.0.so.0", "pango_parse_markup", [
@@ -1251,6 +1915,18 @@ export const parseMarkup = (markupText, length, accelMarker, attrList, text, acc
     }
     return result;
 };
+/**
+ * Parses a font stretch.
+ *
+ * The allowed values are
+ * "ultra_condensed", "extra_condensed", "condensed",
+ * "semi_condensed", "normal", "semi_expanded", "expanded",
+ * "extra_expanded" and "ultra_expanded". Case variations are
+ * ignored and the '_' characters may be omitted.
+ * @param str - a string to parse.
+ * @param stretch - a `PangoStretch` to store the result in.
+ * @param warn - if %TRUE, issue a g_warning() on bad input.
+ */
 export const parseStretch = (str, stretch, warn) => {
     return call("libpango-1.0.so.0", "pango_parse_stretch", [
         {
@@ -1270,6 +1946,16 @@ export const parseStretch = (str, stretch, warn) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Parses a font style.
+ *
+ * The allowed values are "normal", "italic" and "oblique", case
+ * variations being
+ * ignored.
+ * @param str - a string to parse.
+ * @param style - a `PangoStyle` to store the result in.
+ * @param warn - if %TRUE, issue a g_warning() on bad input.
+ */
 export const parseStyle = (str, style, warn) => {
     return call("libpango-1.0.so.0", "pango_parse_style", [
         {
@@ -1289,6 +1975,16 @@ export const parseStyle = (str, style, warn) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Parses a font variant.
+ *
+ * The allowed values are "normal", "small-caps", "all-small-caps",
+ * "petite-caps", "all-petite-caps", "unicase" and "title-caps",
+ * case variations being ignored.
+ * @param str - a string to parse.
+ * @param variant - a `PangoVariant` to store the result in.
+ * @param warn - if %TRUE, issue a g_warning() on bad input.
+ */
 export const parseVariant = (str, variant, warn) => {
     return call("libpango-1.0.so.0", "pango_parse_variant", [
         {
@@ -1308,6 +2004,16 @@ export const parseVariant = (str, variant, warn) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Parses a font weight.
+ *
+ * The allowed values are "heavy",
+ * "ultrabold", "bold", "normal", "light", "ultraleight"
+ * and integers. Case variations are ignored.
+ * @param str - a string to parse.
+ * @param weight - a `PangoWeight` to store the result in.
+ * @param warn - if %TRUE, issue a g_warning() on bad input.
+ */
 export const parseWeight = (str, weight, warn) => {
     return call("libpango-1.0.so.0", "pango_parse_weight", [
         {
@@ -1327,6 +2033,18 @@ export const parseWeight = (str, weight, warn) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Quantizes the thickness and position of a line to whole device pixels.
+ *
+ * This is typically used for underline or strikethrough. The purpose of
+ * this function is to avoid such lines looking blurry.
+ *
+ * Care is taken to make sure `thickness` is at least one pixel when this
+ * function returns, but returned `position` may become zero as a result
+ * of rounding.
+ * @param thickness - pointer to the thickness of a line, in Pango units
+ * @param position - corresponding position
+ */
 export const quantizeLineGeometry = (thickness, position) => {
     call("libpango-1.0.so.0", "pango_quantize_line_geometry", [
         {
@@ -1345,6 +2063,18 @@ export const quantizeLineGeometry = (thickness, position) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Reads an entire line from a file into a buffer.
+ *
+ * Lines may be delimited with '\n', '\r', '\n\r', or '\r\n'. The delimiter
+ * is not written into the buffer. Text after a '#' character is treated as
+ * a comment and skipped. '\' can be used to escape a # character.
+ * '\' proceeding a line delimiter combines adjacent lines. A '\' proceeding
+ * any other character is ignored and written into the output buffer
+ * unmodified.
+ * @param stream - a stdio stream
+ * @param str - `GString` buffer into which to write the result
+ */
 export const readLine = (str, stream) => {
     return call("libpango-1.0.so.0", "pango_read_line", [
         {
@@ -1363,6 +2093,17 @@ export const readLine = (str, stream) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Reorder items from logical order to visual order.
+ *
+ * The visual order is determined from the associated directional
+ * levels of the items. The original list is unmodified.
+ *
+ * (Please open a bug if you use this function.
+ * It is not a particularly convenient interface, and the code
+ * is duplicated elsewhere in Pango for that reason.)
+ * @param items - a `GList` of `PangoItem`
+ */
 export const reorderItems = (items) => {
     return call("libpango-1.0.so.0", "pango_reorder_items", [
         {
@@ -1388,6 +2129,13 @@ export const reorderItems = (items) => {
         borrowed: true,
     });
 };
+/**
+ * Scans an integer.
+ *
+ * Leading white space is skipped.
+ * @param pos - in/out string position
+ * @param out - an int into which to write the result
+ */
 export const scanInt = (pos, out) => {
     return call("libpango-1.0.so.0", "pango_scan_int", [
         {
@@ -1403,6 +2151,15 @@ export const scanInt = (pos, out) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Scans a string into a `GString` buffer.
+ *
+ * The string may either be a sequence of non-white-space characters,
+ * or a quoted string with '"'. Instead a quoted string, '\"' represents
+ * a literal quote. Leading white space outside of quotes is skipped.
+ * @param pos - in/out string position
+ * @param out - a `GString` into which to write the result
+ */
 export const scanString = (pos, out) => {
     return call("libpango-1.0.so.0", "pango_scan_string", [
         {
@@ -1420,6 +2177,14 @@ export const scanString = (pos, out) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Scans a word into a `GString` buffer.
+ *
+ * A word consists of [A-Za-z_] followed by zero or more
+ * [A-Za-z_0-9]. Leading white space is skipped.
+ * @param pos - in/out string position
+ * @param out - a `GString` into which to write the result
+ */
 export const scanWord = (pos, out) => {
     return call("libpango-1.0.so.0", "pango_scan_word", [
         {
@@ -1437,6 +2202,21 @@ export const scanWord = (pos, out) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Looks up the script for a particular character.
+ *
+ * The script of a character is defined by
+ * [Unicode Standard Annex 24: Script names](http://www.unicode.org/reports/tr24/).
+ *
+ * No check is made for `ch` being a valid Unicode character; if you pass
+ * in invalid character, the result is undefined.
+ *
+ * Note that while the return type of this function is declared
+ * as `PangoScript`, as of Pango 1.18, this function simply returns
+ * the return value of [func@GLib.unichar_get_script]. Callers must be
+ * prepared to handle unknown values.
+ * @param ch - a Unicode character
+ */
 export const scriptForUnichar = (ch) => {
     return call("libpango-1.0.so.0", "pango_script_for_unichar", [
         {
@@ -1445,6 +2225,38 @@ export const scriptForUnichar = (ch) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Finds a language tag that is reasonably representative of @script.
+ *
+ * The language will usually be the most widely spoken or used language
+ * written in that script: for instance, the sample language for
+ * %PANGO_SCRIPT_CYRILLIC is ru (Russian), the sample language for
+ * %PANGO_SCRIPT_ARABIC is ar.
+ *
+ * For some scripts, no sample language will be returned because
+ * there is no language that is sufficiently representative. The
+ * best example of this is %PANGO_SCRIPT_HAN, where various different
+ * variants of written Chinese, Japanese, and Korean all use
+ * significantly different sets of Han characters and forms
+ * of shared characters. No sample language can be provided
+ * for many historical scripts as well.
+ *
+ * As of 1.18, this function checks the environment variables
+ * `PANGO_LANGUAGE` and `LANGUAGE` (checked in that order) first.
+ * If one of them is set, it is parsed as a list of language tags
+ * separated by colons or other separators. This function
+ * will return the first language in the parsed list that Pango
+ * believes may use `script` for writing. This last predicate
+ * is tested using [method@Pango.Language.includes_script]. This can
+ * be used to control Pango's font selection for non-primary
+ * languages. For example, a `PANGO_LANGUAGE` enviroment variable
+ * set to "en:fa" makes Pango choose fonts suitable for Persian (fa)
+ * instead of Arabic (ar) when a segment of Arabic text is found
+ * in an otherwise non-Arabic text. The same trick can be used to
+ * choose a default language for %PANGO_SCRIPT_HAN when setting
+ * context language is not feasible.
+ * @param script - a `PangoScript`
+ */
 export const scriptGetSampleLanguage = (script) => {
     const ptr = call("libpango-1.0.so.0", "pango_script_get_sample_language", [
         {
@@ -1461,6 +2273,30 @@ export const scriptGetSampleLanguage = (script) => {
         return null;
     return getObject(ptr, Language);
 };
+/**
+ * Convert the characters in `text` into glyphs.
+ *
+ * Given a segment of text and the corresponding `PangoAnalysis` structure
+ * returned from [func@Pango.itemize], convert the characters into glyphs. You
+ * may also pass in only a substring of the item from [func@Pango.itemize].
+ *
+ * It is recommended that you use [func@Pango.shape_full] instead, since
+ * that API allows for shaping interaction happening across text item
+ * boundaries.
+ *
+ * Some aspects of hyphen insertion and text transformation (in particular,
+ * capitalization) require log attrs, and thus can only be handled by
+ * [func@Pango.shape_item].
+ *
+ * Note that the extra attributes in the `analyis` that is returned from
+ * [func@Pango.itemize] have indices that are relative to the entire paragraph,
+ * so you need to subtract the item offset from their indices before
+ * calling [func@Pango.shape].
+ * @param text - the text to process
+ * @param length - the length (in bytes) of @text
+ * @param analysis - `PangoAnalysis` structure from [func@Pango.itemize]
+ * @param glyphs - glyph string in which to store results
+ */
 export const shape = (text, length, analysis, glyphs) => {
     call("libpango-1.0.so.0", "pango_shape", [
         {
@@ -1488,6 +2324,35 @@ export const shape = (text, length, analysis, glyphs) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Convert the characters in `text` into glyphs.
+ *
+ * Given a segment of text and the corresponding `PangoAnalysis` structure
+ * returned from [func@Pango.itemize], convert the characters into glyphs.
+ * You may also pass in only a substring of the item from [func@Pango.itemize].
+ *
+ * This is similar to [func@Pango.shape], except it also can optionally take
+ * the full paragraph text as input, which will then be used to perform
+ * certain cross-item shaping interactions. If you have access to the broader
+ * text of which `item_text` is part of, provide the broader text as
+ * @paragraph_text. If `paragraph_text` is %NULL, item text is used instead.
+ *
+ * Some aspects of hyphen insertion and text transformation (in particular,
+ * capitalization) require log attrs, and thus can only be handled by
+ * [func@Pango.shape_item].
+ *
+ * Note that the extra attributes in the `analyis` that is returned from
+ * [func@Pango.itemize] have indices that are relative to the entire paragraph,
+ * so you do not pass the full paragraph text as @paragraph_text, you need
+ * to subtract the item offset from their indices before calling
+ * [func@Pango.shape_full].
+ * @param itemText - valid UTF-8 text to shape.
+ * @param itemLength - the length (in bytes) of @item_text. -1 means nul-terminated text.
+ * @param paragraphText - text of the paragraph (see details).
+ * @param paragraphLength - the length (in bytes) of @paragraph_text. -1 means nul-terminated text.
+ * @param analysis - `PangoAnalysis` structure from [func@Pango.itemize].
+ * @param glyphs - glyph string in which to store results.
+ */
 export const shapeFull = (itemText, itemLength, paragraphLength, analysis, glyphs, paragraphText) => {
     call("libpango-1.0.so.0", "pango_shape_full", [
         {
@@ -1524,6 +2389,27 @@ export const shapeFull = (itemText, itemLength, paragraphLength, analysis, glyph
         },
     ], { type: "undefined" });
 };
+/**
+ * Convert the characters in `item` into glyphs.
+ *
+ * This is similar to [func@Pango.shape_with_flags], except it takes a
+ * `PangoItem` instead of separate `item_text` and `analysis` arguments.
+ *
+ * It also takes @log_attrs, which are needed for implementing some aspects
+ * of hyphen insertion and text transforms (in particular, capitalization).
+ *
+ * Note that the extra attributes in the `analyis` that is returned from
+ * [func@Pango.itemize] have indices that are relative to the entire paragraph,
+ * so you do not pass the full paragraph text as @paragraph_text, you need
+ * to subtract the item offset from their indices before calling
+ * [func@Pango.shape_with_flags].
+ * @param item - `PangoItem` to shape
+ * @param paragraphText - text of the paragraph (see details).
+ * @param paragraphLength - the length (in bytes) of @paragraph_text.
+ * @param logAttrs - array of `PangoLogAttr` for @item
+ * @param glyphs - glyph string in which to store results
+ * @param flags - flags influencing the shaping process
+ */
 export const shapeItem = (item, paragraphLength, glyphs, flags, paragraphText, logAttrs) => {
     call("libpango-1.0.so.0", "pango_shape_item", [
         {
@@ -1566,6 +2452,33 @@ export const shapeItem = (item, paragraphLength, glyphs, flags, paragraphText, l
         },
     ], { type: "undefined" });
 };
+/**
+ * Convert the characters in `text` into glyphs.
+ *
+ * Given a segment of text and the corresponding `PangoAnalysis` structure
+ * returned from [func@Pango.itemize], convert the characters into glyphs.
+ * You may also pass in only a substring of the item from [func@Pango.itemize].
+ *
+ * This is similar to [func@Pango.shape_full], except it also takes flags
+ * that can influence the shaping process.
+ *
+ * Some aspects of hyphen insertion and text transformation (in particular,
+ * capitalization) require log attrs, and thus can only be handled by
+ * [func@Pango.shape_item].
+ *
+ * Note that the extra attributes in the `analyis` that is returned from
+ * [func@Pango.itemize] have indices that are relative to the entire paragraph,
+ * so you do not pass the full paragraph text as @paragraph_text, you need
+ * to subtract the item offset from their indices before calling
+ * [func@Pango.shape_with_flags].
+ * @param itemText - valid UTF-8 text to shape
+ * @param itemLength - the length (in bytes) of @item_text.
+ * @param paragraphText - text of the paragraph (see details).
+ * @param paragraphLength - the length (in bytes) of @paragraph_text.
+ * @param analysis - `PangoAnalysis` structure from [func@Pango.itemize]
+ * @param glyphs - glyph string in which to store results
+ * @param flags - flags influencing the shaping process
+ */
 export const shapeWithFlags = (itemText, itemLength, paragraphLength, analysis, glyphs, flags, paragraphText) => {
     call("libpango-1.0.so.0", "pango_shape_with_flags", [
         {
@@ -1606,6 +2519,10 @@ export const shapeWithFlags = (itemText, itemLength, paragraphLength, analysis,
         },
     ], { type: "undefined" });
 };
+/**
+ * Skips 0 or more characters of white space.
+ * @param pos - in/out string position
+ */
 export const skipSpace = (pos) => {
     return call("libpango-1.0.so.0", "pango_skip_space", [
         {
@@ -1614,6 +2531,11 @@ export const skipSpace = (pos) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Splits a %G_SEARCHPATH_SEPARATOR-separated list of files, stripping
+ * white space and substituting ~/ with $HOME/.
+ * @param str - a %G_SEARCHPATH_SEPARATOR separated list of filenames
+ */
 export const splitFileList = (str) => {
     return call("libpango-1.0.so.0", "pango_split_file_list", [
         {
@@ -1622,6 +2544,13 @@ export const splitFileList = (str) => {
         },
     ], { type: "array", itemType: { type: "string" } });
 };
+/**
+ * Deserializes a `PangoTabArray` from a string.
+ *
+ * This is the counterpart to [method@Pango.TabArray.to_string].
+ * See that functions for details about the format.
+ * @param text - a string
+ */
 export const tabArrayFromString = (text) => {
     const ptr = call("libpango-1.0.so.0", "pango_tab_array_from_string", [
         {
@@ -1638,6 +2567,23 @@ export const tabArrayFromString = (text) => {
         return null;
     return getObject(ptr, TabArray);
 };
+/**
+ * Apply language-specific tailoring to the breaks in @attrs.
+ *
+ * The line breaks are assumed to have been produced by [func@Pango.default_break].
+ *
+ * If `offset` is not -1, it is used to apply attributes from `analysis` that are
+ * relevant to line breaking.
+ *
+ * Note that it is better to pass -1 for `offset` and use [func@Pango.attr_break]
+ * to apply attributes to the whole paragraph.
+ * @param text - text to process. Must be valid UTF-8
+ * @param length - length in bytes of @text
+ * @param analysis - `PangoAnalysis` for @text
+ * @param offset - Byte offset of `text` from the beginning of the
+ * @param attrs - array with one
+ * @param attrsLen - length of `attrs` array
+ */
 export const tailorBreak = (text, length, analysis, offset, attrs, attrsLen) => {
     call("libpango-1.0.so.0", "pango_tailor_break", [
         {
@@ -1672,6 +2618,10 @@ export const tailorBreak = (text, length, analysis, offset, attrs, attrsLen) =>
         },
     ], { type: "undefined" });
 };
+/**
+ * Trims leading and trailing whitespace from a string.
+ * @param str - a string
+ */
 export const trimString = (str) => {
     return call("libpango-1.0.so.0", "pango_trim_string", [
         {
@@ -1680,6 +2630,18 @@ export const trimString = (str) => {
         },
     ], { type: "string" });
 };
+/**
+ * Determines the inherent direction of a character.
+ *
+ * The inherent direction is either `PANGO_DIRECTION_LTR`, `PANGO_DIRECTION_RTL`,
+ * or `PANGO_DIRECTION_NEUTRAL`.
+ *
+ * This function is useful to categorize characters into left-to-right
+ * letters, right-to-left letters, and everything else. If full Unicode
+ * bidirectional type of a character is needed, [func@Pango.BidiType.for_unichar]
+ * can be used instead.
+ * @param ch - a Unicode character
+ */
 export const unicharDirection = (ch) => {
     return call("libpango-1.0.so.0", "pango_unichar_direction", [
         {
@@ -1688,6 +2650,13 @@ export const unicharDirection = (ch) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Converts a floating-point number to Pango units.
+ *
+ * The conversion is done by multiplying `d` by %PANGO_SCALE and
+ * rounding the result to nearest integer.
+ * @param d - double floating-point value
+ */
 export const unitsFromDouble = (d) => {
     return call("libpango-1.0.so.0", "pango_units_from_double", [
         {
@@ -1696,6 +2665,12 @@ export const unitsFromDouble = (d) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Converts a number in Pango units to floating-point.
+ *
+ * The conversion is done by dividing `i` by %PANGO_SCALE.
+ * @param i - value in Pango units
+ */
 export const unitsToDouble = (i) => {
     return call("libpango-1.0.so.0", "pango_units_to_double", [
         {
@@ -1704,6 +2679,13 @@ export const unitsToDouble = (i) => {
         },
     ], { type: "float", size: 64 });
 };
+/**
+ * Returns the encoded version of Pango available at run-time.
+ *
+ * This is similar to the macro %PANGO_VERSION except that the macro
+ * returns the encoded version available at compile-time. A version
+ * number can be encoded into an integer using PANGO_VERSION_ENCODE().
+ */
 export const version = () => {
     return call("libpango-1.0.so.0", "pango_version", [], {
         type: "int",
@@ -1711,6 +2693,27 @@ export const version = () => {
         unsigned: false,
     });
 };
+/**
+ * Checks that the Pango library in use is compatible with the
+ * given version.
+ *
+ * Generally you would pass in the constants %PANGO_VERSION_MAJOR,
+ * %PANGO_VERSION_MINOR, %PANGO_VERSION_MICRO as the three arguments
+ * to this function; that produces a check that the library in use at
+ * run-time is compatible with the version of Pango the application or
+ * module was compiled against.
+ *
+ * Compatibility is defined by two things: first the version
+ * of the running library is newer than the version
+ * @required_major.required_minor.@required_micro. Second
+ * the running library must be binary compatible with the
+ * version @required_major.required_minor.`required_micro` (same major version.)
+ *
+ * For compile-time version checking use PANGO_VERSION_CHECK().
+ * @param requiredMajor - the required major version
+ * @param requiredMinor - the required minor version
+ * @param requiredMicro - the required major version
+ */
 export const versionCheck = (requiredMajor, requiredMinor, requiredMicro) => {
     return call("libpango-1.0.so.0", "pango_version_check", [
         {
@@ -1727,6 +2730,12 @@ export const versionCheck = (requiredMajor, requiredMinor, requiredMicro) => {
         },
     ], { type: "string", borrowed: true });
 };
+/**
+ * Returns the version of Pango available at run-time.
+ *
+ * This is similar to the macro %PANGO_VERSION_STRING except that the
+ * macro returns the version available at compile-time.
+ */
 export const versionString = () => {
     return call("libpango-1.0.so.0", "pango_version_string", [], {
         type: "string",