import { ReadableStream } from 'node:stream/web' // Clear all type of caches in Skia export function clearAllCache(): void interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasSettings, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasPDFAnnotations { } interface CanvasState { isContextLost(): boolean reset(): void restore(): void save(): void } interface CanvasShadowStyles { shadowBlur: number shadowColor: string shadowOffsetX: number shadowOffsetY: number } interface CanvasRenderingContext2DSettings { alpha?: boolean colorSpace?: PredefinedColorSpace desynchronized?: boolean willReadFrequently?: boolean } interface CanvasSettings { getContextAttributes(): CanvasRenderingContext2DSettings } interface CanvasRect { clearRect(x: number, y: number, w: number, h: number): void fillRect(x: number, y: number, w: number, h: number): void strokeRect(x: number, y: number, w: number, h: number): void } interface TextMetrics { readonly actualBoundingBoxAscent: number readonly actualBoundingBoxDescent: number readonly actualBoundingBoxLeft: number readonly actualBoundingBoxRight: number readonly alphabeticBaseline: number readonly emHeightAscent: number readonly emHeightDescent: number readonly fontBoundingBoxAscent: number readonly fontBoundingBoxDescent: number readonly hangingBaseline: number readonly ideographicBaseline: number readonly width: number } interface CanvasText { fillText(text: string, x: number, y: number, maxWidth?: number): void measureText(text: string): TextMetrics strokeText(text: string, x: number, y: number, maxWidth?: number): void } type CanvasLineCap = 'butt' | 'round' | 'square' type CanvasLineJoin = 'bevel' | 'miter' | 'round' interface CanvasPathDrawingStyles { lineCap: CanvasLineCap lineDashOffset: number lineJoin: CanvasLineJoin lineWidth: number miterLimit: number getLineDash(): number[] setLineDash(segments: number[]): void } interface CanvasPath { arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void closePath(): void ellipse( x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean, ): void lineTo(x: number, y: number): void moveTo(x: number, y: number): void quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void rect(x: number, y: number, w: number, h: number): void roundRect(x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | (number | DOMPointInit)[]): void } type ImageSmoothingQuality = 'high' | 'low' | 'medium' interface CanvasImageSmoothing { imageSmoothingEnabled: boolean imageSmoothingQuality: ImageSmoothingQuality } interface CanvasTransform { resetTransform(): void rotate(angle: number): void scale(x: number, y: number): void setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void setTransform(transform?: DOMMatrix2DInit): void transform(a: number, b: number, c: number, d: number, e: number, f: number): void translate(x: number, y: number): void } interface CanvasPDFAnnotations { /** * Create a clickable URL link annotation in a PDF document. * This is only effective when used with PDF documents. * @param left - Left coordinate of the link rectangle * @param top - Top coordinate of the link rectangle * @param right - Right coordinate of the link rectangle * @param bottom - Bottom coordinate of the link rectangle * @param url - The URL to link to */ annotateLinkUrl(left: number, top: number, right: number, bottom: number, url: string): void /** * Create a named destination at a specific point in a PDF document. * This destination can be used as a target for internal links. * @param x - X coordinate of the destination point * @param y - Y coordinate of the destination point * @param name - Name identifier for the destination */ annotateNamedDestination(x: number, y: number, name: string): void /** * Create a link to a named destination within the PDF document. * This is only effective when used with PDF documents. * @param left - Left coordinate of the link rectangle * @param top - Top coordinate of the link rectangle * @param right - Right coordinate of the link rectangle * @param bottom - Bottom coordinate of the link rectangle * @param name - Name of the destination to link to */ annotateLinkToDestination(left: number, top: number, right: number, bottom: number, name: string): void } type PredefinedColorSpace = 'display-p3' | 'srgb' interface ImageDataSettings { colorSpace?: PredefinedColorSpace } interface CanvasImageData { createImageData(sw: number, sh: number, settings?: ImageDataSettings): ImageData createImageData(imagedata: ImageData): ImageData getImageData(sx: number, sy: number, sw: number, sh: number, settings?: ImageDataSettings): ImageData putImageData(imagedata: ImageData, dx: number, dy: number): void putImageData( imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number, ): void } type CanvasDirection = 'inherit' | 'ltr' | 'rtl' type CanvasFontKerning = 'auto' | 'none' | 'normal' type CanvasFontStretch = | 'condensed' | 'expanded' | 'extra-condensed' | 'extra-expanded' | 'normal' | 'semi-condensed' | 'semi-expanded' | 'ultra-condensed' | 'ultra-expanded' type CanvasFontVariantCaps = | 'all-petite-caps' | 'all-small-caps' | 'normal' | 'petite-caps' | 'small-caps' | 'titling-caps' | 'unicase' type CanvasTextAlign = 'center' | 'end' | 'left' | 'right' | 'start' type CanvasTextBaseline = 'alphabetic' | 'bottom' | 'hanging' | 'ideographic' | 'middle' | 'top' type CanvasTextRendering = 'auto' | 'geometricPrecision' | 'optimizeLegibility' | 'optimizeSpeed' interface CanvasTextDrawingStyles { direction: CanvasDirection font: string fontKerning: CanvasFontKerning fontStretch: CanvasFontStretch fontVariantCaps: CanvasFontVariantCaps letterSpacing: string textAlign: CanvasTextAlign textBaseline: CanvasTextBaseline textRendering: CanvasTextRendering wordSpacing: string fontVariationSettings: string lang: string } interface CanvasFilters { filter: string } interface CanvasFillStrokeStyles { fillStyle: string | CanvasGradient | CanvasPattern strokeStyle: string | CanvasGradient | CanvasPattern createConicGradient(startAngle: number, x: number, y: number): CanvasGradient createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient } type CanvasFillRule = 'evenodd' | 'nonzero' interface CanvasDrawPath { beginPath(): void clip(fillRule?: CanvasFillRule): void clip(path: Path2D, fillRule?: CanvasFillRule): void fill(fillRule?: CanvasFillRule): void fill(path: Path2D, fillRule?: CanvasFillRule): void isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean isPointInStroke(x: number, y: number): boolean isPointInStroke(path: Path2D, x: number, y: number): boolean stroke(): void stroke(path: Path2D): void } type GlobalCompositeOperation = | 'color' | 'color-burn' | 'color-dodge' | 'copy' | 'darken' | 'destination-atop' | 'destination-in' | 'destination-out' | 'destination-over' | 'difference' | 'exclusion' | 'hard-light' | 'hue' | 'lighten' | 'lighter' | 'luminosity' | 'multiply' | 'overlay' | 'saturation' | 'screen' | 'soft-light' | 'source-atop' | 'source-in' | 'source-out' | 'source-over' | 'xor' interface CanvasCompositing { globalAlpha: number globalCompositeOperation: GlobalCompositeOperation } interface DOMPointInit { w?: number x?: number y?: number z?: number } interface CanvasPattern { setTransform(transform?: DOMMatrix2DInit): void } interface CanvasGradient { addColorStop(offset: number, color: string): void } interface DOMRectInit { height?: number width?: number x?: number y?: number } interface DOMMatrixInit extends DOMMatrix2DInit { is2D?: boolean m13?: number m14?: number m23?: number m24?: number m31?: number m32?: number m33?: number m34?: number m43?: number m44?: number } // ----------- added types export interface DOMMatrix2DInit { a: number b: number c: number d: number e: number f: number } interface DOMMatrixReadOnly { readonly a: number readonly b: number readonly c: number readonly d: number readonly e: number readonly f: number readonly is2D: boolean readonly isIdentity: boolean readonly m11: number readonly m12: number readonly m13: number readonly m14: number readonly m21: number readonly m22: number readonly m23: number readonly m24: number readonly m31: number readonly m32: number readonly m33: number readonly m34: number readonly m41: number readonly m42: number readonly m43: number readonly m44: number flipX(): DOMMatrix flipY(): DOMMatrix inverse(): DOMMatrix multiply(other?: DOMMatrixInit): DOMMatrix rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix rotateFromVector(x?: number, y?: number): DOMMatrix scale( scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number, ): DOMMatrix scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix skewX(sx?: number): DOMMatrix skewY(sy?: number): DOMMatrix toFloat32Array(): Float32Array toFloat64Array(): Float64Array transformPoint(point?: DOMPointInit): DOMPoint translate(tx?: number, ty?: number, tz?: number): DOMMatrix toString(): string } export interface DOMMatrix extends DOMMatrixReadOnly { a: number b: number c: number d: number e: number f: number m11: number m12: number m13: number m14: number m21: number m22: number m23: number m24: number m31: number m32: number m33: number m34: number m41: number m42: number m43: number m44: number invertSelf(): DOMMatrix multiplySelf(other?: DOMMatrixInit): DOMMatrix preMultiplySelf(other?: DOMMatrixInit): DOMMatrix rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix rotateFromVectorSelf(x?: number, y?: number): DOMMatrix rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix scaleSelf( scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number, ): DOMMatrix setMatrixValue(transformList: string): DOMMatrix skewXSelf(sx?: number): DOMMatrix skewYSelf(sy?: number): DOMMatrix translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix toJSON(): { [K in OmitNeverOfMatrix]: DOMMatrix[K] } } type OmitMatrixMethod = { [K in keyof DOMMatrix]: DOMMatrix[K] extends (...args: any[]) => any ? never : K } type OmitNeverOfMatrix = OmitMatrixMethod[keyof OmitMatrixMethod] export const DOMMatrix: { prototype: DOMMatrix new(init?: string | number[]): DOMMatrix fromFloat32Array(array32: Float32Array): DOMMatrix fromFloat64Array(array64: Float64Array): DOMMatrix fromMatrix(other?: DOMMatrixInit): DOMMatrix } interface DOMRectReadOnly { readonly bottom: number readonly height: number readonly left: number readonly right: number readonly top: number readonly width: number readonly x: number readonly y: number } export interface DOMRect extends DOMRectReadOnly { height: number width: number x: number y: number toJSON(): Omit } export const DOMRect: { prototype: DOMRect new(x?: number, y?: number, width?: number, height?: number): DOMRect fromRect(other?: DOMRectInit): DOMRect } interface DOMPointReadOnly { readonly w: number readonly x: number readonly y: number readonly z: number matrixTransform(matrix?: DOMMatrixInit): DOMPoint } export interface DOMPoint extends DOMPointReadOnly { w: number x: number y: number z: number toJSON(): Omit } export const DOMPoint: { prototype: DOMPoint new(x?: number, y?: number, z?: number, w?: number): DOMPoint fromPoint(other?: DOMPointInit): DOMPoint } export class ImageData { /** * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255. */ readonly data: Uint8ClampedArray /** * Returns the actual dimensions of the data in the ImageData object, in pixels. */ readonly height: number /** * Returns the actual dimensions of the data in the ImageData object, in pixels. */ readonly width: number constructor(sw: number, sh: number, attr?: { colorSpace?: ColorSpace }) constructor(imageData: ImageData, attr?: { colorSpace?: ColorSpace }) constructor(data: Uint8ClampedArray | Uint16Array | Float16Array | Float32Array, sw: number, sh?: number) } export class Image { constructor() // attrs only affects SVG constructor(width: number, height: number, attrs?: { colorSpace?: ColorSpace }) width: number height: number readonly naturalWidth: number readonly naturalHeight: number readonly complete: boolean readonly currentSrc: string | null alt: string // the src can be a Uint8Array or a string // if it's a string, it can be a file path, a data URL, a remote URL, or a SVG string src: Uint8Array | string onload?(): void onerror?(err: Error): void decode(): Promise } export class Path2D { constructor(path?: Path2D | string) addPath(path: Path2D, transform?: DOMMatrix2DInit): void arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void closePath(): void ellipse( x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean, ): void lineTo(x: number, y: number): void moveTo(x: number, y: number): void quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void rect(x: number, y: number, w: number, h: number): void roundRect(x: number, y: number, w: number, h: number, radii?: number | number[]): void // PathKit methods op(path: Path2D, operation: PathOp): Path2D toSVGString(): string getFillType(): FillType getFillTypeString(): string setFillType(type: FillType): void simplify(): Path2D asWinding(): Path2D stroke(stroke?: StrokeOptions): Path2D transform(transform: DOMMatrix2DInit): Path2D getBounds(): [left: number, top: number, right: number, bottom: number] computeTightBounds(): [left: number, top: number, right: number, bottom: number] trim(start: number, end: number, isComplement?: boolean): Path2D dash(on: number, off: number, phase: number): Path2D round(radius: number): Path2D equals(path: Path2D): boolean } export interface StrokeOptions { width?: number miterLimit?: number cap?: StrokeCap join?: StrokeJoin } export interface SKRSContext2D extends CanvasRenderingContext2D { canvas: Canvas /** * @param startAngle The angle at which to begin the gradient, in radians. Angle measurements start vertically above the centre and move around clockwise. * @param x The x-axis coordinate of the centre of the gradient. * @param y The y-axis coordinate of the centre of the gradient. */ createConicGradient(startAngle: number, x: number, y: number): CanvasGradient drawImage(image: Image | Canvas, dx: number, dy: number): void drawImage(image: Image | Canvas, dx: number, dy: number, dw: number, dh: number): void drawImage( image: Image | Canvas, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number, ): void /** * Draw another canvas, preserving vector graphics when possible. * When the source canvas has recorded operations, this method preserves the * SkPicture representation without rasterization, which can be faster than * drawImage. Falls back to bitmap rendering if no picture is available. */ drawCanvas(canvas: Canvas, dx: number, dy: number): void drawCanvas(canvas: Canvas, dx: number, dy: number, dWidth: number, dHeight: number): void drawCanvas( canvas: Canvas, sx: number, sy: number, sWidth: number, sHeight: number, dx: number, dy: number, dWidth: number, dHeight: number, ): void createPattern( image: Image | ImageData | Canvas | SvgCanvas, repeat: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat' | null, ): CanvasPattern getContextAttributes(): { alpha: boolean; desynchronized: boolean } getTransform(): DOMMatrix letterSpacing: string wordSpacing: string } export type ColorSpace = 'srgb' | 'display-p3' export interface ContextAttributes { alpha?: boolean colorSpace?: ColorSpace } export interface SvgCanvas { width: number height: number getContext(contextType: '2d', contextAttributes?: ContextAttributes): SKRSContext2D getContent(): Buffer } export interface AvifConfig { /** 0-100 scale, 100 is lossless */ quality?: number /** 0-100 scale */ alphaQuality?: number /** rav1e preset 1 (slow) 10 (fast but crappy), default is 4 */ speed?: number /** How many threads should be used (0 = match core count) */ threads?: number /** set to '4:2:0' to use chroma subsampling, default '4:4:4' */ chromaSubsampling?: ChromaSubsampling } /** GIF encoding configuration for single-frame encoding */ export interface GifConfig { /** * Quality for NeuQuant color quantization (1-30, lower = slower but better quality) * @default 10 */ quality?: number } /** Configuration for the GIF encoder (animated GIFs) */ export interface GifEncoderConfig { /** * Loop count: 0 = infinite loop, positive number = finite loops * @default 0 (infinite) */ repeat?: number /** * Quality for NeuQuant color quantization (1-30, lower = slower but better quality) * @default 10 */ quality?: number } /** Configuration for individual GIF frames */ export interface GifFrameConfig { /** * Frame delay in milliseconds * @default 100 */ delay?: number /** Disposal method for this frame */ disposal?: GifDisposal /** Transparent color index (0-255), if the frame has transparency */ transparent?: number /** X offset of this frame within the canvas */ left?: number /** Y offset of this frame within the canvas */ top?: number } /** GIF frame disposal method */ export enum GifDisposal { /** Keep the frame visible (default) */ Keep = 0, /** Clear the frame area to the background color */ Background = 1, /** Restore to the previous frame */ Previous = 2, } /** * GIF Encoder for creating animated GIFs. * Implements `Disposable` interface for use with the `using` keyword (ES2024). * * @example * ```typescript * // Basic usage * const encoder = new GifEncoder(100, 100, { repeat: 0, quality: 10 }); * encoder.addFrame(rgbaData, 100, 100, { delay: 100 }); * encoder.addFrame(rgbaData2, 100, 100, { delay: 100 }); * const buffer = encoder.finish(); * * // With `using` keyword (automatic cleanup) * { * using encoder = new GifEncoder(100, 100); * encoder.addFrame(frame1, 100, 100, { delay: 100 }); * const buffer = encoder.finish(); * } // encoder automatically disposed * ``` */ export class GifEncoder implements Disposable { /** * Create a new GIF encoder with the specified dimensions * @param width - Width of the GIF canvas in pixels * @param height - Height of the GIF canvas in pixels * @param config - Optional encoder configuration */ constructor(width: number, height: number, config?: GifEncoderConfig) /** Width of the GIF canvas */ readonly width: number /** Height of the GIF canvas */ readonly height: number /** Number of frames added so far */ readonly frameCount: number /** * Add a frame from RGBA pixel data * @param data - RGBA pixel data (must be width * height * 4 bytes) * @param width - Width of the frame in pixels * @param height - Height of the frame in pixels * @param config - Optional frame configuration */ addFrame(data: Uint8Array, width: number, height: number, config?: GifFrameConfig): void /** * Finish encoding and return the GIF data. * Clears all accumulated frames after encoding. * @throws Error if no frames have been added */ finish(): Buffer /** * Dispose of the encoder, clearing all accumulated frames without encoding. * Called automatically when using the `using` keyword. */ dispose(): void /** * Symbol.dispose implementation for ES2024 Explicit Resource Management. * Allows using `using encoder = new GifEncoder(...)` syntax. */ [Symbol.dispose](): void } /** * https://en.wikipedia.org/wiki/Chroma_subsampling#Types_of_sampling_and_subsampling * https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_concepts */ export enum ChromaSubsampling { /** * Each of the three Y'CbCr components has the same sample rate, thus there is no chroma subsampling. This scheme is sometimes used in high-end film scanners and cinematic post-production. * Note that "4:4:4" may instead be wrongly referring to R'G'B' color space, which implicitly also does not have any chroma subsampling (except in JPEG R'G'B' can be subsampled). * Formats such as HDCAM SR can record 4:4:4 R'G'B' over dual-link HD-SDI. */ Yuv444 = 0, /** * The two chroma components are sampled at half the horizontal sample rate of luma: the horizontal chroma resolution is halved. This reduces the bandwidth of an uncompressed video signal by one-third. * Many high-end digital video formats and interfaces use this scheme: * - [AVC-Intra 100](https://en.wikipedia.org/wiki/AVC-Intra) * - [Digital Betacam](https://en.wikipedia.org/wiki/Betacam#Digital_Betacam) * - [Betacam SX](https://en.wikipedia.org/wiki/Betacam#Betacam_SX) * - [DVCPRO50](https://en.wikipedia.org/wiki/DV#DVCPRO) and [DVCPRO HD](https://en.wikipedia.org/wiki/DV#DVCPRO_HD) * - [Digital-S](https://en.wikipedia.org/wiki/Digital-S) * - [CCIR 601](https://en.wikipedia.org/wiki/Rec._601) / [Serial Digital Interface](https://en.wikipedia.org/wiki/Serial_digital_interface) / [D1](https://en.wikipedia.org/wiki/D-1_(Sony)) * - [ProRes (HQ, 422, LT, and Proxy)](https://en.wikipedia.org/wiki/Apple_ProRes) * - [XDCAM HD422](https://en.wikipedia.org/wiki/XDCAM) * - [Canon MXF HD422](https://en.wikipedia.org/wiki/Canon_XF-300) */ Yuv422 = 1, /** * n 4:2:0, the horizontal sampling is doubled compared to 4:1:1, * but as the **Cb** and **Cr** channels are only sampled on each alternate line in this scheme, the vertical resolution is halved. * The data rate is thus the same. * This fits reasonably well with the PAL color encoding system, since this has only half the vertical chrominance resolution of [NTSC](https://en.wikipedia.org/wiki/NTSC). * It would also fit extremely well with the [SECAM](https://en.wikipedia.org/wiki/SECAM) color encoding system, * since like that format, 4:2:0 only stores and transmits one color channel per line (the other channel being recovered from the previous line). * However, little equipment has actually been produced that outputs a SECAM analogue video signal. * In general, SECAM territories either have to use a PAL-capable display or a [transcoder](https://en.wikipedia.org/wiki/Transcoding) to convert the PAL signal to SECAM for display. */ Yuv420 = 2, /** * What if the chroma subsampling model is 4:0:0? * That says to use every pixel of luma data, but that each row has 0 chroma samples applied to it. The resulting image, then, is comprised solely of the luminance data—a greyscale image. */ Yuv400 = 3, } export interface ConvertToBlobOptions { mime?: string quality?: number } export class Canvas { constructor(width: number, height: number, flag?: SvgExportFlag) width: number height: number getContext(contextType: '2d', contextAttributes?: ContextAttributes): SKRSContext2D encodeSync(format: 'webp' | 'jpeg', quality?: number): Buffer encodeSync(format: 'png'): Buffer encodeSync(format: 'avif', cfg?: AvifConfig): Buffer encodeSync(format: 'gif', quality?: number): Buffer encode(format: 'webp' | 'jpeg', quality?: number): Promise encode(format: 'png'): Promise encode(format: 'avif', cfg?: AvifConfig): Promise encode(format: 'gif', quality?: number): Promise encodeStream(format: 'webp' | 'jpeg', quality?: number): ReadableStream encodeStream(format: 'png'): ReadableStream toBuffer(mime: 'image/png'): Buffer toBuffer(mime: 'image/jpeg' | 'image/webp', quality?: number): Buffer toBuffer(mime: 'image/avif', cfg?: AvifConfig): Buffer toBuffer(mime: 'image/gif', quality?: number): Buffer // raw pixels data(): Buffer toDataURL(mime?: 'image/png'): string toDataURL(mime: 'image/jpeg' | 'image/webp', quality?: number): string toDataURL(mime: 'image/gif', quality?: number): string toDataURL(mime?: 'image/jpeg' | 'image/webp' | 'image/png' | 'image/gif', quality?: number): string toDataURL(mime?: 'image/avif', cfg?: AvifConfig): string toDataURLAsync(mime?: 'image/png'): Promise toDataURLAsync(mime: 'image/jpeg' | 'image/webp', quality?: number): Promise toDataURLAsync(mime: 'image/gif', quality?: number): Promise toDataURLAsync(mime?: 'image/jpeg' | 'image/webp' | 'image/png' | 'image/gif', quality?: number): Promise toDataURLAsync(mime?: 'image/avif', cfg?: AvifConfig): Promise toBlob(callback: (blob: Blob | null) => void, mime?: string, quality?: number): void convertToBlob(options?: ConvertToBlobOptions): Promise } export function createCanvas(width: number, height: number): Canvas export function createCanvas(width: number, height: number, svgExportFlag: SvgExportFlag): SvgCanvas export declare class FontKey { // make it a unique type private readonly key: symbol readonly typefaceId: number } export interface FontVariationAxis { /** OpenType tag as a 32-bit integer (e.g., 0x77676874 for 'wght') */ tag: number /** Current value for this axis */ value: number /** Minimum value for this axis */ min: number /** Maximum value for this axis */ max: number /** Default value for this axis */ def: number /** Whether this axis should be hidden from UI */ hidden: boolean } interface IGlobalFonts { readonly families: { family: string; styles: { weight: number; width: string; style: string }[] }[] // return FontKey if succeeded, null if failed register(font: Buffer, nameAlias?: string): FontKey | null // absolute path - returns FontKey if succeeded, null if failed registerFromPath(path: string, nameAlias?: string): FontKey | null has(name: string): boolean loadFontsFromDir(path: string): number /** * Set an alias for a font family. * @param fontName The original font family name * @param alias The alias name to set * @returns true if the alias was set successfully, false if the font family doesn't exist */ setAlias(fontName: string, alias: string): boolean remove(key: FontKey): boolean /** * Remove multiple fonts by their keys in a single operation. * More efficient than calling remove() multiple times as it triggers only one rebuild. * @param fontKeys Array of FontKey objects to remove * @returns Number of fonts successfully removed */ removeBatch(fontKeys: FontKey[]): number /** * Remove ALL registered fonts. * @returns Number of fonts removed */ removeAll(): number /** * Get variation axes for a specific font instance * @param familyName The font family name * @param weight Font weight (100-900) * @param width Font width/stretch value * @param slant Font slant (0 = upright, 1 = italic, 2 = oblique) * @returns Array of variation axes or empty array if not a variable font */ getVariationAxes(familyName: string, weight: number, width: number, slant: number): FontVariationAxis[] /** * Check if a font has variable font capabilities * @param familyName The font family name * @param weight Font weight (100-900) * @param width Font width/stretch value * @param slant Font slant (0 = upright, 1 = italic, 2 = oblique) * @returns true if the font is a variable font */ hasVariations(familyName: string, weight: number, width: number, slant: number): boolean } export const GlobalFonts: IGlobalFonts export enum PathOp { Difference = 0, // subtract the op path from the first path Intersect = 1, // intersect the two paths Union = 2, // union (inclusive-or) the two paths Xor = 3, // exclusive-or the two paths ReverseDifference = 4, // subtract the first path from the op path } export enum FillType { Winding = 0, EvenOdd = 1, InverseWinding = 2, InverseEvenOdd = 3, } export enum StrokeJoin { Miter = 0, Round = 1, Bevel = 2, } export enum StrokeCap { Butt = 0, Round = 1, Square = 2, } export enum SvgExportFlag { ConvertTextToPaths = 0x01, NoPrettyXML = 0x02, RelativePathEncoding = 0x04, } export function convertSVGTextToPath(svg: Buffer | string): Buffer export interface LoadImageOptions { alt?: string maxRedirects?: number requestOptions?: import('http').RequestOptions } export function loadImage( source: string | URL | Buffer | ArrayBufferLike | Uint8Array | Image | import('stream').Readable, options?: LoadImageOptions, ): Promise export interface PDFMetadata { /// The document's title title?: string /// The name of the person who created the document author?: string /// The subject of the document subject?: string /// Keywords associated with the document keywords?: string /// The product that created the original document creator?: string /// The product that is converting this document to PDF (defaults to "Skia/PDF") producer?: string /// The DPI for rasterization (default: 72.0) rasterDPI?: number /// Encoding quality: 0-100 for lossy JPEG, 101 for lossless (default: 101) encodingQuality?: number /// Whether to conform to PDF/A-2b standard (default: false) pdfa?: boolean /// Compression level: -1 (default), 0 (none), 1 (low/fast), 6 (average), 9 (high/slow) compressionLevel?: number } export interface Rect { left: number top: number right: number bottom: number } export declare class PDFDocument { constructor(metadata?: PDFMetadata | undefined | null) beginPage(width: number, height: number, rect?: Rect | undefined | null): CanvasRenderingContext2D endPage(): void close(): Buffer } export interface LottieAnimationOptions { /** Base path for resolving external resources (images, fonts) */ resourcePath?: string } export interface LottieRenderRect { x: number y: number width: number height: number } /** * Lottie animation class for loading and rendering Lottie JSON files. * * @example * ```typescript * import { LottieAnimation, createCanvas } from '@napi-rs/canvas' * * const animation = LottieAnimation.loadFromFile('./animation.json') * const canvas = createCanvas(animation.width, animation.height) * const ctx = canvas.getContext('2d') * * // Render frame 0 * animation.seekFrame(0) * animation.render(ctx) * * // Save to PNG * const buffer = canvas.toBuffer('image/png') * ``` */ export declare class LottieAnimation { /** * Load animation from JSON string or Buffer * @param data - JSON string or Buffer containing Lottie animation data * @param options - Optional configuration */ static loadFromData(data: string | Buffer, options?: LottieAnimationOptions): LottieAnimation /** * Load animation from file path * External assets are resolved relative to the file's directory * @param path - Path to the Lottie JSON file */ static loadFromFile(path: string): LottieAnimation /** Animation duration in seconds */ readonly duration: number /** Frame rate (frames per second) */ readonly fps: number /** Total frame count */ readonly frames: number /** Animation width in pixels */ readonly width: number /** Animation height in pixels */ readonly height: number /** Lottie format version string */ readonly version: string /** Animation in-point (start frame) */ readonly inPoint: number /** Animation out-point (end frame) */ readonly outPoint: number /** * Seek to normalized position * @param t - Position between 0.0 (start) and 1.0 (end) */ seek(t: number): void /** * Seek to specific frame index * @param frame - Frame index (0 = first frame) */ seekFrame(frame: number): void /** * Seek to specific time in seconds * @param seconds - Time in seconds from start */ seekTime(seconds: number): void /** * Render current frame to canvas context * @param ctx - Canvas 2D rendering context * @param dst - Optional destination rectangle for scaling/positioning */ render(ctx: CanvasRenderingContext2D, dst?: LottieRenderRect): void }