@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/pango/functions.d.ts

@@ -11,97 +11,1106 @@ import { Matrix } from "./matrix.js";
 import { TabArray } from "./tab-array.js";
 import { Context } from "./context.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 declare const attrAllowBreaksNew: (allowBreaks: boolean) => Attribute;
+/**
+ * Create a new background alpha attribute.
+ * @param alpha - the alpha value, between 1 and 65536
+ */
 export declare const attrBackgroundAlphaNew: (alpha: number) => 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 declare const attrBackgroundNew: (red: number, green: number, blue: number) => 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 declare const attrBaselineShiftNew: (shift: number) => 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 declare const attrBreak: (text: string, length: number, attrList: AttrList, offset: number, attrs: Ref<number[]>, attrsLen: number) => void;
+/**
+ * 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 declare const attrFallbackNew: (enableFallback: boolean) => Attribute;
+/**
+ * Create a new font family attribute.
+ * @param family - the family or comma-separated list of families
+ */
 export declare const attrFamilyNew: (family: string) => 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 declare const attrFontDescNew: (desc: FontDescription) => 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 declare const attrFontFeaturesNew: (features: string) => 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 declare const attrFontScaleNew: (scale: FontScale) => Attribute;
+/**
+ * Create a new foreground alpha attribute.
+ * @param alpha - the alpha value, between 1 and 65536
+ */
 export declare const attrForegroundAlphaNew: (alpha: number) => 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 declare const attrForegroundNew: (red: number, green: number, blue: number) => Attribute;
+/**
+ * Create a new gravity hint attribute.
+ * @param hint - the gravity hint value
+ */
 export declare const attrGravityHintNew: (hint: GravityHint) => Attribute;
+/**
+ * Create a new gravity attribute.
+ * @param gravity - the gravity value; should not be %PANGO_GRAVITY_AUTO
+ */
 export declare const attrGravityNew: (gravity: Gravity) => 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 declare const attrInsertHyphensNew: (insertHyphens: boolean) => Attribute;
+/**
+ * Create a new language tag attribute.
+ * @param language - language tag
+ */
 export declare const attrLanguageNew: (language: Language) => Attribute;
+/**
+ * Create a new letter-spacing attribute.
+ * @param letterSpacing - amount of extra space to add between
+ */
 export declare const attrLetterSpacingNew: (letterSpacing: number) => 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 declare const attrLineHeightNew: (factor: number) => 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 declare const attrLineHeightNewAbsolute: (height: number) => 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 declare const attrListFromString: (text: string) => AttrList | null;
+/**
+ * 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 declare const attrOverlineColorNew: (red: number, green: number, blue: number) => Attribute;
+/**
+ * Create a new overline-style attribute.
+ * @param overline - the overline style
+ */
 export declare const attrOverlineNew: (overline: Overline) => Attribute;
+/**
+ * Create a new baseline displacement attribute.
+ * @param rise - the amount that the text should be displaced vertically,
+ */
 export declare const attrRiseNew: (rise: number) => 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 declare const attrScaleNew: (scaleFactor: number) => 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 declare const attrSentenceNew: () => 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 declare const attrShapeNew: (inkRect: number, logicalRect: number) => 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 declare const attrShapeNewWithData: (inkRect: number, logicalRect: number, data?: number | null, copyFunc?: (...args: unknown[]) => unknown | null, destroyFunc?: () => void | null) => Attribute;
+/**
+ * Create a new attribute that influences how invisible
+ * characters are rendered.
+ * @param flags - `PangoShowFlags` to apply
+ */
 export declare const attrShowNew: (flags: ShowFlags) => Attribute;
+/**
+ * Create a new font-size attribute in fractional points.
+ * @param size - the font size, in %PANGO_SCALE-ths of a point
+ */
 export declare const attrSizeNew: (size: number) => Attribute;
+/**
+ * Create a new font-size attribute in device units.
+ * @param size - the font size, in %PANGO_SCALE-ths of a device unit
+ */
 export declare const attrSizeNewAbsolute: (size: number) => Attribute;
+/**
+ * Create a new font stretch attribute.
+ * @param stretch - the stretch
+ */
 export declare const attrStretchNew: (stretch: Stretch) => 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 declare const attrStrikethroughColorNew: (red: number, green: number, blue: number) => Attribute;
+/**
+ * Create a new strike-through attribute.
+ * @param strikethrough - %TRUE if the text should be struck-through
+ */
 export declare const attrStrikethroughNew: (strikethrough: boolean) => Attribute;
+/**
+ * Create a new font slant style attribute.
+ * @param style - the slant style
+ */
 export declare const attrStyleNew: (style: Style) => Attribute;
+/**
+ * Create a new attribute that influences how characters
+ * are transformed during shaping.
+ * @param transform - `PangoTextTransform` to apply
+ */
 export declare const attrTextTransformNew: (transform: TextTransform) => 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 declare const attrTypeGetName: (type: AttrType) => string | null;
+/**
+ * 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 declare const attrTypeRegister: (name: string) => AttrType;
+/**
+ * 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 declare const attrUnderlineColorNew: (red: number, green: number, blue: number) => Attribute;
+/**
+ * Create a new underline-style attribute.
+ * @param underline - the underline style
+ */
 export declare const attrUnderlineNew: (underline: Underline) => Attribute;
+/**
+ * Create a new font variant attribute (normal or small caps).
+ * @param variant - the variant
+ */
 export declare const attrVariantNew: (variant: Variant) => Attribute;
+/**
+ * Create a new font weight attribute.
+ * @param weight - the weight
+ */
 export declare const attrWeightNew: (weight: Weight) => 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 declare const attrWordNew: () => 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 declare const bidiTypeForUnichar: (ch: number) => BidiType;
+/**
+ * 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 declare const _break: (text: string, length: number, analysis: number, attrs: Ref<number[]>, attrsLen: number) => void;
+/**
+ * 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 declare const defaultBreak: (text: string, length: number, attrs: Ref<number[]>, attrsLen: number, analysis?: number | null) => void;
+/**
+ * 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 declare const extentsToPixels: (inclusive: Ref<number>, nearest: Ref<number>) => void;
+/**
+ * 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 declare const findBaseDir: (text: string, length: number) => Direction;
+/**
+ * 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 declare const findParagraphBoundary: (text: string, length: number, paragraphDelimiterIndex?: Ref<number> | null, nextParagraphStart?: Ref<number> | null) => void;
+/**
+ * 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 declare const fontDescriptionFromString: (str: string) => 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 declare const getLogAttrs: (text: string, length: number, level: number, language: Language, attrs: Ref<number[]>, attrsLen: number) => void;
+/**
+ * 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 declare const getMirrorChar: (ch: number, mirroredCh?: Ref<number> | null) => boolean;
+/**
+ * Finds the gravity that best matches the rotation component
+ * in a `PangoMatrix`.
+ * @param matrix - a `PangoMatrix`
+ */
 export declare const gravityGetForMatrix: (matrix?: Matrix | null) => Gravity;
+/**
+ * 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 declare const gravityGetForScript: (script: Script, baseGravity: Gravity, hint: GravityHint) => Gravity;
+/**
+ * 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 declare const gravityGetForScriptAndWidth: (script: Script, wide: boolean, baseGravity: Gravity, hint: GravityHint) => Gravity;
+/**
+ * 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 declare const gravityToRotation: (gravity: Gravity) => number;
+/**
+ * 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 declare const isZeroWidth: (ch: number) => 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 declare const itemize: (context: Context, text: string, startIndex: number, length: number, attrs: AttrList, cachedIter?: AttrIterator | null) => Item[];
+/**
+ * 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 declare const itemizeWithBaseDir: (context: Context, baseDir: Direction, text: string, startIndex: number, length: number, attrs: AttrList, cachedIter?: AttrIterator | null) => Item[];
+/**
+ * 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 declare const languageFromString: (language?: string | null) => Language | null;
+/**
+ * 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 declare const languageGetDefault: () => 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 declare const languageGetPreferred: () => Language[] | null;
 export declare const layoutDeserializeErrorQuark: () => number;
+/**
+ * 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 declare const log2visGetEmbeddingLevels: (text: string, length: number, pbaseDir: Ref<Direction>) => number[];
+/**
+ * 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 declare const markupParserFinish: (context: GLib.MarkupParseContext, attrList?: Ref<AttrList> | null, text?: Ref<string> | null, accelChar?: Ref<number> | null) => boolean;
+/**
+ * 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 declare const markupParserNew: (accelMarker: number) => 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 declare const parseEnum: (type: number, warn: boolean, str?: string | null, value?: Ref<number> | null, possibleValues?: Ref<string> | null) => 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 declare const parseMarkup: (markupText: string, length: number, accelMarker: number, attrList?: Ref<AttrList> | null, text?: Ref<string> | null, accelChar?: Ref<number> | null) => boolean;
+/**
+ * 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 declare const parseStretch: (str: string, stretch: Ref<Stretch>, warn: boolean) => 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 declare const parseStyle: (str: string, style: Ref<Style>, warn: boolean) => 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 declare const parseVariant: (str: string, variant: Ref<Variant>, warn: boolean) => 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 declare const parseWeight: (str: string, weight: Ref<Weight>, warn: boolean) => 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 declare const quantizeLineGeometry: (thickness: Ref<number>, position: Ref<number>) => void;
+/**
+ * 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 declare const readLine: (str: GLib.String, stream?: number | null) => number;
+/**
+ * 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 declare const reorderItems: (items: Item[]) => Item[];
+/**
+ * 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 declare const scanInt: (pos: Ref<string>, out: Ref<number>) => 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 declare const scanString: (pos: Ref<string>, out: GLib.String) => 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 declare const scanWord: (pos: Ref<string>, out: GLib.String) => 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 declare const scriptForUnichar: (ch: number) => Script;
+/**
+ * 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 declare const scriptGetSampleLanguage: (script: Script) => Language | null;
+/**
+ * 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 declare const shape: (text: string, length: number, analysis: number, glyphs: Ref<GlyphString>) => void;
+/**
+ * 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 declare const shapeFull: (itemText: string, itemLength: number, paragraphLength: number, analysis: number, glyphs: Ref<GlyphString>, paragraphText?: string | null) => void;
+/**
+ * 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 declare const shapeItem: (item: Item, paragraphLength: number, glyphs: Ref<GlyphString>, flags: ShapeFlags, paragraphText?: string | null, logAttrs?: number | null) => void;
+/**
+ * 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 declare const shapeWithFlags: (itemText: string, itemLength: number, paragraphLength: number, analysis: number, glyphs: Ref<GlyphString>, flags: ShapeFlags, paragraphText?: string | null) => void;
+/**
+ * Skips 0 or more characters of white space.
+ * @param pos - in/out string position
+ */
 export declare const skipSpace: (pos: Ref<string>) => 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 declare const splitFileList: (str: string) => 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 declare const tabArrayFromString: (text: string) => TabArray | null;
+/**
+ * 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 declare const tailorBreak: (text: string, length: number, analysis: number, offset: number, attrs: Ref<number[]>, attrsLen: number) => void;
+/**
+ * Trims leading and trailing whitespace from a string.
+ * @param str - a string
+ */
 export declare const trimString: (str: string) => 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 declare const unicharDirection: (ch: number) => Direction;
+/**
+ * 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 declare const unitsFromDouble: (d: number) => number;
+/**
+ * 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 declare const unitsToDouble: (i: number) => number;
+/**
+ * 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 declare const version: () => number;
+/**
+ * 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 declare const versionCheck: (requiredMajor: number, requiredMinor: number, requiredMicro: number) => string | null;
+/**
+ * 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 declare const versionString: () => string;