sharp 0.30.2 → 0.30.5

package/install/libvips.js

@@ -35,6 +35,7 @@ const hasSharpPrebuild = [
 ];
 
 const { minimumLibvipsVersion, minimumLibvipsVersionLabelled } = libvips;
+const localLibvipsDir = process.env.npm_config_sharp_libvips_local_prebuilds || '';
 const distHost = process.env.npm_config_sharp_libvips_binary_host || 'https://github.com/lovell/sharp-libvips/releases/download';
 const distBaseUrl = process.env.npm_config_sharp_dist_base_url || process.env.SHARP_DIST_BASE_URL || `${distHost}/v${minimumLibvipsVersionLabelled}/`;
 const installationForced = !!(process.env.npm_config_sharp_install_force || process.env.SHARP_INSTALL_FORCE);
@@ -42,7 +43,9 @@ const installationForced = !!(process.env.npm_config_sharp_install_force || proc
 const fail = function (err) {
   libvips.log(err);
   if (err.code === 'EACCES') {
-    libvips.log('Are you trying to install as a root or sudo user? Try again with the --unsafe-perm flag');
+    libvips.log('Are you trying to install as a root or sudo user?');
+    libvips.log('- For npm <= v6, try again with the "--unsafe-perm" flag');
+    libvips.log('- For npm >= v8, the user must own the directory "npm install" is run in');
   }
   libvips.log('Please see https://sharp.pixelplumbing.com/install for required dependencies');
   process.exit(1);
@@ -156,6 +159,11 @@ try {
     if (fs.existsSync(tarPathCache)) {
       libvips.log(`Using cached ${tarPathCache}`);
       extractTarball(tarPathCache, platformAndArch);
+    } else if (localLibvipsDir) {
+      // If localLibvipsDir is given try to use binaries from local directory
+      const tarPathLocal = path.join(path.resolve(localLibvipsDir), `v${minimumLibvipsVersionLabelled}`, tarFilename);
+      libvips.log(`Using local libvips from ${tarPathLocal}`);
+      extractTarball(tarPathLocal, platformAndArch);
     } else {
       const url = distBaseUrl + tarFilename;
       libvips.log(`Downloading ${url}`);

package/lib/colour.js

@@ -19,6 +19,11 @@ const colourspace = {
  * Tint the image using the provided chroma while preserving the image luminance.
  * An alpha channel may be present and will be unchanged by the operation.
  *
+ * @example
+ * const output = await sharp(input)
+ *   .tint({ r: 255, g: 240, b: 16 })
+ *   .toBuffer();
+ *
  * @param {string|Object} rgb - parsed by the [color](https://www.npmjs.org/package/color) module to extract chroma values.
  * @returns {Sharp}
  * @throws {Error} Invalid parameter
@@ -37,6 +42,10 @@ function tint (rgb) {
  * This may be overridden by other sharp operations such as `toColourspace('b-w')`,
  * which will produce an output image containing one color channel.
  * An alpha channel may be present, and will be unchanged by the operation.
+ *
+ * @example
+ * const output = await sharp(input).greyscale().toBuffer();
+ *
  * @param {Boolean} [greyscale=true]
  * @returns {Sharp}
  */

package/lib/composite.js

@@ -50,12 +50,27 @@ const blend = {
  * `hard-light`, `soft-light`, `difference`, `exclusion`.
  *
  * More information about blend modes can be found at
- * https://libvips.github.io/libvips/API/current/libvips-conversion.html#VipsBlendMode
+ * https://www.libvips.org/API/current/libvips-conversion.html#VipsBlendMode
  * and https://www.cairographics.org/operators/
  *
  * @since 0.22.0
  *
  * @example
+ * await sharp(background)
+ *   .composite([
+ *     { input: layer1, gravity: 'northwest' },
+ *     { input: layer2, gravity: 'southeast' },
+ *   ])
+ *   .toFile('combined.png');
+ *
+ * @example
+ * const output = await sharp('input.gif', { animated: true })
+ *   .composite([
+ *     { input: 'overlay.png', tile: true, blend: 'saturate' }
+ *   ])
+ *   .toBuffer();
+ *
+ * @example
  * sharp('input.png')
  *   .rotate(180)
  *   .resize(300)
@@ -89,7 +104,8 @@ const blend = {
  * @param {Number} [images[].raw.width]
  * @param {Number} [images[].raw.height]
  * @param {Number} [images[].raw.channels]
- * @param {boolean} [images[].failOnError=true] - @see {@link /api-constructor#parameters|constructor parameters}
+ * @param {boolean} [images[].animated=false] - Set to `true` to read all frames/pages of an animated image.
+ * @param {string} [images[].failOn='warning'] - @see {@link /api-constructor#parameters|constructor parameters}
  * @param {number|boolean} [images[].limitInputPixels=268402689] - @see {@link /api-constructor#parameters|constructor parameters}
  * @returns {Sharp}
  * @throws {Error} Invalid parameters

package/lib/constructor.js

@@ -98,8 +98,7 @@ const debuglog = util.debuglog('sharp');
  *  a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file.
  *  JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
  * @param {Object} [options] - if present, is an Object with optional attributes.
- * @param {boolean} [options.failOnError=true] - by default halt processing and raise an error when loading invalid images.
- *  Set this flag to `false` if you'd rather apply a "best effort" to decode images, even if the data is corrupt or invalid.
+ * @param {string} [options.failOn='warning'] - level of sensitivity to invalid images, one of (in order of sensitivity): 'none' (least), 'truncated', 'error' or 'warning' (most), highers level imply lower levels.
  * @param {number|boolean} [options.limitInputPixels=268402689] - Do not process input images where the number of pixels
  *  (width x height) exceeds this limit. Assumes image dimensions contained in the input metadata can be trusted.
  *  An integral Number of pixels, zero or false to remove limit, true to use default limit of 268402689 (0x3FFF x 0x3FFF).
@@ -186,8 +185,11 @@ const Sharp = function (input, options) {
     medianSize: 0,
     blurSigma: 0,
     sharpenSigma: 0,
-    sharpenFlat: 1,
-    sharpenJagged: 2,
+    sharpenM1: 1,
+    sharpenM2: 2,
+    sharpenX1: 2,
+    sharpenY2: 10,
+    sharpenY3: 20,
     threshold: 0,
     thresholdGrayscale: true,
     trimThreshold: 0,
@@ -317,9 +319,7 @@ Object.setPrototypeOf(Sharp, stream.Duplex);
  * // Using Promises to know when the pipeline is complete
  * const fs = require("fs");
  * const got = require("got");
- * const sharpStream = sharp({
- *   failOnError: false
- * });
+ * const sharpStream = sharp({ failOn: 'none' });
  *
  * const promises = [];
  *

package/lib/input.js

@@ -9,9 +9,9 @@ const sharp = require('./sharp');
  * @private
  */
 function _inputOptionsFromObject (obj) {
-  const { raw, density, limitInputPixels, unlimited, sequentialRead, failOnError, animated, page, pages, subifd } = obj;
-  return [raw, density, limitInputPixels, unlimited, sequentialRead, failOnError, animated, page, pages, subifd].some(is.defined)
-    ? { raw, density, limitInputPixels, unlimited, sequentialRead, failOnError, animated, page, pages, subifd }
+  const { raw, density, limitInputPixels, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd } = obj;
+  return [raw, density, limitInputPixels, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd].some(is.defined)
+    ? { raw, density, limitInputPixels, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd }
     : undefined;
 }
 
@@ -21,7 +21,7 @@ function _inputOptionsFromObject (obj) {
  */
 function _createInputDescriptor (input, inputOptions, containerOptions) {
   const inputDescriptor = {
-    failOnError: true,
+    failOn: 'warning',
     limitInputPixels: Math.pow(0x3FFF, 2),
     unlimited: false,
     sequentialRead: false
@@ -39,7 +39,7 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     if (input.length === 0) {
       throw Error('Input Bit Array is empty');
     }
-    inputDescriptor.buffer = Buffer.from(input.buffer);
+    inputDescriptor.buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
   } else if (is.plainObject(input) && !is.defined(inputOptions)) {
     // Plain Object descriptor, e.g. create
     inputOptions = input;
@@ -56,14 +56,22 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     }`);
   }
   if (is.object(inputOptions)) {
-    // Fail on error
+    // Deprecated: failOnError
     if (is.defined(inputOptions.failOnError)) {
       if (is.bool(inputOptions.failOnError)) {
-        inputDescriptor.failOnError = inputOptions.failOnError;
+        inputDescriptor.failOn = inputOptions.failOnError ? 'warning' : 'none';
       } else {
         throw is.invalidParameterError('failOnError', 'boolean', inputOptions.failOnError);
       }
     }
+    // failOn
+    if (is.defined(inputOptions.failOn)) {
+      if (is.string(inputOptions.failOn) && is.inArray(inputOptions.failOn, ['none', 'truncated', 'error', 'warning'])) {
+        inputDescriptor.failOn = inputOptions.failOn;
+      } else {
+        throw is.invalidParameterError('failOn', 'one of: none, truncated, error, warning', inputOptions.failOn);
+      }
+    }
     // Density
     if (is.defined(inputOptions.density)) {
       if (is.inRange(inputOptions.density, 1, 100000)) {
@@ -299,11 +307,11 @@ function _isStreamInput () {
  *
  * - `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
  * - `size`: Total size of image in bytes, for Stream and Buffer input only
- * - `width`: Number of pixels wide (EXIF orientation is not taken into consideration)
- * - `height`: Number of pixels high (EXIF orientation is not taken into consideration)
- * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation)
+ * - `width`: Number of pixels wide (EXIF orientation is not taken into consideration, see example below)
+ * - `height`: Number of pixels high (EXIF orientation is not taken into consideration, see example below)
+ * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://www.libvips.org/API/current/VipsImage.html#VipsInterpretation)
  * - `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
- * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://libvips.github.io/libvips/API/current/VipsImage.html#VipsBandFormat)
+ * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://www.libvips.org/API/current/VipsImage.html#VipsBandFormat)
  * - `density`: Number of pixels per inch (DPI), if present
  * - `chromaSubsampling`: String containing JPEG chroma subsampling, `4:2:0` or `4:4:4` for RGB, `4:2:0:4` or `4:4:4:4` for CMYK
  * - `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
@@ -343,6 +351,17 @@ function _isStreamInput () {
  *     // data contains a WebP image half the width and height of the original JPEG
  *   });
  *
+ * @example
+ * // Based on EXIF rotation metadata, get the right-side-up width and height:
+ *
+ * const size = getNormalSize(await sharp(input).metadata());
+ *
+ * function getNormalSize({ width, height, orientation }) {
+ *   return orientation || 0 >= 5
+ *     ? { width: height, height: width }
+ *     : { width, height };
+ * }
+ *
  * @param {Function} [callback] - called with the arguments `(err, metadata)`
  * @returns {Promise<Object>|Sharp}
  */
@@ -401,9 +420,9 @@ function metadata (callback) {
  *     - `maxX` (x-coordinate of one of the pixel where the maximum lies)
  *     - `maxY` (y-coordinate of one of the pixel where the maximum lies)
  * - `isOpaque`: Is the image fully opaque? Will be `true` if the image has no alpha channel or if every pixel is fully opaque.
- * - `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any (experimental)
- * - `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any (experimental)
- * - `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram (experimental)
+ * - `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any.
+ * - `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any.
+ * - `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram.
  *
  * **Note**: Statistics are derived from the original input image. Any operations performed on the image must first be
  * written to a buffer in order to run `stats` on the result (see third example).

package/lib/libvips.js

@@ -65,7 +65,12 @@ const isRosetta = function () {
 
 const globalLibvipsVersion = function () {
   if (process.platform !== 'win32') {
-    const globalLibvipsVersion = spawnSync(`PKG_CONFIG_PATH="${pkgConfigPath()}" pkg-config --modversion vips-cpp`, spawnSyncOptions).stdout;
+    const globalLibvipsVersion = spawnSync('pkg-config --modversion vips-cpp', {
+      ...spawnSyncOptions,
+      env: {
+        PKG_CONFIG_PATH: pkgConfigPath()
+      }
+    }).stdout;
     /* istanbul ignore next */
     return (globalLibvipsVersion || '').trim();
   } else {
@@ -85,7 +90,10 @@ const removeVendoredLibvips = function () {
 
 const pkgConfigPath = function () {
   if (process.platform !== 'win32') {
-    const brewPkgConfigPath = spawnSync('which brew >/dev/null 2>&1 && eval $(brew --env) && echo $PKG_CONFIG_LIBDIR', spawnSyncOptions).stdout || '';
+    const brewPkgConfigPath = spawnSync(
+      'which brew >/dev/null 2>&1 && brew environment --plain | grep PKG_CONFIG_LIBDIR | cut -d" " -f2',
+      spawnSyncOptions
+    ).stdout || '';
     return [
       brewPkgConfigPath.trim(),
       env.PKG_CONFIG_PATH,

package/lib/operation.js

@@ -63,6 +63,10 @@ function rotate (angle, options) {
 /**
  * Flip the image about the vertical Y axis. This always occurs after rotation, if any.
  * The use of `flip` implies the removal of the EXIF `Orientation` tag, if any.
+ *
+ * @example
+ * const output = await sharp(input).flip().toBuffer();
+ *
  * @param {Boolean} [flip=true]
  * @returns {Sharp}
  */
@@ -74,6 +78,10 @@ function flip (flip) {
 /**
  * Flop the image about the horizontal X axis. This always occurs after rotation, if any.
  * The use of `flop` implies the removal of the EXIF `Orientation` tag, if any.
+ *
+ * @example
+ * const output = await sharp(input).flop().toBuffer();
+ *
  * @param {Boolean} [flop=true]
  * @returns {Sharp}
  */
@@ -185,40 +193,107 @@ function affine (matrix, options) {
  * When a `sigma` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space.
  * Separate control over the level of sharpening in "flat" and "jagged" areas is available.
  *
- * @param {number} [sigma] - the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
- * @param {number} [flat=1.0] - the level of sharpening to apply to "flat" areas.
- * @param {number} [jagged=2.0] - the level of sharpening to apply to "jagged" areas.
+ * See {@link https://www.libvips.org/API/current/libvips-convolution.html#vips-sharpen|libvips sharpen} operation.
+ *
+ * @example
+ * const data = await sharp(input).sharpen().toBuffer();
+ *
+ * @example
+ * const data = await sharp(input).sharpen({ sigma: 2 }).toBuffer();
+ *
+ * @example
+ * const data = await sharp(input)
+ *   .sharpen({
+ *     sigma: 2,
+ *     m1: 0
+ *     m2: 3,
+ *     x1: 3,
+ *     y2: 15,
+ *     y3: 15,
+ *   })
+ *   .toBuffer();
+ *
+ * @param {Object|number} [options] - if present, is an Object with attributes or (deprecated) a number for `options.sigma`.
+ * @param {number} [options.sigma] - the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+ * @param {number} [options.m1=1.0] - the level of sharpening to apply to "flat" areas.
+ * @param {number} [options.m2=2.0] - the level of sharpening to apply to "jagged" areas.
+ * @param {number} [options.x1=2.0] - threshold between "flat" and "jagged"
+ * @param {number} [options.y2=10.0] - maximum amount of brightening.
+ * @param {number} [options.y3=20.0] - maximum amount of darkening.
+ * @param {number} [flat] - (deprecated) see `options.m1`.
+ * @param {number} [jagged] - (deprecated) see `options.m2`.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
-function sharpen (sigma, flat, jagged) {
-  if (!is.defined(sigma)) {
+function sharpen (options, flat, jagged) {
+  if (!is.defined(options)) {
     // No arguments: default to mild sharpen
     this.options.sharpenSigma = -1;
-  } else if (is.bool(sigma)) {
-    // Boolean argument: apply mild sharpen?
-    this.options.sharpenSigma = sigma ? -1 : 0;
-  } else if (is.number(sigma) && is.inRange(sigma, 0.01, 10000)) {
-    // Numeric argument: specific sigma
-    this.options.sharpenSigma = sigma;
-    // Control over flat areas
+  } 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.sharpenFlat = flat;
+        this.options.sharpenM1 = flat;
       } else {
         throw is.invalidParameterError('flat', 'number between 0 and 10000', flat);
       }
     }
-    // Control over jagged areas
+    // Deprecated control over jagged areas
     if (is.defined(jagged)) {
       if (is.number(jagged) && is.inRange(jagged, 0, 10000)) {
-        this.options.sharpenJagged = jagged;
+        this.options.sharpenM2 = jagged;
       } else {
         throw is.invalidParameterError('jagged', 'number between 0 and 10000', jagged);
       }
     }
+  } else if (is.plainObject(options)) {
+    if (is.number(options.sigma) && is.inRange(options.sigma, 0.01, 10000)) {
+      this.options.sharpenSigma = options.sigma;
+    } else {
+      throw is.invalidParameterError('options.sigma', 'number between 0.01 and 10000', options.sigma);
+    }
+    if (is.defined(options.m1)) {
+      if (is.number(options.m1) && is.inRange(options.m1, 0, 10000)) {
+        this.options.sharpenM1 = options.m1;
+      } else {
+        throw is.invalidParameterError('options.m1', 'number between 0 and 10000', options.m1);
+      }
+    }
+    if (is.defined(options.m2)) {
+      if (is.number(options.m2) && is.inRange(options.m2, 0, 10000)) {
+        this.options.sharpenM2 = options.m2;
+      } else {
+        throw is.invalidParameterError('options.m2', 'number between 0 and 10000', options.m2);
+      }
+    }
+    if (is.defined(options.x1)) {
+      if (is.number(options.x1) && is.inRange(options.x1, 0, 10000)) {
+        this.options.sharpenX1 = options.x1;
+      } else {
+        throw is.invalidParameterError('options.x1', 'number between 0 and 10000', options.x1);
+      }
+    }
+    if (is.defined(options.y2)) {
+      if (is.number(options.y2) && is.inRange(options.y2, 0, 10000)) {
+        this.options.sharpenY2 = options.y2;
+      } else {
+        throw is.invalidParameterError('options.y2', 'number between 0 and 10000', options.y2);
+      }
+    }
+    if (is.defined(options.y3)) {
+      if (is.number(options.y3) && is.inRange(options.y3, 0, 10000)) {
+        this.options.sharpenY3 = options.y3;
+      } else {
+        throw is.invalidParameterError('options.y3', 'number between 0 and 10000', options.y3);
+      }
+    }
   } else {
-    throw is.invalidParameterError('sigma', 'number between 0.01 and 10000', sigma);
+    throw is.invalidParameterError('sigma', 'number between 0.01 and 10000', options);
   }
   return this;
 }
@@ -226,6 +301,13 @@ function sharpen (sigma, flat, jagged) {
 /**
  * Apply median filter.
  * When used without parameters the default window is 3x3.
+ *
+ * @example
+ * const output = await sharp(input).median().toBuffer();
+ *
+ * @example
+ * const output = await sharp(input).median(5).toBuffer();
+ *
  * @param {number} [size=3] square mask size: size x size
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
@@ -338,6 +420,17 @@ function gamma (gamma, gammaOut) {
 
 /**
  * Produce the "negative" of the image.
+ *
+ * @example
+ * const output = await sharp(input)
+ *   .negate()
+ *   .toBuffer();
+ *
+ * @example
+ * const output = await sharp(input)
+ *   .negate({ alpha: false })
+ *   .toBuffer();
+ *
  * @param {Object} [options]
  * @param {Boolean} [options.alpha=true] Whether or not to negate any alpha channel
  * @returns {Sharp}
@@ -356,6 +449,10 @@ function negate (options) {
 
 /**
  * Enhance output image contrast by stretching its luminance to cover the full dynamic range.
+ *
+ * @example
+ * const output = await sharp(input).normalise().toBuffer();
+ *
  * @param {Boolean} [normalise=true]
  * @returns {Sharp}
  */
@@ -366,6 +463,10 @@ function normalise (normalise) {
 
 /**
  * Alternative spelling of normalise.
+ *
+ * @example
+ * const output = await sharp(input).normalize().toBuffer();
+ *
  * @param {Boolean} [normalize=true]
  * @returns {Sharp}
  */
@@ -381,6 +482,14 @@ function normalize (normalize) {
  *
  * @since 0.28.3
  *
+ * @example
+ * const output = await sharp(input)
+ *   .clahe({
+ *     width: 3,
+ *     height: 3,
+ *   })
+ *   .toBuffer();
+ *
  * @param {Object} options
  * @param {number} options.width - integer width of the region in pixels.
  * @param {number} options.height - integer height of the region in pixels.
@@ -590,28 +699,38 @@ function recomb (inputMatrix) {
  * @since 0.22.1
  *
  * @example
- * sharp(input)
+ * // increase brightness by a factor of 2
+ * const output = await sharp(input)
  *   .modulate({
- *     brightness: 2 // increase brightness by a factor of 2
- *   });
+ *     brightness: 2
+ *   })
+ *   .toBuffer();
  *
- * sharp(input)
+ * @example
+ * // hue-rotate by 180 degrees
+ * const output = await sharp(input)
  *   .modulate({
- *     hue: 180 // hue-rotate by 180 degrees
- *   });
+ *     hue: 180
+ *   })
+ *   .toBuffer();
  *
- * sharp(input)
+ * @example
+ * // increase lightness by +50
+ * const output = await sharp(input)
  *   .modulate({
- *     lightness: 50 // increase lightness by +50
- *   });
+ *     lightness: 50
+ *   })
+ *   .toBuffer();
  *
+ * @example
  * // decreate brightness and saturation while also hue-rotating by 90 degrees
- * sharp(input)
+ * const output = await sharp(input)
  *   .modulate({
  *     brightness: 0.5,
  *     saturation: 0.5,
- *     hue: 90
- *   });
+ *     hue: 90,
+ *   })
+ *   .toBuffer();
  *
  * @param {Object} [options]
  * @param {number} [options.brightness] Brightness multiplier

package/lib/output.js

@@ -82,6 +82,8 @@ function toFile (fileOut, callback) {
  * Write output to a Buffer.
  * JPEG, PNG, WebP, AVIF, TIFF, GIF and raw pixel data output are supported.
  *
+ * Use {@link toFormat} or one of the format-specific functions such as {@link jpeg}, {@link png} etc. to set the output format.
+ *
  * If no explicit format is set, the output format will match the input image, except SVG input which becomes PNG output.
  *
  * By default all metadata will be removed, which includes EXIF-based orientation.
@@ -108,6 +110,7 @@ function toFile (fileOut, callback) {
  *
  * @example
  * sharp(input)
+ *   .png()
  *   .toBuffer({ resolveWithObject: true })
  *   .then(({ data, info }) => { ... })
  *   .catch(err => { ... });
@@ -151,6 +154,8 @@ function toBuffer (options, callback) {
  * The default behaviour, when `withMetadata` is not used, is to convert to the device-independent
  * sRGB colour space and strip all metadata, including the removal of any ICC profile.
  *
+ * EXIF metadata is unsupported for TIFF output.
+ *
  * @example
  * sharp('input.jpg')
  *   .withMetadata()
@@ -514,7 +519,7 @@ function webp (options) {
  * // Convert PNG to GIF
  * await sharp(pngBuffer)
  *   .gif()
- *   .toBuffer());
+ *   .toBuffer();
  *
  * @example
  * // Convert animated WebP to animated GIF

package/lib/platform.js

@@ -7,10 +7,12 @@ const env = process.env;
 module.exports = function () {
   const arch = env.npm_config_arch || process.arch;
   const platform = env.npm_config_platform || process.platform;
-  /* istanbul ignore next */
-  const libc = (platform === 'linux' && detectLibc.isNonGlibcLinuxSync()) ? detectLibc.familySync() : '';
+  const libc = process.env.npm_config_libc ||
+    /* istanbul ignore next */
+    (detectLibc.isNonGlibcLinuxSync() ? detectLibc.familySync() : '');
+  const libcId = platform !== 'linux' || libc === detectLibc.GLIBC ? '' : libc;
 
-  const platformId = [`${platform}${libc}`];
+  const platformId = [`${platform}${libcId}`];
 
   if (arch === 'arm') {
     const fallback = process.versions.electron ? '7' : '6';

package/lib/sharp.js

@@ -13,7 +13,7 @@ try {
   } else {
     const [platform, arch] = platformAndArch.split('-');
     help.push(
-      '- Install with the --verbose flag and look for errors: "npm install --ignore-scripts=false --verbose sharp"',
+      '- Install with verbose logging and look for errors: "npm install --ignore-scripts=false --foreground-scripts --verbose sharp"',
       `- Install for the current ${platformAndArch} runtime: "npm install --platform=${platform} --arch=${arch} sharp"`
     );
   }
@@ -21,7 +21,7 @@ try {
     '- Consult the installation documentation: https://sharp.pixelplumbing.com/install'
   );
   // Check loaded
-  if (process.platform === 'win32') {
+  if (process.platform === 'win32' || /symbol/.test(err.message)) {
     const loadedModule = Object.keys(require.cache).find((i) => /[\\/]build[\\/]Release[\\/]sharp(.*)\.node$/.test(i));
     if (loadedModule) {
       const [, loadedPackage] = loadedModule.match(/node_modules[\\/]([^\\/]+)[\\/]/);

package/lib/utility.js

@@ -103,7 +103,11 @@ cache(true);
 
 /**
  * Gets or, when a concurrency is provided, sets
- * the number of threads _libvips'_ should create to process each image.
+ * the maximum number of threads _libvips_ should use to process _each image_.
+ * These are from a thread pool managed by glib,
+ * which helps avoid the overhead of creating new threads.
+ *
+ * This method always returns the current concurrency.
  *
  * The default value is the number of CPU cores,
  * except when using glibc-based Linux without jemalloc,
@@ -111,10 +115,19 @@ cache(true);
  *
  * A value of `0` will reset this to the number of CPU cores.
  *
- * The maximum number of images that can be processed in parallel
- * is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
+ * Some image format libraries spawn additional threads,
+ * e.g. libaom manages its own 4 threads when encoding AVIF images,
+ * and these are independent of the value set here.
  *
- * This method always returns the current concurrency.
+ * The maximum number of images that sharp can process in parallel
+ * is controlled by libuv's `UV_THREADPOOL_SIZE` environment variable,
+ * which defaults to 4.
+ *
+ * https://nodejs.org/api/cli.html#uv_threadpool_sizesize
+ *
+ * For example, by default, a machine with 8 CPU cores will process
+ * 4 images in parallel and use up to 8 threads per image,
+ * so there will be up to 32 concurrent threads.
  *
  * @example
  * const threads = sharp.concurrency(); // 4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
-  "version": "0.30.2",
+  "version": "0.30.5",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -81,7 +81,9 @@
     "Taneli Vatanen <taneli.vatanen@gmail.com>",
     "Joris Dugué <zaruike10@gmail.com>",
     "Chris Banks <christopher.bradley.banks@gmail.com>",
-    "Ompal Singh <ompal.hitm09@gmail.com>"
+    "Ompal Singh <ompal.hitm09@gmail.com>",
+    "Brodan <christopher.hranj@gmail.com",
+    "Ankur Parihar <ankur.github@gmail.com>"
   ],
   "scripts": {
     "install": "(node install/libvips && node install/dll-copy && prebuild-install) || (node install/can-compile && node-gyp rebuild && node install/dll-copy)",
@@ -126,11 +128,11 @@
     "vips"
   ],
   "dependencies": {
-    "color": "^4.2.1",
+    "color": "^4.2.3",
     "detect-libc": "^2.0.1",
-    "node-addon-api": "^4.3.0",
-    "prebuild-install": "^7.0.1",
-    "semver": "^7.3.5",
+    "node-addon-api": "^5.0.0",
+    "prebuild-install": "^7.1.0",
+    "semver": "^7.3.7",
     "simple-get": "^4.0.1",
     "tar-fs": "^2.1.1",
     "tunnel-agent": "^0.6.0"
@@ -143,7 +145,7 @@
     "exif-reader": "^1.0.3",
     "icc": "^2.0.0",
     "license-checker": "^25.0.1",
-    "mocha": "^9.2.1",
+    "mocha": "^10.0.0",
     "mock-fs": "^5.1.2",
     "nyc": "^15.1.0",
     "prebuild": "^11.0.3",

package/src/common.cc

@@ -85,7 +85,9 @@ namespace sharp {
       descriptor->buffer = buffer.Data();
       descriptor->isBuffer = TRUE;
     }
-    descriptor->failOnError = AttrAsBool(input, "failOnError");
+    descriptor->failOn = static_cast<VipsFailOn>(
+      vips_enum_from_nick(nullptr, VIPS_TYPE_FAIL_ON,
+      AttrAsStr(input, "failOn").data()));
     // Density for vector-based input
     if (HasAttr(input, "density")) {
       descriptor->density = AttrAsDouble(input, "density");
@@ -329,7 +331,7 @@ namespace sharp {
           try {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
-              ->set("fail", descriptor->failOnError);
+              ->set("fail_on", descriptor->failOn);
             if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
               option->set("unlimited", TRUE);
             }
@@ -375,12 +377,6 @@ namespace sharp {
               VImage::option()->set("mean", descriptor->createNoiseMean)->set("sigma", descriptor->createNoiseSigma)));
           }
           image = image.bandjoin(bands);
-          image = image.cast(VipsBandFormat::VIPS_FORMAT_UCHAR);
-          if (channels < 3) {
-            image = image.colourspace(VIPS_INTERPRETATION_B_W);
-          } else {
-            image = image.colourspace(VIPS_INTERPRETATION_sRGB);
-          }
         } else {
           std::vector<double> background = {
             descriptor->createBackground[0],
@@ -392,7 +388,8 @@ namespace sharp {
           }
           image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight).new_from_image(background);
         }
-        image.get_image()->Type = VIPS_INTERPRETATION_sRGB;
+        image.get_image()->Type = image.guess_interpretation();
+        image = image.cast(VIPS_FORMAT_UCHAR);
         imageType = ImageType::RAW;
       } else {
         // From filesystem
@@ -402,13 +399,13 @@ namespace sharp {
             throw vips::VError("Input file is missing, did you mean "
               "sharp(Buffer.from('" + descriptor->file.substr(0, 8) + "...')?");
           }
-          throw vips::VError("Input file is missing");
+          throw vips::VError("Input file is missing: " + descriptor->file);
         }
         if (imageType != ImageType::UNKNOWN) {
           try {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
-              ->set("fail", descriptor->failOnError);
+              ->set("fail_on", descriptor->failOn);
             if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
               option->set("unlimited", TRUE);
             }

package/src/common.h

@@ -48,7 +48,7 @@ namespace sharp {
     std::string name;
     std::string file;
     char *buffer;
-    bool failOnError;
+    VipsFailOn failOn;
     int limitInputPixels;
     bool unlimited;
     VipsAccess access;
@@ -74,7 +74,7 @@ namespace sharp {
 
     InputDescriptor():
       buffer(nullptr),
-      failOnError(TRUE),
+      failOn(VIPS_FAIL_ON_WARNING),
       limitInputPixels(0x3FFF * 0x3FFF),
       unlimited(FALSE),
       access(VIPS_ACCESS_RANDOM),

package/src/operations.cc

@@ -209,7 +209,8 @@ namespace sharp {
   /*
    * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
    */
-  VImage Sharpen(VImage image, double const sigma, double const flat, double const jagged) {
+  VImage Sharpen(VImage image, double const sigma, double const m1, double const m2,
+    double const x1, double const y2, double const y3) {
     if (sigma == -1.0) {
       // Fast, mild sharpen
       VImage sharpen = VImage::new_matrixv(3, 3,
@@ -224,8 +225,14 @@ namespace sharp {
       if (colourspaceBeforeSharpen == VIPS_INTERPRETATION_RGB) {
         colourspaceBeforeSharpen = VIPS_INTERPRETATION_sRGB;
       }
-      return image.sharpen(
-        VImage::option()->set("sigma", sigma)->set("m1", flat)->set("m2", jagged))
+      return image
+        .sharpen(VImage::option()
+          ->set("sigma", sigma)
+          ->set("m1", m1)
+          ->set("m2", m2)
+          ->set("x1", x1)
+          ->set("y2", y2)
+          ->set("y3", y3))
         .colourspace(colourspaceBeforeSharpen);
     }
   }

package/src/operations.h

@@ -64,7 +64,8 @@ namespace sharp {
   /*
    * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
    */
-  VImage Sharpen(VImage image, double const sigma, double const flat, double const jagged);
+  VImage Sharpen(VImage image, double const sigma, double const m1, double const m2,
+    double const x1, double const y2, double const y3);
 
   /*
     Threshold an image

package/src/pipeline.cc

@@ -95,16 +95,18 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (baton->rotateBeforePreExtract) {
         if (rotation != VIPS_ANGLE_D0) {
           image = image.rot(rotation);
-          if (flip) {
-            image = image.flip(VIPS_DIRECTION_VERTICAL);
-            flip = FALSE;
-          }
-          if (flop) {
-            image = image.flip(VIPS_DIRECTION_HORIZONTAL);
-            flop = FALSE;
-          }
+        }
+        if (flip) {
+          image = image.flip(VIPS_DIRECTION_VERTICAL);
+        }
+        if (flop) {
+          image = image.flip(VIPS_DIRECTION_HORIZONTAL);
+        }
+        if (rotation != VIPS_ANGLE_D0 || flip || flop) {
           image = sharp::RemoveExifOrientation(image);
         }
+        flop = FALSE;
+        flip = FALSE;
         if (baton->rotationAngle != 0.0) {
           MultiPageUnsupported(nPages, "Rotate");
           std::vector<double> background;
@@ -200,7 +202,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         vips::VOption *option = VImage::option()
           ->set("access", baton->input->access)
           ->set("shrink", jpegShrinkOnLoad)
-          ->set("fail", baton->input->failOnError);
+          ->set("fail_on", baton->input->failOn);
         if (baton->input->buffer != nullptr) {
           // Reload JPEG buffer
           VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
@@ -214,7 +216,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         vips::VOption *option = VImage::option()
           ->set("access", baton->input->access)
           ->set("scale", scale)
-          ->set("fail", baton->input->failOnError);
+          ->set("fail_on", baton->input->failOn);
         if (inputImageType == sharp::ImageType::WEBP) {
           option->set("n", baton->input->pages);
           option->set("page", baton->input->page);
@@ -241,8 +243,10 @@ class PipelineWorker : public Napi::AsyncWorker {
             // Reload SVG file
             image = VImage::svgload(const_cast<char*>(baton->input->file.data()), option);
           }
-
           sharp::SetDensity(image, baton->input->density);
+          if (image.width() > 32767 || image.height() > 32767) {
+            throw vips::VError("Input SVG image will exceed 32767x32767 pixel limit when scaled");
+          }
         } else if (inputImageType == sharp::ImageType::PDF) {
           option->set("n", baton->input->pages);
           option->set("page", baton->input->page);
@@ -260,6 +264,10 @@ class PipelineWorker : public Napi::AsyncWorker {
 
           sharp::SetDensity(image, baton->input->density);
         }
+      } else {
+        if (inputImageType == sharp::ImageType::SVG && (image.width() > 32767 || image.height() > 32767)) {
+          throw vips::VError("Input SVG image exceeds 32767x32767 pixel limit");
+        }
       }
 
       // Any pre-shrinking may already have been done
@@ -354,7 +362,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       bool const shouldPremultiplyAlpha = sharp::HasAlpha(image) &&
-        (shouldResize || shouldBlur || shouldConv || shouldSharpen || shouldComposite);
+        (shouldResize || shouldBlur || shouldConv || shouldSharpen);
 
       // Premultiply image alpha channel before all transformations to avoid
       // dark fringing around bright pixels
@@ -577,7 +585,8 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Sharpen
       if (shouldSharpen) {
-        image = sharp::Sharpen(image, baton->sharpenSigma, baton->sharpenFlat, baton->sharpenJagged);
+        image = sharp::Sharpen(image, baton->sharpenSigma, baton->sharpenM1, baton->sharpenM2,
+          baton->sharpenX1, baton->sharpenY2, baton->sharpenY3);
       }
 
       // Composite
@@ -1400,8 +1409,11 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->lightness = sharp::AttrAsDouble(options, "lightness");
   baton->medianSize = sharp::AttrAsUint32(options, "medianSize");
   baton->sharpenSigma = sharp::AttrAsDouble(options, "sharpenSigma");
-  baton->sharpenFlat = sharp::AttrAsDouble(options, "sharpenFlat");
-  baton->sharpenJagged = sharp::AttrAsDouble(options, "sharpenJagged");
+  baton->sharpenM1 = sharp::AttrAsDouble(options, "sharpenM1");
+  baton->sharpenM2 = sharp::AttrAsDouble(options, "sharpenM2");
+  baton->sharpenX1 = sharp::AttrAsDouble(options, "sharpenX1");
+  baton->sharpenY2 = sharp::AttrAsDouble(options, "sharpenY2");
+  baton->sharpenY3 = sharp::AttrAsDouble(options, "sharpenY3");
   baton->threshold = sharp::AttrAsInt32(options, "threshold");
   baton->thresholdGrayscale = sharp::AttrAsBool(options, "thresholdGrayscale");
   baton->trimThreshold = sharp::AttrAsDouble(options, "trimThreshold");

package/src/pipeline.h

@@ -90,8 +90,11 @@ struct PipelineBaton {
   double lightness;
   int medianSize;
   double sharpenSigma;
-  double sharpenFlat;
-  double sharpenJagged;
+  double sharpenM1;
+  double sharpenM2;
+  double sharpenX1;
+  double sharpenY2;
+  double sharpenY3;
   int threshold;
   bool thresholdGrayscale;
   double trimThreshold;
@@ -234,8 +237,11 @@ struct PipelineBaton {
     lightness(0),
     medianSize(0),
     sharpenSigma(0.0),
-    sharpenFlat(1.0),
-    sharpenJagged(2.0),
+    sharpenM1(1.0),
+    sharpenM2(2.0),
+    sharpenX1(2.0),
+    sharpenY2(10.0),
+    sharpenY3(20.0),
     threshold(0),
     thresholdGrayscale(true),
     trimThreshold(0.0),