@gtkx/codegen 0.21.0 → 1.0.0-rc.2

package/overrides/cairo/context.ts.ejs

@@ -0,0 +1,1269 @@
+import { alloc, type ExternalObject, getHandle, type Handle, read, t, wrapHandle, write } from "@gtkx/runtime";
+import type {
+    Antialias,
+    Content,
+    FillRule,
+    FontOptions,
+    FontSlant,
+    FontWeight,
+    LineCap,
+    LineJoin,
+    Operator,
+    Status,
+    TextClusterFlags,
+} from "../cairo.js";
+import { Context, FontFace, Pattern, ScaledFont, Surface } from "../cairo.js";
+import { FontOptions as FontOptionsConstructor } from "./font-options.js";
+import { allocMatrix, type Matrix as CairoMatrix } from "./matrix.js";
+
+const { bind } = t;
+const CONTEXT_T = t.boxed("CairoContext", {
+    ownership: "borrowed",
+    sharedLibrary: "libcairo-gobject.so.2",
+    getTypeFnName: "cairo_gobject_context_get_type",
+});
+
+export type CairoGlyph = { index: number; x: number; y: number };
+export type CairoTextCluster = { numBytes: number; numGlyphs: number };
+
+export const allocGlyphBuffer = (glyphs: CairoGlyph[]): ExternalObject<Handle> => {
+    const buf = alloc(glyphs.length * 24);
+    let offset = 0;
+    for (const glyph of glyphs) {
+        write(buf, t.uint64, offset, glyph.index);
+        write(buf, t.float64, offset + 8, glyph.x);
+        write(buf, t.float64, offset + 16, glyph.y);
+        offset += 24;
+    }
+    return buf;
+};
+
+export const allocClusterBuffer = (clusters: CairoTextCluster[]): ExternalObject<Handle> => {
+    const buf = alloc(clusters.length * 8);
+    let offset = 0;
+    for (const cluster of clusters) {
+        write(buf, t.int32, offset, cluster.numBytes);
+        write(buf, t.int32, offset + 4, cluster.numGlyphs);
+        offset += 8;
+    }
+    return buf;
+};
+
+export type TextExtents = {
+    xBearing: number;
+    yBearing: number;
+    width: number;
+    height: number;
+    xAdvance: number;
+    yAdvance: number;
+};
+
+export type FontExtents = {
+    ascent: number;
+    descent: number;
+    height: number;
+    maxXAdvance: number;
+    maxYAdvance: number;
+};
+
+export const readTextExtents = (handle: ExternalObject<Handle>): TextExtents => ({
+    xBearing: read(handle, t.float64, 0) as number,
+    yBearing: read(handle, t.float64, 8) as number,
+    width: read(handle, t.float64, 16) as number,
+    height: read(handle, t.float64, 24) as number,
+    xAdvance: read(handle, t.float64, 32) as number,
+    yAdvance: read(handle, t.float64, 40) as number,
+});
+
+export const readFontExtents = (handle: ExternalObject<Handle>): FontExtents => ({
+    ascent: read(handle, t.float64, 0) as number,
+    descent: read(handle, t.float64, 8) as number,
+    height: read(handle, t.float64, 16) as number,
+    maxXAdvance: read(handle, t.float64, 24) as number,
+    maxYAdvance: read(handle, t.float64, 32) as number,
+});
+
+export type PathData =
+    | { type: "moveTo"; x: number; y: number }
+    | { type: "lineTo"; x: number; y: number }
+    | { type: "curveTo"; x1: number; y1: number; x2: number; y2: number; x3: number; y3: number }
+    | { type: "closePath" };
+
+const PATH_MOVE_TO = 0;
+const PATH_LINE_TO = 1;
+const PATH_CURVE_TO = 2;
+const PATH_CLOSE_PATH = 3;
+
+export const parsePath = (pathHandle: ExternalObject<Handle>): PathData[] => {
+    const numData = read(pathHandle, t.int32, 16) as number;
+    if (numData === 0) return [];
+
+    const dataArray = read(pathHandle, t.struct("borrowed", { size: numData * 16 }), 8) as ExternalObject<Handle>;
+    const result: PathData[] = [];
+    let i = 0;
+    while (i < numData) {
+        const base = i * 16;
+        const headerType = read(dataArray, t.int32, base) as number;
+        const length = read(dataArray, t.int32, base + 4) as number;
+        switch (headerType) {
+            case PATH_MOVE_TO: {
+                const ptBase = (i + 1) * 16;
+                result.push({
+                    type: "moveTo",
+                    x: read(dataArray, t.float64, ptBase) as number,
+                    y: read(dataArray, t.float64, ptBase + 8) as number,
+                });
+                break;
+            }
+            case PATH_LINE_TO: {
+                const ptBase = (i + 1) * 16;
+                result.push({
+                    type: "lineTo",
+                    x: read(dataArray, t.float64, ptBase) as number,
+                    y: read(dataArray, t.float64, ptBase + 8) as number,
+                });
+                break;
+            }
+            case PATH_CURVE_TO: {
+                const pt1 = (i + 1) * 16;
+                const pt2 = (i + 2) * 16;
+                const pt3 = (i + 3) * 16;
+                result.push({
+                    type: "curveTo",
+                    x1: read(dataArray, t.float64, pt1) as number,
+                    y1: read(dataArray, t.float64, pt1 + 8) as number,
+                    x2: read(dataArray, t.float64, pt2) as number,
+                    y2: read(dataArray, t.float64, pt2 + 8) as number,
+                    x3: read(dataArray, t.float64, pt3) as number,
+                    y3: read(dataArray, t.float64, pt3 + 8) as number,
+                });
+                break;
+            }
+            case PATH_CLOSE_PATH: {
+                result.push({ type: "closePath" });
+                break;
+            }
+        }
+        i += length;
+    }
+    return result;
+};
+
+const cairoVersion = t.bind("libcairo.so.2", "cairo_version", [], t.int32);
+const cairoVersionString = t.bind("libcairo.so.2", "cairo_version_string", [], t.string("borrowed"));
+
+export const version = (): number => cairoVersion() as number;
+
+export const versionString = (): string => cairoVersionString() as string;
+
+declare module "../cairo.js" {
+    interface Context {
+        moveTo(x: number, y: number): void;
+        lineTo(x: number, y: number): void;
+        relMoveTo(dx: number, dy: number): void;
+        relLineTo(dx: number, dy: number): void;
+        relCurveTo(dx1: number, dy1: number, dx2: number, dy2: number, dx3: number, dy3: number): void;
+        curveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+        arc(xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+        arcNegative(xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+        rectangle(x: number, y: number, width: number, height: number): void;
+        closePath(): void;
+        newPath(): void;
+        newSubPath(): void;
+
+        stroke(): void;
+        strokePreserve(): void;
+        fill(): void;
+        fillPreserve(): void;
+        paint(): void;
+        paintWithAlpha(alpha: number): void;
+        clip(): void;
+        clipPreserve(): void;
+        resetClip(): void;
+
+        setSourceRgb(red: number, green: number, blue: number): void;
+        setSourceRgba(red: number, green: number, blue: number, alpha: number): void;
+        setSource(pattern: Pattern): void;
+
+        setLineWidth(width: number): void;
+        getLineWidth(): number;
+        setLineCap(lineCap: LineCap): void;
+        getLineCap(): LineCap;
+        setLineJoin(lineJoin: LineJoin): void;
+        getLineJoin(): LineJoin;
+        setDash(dashes: number[], offset: number): void;
+        getDashCount(): number;
+        getDash(): { dashes: number[]; offset: number };
+        setMiterLimit(limit: number): void;
+        getMiterLimit(): number;
+        setTolerance(tolerance: number): void;
+        getTolerance(): number;
+
+        setFillRule(fillRule: FillRule): void;
+        getFillRule(): FillRule;
+
+        save(): void;
+        restore(): void;
+        translate(tx: number, ty: number): void;
+        scale(sx: number, sy: number): void;
+        rotate(angle: number): void;
+
+        setOperator(op: Operator): void;
+        getOperator(): Operator;
+
+        selectFontFace(family: string, slant: FontSlant, weight: FontWeight): void;
+        setFontSize(size: number): void;
+        showText(text: string): void;
+        textPath(text: string): void;
+        textExtents(text: string): TextExtents;
+        fontExtents(): FontExtents;
+
+        setFontOptions(options: FontOptions): void;
+        getFontOptions(): FontOptions;
+        setAntialias(antialias: Antialias): void;
+        getAntialias(): Antialias;
+
+        showPage(): void;
+        copyPage(): void;
+        getTarget(): Surface;
+        setSourceSurface(surface: Surface, x: number, y: number): void;
+        hasCurrentPoint(): boolean;
+        getCurrentPoint(): { x: number; y: number } | null;
+        getSource(): Pattern;
+
+        strokeExtents(): { x1: number; y1: number; x2: number; y2: number };
+        fillExtents(): { x1: number; y1: number; x2: number; y2: number };
+        clipExtents(): { x1: number; y1: number; x2: number; y2: number };
+        pathExtents(): { x1: number; y1: number; x2: number; y2: number };
+        inStroke(x: number, y: number): boolean;
+        inFill(x: number, y: number): boolean;
+        inClip(x: number, y: number): boolean;
+        copyClipRectangleList(): Array<{ x: number; y: number; width: number; height: number }>;
+
+        mask(pattern: Pattern): void;
+        maskSurface(surface: Surface, x: number, y: number): void;
+
+        setMatrix(matrix: CairoMatrix): void;
+        getMatrix(): CairoMatrix;
+        transform(matrix: CairoMatrix): void;
+        identityMatrix(): void;
+        userToDevice(x: number, y: number): { x: number; y: number };
+        userToDeviceDistance(dx: number, dy: number): { dx: number; dy: number };
+        deviceToUser(x: number, y: number): { x: number; y: number };
+        deviceToUserDistance(dx: number, dy: number): { dx: number; dy: number };
+
+        status(): Status;
+        getReferenceCount(): number;
+    }
+}
+
+const cairoMoveTo = bind("libcairo.so.2", "cairo_move_to", [CONTEXT_T, t.float64, t.float64], t.void);
+Context.prototype.moveTo = function (x: number, y: number): void {
+    cairoMoveTo(getHandle(this), x, y);
+};
+
+const cairoLineTo = bind("libcairo.so.2", "cairo_line_to", [CONTEXT_T, t.float64, t.float64], t.void);
+Context.prototype.lineTo = function (x: number, y: number): void {
+    cairoLineTo(getHandle(this), x, y);
+};
+
+const cairoRelMoveTo = bind("libcairo.so.2", "cairo_rel_move_to", [CONTEXT_T, t.float64, t.float64], t.void);
+Context.prototype.relMoveTo = function (dx: number, dy: number): void {
+    cairoRelMoveTo(getHandle(this), dx, dy);
+};
+
+const cairoRelLineTo = bind("libcairo.so.2", "cairo_rel_line_to", [CONTEXT_T, t.float64, t.float64], t.void);
+Context.prototype.relLineTo = function (dx: number, dy: number): void {
+    cairoRelLineTo(getHandle(this), dx, dy);
+};
+
+const cairoRelCurveTo = bind(
+    "libcairo.so.2",
+    "cairo_rel_curve_to",
+    [CONTEXT_T, t.float64, t.float64, t.float64, t.float64, t.float64, t.float64],
+    t.void,
+);
+Context.prototype.relCurveTo = function (
+    dx1: number,
+    dy1: number,
+    dx2: number,
+    dy2: number,
+    dx3: number,
+    dy3: number,
+): void {
+    cairoRelCurveTo(getHandle(this), dx1, dy1, dx2, dy2, dx3, dy3);
+};
+
+const cairoCurveTo = bind(
+    "libcairo.so.2",
+    "cairo_curve_to",
+    [CONTEXT_T, t.float64, t.float64, t.float64, t.float64, t.float64, t.float64],
+    t.void,
+);
+Context.prototype.curveTo = function (x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void {
+    cairoCurveTo(getHandle(this), x1, y1, x2, y2, x3, y3);
+};
+
+const cairoArc = bind(
+    "libcairo.so.2",
+    "cairo_arc",
+    [CONTEXT_T, t.float64, t.float64, t.float64, t.float64, t.float64],
+    t.void,
+);
+Context.prototype.arc = function (xc: number, yc: number, radius: number, angle1: number, angle2: number): void {
+    cairoArc(getHandle(this), xc, yc, radius, angle1, angle2);
+};
+
+const cairoArcNegative = bind(
+    "libcairo.so.2",
+    "cairo_arc_negative",
+    [CONTEXT_T, t.float64, t.float64, t.float64, t.float64, t.float64],
+    t.void,
+);
+Context.prototype.arcNegative = function (
+    xc: number,
+    yc: number,
+    radius: number,
+    angle1: number,
+    angle2: number,
+): void {
+    cairoArcNegative(getHandle(this), xc, yc, radius, angle1, angle2);
+};
+
+const cairoRectangle = bind(
+    "libcairo.so.2",
+    "cairo_rectangle",
+    [CONTEXT_T, t.float64, t.float64, t.float64, t.float64],
+    t.void,
+);
+Context.prototype.rectangle = function (x: number, y: number, width: number, height: number): void {
+    cairoRectangle(getHandle(this), x, y, width, height);
+};
+
+const cairoClosePath = bind("libcairo.so.2", "cairo_close_path", [CONTEXT_T], t.void);
+Context.prototype.closePath = function (): void {
+    cairoClosePath(getHandle(this));
+};
+
+const cairoNewPath = bind("libcairo.so.2", "cairo_new_path", [CONTEXT_T], t.void);
+Context.prototype.newPath = function (): void {
+    cairoNewPath(getHandle(this));
+};
+
+const cairoNewSubPath = bind("libcairo.so.2", "cairo_new_sub_path", [CONTEXT_T], t.void);
+Context.prototype.newSubPath = function (): void {
+    cairoNewSubPath(getHandle(this));
+};
+
+const cairoStroke = bind("libcairo.so.2", "cairo_stroke", [CONTEXT_T], t.void);
+Context.prototype.stroke = function (): void {
+    cairoStroke(getHandle(this));
+};
+
+const cairoStrokePreserve = bind("libcairo.so.2", "cairo_stroke_preserve", [CONTEXT_T], t.void);
+Context.prototype.strokePreserve = function (): void {
+    cairoStrokePreserve(getHandle(this));
+};
+
+const cairoFill = bind("libcairo.so.2", "cairo_fill", [CONTEXT_T], t.void);
+Context.prototype.fill = function (): void {
+    cairoFill(getHandle(this));
+};
+
+const cairoFillPreserve = bind("libcairo.so.2", "cairo_fill_preserve", [CONTEXT_T], t.void);
+Context.prototype.fillPreserve = function (): void {
+    cairoFillPreserve(getHandle(this));
+};
+
+const cairoPaint = bind("libcairo.so.2", "cairo_paint", [CONTEXT_T], t.void);
+Context.prototype.paint = function (): void {
+    cairoPaint(getHandle(this));
+};
+
+const cairoPaintWithAlpha = bind("libcairo.so.2", "cairo_paint_with_alpha", [CONTEXT_T, t.float64], t.void);
+Context.prototype.paintWithAlpha = function (alpha: number): void {
+    cairoPaintWithAlpha(getHandle(this), alpha);
+};
+
+const cairoClip = bind("libcairo.so.2", "cairo_clip", [CONTEXT_T], t.void);
+Context.prototype.clip = function (): void {
+    cairoClip(getHandle(this));
+};
+
+const cairoClipPreserve = bind("libcairo.so.2", "cairo_clip_preserve", [CONTEXT_T], t.void);
+Context.prototype.clipPreserve = function (): void {
+    cairoClipPreserve(getHandle(this));
+};
+
+const cairoResetClip = bind("libcairo.so.2", "cairo_reset_clip", [CONTEXT_T], t.void);
+Context.prototype.resetClip = function (): void {
+    cairoResetClip(getHandle(this));
+};
+
+const cairoSetSourceRgb = bind(
+    "libcairo.so.2",
+    "cairo_set_source_rgb",
+    [CONTEXT_T, t.float64, t.float64, t.float64],
+    t.void,
+);
+Context.prototype.setSourceRgb = function (red: number, green: number, blue: number): void {
+    cairoSetSourceRgb(getHandle(this), red, green, blue);
+};
+
+const cairoSetSourceRgba = bind(
+    "libcairo.so.2",
+    "cairo_set_source_rgba",
+    [CONTEXT_T, t.float64, t.float64, t.float64, t.float64],
+    t.void,
+);
+Context.prototype.setSourceRgba = function (red: number, green: number, blue: number, alpha: number): void {
+    cairoSetSourceRgba(getHandle(this), red, green, blue, alpha);
+};
+
+const cairoSetSource = bind(
+    "libcairo.so.2",
+    "cairo_set_source",
+    [
+        CONTEXT_T,
+        t.boxed("CairoPattern", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_pattern_get_type",
+        }),
+    ],
+    t.void,
+);
+Context.prototype.setSource = function (pattern: Pattern): void {
+    cairoSetSource(getHandle(this), getHandle(pattern));
+};
+
+const cairoSetLineWidth = bind("libcairo.so.2", "cairo_set_line_width", [CONTEXT_T, t.float64], t.void);
+Context.prototype.setLineWidth = function (width: number): void {
+    cairoSetLineWidth(getHandle(this), width);
+};
+
+const cairoGetLineWidth = bind("libcairo.so.2", "cairo_get_line_width", [CONTEXT_T], t.float64);
+Context.prototype.getLineWidth = function (): number {
+    return cairoGetLineWidth(getHandle(this)) as number;
+};
+
+const cairoSetLineCap = bind("libcairo.so.2", "cairo_set_line_cap", [CONTEXT_T, t.int32], t.void);
+Context.prototype.setLineCap = function (lineCap: LineCap): void {
+    cairoSetLineCap(getHandle(this), lineCap);
+};
+
+const cairoGetLineCap = bind("libcairo.so.2", "cairo_get_line_cap", [CONTEXT_T], t.int32);
+Context.prototype.getLineCap = function (): LineCap {
+    return cairoGetLineCap(getHandle(this)) as LineCap;
+};
+
+const cairoSetLineJoin = bind("libcairo.so.2", "cairo_set_line_join", [CONTEXT_T, t.int32], t.void);
+Context.prototype.setLineJoin = function (lineJoin: LineJoin): void {
+    cairoSetLineJoin(getHandle(this), lineJoin);
+};
+
+const cairoGetLineJoin = bind("libcairo.so.2", "cairo_get_line_join", [CONTEXT_T], t.int32);
+Context.prototype.getLineJoin = function (): LineJoin {
+    return cairoGetLineJoin(getHandle(this)) as LineJoin;
+};
+
+const DOUBLE_BUFFER_T = t.boxed("double[]", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" });
+
+const cairoSetDash = bind("libcairo.so.2", "cairo_set_dash", [CONTEXT_T, DOUBLE_BUFFER_T, t.int32, t.float64], t.void);
+Context.prototype.setDash = function (dashes: number[], offset: number): void {
+    const dashBuf = alloc(dashes.length * 8);
+    for (let i = 0; i < dashes.length; i++) {
+        write(dashBuf, t.float64, i * 8, dashes[i]);
+    }
+    cairoSetDash(getHandle(this), dashBuf, dashes.length, offset);
+};
+
+const cairoGetDashCount = bind("libcairo.so.2", "cairo_get_dash_count", [CONTEXT_T], t.int32);
+Context.prototype.getDashCount = function (): number {
+    return cairoGetDashCount(getHandle(this)) as number;
+};
+
+const cairoGetDash = bind("libcairo.so.2", "cairo_get_dash", [CONTEXT_T, DOUBLE_BUFFER_T, t.ref(t.float64)], t.void);
+Context.prototype.getDash = function (): { dashes: number[]; offset: number } {
+    const count = this.getDashCount();
+    if (count === 0) {
+        return { dashes: [], offset: 0 };
+    }
+    const dashBuf = alloc(count * 8);
+    const offsetRef = { value: 0 };
+    cairoGetDash(getHandle(this), dashBuf, offsetRef);
+    const dashes: number[] = [];
+    for (let i = 0; i < count; i++) {
+        dashes.push(read(dashBuf, t.float64, i * 8) as number);
+    }
+    return { dashes, offset: offsetRef.value };
+};
+
+const cairoSetMiterLimit = bind("libcairo.so.2", "cairo_set_miter_limit", [CONTEXT_T, t.float64], t.void);
+Context.prototype.setMiterLimit = function (limit: number): void {
+    cairoSetMiterLimit(getHandle(this), limit);
+};
+
+const cairoGetMiterLimit = bind("libcairo.so.2", "cairo_get_miter_limit", [CONTEXT_T], t.float64);
+Context.prototype.getMiterLimit = function (): number {
+    return cairoGetMiterLimit(getHandle(this)) as number;
+};
+
+const cairoSetTolerance = bind("libcairo.so.2", "cairo_set_tolerance", [CONTEXT_T, t.float64], t.void);
+Context.prototype.setTolerance = function (tolerance: number): void {
+    cairoSetTolerance(getHandle(this), tolerance);
+};
+
+const cairoGetTolerance = bind("libcairo.so.2", "cairo_get_tolerance", [CONTEXT_T], t.float64);
+Context.prototype.getTolerance = function (): number {
+    return cairoGetTolerance(getHandle(this)) as number;
+};
+
+const cairoSetFillRule = bind("libcairo.so.2", "cairo_set_fill_rule", [CONTEXT_T, t.int32], t.void);
+Context.prototype.setFillRule = function (fillRule: FillRule): void {
+    cairoSetFillRule(getHandle(this), fillRule);
+};
+
+const cairoGetFillRule = bind("libcairo.so.2", "cairo_get_fill_rule", [CONTEXT_T], t.int32);
+Context.prototype.getFillRule = function (): FillRule {
+    return cairoGetFillRule(getHandle(this)) as FillRule;
+};
+
+const cairoSave = bind("libcairo.so.2", "cairo_save", [CONTEXT_T], t.void);
+Context.prototype.save = function (): void {
+    cairoSave(getHandle(this));
+};
+
+const cairoRestore = bind("libcairo.so.2", "cairo_restore", [CONTEXT_T], t.void);
+Context.prototype.restore = function (): void {
+    cairoRestore(getHandle(this));
+};
+
+const cairoTranslate = bind("libcairo.so.2", "cairo_translate", [CONTEXT_T, t.float64, t.float64], t.void);
+Context.prototype.translate = function (tx: number, ty: number): void {
+    cairoTranslate(getHandle(this), tx, ty);
+};
+
+const cairoScale = bind("libcairo.so.2", "cairo_scale", [CONTEXT_T, t.float64, t.float64], t.void);
+Context.prototype.scale = function (sx: number, sy: number): void {
+    cairoScale(getHandle(this), sx, sy);
+};
+
+const cairoRotate = bind("libcairo.so.2", "cairo_rotate", [CONTEXT_T, t.float64], t.void);
+Context.prototype.rotate = function (angle: number): void {
+    cairoRotate(getHandle(this), angle);
+};
+
+const cairoSetOperator = bind("libcairo.so.2", "cairo_set_operator", [CONTEXT_T, t.int32], t.void);
+Context.prototype.setOperator = function (op: Operator): void {
+    cairoSetOperator(getHandle(this), op);
+};
+
+const cairoGetOperator = bind("libcairo.so.2", "cairo_get_operator", [CONTEXT_T], t.int32);
+Context.prototype.getOperator = function (): Operator {
+    return cairoGetOperator(getHandle(this)) as Operator;
+};
+
+const cairoSelectFontFace = bind(
+    "libcairo.so.2",
+    "cairo_select_font_face",
+    [CONTEXT_T, t.string("full"), t.int32, t.int32],
+    t.void,
+);
+Context.prototype.selectFontFace = function (family: string, slant: FontSlant, weight: FontWeight): void {
+    cairoSelectFontFace(getHandle(this), family, slant, weight);
+};
+
+const cairoSetFontSize = bind("libcairo.so.2", "cairo_set_font_size", [CONTEXT_T, t.float64], t.void);
+Context.prototype.setFontSize = function (size: number): void {
+    cairoSetFontSize(getHandle(this), size);
+};
+
+const cairoShowText = bind("libcairo.so.2", "cairo_show_text", [CONTEXT_T, t.string("full")], t.void);
+Context.prototype.showText = function (text: string): void {
+    cairoShowText(getHandle(this), text);
+};
+
+const cairoTextPath = bind("libcairo.so.2", "cairo_text_path", [CONTEXT_T, t.string("full")], t.void);
+Context.prototype.textPath = function (text: string): void {
+    cairoTextPath(getHandle(this), text);
+};
+
+const cairoTextExtents = bind(
+    "libcairo.so.2",
+    "cairo_text_extents",
+    [
+        CONTEXT_T,
+        t.string("full"),
+        t.boxed("cairo_text_extents_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+    ],
+    t.void,
+);
+Context.prototype.textExtents = function (text: string): TextExtents {
+    const extents = alloc(48);
+    cairoTextExtents(getHandle(this), text, extents);
+    return readTextExtents(extents);
+};
+
+const cairoFontExtents = bind(
+    "libcairo.so.2",
+    "cairo_font_extents",
+    [CONTEXT_T, t.boxed("cairo_font_extents_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+Context.prototype.fontExtents = function (): FontExtents {
+    const extents = alloc(40);
+    cairoFontExtents(getHandle(this), extents);
+    return readFontExtents(extents);
+};
+
+const cairoSetFontOptions = bind(
+    "libcairo.so.2",
+    "cairo_set_font_options",
+    [
+        CONTEXT_T,
+        t.boxed("CairoFontOptions", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_font_options_get_type",
+        }),
+    ],
+    t.void,
+);
+Context.prototype.setFontOptions = function (options: FontOptions): void {
+    cairoSetFontOptions(getHandle(this), getHandle(options));
+};
+
+const cairoGetFontOptions = bind(
+    "libcairo.so.2",
+    "cairo_get_font_options",
+    [
+        CONTEXT_T,
+        t.boxed("CairoFontOptions", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_font_options_get_type",
+        }),
+    ],
+    t.void,
+);
+Context.prototype.getFontOptions = function (): FontOptions {
+    const options = FontOptionsConstructor.create();
+    cairoGetFontOptions(getHandle(this), getHandle(options));
+    return options;
+};
+
+const cairoSetAntialias = bind("libcairo.so.2", "cairo_set_antialias", [CONTEXT_T, t.int32], t.void);
+Context.prototype.setAntialias = function (antialias: Antialias): void {
+    cairoSetAntialias(getHandle(this), antialias);
+};
+
+const cairoGetAntialias = bind("libcairo.so.2", "cairo_get_antialias", [CONTEXT_T], t.int32);
+Context.prototype.getAntialias = function (): Antialias {
+    return cairoGetAntialias(getHandle(this)) as Antialias;
+};
+
+const cairoShowPage = bind("libcairo.so.2", "cairo_show_page", [CONTEXT_T], t.void);
+Context.prototype.showPage = function (): void {
+    cairoShowPage(getHandle(this));
+};
+
+const cairoCopyPage = bind("libcairo.so.2", "cairo_copy_page", [CONTEXT_T], t.void);
+Context.prototype.copyPage = function (): void {
+    cairoCopyPage(getHandle(this));
+};
+
+const cairoGetTarget = bind(
+    "libcairo.so.2",
+    "cairo_get_target",
+    [CONTEXT_T],
+    t.boxed("CairoSurface", {
+        ownership: "borrowed",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_surface_get_type",
+    }),
+);
+Context.prototype.getTarget = function (): Surface {
+    return wrapHandle(cairoGetTarget(getHandle(this)) as ExternalObject<Handle>, Surface) as Surface;
+};
+
+const cairoSetSourceSurface = bind(
+    "libcairo.so.2",
+    "cairo_set_source_surface",
+    [
+        CONTEXT_T,
+        t.boxed("CairoSurface", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_surface_get_type",
+        }),
+        t.float64,
+        t.float64,
+    ],
+    t.void,
+);
+Context.prototype.setSourceSurface = function (surface: Surface, x: number, y: number): void {
+    cairoSetSourceSurface(getHandle(this), getHandle(surface), x, y);
+};
+
+const cairoHasCurrentPoint = bind("libcairo.so.2", "cairo_has_current_point", [CONTEXT_T], t.boolean);
+Context.prototype.hasCurrentPoint = function (): boolean {
+    return cairoHasCurrentPoint(getHandle(this)) as boolean;
+};
+
+const cairoGetCurrentPoint = bind(
+    "libcairo.so.2",
+    "cairo_get_current_point",
+    [CONTEXT_T, t.ref(t.float64), t.ref(t.float64)],
+    t.void,
+);
+Context.prototype.getCurrentPoint = function (): { x: number; y: number } | null {
+    if (!this.hasCurrentPoint()) {
+        return null;
+    }
+    const xRef = { value: 0 };
+    const yRef = { value: 0 };
+    cairoGetCurrentPoint(getHandle(this), xRef, yRef);
+    return { x: xRef.value, y: yRef.value };
+};
+
+const cairoGetSource = bind(
+    "libcairo.so.2",
+    "cairo_get_source",
+    [CONTEXT_T],
+    t.boxed("CairoPattern", {
+        ownership: "borrowed",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_pattern_get_type",
+    }),
+);
+Context.prototype.getSource = function (): Pattern {
+    return wrapHandle(cairoGetSource(getHandle(this)) as ExternalObject<Handle>, Pattern) as Pattern;
+};
+
+const EXTENTS_ARGS = [CONTEXT_T, t.ref(t.float64), t.ref(t.float64), t.ref(t.float64), t.ref(t.float64)];
+const cairoStrokeExtents = bind("libcairo.so.2", "cairo_stroke_extents", EXTENTS_ARGS, t.void);
+const cairoFillExtents = bind("libcairo.so.2", "cairo_fill_extents", EXTENTS_ARGS, t.void);
+const cairoClipExtents = bind("libcairo.so.2", "cairo_clip_extents", EXTENTS_ARGS, t.void);
+const cairoPathExtents = bind("libcairo.so.2", "cairo_path_extents", EXTENTS_ARGS, t.void);
+
+const getExtents = (
+    ctx: Context,
+    boundFn: (...args: unknown[]) => unknown,
+): { x1: number; y1: number; x2: number; y2: number } => {
+    const x1Ref = { value: 0 };
+    const y1Ref = { value: 0 };
+    const x2Ref = { value: 0 };
+    const y2Ref = { value: 0 };
+    boundFn(getHandle(ctx), x1Ref, y1Ref, x2Ref, y2Ref);
+    return { x1: x1Ref.value, y1: y1Ref.value, x2: x2Ref.value, y2: y2Ref.value };
+};
+
+Context.prototype.strokeExtents = function (): { x1: number; y1: number; x2: number; y2: number } {
+    return getExtents(this, cairoStrokeExtents);
+};
+
+Context.prototype.fillExtents = function (): { x1: number; y1: number; x2: number; y2: number } {
+    return getExtents(this, cairoFillExtents);
+};
+
+Context.prototype.clipExtents = function (): { x1: number; y1: number; x2: number; y2: number } {
+    return getExtents(this, cairoClipExtents);
+};
+
+Context.prototype.pathExtents = function (): { x1: number; y1: number; x2: number; y2: number } {
+    return getExtents(this, cairoPathExtents);
+};
+
+const cairoInStroke = bind("libcairo.so.2", "cairo_in_stroke", [CONTEXT_T, t.float64, t.float64], t.boolean);
+Context.prototype.inStroke = function (x: number, y: number): boolean {
+    return cairoInStroke(getHandle(this), x, y) as boolean;
+};
+
+const cairoInFill = bind("libcairo.so.2", "cairo_in_fill", [CONTEXT_T, t.float64, t.float64], t.boolean);
+Context.prototype.inFill = function (x: number, y: number): boolean {
+    return cairoInFill(getHandle(this), x, y) as boolean;
+};
+
+const cairoInClip = bind("libcairo.so.2", "cairo_in_clip", [CONTEXT_T, t.float64, t.float64], t.boolean);
+Context.prototype.inClip = function (x: number, y: number): boolean {
+    return cairoInClip(getHandle(this), x, y) as boolean;
+};
+
+const cairoCopyClipRectangleList = bind(
+    "libcairo.so.2",
+    "cairo_copy_clip_rectangle_list",
+    [CONTEXT_T],
+    t.boxed("cairo_rectangle_list_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+);
+const cairoRectangleListDestroy = bind(
+    "libcairo.so.2",
+    "cairo_rectangle_list_destroy",
+    [t.boxed("cairo_rectangle_list_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+
+Context.prototype.copyClipRectangleList = function (): Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}> {
+    const listHandle = cairoCopyClipRectangleList(getHandle(this)) as ExternalObject<Handle>;
+
+    const numRectangles = read(listHandle, t.int32, 16) as number;
+    if (numRectangles === 0) {
+        cairoRectangleListDestroy(listHandle);
+        return [];
+    }
+    const rectsArray = read(listHandle, t.struct("full", { size: numRectangles * 32 }), 8) as ExternalObject<Handle>;
+    const result: Array<{ x: number; y: number; width: number; height: number }> = [];
+
+    for (let i = 0; i < numRectangles; i++) {
+        const base = i * 32;
+        result.push({
+            x: read(rectsArray, t.float64, base) as number,
+            y: read(rectsArray, t.float64, base + 8) as number,
+            width: read(rectsArray, t.float64, base + 16) as number,
+            height: read(rectsArray, t.float64, base + 24) as number,
+        });
+    }
+
+    cairoRectangleListDestroy(listHandle);
+
+    return result;
+};
+
+const cairoMask = bind(
+    "libcairo.so.2",
+    "cairo_mask",
+    [
+        CONTEXT_T,
+        t.boxed("CairoPattern", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_pattern_get_type",
+        }),
+    ],
+    t.void,
+);
+Context.prototype.mask = function (pattern: Pattern): void {
+    cairoMask(getHandle(this), getHandle(pattern));
+};
+
+const cairoMaskSurface = bind(
+    "libcairo.so.2",
+    "cairo_mask_surface",
+    [
+        CONTEXT_T,
+        t.boxed("CairoSurface", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_surface_get_type",
+        }),
+        t.float64,
+        t.float64,
+    ],
+    t.void,
+);
+Context.prototype.maskSurface = function (surface: Surface, x: number, y: number): void {
+    cairoMaskSurface(getHandle(this), getHandle(surface), x, y);
+};
+
+const cairoSetMatrix = bind(
+    "libcairo.so.2",
+    "cairo_set_matrix",
+    [CONTEXT_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+Context.prototype.setMatrix = function (matrix: CairoMatrix): void {
+    cairoSetMatrix(getHandle(this), getHandle(matrix));
+};
+
+const cairoGetMatrix = bind(
+    "libcairo.so.2",
+    "cairo_get_matrix",
+    [CONTEXT_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+Context.prototype.getMatrix = function (): CairoMatrix {
+    const { handle, obj } = allocMatrix();
+    cairoGetMatrix(getHandle(this), handle);
+    return obj;
+};
+
+const cairoTransform = bind(
+    "libcairo.so.2",
+    "cairo_transform",
+    [CONTEXT_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+Context.prototype.transform = function (matrix: CairoMatrix): void {
+    cairoTransform(getHandle(this), getHandle(matrix));
+};
+
+const cairoIdentityMatrix = bind("libcairo.so.2", "cairo_identity_matrix", [CONTEXT_T], t.void);
+Context.prototype.identityMatrix = function (): void {
+    cairoIdentityMatrix(getHandle(this));
+};
+
+const COORD_ARGS = [CONTEXT_T, t.ref(t.float64), t.ref(t.float64)];
+const cairoUserToDevice = bind("libcairo.so.2", "cairo_user_to_device", COORD_ARGS, t.void);
+const cairoUserToDeviceDistance = bind("libcairo.so.2", "cairo_user_to_device_distance", COORD_ARGS, t.void);
+const cairoDeviceToUser = bind("libcairo.so.2", "cairo_device_to_user", COORD_ARGS, t.void);
+const cairoDeviceToUserDistance = bind("libcairo.so.2", "cairo_device_to_user_distance", COORD_ARGS, t.void);
+
+const coordTransform = (
+    ctx: Context,
+    boundFn: (...args: unknown[]) => unknown,
+    a: number,
+    b: number,
+): [number, number] => {
+    const aRef = { value: a };
+    const bRef = { value: b };
+    boundFn(getHandle(ctx), aRef, bRef);
+    return [aRef.value, bRef.value];
+};
+
+Context.prototype.userToDevice = function (x: number, y: number): { x: number; y: number } {
+    const [px, py] = coordTransform(this, cairoUserToDevice, x, y);
+    return { x: px, y: py };
+};
+
+Context.prototype.userToDeviceDistance = function (dx: number, dy: number): { dx: number; dy: number } {
+    const [ddx, ddy] = coordTransform(this, cairoUserToDeviceDistance, dx, dy);
+    return { dx: ddx, dy: ddy };
+};
+
+Context.prototype.deviceToUser = function (x: number, y: number): { x: number; y: number } {
+    const [px, py] = coordTransform(this, cairoDeviceToUser, x, y);
+    return { x: px, y: py };
+};
+
+Context.prototype.deviceToUserDistance = function (dx: number, dy: number): { dx: number; dy: number } {
+    const [ddx, ddy] = coordTransform(this, cairoDeviceToUserDistance, dx, dy);
+    return { dx: ddx, dy: ddy };
+};
+
+const cairoStatus = bind("libcairo.so.2", "cairo_status", [CONTEXT_T], t.int32);
+Context.prototype.status = function (): Status {
+    return cairoStatus(getHandle(this)) as Status;
+};
+
+const cairoGetReferenceCount = bind("libcairo.so.2", "cairo_get_reference_count", [CONTEXT_T], t.int32);
+Context.prototype.getReferenceCount = function (): number {
+    return cairoGetReferenceCount(getHandle(this)) as number;
+};
+
+declare module "../cairo.js" {
+    interface Context {
+        pushGroup(): void;
+        pushGroupWithContent(content: Content): void;
+        popGroup(): Pattern;
+        popGroupToSource(): void;
+        getGroupTarget(): Surface;
+
+        setFontFace(fontFace: FontFace): void;
+        getFontFace(): FontFace;
+        setFontMatrix(matrix: CairoMatrix): void;
+        getFontMatrix(): CairoMatrix;
+        setScaledFont(scaledFont: ScaledFont): void;
+        getScaledFont(): ScaledFont;
+
+        showGlyphs(glyphs: Array<{ index: number; x: number; y: number }>): void;
+        glyphPath(glyphs: Array<{ index: number; x: number; y: number }>): void;
+        glyphExtents(glyphs: Array<{ index: number; x: number; y: number }>): TextExtents;
+
+        copyPath(): PathData[];
+        copyPathFlat(): PathData[];
+        appendPath(data: PathData[]): void;
+    }
+}
+
+const cairoPushGroup = bind("libcairo.so.2", "cairo_push_group", [CONTEXT_T], t.void);
+Context.prototype.pushGroup = function (): void {
+    cairoPushGroup(getHandle(this));
+};
+
+const cairoPushGroupWithContent = bind("libcairo.so.2", "cairo_push_group_with_content", [CONTEXT_T, t.int32], t.void);
+Context.prototype.pushGroupWithContent = function (content: Content): void {
+    cairoPushGroupWithContent(getHandle(this), content);
+};
+
+const cairoPopGroup = bind(
+    "libcairo.so.2",
+    "cairo_pop_group",
+    [CONTEXT_T],
+    t.boxed("CairoPattern", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_pattern_get_type",
+    }),
+);
+Context.prototype.popGroup = function (): Pattern {
+    return wrapHandle(cairoPopGroup(getHandle(this)) as ExternalObject<Handle>, Pattern) as Pattern;
+};
+
+const cairoPopGroupToSource = bind("libcairo.so.2", "cairo_pop_group_to_source", [CONTEXT_T], t.void);
+Context.prototype.popGroupToSource = function (): void {
+    cairoPopGroupToSource(getHandle(this));
+};
+
+const cairoGetGroupTarget = bind(
+    "libcairo.so.2",
+    "cairo_get_group_target",
+    [CONTEXT_T],
+    t.boxed("CairoSurface", {
+        ownership: "borrowed",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_surface_get_type",
+    }),
+);
+Context.prototype.getGroupTarget = function (): Surface {
+    return wrapHandle(cairoGetGroupTarget(getHandle(this)) as ExternalObject<Handle>, Surface) as Surface;
+};
+
+const cairoSetFontFace = bind(
+    "libcairo.so.2",
+    "cairo_set_font_face",
+    [
+        CONTEXT_T,
+        t.boxed("CairoFontFace", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_font_face_get_type",
+        }),
+    ],
+    t.void,
+);
+Context.prototype.setFontFace = function (fontFace: FontFace): void {
+    cairoSetFontFace(getHandle(this), getHandle(fontFace));
+};
+
+const cairoGetFontFace = bind(
+    "libcairo.so.2",
+    "cairo_get_font_face",
+    [CONTEXT_T],
+    t.boxed("CairoFontFace", {
+        ownership: "borrowed",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_font_face_get_type",
+    }),
+);
+Context.prototype.getFontFace = function (): FontFace {
+    return wrapHandle(cairoGetFontFace(getHandle(this)) as ExternalObject<Handle>, FontFace) as FontFace;
+};
+
+const cairoSetFontMatrix = bind(
+    "libcairo.so.2",
+    "cairo_set_font_matrix",
+    [CONTEXT_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+Context.prototype.setFontMatrix = function (matrix: CairoMatrix): void {
+    cairoSetFontMatrix(getHandle(this), getHandle(matrix));
+};
+
+const cairoGetFontMatrix = bind(
+    "libcairo.so.2",
+    "cairo_get_font_matrix",
+    [CONTEXT_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+Context.prototype.getFontMatrix = function (): CairoMatrix {
+    const { handle, obj } = allocMatrix();
+    cairoGetFontMatrix(getHandle(this), handle);
+    return obj;
+};
+
+const cairoSetScaledFont = bind(
+    "libcairo.so.2",
+    "cairo_set_scaled_font",
+    [
+        CONTEXT_T,
+        t.boxed("CairoScaledFont", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_scaled_font_get_type",
+        }),
+    ],
+    t.void,
+);
+Context.prototype.setScaledFont = function (scaledFont: ScaledFont): void {
+    cairoSetScaledFont(getHandle(this), getHandle(scaledFont));
+};
+
+const cairoGetScaledFont = bind(
+    "libcairo.so.2",
+    "cairo_get_scaled_font",
+    [CONTEXT_T],
+    t.boxed("CairoScaledFont", {
+        ownership: "borrowed",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_scaled_font_get_type",
+    }),
+);
+Context.prototype.getScaledFont = function (): ScaledFont {
+    return wrapHandle(cairoGetScaledFont(getHandle(this)) as ExternalObject<Handle>, ScaledFont) as ScaledFont;
+};
+
+const cairoShowGlyphs = bind(
+    "libcairo.so.2",
+    "cairo_show_glyphs",
+    [CONTEXT_T, t.boxed("cairo_glyph_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }), t.int32],
+    t.void,
+);
+Context.prototype.showGlyphs = function (glyphs: Array<{ index: number; x: number; y: number }>): void {
+    cairoShowGlyphs(getHandle(this), allocGlyphBuffer(glyphs), glyphs.length);
+};
+
+const cairoGlyphPath = bind(
+    "libcairo.so.2",
+    "cairo_glyph_path",
+    [CONTEXT_T, t.boxed("cairo_glyph_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }), t.int32],
+    t.void,
+);
+Context.prototype.glyphPath = function (glyphs: Array<{ index: number; x: number; y: number }>): void {
+    cairoGlyphPath(getHandle(this), allocGlyphBuffer(glyphs), glyphs.length);
+};
+
+const cairoGlyphExtents = bind(
+    "libcairo.so.2",
+    "cairo_glyph_extents",
+    [
+        CONTEXT_T,
+        t.boxed("cairo_glyph_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.int32,
+        t.boxed("cairo_text_extents_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+    ],
+    t.void,
+);
+Context.prototype.glyphExtents = function (glyphs: Array<{ index: number; x: number; y: number }>): TextExtents {
+    const buf = allocGlyphBuffer(glyphs);
+    const extents = alloc(48);
+    cairoGlyphExtents(getHandle(this), buf, glyphs.length, extents);
+    return readTextExtents(extents);
+};
+
+const cairoCopyPath = bind(
+    "libcairo.so.2",
+    "cairo_copy_path",
+    [CONTEXT_T],
+    t.boxed("cairo_path_t", { ownership: "full", sharedLibrary: "libcairo.so.2", freeFnName: "cairo_path_destroy" }),
+);
+Context.prototype.copyPath = function (): PathData[] {
+    return parsePath(cairoCopyPath(getHandle(this)) as ExternalObject<Handle>);
+};
+
+const cairoCopyPathFlat = bind(
+    "libcairo.so.2",
+    "cairo_copy_path_flat",
+    [CONTEXT_T],
+    t.boxed("cairo_path_t", { ownership: "full", sharedLibrary: "libcairo.so.2", freeFnName: "cairo_path_destroy" }),
+);
+Context.prototype.copyPathFlat = function (): PathData[] {
+    return parsePath(cairoCopyPathFlat(getHandle(this)) as ExternalObject<Handle>);
+};
+
+Context.prototype.appendPath = function (data: PathData[]): void {
+    for (const item of data) {
+        switch (item.type) {
+            case "moveTo":
+                this.moveTo(item.x, item.y);
+                break;
+            case "lineTo":
+                this.lineTo(item.x, item.y);
+                break;
+            case "curveTo":
+                this.curveTo(item.x1, item.y1, item.x2, item.y2, item.x3, item.y3);
+                break;
+            case "closePath":
+                this.closePath();
+                break;
+        }
+    }
+};
+
+const cairoStatusToString = bind("libcairo.so.2", "cairo_status_to_string", [t.int32], t.string("borrowed"));
+export const statusToString = (status: Status): string => {
+    return cairoStatusToString(status) as string;
+};
+
+const cairoCreate = bind(
+    "libcairo.so.2",
+    "cairo_create",
+    [
+        t.boxed("CairoSurface", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_surface_get_type",
+        }),
+    ],
+    CONTEXT_T,
+);
+
+class ContextImpl extends Context {
+    static create(surface: Surface): ContextImpl {
+        return wrapHandle(cairoCreate(getHandle(surface)) as ExternalObject<Handle>, ContextImpl);
+    }
+}
+
+export { ContextImpl as Context };
+
+declare module "../cairo.js" {
+    interface Context {
+        tagBegin(tagName: string, attributes: string): void;
+        tagEnd(tagName: string): void;
+        showTextGlyphs(
+            text: string,
+            glyphs: CairoGlyph[],
+            clusters: CairoTextCluster[],
+            clusterFlags: TextClusterFlags,
+        ): void;
+    }
+}
+
+const cairoTagBegin = bind("libcairo.so.2", "cairo_tag_begin", [CONTEXT_T, t.string("full"), t.string("full")], t.void);
+Context.prototype.tagBegin = function (tagName: string, attributes: string): void {
+    cairoTagBegin(getHandle(this), tagName, attributes);
+};
+
+const cairoTagEnd = bind("libcairo.so.2", "cairo_tag_end", [CONTEXT_T, t.string("full")], t.void);
+Context.prototype.tagEnd = function (tagName: string): void {
+    cairoTagEnd(getHandle(this), tagName);
+};
+
+const cairoShowTextGlyphs = bind(
+    "libcairo.so.2",
+    "cairo_show_text_glyphs",
+    [
+        CONTEXT_T,
+        t.string("full"),
+        t.int32,
+        t.boxed("cairo_glyph_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.int32,
+        t.boxed("cairo_text_cluster_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.int32,
+        t.int32,
+    ],
+    t.void,
+);
+Context.prototype.showTextGlyphs = function (
+    text: string,
+    glyphs: CairoGlyph[],
+    clusters: CairoTextCluster[],
+    clusterFlags: TextClusterFlags,
+): void {
+    const glyphBuf = allocGlyphBuffer(glyphs);
+    const clusterBuf = allocClusterBuffer(clusters);
+    cairoShowTextGlyphs(
+        getHandle(this),
+        text,
+        -1,
+        glyphBuf,
+        glyphs.length,
+        clusterBuf,
+        clusters.length,
+        clusterFlags,
+    );
+};