@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -7,33 +7,169 @@ export interface MatrixInit {
     x0?: number;
     y0?: number;
 }
+/**
+ * A `PangoMatrix` specifies a transformation between user-space
+ * and device coordinates.
+ *
+ * The transformation is given by
+ *
+ * ```
+ * x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
+ * y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;
+ * ```
+ */
 export declare class Matrix {
     ptr: unknown;
     constructor(init?: MatrixInit);
     protected createPtr(init: MatrixInit): unknown;
+    /**
+     * Changes the transformation represented by `matrix` to be the
+     * transformation given by first applying transformation
+     * given by `new_matrix` then applying the original transformation.
+     * @param newMatrix - a `PangoMatrix`
+     */
     concat(newMatrix: Matrix): void;
+    /**
+     * Copies a `PangoMatrix`.
+     */
     copy(): Matrix | null;
+    /**
+     * Free a `PangoMatrix`.
+     */
     free(): void;
+    /**
+     * Returns the scale factor of a matrix on the height of the font.
+     *
+     * That is, the scale factor in the direction perpendicular to the
+     * vector that the X coordinate is mapped to.  If the scale in the X
+     * coordinate is needed as well, use [method@Pango.Matrix.get_font_scale_factors].
+     */
     getFontScaleFactor(): number;
+    /**
+     * Calculates the scale factor of a matrix on the width and height of the font.
+     *
+     * That is, `xscale` is the scale factor in the direction of the X coordinate,
+     * and `yscale` is the scale factor in the direction perpendicular to the
+     * vector that the X coordinate is mapped to.
+     *
+     * Note that output numbers will always be non-negative.
+     * @param xscale - output scale factor in the x direction
+     * @param yscale - output scale factor perpendicular to the x direction
+     */
     getFontScaleFactors(xscale?: Ref<number> | null, yscale?: Ref<number> | null): void;
+    /**
+     * Gets the slant ratio of a matrix.
+     *
+     * For a simple shear matrix in the form:
+     *
+     * 1 λ
+     * 0 1
+     *
+     * this is simply λ.
+     */
     getSlantRatio(): number;
+    /**
+     * Changes the transformation represented by `matrix` to be the
+     * transformation given by first rotating by `degrees` degrees
+     * counter-clockwise then applying the original transformation.
+     * @param degrees - degrees to rotate counter-clockwise
+     */
     rotate(degrees: number): void;
+    /**
+     * Changes the transformation represented by `matrix` to be the
+     * transformation given by first scaling by `sx` in the X direction
+     * and `sy` in the Y direction then applying the original
+     * transformation.
+     * @param scaleX - amount to scale by in X direction
+     * @param scaleY - amount to scale by in Y direction
+     */
     scale(scaleX: number, scaleY: number): void;
+    /**
+     * Transforms the distance vector (@dx,@dy) by @matrix.
+     *
+     * This is similar to [method@Pango.Matrix.transform_point],
+     * except that the translation components of the transformation
+     * are ignored. The calculation of the returned vector is as follows:
+     *
+     * ```
+     * dx2 = dx1 * xx + dy1 * xy;
+     * dy2 = dx1 * yx + dy1 * yy;
+     * ```
+     *
+     * Affine transformations are position invariant, so the same vector
+     * always transforms to the same vector. If (@x1,@y1) transforms
+     * to (@x2,@y2) then (@x1+@dx1,@y1+@dy1) will transform to
+     * (@x1+@dx2,@y1+@dy2) for all values of `x1` and @x2.
+     * @param dx - in/out X component of a distance vector
+     * @param dy - in/out Y component of a distance vector
+     */
     transformDistance(dx: Ref<number>, dy: Ref<number>): void;
+    /**
+     * First transforms the `rect` using @matrix, then calculates the bounding box
+     * of the transformed rectangle.
+     *
+     * This function is useful for example when you want to draw a rotated
+     * `PangoLayout` to an image buffer, and want to know how large the image
+     * should be and how much you should shift the layout when rendering.
+     *
+     * For better accuracy, you should use [method@Pango.Matrix.transform_rectangle]
+     * on original rectangle in Pango units and convert to pixels afterward
+     * using [func@extents_to_pixels]'s first argument.
+     * @param rect - in/out bounding box in device units
+     */
     transformPixelRectangle(rect: Ref<number>): void;
+    /**
+     * Transforms the point (@x, @y) by @matrix.
+     * @param x - in/out X position
+     * @param y - in/out Y position
+     */
     transformPoint(x: Ref<number>, y: Ref<number>): void;
+    /**
+     * First transforms `rect` using @matrix, then calculates the bounding box
+     * of the transformed rectangle.
+     *
+     * This function is useful for example when you want to draw a rotated
+     * `PangoLayout` to an image buffer, and want to know how large the image
+     * should be and how much you should shift the layout when rendering.
+     *
+     * If you have a rectangle in device units (pixels), use
+     * [method@Pango.Matrix.transform_pixel_rectangle].
+     *
+     * If you have the rectangle in Pango units and want to convert to
+     * transformed pixel bounding box, it is more accurate to transform it first
+     * (using this function) and pass the result to pango_extents_to_pixels(),
+     * first argument, for an inclusive rounded rectangle.
+     * However, there are valid reasons that you may want to convert
+     * to pixels first and then transform, for example when the transformed
+     * coordinates may overflow in Pango units (large matrix translation for
+     * example).
+     * @param rect - in/out bounding box in Pango units
+     */
     transformRectangle(rect: Ref<number>): void;
+    /**
+     * Changes the transformation represented by `matrix` to be the
+     * transformation given by first translating by (@tx, @ty)
+     * then applying the original transformation.
+     * @param tx - amount to translate in the X direction
+     * @param ty - amount to translate in the Y direction
+     */
     translate(tx: number, ty: number): void;
+    /** 1st component of the transformation matrix */
     get xx(): number;
     set xx(value: number);
+    /** 2nd component of the transformation matrix */
     get xy(): number;
     set xy(value: number);
+    /** 3rd component of the transformation matrix */
     get yx(): number;
     set yx(value: number);
+    /** 4th component of the transformation matrix */
     get yy(): number;
     set yy(value: number);
+    /** x translation */
     get x0(): number;
     set x0(value: number);
+    /** y translation */
     get y0(): number;
     set y0(value: number);
 }

package/dist/generated/pango/matrix.js

@@ -1,5 +1,16 @@
 import { alloc, call, read, write } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * A `PangoMatrix` specifies a transformation between user-space
+ * and device coordinates.
+ *
+ * The transformation is given by
+ *
+ * ```
+ * x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
+ * y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;
+ * ```
+ */
 export class Matrix {
     ptr;
     constructor(init = {}) {
@@ -21,6 +32,12 @@ export class Matrix {
             write(ptr, { type: "float", size: 64 }, 40, init.y0);
         return ptr;
     }
+    /**
+     * Changes the transformation represented by `matrix` to be the
+     * transformation given by first applying transformation
+     * given by `new_matrix` then applying the original transformation.
+     * @param newMatrix - a `PangoMatrix`
+     */
     concat(newMatrix) {
         call("libpango-1.0.so.0", "pango_matrix_concat", [
             {
@@ -38,6 +55,9 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Copies a `PangoMatrix`.
+     */
     copy() {
         const ptr = call("libpango-1.0.so.0", "pango_matrix_copy", [
             {
@@ -54,6 +74,9 @@ export class Matrix {
             return null;
         return getObject(ptr, Matrix);
     }
+    /**
+     * Free a `PangoMatrix`.
+     */
     free() {
         call("libpango-1.0.so.0", "pango_matrix_free", [
             {
@@ -62,6 +85,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the scale factor of a matrix on the height of the font.
+     *
+     * That is, the scale factor in the direction perpendicular to the
+     * vector that the X coordinate is mapped to.  If the scale in the X
+     * coordinate is needed as well, use [method@Pango.Matrix.get_font_scale_factors].
+     */
     getFontScaleFactor() {
         return call("libpango-1.0.so.0", "pango_matrix_get_font_scale_factor", [
             {
@@ -70,6 +100,17 @@ export class Matrix {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Calculates the scale factor of a matrix on the width and height of the font.
+     *
+     * That is, `xscale` is the scale factor in the direction of the X coordinate,
+     * and `yscale` is the scale factor in the direction perpendicular to the
+     * vector that the X coordinate is mapped to.
+     *
+     * Note that output numbers will always be non-negative.
+     * @param xscale - output scale factor in the x direction
+     * @param yscale - output scale factor perpendicular to the x direction
+     */
     getFontScaleFactors(xscale, yscale) {
         call("libpango-1.0.so.0", "pango_matrix_get_font_scale_factors", [
             {
@@ -88,6 +129,16 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the slant ratio of a matrix.
+     *
+     * For a simple shear matrix in the form:
+     *
+     * 1 λ
+     * 0 1
+     *
+     * this is simply λ.
+     */
     getSlantRatio() {
         return call("libpango-1.0.so.0", "pango_matrix_get_slant_ratio", [
             {
@@ -96,6 +147,12 @@ export class Matrix {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Changes the transformation represented by `matrix` to be the
+     * transformation given by first rotating by `degrees` degrees
+     * counter-clockwise then applying the original transformation.
+     * @param degrees - degrees to rotate counter-clockwise
+     */
     rotate(degrees) {
         call("libpango-1.0.so.0", "pango_matrix_rotate", [
             {
@@ -108,6 +165,14 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Changes the transformation represented by `matrix` to be the
+     * transformation given by first scaling by `sx` in the X direction
+     * and `sy` in the Y direction then applying the original
+     * transformation.
+     * @param scaleX - amount to scale by in X direction
+     * @param scaleY - amount to scale by in Y direction
+     */
     scale(scaleX, scaleY) {
         call("libpango-1.0.so.0", "pango_matrix_scale", [
             {
@@ -124,6 +189,25 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms the distance vector (@dx,@dy) by @matrix.
+     *
+     * This is similar to [method@Pango.Matrix.transform_point],
+     * except that the translation components of the transformation
+     * are ignored. The calculation of the returned vector is as follows:
+     *
+     * ```
+     * dx2 = dx1 * xx + dy1 * xy;
+     * dy2 = dx1 * yx + dy1 * yy;
+     * ```
+     *
+     * Affine transformations are position invariant, so the same vector
+     * always transforms to the same vector. If (@x1,@y1) transforms
+     * to (@x2,@y2) then (@x1+@dx1,@y1+@dy1) will transform to
+     * (@x1+@dx2,@y1+@dy2) for all values of `x1` and @x2.
+     * @param dx - in/out X component of a distance vector
+     * @param dy - in/out Y component of a distance vector
+     */
     transformDistance(dx, dy) {
         call("libpango-1.0.so.0", "pango_matrix_transform_distance", [
             {
@@ -140,6 +224,19 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * First transforms the `rect` using @matrix, then calculates the bounding box
+     * of the transformed rectangle.
+     *
+     * This function is useful for example when you want to draw a rotated
+     * `PangoLayout` to an image buffer, and want to know how large the image
+     * should be and how much you should shift the layout when rendering.
+     *
+     * For better accuracy, you should use [method@Pango.Matrix.transform_rectangle]
+     * on original rectangle in Pango units and convert to pixels afterward
+     * using [func@extents_to_pixels]'s first argument.
+     * @param rect - in/out bounding box in device units
+     */
     transformPixelRectangle(rect) {
         call("libpango-1.0.so.0", "pango_matrix_transform_pixel_rectangle", [
             {
@@ -155,6 +252,11 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms the point (@x, @y) by @matrix.
+     * @param x - in/out X position
+     * @param y - in/out Y position
+     */
     transformPoint(x, y) {
         call("libpango-1.0.so.0", "pango_matrix_transform_point", [
             {
@@ -171,6 +273,27 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * First transforms `rect` using @matrix, then calculates the bounding box
+     * of the transformed rectangle.
+     *
+     * This function is useful for example when you want to draw a rotated
+     * `PangoLayout` to an image buffer, and want to know how large the image
+     * should be and how much you should shift the layout when rendering.
+     *
+     * If you have a rectangle in device units (pixels), use
+     * [method@Pango.Matrix.transform_pixel_rectangle].
+     *
+     * If you have the rectangle in Pango units and want to convert to
+     * transformed pixel bounding box, it is more accurate to transform it first
+     * (using this function) and pass the result to pango_extents_to_pixels(),
+     * first argument, for an inclusive rounded rectangle.
+     * However, there are valid reasons that you may want to convert
+     * to pixels first and then transform, for example when the transformed
+     * coordinates may overflow in Pango units (large matrix translation for
+     * example).
+     * @param rect - in/out bounding box in Pango units
+     */
     transformRectangle(rect) {
         call("libpango-1.0.so.0", "pango_matrix_transform_rectangle", [
             {
@@ -186,6 +309,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Changes the transformation represented by `matrix` to be the
+     * transformation given by first translating by (@tx, @ty)
+     * then applying the original transformation.
+     * @param tx - amount to translate in the X direction
+     * @param ty - amount to translate in the Y direction
+     */
     translate(tx, ty) {
         call("libpango-1.0.so.0", "pango_matrix_translate", [
             {
@@ -202,36 +332,42 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /** 1st component of the transformation matrix */
     get xx() {
         return read(this.ptr, { type: "float", size: 64 }, 0);
     }
     set xx(value) {
         write(this.ptr, { type: "float", size: 64 }, 0, value);
     }
+    /** 2nd component of the transformation matrix */
     get xy() {
         return read(this.ptr, { type: "float", size: 64 }, 8);
     }
     set xy(value) {
         write(this.ptr, { type: "float", size: 64 }, 8, value);
     }
+    /** 3rd component of the transformation matrix */
     get yx() {
         return read(this.ptr, { type: "float", size: 64 }, 16);
     }
     set yx(value) {
         write(this.ptr, { type: "float", size: 64 }, 16, value);
     }
+    /** 4th component of the transformation matrix */
     get yy() {
         return read(this.ptr, { type: "float", size: 64 }, 24);
     }
     set yy(value) {
         write(this.ptr, { type: "float", size: 64 }, 24, value);
     }
+    /** x translation */
     get x0() {
         return read(this.ptr, { type: "float", size: 64 }, 32);
     }
     set x0(value) {
         write(this.ptr, { type: "float", size: 64 }, 32, value);
     }
+    /** y translation */
     get y0() {
         return read(this.ptr, { type: "float", size: 64 }, 40);
     }

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

@@ -7,27 +7,215 @@ import { Matrix } from "./matrix.js";
 import { Font } from "./font.js";
 import { Layout } from "./layout.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `PangoRenderer` is a base class for objects that can render text
+ * provided as `PangoGlyphString` or `PangoLayout`.
+ *
+ * By subclassing `PangoRenderer` and overriding operations such as
+ * `draw_glyphs` and @draw_rectangle, renderers for particular font
+ * backends and destinations can be created.
+ */
 export declare class Renderer extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Does initial setup before rendering operations on @renderer.
+     *
+     * [method@Pango.Renderer.deactivate] should be called when done drawing.
+     * Calls such as [method@Pango.Renderer.draw_layout] automatically
+     * activate the layout before drawing on it.
+     *
+     * Calls to [method@Pango.Renderer.activate] and
+     * [method@Pango.Renderer.deactivate] can be nested and the
+     * renderer will only be initialized and deinitialized once.
+     */
     activate(): void;
+    /**
+     * Cleans up after rendering operations on @renderer.
+     *
+     * See docs for [method@Pango.Renderer.activate].
+     */
     deactivate(): void;
+    /**
+     * Draw a squiggly line that approximately covers the given rectangle
+     * in the style of an underline used to indicate a spelling error.
+     *
+     * The width of the underline is rounded to an integer number
+     * of up/down segments and the resulting rectangle is centered
+     * in the original rectangle.
+     *
+     * This should be called while `renderer` is already active.
+     * Use [method@Pango.Renderer.activate] to activate a renderer.
+     * @param x - X coordinate of underline, in Pango units in user coordinate system
+     * @param y - Y coordinate of underline, in Pango units in user coordinate system
+     * @param width - width of underline, in Pango units in user coordinate system
+     * @param height - height of underline, in Pango units in user coordinate system
+     */
     drawErrorUnderline(x: number, y: number, width: number, height: number): void;
+    /**
+     * Draws a single glyph with coordinates in device space.
+     * @param font - a `PangoFont`
+     * @param glyph - the glyph index of a single glyph
+     * @param x - X coordinate of left edge of baseline of glyph
+     * @param y - Y coordinate of left edge of baseline of glyph
+     */
     drawGlyph(font: Font, glyph: number, x: number, y: number): void;
+    /**
+     * Draws the glyphs in `glyph_item` with the specified `PangoRenderer`,
+     * embedding the text associated with the glyphs in the output if the
+     * output format supports it.
+     *
+     * This is useful for rendering text in PDF.
+     *
+     * Note that this method does not handle attributes in @glyph_item.
+     * If you want colors, shapes and lines handled automatically according
+     * to those attributes, you need to use pango_renderer_draw_layout_line()
+     * or pango_renderer_draw_layout().
+     *
+     * Note that `text` is the start of the text for layout, which is then
+     * indexed by `glyph_item->item->offset`.
+     *
+     * If `text` is %NULL, this simply calls [method@Pango.Renderer.draw_glyphs].
+     *
+     * The default implementation of this method simply falls back to
+     * [method@Pango.Renderer.draw_glyphs].
+     * @param text - the UTF-8 text that `glyph_item` refers to
+     * @param glyphItem - a `PangoGlyphItem`
+     * @param x - X position of left edge of baseline, in user space coordinates
+     * @param y - Y position of left edge of baseline, in user space coordinates
+     */
     drawGlyphItem(glyphItem: GlyphItem, x: number, y: number, text?: string | null): void;
+    /**
+     * Draws the glyphs in `glyphs` with the specified `PangoRenderer`.
+     * @param font - a `PangoFont`
+     * @param glyphs - a `PangoGlyphString`
+     * @param x - X position of left edge of baseline, in user space coordinates
+     * @param y - Y position of left edge of baseline, in user space coordinates
+     */
     drawGlyphs(font: Font, glyphs: GlyphString, x: number, y: number): void;
+    /**
+     * Draws `layout` with the specified `PangoRenderer`.
+     *
+     * This is equivalent to drawing the lines of the layout, at their
+     * respective positions relative to @x, @y.
+     * @param layout - a `PangoLayout`
+     * @param x - X position of left edge of baseline, in user space coordinates
+     * @param y - Y position of left edge of baseline, in user space coordinates
+     */
     drawLayout(layout: Layout, x: number, y: number): void;
+    /**
+     * Draws `line` with the specified `PangoRenderer`.
+     *
+     * This draws the glyph items that make up the line, as well as
+     * shapes, backgrounds and lines that are specified by the attributes
+     * of those items.
+     * @param line - a `PangoLayoutLine`
+     * @param x - X position of left edge of baseline, in user space coordinates
+     * @param y - Y position of left edge of baseline, in user space coordinates
+     */
     drawLayoutLine(line: LayoutLine, x: number, y: number): void;
+    /**
+     * Draws an axis-aligned rectangle in user space coordinates with the
+     * specified `PangoRenderer`.
+     *
+     * This should be called while `renderer` is already active.
+     * Use [method@Pango.Renderer.activate] to activate a renderer.
+     * @param part - type of object this rectangle is part of
+     * @param x - X position at which to draw rectangle, in user space coordinates
+     * @param y - Y position at which to draw rectangle, in user space coordinates
+     * @param width - width of rectangle in Pango units
+     * @param height - height of rectangle in Pango units
+     */
     drawRectangle(part: RenderPart, x: number, y: number, width: number, height: number): void;
+    /**
+     * Draws a trapezoid with the parallel sides aligned with the X axis
+     * using the given `PangoRenderer`; coordinates are in device space.
+     * @param part - type of object this trapezoid is part of
+     * @param y1_ - Y coordinate of top of trapezoid
+     * @param x11 - X coordinate of left end of top of trapezoid
+     * @param x21 - X coordinate of right end of top of trapezoid
+     * @param y2 - Y coordinate of bottom of trapezoid
+     * @param x12 - X coordinate of left end of bottom of trapezoid
+     * @param x22 - X coordinate of right end of bottom of trapezoid
+     */
     drawTrapezoid(part: RenderPart, y1_: number, x11: number, x21: number, y2: number, x12: number, x22: number): void;
+    /**
+     * Gets the current alpha for the specified part.
+     * @param part - the part to get the alpha for
+     */
     getAlpha(part: RenderPart): number;
+    /**
+     * Gets the current rendering color for the specified part.
+     * @param part - the part to get the color for
+     */
     getColor(part: RenderPart): Color | null;
+    /**
+     * Gets the layout currently being rendered using @renderer.
+     *
+     * Calling this function only makes sense from inside a subclass's
+     * methods, like in its draw_shape vfunc, for example.
+     *
+     * The returned layout should not be modified while still being
+     * rendered.
+     */
     getLayout(): Layout | null;
+    /**
+     * Gets the layout line currently being rendered using @renderer.
+     *
+     * Calling this function only makes sense from inside a subclass's
+     * methods, like in its draw_shape vfunc, for example.
+     *
+     * The returned layout line should not be modified while still being
+     * rendered.
+     */
     getLayoutLine(): LayoutLine | null;
+    /**
+     * Gets the transformation matrix that will be applied when
+     * rendering.
+     *
+     * See [method@Pango.Renderer.set_matrix].
+     */
     getMatrix(): Matrix | null;
+    /**
+     * Informs Pango that the way that the rendering is done
+     * for `part` has changed.
+     *
+     * This should be called if the rendering changes in a way that would
+     * prevent multiple pieces being joined together into one drawing call.
+     * For instance, if a subclass of `PangoRenderer` was to add a stipple
+     * option for drawing underlines, it needs to call
+     *
+     * ```
+     * pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
+     * ```
+     *
+     * When the stipple changes or underlines with different stipples
+     * might be joined together. Pango automatically calls this for
+     * changes to colors. (See [method@Pango.Renderer.set_color])
+     * @param part - the part for which rendering has changed.
+     */
     partChanged(part: RenderPart): void;
+    /**
+     * Sets the alpha for part of the rendering.
+     *
+     * Note that the alpha may only be used if a color is
+     * specified for `part` as well.
+     * @param part - the part to set the alpha for
+     * @param alpha - an alpha value between 1 and 65536, or 0 to unset the alpha
+     */
     setAlpha(part: RenderPart, alpha: number): void;
+    /**
+     * Sets the color for part of the rendering.
+     *
+     * Also see [method@Pango.Renderer.set_alpha].
+     * @param part - the part to change the color of
+     * @param color - the new color or %NULL to unset the current color
+     */
     setColor(part: RenderPart, color?: Color | null): void;
+    /**
+     * Sets the transformation matrix that will be applied when rendering.
+     * @param matrix - a `PangoMatrix`, or %NULL to unset any existing matrix
+     */
     setMatrix(matrix?: Matrix | null): void;
     connect(signal: "notify", handler: (self: Renderer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;