@pen.dev/cli 0.2.8

package/dist/node_modules/@highagency/pencil-wasm/pencil.d.ts

@@ -0,0 +1,769 @@
+export { AddPathMode, AlphaType, BitDepth, BlendMode, BlurStyle, ClipOp, ColorChannel, ColorSpace, ColorType, FillType, FilterMode, FontEdging, FontHinting, FontSlant, FontWeight, FontWidth, ImageFormat, MipmapMode, PaintStyle, Path1DEffectStyle, PathOp, PathVerb, PointMode, SaveLayerFlag, StrokeCap, StrokeJoin, TextAlign, TextDirection, TextEncoding, TileMode, VertexMode, } from "./enums.gen.js";
+import { AddPathMode, AlphaType, BlendMode, BlurStyle, BitDepth, ClipOp, ColorChannel, ColorSpace, ColorType, FillType, FilterMode, FontEdging, FontHinting, FontSlant, FontWeight, FontWidth, ImageFormat, MipmapMode, PaintStyle, Path1DEffectStyle, PathOp, PathVerb, PointMode, SaveLayerFlag, StrokeCap, StrokeJoin, TextAlign, TextDirection, TextEncoding, TileMode, VertexMode } from "./enums.gen.js";
+export type RRect = ArrayLike<number>;
+export type WebGLContextHandle = number;
+export type EncodedImageFormat = number;
+export declare function XYWHRect(x: number, y: number, w: number, h: number): Float32Array;
+export declare function LTRBRect(l: number, t: number, r: number, b: number): Float32Array;
+export declare function RRectXY(rect: ArrayLike<number>, rx: number, ry: number): Float32Array;
+export declare class Paint {
+    ptr: number;
+    constructor(_ptr?: number);
+    setColor4f(r: number, g: number, b: number, a: number): void;
+    setColorComponents(r: number, g: number, b: number, a: number): void;
+    setColor(rgba: ArrayLike<number>): void;
+    setColorInt(argb: number): void;
+    setAlphaf(alpha: number): void;
+    setAntiAlias(enabled: boolean): void;
+    setDither(enabled: boolean): void;
+    setStyle(style: PaintStyle): void;
+    setBlendMode(mode: BlendMode): void;
+    setStrokeWidth(width: number): void;
+    setStrokeCap(cap: StrokeCap): void;
+    setStrokeJoin(join: StrokeJoin): void;
+    setStrokeMiter(limit: number): void;
+    setShader(shader: Shader | undefined): void;
+    setImageFilter(filter: ImageFilter | undefined): void;
+    setColorFilter(filter: ColorFilter | undefined): void;
+    setPathEffect(effect: PathEffect | undefined): void;
+    setMaskFilter(filter: MaskFilter | undefined): void;
+    setBlender(blender: Blender | undefined): void;
+    getColor(): Float32Array;
+    getAlphaf(): number;
+    getStyle(): PaintStyle;
+    getBlendMode(): BlendMode;
+    getStrokeWidth(): number;
+    getStrokeCap(): StrokeCap;
+    getStrokeJoin(): StrokeJoin;
+    getStrokeMiter(): number;
+    isAntiAlias(): boolean;
+    copy(): Paint;
+    delete(): void;
+}
+export declare class Path {
+    static readonly AddMode: Readonly<{
+        readonly Append: 0;
+        readonly Extend: 1;
+    }>;
+    ptr: number;
+    constructor(ptr?: number);
+    static MakeFromSVGString(svg: string): Path | undefined;
+    static MakeFromOp(a: Path, b: Path, op: PathOp): Path | undefined;
+    copy(): Path;
+    makeTransformed(matrix3x3: ArrayLike<number>): Path;
+    makeStroked(opts?: {
+        width?: number;
+        miter_limit?: number;
+        precision?: number;
+        join?: StrokeJoin;
+        cap?: StrokeCap;
+    }): Path | undefined;
+    toSVGString(): string;
+    setFillType(fillType: FillType): void;
+    getFillType(): FillType;
+    contains(x: number, y: number): boolean;
+    computeTightBounds(): Float32Array;
+    getBounds(): Float32Array;
+    isEmpty(): boolean;
+    countPoints(): number;
+    getPoint(index: number): [number, number];
+    getGenerationID(): number;
+    simplify(): Path | undefined;
+    trim(startT: number, stopT: number, isComplement?: boolean): Path | undefined;
+    makeAsWinding(): Path | undefined;
+    makeDashed(on: number, off: number, phase: number): Path | undefined;
+    setIsVolatile(v: boolean): void;
+    isVolatile(): boolean;
+    equals(other: Path): boolean;
+    delete(): void;
+    writeToMemory(): Uint8Array;
+}
+export declare class PathBuilder {
+    ptr: number;
+    constructor();
+    moveTo(x: number, y: number): PathBuilder;
+    lineTo(x: number, y: number): PathBuilder;
+    quadTo(x1: number, y1: number, x2: number, y2: number): PathBuilder;
+    cubicTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): PathBuilder;
+    close(): PathBuilder;
+    addRect(rect: ArrayLike<number>, isCCW?: boolean): PathBuilder;
+    addOval(rect: ArrayLike<number>, isCCW?: boolean, startIndex?: number): PathBuilder;
+    addRRect(rrect: ArrayLike<number>, isCCW?: boolean): PathBuilder;
+    addArc(rect: ArrayLike<number>, startDeg: number, sweepDeg: number): PathBuilder;
+    arcToOval(rect: ArrayLike<number>, startDeg: number, sweepDeg: number, forceMoveTo: boolean): PathBuilder;
+    conicTo(x1: number, y1: number, x2: number, y2: number, weight: number): PathBuilder;
+    offset(dx: number, dy: number): PathBuilder;
+    setFillType(fillType: FillType): PathBuilder;
+    addPath(path: Path, mode?: AddPathMode): PathBuilder;
+    rMoveTo(dx: number, dy: number): PathBuilder;
+    rLineTo(dx: number, dy: number): PathBuilder;
+    rQuadTo(dx1: number, dy1: number, dx2: number, dy2: number): PathBuilder;
+    rCubicTo(dx1: number, dy1: number, dx2: number, dy2: number, dx3: number, dy3: number): PathBuilder;
+    rConicTo(dx1: number, dy1: number, dx2: number, dy2: number, weight: number): PathBuilder;
+    addCircle(x: number, y: number, radius: number, isCCW?: boolean): PathBuilder;
+    addPolygon(pts: ArrayLike<number>, close: boolean): PathBuilder;
+    arcToRotated(rx: number, ry: number, xAxisRotate: number, useSmallArc: boolean, isCCW: boolean, x: number, y: number): PathBuilder;
+    arcToTangent(x1: number, y1: number, x2: number, y2: number, radius: number): PathBuilder;
+    rArcTo(rx: number, ry: number, xAxisRotate: number, useSmallArc: boolean, isCCW: boolean, dx: number, dy: number): PathBuilder;
+    snapshot(): Path;
+    reset(): PathBuilder;
+    detach(): Path;
+    detachAndDelete(): Path;
+    countPoints(): number;
+    isEmpty(): boolean;
+    getBounds(): Float32Array;
+    contains(x: number, y: number): boolean;
+    delete(): void;
+}
+export declare class Shader {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeColor(color: ArrayLike<number>, colorSpace?: ColorSpace): Shader;
+    static MakeLinearGradient(start: ArrayLike<number>, end: ArrayLike<number>, colors: ArrayLike<number>, positions: ArrayLike<number> | undefined, tileMode: TileMode, localMatrix?: ArrayLike<number> | undefined, flags?: number): Shader;
+    static MakeRadialGradient(center: ArrayLike<number>, radius: number, colors: ArrayLike<number>, positions: ArrayLike<number> | undefined, tileMode: TileMode, localMatrix?: ArrayLike<number> | undefined, flags?: number): Shader;
+    static MakeSweepGradient(cx: number, cy: number, colors: ArrayLike<number>, positions: ArrayLike<number> | undefined, tileMode: TileMode, localMatrix?: ArrayLike<number> | undefined, flags?: number, startAngle?: number, endAngle?: number): Shader;
+    static MakeTwoPointConicalGradient(start: ArrayLike<number>, startRadius: number, end: ArrayLike<number>, endRadius: number, colors: ArrayLike<number>, positions: ArrayLike<number> | undefined, tileMode: TileMode, localMatrix?: ArrayLike<number> | undefined, flags?: number): Shader;
+    static MakeBlend(blendMode: BlendMode, dst: Shader, src: Shader): Shader;
+    static MakeFractalNoise(baseFreqX: number, baseFreqY: number, octaves: number, seed: number, tileW?: number, tileH?: number): Shader;
+    static MakeTurbulence(baseFreqX: number, baseFreqY: number, octaves: number, seed: number, tileW?: number, tileH?: number): Shader;
+    delete(): void;
+    makeWithLocalMatrix(localMatrix: ArrayLike<number>): Shader;
+}
+export declare class ImageFilter {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeBlur(sigmaX: number, sigmaY: number, tileMode: TileMode, input: ImageFilter | undefined): ImageFilter;
+    static MakeDropShadow(dx: number, dy: number, sigmaX: number, sigmaY: number, color: ArrayLike<number>, input: ImageFilter | undefined): ImageFilter;
+    static MakeDropShadowOnly(dx: number, dy: number, sigmaX: number, sigmaY: number, color: ArrayLike<number>, input: ImageFilter | undefined): ImageFilter;
+    static MakeColorFilter(cf: ColorFilter, input: ImageFilter | undefined): ImageFilter;
+    static MakeCompose(outer: ImageFilter, inner: ImageFilter): ImageFilter;
+    static MakeOffset(dx: number, dy: number, input: ImageFilter | undefined): ImageFilter;
+    static MakeMatrix(matrix3x3: ArrayLike<number>, filter?: FilterMode, mipmap?: MipmapMode, input?: ImageFilter): ImageFilter;
+    static MakeBlend(blendMode: BlendMode, background: ImageFilter | undefined, foreground: ImageFilter | undefined): ImageFilter;
+    static MakeErode(rx: number, ry: number, input: ImageFilter | undefined): ImageFilter;
+    static MakeDilate(rx: number, ry: number, input: ImageFilter | undefined): ImageFilter;
+    static MakeShader(shader: Shader): ImageFilter;
+    static MakeImage(image: SkImage, sampling: {
+        filter?: FilterMode;
+        mipmap?: MipmapMode;
+        B?: number;
+        C?: number;
+    }, src?: ArrayLike<number>, dst?: ArrayLike<number>): ImageFilter;
+    static MakeDisplacementMap(xChannel: ColorChannel, yChannel: ColorChannel, scale: number, displacement: ImageFilter | undefined, color: ImageFilter | undefined): ImageFilter;
+    getOutputBounds(drawBounds: ArrayLike<number>, ctm?: ArrayLike<number>): Int32Array;
+    delete(): void;
+}
+export declare class MaskFilter {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeBlur(style: BlurStyle, sigma: number, respectCTM?: boolean): MaskFilter;
+    delete(): void;
+}
+export declare class Blender {
+    ptr: number;
+    constructor(ptr: number);
+    static Mode(blendMode: BlendMode): Blender;
+    delete(): void;
+}
+export declare class PathEffect {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeDash(intervals: ArrayLike<number>, phase?: number): PathEffect;
+    static MakeCorner(radius: number): PathEffect;
+    static MakeDiscrete(segLength: number, deviation: number, seed: number): PathEffect;
+    static MakeCompose(outer: PathEffect, inner: PathEffect): PathEffect;
+    static MakeSum(a: PathEffect, b: PathEffect): PathEffect;
+    static MakePath1D(path: Path, advance: number, phase: number, style: Path1DEffectStyle): PathEffect;
+    static MakeLine2D(width: number, matrix: ArrayLike<number>): PathEffect;
+    static MakePath2D(matrix: ArrayLike<number>, path: Path): PathEffect;
+    delete(): void;
+}
+export declare class ColorFilter {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeMatrix(matrix: ArrayLike<number>): ColorFilter;
+    static MakeBlend(color: ArrayLike<number>, blendMode: BlendMode): ColorFilter;
+    static MakeCompose(outer: ColorFilter, inner: ColorFilter): ColorFilter;
+    static MakeLerp(t: number, dst: ColorFilter, src: ColorFilter): ColorFilter;
+    static MakeLinearToSRGB(): ColorFilter;
+    static MakeSRGBToLinear(): ColorFilter;
+    static MakeLuma(): ColorFilter;
+    delete(): void;
+}
+export declare class Vertices {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeVertices(mode: VertexMode, positions: ArrayLike<number>, texs: ArrayLike<number> | undefined, colors: ArrayLike<number> | undefined, indices: ArrayLike<number> | undefined): Vertices;
+    bounds(): Float32Array;
+    uniqueID(): number;
+    delete(): void;
+}
+export declare class ContourMeasure {
+    ptr: number;
+    constructor(ptr: number);
+    length(): number;
+    isClosed(): boolean;
+    getPosTan(distance: number): [number, number, number, number] | undefined;
+    getSegment(startD: number, stopD: number, startWithMoveTo: boolean): Path | undefined;
+    delete(): void;
+}
+export declare class ContourMeasureIter {
+    ptr: number;
+    constructor(path: Path, forceClosed: boolean, resScale?: number);
+    next(): ContourMeasure | undefined;
+    delete(): void;
+}
+export declare class SkImage {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeImageFromEncoded(bytes: Uint8Array | ArrayBuffer, alphaType?: AlphaType): SkImage | undefined;
+    width(): number;
+    height(): number;
+    getImageInfo(): {
+        width: number;
+        height: number;
+        colorType: ColorType;
+        alphaType: AlphaType;
+    };
+    getUniqueID(): number;
+    makeCopyWithDefaultMipmaps(): SkImage;
+    getColorSpace(): ColorSpace;
+    makeShader(tx: number, ty: number, filter?: FilterMode, mipmap?: MipmapMode, localMatrix?: ArrayLike<number> | undefined): Shader;
+    makeShaderOptions(tx: number, ty: number, filter?: FilterMode, mipmap?: MipmapMode, localMatrix?: ArrayLike<number> | undefined): Shader;
+    makeShaderCubic(tx: number, ty: number, cubicB: number, cubicC: number, localMatrix?: ArrayLike<number> | undefined): Shader;
+    encodeToBytes(grContext: GrDirectContext | undefined, format?: number, quality?: number): Uint8Array | undefined;
+    readPixels(srcX: number, srcY: number, imageInfo: {
+        width: number;
+        height: number;
+        colorType: ColorType;
+        alphaType: AlphaType;
+        colorSpace?: ColorSpace;
+    }): Uint8Array | undefined;
+    reinterpretColorSpace(colorSpace: ColorSpace): SkImage;
+    delete(): void;
+}
+export declare class SkImages {
+    static deferredFromPicture(picture: Picture, width: number, height: number, localMatrix?: ArrayLike<number> | undefined, paint?: Paint | undefined, bitDepth?: BitDepth, colorSpace?: ColorSpace): SkImage;
+}
+export interface RuntimeEffectResult {
+    effect?: RuntimeEffect;
+    error?: string;
+}
+export interface RuntimeEffectUniform {
+    name: string;
+    type: number;
+    count: number;
+    offset: number;
+    flags: number;
+    isColor: boolean;
+    isArray: boolean;
+    columns: number;
+    rows: number;
+    slot: number;
+    isInteger: boolean;
+}
+export declare class RuntimeEffect {
+    ptr: number;
+    constructor(ptr: number);
+    static Make(sksl: string): RuntimeEffectResult;
+    static MakeForShader(sksl: string): RuntimeEffectResult;
+    static MakeForColorFilter(sksl: string): RuntimeEffectResult;
+    static MakeForBlender(sksl: string): RuntimeEffectResult;
+    private static _make;
+    getUniformCount(): number;
+    getUniformSize(): number;
+    getUniform(index: number): RuntimeEffectUniform | undefined;
+    makeShader(uniforms: Uint8Array | ArrayLike<number> | undefined, localMatrix?: ArrayLike<number> | undefined): Shader;
+    makeShaderWithChildren(uniforms: Uint8Array | ArrayLike<number> | undefined, children?: (Shader | undefined)[], localMatrix?: ArrayLike<number> | undefined): Shader;
+    private _makeShader;
+    makeColorFilter(uniforms: Uint8Array | ArrayLike<number> | undefined): ColorFilter;
+    makeBlender(uniforms: Uint8Array | ArrayLike<number> | undefined): Blender;
+    delete(): void;
+}
+export declare class PDFDocument {
+    ptr: number;
+    constructor();
+    beginPage(width: number, height: number): Canvas;
+    endPage(): void;
+    close(): Uint8Array;
+    getBytes(): Uint8Array;
+    delete(): void;
+}
+export interface FontStyle {
+    weight: FontWeight;
+    width: FontWidth;
+    slant: FontSlant;
+}
+export interface VariationAxis {
+    tag: number;
+    min: number;
+    def: number;
+    max: number;
+    isHidden: boolean;
+}
+export declare class Typeface {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeFromData(bytes: Uint8Array | ArrayBuffer): Typeface | undefined;
+    getFamilyName(): string;
+    fontStyle(): FontStyle;
+    getVariationDesignParameters(): VariationAxis[];
+    delete(): void;
+}
+export declare class FontMgr {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeEmpty(): FontMgr;
+    static FromData(...buffers: (Uint8Array | ArrayBuffer)[]): FontMgr | undefined;
+    countFamilies(): number;
+    getFamilyName(index: number): string;
+    matchFamilyStyle(name: string, style: {
+        weight?: FontWeight;
+        width?: FontWidth;
+        slant?: FontSlant;
+    }): Typeface | undefined;
+    delete(): void;
+}
+export declare class Font {
+    ptr: number;
+    constructor(typeface?: Typeface | undefined, size?: number);
+    copy(): Font;
+    setTypeface(typeface: Typeface | undefined): void;
+    setSize(size: number): void;
+    setScaleX(sx: number): void;
+    setSkewX(kx: number): void;
+    setEdging(e: FontEdging): void;
+    setHinting(h: FontHinting): void;
+    setSubpixel(v: boolean): void;
+    setEmbeddedBitmaps(v: boolean): void;
+    setForceAutoHinting(v: boolean): void;
+    setLinearMetrics(v: boolean): void;
+    getSize(): number;
+    getScaleX(): number;
+    getSkewX(): number;
+    getEdging(): FontEdging;
+    getHinting(): FontHinting;
+    countText(text: string, encoding?: TextEncoding): number;
+    getGlyphIDs(text: string): Uint16Array;
+    measureText(text: string): number;
+    getGlyphWidths(glyphs: Uint16Array): Float32Array;
+    delete(): void;
+}
+export declare class TextBlob {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeFromText(text: string, font: Font, encoding?: TextEncoding): TextBlob | undefined;
+    static MakeFromGlyphs(glyphs: Uint16Array, font: Font): TextBlob | undefined;
+    static MakeFromRSXform(text: string, rsxforms: ArrayLike<number>, font: Font, encoding?: TextEncoding): TextBlob | undefined;
+    delete(): void;
+}
+export declare class Picture {
+    ptr: number;
+    constructor(ptr: number);
+    cullRect(): Float32Array;
+    uniqueID(): number;
+    approximateOpCount(): number;
+    makeShader(tx: number, ty: number, filterMode?: FilterMode, localMatrix?: ArrayLike<number> | undefined, tileRect?: ArrayLike<number> | undefined): Shader;
+    serialize(): Uint8Array | undefined;
+    delete(): void;
+}
+export declare class PictureRecorder {
+    ptr: number;
+    constructor();
+    beginRecording(bounds: ArrayLike<number>): Canvas;
+    finishRecordingAsPicture(): Picture | undefined;
+    delete(): void;
+}
+export declare class SkUnicodeImpl {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeICU(): SkUnicodeImpl | undefined;
+    delete(): void;
+}
+export declare class TypefaceFontProvider {
+    ptr: number;
+    constructor();
+    static Make(): TypefaceFontProvider;
+    registerFont(bytes: Uint8Array | ArrayBuffer, alias?: string): boolean;
+    delete(): void;
+}
+export declare class FontCollection {
+    ptr: number;
+    constructor();
+    static Make(): FontCollection;
+    setDefaultFontManager(mgr: TypefaceFontProvider | FontMgr | undefined): void;
+    setDynamicFontManager(provider: TypefaceFontProvider | undefined): void;
+    enableFontFallback(): void;
+    clearCaches(): void;
+    delete(): void;
+}
+interface TextShadow {
+    color?: ArrayLike<number>;
+    offset?: ArrayLike<number>;
+    blurRadius?: number;
+}
+interface TextFontFeatures {
+    name: string;
+    value: number;
+}
+interface TextFontVariations {
+    axis: string;
+    value: number;
+}
+interface TextStyleProps {
+    color?: ArrayLike<number>;
+    foregroundColor?: ArrayLike<number>;
+    backgroundColor?: ArrayLike<number>;
+    decoration?: number;
+    decorationColor?: ArrayLike<number>;
+    decorationThickness?: number;
+    decorationStyle?: number;
+    fontFamilies?: string[];
+    fontFeatures?: TextFontFeatures[];
+    fontSize?: number;
+    fontStyle?: {
+        weight?: FontWeight;
+        width?: FontWidth;
+        slant?: FontSlant;
+    };
+    fontVariations?: TextFontVariations[];
+    heightMultiplier?: number;
+    halfLeading?: boolean;
+    letterSpacing?: number;
+    locale?: string;
+    shadows?: TextShadow[];
+    textBaseline?: number;
+    wordSpacing?: number;
+}
+interface StrutStyleProps {
+    strutEnabled?: boolean;
+    fontFamilies?: string[];
+    fontStyle?: {
+        weight?: FontWeight;
+        width?: FontWidth;
+        slant?: FontSlant;
+    };
+    fontSize?: number;
+    heightMultiplier?: number;
+    halfLeading?: boolean;
+    leading?: number;
+    forceStrutHeight?: boolean;
+}
+interface ParagraphStyleProps {
+    disableHinting?: boolean;
+    ellipsis?: string;
+    heightMultiplier?: number;
+    maxLines?: number;
+    replaceTabCharacters?: boolean;
+    strutStyle?: StrutStyleProps;
+    textAlign?: TextAlign;
+    textDirection?: TextDirection;
+    textHeightBehavior?: number;
+    textStyle?: TextStyleProps;
+    applyRoundingHack?: boolean;
+}
+export interface LineMetrics {
+    startIndex: number;
+    endIndex: number;
+    endExcludingWhitespaces: number;
+    endIncludingNewline: number;
+    hardBreak: boolean;
+    ascent: number;
+    descent: number;
+    height: number;
+    width: number;
+    left: number;
+    baseline: number;
+    lineNumber: number;
+}
+export interface GlyphInfo {
+    graphemeLayoutBounds: Float32Array;
+    graphemeClusterTextRange: {
+        start: number;
+        end: number;
+    };
+    direction: TextDirection;
+    isEllipsis: boolean;
+}
+export declare class Paragraph {
+    ptr: number;
+    constructor(ptr: number);
+    layout(width: number): void;
+    paint(canvas: Canvas, x: number, y: number): void;
+    getMaxWidth(): number;
+    getHeight(): number;
+    getMinIntrinsicWidth(): number;
+    getMaxIntrinsicWidth(): number;
+    getAlphabeticBaseline(): number;
+    getIdeographicBaseline(): number;
+    getNumberOfLines(): number;
+    didExceedMaxLines(): boolean;
+    getGlyphPositionAtCoordinate(dx: number, dy: number): {
+        position: number;
+        affinity: number;
+    };
+    getLineMetricsAt(lineNumber: number): LineMetrics | undefined;
+    getLineMetrics(): LineMetrics[];
+    getLongestLine(): number;
+    getRectsForRange(start: number, end: number, rectHeightStyle: number, rectWidthStyle: number): Float32Array;
+    getWordBoundary(offset: number): {
+        start: number;
+        end: number;
+    };
+    getLineNumberAt(index: number): number;
+    getRectsForPlaceholders(): Float32Array;
+    getGlyphInfoAt(index: number): GlyphInfo | undefined;
+    getClosestGlyphInfoAtCoordinate(dx: number, dy: number): GlyphInfo | undefined;
+    getPath(): Path;
+    unresolvedCodepoints(): number[];
+    delete(): void;
+}
+export declare class ParagraphBuilder {
+    ptr: number;
+    constructor(ptr: number);
+    static MakeFromFontCollection(style: ParagraphStyleProps, fc: FontCollection, unicode?: SkUnicodeImpl): ParagraphBuilder;
+    pushStyle(style: TextStyleProps): void;
+    pushPaintStyle(textStyle: TextStyleProps, fg: Paint, bg: Paint): void;
+    pop(): void;
+    addText(text: string): void;
+    addPlaceholder(width: number, height: number, alignment: number, baseline: number, offset: number): void;
+    build(): Paragraph;
+    reset(): void;
+    getText(): string;
+    delete(): void;
+}
+export declare class Canvas {
+    ptr: number;
+    _glHandle: number;
+    constructor(ptr: number);
+    clear(rOrColor: number | ArrayLike<number>, g?: number, b?: number, a?: number): void;
+    drawColor(color: ArrayLike<number>, blendMode?: BlendMode): void;
+    drawColorInt(color: number, blendMode?: BlendMode): void;
+    drawPaint(paint: Paint): void;
+    drawRect(rect: ArrayLike<number>, paint: Paint): void;
+    drawRect4f(l: number, t: number, r: number, b: number, paint: Paint): void;
+    drawRRect(rrect: ArrayLike<number>, paint: Paint): void;
+    drawCircle(cx: number, cy: number, radius: number, paint: Paint): void;
+    drawOval(rect: ArrayLike<number>, paint: Paint): void;
+    drawLine(x0: number, y0: number, x1: number, y1: number, paint: Paint): void;
+    drawPath(path: Path, paint: Paint): void;
+    drawVertices(vertices: Vertices, blendMode: BlendMode, paint: Paint): void;
+    drawImage(image: SkImage, x: number, y: number, paint?: Paint | undefined, filter?: FilterMode, mipmap?: MipmapMode): void;
+    drawImageRect(image: SkImage, src: ArrayLike<number>, dst: ArrayLike<number>, paint?: Paint | undefined, fastSample?: boolean, filter?: FilterMode, mipmap?: MipmapMode): void;
+    drawImageNine(image: SkImage, center: ArrayLike<number>, dst: ArrayLike<number>, filter: FilterMode, paint?: Paint | undefined): void;
+    drawImageCubic(image: SkImage, x: number, y: number, B: number, C: number, paint?: Paint | undefined): void;
+    drawImageRectCubic(image: SkImage, src: ArrayLike<number>, dst: ArrayLike<number>, B: number, C: number, paint?: Paint | undefined): void;
+    writePixels(pixels: Uint8Array, srcWidth: number, srcHeight: number, destX: number, destY: number, alphaType?: number, colorType?: number, colorSpace?: ColorSpace): boolean;
+    makeSurface(info: {
+        width: number;
+        height: number;
+        colorType?: ColorType;
+        alphaType?: AlphaType;
+        colorSpace?: ColorSpace;
+    }): Surface | undefined;
+    drawParagraph(p: Paragraph, x: number, y: number): void;
+    drawArc(oval: ArrayLike<number>, startAngle: number, sweepAngle: number, useCenter: boolean, paint: Paint): void;
+    drawDRRect(outer: ArrayLike<number>, inner: ArrayLike<number>, paint: Paint): void;
+    drawPoints(mode: PointMode, points: ArrayLike<number>, paint: Paint): void;
+    quickReject(rect: ArrayLike<number>): boolean;
+    drawText(text: string, x: number, y: number, paint: Paint, font: Font): void;
+    drawGlyphs(glyphs: Uint16Array, positions: ArrayLike<number>, x: number, y: number, font: Font, paint: Paint): void;
+    drawTextBlob(blob: TextBlob, x: number, y: number, paint: Paint): void;
+    drawPicture(picture: Picture): void;
+    drawPatch(cubics: ArrayLike<number>, colors?: ArrayLike<number> | undefined, texs?: ArrayLike<number> | undefined, blendMode?: BlendMode, paint?: Paint): void;
+    drawAtlas(atlas: SkImage, srcRects: ArrayLike<number>, dstXforms: ArrayLike<number>, paint: Paint, blendMode?: BlendMode, colors?: ArrayLike<number> | undefined, sampling?: {
+        filter?: FilterMode;
+        mipmap?: MipmapMode;
+        B?: number;
+        C?: number;
+    }): void;
+    drawShadow(path: Path, zPlane: ArrayLike<number>, lightPos: ArrayLike<number>, lightRadius: number, ambientColor: ArrayLike<number>, spotColor: ArrayLike<number>, flags: number): void;
+    save(): number;
+    saveLayer(paint?: Paint | undefined, bounds?: ArrayLike<number> | undefined, backdrop?: ImageFilter | undefined, flags?: number, backdropTileMode?: TileMode): number;
+    restore(): void;
+    getSaveCount(): number;
+    restoreToCount(count: number): void;
+    translate(dx: number, dy: number): void;
+    scale(sx: number, sy: number): void;
+    rotate(degrees: number, px?: number, py?: number): void;
+    skew(sx: number, sy: number): void;
+    concat(matrix: ArrayLike<number>): void;
+    resetMatrix(): void;
+    clipRect(rect: ArrayLike<number>, clipOp?: ClipOp, antiAlias?: boolean): void;
+    clipRRect(rrect: ArrayLike<number>, clipOp?: ClipOp, antiAlias?: boolean): void;
+    clipPath(path: Path, clipOp?: ClipOp, antiAlias?: boolean): void;
+    readPixels(srcX: number, srcY: number, imageInfo: {
+        width: number;
+        height: number;
+        colorType: ColorType;
+        alphaType: AlphaType;
+        colorSpace?: ColorSpace;
+    }, out?: Uint8Array): Uint8Array | undefined;
+    getTotalMatrix(): Float32Array;
+    getLocalToDevice(): Float32Array;
+    getDeviceClipBounds(): Int32Array;
+}
+export declare class GrDirectContext {
+    ptr: number;
+    _glHandle: number;
+    constructor(ptr: number, glHandle?: number);
+    private _bind;
+    setResourceCacheLimitBytes(maxBytes: number): void;
+    getResourceCacheLimitBytes(): number;
+    getResourceCacheUsage(): {
+        count: number;
+        bytes: number;
+    };
+    getResourceCacheUsageBytes(): number;
+    getResourceCachePurgeableBytes(): number;
+    freeGpuResources(): void;
+    purgeUnlockedResources(scratchResourcesOnly?: boolean): void;
+    performDeferredCleanup(msNotUsed: number, scratchResourcesOnly?: boolean): void;
+    flush(): void;
+    submit(syncCpu?: boolean): void;
+    flushAndSubmit(syncCpu?: boolean): void;
+    abandonContext(): void;
+    isAbandoned(): boolean;
+    maxTextureSize(): number;
+    maxRenderTargetSize(): number;
+    releaseResourcesAndAbandonContext(): void;
+    delete(): void;
+}
+export declare class Surface {
+    ptr: number;
+    _glHandle: number;
+    constructor(ptr: number);
+    private _bind;
+    static MakeSurface(w: number, h: number): Surface | undefined;
+    static MakeSurfaceWithInfo(info: {
+        width: number;
+        height: number;
+        colorType?: ColorType;
+        alphaType?: AlphaType;
+        colorSpace?: ColorSpace;
+    }): Surface | undefined;
+    makeImageSnapshot(bounds?: ArrayLike<number> | undefined): SkImage;
+    draw(canvas: Canvas, x: number, y: number, filter?: FilterMode, mipmap?: MipmapMode, paint?: Paint | undefined): void;
+    makeSurface(info: {
+        width: number;
+        height: number;
+        colorType?: ColorType;
+        alphaType?: AlphaType;
+        colorSpace?: ColorSpace;
+    }, sampleCount?: number): Surface | undefined;
+    width(): number;
+    height(): number;
+    sampleCnt(): number;
+    makeImageFromTexture(texId: number, info: {
+        width: number;
+        height: number;
+        colorType?: ColorType;
+        alphaType?: AlphaType;
+    }): SkImage | undefined;
+    imageInfo(): {
+        width: number;
+        height: number;
+        colorType: ColorType;
+        alphaType: AlphaType;
+        colorSpace: ColorSpace;
+    };
+    flush(): void;
+    getCanvas(): Canvas;
+    delete(): void;
+}
+export declare function MakeWebGLContext(handle: number): GrDirectContext | undefined;
+export declare function MakeOnScreenGLSurface(grContext: GrDirectContext, width: number, height: number, colorSpace?: ColorSpace, sampleCount?: number, stencil?: number): Surface | undefined;
+export declare function MakeSurface(w: number, h: number): Surface | undefined;
+export declare function MakeRenderTarget(grContext: GrDirectContext, info: {
+    width: number;
+    height: number;
+    colorType?: ColorType;
+    alphaType?: AlphaType;
+    colorSpace?: ColorSpace;
+}, sampleCount?: number): Surface | undefined;
+export declare function GetWebGLContext(canvas: HTMLCanvasElement | OffscreenCanvas, attrs?: WebGLContextAttributes): number;
+export declare function setCurrentContext(handle: number): boolean;
+export declare function deleteContext(handle: number): void;
+export type Image = SkImage;
+export interface PencilWasmInitOptions {
+    wasmBinary?: Uint8Array;
+    locateFile?: (path: string, prefix: string) => string;
+}
+export interface PencilWasm {
+    readonly Surface: typeof Surface;
+    readonly Canvas: typeof Canvas;
+    readonly Paint: typeof Paint;
+    readonly Path: typeof Path;
+    readonly PathBuilder: typeof PathBuilder;
+    readonly Shader: typeof Shader;
+    readonly ImageFilter: typeof ImageFilter;
+    readonly ColorFilter: typeof ColorFilter;
+    readonly Vertices: typeof Vertices;
+    readonly ContourMeasure: typeof ContourMeasure;
+    readonly ContourMeasureIter: typeof ContourMeasureIter;
+    readonly Image: typeof SkImage;
+    readonly RuntimeEffect: typeof RuntimeEffect;
+    readonly PDFDocument: typeof PDFDocument;
+    readonly FontMgr: typeof FontMgr;
+    readonly Typeface: typeof Typeface;
+    readonly Font: typeof Font;
+    readonly TextBlob: typeof TextBlob;
+    readonly Picture: typeof Picture;
+    readonly PictureRecorder: typeof PictureRecorder;
+    readonly MaskFilter: typeof MaskFilter;
+    readonly Blender: typeof Blender;
+    readonly SkUnicodeImpl: typeof SkUnicodeImpl;
+    readonly TypefaceFontProvider: typeof TypefaceFontProvider;
+    readonly FontCollection: typeof FontCollection;
+    readonly ParagraphBuilder: typeof ParagraphBuilder;
+    readonly Paragraph: typeof Paragraph;
+    readonly PathEffect: typeof PathEffect;
+    readonly GrDirectContext: typeof GrDirectContext;
+    XYWHRect(x: number, y: number, w: number, h: number): Float32Array;
+    LTRBRect(l: number, t: number, r: number, b: number): Float32Array;
+    RRectXY(rect: ArrayLike<number>, rx: number, ry: number): Float32Array;
+    readonly PaintStyle: typeof PaintStyle;
+    readonly StrokeCap: typeof StrokeCap;
+    readonly StrokeJoin: typeof StrokeJoin;
+    readonly TileMode: typeof TileMode;
+    readonly ClipOp: typeof ClipOp;
+    readonly VertexMode: typeof VertexMode;
+    readonly PointMode: typeof PointMode;
+    readonly PathOp: typeof PathOp;
+    readonly FillType: typeof FillType;
+    readonly BlendMode: typeof BlendMode;
+    readonly BlurStyle: typeof BlurStyle;
+    readonly FilterMode: typeof FilterMode;
+    readonly MipmapMode: typeof MipmapMode;
+    readonly ImageFormat: typeof ImageFormat;
+    readonly TextAlign: typeof TextAlign;
+    readonly TextDirection: typeof TextDirection;
+    readonly TextEncoding: typeof TextEncoding;
+    readonly FontSlant: typeof FontSlant;
+    readonly FontWeight: typeof FontWeight;
+    readonly FontWidth: typeof FontWidth;
+    readonly FontEdging: typeof FontEdging;
+    readonly FontHinting: typeof FontHinting;
+    readonly ColorType: typeof ColorType;
+    readonly AlphaType: typeof AlphaType;
+    readonly ColorSpace: typeof ColorSpace;
+    readonly ColorChannel: typeof ColorChannel;
+    readonly Path1DEffectStyle: typeof Path1DEffectStyle;
+    readonly PathVerb: typeof PathVerb;
+    readonly SaveLayerFlag: typeof SaveLayerFlag;
+    createWebGLContext(canvas: HTMLCanvasElement | OffscreenCanvas, attrs?: WebGLContextAttributes): number;
+    setCurrentContext(handle: number): boolean;
+    deleteContext(handle: number): void;
+    GetWebGLContext(canvas: HTMLCanvasElement | OffscreenCanvas, attrs?: WebGLContextAttributes): number;
+    MakeWebGLContext(handle: number): GrDirectContext | undefined;
+    MakeOnScreenGLSurface(grContext: GrDirectContext, width: number, height: number, colorSpace?: ColorSpace, sampleCount?: number, stencil?: number): Surface | undefined;
+    MakeSurface(w: number, h: number): Surface | undefined;
+    MakeRenderTarget(grContext: GrDirectContext, info: {
+        width: number;
+        height: number;
+        colorType?: ColorType;
+        alphaType?: AlphaType;
+        colorSpace?: ColorSpace;
+    }, sampleCount?: number): Surface | undefined;
+}
+export default function PencilWasmInit(opts?: PencilWasmInitOptions): Promise<PencilWasm>;