skia-canvas 2.0.2 → 3.0.0

package/lib/classes/canvas.js

@@ -4,15 +4,17 @@
 
 "use strict"
 
-const {RustClass, core, inspect, REPR} = require('./neon'),
-      {Image, ImageData, pixelSize} = require('./imagery'),
+const {fileURLToPath} = require('url'),
+      {RustClass, core, inspect, argc, REPR} = require('./neon'),
+      {Image, ImageData, pixelSize, getSharp} = require('./imagery'),
+      {Path2D} = require('./path'),
       {toSkMatrix} = require('./geometry')
 
 class Canvas extends RustClass{
   #contexts
 
-  constructor(width, height){
-    super(Canvas).alloc()
+  constructor(width, height, {textContrast=0, textGamma=1.4, gpu=true}={}){
+    super(Canvas).alloc({textContrast, textGamma, gpu:!!gpu})
     this.#contexts = []
     Object.assign(this, {width, height})
   }
@@ -28,13 +30,13 @@ class Canvas extends RustClass{
 
   get width(){ return this.prop('width') }
   set width(w){
-    this.prop('width', (typeof w=='number' && !Number.isNaN(w) && w>=0) ? w : 300)
+    this.prop('width', !Number.isNaN(+w) && +w>=0 ? w : 300)
     if (this.#contexts[0]) this.getContext("2d").ƒ('resetSize', core(this))
   }
 
   get height(){ return this.prop('height') }
   set height(h){
-    this.prop('height', h = (typeof h=='number' && !Number.isNaN(h) && h>=0) ? h : 150)
+    this.prop('height', !Number.isNaN(+h) && +h>=0 ? h : 150)
     if (this.#contexts[0]) this.getContext("2d").ƒ('resetSize', core(this))
   }
 
@@ -52,52 +54,70 @@ class Canvas extends RustClass{
     return this.#contexts.slice().reverse()
   }
 
+  get raw(){ return this.toBuffer("raw") }
   get png(){ return this.toBuffer("png") }
   get jpg(){ return this.toBuffer("jpg") }
   get pdf(){ return this.toBuffer("pdf") }
   get svg(){ return this.toBuffer("svg") }
   get webp(){ return this.toBuffer("webp") }
 
-  saveAs(filename, opts={}){
-    opts = typeof opts=='number' ? {quality:opts} : opts
-    let {format, quality, pages, padding, pattern, density, outline, matte, msaa, colorType} = exportOptions(this.pages, {filename, ...opts}),
-        args = [pages.map(core), pattern, padding, {format, quality, density, outline, matte, msaa, colorType}]
+  // Warn about renamed methods but map them to the new names (for now)
+  saveAs(){ _deprecated('Canvas.saveAs()'); this.toFile(...arguments) }
+  saveAsSync(){ _deprecated('Canvas.saveAsSync()'); this.toFileSync(...arguments) }
+  toDataURLSync(){ _deprecated('Canvas.toDataURLSync()'); this.toURLSync(...arguments) }
+
+  toFile(filename, opts={}){
+    let {pages, padding, pattern, ...rest} = exportOptions(this, {filename}, opts),
+        args = [pages.map(core), pattern, padding, rest]
     return this.ƒ("save", ...args)
   }
 
-  saveAsSync(filename, opts={}){
-    opts = typeof opts=='number' ? {quality:opts} : opts
-    let {format, quality, pages, padding, pattern, density, outline, matte, msaa, colorType} = exportOptions(this.pages, {filename, ...opts})
-    this.ƒ("saveSync", pages.map(core), pattern, padding, {format, quality, density, outline, matte, msaa, colorType})
+  toFileSync(filename, opts={}){
+    let {pages, padding, pattern, ...rest} = exportOptions(this, {filename}, opts)
+    this.ƒ("saveSync", pages.map(core), pattern, padding, rest)
   }
 
   toBuffer(extension="png", opts={}){
-    opts = typeof opts=='number' ? {quality:opts} : opts
-    let {format, quality, pages, density, outline, matte, msaa, colorType} = exportOptions(this.pages, {extension, ...opts}),
-        args = [pages.map(core), {format, quality, density, outline, matte, msaa, colorType}];
-    return this.ƒ("toBuffer", ...args)
+    let {pages, ...rest} = exportOptions(this, {extension}, opts)
+    return this.ƒ("toBuffer", pages.map(core), rest)
   }
 
   toBufferSync(extension="png", opts={}){
-    opts = typeof opts=='number' ? {quality:opts} : opts
-    let {format, quality, pages, density, outline, matte, msaa, colorType} = exportOptions(this.pages, {extension, ...opts})
-    return this.ƒ("toBufferSync", pages.map(core), {format, quality, density, outline, matte, msaa, colorType})
+    let {pages, ...rest} = exportOptions(this, {extension}, opts)
+    return this.ƒ("toBufferSync", pages.map(core), rest)
   }
 
-  toDataURL(extension="png", opts={}){
-    opts = typeof opts=='number' ? {quality:opts} : opts
-    let {mime} = exportOptions(this.pages, {extension, ...opts}),
+  toURL(extension="png", opts={}){
+    let {mime} = exportOptions(this, {extension}, opts),
         buffer = this.toBuffer(extension, opts);
     return buffer.then(data => `data:${mime};base64,${data.toString('base64')}`)
   }
 
-  toDataURLSync(extension="png", opts={}){
-    opts = typeof opts=='number' ? {quality:opts} : opts
-    let {mime} = exportOptions(this.pages, {extension, ...opts}),
+  toURLSync(extension="png", opts={}){
+    let {mime} = exportOptions(this, {extension}, opts),
         buffer = this.toBufferSync(extension, opts);
     return `data:${mime};base64,${buffer.toString('base64')}`
   }
 
+  // Match the browser API in only accepting a single optional quality argument
+  toDataURL(extension="png", quality){
+    if (quality!==undefined && typeof quality!=='number'){
+      throw TypeError("Expected a number in the range 0–1 for `quality` (use toURL() for additional rendering options)")
+    }
+    return this.toURLSync(extension, {quality})
+  }
+
+  toSharp({page, matte, msaa, density=1}={}){
+    const {Readable} = require('node:stream'),
+          sharp = getSharp(),
+          buffer = this.toBuffer("raw", {page, matte, density, msaa})
+
+    return Readable.from(
+      (async function * (){ yield buffer })()
+    ).pipe(sharp({
+      raw: {width:this.width*density, height:this.height*density, channels:4}
+    }).withMetadata({density:density * 72}))
+  }
 
   [REPR](depth, options) {
     let {width, height, gpu, engine, pages} = this
@@ -114,8 +134,7 @@ class CanvasGradient extends RustClass{
   }
 
   addColorStop(offset, color){
-    if (offset>=0 && offset<=1) this.ƒ('addColorStop', offset, color)
-    else throw new Error("Color stop offsets must be between 0.0 and 1.0")
+    this.ƒ('addColorStop', ...arguments)
   }
 
   [REPR](depth, options) {
@@ -125,15 +144,16 @@ class CanvasGradient extends RustClass{
 
 class CanvasPattern extends RustClass{
   constructor(canvas, src, repeat){
+    repeat = [...arguments].slice(2)
     super(CanvasPattern)
     if (src instanceof Image){
       let {width, height} = canvas
-      this.init('from_image', core(src), width, height, repeat)
+      this.init('from_image', core(src), width, height, ...repeat)
     }else if (src instanceof ImageData){
-      this.init('from_image_data', src, repeat)
+      this.init('from_image_data', src, ...repeat)
     }else if (src instanceof Canvas){
       let ctx = src.getContext('2d')
-      this.init('from_canvas', core(ctx), repeat)
+      this.init('from_canvas', core(ctx), ...repeat)
     }else{
       throw new Error("CanvasPatterns require a source Image or a Canvas")
     }
@@ -147,14 +167,18 @@ class CanvasPattern extends RustClass{
 }
 
 class CanvasTexture extends RustClass{
-  constructor(spacing, {path, line, color, angle, offset=0}={}){
+  constructor(spacing, {path, color, angle, line, cap="butt", outline=false, offset=0}={}){
     super(CanvasTexture)
-    let [x, y] = typeof offset=='number' ? [offset, offset] : offset.slice(0, 2)
-    let [h, v] = typeof spacing=='number' ? [spacing, spacing] : spacing.slice(0, 2)
+    argc(arguments, 1)
+    let [x, y] = Array.isArray(offset) ? offset.concat(offset).slice(0, 2) : [offset, offset]
+    let [h, v] = Array.isArray(spacing) ? spacing.concat(spacing).slice(0, 2) : [spacing, spacing]
+    if (path!==undefined && !(path instanceof Path2D)){
+      throw TypeError("Expected a Path2D object for `path`")
+    }
     path = core(path)
     line = line != null ? line : (path ? 0 : 1)
     angle = angle != null ? angle : (path ? 0 : -Math.PI / 4)
-    this.alloc(path, color, line, angle, h, v, x, y)
+    this.alloc(path, color, line, cap, angle, !!outline, h, v, x, y)
   }
 
   [REPR](depth, options) {
@@ -201,16 +225,33 @@ class Format{
 
 const {basename, extname} = require('path')
 
-function exportOptions(pages, {filename='', extension='', format, page, quality, matte, density, outline, msaa, colorType}={}){
+function exportOptions(canvas, {filename='', extension=''}, opts){
+  // a single number will be interpreted as a quality setting
+  if (typeof opts=='number') opts = {quality:opts}
+
+  // unpack common export options
+  let {page, quality, matte, density, msaa, outline, downsample, colorType} = opts
+
+  // only allow format overrides in toFile()
+  let imageFormat = !!filename ? opts.format : undefined
+
+  if (filename instanceof URL){
+    if (filename.protocol=='file:') filename = fileURLToPath(filename)
+    else throw Error(`URLs must use 'file' protocol (got '${filename.protocol.replace(':', '')}')`)
+  }
+
+  // ensure the canvas has a context (so it can at least generate an empty image)
+  if (!canvas.pages.length) canvas.getContext("2d")
+
   var {fromMime, toMime, expected} = new Format(),
-      ext = format || extension.replace(/@\d+x$/i,'') || extname(filename),
+      ext = imageFormat || extension.replace(/@\d+x$/i,'') || extname(filename),
       format = fromMime(toMime(ext) || ext),
       mime = toMime(format),
+      pages = canvas.pages,
       pp = pages.length
 
   if (!ext) throw new Error(`Cannot determine image format (use a filename extension or 'format' argument)`)
   if (!format) throw new Error(`Unsupported file format "${ext}" (expected ${expected})`)
-  if (!pp) throw new RangeError(`Canvas has no associated contexts (try calling getContext or newPage first)`)
 
   let padding, isSequence, pattern = filename.replace(/{(\d*)}/g, (_, width) => {
     isSequence = true
@@ -233,11 +274,14 @@ function exportOptions(pages, {filename='', extension='', format, page, quality,
         : isSequence || format=='pdf' ? pages
         : pages.slice(-1) // default to the 'current' context
 
+  // inherit text settings from the canvas (since they can't be changed on a per-render basis due to glyph caching)
+  const {textContrast, textGamma} = canvas.engine
+
   if (quality===undefined){
     quality = 0.92
   }else{
     if (typeof quality!='number' || !isFinite(quality) || quality<0 || quality>1){
-      throw new TypeError("The quality option must be an number in the 0.0–1.0 range")
+      throw new TypeError("Expected a number between 0.0–1.0 for `quality`")
     }
   }
 
@@ -245,20 +289,12 @@ function exportOptions(pages, {filename='', extension='', format, page, quality,
     let m = (extension || basename(filename, ext)).match(/@(\d+)x$/i)
     density = m ? parseInt(m[1], 10) : 1
   }else if (typeof density!='number' || !Number.isInteger(density) || density<1){
-    throw new TypeError("The density option must be a non-negative integer")
-  }
-
-  if (outline===undefined){
-    outline = true
-  }else if (format == 'svg'){
-    outline = !!outline
+    throw new TypeError("Expected a non-negative integer for `density`")
   }
 
-  if (msaa===undefined) {
-    msaa = undefined // leave as-is
-  }else if (!msaa){
-    msaa = 0 // null, false, etc. should all disable it
-  }else if (typeof msaa!='number' || !isFinite(msaa) || msaa<0){
+  if (msaa===undefined || msaa===true) {
+    msaa = undefined // use the default 4x msaa
+  }else if (!isFinite(+msaa) || +msaa<0){
     throw new TypeError("The number of MSAA samples must be an integer ≥0")
   }
 
@@ -266,7 +302,26 @@ function exportOptions(pages, {filename='', extension='', format, page, quality,
     pixelSize(colorType) // throw an error if invalid
   }
 
-  return {filename, pattern, format, mime, pages, padding, quality, matte, density, outline, msaa, colorType}
+  // default to false, otherwise detect truthy
+  downsample = !!downsample
+  outline = !!outline
+
+  return {
+    filename, pattern, format, mime, pages, padding, quality, matte,
+    density, msaa, outline, textContrast, textGamma, downsample, colorType
+  }
+}
+
+// emit a deprecation warning, once per API per process
+let _warnings = {
+  "Canvas.saveAs()": "Canvas.toFile()",
+  "Canvas.saveAsSync()": "Canvas.toFileSync()",
+  "Canvas.toDataURLSync()": "Canvas.toURLSync() (see also Canvas.toDataURL() which is now synchronous)",
+}
+function _deprecated(oldAPI){
+  let newAPI = _warnings[oldAPI]
+  if (newAPI) console.error(`Deprecation warning: ${oldAPI} has been renamed to ${newAPI} and will stop working in a future release.`)
+  delete _warnings[oldAPI]
 }
 
-module.exports = {Canvas, CanvasGradient, CanvasPattern, CanvasTexture}
+module.exports = {Canvas, CanvasGradient, CanvasPattern, CanvasTexture, getSharp}

package/lib/classes/context.js

@@ -4,7 +4,7 @@
 
 "use strict"
 
-const {RustClass, core, wrap, inspect, REPR} = require('./neon'),
+const {RustClass, core, wrap, inspect, argc, REPR} = require('./neon'),
       {Canvas, CanvasGradient, CanvasPattern, CanvasTexture} = require('./canvas'),
       {fromSkMatrix, toSkMatrix} = require('./geometry'),
       {Image, ImageData} = require('./imagery'),
@@ -63,7 +63,8 @@ class CanvasRenderingContext2D extends RustClass{
   quadraticCurveTo(cpx, cpy, x, y){ this.ƒ('quadraticCurveTo', ...arguments) }
   conicCurveTo(cpx, cpy, x, y, weight){ this.ƒ("conicCurveTo", ...arguments) }
   closePath(){ this.ƒ('closePath') }
-  roundRect(x, y, w, h, r){
+  roundRect(x, y, w, h, r=0){
+    argc(arguments, 4, 5)
     let radii = css.radii(r)
     if (radii){
       if (w < 0) radii = [radii[1], radii[0], radii[3], radii[2]]
@@ -75,32 +76,32 @@ class CanvasRenderingContext2D extends RustClass{
 
   // -- using paths -----------------------------------------------------------
   fill(path, rule){
-    if (path instanceof Path2D) this.ƒ('fill', core(path), rule)
-    else this.ƒ('fill', path) // 'path' is the optional winding-rule
+    if (path instanceof Path2D) arguments[0] = core(path)
+    return this.ƒ('fill', ...arguments)
   }
 
-  stroke(path, rule){
-    if (path instanceof Path2D) this.ƒ('stroke', core(path), rule)
-    else this.ƒ('stroke', path) // 'path' is the optional winding-rule
+  stroke(path){
+    if (path instanceof Path2D) arguments[0] = core(path)
+    return this.ƒ('stroke', ...arguments)
   }
 
   clip(path, rule){
-    if (path instanceof Path2D) this.ƒ('clip', core(path), rule)
-    else this.ƒ('clip', path) // 'path' is the optional winding-rule
+    if (path instanceof Path2D) arguments[0] = core(path)
+    return this.ƒ('clip', ...arguments)
   }
 
-  isPointInPath(path, x, y){
-    let args = path instanceof Path2D ? [core(path), x, y] : arguments
-    return this.ƒ('isPointInPath', ...args)
+  isPointInPath(path, x, y, rule){
+    if (path instanceof Path2D) arguments[0] = core(path)
+    return this.ƒ('isPointInPath', ...arguments)
   }
   isPointInStroke(path, x, y){
-    let args = path instanceof Path2D ? [core(path), x, y] : arguments
-    return this.ƒ('isPointInStroke', ...args)
+    if (path instanceof Path2D) arguments[0] = core(path)
+    return this.ƒ('isPointInStroke', ...arguments)
   }
 
 
   // -- shaders ---------------------------------------------------------------
-  createPattern(image, repetition){ return new CanvasPattern(this.canvas, image, repetition) }
+  createPattern(image, repetition){ return new CanvasPattern(this.canvas, ...arguments) }
   createLinearGradient(x0, y0, x1, y1){
     return new CanvasGradient("Linear", ...arguments)
   }
@@ -112,7 +113,7 @@ class CanvasRenderingContext2D extends RustClass{
   }
 
   createTexture(spacing, options){
-    return new CanvasTexture(spacing, options)
+    return new CanvasTexture(...arguments)
   }
 
   // -- fill & stroke ---------------------------------------------------------
@@ -146,7 +147,7 @@ class CanvasRenderingContext2D extends RustClass{
 
   // -- line style ------------------------------------------------------------
   getLineDash(){        return this.ƒ("getLineDash") }
-  setLineDash(segments){       this.ƒ("setLineDash", segments) }
+  setLineDash(segments){       this.ƒ("setLineDash", ...arguments) }
   get lineCap(){        return this.prop("lineCap") }
   set lineCap(style){          this.prop("lineCap", style) }
   get lineDashFit(){    return this.prop("lineDashFit") }
@@ -167,14 +168,34 @@ class CanvasRenderingContext2D extends RustClass{
   set imageSmoothingEnabled(flag){    this.prop("imageSmoothingEnabled", !!flag)}
   get imageSmoothingQuality(){ return this.prop("imageSmoothingQuality")}
   set imageSmoothingQuality(level){   this.prop("imageSmoothingQuality", level)}
-  putImageData(imageData, ...coords){ this.ƒ('putImageData', imageData, ...coords) }
-  createImageData(width, height, settings){ return new ImageData(width, height, settings) }
-
-  getImageData(x, y, width, height, {colorType='rgba', colorSpace='srgb'}={}){
-    let w = Math.floor(width),
-        h = Math.floor(height),
-        buffer = this.ƒ('getImageData', core(this.canvas), x, y, w, h, {colorType, colorSpace});
-    return new ImageData(buffer, w, h, {colorType, colorSpace})
+
+  createImageData(width, height, settings){
+    argc(arguments, 2, 3)
+    return new ImageData(width, height, settings)
+  }
+
+  getImageData(x, y, width, height, {colorType='rgba', colorSpace='srgb', density=1, matte, msaa}={}){
+    argc(arguments, 4, 5)
+
+    if (typeof density!='number' || !Number.isInteger(density) || density<1){
+      throw new TypeError("Expected a non-negative integer for `density`")
+    }
+
+    if (msaa===undefined || msaa===true) {
+      msaa = undefined // use the default 4x msaa
+    }else if (!isFinite(+msaa) || +msaa<0){
+      throw new TypeError("The number of MSAA samples must be an integer ≥0")
+    }
+
+    let opts = {colorType, colorSpace, density, matte, msaa},
+        buffer = this.ƒ('getImageData', x, y, width, height, opts, core(this.canvas));
+    return new ImageData(buffer, width*density, height*density, {colorType, colorSpace})
+  }
+
+  putImageData(imageData, ...coords){
+    argc(arguments, 3, 7)
+    if (!(imageData instanceof ImageData)) throw TypeError("Expected an ImageData as 1st arg")
+    this.ƒ('putImageData', imageData, ...coords)
   }
 
   drawImage(image, ...coords){
@@ -182,13 +203,14 @@ class CanvasRenderingContext2D extends RustClass{
       this.ƒ('drawImage', core(image.getContext('2d')), ...coords)
     }else if (image instanceof Image){
       if (image.complete) this.ƒ('drawImage', core(image), ...coords)
-      else throw new Error("Image has not completed loading: listen for `load` event or await `decode()` first")
+      else throw Error("Image has not completed loading: listen for `load` event or await `decode()` first")
     }else if (image instanceof ImageData){
       this.ƒ('drawImage', image, ...coords)
     }else if (image instanceof Promise) {
-      throw new Error("Promise has not yet resolved: `await` image loading before drawing")
+      throw Error("Promise has not yet resolved: `await` image loading before drawing")
     }else{
-      throw new Error(`Expected an Image or a Canvas argument (got: ${inspect(image, {depth:1})})`)
+      let nonimage = inspect(image, {depth:1})
+      throw Error(`Expected an Image or a Canvas argument (got: ${nonimage})`)
     }
   }
 
@@ -217,21 +239,20 @@ class CanvasRenderingContext2D extends RustClass{
   set wordSpacing(str){       this.prop('wordSpacing', css.spacing(str)) }
 
   measureText(text, maxWidth){
-    text = this.textWrap ? text : text + '\u200b' // include trailing whitespace by default
-    let [metrics, ...lines] = this.ƒ('measureText', toString(text), maxWidth)
-    return new TextMetrics(metrics, lines)
+    let metrics = JSON.parse(this.ƒ('measureText', toString(text), maxWidth))
+    return new TextMetrics(metrics)
   }
 
-  fillText(text, x, y, maxWidth){
-    this.ƒ('fillText', toString(text), x, y, maxWidth)
+  fillText(text, ...geom){
+    this.ƒ('fillText', toString(text), ...geom)
   }
 
-  strokeText(text, x, y, maxWidth){
-    this.ƒ('strokeText', toString(text), x, y, maxWidth)
+  strokeText(text, ...geom){
+    this.ƒ('strokeText', toString(text), ...geom)
   }
 
-  outlineText(text, width){
-    let path = this.ƒ('outlineText', toString(text), width)
+  outlineText(text, ...geom){
+    let path = this.ƒ('outlineText', toString(text), ...geom)
     return path ? wrap(Path2D, path) : null
   }
 

package/lib/classes/css.js

@@ -9,7 +9,6 @@
 //    https://www.w3.org/TR/css-fonts-3/#font-size-prop
 
 var splitBy = require('string-split-by'),
-    {DOMPoint} = require('./geometry'),
     m, cache = {font:{}, variant:{}};
 
 const styleRE = /^(normal|italic|oblique)$/,
@@ -225,20 +224,20 @@ function parseFit(mode){
 
 function parseCornerRadii(r){
   r = [r].flat()
-         .map(n => n instanceof DOMPoint ? n : new DOMPoint(n, n))
          .slice(0, 4)
+         .map(n => n && Object.hasOwn(n, 'x') && Object.hasOwn(n, 'y') ? n : {x:n, y:n})
 
   if (r.some(pt => !Number.isFinite(pt.x) || !Number.isFinite(pt.y))){
     return null // silently abort
   }else if (r.some(pt => pt.x < 0 || pt.y < 0)){
-    throw new Error("Corner radius cannot be negative")
+    throw RangeError("Corner radius cannot be negative")
   }
 
   return r.length == 1 ? [r[0], r[0], r[0], r[0]]
        : r.length == 2 ? [r[0], r[1], r[0], r[1]]
        : r.length == 3 ? [r[0], r[1], r[2], r[1]]
        : r.length == 4 ? [r[0], r[1], r[2], r[3]]
-       : [0, 0, 0, 0].map(n => new DOMPoint(n, n))
+       : [0, 0, 0, 0].map(n => ({x:n, y:n}))
 }
 
 // -- Image Filters -----------------------------------------------------------------------

package/lib/classes/geometry.js

@@ -6,6 +6,14 @@
 
 const {inspect} = require('util')
 
+const isPlainObject = o => (
+  o !== null &&
+  typeof o === "object" &&
+  !(o instanceof DOMMatrix) &&
+  !Array.isArray(o) &&
+  !ArrayBuffer.isView(o)
+)
+
 /*
  * vendored in order to fix its dependence on the window global [@samizdatco 2020/08/04]
  * removed SVGMatrix references that were guaranteed to be undefined on node [@mpaperno 2024/10/20]
@@ -331,8 +339,10 @@ class DOMMatrix {
         init.m31, init.m32, init.m33, init.m34,
         init.m41, init.m42, init.m43, init.m44,
       ]);
-    if (DOMMatrix.isMatrix3(init))
-      return new DOMMatrix([init.a, init.b, init.c, init.d, init.e, init.f]);
+    if (DOMMatrix.isMatrix3(init) || isPlainObject(init)){
+      let {a=1, b=0, c=0, d=1, e=0, f=0} = init
+      return new DOMMatrix([a, b, c, d, e, f]);
+    }
     throw new TypeError(`Expected DOMMatrix, got: '${init}'`);
   }
 
@@ -378,7 +388,7 @@ class DOMMatrix {
   // (Float64Array) => void
   constructor(init) {
 
-    if (typeof init === "object" && !Array.isArray(init) && !ArrayBuffer.isView(init))
+    if (init instanceof DOMMatrix || isPlainObject(init))
       return DOMMatrix.fromMatrix(init);
 
     if (arguments.length > 1)
@@ -437,7 +447,7 @@ class DOMMatrix {
       setNumber3D(this, M44, init[i]);
     }
     else if (init !== undefined) {
-      throw new TypeError("Expected string or array.");
+      throw new TypeError("Expected string, array, or matrix object.");
     }
   }
 
@@ -861,6 +871,9 @@ for (let propertyName of [
 //
 
 function toSkMatrix() {
+  if (arguments.length != 1 && arguments.length < 6){
+     throw new TypeError("not enough arguments")
+  }
   try {
     const m = new DOMMatrix(...arguments);
     return [m.a, m.c, m.e, m.b, m.d, m.f, m.m14, m.m24, m.m44];