@napi-rs/canvas1.2.028.7 kB
const { platform, homedir } = require('os')
const { join } = require('path')
const {
clearAllCache,
CanvasRenderingContext2D,
CanvasElement,
CanvasGradient,
CanvasPattern,
SVGCanvas,
Path: Path2D,
ImageData: NativeImageData,
Image,
FontKey,
GlobalFonts,
PathOp,
FillType,
StrokeJoin,
StrokeCap,
convertSVGTextToPath,
PdfDocument,
GifEncoder,
GifDisposal,
LottieAnimation,
TextMetrics,
_argumentCounts,
_imageDataConstructor,
_toNumber: toNumber,
setTextRenderer,
getTextRenderer,
} = require('./js-binding')
const { DOMPoint, DOMMatrix, DOMRect } = require('./geometry')
const loadImage = require('./load-image')
// Add Symbol.dispose support for GifEncoder (ECMAScript 2024 Explicit Resource Management)
if (GifEncoder && typeof Symbol.dispose !== 'undefined') {
GifEncoder.prototype[Symbol.dispose] = function () {
this.dispose()
}
}
// napi-rs defines a class's accessors in name order. Chrome's TextMetrics
// prototype has them in IDL order (text_metrics.idl), which for...in shows,
// then the constructor: define them again in that order.
for (const name of [
'width',
'actualBoundingBoxLeft',
'actualBoundingBoxRight',
'fontBoundingBoxAscent',
'fontBoundingBoxDescent',
'actualBoundingBoxAscent',
'actualBoundingBoxDescent',
'hangingBaseline',
'alphabeticBaseline',
'ideographicBaseline',
'emHeightAscent',
'emHeightDescent',
'constructor',
]) {
const descriptor = Object.getOwnPropertyDescriptor(TextMetrics.prototype, name)
delete TextMetrics.prototype[name]
Object.defineProperty(TextMetrics.prototype, name, descriptor)
}
// Chrome's Symbol.toStringTag, an own property of each prototype. The
// canvas and Image classes take their HTML element names; SVGCanvas has no
// counterpart and no tag.
for (const [Class, tag] of [
[CanvasRenderingContext2D, 'CanvasRenderingContext2D'],
[CanvasGradient, 'CanvasGradient'],
[CanvasPattern, 'CanvasPattern'],
[Path2D, 'Path2D'],
[NativeImageData, 'ImageData'],
[TextMetrics, 'TextMetrics'],
[CanvasElement, 'HTMLCanvasElement'],
[Image, 'HTMLImageElement'],
]) {
Object.defineProperty(Class.prototype, Symbol.toStringTag, { value: tag, configurable: true })
}
const SvgExportFlag = {
ConvertTextToPaths: 0x01,
NoPrettyXML: 0x02,
RelativePathEncoding: 0x04,
}
const PngFilter = {
None: 0x08,
Sub: 0x10,
Up: 0x20,
Avg: 0x40,
Paeth: 0x80,
All: 0xf8,
}
if (!('families' in GlobalFonts)) {
Object.defineProperty(GlobalFonts, 'families', {
get: function () {
return JSON.parse(GlobalFonts.getFamilies().toString())
},
})
}
if (!('has' in GlobalFonts)) {
Object.defineProperty(GlobalFonts, 'has', {
value: function has(name) {
return !!JSON.parse(GlobalFonts.getFamilies().toString()).find(({ family }) => family === name)
},
configurable: false,
enumerable: false,
writable: false,
})
}
// Re-evaluating this module (Jest resets its module registry per test
// file; the .node binding and its prototypes stay loaded) must wrap the
// native methods again, not the previous wrappers: their argument padding
// would corrupt the argument count the native methods read.
const NATIVE_METHODS = Symbol.for('@napi-rs/canvas:native-methods')
function nativeMethods(proto) {
let stash = proto[NATIVE_METHODS]
if (stash === undefined) {
stash = {}
Object.defineProperty(proto, NATIVE_METHODS, { value: stash })
}
return stash
}
const canvasNative = nativeMethods(CanvasElement.prototype)
const _toBlob = (canvasNative.toBlob ??= CanvasElement.prototype.toBlob)
const _convertToBlob = (canvasNative.convertToBlob ??= CanvasElement.prototype.convertToBlob)
// A native method of CanvasElement for the receiver check: with no arguments
// it has no side effects.
const canvasBrand = (canvasNative.getContext ??= CanvasElement.prototype.getContext)
if ('Blob' in globalThis) {
// toBlob(callback, type, quality), as Chrome: the receiver, the argument
// count and the callback are checked first, then the native method converts
// the type and encodes. The callback gets the Blob, or null without pixels
// or when the encoder fails, from a task. A throw in it is an uncaught
// exception, as in Chrome (window.onerror).
CanvasElement.prototype.toBlob = function toBlob(callback) {
if (arguments.length < 1) {
argumentCountError(canvasBrand, this, 'toBlob', 'HTMLCanvasElement', 1, 0)
}
if (typeof callback !== 'function') {
bindingTypeError(canvasBrand, this, 'toBlob', 'HTMLCanvasElement', "parameter 1 is not of type 'Function'.")
}
// Only the arguments that were passed: past arguments.length,
// arguments[i] reads Object.prototype[i], which Chrome never reads.
const type = arguments.length > 1 ? arguments[1] : undefined
const quality = arguments.length > 2 ? arguments[2] : undefined
_toBlob.call(this, type, quality).then(
(result) => {
const blob = result === null ? null : new Blob([result.data], { type: result.type })
queueMicrotask(() => callback(blob))
},
() => queueMicrotask(() => callback(null)),
)
}
// convertToBlob(options): Chrome's OffscreenCanvas method. An options error
// rejects the promise, as a WebIDL conversion error of a promise method.
CanvasElement.prototype.convertToBlob = function convertToBlob() {
let pending
try {
pending = _convertToBlob.call(this, arguments.length > 0 ? arguments[0] : undefined)
} catch (error) {
return Promise.reject(error)
}
return pending.then((result) => new Blob([result.data], { type: result.type }))
}
} else {
// oxlint-disable-next-line no-unused-vars
CanvasElement.prototype.toBlob = function toBlob(callback, mimeType, quality) {
callback(null)
}
// oxlint-disable-next-line no-unused-vars
CanvasElement.prototype.convertToBlob = function convertToBlob(options) {
return Promise.reject(new Error('Blob is not supported in this environment'))
}
}
const ctxNative = nativeMethods(CanvasRenderingContext2D.prototype)
const _getTransform = (ctxNative.getTransform ??= CanvasRenderingContext2D.prototype.getTransform)
CanvasRenderingContext2D.prototype.getTransform = function getTransform() {
const transform = _getTransform.apply(this, arguments)
// monkey patched, skip
if (transform instanceof DOMMatrix) {
return transform
}
const { a, b, c, d, e, f } = transform
return new DOMMatrix([a, b, c, d, e, f])
}
// Chrome checks the receiver ('Illegal invocation'), then the argument count,
// before it converts any argument. `brand` is a native method of the class: a
// call on another receiver throws 'Illegal invocation'. As Blink's binding
// errors, the stack keeps the bare message and `message` gets the prefix, as
// an enumerable own property.
function argumentCountError(brand, self, method, iface, required, present) {
brand.call(self)
const message = `${required} argument${required === 1 ? '' : 's'} required, but only ${present} present.`
const error = new TypeError(message)
void error.stack
Object.defineProperty(error, 'message', {
value: `Failed to execute '${method}' on '${iface}': ${message}`,
writable: true,
enumerable: true,
configurable: true,
})
throw error
}
// A TypeError as Blink's bindings throw it after the receiver check, with the
// message formatted as argumentCountError does.
function bindingTypeError(brand, self, method, iface, message) {
brand.call(self)
const error = new TypeError(message)
void error.stack
Object.defineProperty(error, 'message', {
value: `Failed to execute '${method}' on '${iface}': ${message}`,
writable: true,
enumerable: true,
configurable: true,
})
throw error
}
// Wraps `proto[method]` with Chrome's argument count check; the wrapper's
// `length` is the required argument count, as Chrome's Function.length.
// napi pads missing arguments with undefined, so the native method cannot
// tell f(1) from f(1, undefined); an explicit undefined counts in Chrome.
function requireArguments(proto, brand, iface, method, required) {
const stash = nativeMethods(proto)
const native = (stash[method] ??= proto[method])
const wrapper = {
[method]() {
if (arguments.length < required) {
argumentCountError(brand, this, method, iface, required, arguments.length)
}
return native.apply(this, arguments)
},
}[method]
Object.defineProperty(wrapper, 'length', { value: required })
proto[method] = wrapper
}
const ctxBrand = CanvasRenderingContext2D.prototype.getContextAttributes
for (const [method, required] of [
['arc', 5],
['arcTo', 5],
['bezierCurveTo', 6],
['clearRect', 4],
['createConicGradient', 3],
['createLinearGradient', 4],
['createRadialGradient', 6],
['ellipse', 7],
['fillRect', 4],
['fillText', 3],
['getImageData', 4],
['lineTo', 2],
['measureText', 1],
['moveTo', 2],
['quadraticCurveTo', 4],
['rect', 4],
['rotate', 1],
['roundRect', 4],
['scale', 2],
['setLineDash', 1],
['strokeRect', 4],
['strokeText', 3],
['transform', 6],
['translate', 2],
]) {
requireArguments(CanvasRenderingContext2D.prototype, ctxBrand, 'CanvasRenderingContext2D', method, required)
}
// getContext(contextId, options): Chrome needs the id. The native method is
// its own brand: with no arguments it converts undefined to 'undefined' and
// returns null, without side effects.
for (const [Class, iface] of [
[CanvasElement, 'HTMLCanvasElement'],
[SVGCanvas, 'SVGCanvas'],
]) {
const stash = nativeMethods(Class.prototype)
requireArguments(Class.prototype, (stash.getContext ??= Class.prototype.getContext), iface, 'getContext', 1)
}
const pathBrand = Path2D.prototype.getFillType
for (const [method, required] of [
['arc', 5],
['arcTo', 5],
['bezierCurveTo', 6],
['ellipse', 7],
['lineTo', 2],
['moveTo', 2],
['quadraticCurveTo', 4],
['rect', 4],
['roundRect', 4],
]) {
requireArguments(Path2D.prototype, pathBrand, 'Path2D', method, required)
}
// The argument-count markers for 0 to 9 arguments. napi pads missing
// arguments with undefined, so the wrappers below pass the real count after
// the positional arguments, as one of these markers: the native methods read
// a count only from a marker, and any other value there (from a raw
// js-binding call) is an extra argument.
const ARGUMENT_COUNTS = _argumentCounts()
// new ImageData(): Chrome checks `new` and the real argument count before it
// picks an overload (image_data.idl). The class napi-rs makes sees neither,
// so a native function checks them and builds the instance itself, from
// new.target.prototype. Instances share the class prototype, so instanceof
// works for those that createImageData and getImageData return.
const ImageData = _imageDataConstructor()
Object.defineProperty(ImageData, 'length', { value: 2 })
Object.defineProperty(ImageData, 'prototype', { value: NativeImageData.prototype, writable: false })
Object.defineProperty(NativeImageData.prototype, 'constructor', {
value: ImageData,
writable: true,
enumerable: false,
configurable: true,
})
// What the wrappers below pass after their `n` positional arguments, for a
// call with `count` (1 to `n`) of them, the last one `last`. Without a marker
// the native method counts up to the last argument that is not undefined:
// that is `count` unless `last` is an explicit undefined, and only then is
// the marker needed.
function argumentCount(count, last) {
return last === undefined ? ARGUMENT_COUNTS[count] : undefined
}
// fill(), clip(), stroke(), isPointInPath() and isPointInStroke(): WebIDL
// picks the overload from the argument count (canvas_2d_recorder_context.idl),
// and an explicit undefined counts: fill(path, undefined) is the nonzero
// fill of path, fill(undefined, 'evenodd') a TypeError.
// These wrappers and drawImage's read only the arguments the call has: past
// arguments.length, arguments[i] would read Object.prototype[i], which
// Chrome never reads.
const _fill = (ctxNative.fill ??= CanvasRenderingContext2D.prototype.fill)
CanvasRenderingContext2D.prototype.fill = function fill() {
const count = Math.min(arguments.length, 2)
return _fill.call(
this,
count > 0 ? arguments[0] : undefined,
count > 1 ? arguments[1] : undefined,
count === 0 ? undefined : argumentCount(count, arguments[count - 1]),
)
}
const _clip = (ctxNative.clip ??= CanvasRenderingContext2D.prototype.clip)
CanvasRenderingContext2D.prototype.clip = function clip() {
const count = Math.min(arguments.length, 2)
return _clip.call(
this,
count > 0 ? arguments[0] : undefined,
count > 1 ? arguments[1] : undefined,
count === 0 ? undefined : argumentCount(count, arguments[count - 1]),
)
}
const _stroke = (ctxNative.stroke ??= CanvasRenderingContext2D.prototype.stroke)
CanvasRenderingContext2D.prototype.stroke = function stroke() {
if (arguments.length === 0) {
return _stroke.call(this, undefined, undefined)
}
const path = arguments[0]
return _stroke.call(this, path, argumentCount(1, path))
}
const _isPointInPath = (ctxNative.isPointInPath ??= CanvasRenderingContext2D.prototype.isPointInPath)
CanvasRenderingContext2D.prototype.isPointInPath = function isPointInPath() {
if (arguments.length < 2) {
argumentCountError(ctxBrand, this, 'isPointInPath', 'CanvasRenderingContext2D', 2, arguments.length)
}
const count = Math.min(arguments.length, 4)
return _isPointInPath.call(
this,
arguments[0],
arguments[1],
count > 2 ? arguments[2] : undefined,
count > 3 ? arguments[3] : undefined,
// (x, y, undefined) converts as (x, y) when x is not an object (only an
// object can be a Path2D), so the count is not needed.
count === 3 && typeof arguments[0] !== 'object' ? undefined : argumentCount(count, arguments[count - 1]),
)
}
Object.defineProperty(CanvasRenderingContext2D.prototype.isPointInPath, 'length', { value: 2 })
const _isPointInStroke = (ctxNative.isPointInStroke ??= CanvasRenderingContext2D.prototype.isPointInStroke)
CanvasRenderingContext2D.prototype.isPointInStroke = function isPointInStroke() {
if (arguments.length < 2) {
argumentCountError(ctxBrand, this, 'isPointInStroke', 'CanvasRenderingContext2D', 2, arguments.length)
}
const count = Math.min(arguments.length, 3)
return _isPointInStroke.call(
this,
arguments[0],
arguments[1],
count > 2 ? arguments[2] : undefined,
argumentCount(count, arguments[count - 1]),
)
}
Object.defineProperty(CanvasRenderingContext2D.prototype.isPointInStroke, 'length', { value: 2 })
// A TypeError as Chrome's bindings throw it, as in argumentCountError: the
// stack keeps the bare message, and `message` gets the prefix.
function contextTypeError(prefix, message) {
const error = new TypeError(message)
void error.stack
Object.defineProperty(error, 'message', {
value: prefix + message,
writable: true,
enumerable: true,
configurable: true,
})
return error
}
// An `unrestricted double` member of a matrix dictionary; undefined when it
// is absent. The native ToNumber keeps the engine's texts, and the error
// names the member, as in Chrome.
function matrixMember(value, key, dictionary, prefix) {
if (typeof value === 'number' || value === undefined) return value
return toNumber(value, `${prefix}Failed to read the '${key}' property from '${dictionary}': `)
}
// a and m11 (and so on) disagree: both given and not equal. Two NaNs agree.
const mismatch = (x, y) => x !== undefined && y !== undefined && x !== y && (x === x || y === y)
// A 3D member against its identity value; absent is the identity. As C++
// truthiness, NaN counts as 3D and -0 as 0.
const notZero = (v) => v !== undefined && v !== 0
const notOne = (v) => v !== undefined && v !== 1
// The matrix of a DOMMatrix2DInit, or of a DOMMatrixInit when `full`, as
// [m11, m12, m21, m22, m41, m42]; undefined and null are {}. As Blink's
// bindings, every member is read with [[Get]], in order (a..f, m11, m12,
// m21, m22, m41, m42, then is2D and m13..m44), then checked as
// DOMMatrixReadOnly::ValidateAndFixup (dom_matrix_read_only.cc). A DOMMatrix
// is read the same way: an own property, a patched getter or a Proxy may
// make its members disagree. The result is one shared array: read it before
// any other user code runs.
const MATRIX = [1, 0, 0, 1, 0, 0]
function matrix2DFromInit(init, prefix, full) {
if (init === undefined || init === null) {
MATRIX[0] = 1
MATRIX[1] = 0
MATRIX[2] = 0
MATRIX[3] = 1
MATRIX[4] = 0
MATRIX[5] = 0
return MATRIX
}
if (typeof init !== 'object' && typeof init !== 'function') {
throw contextTypeError(prefix, `The provided value is not of type '${full ? 'DOMMatrixInit' : 'DOMMatrix2DInit'}'.`)
}
const D2 = 'DOMMatrix2DInit'
const a = matrixMember(init.a, 'a', D2, prefix)
const b = matrixMember(init.b, 'b', D2, prefix)
const c = matrixMember(init.c, 'c', D2, prefix)
const d = matrixMember(init.d, 'd', D2, prefix)
const e = matrixMember(init.e, 'e', D2, prefix)
const f = matrixMember(init.f, 'f', D2, prefix)
const m11 = matrixMember(init.m11, 'm11', D2, prefix)
const m12 = matrixMember(init.m12, 'm12', D2, prefix)
const m21 = matrixMember(init.m21, 'm21', D2, prefix)
const m22 = matrixMember(init.m22, 'm22', D2, prefix)
const m41 = matrixMember(init.m41, 'm41', D2, prefix)
const m42 = matrixMember(init.m42, 'm42', D2, prefix)
let is3DIn2D = false
if (full) {
const D = 'DOMMatrixInit'
const is2D = init.is2D
const m13 = matrixMember(init.m13, 'm13', D, prefix)
const m14 = matrixMember(init.m14, 'm14', D, prefix)
const m23 = matrixMember(init.m23, 'm23', D, prefix)
const m24 = matrixMember(init.m24, 'm24', D, prefix)
const m31 = matrixMember(init.m31, 'm31', D, prefix)
const m32 = matrixMember(init.m32, 'm32', D, prefix)
const m33 = matrixMember(init.m33, 'm33', D, prefix)
const m34 = matrixMember(init.m34, 'm34', D, prefix)
const m43 = matrixMember(init.m43, 'm43', D, prefix)
const m44 = matrixMember(init.m44, 'm44', D, prefix)
// is2D is a boolean member: ToBoolean when present.
is3DIn2D =
is2D !== undefined &&
!!is2D &&
(notZero(m31) ||
notZero(m32) ||
notZero(m13) ||
notZero(m23) ||
notZero(m43) ||
notZero(m14) ||
notZero(m24) ||
notZero(m34) ||
notOne(m33) ||
notOne(m44))
}
if (
mismatch(a, m11) ||
mismatch(b, m12) ||
mismatch(c, m21) ||
mismatch(d, m22) ||
mismatch(e, m41) ||
mismatch(f, m42)
) {
throw contextTypeError(prefix, 'Property mismatch on matrix initialization.')
}
if (is3DIn2D) {
throw contextTypeError(prefix, 'The is2D member is set to true but the input matrix is a 3d matrix.')
}
MATRIX[0] = m11 !== undefined ? m11 : a !== undefined ? a : 1
MATRIX[1] = m12 !== undefined ? m12 : b !== undefined ? b : 0
MATRIX[2] = m21 !== undefined ? m21 : c !== undefined ? c : 0
MATRIX[3] = m22 !== undefined ? m22 : d !== undefined ? d : 1
MATRIX[4] = m41 !== undefined ? m41 : e !== undefined ? e : 0
MATRIX[5] = m42 !== undefined ? m42 : f !== undefined ? f : 0
return MATRIX
}
// setTransform(): six or more arguments are six numbers, fewer a DOMMatrixInit
// (canvas_2d_recorder_context.idl), and an explicit undefined counts. The
// DOMMatrixInit is read above; the native method takes six numbers. It reads
// a first argument that is not a number as a DOMMatrixInit, the form a raw
// js-binding call may use, so ToNumber runs here for such an `a`.
const _setTransform = (ctxNative.setTransform ??= CanvasRenderingContext2D.prototype.setTransform)
// A cheap native method: on another receiver it throws 'Illegal invocation',
// which Chrome checks before it converts any argument.
const ctxReceiver = CanvasRenderingContext2D.prototype.isContextLost
const SET_TRANSFORM = "Failed to execute 'setTransform' on 'CanvasRenderingContext2D': "
CanvasRenderingContext2D.prototype.setTransform = function setTransform() {
if (arguments.length >= 6) {
let a = arguments[0]
if (typeof a !== 'number') {
ctxReceiver.call(this)
a = toNumber(a, SET_TRANSFORM)
}
return _setTransform.call(this, a, arguments[1], arguments[2], arguments[3], arguments[4], arguments[5])
}
// Past arguments.length, arguments[0] would read Object.prototype[0].
const init = arguments.length > 0 ? arguments[0] : undefined
if (init !== undefined && init !== null) ctxReceiver.call(this)
const m = matrix2DFromInit(init, SET_TRANSFORM, true)
return _setTransform.call(this, m[0], m[1], m[2], m[3], m[4], m[5])
}
// addPath(path, transform = {}): Chrome checks the receiver, the argument
// count and the path, then reads the DOMMatrix2DInit, read above. The native
// method takes six numbers after the path; anything else there is a
// DOMMatrix2DInit, which only a raw js-binding call passes. Without a
// transform (undefined or null is `{}`), a native method that takes only the
// path adds it as it is; Chrome's Path2D has no such method, so it comes off
// the prototype.
const pathNative = nativeMethods(Path2D.prototype)
const _addPath = (pathNative.addPath ??= Path2D.prototype.addPath)
const _addPathWithoutTransform = (pathNative._addPathWithoutTransform ??= Path2D.prototype._addPathWithoutTransform)
delete Path2D.prototype._addPathWithoutTransform
const ADD_PATH = "Failed to execute 'addPath' on 'Path2D': "
Path2D.prototype.addPath = function addPath() {
if (arguments.length < 1) {
argumentCountError(pathBrand, this, 'addPath', 'Path2D', 1, arguments.length)
}
const path = arguments[0]
// Past arguments.length, arguments[1] would read Object.prototype[1].
const transform = arguments.length > 1 ? arguments[1] : undefined
if (transform === undefined || transform === null) {
return _addPathWithoutTransform.call(this, path)
}
pathBrand.call(this)
try {
pathBrand.call(path)
} catch {
throw contextTypeError(ADD_PATH, "parameter 1 is not of type 'Path2D'.")
}
const m = matrix2DFromInit(transform, ADD_PATH, false)
return _addPath.call(this, path, m[0], m[1], m[2], m[3], m[4], m[5])
}
Object.defineProperty(Path2D.prototype.addPath, 'length', { value: 1 })
// createImageData(): WebIDL picks the overload from the argument count, and an
// explicit undefined counts: createImageData(imagedata, undefined) is the
// (sw, sh) form.
const _createImageData = (ctxNative.createImageData ??= CanvasRenderingContext2D.prototype.createImageData)
CanvasRenderingContext2D.prototype.createImageData = function createImageData() {
const count = arguments.length
// Past arguments.length, arguments[i] would read Object.prototype[i]: pass
// undefined there, as napi pads missing arguments.
return _createImageData.call(
this,
count > 0 ? arguments[0] : undefined,
count > 1 ? arguments[1] : undefined,
count > 2 ? arguments[2] : undefined,
count > 3 ? arguments[3] : undefined,
ARGUMENT_COUNTS[Math.min(count, 4)],
)
}
Object.defineProperty(CanvasRenderingContext2D.prototype.createImageData, 'length', { value: 1 })
// putImageData(imagedata, dx, dy) or (imagedata, dx, dy, dirtyX, dirtyY,
// dirtyWidth, dirtyHeight): as in Chrome, it needs 3 arguments; the native
// method picks the overload from the argument count (3 or 7).
const _putImageData = (ctxNative.putImageData ??= CanvasRenderingContext2D.prototype.putImageData)
CanvasRenderingContext2D.prototype.putImageData = function putImageData() {
const count = arguments.length
if (count < 3) {
argumentCountError(ctxBrand, this, 'putImageData', 'CanvasRenderingContext2D', 3, count)
}
// Past arguments.length, arguments[i] would read Object.prototype[i]: pass
// undefined there, as napi pads missing arguments.
return _putImageData.call(
this,
arguments[0],
arguments[1],
arguments[2],
count > 3 ? arguments[3] : undefined,
count > 4 ? arguments[4] : undefined,
count > 5 ? arguments[5] : undefined,
count > 6 ? arguments[6] : undefined,
ARGUMENT_COUNTS[Math.min(count, 7)],
)
}
Object.defineProperty(CanvasRenderingContext2D.prototype.putImageData, 'length', { value: 3 })
// createPattern(image, repetitionType): as in Chrome, both arguments are
// required, and the image is converted before the repetition, a
// [LegacyNullToEmptyString] DOMString (canvas_2d_recorder_context.idl), so
// null is '' and undefined is 'undefined'.
const _createPattern = (ctxNative.createPattern ??= CanvasRenderingContext2D.prototype.createPattern)
CanvasRenderingContext2D.prototype.createPattern = function createPattern(image, repetition) {
return _createPattern.call(this, image, repetition, ARGUMENT_COUNTS[Math.min(arguments.length, 4)])
}
// addColorStop(offset, color): both arguments are required. CanvasGradient
// has no other native method to check the receiver first, so the native
// method itself reads the real count from the marker after them.
const gradientNative = nativeMethods(CanvasGradient.prototype)
const _addColorStop = (gradientNative.addColorStop ??= CanvasGradient.prototype.addColorStop)
CanvasGradient.prototype.addColorStop = function addColorStop(offset, color) {
return _addColorStop.call(this, offset, color, ARGUMENT_COUNTS[Math.min(arguments.length, 2)])
}
// Workaround for webpack bundling issue with drawImage
// Store the original drawImage method
const _drawImage = (ctxNative.drawImage ??= CanvasRenderingContext2D.prototype.drawImage)
// Override drawImage to ensure proper type recognition in bundled environments.
// As in Chrome, it needs 3 arguments; the native method picks the overload
// from the argument count (3, 5 or 9).
CanvasRenderingContext2D.prototype.drawImage = function drawImage() {
if (arguments.length < 3) {
argumentCountError(ctxBrand, this, 'drawImage', 'CanvasRenderingContext2D', 3, arguments.length)
}
let image = arguments[0]
// If the image is a Canvas-like object but not recognized due to bundling,
// we need to ensure it's properly identified
if (image && typeof image === 'object') {
// First check if it's a wrapped canvas object
if (image.canvas instanceof CanvasElement || image.canvas instanceof SVGCanvas) {
image = image.canvas
} else if (image._canvas instanceof CanvasElement || image._canvas instanceof SVGCanvas) {
image = image._canvas
}
// Then check if it's a Canvas-like object by checking for getContext method
else if (typeof image.getContext === 'function' && image.width && image.height) {
// If it has canvas properties but isn't recognized as CanvasElement or SVGCanvas,
// try to correct the prototype chain
if (!(image instanceof CanvasElement) && !(image instanceof SVGCanvas)) {
// Try to create a proper CanvasElement from the canvas-like object
// This helps when webpack has transformed the prototype chain
Object.setPrototypeOf(image, CanvasElement.prototype)
}
}
}
// Call the original drawImage with the potentially corrected image
const count = Math.min(arguments.length, 9)
return _drawImage.call(
this,
image,
arguments[1],
arguments[2],
count > 3 ? arguments[3] : undefined,
count > 4 ? arguments[4] : undefined,
count > 5 ? arguments[5] : undefined,
count > 6 ? arguments[6] : undefined,
count > 7 ? arguments[7] : undefined,
count > 8 ? arguments[8] : undefined,
argumentCount(count, arguments[count - 1]),
)
}
Object.defineProperty(CanvasRenderingContext2D.prototype.drawImage, 'length', { value: 3 })
function createCanvas(width, height, flag) {
const isSvgBackend = typeof flag !== 'undefined'
return isSvgBackend ? new SVGCanvas(width, height, flag) : new CanvasElement(width, height)
}
class Canvas {
constructor(width, height, flag) {
return createCanvas(width, height, flag)
}
static [Symbol.hasInstance](instance) {
return instance instanceof CanvasElement || instance instanceof SVGCanvas
}
}
if (!process.env.DISABLE_SYSTEM_FONTS_LOAD) {
// Installed fonts and the per-user font folders: FreeType by default;
// CoreText's on macOS after setTextRenderer('system'). On macOS that is
// /Library/Fonts (all users) and ~/Library/Fonts, after
// /System/Library/Fonts, as CoreText lists them.
const homedirPath = homedir()
const userFontDirs =
{
win32: [join(homedirPath, 'AppData', 'Local', 'Microsoft', 'Windows', 'Fonts')],
darwin: ['/Library/Fonts', join(homedirPath, 'Library', 'Fonts')],
linux: [join('usr', 'local', 'share', 'fonts'), join(homedirPath, '.fonts')],
}[platform()] ?? []
GlobalFonts.enableSystemFonts(userFontDirs)
}
module.exports = {
clearAllCache,
setTextRenderer,
getTextRenderer,
Canvas,
createCanvas,
Path2D,
ImageData,
Image,
PathOp,
FillType,
StrokeCap,
StrokeJoin,
SvgExportFlag,
PngFilter,
GlobalFonts: GlobalFonts,
convertSVGTextToPath,
DOMPoint,
DOMMatrix,
DOMRect,
loadImage,
FontKey,
// Export these for better webpack compatibility
CanvasElement,
SVGCanvas,
PDFDocument: PdfDocument,
// GIF encoding
GifEncoder,
GifDisposal,
// Lottie animation
LottieAnimation,
}
Shown as plain text from the published tarball, after apm checked it against the version's checksum. Nothing in it runs on this page.