@napi-rs/canvas 0.1.91 → 0.1.93

package/README.md

@@ -1,7 +1,7 @@
 # `skr canvas`
 
 [![CI](https://github.com/Brooooooklyn/canvas/actions/workflows/CI.yaml/badge.svg)](https://github.com/Brooooooklyn/canvas/actions/workflows/CI.yaml)
-![Skia Version](https://img.shields.io/badge/Skia-chrome%2Fm144-hotpink)
+![Skia Version](https://img.shields.io/badge/Skia-chrome%2Fm146-hotpink)
 [![install size](https://packagephobia.com/badge?p=@napi-rs/canvas)](https://packagephobia.com/result?p=@napi-rs/canvas)
 [![Downloads](https://img.shields.io/npm/dm/@napi-rs/canvas.svg?sanitize=true)](https://npmcharts.com/compare/@napi-rs/canvas?minimal=true)
 

package/node-canvas.d.ts

@@ -0,0 +1,216 @@
+/**
+ * node-canvas compatibility layer for @napi-rs/canvas.
+ *
+ * Provides a drop-in replacement API matching the `canvas` (node-canvas) npm package.
+ * Quality values for JPEG/WebP use the node-canvas 0-1 scale and are automatically
+ * converted to @napi-rs/canvas's 0-100 scale internally.
+ *
+ * @example
+ * ```typescript
+ * // Drop-in replacement: change this import
+ * // import { createCanvas, registerFont, loadImage } from 'canvas'
+ * // to this:
+ * import { createCanvas, registerFont, loadImage } from '@napi-rs/canvas/node-canvas'
+ * ```
+ */
+
+import { Readable } from 'node:stream'
+
+// Re-export types from @napi-rs/canvas that are API-compatible
+import {
+  Image as NapiImage,
+  ImageData as NapiImageData,
+  Path2D as NapiPath2D,
+  DOMPoint as NapiDOMPoint,
+  DOMMatrix as NapiDOMMatrix,
+  DOMRect as NapiDOMRect,
+  SKRSContext2D,
+  Canvas as NapiCanvas,
+  SvgCanvas,
+  SvgExportFlag,
+  IGlobalFonts,
+  PDFDocument,
+} from './index'
+
+// ---------------------------------------------------------------------------
+// Config interfaces (node-canvas conventions)
+// ---------------------------------------------------------------------------
+
+export interface PngConfig {
+  /** ZLIB compression level (0-9). Accepted for compatibility; Skia uses its own encoder. */
+  compressionLevel?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+  /** PNG filter flags. Accepted for compatibility; Skia uses its own encoder. */
+  filters?: number
+  /** Palette for indexed PNGs. Not supported by Skia backend. */
+  palette?: Uint8ClampedArray
+  /** Background color index for indexed PNGs. Not supported by Skia backend. */
+  backgroundIndex?: number
+  /** Pixels per inch. Accepted for compatibility. */
+  resolution?: number
+}
+
+export interface JpegConfig {
+  /** Quality between 0 and 1. Defaults to 0.75. Converted to 0-100 for Skia. */
+  quality?: number
+  /** Progressive encoding. Accepted for compatibility; not supported by Skia backend. */
+  progressive?: boolean
+  /** 2x2 chroma subsampling. Accepted for compatibility; not supported by Skia backend. */
+  chromaSubsampling?: boolean
+}
+
+// ---------------------------------------------------------------------------
+// Canvas class (with node-canvas compatible methods)
+// ---------------------------------------------------------------------------
+
+export interface Canvas extends Omit<NapiCanvas, 'toBuffer' | 'toDataURL'> {
+  /**
+   * Encode the canvas as a PNG and return a Node.js Readable stream.
+   * @param config PNG encoding options (accepted for compatibility)
+   */
+  createPNGStream(config?: PngConfig): PNGStream
+
+  /**
+   * Encode the canvas as a JPEG and return a Node.js Readable stream.
+   * @param config JPEG encoding options. Quality is 0-1 (default 0.75).
+   */
+  createJPEGStream(config?: JpegConfig): JPEGStream
+
+  // --- toBuffer overloads (node-canvas conventions) ---
+
+  /** Encode as PNG (default). */
+  toBuffer(): Buffer
+  toBuffer(mimeType: 'image/png', config?: PngConfig): Buffer
+  /** Encode as JPEG. Quality in config is 0-1 (default 0.75). */
+  toBuffer(mimeType: 'image/jpeg', config?: JpegConfig): Buffer
+  /** Get raw unencoded pixel data. */
+  toBuffer(mimeType: 'raw'): Buffer
+
+  /** Async: encode as PNG (default) via callback. */
+  toBuffer(cb: (err: Error | null, result: Buffer) => void): void
+  toBuffer(cb: (err: Error | null, result: Buffer) => void, mimeType: 'image/png', config?: PngConfig): void
+  /** Async: encode as JPEG via callback. Quality in config is 0-1 (default 0.75). */
+  toBuffer(cb: (err: Error | null, result: Buffer) => void, mimeType: 'image/jpeg', config?: JpegConfig): void
+
+  // --- toDataURL overloads (node-canvas conventions) ---
+
+  /** Encode as PNG data URL (default). */
+  toDataURL(): string
+  toDataURL(mimeType: 'image/png'): string
+  /** Encode as JPEG data URL. Quality is 0-1. */
+  toDataURL(mimeType: 'image/jpeg', quality?: number): string
+  /** Async: encode as data URL via callback. */
+  toDataURL(cb: (err: Error | null, result: string) => void): void
+  toDataURL(mimeType: 'image/png', cb: (err: Error | null, result: string) => void): void
+  toDataURL(mimeType: 'image/jpeg', cb: (err: Error | null, result: string) => void): void
+  toDataURL(mimeType: 'image/jpeg', quality: number, cb: (err: Error | null, result: string) => void): void
+}
+
+// ---------------------------------------------------------------------------
+// Stream classes
+// ---------------------------------------------------------------------------
+
+/** Readable stream that emits PNG-encoded data. */
+export class PNGStream extends Readable {}
+
+/** Readable stream that emits JPEG-encoded data. */
+export class JPEGStream extends Readable {}
+
+// ---------------------------------------------------------------------------
+// Factory functions
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a new canvas with node-canvas compatible API.
+ * Canvas instances created through this function have `createPNGStream()`,
+ * `createJPEGStream()`, and node-canvas compatible `toBuffer()` overloads.
+ *
+ * When `type` is `'svg'`, returns a `SvgCanvas` which produces vector output
+ * via `getContent()` instead of raster encoding methods.
+ *
+ * @param width  Canvas width in pixels
+ * @param height Canvas height in pixels
+ * @param type   Canvas type: 'image' (default) or 'svg'
+ */
+export function createCanvas(width: number, height: number, type: 'svg'): SvgCanvas
+export function createCanvas(width: number, height: number, type?: 'image'): Canvas
+
+/**
+ * Create an ImageData instance.
+ * @param data   Pixel data array
+ * @param width  Width in pixels
+ * @param height Height in pixels (calculated from data length if omitted)
+ */
+export function createImageData(data: Uint8ClampedArray, width: number, height?: number): NapiImageData
+export function createImageData(width: number, height: number): NapiImageData
+
+/**
+ * Load an image from a file path, URL, Buffer, or other source.
+ * Returns a Promise that resolves to an Image instance.
+ */
+export function loadImage(
+  source: string | URL | Buffer | ArrayBufferLike | Uint8Array | NapiImage | import('stream').Readable,
+  options?: { alt?: string; maxRedirects?: number; requestOptions?: import('http').RequestOptions },
+): Promise<NapiImage>
+
+// ---------------------------------------------------------------------------
+// Font registration (node-canvas convention)
+// ---------------------------------------------------------------------------
+
+/**
+ * Register a font file for use in canvas text rendering.
+ * Compatible with node-canvas's `registerFont()`.
+ *
+ * Note: @napi-rs/canvas auto-detects weight and style from font file metadata
+ * (matching browser behavior). The `weight` and `style` properties in fontFace
+ * are accepted for API compatibility.
+ *
+ * @param path     Absolute path to the font file (.ttf, .otf, etc.)
+ * @param fontFace Font face properties matching CSS @font-face descriptors
+ */
+export function registerFont(path: string, fontFace: { family: string; weight?: string; style?: string }): void
+
+/**
+ * Deregister all previously registered fonts.
+ * Compatible with node-canvas's `deregisterAllFonts()`.
+ */
+export function deregisterAllFonts(): void
+
+// ---------------------------------------------------------------------------
+// Re-exported classes & values
+// ---------------------------------------------------------------------------
+
+// Canvas is exported both as a type (the compat interface above) and as a
+// value (constructor that returns compat Canvas instances at runtime).
+export declare const Canvas: {
+  new (width: number, height: number): Canvas
+  new (width: number, height: number, flag: SvgExportFlag): SvgCanvas
+  prototype: NapiCanvas
+}
+
+export { NapiImage as Image }
+export { NapiImageData as ImageData }
+export { NapiPath2D as Path2D }
+export { NapiDOMPoint as DOMPoint }
+export { NapiDOMMatrix as DOMMatrix }
+export { NapiDOMRect as DOMRect }
+
+// SKRSContext2D is an interface in index.d.ts but a class value at runtime.
+// Declare as const to export the value for instanceof checks and re-export the type.
+export type CanvasRenderingContext2D = SKRSContext2D
+export declare const CanvasRenderingContext2D: { prototype: SKRSContext2D }
+/** Legacy alias for CanvasRenderingContext2D. */
+export type Context2d = SKRSContext2D
+export declare const Context2d: { prototype: SKRSContext2D }
+
+// ---------------------------------------------------------------------------
+// @napi-rs/canvas extras (not part of node-canvas, but useful)
+// ---------------------------------------------------------------------------
+
+export { IGlobalFonts }
+export declare const GlobalFonts: IGlobalFonts & {
+  /** Reload system fonts. Available at runtime but not declared in IGlobalFonts. */
+  loadSystemFonts(): number
+}
+export { PDFDocument }
+export { NapiCanvas as CanvasElement }
+export { SvgCanvas as SVGCanvas }

package/node-canvas.js

@@ -0,0 +1,379 @@
+'use strict'
+
+const { Readable } = require('node:stream')
+
+const {
+  createCanvas: _createCanvas,
+  Canvas,
+  CanvasElement,
+  SVGCanvas,
+  GlobalFonts,
+  Image,
+  ImageData,
+  Path2D,
+  DOMPoint,
+  DOMMatrix,
+  DOMRect,
+  loadImage,
+  PDFDocument,
+  SvgExportFlag,
+} = require('./index.js')
+
+// CanvasRenderingContext2D is not re-exported by index.js, grab from native bindings
+const { CanvasRenderingContext2D } = require('./js-binding')
+
+// node-canvas defaults JPEG quality to 0.75 across all paths.
+// @napi-rs/canvas native default is 0.92 (matching Blink/Chrome).
+const NODE_CANVAS_DEFAULT_QUALITY = 0.75
+
+// ---------------------------------------------------------------------------
+// Stream classes (node-canvas returns Node.js Readable streams)
+// ---------------------------------------------------------------------------
+
+class PNGStream extends Readable {
+  constructor(canvas, options) {
+    super()
+    this._canvas = canvas
+    this._options = options || {}
+    this._done = false
+  }
+
+  _read() {
+    if (this._done) return
+    this._done = true
+    this._canvas
+      .encode('png')
+      .then((buf) => {
+        this.push(buf)
+        this.push(null)
+      })
+      .catch((err) => {
+        this.destroy(err)
+      })
+  }
+}
+
+class JPEGStream extends Readable {
+  constructor(canvas, options) {
+    super()
+    this._canvas = canvas
+    const opts = options || {}
+    // node-canvas quality: 0-1 (default 0.75), encode() expects 0-100
+    this._quality = Math.round((opts.quality != null ? opts.quality : NODE_CANVAS_DEFAULT_QUALITY) * 100)
+    this._done = false
+  }
+
+  _read() {
+    if (this._done) return
+    this._done = true
+    this._canvas
+      .encode('jpeg', this._quality)
+      .then((buf) => {
+        this.push(buf)
+        this.push(null)
+      })
+      .catch((err) => {
+        this.destroy(err)
+      })
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Quality normalization helpers
+// ---------------------------------------------------------------------------
+
+const MIME_FORMAT_MAP = {
+  'image/png': 'png',
+  'image/jpeg': 'jpeg',
+  'image/webp': 'webp',
+  'image/avif': 'avif',
+  'image/gif': 'gif',
+}
+
+/**
+ * Extract quality from a node-canvas config object or number.
+ * Returns the raw 0-1 quality value, defaulting to NODE_CANVAS_DEFAULT_QUALITY
+ * for JPEG/WebP when not specified.
+ *
+ * @param {string} mime
+ * @param {number|object|undefined} configOrQuality
+ * @returns {number|undefined}  0-1 scale for JPEG/WebP, undefined for other mimes
+ */
+function _extractQuality(mime, configOrQuality) {
+  if (mime !== 'image/jpeg' && mime !== 'image/webp') return undefined
+  if (configOrQuality == null) return NODE_CANVAS_DEFAULT_QUALITY
+  if (typeof configOrQuality === 'number') return configOrQuality
+  if (typeof configOrQuality === 'object' && configOrQuality.quality != null) {
+    return configOrQuality.quality
+  }
+  return NODE_CANVAS_DEFAULT_QUALITY
+}
+
+// ---------------------------------------------------------------------------
+// Compat methods added to each canvas instance created via this module
+// ---------------------------------------------------------------------------
+
+// Keep references to the original prototype methods
+const _origToBuffer = CanvasElement.prototype.toBuffer
+const _origToDataURL = CanvasElement.prototype.toDataURL
+
+function _compatCreatePNGStream(options) {
+  return new PNGStream(this, options)
+}
+
+function _compatCreateJPEGStream(options) {
+  return new JPEGStream(this, options)
+}
+
+/**
+ * node-canvas compatible toBuffer:
+ * - toBuffer()                           → PNG (sync)
+ * - toBuffer('image/png', config?)       → PNG (sync)
+ * - toBuffer('image/jpeg', config?)      → JPEG (sync, quality 0-1)
+ * - toBuffer('raw')                      → raw pixel data (sync)
+ * - toBuffer(callback)                   → PNG (async)
+ * - toBuffer(callback, mime, config?)    → specified format (async)
+ */
+function _compatToBuffer(mimeOrCallback, configOrQuality) {
+  // Callback form: toBuffer(callback) or toBuffer(callback, mime, config)
+  if (typeof mimeOrCallback === 'function') {
+    const callback = mimeOrCallback
+    const mime = typeof configOrQuality === 'string' ? configOrQuality : 'image/png'
+    const config = arguments[2]
+
+    if (mime === 'raw') {
+      let buf
+      try {
+        buf = this.data()
+      } catch (err) {
+        callback(err)
+        return
+      }
+      callback(null, buf)
+      return
+    }
+
+    const format = MIME_FORMAT_MAP[mime]
+    if (!format) {
+      callback(new TypeError(`Unsupported MIME type "${mime}". Supported: ${Object.keys(MIME_FORMAT_MAP).join(', ')}`))
+      return
+    }
+    const q = _extractQuality(mime, config)
+    this.encode(format, q != null ? Math.round(q * 100) : undefined).then(
+      (buf) => callback(null, buf),
+      (err) => callback(err),
+    )
+    return
+  }
+
+  // Sync: no args → PNG
+  if (mimeOrCallback === undefined) {
+    return _origToBuffer.call(this, 'image/png')
+  }
+
+  // Sync: raw pixel data
+  if (mimeOrCallback === 'raw') {
+    return this.data()
+  }
+
+  // Sync: extract quality (0-1) and scale to 0-100 for native toBuffer
+  const q = _extractQuality(mimeOrCallback, configOrQuality)
+  return _origToBuffer.call(this, mimeOrCallback, q != null ? Math.round(q * 100) : undefined)
+}
+
+/**
+ * node-canvas compatible toDataURL:
+ * - toDataURL()                              → PNG data URL (sync)
+ * - toDataURL('image/jpeg', quality)         → JPEG data URL, quality 0-1 (sync)
+ * - toDataURL(callback)                      → PNG data URL (async)
+ * - toDataURL(mime, callback)                → data URL (async)
+ * - toDataURL(mime, quality, callback)       → data URL with quality (async)
+ */
+function _compatToDataURL(mimeOrCallback, qualityOrCallback) {
+  // toDataURL(callback)
+  if (typeof mimeOrCallback === 'function') {
+    this.toDataURLAsync('image/png').then(
+      (url) => mimeOrCallback(null, url),
+      (err) => mimeOrCallback(err),
+    )
+    return
+  }
+  // toDataURL(mime, callback)
+  if (typeof qualityOrCallback === 'function') {
+    this.toDataURLAsync(mimeOrCallback, _extractQuality(mimeOrCallback, undefined)).then(
+      (url) => qualityOrCallback(null, url),
+      (err) => qualityOrCallback(err),
+    )
+    return
+  }
+  // toDataURL(mime, quality, callback)
+  const cb = arguments[2]
+  if (typeof cb === 'function') {
+    // Native toDataURLAsync expects 0-1 (f64) — pass quality through as-is
+    const quality = _extractQuality(mimeOrCallback, qualityOrCallback)
+    this.toDataURLAsync(mimeOrCallback, quality).then(
+      (url) => cb(null, url),
+      (err) => cb(err),
+    )
+    return
+  }
+
+  // Sync form: native toDataURL expects 0-1 (f64) — pass quality through as-is
+  const quality = _extractQuality(mimeOrCallback, qualityOrCallback)
+  return _origToDataURL.call(this, mimeOrCallback, quality)
+}
+
+/**
+ * Attach node-canvas compatible methods to a CanvasElement instance.
+ */
+function _addCompatMethods(canvas) {
+  canvas.createPNGStream = _compatCreatePNGStream
+  canvas.createJPEGStream = _compatCreateJPEGStream
+  canvas.toBuffer = _compatToBuffer
+  canvas.toDataURL = _compatToDataURL
+  return canvas
+}
+
+// ---------------------------------------------------------------------------
+// Public API: registerFont / deregisterAllFonts
+// ---------------------------------------------------------------------------
+
+// Track FontKeys from registerFont() so deregisterAllFonts() can remove
+// only user-registered fonts (matching node-canvas behavior which leaves
+// system fonts untouched).
+const _registeredFontKeys = []
+
+/**
+ * Register a font file with the specified font face properties.
+ * Compatible with node-canvas's registerFont(path, { family, weight?, style? }).
+ *
+ * Note: @napi-rs/canvas auto-detects weight and style from font file metadata
+ * (matching browser behavior). The weight and style properties in fontFace are
+ * accepted for API compatibility but the actual values are read from the font.
+ *
+ * @param {string} path   Absolute path to the font file (.ttf, .otf, etc.)
+ * @param {{ family: string, weight?: string, style?: string }} fontFace
+ */
+function registerFont(path, fontFace) {
+  if (!fontFace || typeof fontFace.family !== 'string') {
+    throw new TypeError('registerFont requires a fontFace with a "family" property')
+  }
+  const key = GlobalFonts.registerFromPath(path, fontFace.family)
+  if (!key) {
+    throw new Error(`Failed to register font from "${path}" with family "${fontFace.family}"`)
+  }
+  _registeredFontKeys.push(key)
+}
+
+/**
+ * Deregister all fonts previously registered via registerFont().
+ * Compatible with node-canvas's deregisterAllFonts() which only removes
+ * user-registered fonts and leaves system fonts untouched.
+ */
+function deregisterAllFonts() {
+  if (_registeredFontKeys.length > 0) {
+    GlobalFonts.removeBatch(_registeredFontKeys)
+    _registeredFontKeys.length = 0
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API: createCanvas / createImageData
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a new canvas instance with node-canvas compatible API.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {'image'|'svg'} [type='image']
+ * @returns {Canvas}
+ */
+function createCanvas(width, height, type) {
+  if (type === 'svg') {
+    // SvgExportFlag enum requires a valid variant; NoPrettyXML (0x02) is the
+    // least impactful on rendering behavior (only affects XML whitespace).
+    return _createCanvas(width, height, SvgExportFlag.NoPrettyXML)
+  }
+  if (type === 'pdf') {
+    throw new Error(
+      'createCanvas with type "pdf" is not supported. Use the PDFDocument class from @napi-rs/canvas directly.',
+    )
+  }
+  if (type != null && type !== 'image') {
+    throw new TypeError(`createCanvas: unknown type "${type}". Supported types: "image", "svg".`)
+  }
+  return _addCompatMethods(_createCanvas(width, height))
+}
+
+/**
+ * Create an ImageData instance.
+ * Compatible with node-canvas's createImageData().
+ *
+ * @param {Uint8ClampedArray|number} dataOrWidth
+ * @param {number} widthOrHeight
+ * @param {number} [height]
+ * @returns {ImageData}
+ */
+function createImageData(dataOrWidth, widthOrHeight, height) {
+  if (typeof dataOrWidth === 'number') {
+    return new ImageData(dataOrWidth, widthOrHeight)
+  }
+  if (height != null) {
+    return new ImageData(dataOrWidth, widthOrHeight, height)
+  }
+  return new ImageData(dataOrWidth, widthOrHeight)
+}
+
+// ---------------------------------------------------------------------------
+// Canvas constructor wrapper
+// ---------------------------------------------------------------------------
+
+// In node-canvas, `new Canvas(w, h)` and `createCanvas(w, h)` produce
+// equivalent canvases. Wrap the native Canvas constructor so that
+// `new Canvas(w, h)` also gets compat methods, without polluting the
+// prototype (which would affect @napi-rs/canvas users who don't use
+// this compat layer).
+const CompatCanvas = new Proxy(Canvas, {
+  construct(target, args) {
+    const canvas = new target(...args)
+    if (canvas instanceof CanvasElement) {
+      return _addCompatMethods(canvas)
+    }
+    return canvas
+  },
+})
+
+// ---------------------------------------------------------------------------
+// Exports (matches node-canvas export shape)
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  // Factory functions
+  Canvas: CompatCanvas,
+  createCanvas,
+  createImageData,
+  loadImage,
+  registerFont,
+  deregisterAllFonts,
+
+  // Classes
+  Image,
+  ImageData,
+  CanvasRenderingContext2D,
+  Context2d: CanvasRenderingContext2D,
+  PNGStream,
+  JPEGStream,
+  Path2D,
+
+  // Geometry
+  DOMPoint,
+  DOMMatrix,
+  DOMRect,
+
+  // @napi-rs/canvas extras (available but not part of node-canvas)
+  GlobalFonts,
+  PDFDocument,
+  CanvasElement,
+  SVGCanvas,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@napi-rs/canvas",
-  "version": "0.1.91",
+  "version": "0.1.93",
   "description": "Canvas for Node.js with skia backend",
   "main": "index.js",
   "repository": {
@@ -29,7 +29,9 @@
     "index.js",
     "geometry.js",
     "js-binding.js",
-    "load-image.js"
+    "load-image.js",
+    "node-canvas.js",
+    "node-canvas.d.ts"
   ],
   "napi": {
     "binaryName": "skia",
@@ -99,6 +101,7 @@
     "lodash": "^4.17.21",
     "npm-run-all2": "^8.0.4",
     "oxlint": "^1.34.0",
+    "oxlint-tsgolint": "^0.14.0",
     "pinst": "^3.0.0",
     "png.js": "^0.2.1",
     "prettier": "^3.7.4",
@@ -150,16 +153,16 @@
   },
   "packageManager": "yarn@4.12.0",
   "optionalDependencies": {
-    "@napi-rs/canvas-linux-x64-gnu": "0.1.91",
-    "@napi-rs/canvas-darwin-x64": "0.1.91",
-    "@napi-rs/canvas-win32-x64-msvc": "0.1.91",
-    "@napi-rs/canvas-win32-arm64-msvc": "0.1.91",
-    "@napi-rs/canvas-linux-arm-gnueabihf": "0.1.91",
-    "@napi-rs/canvas-linux-x64-musl": "0.1.91",
-    "@napi-rs/canvas-linux-arm64-gnu": "0.1.91",
-    "@napi-rs/canvas-linux-arm64-musl": "0.1.91",
-    "@napi-rs/canvas-darwin-arm64": "0.1.91",
-    "@napi-rs/canvas-android-arm64": "0.1.91",
-    "@napi-rs/canvas-linux-riscv64-gnu": "0.1.91"
+    "@napi-rs/canvas-linux-x64-gnu": "0.1.93",
+    "@napi-rs/canvas-darwin-x64": "0.1.93",
+    "@napi-rs/canvas-win32-x64-msvc": "0.1.93",
+    "@napi-rs/canvas-win32-arm64-msvc": "0.1.93",
+    "@napi-rs/canvas-linux-arm-gnueabihf": "0.1.93",
+    "@napi-rs/canvas-linux-x64-musl": "0.1.93",
+    "@napi-rs/canvas-linux-arm64-gnu": "0.1.93",
+    "@napi-rs/canvas-linux-arm64-musl": "0.1.93",
+    "@napi-rs/canvas-darwin-arm64": "0.1.93",
+    "@napi-rs/canvas-android-arm64": "0.1.93",
+    "@napi-rs/canvas-linux-riscv64-gnu": "0.1.93"
   }
 }