Release v0.30.6

This deprecates the libc-as-suffix approach of --platform=linuxmusl

.github/CONTRIBUTING.md

@@ -16,7 +16,7 @@ If a [similar request](https://github.com/lovell/sharp/labels/enhancement) exist
 it's probably fastest to add a comment to it about your requirement.
 
 Implementation is usually straightforward if libvips
-[already supports](https://libvips.github.io/libvips/API/current/func-list.html)
+[already supports](https://www.libvips.org/API/current/func-list.html)
 the feature you need.
 
 ## Submit a Pull Request to fix a bug

.github/ISSUE_TEMPLATE/installation.md

@@ -32,11 +32,11 @@ If you are using npm v7 or later, does the user running `npm install` own the di
 
 If you are using the `ignore-scripts` feature of `npm`, have you tried with the `npm install --ignore-scripts=false` flag?
 
-### What is the complete output of running `npm install --verbose sharp`?
+### What is the complete output of running `npm install --verbose --foreground-scripts sharp` in an empty directory?
 
 <details>
 
-<!-- Please provide output of `npm install --verbose sharp` here. -->
+<!-- Please provide output of `npm install --verbose --foreground-scripts sharp` in an empty directory here. -->
 
 </details>
 

docs/api-composite.md

@@ -14,7 +14,7 @@ The `blend` option can be one of `clear`, `source`, `over`, `in`, `out`, `atop`,
 `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][1]
+[https://www.libvips.org/API/current/libvips-conversion.html#VipsBlendMode][1]
 and [https://www.cairographics.org/operators/][2]
 
 ### Parameters
@@ -42,7 +42,7 @@ and [https://www.cairographics.org/operators/][2]
         *   `images[].raw.height` **[Number][7]?** 
         *   `images[].raw.channels` **[Number][7]?** 
     *   `images[].animated` **[boolean][9]** Set to `true` to read all frames/pages of an animated image. (optional, default `false`)
-    *   `images[].failOnError` **[boolean][9]** @see [constructor parameters][10] (optional, default `true`)
+    *   `images[].failOn` **[string][6]** @see [constructor parameters][10] (optional, default `'warning'`)
     *   `images[].limitInputPixels` **([number][7] | [boolean][9])** @see [constructor parameters][10] (optional, default `268402689`)
 
 ### Examples
@@ -89,7 +89,7 @@ Returns **Sharp**
 
 *   **since**: 0.22.0
 
-[1]: https://libvips.github.io/libvips/API/current/libvips-conversion.html#VipsBlendMode
+[1]: https://www.libvips.org/API/current/libvips-conversion.html#VipsBlendMode
 
 [2]: https://www.cairographics.org/operators/
 

docs/api-constructor.md

@@ -20,38 +20,37 @@ Implements the [stream.Duplex][1] class.
     JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
 *   `options` **[Object][13]?** if present, is an Object with optional attributes.
 
-    *   `options.failOnError` **[boolean][14]** 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. (optional, default `true`)
-    *   `options.limitInputPixels` **([number][15] | [boolean][14])** Do not process input images where the number of pixels
+    *   `options.failOn` **[string][12]** level of sensitivity to invalid images, one of (in order of sensitivity): 'none' (least), 'truncated', 'error' or 'warning' (most), highers level imply lower levels. (optional, default `'warning'`)
+    *   `options.limitInputPixels` **([number][14] | [boolean][15])** 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). (optional, default `268402689`)
-    *   `options.unlimited` **[boolean][14]** Set this to `true` to remove safety features that help prevent memory exhaustion (SVG, PNG). (optional, default `false`)
-    *   `options.sequentialRead` **[boolean][14]** Set this to `true` to use sequential rather than random access where possible.
+    *   `options.unlimited` **[boolean][15]** Set this to `true` to remove safety features that help prevent memory exhaustion (SVG, PNG). (optional, default `false`)
+    *   `options.sequentialRead` **[boolean][15]** Set this to `true` to use sequential rather than random access where possible.
         This can reduce memory usage and might improve performance on some systems. (optional, default `false`)
-    *   `options.density` **[number][15]** number representing the DPI for vector images in the range 1 to 100000. (optional, default `72`)
-    *   `options.pages` **[number][15]** number of pages to extract for multi-page input (GIF, WebP, AVIF, TIFF, PDF), use -1 for all pages. (optional, default `1`)
-    *   `options.page` **[number][15]** page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based. (optional, default `0`)
-    *   `options.subifd` **[number][15]** subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image. (optional, default `-1`)
-    *   `options.level` **[number][15]** level to extract from a multi-level input (OpenSlide), zero based. (optional, default `0`)
-    *   `options.animated` **[boolean][14]** Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`). (optional, default `false`)
+    *   `options.density` **[number][14]** number representing the DPI for vector images in the range 1 to 100000. (optional, default `72`)
+    *   `options.pages` **[number][14]** number of pages to extract for multi-page input (GIF, WebP, AVIF, TIFF, PDF), use -1 for all pages. (optional, default `1`)
+    *   `options.page` **[number][14]** page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based. (optional, default `0`)
+    *   `options.subifd` **[number][14]** subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image. (optional, default `-1`)
+    *   `options.level` **[number][14]** level to extract from a multi-level input (OpenSlide), zero based. (optional, default `0`)
+    *   `options.animated` **[boolean][15]** Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`). (optional, default `false`)
     *   `options.raw` **[Object][13]?** describes raw pixel input image data. See `raw()` for pixel ordering.
 
-        *   `options.raw.width` **[number][15]?** integral number of pixels wide.
-        *   `options.raw.height` **[number][15]?** integral number of pixels high.
-        *   `options.raw.channels` **[number][15]?** integral number of channels, between 1 and 4.
-        *   `options.raw.premultiplied` **[boolean][14]?** specifies that the raw input has already been premultiplied, set to `true`
+        *   `options.raw.width` **[number][14]?** integral number of pixels wide.
+        *   `options.raw.height` **[number][14]?** integral number of pixels high.
+        *   `options.raw.channels` **[number][14]?** integral number of channels, between 1 and 4.
+        *   `options.raw.premultiplied` **[boolean][15]?** specifies that the raw input has already been premultiplied, set to `true`
             to avoid sharp premultiplying the image. (optional, default `false`)
     *   `options.create` **[Object][13]?** describes a new image to be created.
 
-        *   `options.create.width` **[number][15]?** integral number of pixels wide.
-        *   `options.create.height` **[number][15]?** integral number of pixels high.
-        *   `options.create.channels` **[number][15]?** integral number of channels, either 3 (RGB) or 4 (RGBA).
+        *   `options.create.width` **[number][14]?** integral number of pixels wide.
+        *   `options.create.height` **[number][14]?** integral number of pixels high.
+        *   `options.create.channels` **[number][14]?** integral number of channels, either 3 (RGB) or 4 (RGBA).
         *   `options.create.background` **([string][12] | [Object][13])?** parsed by the [color][16] module to extract values for red, green, blue and alpha.
         *   `options.create.noise` **[Object][13]?** describes a noise to be created.
 
             *   `options.create.noise.type` **[string][12]?** type of generated noise, currently only `gaussian` is supported.
-            *   `options.create.noise.mean` **[number][15]?** mean of pixels in generated noise.
-            *   `options.create.noise.sigma` **[number][15]?** standard deviation of pixels in generated noise.
+            *   `options.create.noise.mean` **[number][14]?** mean of pixels in generated noise.
+            *   `options.create.noise.sigma` **[number][14]?** standard deviation of pixels in generated noise.
 
 ### Examples
 
@@ -154,9 +153,7 @@ readableStream.pipe(pipeline);
 // 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 = [];
 
@@ -226,9 +223,9 @@ Returns **[Sharp][18]**
 
 [13]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[14]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[14]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
-[15]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[15]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
 [16]: https://www.npmjs.org/package/color
 

docs/api-input.md

@@ -131,9 +131,9 @@ const stats = await sharp(part).stats();
 
 Returns **[Promise][5]<[Object][6]>** 
 
-[1]: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation
+[1]: https://www.libvips.org/API/current/VipsImage.html#VipsInterpretation
 
-[2]: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsBandFormat
+[2]: https://www.libvips.org/API/current/VipsImage.html#VipsBandFormat
 
 [3]: https://www.npmjs.com/package/icc
 

docs/api-operation.md

@@ -289,6 +289,20 @@ Produce the "negative" of the image.
 
     *   `options.alpha` **[Boolean][6]** Whether or not to negate any alpha channel (optional, default `true`)
 
+### Examples
+
+```javascript
+const output = await sharp(input)
+  .negate()
+  .toBuffer();
+```
+
+```javascript
+const output = await sharp(input)
+  .negate({ alpha: false })
+  .toBuffer();
+```
+
 Returns **Sharp** 
 
 ## normalise

docs/api-output.md

@@ -46,6 +46,8 @@ Returns **[Promise][5]<[Object][6]>** when no callback is provided
 Write output to a Buffer.
 JPEG, PNG, WebP, AVIF, TIFF, GIF and raw pixel data output are supported.
 
+Use [toFormat][7] or one of the format-specific functions such as [jpeg][8], [png][9] 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.
@@ -66,7 +68,7 @@ A `Promise` is returned when `callback` is not provided.
 
 *   `options` **[Object][6]?** 
 
-    *   `options.resolveWithObject` **[boolean][7]?** Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
+    *   `options.resolveWithObject` **[boolean][10]?** Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
 *   `callback` **[Function][3]?** 
 
 ### Examples
@@ -85,6 +87,7 @@ sharp(input)
 
 ```javascript
 sharp(input)
+  .png()
   .toBuffer({ resolveWithObject: true })
   .then(({ data, info }) => { ... })
   .catch(err => { ... });
@@ -107,7 +110,7 @@ await sharp(pixelArray, { raw: { width, height, channels } })
   .toFile('my-changed-image.jpg');
 ```
 
-Returns **[Promise][5]<[Buffer][8]>** when no callback is provided
+Returns **[Promise][5]<[Buffer][11]>** when no callback is provided
 
 ## withMetadata
 
@@ -118,14 +121,16 @@ output profile is provided.
 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.
+
 ### Parameters
 
 *   `options` **[Object][6]?** 
 
-    *   `options.orientation` **[number][9]?** value between 1 and 8, used to update the EXIF `Orientation` tag.
+    *   `options.orientation` **[number][12]?** value between 1 and 8, used to update the EXIF `Orientation` tag.
     *   `options.icc` **[string][2]?** filesystem path to output ICC profile, defaults to sRGB.
     *   `options.exif` **[Object][6]<[Object][6]>** Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data. (optional, default `{}`)
-    *   `options.density` **[number][9]?** Number of pixels per inch (DPI).
+    *   `options.density` **[number][12]?** Number of pixels per inch (DPI).
 
 ### Examples
 
@@ -190,19 +195,19 @@ Use these JPEG options for output image.
 
 *   `options` **[Object][6]?** output options
 
-    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
-    *   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `80`)
+    *   `options.progressive` **[boolean][10]** use progressive (interlace) scan (optional, default `false`)
     *   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling (optional, default `'4:2:0'`)
-    *   `options.optimiseCoding` **[boolean][7]** optimise Huffman coding tables (optional, default `true`)
-    *   `options.optimizeCoding` **[boolean][7]** alternative spelling of optimiseCoding (optional, default `true`)
-    *   `options.mozjpeg` **[boolean][7]** use mozjpeg defaults, equivalent to `{ trellisQuantisation: true, overshootDeringing: true, optimiseScans: true, quantisationTable: 3 }` (optional, default `false`)
-    *   `options.trellisQuantisation` **[boolean][7]** apply trellis quantisation (optional, default `false`)
-    *   `options.overshootDeringing` **[boolean][7]** apply overshoot deringing (optional, default `false`)
-    *   `options.optimiseScans` **[boolean][7]** optimise progressive scans, forces progressive (optional, default `false`)
-    *   `options.optimizeScans` **[boolean][7]** alternative spelling of optimiseScans (optional, default `false`)
-    *   `options.quantisationTable` **[number][9]** quantization table to use, integer 0-8 (optional, default `0`)
-    *   `options.quantizationTable` **[number][9]** alternative spelling of quantisationTable (optional, default `0`)
-    *   `options.force` **[boolean][7]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
+    *   `options.optimiseCoding` **[boolean][10]** optimise Huffman coding tables (optional, default `true`)
+    *   `options.optimizeCoding` **[boolean][10]** alternative spelling of optimiseCoding (optional, default `true`)
+    *   `options.mozjpeg` **[boolean][10]** use mozjpeg defaults, equivalent to `{ trellisQuantisation: true, overshootDeringing: true, optimiseScans: true, quantisationTable: 3 }` (optional, default `false`)
+    *   `options.trellisQuantisation` **[boolean][10]** apply trellis quantisation (optional, default `false`)
+    *   `options.overshootDeringing` **[boolean][10]** apply overshoot deringing (optional, default `false`)
+    *   `options.optimiseScans` **[boolean][10]** optimise progressive scans, forces progressive (optional, default `false`)
+    *   `options.optimizeScans` **[boolean][10]** alternative spelling of optimiseScans (optional, default `false`)
+    *   `options.quantisationTable` **[number][12]** quantization table to use, integer 0-8 (optional, default `0`)
+    *   `options.quantizationTable` **[number][12]** alternative spelling of quantisationTable (optional, default `0`)
+    *   `options.force` **[boolean][10]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
 
 ### Examples
 
@@ -239,16 +244,16 @@ Set `palette` to `true` for slower, indexed PNG output.
 
 *   `options` **[Object][6]?** 
 
-    *   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
-    *   `options.compressionLevel` **[number][9]** zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest) (optional, default `6`)
-    *   `options.adaptiveFiltering` **[boolean][7]** use adaptive row filtering (optional, default `false`)
-    *   `options.palette` **[boolean][7]** quantise to a palette-based image with alpha transparency support (optional, default `false`)
-    *   `options.quality` **[number][9]** use the lowest number of colours needed to achieve given quality, sets `palette` to `true` (optional, default `100`)
-    *   `options.effort` **[number][9]** CPU effort, between 1 (fastest) and 10 (slowest), sets `palette` to `true` (optional, default `7`)
-    *   `options.colours` **[number][9]** maximum number of palette entries, sets `palette` to `true` (optional, default `256`)
-    *   `options.colors` **[number][9]** alternative spelling of `options.colours`, sets `palette` to `true` (optional, default `256`)
-    *   `options.dither` **[number][9]** level of Floyd-Steinberg error diffusion, sets `palette` to `true` (optional, default `1.0`)
-    *   `options.force` **[boolean][7]** force PNG output, otherwise attempt to use input format (optional, default `true`)
+    *   `options.progressive` **[boolean][10]** use progressive (interlace) scan (optional, default `false`)
+    *   `options.compressionLevel` **[number][12]** zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest) (optional, default `6`)
+    *   `options.adaptiveFiltering` **[boolean][10]** use adaptive row filtering (optional, default `false`)
+    *   `options.palette` **[boolean][10]** quantise to a palette-based image with alpha transparency support (optional, default `false`)
+    *   `options.quality` **[number][12]** use the lowest number of colours needed to achieve given quality, sets `palette` to `true` (optional, default `100`)
+    *   `options.effort` **[number][12]** CPU effort, between 1 (fastest) and 10 (slowest), sets `palette` to `true` (optional, default `7`)
+    *   `options.colours` **[number][12]** maximum number of palette entries, sets `palette` to `true` (optional, default `256`)
+    *   `options.colors` **[number][12]** alternative spelling of `options.colours`, sets `palette` to `true` (optional, default `256`)
+    *   `options.dither` **[number][12]** level of Floyd-Steinberg error diffusion, sets `palette` to `true` (optional, default `1.0`)
+    *   `options.force` **[boolean][10]** force PNG output, otherwise attempt to use input format (optional, default `true`)
 
 ### Examples
 
@@ -278,15 +283,15 @@ Use these WebP options for output image.
 
 *   `options` **[Object][6]?** output options
 
-    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
-    *   `options.alphaQuality` **[number][9]** quality of alpha layer, integer 0-100 (optional, default `100`)
-    *   `options.lossless` **[boolean][7]** use lossless compression mode (optional, default `false`)
-    *   `options.nearLossless` **[boolean][7]** use near_lossless compression mode (optional, default `false`)
-    *   `options.smartSubsample` **[boolean][7]** use high quality chroma subsampling (optional, default `false`)
-    *   `options.effort` **[number][9]** CPU effort, between 0 (fastest) and 6 (slowest) (optional, default `4`)
-    *   `options.loop` **[number][9]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
-    *   `options.delay` **([number][9] | [Array][10]<[number][9]>)?** delay(s) between animation frames (in milliseconds)
-    *   `options.force` **[boolean][7]** force WebP output, otherwise attempt to use input format (optional, default `true`)
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `80`)
+    *   `options.alphaQuality` **[number][12]** quality of alpha layer, integer 0-100 (optional, default `100`)
+    *   `options.lossless` **[boolean][10]** use lossless compression mode (optional, default `false`)
+    *   `options.nearLossless` **[boolean][10]** use near_lossless compression mode (optional, default `false`)
+    *   `options.smartSubsample` **[boolean][10]** use high quality chroma subsampling (optional, default `false`)
+    *   `options.effort` **[number][12]** CPU effort, between 0 (fastest) and 6 (slowest) (optional, default `4`)
+    *   `options.loop` **[number][12]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
+    *   `options.delay` **([number][12] | [Array][13]<[number][12]>)?** delay(s) between animation frames (in milliseconds)
+    *   `options.force` **[boolean][10]** force WebP output, otherwise attempt to use input format (optional, default `true`)
 
 ### Examples
 
@@ -318,13 +323,13 @@ The first entry in the palette is reserved for transparency.
 
 *   `options` **[Object][6]?** output options
 
-    *   `options.colours` **[number][9]** maximum number of palette entries, including transparency, between 2 and 256 (optional, default `256`)
-    *   `options.colors` **[number][9]** alternative spelling of `options.colours` (optional, default `256`)
-    *   `options.effort` **[number][9]** CPU effort, between 1 (fastest) and 10 (slowest) (optional, default `7`)
-    *   `options.dither` **[number][9]** level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most) (optional, default `1.0`)
-    *   `options.loop` **[number][9]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
-    *   `options.delay` **([number][9] | [Array][10]<[number][9]>)?** delay(s) between animation frames (in milliseconds)
-    *   `options.force` **[boolean][7]** force GIF output, otherwise attempt to use input format (optional, default `true`)
+    *   `options.colours` **[number][12]** maximum number of palette entries, including transparency, between 2 and 256 (optional, default `256`)
+    *   `options.colors` **[number][12]** alternative spelling of `options.colours` (optional, default `256`)
+    *   `options.effort` **[number][12]** CPU effort, between 1 (fastest) and 10 (slowest) (optional, default `7`)
+    *   `options.dither` **[number][12]** level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most) (optional, default `1.0`)
+    *   `options.loop` **[number][12]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
+    *   `options.delay` **([number][12] | [Array][13]<[number][12]>)?** delay(s) between animation frames (in milliseconds)
+    *   `options.force` **[boolean][10]** force GIF output, otherwise attempt to use input format (optional, default `true`)
 
 ### Examples
 
@@ -332,7 +337,7 @@ The first entry in the palette is reserved for transparency.
 // Convert PNG to GIF
 await sharp(pngBuffer)
   .gif()
-  .toBuffer());
+  .toBuffer();
 ```
 
 ```javascript
@@ -363,16 +368,16 @@ Use these JP2 options for output image.
 
 Requires libvips compiled with support for OpenJPEG.
 The prebuilt binaries do not include this - see
-[installing a custom libvips][11].
+[installing a custom libvips][14].
 
 ### Parameters
 
 *   `options` **[Object][6]?** output options
 
-    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
-    *   `options.lossless` **[boolean][7]** use lossless compression mode (optional, default `false`)
-    *   `options.tileWidth` **[number][9]** horizontal tile size (optional, default `512`)
-    *   `options.tileHeight` **[number][9]** vertical tile size (optional, default `512`)
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `80`)
+    *   `options.lossless` **[boolean][10]** use lossless compression mode (optional, default `false`)
+    *   `options.tileWidth` **[number][12]** horizontal tile size (optional, default `512`)
+    *   `options.tileHeight` **[number][12]** vertical tile size (optional, default `512`)
     *   `options.chromaSubsampling` **[string][2]** set to '4:2:0' to use chroma subsampling (optional, default `'4:4:4'`)
 
 ### Examples
@@ -412,18 +417,18 @@ The `density` can be set in pixels/inch via [withMetadata][1] instead of providi
 
 *   `options` **[Object][6]?** output options
 
-    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
-    *   `options.force` **[boolean][7]** force TIFF output, otherwise attempt to use input format (optional, default `true`)
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `80`)
+    *   `options.force` **[boolean][10]** force TIFF output, otherwise attempt to use input format (optional, default `true`)
     *   `options.compression` **[string][2]** compression options: lzw, deflate, jpeg, ccittfax4 (optional, default `'jpeg'`)
     *   `options.predictor` **[string][2]** compression predictor options: none, horizontal, float (optional, default `'horizontal'`)
-    *   `options.pyramid` **[boolean][7]** write an image pyramid (optional, default `false`)
-    *   `options.tile` **[boolean][7]** write a tiled tiff (optional, default `false`)
-    *   `options.tileWidth` **[number][9]** horizontal tile size (optional, default `256`)
-    *   `options.tileHeight` **[number][9]** vertical tile size (optional, default `256`)
-    *   `options.xres` **[number][9]** horizontal resolution in pixels/mm (optional, default `1.0`)
-    *   `options.yres` **[number][9]** vertical resolution in pixels/mm (optional, default `1.0`)
+    *   `options.pyramid` **[boolean][10]** write an image pyramid (optional, default `false`)
+    *   `options.tile` **[boolean][10]** write a tiled tiff (optional, default `false`)
+    *   `options.tileWidth` **[number][12]** horizontal tile size (optional, default `256`)
+    *   `options.tileHeight` **[number][12]** vertical tile size (optional, default `256`)
+    *   `options.xres` **[number][12]** horizontal resolution in pixels/mm (optional, default `1.0`)
+    *   `options.yres` **[number][12]** vertical resolution in pixels/mm (optional, default `1.0`)
     *   `options.resolutionUnit` **[string][2]** resolution unit options: inch, cm (optional, default `'inch'`)
-    *   `options.bitdepth` **[number][9]** reduce bitdepth to 1, 2 or 4 bit (optional, default `8`)
+    *   `options.bitdepth` **[number][12]** reduce bitdepth to 1, 2 or 4 bit (optional, default `8`)
 
 ### Examples
 
@@ -455,9 +460,9 @@ AVIF image sequences are not supported.
 
 *   `options` **[Object][6]?** output options
 
-    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `50`)
-    *   `options.lossless` **[boolean][7]** use lossless compression (optional, default `false`)
-    *   `options.effort` **[number][9]** CPU effort, between 0 (fastest) and 9 (slowest) (optional, default `4`)
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `50`)
+    *   `options.lossless` **[boolean][10]** use lossless compression (optional, default `false`)
+    *   `options.effort` **[number][12]** CPU effort, between 0 (fastest) and 9 (slowest) (optional, default `4`)
     *   `options.chromaSubsampling` **[string][2]** set to '4:2:0' to use chroma subsampling (optional, default `'4:4:4'`)
 
 <!---->
@@ -481,10 +486,10 @@ globally-installed libvips compiled with support for libheif, libde265 and x265.
 
 *   `options` **[Object][6]?** output options
 
-    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `50`)
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `50`)
     *   `options.compression` **[string][2]** compression format: av1, hevc (optional, default `'av1'`)
-    *   `options.lossless` **[boolean][7]** use lossless compression (optional, default `false`)
-    *   `options.effort` **[number][9]** CPU effort, between 0 (fastest) and 9 (slowest) (optional, default `4`)
+    *   `options.lossless` **[boolean][10]** use lossless compression (optional, default `false`)
+    *   `options.effort` **[number][12]** CPU effort, between 0 (fastest) and 9 (slowest) (optional, default `4`)
     *   `options.chromaSubsampling` **[string][2]** set to '4:2:0' to use chroma subsampling (optional, default `'4:4:4'`)
 
 <!---->
@@ -540,16 +545,16 @@ Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed arc
 
 *   `options` **[Object][6]?** 
 
-    *   `options.size` **[number][9]** tile size in pixels, a value between 1 and 8192. (optional, default `256`)
-    *   `options.overlap` **[number][9]** tile overlap in pixels, a value between 0 and 8192. (optional, default `0`)
-    *   `options.angle` **[number][9]** tile angle of rotation, must be a multiple of 90. (optional, default `0`)
-    *   `options.background` **([string][2] | [Object][6])** background colour, parsed by the [color][12] module, defaults to white without transparency. (optional, default `{r:255,g:255,b:255,alpha:1}`)
+    *   `options.size` **[number][12]** tile size in pixels, a value between 1 and 8192. (optional, default `256`)
+    *   `options.overlap` **[number][12]** tile overlap in pixels, a value between 0 and 8192. (optional, default `0`)
+    *   `options.angle` **[number][12]** tile angle of rotation, must be a multiple of 90. (optional, default `0`)
+    *   `options.background` **([string][2] | [Object][6])** background colour, parsed by the [color][15] module, defaults to white without transparency. (optional, default `{r:255,g:255,b:255,alpha:1}`)
     *   `options.depth` **[string][2]?** how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
-    *   `options.skipBlanks` **[number][9]** threshold to skip tile generation, a value 0 - 255 for 8-bit images or 0 - 65535 for 16-bit images (optional, default `-1`)
+    *   `options.skipBlanks` **[number][12]** threshold to skip tile generation, a value 0 - 255 for 8-bit images or 0 - 65535 for 16-bit images (optional, default `-1`)
     *   `options.container` **[string][2]** tile container, with value `fs` (filesystem) or `zip` (compressed file). (optional, default `'fs'`)
     *   `options.layout` **[string][2]** filesystem layout, possible values are `dz`, `iiif`, `iiif3`, `zoomify` or `google`. (optional, default `'dz'`)
-    *   `options.centre` **[boolean][7]** centre image in tile. (optional, default `false`)
-    *   `options.center` **[boolean][7]** alternative spelling of centre. (optional, default `false`)
+    *   `options.centre` **[boolean][10]** centre image in tile. (optional, default `false`)
+    *   `options.center` **[boolean][10]** alternative spelling of centre. (optional, default `false`)
     *   `options.id` **[string][2]** when `layout` is `iiif`/`iiif3`, sets the `@id`/`id` attribute of `info.json` (optional, default `'https://example.com/iiif'`)
 
 ### Examples
@@ -582,7 +587,7 @@ Time spent waiting for a libuv thread to become available is not included.
 
 *   `options` **[Object][6]** 
 
-    *   `options.seconds` **[number][9]** Number of seconds after which processing will be stopped
+    *   `options.seconds` **[number][12]** Number of seconds after which processing will be stopped
 
 Returns **Sharp** 
 
@@ -602,14 +607,20 @@ Returns **Sharp**
 
 [6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[7]: #toformat
 
-[8]: https://nodejs.org/api/buffer.html
+[8]: #jpeg
 
-[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[9]: #png
 
-[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[11]: https://sharp.pixelplumbing.com/install#custom-libvips
+[11]: https://nodejs.org/api/buffer.html
 
-[12]: https://www.npmjs.org/package/color
+[12]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[13]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+
+[14]: https://sharp.pixelplumbing.com/install#custom-libvips
+
+[15]: https://www.npmjs.org/package/color

docs/api-utility.md

@@ -95,7 +95,11 @@ Returns **[Object][1]**
 ## concurrency
 
 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,
@@ -103,10 +107,19 @@ where the default is `1` to help reduce memory fragmentation.
 
 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][12]
+
+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.
 
 ### Parameters
 
@@ -199,3 +212,5 @@ Returns **[boolean][10]**
 [10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
 [11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[12]: https://nodejs.org/api/cli.html#uv_threadpool_sizesize

docs/changelog.md

@@ -4,6 +4,49 @@
 
 Requires libvips v8.12.2
 
+### v0.30.6 - 30th May 2022
+
+* Allow values for `limitInputPixels` larger than 32-bit.
+  [#3238](https://github.com/lovell/sharp/issues/3238)
+
+* Ensure brew-installed `vips` can be detected (regression in 0.30.5).
+  [#3239](https://github.com/lovell/sharp/issues/3239)
+
+### v0.30.5 - 23rd May 2022
+
+* Install: pass `PKG_CONFIG_PATH` via env rather than substitution.
+  [@dwisiswant0](https://github.com/dwisiswant0)
+
+* Add support for `--libc` flag to improve cross-platform installation.
+  [#3160](https://github.com/lovell/sharp/pull/3160)
+  [@joonamo](https://github.com/joonamo)
+
+* Allow installation of prebuilt libvips binaries from filesystem.
+  [#3196](https://github.com/lovell/sharp/pull/3196)
+  [@ankurparihar](https://github.com/ankurparihar)
+
+* Fix rotate-then-extract for EXIF orientation 2.
+  [#3218](https://github.com/lovell/sharp/pull/3218)
+  [@jakob0fischl](https://github.com/jakob0fischl)
+
+### v0.30.4 - 18th April 2022
+
+* Increase control over sensitivity to invalid images via `failOn`, deprecate `failOnError` (equivalent to `failOn: 'warning'`).
+
+* Ensure `create` input image has correct bit depth and colour space.
+  [#3139](https://github.com/lovell/sharp/issues/3139)
+
+* Add support for `TypedArray` input with `byteOffset` and `length`.
+  [#3146](https://github.com/lovell/sharp/pull/3146)
+  [@codepage949](https://github.com/codepage949)
+
+* Improve error message when attempting to render SVG input greater than 32767x32767.
+  [#3167](https://github.com/lovell/sharp/issues/3167)
+
+* Add missing file name to 'Input file is missing' error message.
+  [#3178](https://github.com/lovell/sharp/pull/3178)
+  [@Brodan](https://github.com/Brodan)
+
 ### v0.30.3 - 14th March 2022
 
 * Allow `sharpen` options to be provided more consistently as an Object.

docs/humans.txt

@@ -236,3 +236,15 @@ GitHub: https://github.com/gforge
 
 Name: Chris Banks
 GitHub: https://github.com/christopherbradleybanks
+
+Name: codepage949
+GitHub: https://github.com/codepage949
+
+Name: Chris Hranj
+GitHub: https://github.com/Brodan
+
+Name: Ankur Parihar
+GitHub: https://github.com/ankurparihar
+
+Name: Joona Heinikoski
+GitHub: https://github.com/joonamo

docs/install.md

@@ -57,7 +57,7 @@ When using npm v7 or later, the user running `npm install` must own the director
 
 The `npm install --ignore-scripts=false` flag must be used when `npm` has been configured to ignore installation scripts.
 
-Check the output of running `npm install --verbose sharp` for useful error messages.
+Check the output of running `npm install --verbose --foreground-scripts sharp` for useful error messages.
 
 ## Apple M1
 
@@ -74,20 +74,28 @@ The target platform and/or architecture can be manually selected using the follo
 npm install --platform=... --arch=... --arm-version=... sharp
 ```
 
-* `--platform`: one of `linux`, `linuxmusl`, `darwin` or `win32`.
+* `--platform`: one of `linux`, `darwin` or `win32`.
 * `--arch`: one of `x64`, `ia32`, `arm` or `arm64`.
 * `--arm-version`: one of `6`, `7` or `8` (`arm` defaults to `6`, `arm64` defaults to `8`).
+* `--libc`: one of `glibc` or `musl`. This option only works with platform `linux`, defaults to `glibc`
 * `--sharp-install-force`: skip version compatibility and Subresource Integrity checks.
 
 These values can also be set via environment variables,
-`npm_config_platform`, `npm_config_arch`, `npm_config_arm_version`
+`npm_config_platform`, `npm_config_arch`, `npm_config_arm_version`, `npm_config_libc`
 and `SHARP_INSTALL_FORCE` respectively.
 
 For example, if the target machine has a 64-bit ARM CPU and is running Alpine Linux,
 use the following flags:
 
 ```sh
-npm install --arch=arm64 --platform=linuxmusl sharp
+npm install --arch=arm64 --platform=linux --libc=musl sharp
+```
+
+If the current machine is Alpine Linux and the target machine is Debian Linux on x64 cpu,
+use the following flags:
+
+```sh
+npm install --arch=x64 --platform=linux --libc=glibc sharp
 ```
 
 ## Custom libvips
@@ -96,8 +104,8 @@ To use a custom, globally-installed version of libvips instead of the provided b
 make sure it is at least the version listed under `config.libvips` in the `package.json` file
 and that it can be located using `pkg-config --modversion vips-cpp`.
 
-For help compiling libvips from source, please see
-[https://libvips.github.io/libvips/install.html#building-libvips-from-a-source-tarball](https://libvips.github.io/libvips/install.html#building-libvips-from-a-source-tarball).
+For help compiling libvips and its dependencies, please see
+[building libvips from source](https://www.libvips.org/install.html#building-libvips-from-source).
 
 The use of a globally-installed libvips is unsupported on Windows.
 
@@ -118,6 +126,8 @@ Building from source requires:
 
 This is an advanced approach that most people will not require.
 
+### Prebuilt sharp binaries
+
 To install the prebuilt sharp binaries from a custom URL,
 set the `sharp_binary_host` npm config option
 or the `npm_config_sharp_binary_host` environment variable.
@@ -126,10 +136,16 @@ To install the prebuilt sharp binaries from a directory on the local filesystem,
 set the `sharp_local_prebuilds` npm config option
 or the `npm_config_sharp_local_prebuilds` environment variable.
 
+### Prebuilt libvips binaries
+
 To install the prebuilt libvips binaries from a custom URL,
 set the `sharp_libvips_binary_host` npm config option
 or the `npm_config_sharp_libvips_binary_host` environment variable.
 
+To install the prebuilt libvips binaries from a directory on the local filesystem,
+set the `sharp_libvips_local_prebuilds` npm config option
+or the `npm_config_sharp_libvips_local_prebuilds` environment variable.
+
 The version subpath and file name are appended to these.
 For example, if `sharp_libvips_binary_host` is set to `https://hostname/path`
 and the libvips version is `1.2.3` then the resultant URL will be
@@ -207,7 +223,8 @@ run the following additional command after `npm install`:
 
 ```sh
 npm install
-SHARP_IGNORE_GLOBAL_LIBVIPS=1 npm install --arch=x64 --platform=linux sharp
+rm -rf node_modules/sharp
+SHARP_IGNORE_GLOBAL_LIBVIPS=1 npm install --arch=x64 --platform=linux --libc=glibc sharp
 ```
 
 To get the best performance select the largest memory available.
@@ -248,11 +265,17 @@ esbuild app.js --bundle --platform=node --external:sharp
 
 ## Worker threads
 
-The main thread must call `require('sharp')`
-before worker threads are created
-to ensure shared libraries remain loaded in memory
+On some platforms, including glibc-based Linux,
+the main thread must call `require('sharp')`
+_before_ worker threads are created.
+This is to ensure shared libraries remain loaded in memory
 until after all threads are complete.
 
+Without this, the following error may occur:
+```
+Module did not self-register
+```
+
 ## Known conflicts
 
 ### Canvas and Windows

docs/search-index/extract.js

@@ -9,7 +9,7 @@ const extractDescription = (str) =>
     .replace(/\s+/g, ' ')
     .replace(/[^A-Za-z0-9_/\-,. ]/g, '')
     .replace(/\s+/g, ' ')
-    .substr(0, 180)
+    .substring(0, 200)
     .trim();
 
 const extractParameters = (str) =>

docs/search-index/stop-words.js

@@ -21,6 +21,7 @@ module.exports = [
   'can',
   'containing',
   'contains',
+  'created',
   'current',
   'date',
   'default',
@@ -43,6 +44,8 @@ module.exports = [
   'how',
   'image',
   'implies',
+  'include',
+  'including',
   'involve',
   'its',
   'last',
@@ -69,6 +72,7 @@ module.exports = [
   'provided',
   'ready',
   'requires',
+  'requiresharp',
   'returned',
   'same',
   'see',
@@ -77,6 +81,7 @@ module.exports = [
   'should',
   'since',
   'site',
+  'some',
   'specified',
   'spelling',
   'such',

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}`);

lib/composite.js

@@ -50,7 +50,7 @@ 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
@@ -105,7 +105,7 @@ const blend = {
  * @param {Number} [images[].raw.height]
  * @param {Number} [images[].raw.channels]
  * @param {boolean} [images[].animated=false] - Set to `true` to read all frames/pages of an animated image.
- * @param {boolean} [images[].failOnError=true] - @see {@link /api-constructor#parameters|constructor parameters}
+ * @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

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).
@@ -320,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 = [];
  *

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)) {
@@ -78,10 +86,10 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         inputDescriptor.limitInputPixels = inputOptions.limitInputPixels
           ? Math.pow(0x3FFF, 2)
           : 0;
-      } else if (is.integer(inputOptions.limitInputPixels) && inputOptions.limitInputPixels >= 0) {
+      } else if (is.integer(inputOptions.limitInputPixels) && is.inRange(inputOptions.limitInputPixels, 0, Number.MAX_SAFE_INTEGER)) {
         inputDescriptor.limitInputPixels = inputOptions.limitInputPixels;
       } else {
-        throw is.invalidParameterError('limitInputPixels', 'integer >= 0', inputOptions.limitInputPixels);
+        throw is.invalidParameterError('limitInputPixels', 'positive integer', inputOptions.limitInputPixels);
       }
     }
     // unlimited
@@ -301,9 +309,9 @@ function _isStreamInput () {
  * - `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, 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://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation)
+ * - `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

lib/libvips.js

@@ -65,7 +65,13 @@ 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: {
+        ...env,
+        PKG_CONFIG_PATH: pkgConfigPath()
+      }
+    }).stdout;
     /* istanbul ignore next */
     return (globalLibvipsVersion || '').trim();
   } else {
@@ -85,7 +91,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,

lib/operation.js

@@ -420,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}

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

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';

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"`
     );
   }

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.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.3",
+  "version": "0.30.6",
   "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.2",
+    "mocha": "^10.0.0",
     "mock-fs": "^5.1.2",
     "nyc": "^15.1.0",
     "prebuild": "^11.0.3",

src/common.cc

@@ -48,6 +48,9 @@ namespace sharp {
   int32_t AttrAsInt32(Napi::Object obj, unsigned int const attr) {
     return obj.Get(attr).As<Napi::Number>().Int32Value();
   }
+  int64_t AttrAsInt64(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::Number>().Int64Value();
+  }
   double AttrAsDouble(Napi::Object obj, std::string attr) {
     return obj.Get(attr).As<Napi::Number>().DoubleValue();
   }
@@ -85,7 +88,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");
@@ -129,7 +134,7 @@ namespace sharp {
       }
     }
     // Limit input images to a given number of pixels, where pixels = width * height
-    descriptor->limitInputPixels = AttrAsUint32(input, "limitInputPixels");
+    descriptor->limitInputPixels = static_cast<uint64_t>(AttrAsInt64(input, "limitInputPixels"));
     // Allow switch from random to sequential access
     descriptor->access = AttrAsBool(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
     // Remove safety features and allow unlimited SVG/PNG input
@@ -329,7 +334,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 +380,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 +391,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 +402,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);
             }
@@ -442,7 +442,7 @@ namespace sharp {
     }
     // Limit input images to a given number of pixels, where pixels = width * height
     if (descriptor->limitInputPixels > 0 &&
-      static_cast<uint64_t>(image.width() * image.height()) > static_cast<uint64_t>(descriptor->limitInputPixels)) {
+      static_cast<uint64_t>(image.width() * image.height()) > descriptor->limitInputPixels) {
       throw vips::VError("Input image exceeds pixel limit");
     }
     return std::make_tuple(image, imageType);

src/common.h

@@ -48,8 +48,8 @@ namespace sharp {
     std::string name;
     std::string file;
     char *buffer;
-    bool failOnError;
-    int limitInputPixels;
+    VipsFailOn failOn;
+    uint64_t limitInputPixels;
     bool unlimited;
     VipsAccess access;
     size_t bufferLength;
@@ -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),

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

test/unit/extract.js

@@ -168,14 +168,51 @@ describe('Partial image extraction', function () {
       });
   });
 
-  it('Rotate with EXIF mirroring then extract', function (done) {
-    sharp(fixtures.inputJpgWithLandscapeExif7)
-      .rotate()
-      .extract({ left: 0, top: 208, width: 60, height: 40 })
-      .toBuffer(function (err, data) {
-        if (err) throw err;
-        fixtures.assertSimilar(fixtures.expected('rotate-mirror-extract.jpg'), data, done);
+  describe('Apply exif orientation and mirroring then extract', () => {
+    [
+      {
+        name: 'EXIF-1',
+        image: fixtures.inputJpgWithLandscapeExif1
+      },
+      {
+        name: 'EXIF-2',
+        image: fixtures.inputJpgWithLandscapeExif2
+      },
+      {
+        name: 'EXIF-3',
+        image: fixtures.inputJpgWithLandscapeExif3
+      },
+      {
+        name: 'EXIF-4',
+        image: fixtures.inputJpgWithLandscapeExif4
+      },
+      {
+        name: 'EXIF-5',
+        image: fixtures.inputJpgWithLandscapeExif5
+      },
+      {
+        name: 'EXIF-6',
+        image: fixtures.inputJpgWithLandscapeExif6
+      },
+      {
+        name: 'EXIF-7',
+        image: fixtures.inputJpgWithLandscapeExif7
+      },
+      {
+        name: 'EXIF-8',
+        image: fixtures.inputJpgWithLandscapeExif8
+      }
+    ].forEach(({ name, image }) => {
+      it(name, function (done) {
+        sharp(image)
+          .rotate()
+          .extract({ left: 0, top: 208, width: 60, height: 40 })
+          .toBuffer(function (err, data) {
+            if (err) throw err;
+            fixtures.assertSimilar(fixtures.expected('rotate-mirror-extract.jpg'), data, done);
+          });
       });
+    });
   });
 
   describe('Invalid parameters', function () {

test/unit/failOn.js

@@ -3,56 +3,70 @@
 const assert = require('assert');
 const fs = require('fs');
 
-const sharp = require('../../');
+const sharp = require('../../lib');
 const fixtures = require('../fixtures');
 
-describe('failOnError', function () {
+describe('failOn', () => {
   it('handles truncated JPEG', function (done) {
-    sharp(fixtures.inputJpgTruncated, { failOnError: false })
-      .resize(320, 240)
+    sharp(fixtures.inputJpgTruncated, { failOn: 'none' })
+      .resize(32, 24)
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);
-        assert.strictEqual(320, info.width);
-        assert.strictEqual(240, info.height);
+        assert.strictEqual(32, info.width);
+        assert.strictEqual(24, info.height);
         fixtures.assertSimilar(fixtures.expected('truncated.jpg'), data, done);
       });
   });
 
   it('handles truncated PNG, emits warnings', function (done) {
     let isWarningEmitted = false;
-    sharp(fixtures.inputPngTruncated, { failOnError: false })
+    sharp(fixtures.inputPngTruncated, { failOn: 'none' })
       .on('warning', function (warning) {
         assert.ok(warning.includes('not enough data') || warning.includes('end of stream'));
         isWarningEmitted = true;
       })
-      .resize(320, 240)
+      .resize(32, 24)
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, isWarningEmitted);
         assert.strictEqual('png', info.format);
-        assert.strictEqual(320, info.width);
-        assert.strictEqual(240, info.height);
+        assert.strictEqual(32, info.width);
+        assert.strictEqual(24, info.height);
         done();
       });
   });
 
-  it('rejects invalid values', function () {
-    assert.doesNotThrow(function () {
-      sharp(fixtures.inputJpg, { failOnError: true });
-    });
+  it('throws for invalid options', () => {
+    assert.throws(
+      () => sharp({ failOn: 'zoinks' }),
+      /Expected one of: none, truncated, error, warning for failOn but received zoinks of type string/
+    );
+    assert.throws(
+      () => sharp({ failOn: 1 }),
+      /Expected one of: none, truncated, error, warning for failOn but received 1 of type number/
+    );
+  });
 
-    assert.throws(function () {
-      sharp(fixtures.inputJpg, { failOnError: 'zoinks' });
-    });
-
-    assert.throws(function () {
-      sharp(fixtures.inputJpg, { failOnError: 1 });
-    });
+  it('deprecated failOnError', () => {
+    assert.doesNotThrow(
+      () => sharp({ failOnError: true })
+    );
+    assert.doesNotThrow(
+      () => sharp({ failOnError: false })
+    );
+    assert.throws(
+      () => sharp({ failOnError: 'zoinks' }),
+      /Expected boolean for failOnError but received zoinks of type string/
+    );
+    assert.throws(
+      () => sharp({ failOnError: 1 }),
+      /Expected boolean for failOnError but received 1 of type number/
+    );
   });
 
   it('returns errors to callback for truncated JPEG', function (done) {
-    sharp(fixtures.inputJpgTruncated).toBuffer(function (err, data, info) {
+    sharp(fixtures.inputJpgTruncated, { failOn: 'truncated' }).toBuffer(function (err, data, info) {
       assert.ok(err.message.includes('VipsJpeg: Premature end of'), err);
       assert.strictEqual(data, undefined);
       assert.strictEqual(info, undefined);
@@ -61,7 +75,7 @@ describe('failOnError', function () {
   });
 
   it('returns errors to callback for truncated PNG', function (done) {
-    sharp(fixtures.inputPngTruncated).toBuffer(function (err, data, info) {
+    sharp(fixtures.inputPngTruncated, { failOn: 'truncated' }).toBuffer(function (err, data, info) {
       assert.ok(err.message.includes('read error'), err);
       assert.strictEqual(data, undefined);
       assert.strictEqual(info, undefined);
@@ -70,7 +84,7 @@ describe('failOnError', function () {
   });
 
   it('rejects promises for truncated JPEG', function (done) {
-    sharp(fixtures.inputJpgTruncated)
+    sharp(fixtures.inputJpgTruncated, { failOn: 'error' })
       .toBuffer()
       .then(() => {
         throw new Error('Expected rejection');
@@ -80,8 +94,8 @@ describe('failOnError', function () {
       });
   });
 
-  it('handles stream-based input', function () {
-    const writable = sharp({ failOnError: false });
+  it('handles stream-based input', async () => {
+    const writable = sharp({ failOn: 'none' }).resize(32, 24);
     fs.createReadStream(fixtures.inputJpgTruncated).pipe(writable);
     return writable.toBuffer();
   });

test/unit/io.js

@@ -182,6 +182,24 @@ describe('Input/output', function () {
     assert.strictEqual(info.height, 1);
   });
 
+  it('Read from Uint8ClampedArray with byteOffset and output to Buffer', async () => {
+    // since a Uint8ClampedArray is the same as Uint8Array but clamps the values
+    // between 0-255 it seemed good to add this also
+    const uint8array = Uint8ClampedArray.from([0, 0, 0, 255, 255, 255, 0, 0, 0, 255, 255, 255]);
+    const uint8ArrayWithByteOffset = new Uint8ClampedArray(uint8array.buffer, 3, 6);
+    const { data, info } = await sharp(uint8ArrayWithByteOffset, {
+      raw: {
+        width: 2,
+        height: 1,
+        channels: 3
+      }
+    }).toBuffer({ resolveWithObject: true });
+
+    assert.deepStrictEqual(Uint8ClampedArray.from([255, 255, 255, 0, 0, 0]), new Uint8ClampedArray(data));
+    assert.strictEqual(info.width, 2);
+    assert.strictEqual(info.height, 1);
+  });
+
   it('Stream should emit info event', function (done) {
     const readable = fs.createReadStream(fixtures.inputJpg);
     const writable = fs.createWriteStream(outputJpg);
@@ -439,7 +457,7 @@ describe('Input/output', function () {
       done();
     }).catch(function (err) {
       assert(err instanceof Error);
-      assert.strictEqual('Input file is missing', err.message);
+      assert.strictEqual('Input file is missing: does-not-exist', err.message);
       done();
     });
   });
@@ -688,6 +706,12 @@ describe('Input/output', function () {
       });
     });
 
+    it('Invalid fails - integer overflow', () => {
+      assert.throws(() => {
+        sharp({ limitInputPixels: Number.MAX_SAFE_INTEGER + 1 });
+      });
+    });
+
     it('Invalid fails - string', () => {
       assert.throws(() => {
         sharp({ limitInputPixels: 'fail' });

test/unit/negate.js

@@ -186,6 +186,22 @@ describe('Negate', function () {
       });
   });
 
+  it('negate create', async () => {
+    const [r, g, b] = await sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 3,
+        background: { r: 10, g: 20, b: 30 }
+      }
+    })
+      .negate()
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual({ r, g, b }, { r: 245, g: 235, b: 225 });
+  });
+
   it('invalid alpha value', function () {
     assert.throws(function () {
       sharp(fixtures.inputWebPWithTransparency).negate({ alpha: 'non-bool' });

test/unit/noise.js

@@ -19,7 +19,7 @@ describe('Gaussian noise', function () {
           sigma: 30
         }
       }
-    });
+    }).toColourspace('b-w');
     noise.toFile(output, function (err, info) {
       if (err) throw err;
       assert.strictEqual('png', info.format);
@@ -131,6 +131,7 @@ describe('Gaussian noise', function () {
       }
     });
     noise
+      .toColourspace('b-w')
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(1, info.channels);

test/unit/platform.js

@@ -61,4 +61,28 @@ describe('Platform-detection', function () {
     delete process.env.npm_config_arch;
     delete process.versions.electron;
   });
+
+  it('Can override libc if platform is linux', function () {
+    process.env.npm_config_platform = 'linux';
+    process.env.npm_config_libc = 'test';
+    assert.strictEqual('linuxtest', platform().split('-')[0]);
+    delete process.env.npm_config_platform;
+    delete process.env.npm_config_libc;
+  });
+
+  it('Handles libc value "glibc" as default linux', function () {
+    process.env.npm_config_platform = 'linux';
+    process.env.npm_config_libc = 'glibc';
+    assert.strictEqual('linux', platform().split('-')[0]);
+    delete process.env.npm_config_platform;
+    delete process.env.npm_config_libc;
+  });
+
+  it('Discards libc value on non-linux platform', function () {
+    process.env.npm_config_platform = 'win32';
+    process.env.npm_config_libc = 'gnuwin32';
+    assert.strictEqual('win32', platform().split('-')[0]);
+    delete process.env.npm_config_platform;
+    delete process.env.npm_config_libc;
+  });
 });

test/unit/svg.js

@@ -136,6 +136,20 @@ describe('SVG input', function () {
     assert.strictEqual(info.channels, 4);
   });
 
+  it('Fails to render SVG larger than 32767x32767', () =>
+    assert.rejects(
+      () => sharp(Buffer.from('<svg width="32768" height="1" />')).toBuffer(),
+      /Input SVG image exceeds 32767x32767 pixel limit/
+    )
+  );
+
+  it('Fails to render scaled SVG larger than 32767x32767', () =>
+    assert.rejects(
+      () => sharp(Buffer.from('<svg width="32767" height="1" />')).resize(32768).toBuffer(),
+      /Input SVG image will exceed 32767x32767 pixel limit when scaled/
+    )
+  );
+
   it('Detects SVG passed as a string', () =>
     assert.rejects(
       () => sharp('<svg></svg>').toBuffer(),