@depup/sharp 0.34.5-depup.0 → 0.35.4-depup.0

package/{lib/is.js → dist/is.cjs}

@@ -78,7 +78,7 @@ const string = (val) => typeof val === 'string' && val.length > 0;
  * Is this value a real number?
  * @private
  */
-const number = (val) => typeof val === 'number' && !Number.isNaN(val);
+const number = (val) => typeof val === 'number' && Number.isFinite(val);
 
 /**
  * Is this value an integer?

package/dist/is.mjs

@@ -0,0 +1,143 @@
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
+
+/**
+ * Is this value defined and not null?
+ * @private
+ */
+const defined = (val) => typeof val !== 'undefined' && val !== null;
+
+/**
+ * Is this value an object?
+ * @private
+ */
+const object = (val) => typeof val === 'object';
+
+/**
+ * Is this value a plain object?
+ * @private
+ */
+const plainObject = (val) => Object.prototype.toString.call(val) === '[object Object]';
+
+/**
+ * Is this value a function?
+ * @private
+ */
+const fn = (val) => typeof val === 'function';
+
+/**
+ * Is this value a boolean?
+ * @private
+ */
+const bool = (val) => typeof val === 'boolean';
+
+/**
+ * Is this value a Buffer object?
+ * @private
+ */
+const buffer = (val) => val instanceof Buffer;
+
+/**
+ * Is this value a typed array object?. E.g. Uint8Array or Uint8ClampedArray?
+ * @private
+ */
+const typedArray = (val) => {
+  if (defined(val)) {
+    switch (val.constructor) {
+      case Uint8Array:
+      case Uint8ClampedArray:
+      case Int8Array:
+      case Uint16Array:
+      case Int16Array:
+      case Uint32Array:
+      case Int32Array:
+      case Float32Array:
+      case Float64Array:
+        return true;
+    }
+  }
+
+  return false;
+};
+
+/**
+ * Is this value an ArrayBuffer object?
+ * @private
+ */
+const arrayBuffer = (val) => val instanceof ArrayBuffer;
+
+/**
+ * Is this value a non-empty string?
+ * @private
+ */
+const string = (val) => typeof val === 'string' && val.length > 0;
+
+/**
+ * Is this value a real number?
+ * @private
+ */
+const number = (val) => typeof val === 'number' && Number.isFinite(val);
+
+/**
+ * Is this value an integer?
+ * @private
+ */
+const integer = (val) => Number.isInteger(val);
+
+/**
+ * Is this value within an inclusive given range?
+ * @private
+ */
+const inRange = (val, min, max) => val >= min && val <= max;
+
+/**
+ * Is this value within the elements of an array?
+ * @private
+ */
+const inArray = (val, list) => list.includes(val);
+
+/**
+ * Create an Error with a message relating to an invalid parameter.
+ *
+ * @param {string} name - parameter name.
+ * @param {string} expected - description of the type/value/range expected.
+ * @param {*} actual - the value received.
+ * @returns {Error} Containing the formatted message.
+ * @private
+ */
+const invalidParameterError = (name, expected, actual) => new Error(
+    `Expected ${expected} for ${name} but received ${actual} of type ${typeof actual}`
+  );
+
+/**
+ * Ensures an Error from C++ contains a JS stack.
+ *
+ * @param {Error} native - Error with message from C++.
+ * @param {Error} context - Error with stack from JS.
+ * @returns {Error} Error with message and stack.
+ * @private
+ */
+const nativeError = (native, context) => {
+  context.message = native.message;
+  return context;
+};
+
+export default {
+  defined,
+  object,
+  plainObject,
+  fn,
+  bool,
+  buffer,
+  typedArray,
+  arrayBuffer,
+  string,
+  number,
+  integer,
+  inRange,
+  inArray,
+  invalidParameterError,
+  nativeError
+};

package/{lib/libvips.js → dist/libvips.cjs}

@@ -5,20 +5,18 @@
 
 const { spawnSync } = require('node:child_process');
 const { createHash } = require('node:crypto');
-const semverCoerce = require('semver/functions/coerce');
-const semverGreaterThanOrEqualTo = require('semver/functions/gte');
-const semverSatisfies = require('semver/functions/satisfies');
+const semver = require('semver');
 const detectLibc = require('detect-libc');
-
-const { config, engines, optionalDependencies } = require('../package.json');
+const pkg = require('../package.json');
 
 /* node:coverage ignore next */
-const minimumLibvipsVersionLabelled = process.env.npm_package_config_libvips || config.libvips;
-const minimumLibvipsVersion = semverCoerce(minimumLibvipsVersionLabelled).version;
+const minimumLibvipsVersionLabelled = process.env.npm_package_config_libvips || pkg.config.libvips;
+const minimumLibvipsVersion = semver.coerce(minimumLibvipsVersionLabelled).version;
 
 const prebuiltPlatforms = [
   'darwin-arm64', 'darwin-x64',
-  'linux-arm', 'linux-arm64', 'linux-ppc64', 'linux-riscv64', 'linux-s390x', 'linux-x64',
+  'freebsd-arm64', 'freebsd-x64',
+  'linux-arm', 'linux-arm64', 'linux-ppc64', 'linux-riscv64', 'linux-s390x', 'linux-wasm32', 'linux-x64',
   'linuxmusl-arm64', 'linuxmusl-x64',
   'win32-arm64', 'win32-ia32', 'win32-x64'
 ];
@@ -36,13 +34,13 @@ const log = (item) => {
   }
 };
 
-/* node:coverage ignore next */
+/* node:coverage disable */
+
 const runtimeLibc = () => detectLibc.isNonGlibcLinuxSync() ? detectLibc.familySync() : '';
 
 const runtimePlatformArch = () => `${process.platform}${runtimeLibc()}-${process.arch}`;
 
 const buildPlatformArch = () => {
-  /* node:coverage ignore next 3 */
   if (isEmscripten()) {
     return 'wasm32';
   }
@@ -55,7 +53,6 @@ const buildSharpLibvipsIncludeDir = () => {
   try {
     return require(`@img/sharp-libvips-dev-${buildPlatformArch()}/include`);
   } catch {
-    /* node:coverage ignore next 5 */
     try {
       return require('@img/sharp-libvips-dev/include');
     } catch {}
@@ -64,7 +61,6 @@ const buildSharpLibvipsIncludeDir = () => {
 };
 
 const buildSharpLibvipsCPlusPlusDir = () => {
-  /* node:coverage ignore next 4 */
   try {
     return require('@img/sharp-libvips-dev/cplusplus');
   } catch {}
@@ -75,7 +71,6 @@ const buildSharpLibvipsLibDir = () => {
   try {
     return require(`@img/sharp-libvips-dev-${buildPlatformArch()}/lib`);
   } catch {
-    /* node:coverage ignore next 5 */
     try {
       return require(`@img/sharp-libvips-${buildPlatformArch()}/lib`);
     } catch {}
@@ -83,12 +78,10 @@ const buildSharpLibvipsLibDir = () => {
   return '';
 };
 
-/* node:coverage disable */
-
 const isUnsupportedNodeRuntime = () => {
   if (process.release?.name === 'node' && process.versions) {
-    if (!semverSatisfies(process.versions.node, engines.node)) {
-      return { found: process.versions.node, expected: engines.node };
+    if (!semver.satisfies(process.versions.node, pkg.engines.node)) {
+      return { found: process.versions.node, expected: pkg.engines.node };
     }
   }
 };
@@ -113,7 +106,7 @@ const sha512 = (s) => createHash('sha512').update(s).digest('hex');
 const yarnLocator = () => {
   try {
     const identHash = sha512(`imgsharp-libvips-${buildPlatformArch()}`);
-    const npmVersion = semverCoerce(optionalDependencies[`@img/sharp-libvips-${buildPlatformArch()}`], {
+    const npmVersion = semver.coerce(pkg.optionalDependencies[`@img/sharp-libvips-${buildPlatformArch()}`], {
       includePrerelease: true
     }).version;
     return sha512(`${identHash}npm:${npmVersion}`).slice(0, 10);
@@ -144,22 +137,34 @@ const globalLibvipsVersion = () => {
   }
 };
 
+const getBrewPkgConfigPath = () => {
+  try {
+    const brewPrefix = (spawnSync('brew', ['--prefix'], { encoding: 'utf8' }).stdout || '').trim();
+    if (brewPrefix) {
+      return `${brewPrefix}/lib/pkgconfig`;
+    }
+  } catch (_err) {}
+  return undefined;
+};
+
+const getPkgConfigPath = () => {
+  try {
+    const pkgConfigPath = (spawnSync('pkg-config', ['--variable', 'pc_path', 'pkg-config'], { encoding: 'utf8' }).stdout || '').trim();
+    if (pkgConfigPath) {
+      return pkgConfigPath;
+    }
+  } catch (_err) {}
+  return undefined;
+};
+
 /* node:coverage enable */
 
 const pkgConfigPath = () => {
   if (process.platform !== 'win32') {
-    /* node:coverage ignore next 4 */
-    const brewPkgConfigPath = spawnSync(
-      'which brew >/dev/null 2>&1 && brew environment --plain | grep PKG_CONFIG_LIBDIR | cut -d" " -f2',
-      spawnSyncOptions
-    ).stdout || '';
     return [
-      brewPkgConfigPath.trim(),
-      process.env.PKG_CONFIG_PATH,
-      '/usr/local/lib/pkgconfig',
-      '/usr/lib/pkgconfig',
-      '/usr/local/libdata/pkgconfig',
-      '/usr/libdata/pkgconfig'
+      getBrewPkgConfigPath(),
+      getPkgConfigPath(),
+      process.env.PKG_CONFIG_PATH
     ].filter(Boolean).join(':');
   } else {
     return '';
@@ -186,7 +191,7 @@ const useGlobalLibvips = (logger) => {
   }
   const globalVipsVersion = globalLibvipsVersion();
   /* node:coverage ignore next */
-  return !!globalVipsVersion && semverGreaterThanOrEqualTo(globalVipsVersion, minimumLibvipsVersion);
+  return !!globalVipsVersion && semver.gte(globalVipsVersion, minimumLibvipsVersion);
 };
 
 module.exports = {

package/dist/libvips.mjs

@@ -0,0 +1,212 @@
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
+
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import semver from 'semver';
+import detectLibc from 'detect-libc';
+import pkg from '../package.json' with { type: 'json' };
+
+/* node:coverage ignore next */
+const minimumLibvipsVersionLabelled = process.env.npm_package_config_libvips || pkg.config.libvips;
+const minimumLibvipsVersion = semver.coerce(minimumLibvipsVersionLabelled).version;
+
+const prebuiltPlatforms = [
+  'darwin-arm64', 'darwin-x64',
+  'freebsd-arm64', 'freebsd-x64',
+  'linux-arm', 'linux-arm64', 'linux-ppc64', 'linux-riscv64', 'linux-s390x', 'linux-wasm32', 'linux-x64',
+  'linuxmusl-arm64', 'linuxmusl-x64',
+  'win32-arm64', 'win32-ia32', 'win32-x64'
+];
+
+const spawnSyncOptions = {
+  encoding: 'utf8',
+  shell: true
+};
+
+const log = (item) => {
+  if (item instanceof Error) {
+    console.error(`sharp: Installation error: ${item.message}`);
+  } else {
+    console.log(`sharp: ${item}`);
+  }
+};
+
+/* node:coverage disable */
+
+const runtimeLibc = () => detectLibc.isNonGlibcLinuxSync() ? detectLibc.familySync() : '';
+
+const runtimePlatformArch = () => `${process.platform}${runtimeLibc()}-${process.arch}`;
+
+const buildPlatformArch = () => {
+  if (isEmscripten()) {
+    return 'wasm32';
+  }
+  const { npm_config_arch, npm_config_platform, npm_config_libc } = process.env;
+  const libc = typeof npm_config_libc === 'string' ? npm_config_libc : runtimeLibc();
+  return `${npm_config_platform || process.platform}${libc}-${npm_config_arch || process.arch}`;
+};
+
+const buildSharpLibvipsIncludeDir = () => {
+  try {
+    return require(`@img/sharp-libvips-dev-${buildPlatformArch()}/include`);
+  } catch {
+    try {
+      return require('@img/sharp-libvips-dev/include');
+    } catch {}
+  }
+  return '';
+};
+
+const buildSharpLibvipsCPlusPlusDir = () => {
+  try {
+    return require('@img/sharp-libvips-dev/cplusplus');
+  } catch {}
+  return '';
+};
+
+const buildSharpLibvipsLibDir = () => {
+  try {
+    return require(`@img/sharp-libvips-dev-${buildPlatformArch()}/lib`);
+  } catch {
+    try {
+      return require(`@img/sharp-libvips-${buildPlatformArch()}/lib`);
+    } catch {}
+  }
+  return '';
+};
+
+const isUnsupportedNodeRuntime = () => {
+  if (process.release?.name === 'node' && process.versions) {
+    if (!semver.satisfies(process.versions.node, pkg.engines.node)) {
+      return { found: process.versions.node, expected: pkg.engines.node };
+    }
+  }
+};
+
+const isEmscripten = () => {
+  const { CC } = process.env;
+  return Boolean(CC?.endsWith('/emcc'));
+};
+
+const isRosetta = () => {
+  if (process.platform === 'darwin' && process.arch === 'x64') {
+    const translated = spawnSync('sysctl sysctl.proc_translated', spawnSyncOptions).stdout;
+    return (translated || '').trim() === 'sysctl.proc_translated: 1';
+  }
+  return false;
+};
+
+/* node:coverage enable */
+
+const sha512 = (s) => createHash('sha512').update(s).digest('hex');
+
+const yarnLocator = () => {
+  try {
+    const identHash = sha512(`imgsharp-libvips-${buildPlatformArch()}`);
+    const npmVersion = semver.coerce(pkg.optionalDependencies[`@img/sharp-libvips-${buildPlatformArch()}`], {
+      includePrerelease: true
+    }).version;
+    return sha512(`${identHash}npm:${npmVersion}`).slice(0, 10);
+  } catch {}
+  return '';
+};
+
+/* node:coverage disable */
+
+const spawnRebuild = () =>
+  spawnSync(`node-gyp rebuild --directory=src ${isEmscripten() ? '--nodedir=emscripten' : ''}`, {
+    ...spawnSyncOptions,
+    stdio: 'inherit'
+  }).status;
+
+const globalLibvipsVersion = () => {
+  if (process.platform !== 'win32') {
+    const globalLibvipsVersion = spawnSync('pkg-config --modversion vips-cpp', {
+      ...spawnSyncOptions,
+      env: {
+        ...process.env,
+        PKG_CONFIG_PATH: pkgConfigPath()
+      }
+    }).stdout;
+    return (globalLibvipsVersion || '').trim();
+  } else {
+    return '';
+  }
+};
+
+const getBrewPkgConfigPath = () => {
+  try {
+    const brewPrefix = (spawnSync('brew', ['--prefix'], { encoding: 'utf8' }).stdout || '').trim();
+    if (brewPrefix) {
+      return `${brewPrefix}/lib/pkgconfig`;
+    }
+  } catch (_err) {}
+  return undefined;
+};
+
+const getPkgConfigPath = () => {
+  try {
+    const pkgConfigPath = (spawnSync('pkg-config', ['--variable', 'pc_path', 'pkg-config'], { encoding: 'utf8' }).stdout || '').trim();
+    if (pkgConfigPath) {
+      return pkgConfigPath;
+    }
+  } catch (_err) {}
+  return undefined;
+};
+
+/* node:coverage enable */
+
+const pkgConfigPath = () => {
+  if (process.platform !== 'win32') {
+    return [
+      getBrewPkgConfigPath(),
+      getPkgConfigPath(),
+      process.env.PKG_CONFIG_PATH
+    ].filter(Boolean).join(':');
+  } else {
+    return '';
+  }
+};
+
+const skipSearch = (status, reason, logger) => {
+  if (logger) {
+    logger(`Detected ${reason}, skipping search for globally-installed libvips`);
+  }
+  return status;
+};
+
+const useGlobalLibvips = (logger) => {
+  if (Boolean(process.env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
+    return skipSearch(false, 'SHARP_IGNORE_GLOBAL_LIBVIPS', logger);
+  }
+  if (Boolean(process.env.SHARP_FORCE_GLOBAL_LIBVIPS) === true) {
+    return skipSearch(true, 'SHARP_FORCE_GLOBAL_LIBVIPS', logger);
+  }
+  /* node:coverage ignore next 3 */
+  if (isRosetta()) {
+    return skipSearch(false, 'Rosetta', logger);
+  }
+  const globalVipsVersion = globalLibvipsVersion();
+  /* node:coverage ignore next */
+  return !!globalVipsVersion && semver.gte(globalVipsVersion, minimumLibvipsVersion);
+};
+
+export default {
+  minimumLibvipsVersion,
+  prebuiltPlatforms,
+  buildPlatformArch,
+  buildSharpLibvipsIncludeDir,
+  buildSharpLibvipsCPlusPlusDir,
+  buildSharpLibvipsLibDir,
+  isUnsupportedNodeRuntime,
+  runtimePlatformArch,
+  log,
+  yarnLocator,
+  spawnRebuild,
+  globalLibvipsVersion,
+  pkgConfigPath,
+  useGlobalLibvips
+};

package/{lib/operation.js → dist/operation.cjs}

@@ -3,7 +3,7 @@
   SPDX-License-Identifier: Apache-2.0
 */
 
-const is = require('./is');
+const is = require('./is.cjs');
 
 /**
  * How accurate an operation should be.
@@ -78,6 +78,10 @@ function rotate (angle, options) {
  * Auto-orient based on the EXIF `Orientation` tag, then remove the tag.
  * Mirroring is supported and may infer the use of a flip operation.
  *
+ * Only the EXIF `Orientation` tag is considered; orientation carried in other
+ * places, such as an XMP `tiff:Orientation` element, is left untouched and
+ * remains the responsibility of the consumer.
+ *
  * Previous or subsequent use of `rotate(angle)` and either `flip()` or `flop()`
  * will logically occur after auto-orientation, regardless of call order.
  *
@@ -178,7 +182,13 @@ function flop (flop) {
  * @throws {Error} Invalid parameters
  */
 function affine (matrix, options) {
-  const flatMatrix = [].concat(...matrix);
+  const isValidShape = Array.isArray(matrix) && (
+    // 1x4 array of numbers
+    (matrix.length === 4 && matrix.every(is.number)) ||
+    // 2x2 array of arrays of numbers
+    (matrix.length === 2 && matrix.every((row) => Array.isArray(row) && row.length === 2))
+  );
+  const flatMatrix = isValidShape ? matrix.flat() : [];
   if (flatMatrix.length === 4 && flatMatrix.every(is.number)) {
     this.options.affineMatrix = flatMatrix;
   } else {
@@ -259,45 +269,18 @@ function affine (matrix, options) {
  *   })
  *   .toBuffer();
  *
- * @param {Object|number} [options] - if present, is an Object with attributes
+ * @param {Object} [options] - if present, is an Object with attributes
  * @param {number} [options.sigma] - the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`, between 0.000001 and 10
  * @param {number} [options.m1=1.0] - the level of sharpening to apply to "flat" areas, between 0 and 1000000
  * @param {number} [options.m2=2.0] - the level of sharpening to apply to "jagged" areas, between 0 and 1000000
  * @param {number} [options.x1=2.0] - threshold between "flat" and "jagged", between 0 and 1000000
  * @param {number} [options.y2=10.0] - maximum amount of brightening, between 0 and 1000000
  * @param {number} [options.y3=20.0] - maximum amount of darkening, between 0 and 1000000
- * @param {number} [flat] - (deprecated) see `options.m1`.
- * @param {number} [jagged] - (deprecated) see `options.m2`.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
-function sharpen (options, flat, jagged) {
-  if (!is.defined(options)) {
-    // No arguments: default to mild sharpen
-    this.options.sharpenSigma = -1;
-  } else if (is.bool(options)) {
-    // Deprecated boolean argument: apply mild sharpen?
-    this.options.sharpenSigma = options ? -1 : 0;
-  } else if (is.number(options) && is.inRange(options, 0.01, 10000)) {
-    // Deprecated numeric argument: specific sigma
-    this.options.sharpenSigma = options;
-    // Deprecated control over flat areas
-    if (is.defined(flat)) {
-      if (is.number(flat) && is.inRange(flat, 0, 10000)) {
-        this.options.sharpenM1 = flat;
-      } else {
-        throw is.invalidParameterError('flat', 'number between 0 and 10000', flat);
-      }
-    }
-    // Deprecated control over jagged areas
-    if (is.defined(jagged)) {
-      if (is.number(jagged) && is.inRange(jagged, 0, 10000)) {
-        this.options.sharpenM2 = jagged;
-      } else {
-        throw is.invalidParameterError('jagged', 'number between 0 and 10000', jagged);
-      }
-    }
-  } else if (is.plainObject(options)) {
+function sharpen (options) {
+  if (is.plainObject(options)) {
     if (is.number(options.sigma) && is.inRange(options.sigma, 0.000001, 10)) {
       this.options.sharpenSigma = options.sigma;
     } else {
@@ -339,7 +322,7 @@ function sharpen (options, flat, jagged) {
       }
     }
   } else {
-    throw is.invalidParameterError('sigma', 'number between 0.01 and 10000', options);
+    this.options.sharpenSigma = -1;
   }
   return this;
 }
@@ -451,10 +434,10 @@ function blur (options) {
 function dilate (width) {
   if (!is.defined(width)) {
     this.options.dilateWidth = 1;
-  } else if (is.integer(width) && width > 0) {
+  } else if (is.integer(width) && is.inRange(width, 1, 65536)) {
     this.options.dilateWidth = width;
   } else {
-    throw is.invalidParameterError('dilate', 'positive integer', dilate);
+    throw is.invalidParameterError('width', 'integer between 1 and 65536', width);
   }
   return this;
 }
@@ -474,10 +457,10 @@ function dilate (width) {
 function erode (width) {
   if (!is.defined(width)) {
     this.options.erodeWidth = 1;
-  } else if (is.integer(width) && width > 0) {
+  } else if (is.integer(width) && is.inRange(width, 1, 65536)) {
     this.options.erodeWidth = width;
   } else {
-    throw is.invalidParameterError('erode', 'positive integer', erode);
+    throw is.invalidParameterError('width', 'integer between 1 and 65536', width);
   }
   return this;
 }
@@ -510,8 +493,6 @@ function flatten (options) {
  *
  * Existing alpha channel values for non-white pixels remain unchanged.
  *
- * This feature is experimental and the API may change.
- *
  * @since 0.32.1
  *
  * @example
@@ -675,23 +656,23 @@ function normalize (options) {
  *   .toBuffer();
  *
  * @param {Object} options
- * @param {number} options.width - Integral width of the search window, in pixels.
- * @param {number} options.height - Integral height of the search window, in pixels.
+ * @param {number} options.width - Integral width of the search window, in pixels, between 1 and 65536.
+ * @param {number} options.height - Integral height of the search window, in pixels, between 1 and 65536.
  * @param {number} [options.maxSlope=3] - Integral level of brightening, between 0 and 100, where 0 disables contrast limiting.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
 function clahe (options) {
   if (is.plainObject(options)) {
-    if (is.integer(options.width) && options.width > 0) {
+    if (is.integer(options.width) && is.inRange(options.width, 1, 65536)) {
       this.options.claheWidth = options.width;
     } else {
-      throw is.invalidParameterError('width', 'integer greater than zero', options.width);
+      throw is.invalidParameterError('width', 'integer between 1 and 65536', options.width);
     }
-    if (is.integer(options.height) && options.height > 0) {
+    if (is.integer(options.height) && is.inRange(options.height, 1, 65536)) {
       this.options.claheHeight = options.height;
     } else {
-      throw is.invalidParameterError('height', 'integer greater than zero', options.height);
+      throw is.invalidParameterError('height', 'integer between 1 and 65536', options.height);
     }
     if (is.defined(options.maxSlope)) {
       if (is.integer(options.maxSlope) && is.inRange(options.maxSlope, 0, 100)) {
@@ -735,7 +716,8 @@ function convolve (kernel) {
   if (!is.object(kernel) || !Array.isArray(kernel.kernel) ||
       !is.integer(kernel.width) || !is.integer(kernel.height) ||
       !is.inRange(kernel.width, 3, 1001) || !is.inRange(kernel.height, 3, 1001) ||
-      kernel.height * kernel.width !== kernel.kernel.length
+      kernel.height * kernel.width !== kernel.kernel.length ||
+      !kernel.kernel.every(is.number)
   ) {
     // must pass in a kernel
     throw new Error('Invalid convolution kernel');
@@ -888,12 +870,16 @@ function recomb (inputMatrix) {
   if (!Array.isArray(inputMatrix)) {
     throw is.invalidParameterError('inputMatrix', 'array', inputMatrix);
   }
-  if (inputMatrix.length !== 3 && inputMatrix.length !== 4) {
-    throw is.invalidParameterError('inputMatrix', '3x3 or 4x4 array', inputMatrix.length);
+  const dimensions = inputMatrix.length;
+  if (dimensions !== 3 && dimensions !== 4) {
+    throw is.invalidParameterError('inputMatrix', '3x3 or 4x4 array', dimensions);
+  }
+  if (!inputMatrix.every((row) => Array.isArray(row) && row.length === dimensions)) {
+    throw is.invalidParameterError('inputMatrix', `array of ${dimensions} arrays of length ${dimensions}`, inputMatrix);
   }
-  const recombMatrix = inputMatrix.flat().map(Number);
-  if (recombMatrix.length !== 9 && recombMatrix.length !== 16) {
-    throw is.invalidParameterError('inputMatrix', 'cardinality of 9 or 16', recombMatrix.length);
+  const recombMatrix = inputMatrix.flat();
+  if (!recombMatrix.every(is.number)) {
+    throw is.invalidParameterError('inputMatrix', 'array of numbers', recombMatrix);
   }
   this.options.recombMatrix = recombMatrix;
   return this;