Release v0.28.0

Fixes bug where certain input values for top/left parameters
in composite can conflict with clipping logic, resulting in
inaccurate alignment in output.

.github/CONTRIBUTING.md

@@ -27,7 +27,7 @@ Please select the `master` branch as the destination for your Pull Request so yo
 
 Please squash your changes into a single commit using a command like `git rebase -i upstream/master`.
 
-To test C++ changes, you can compile the module using `npm install` and then run the tests using `npm test`.
+To test C++ changes, you can compile the module using `npm install --build-from-source` and then run the tests using `npm test`.
 
 ## Submit a Pull Request with a new feature
 

.github/ISSUE_TEMPLATE/installation.md

@@ -11,7 +11,9 @@ Have you ensured the architecture and platform of Node.js used for `npm install`
 
 Are you using the latest version? Is the version currently in use as reported by `npm ls sharp` the same as the latest version as reported by `npm view sharp dist-tags.latest`?
 
-If you are installing as a `root` or `sudo` user, have you tried with the `npm install --unsafe-perm` flag?
+If you are using npm v6 or earlier and installing as a `root` or `sudo` user, have you tried with the `npm install --unsafe-perm` flag?
+
+If you are using npm v7, does the user running `npm install` own the directory it is run in?
 
 If you are using the `ignore-scripts` feature of `npm`, have you tried with the `npm install --ignore-scripts=false` flag?
 

.github/workflows/ci.yml

@@ -30,6 +30,8 @@ jobs:
             container: node:12-alpine3.11
           - os: ubuntu-20.04
             container: node:14-alpine3.11
+          - os: ubuntu-20.04
+            container: node:14-alpine3.13
           - os: ubuntu-20.04
             container: node:15-alpine3.11
           - os: macos-10.15

.travis.yml

@@ -58,5 +58,51 @@ jobs:
       install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
       script: sudo docker exec sharp sh -c "npm test"
 
+    - name: "Linux ARM64v8 (Alpine 3.11, musl 1.1.24) - Node.js 10"
+      arch: arm64
+      os: linux
+      dist: focal
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:10-alpine3.11
+        - sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+      after_success: "[[ -n $TRAVIS_TAG ]] && sudo docker exec --env prebuild_upload sharp sh -c \"npx prebuild --runtime napi --target 3\""
+
+    - name: "Linux ARM64v8 (Alpine 3.11, musl 1.1.24) - Node.js 12"
+      arch: arm64
+      os: linux
+      dist: focal
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:12-alpine3.11
+        - sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "Linux ARM64v8 (Alpine 3.11, musl 1.1.24) - Node.js 14"
+      arch: arm64
+      os: linux
+      dist: focal
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:14-alpine3.11
+        - sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "Linux ARM64v8 (Alpine 3.11, musl 1.1.24) - Node.js 15"
+      arch: arm64
+      os: linux
+      dist: focal
+      language: shell
+      before_install:
+        - sudo chown 0.0 ${PWD}
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:15-alpine3.11
+        - sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
 cache:
   npm: false

README.md

@@ -19,6 +19,14 @@ rotation, extraction, compositing and gamma correction are available.
 Most modern macOS, Windows and Linux systems running Node.js v10+
 do not require any additional install or runtime dependencies.
 
+## Documentation
+
+Visit [sharp.pixelplumbing.com](https://sharp.pixelplumbing.com/) for complete
+[installation instructions](https://sharp.pixelplumbing.com/install),
+[API documentation](https://sharp.pixelplumbing.com/api-constructor),
+[benchmark tests](https://sharp.pixelplumbing.com/performance) and
+[changelog](https://sharp.pixelplumbing.com/changelog).
+
 ## Examples
 
 ```sh
@@ -43,6 +51,7 @@ sharp(inputBuffer)
 sharp('input.jpg')
   .rotate()
   .resize(200)
+  .jpeg({ mozjpeg: true })
   .toBuffer()
   .then( data => { ... })
   .catch( err => { ... });
@@ -84,25 +93,17 @@ readableStream
   .pipe(writableStream);
 ```
 
-[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.svg?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
-[![N-API v3](https://img.shields.io/badge/N--API-v3-green.svg)](https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api_version_matrix)
-
-### Documentation
-
-Visit [sharp.pixelplumbing.com](https://sharp.pixelplumbing.com/) for complete
-[installation instructions](https://sharp.pixelplumbing.com/install),
-[API documentation](https://sharp.pixelplumbing.com/api-constructor),
-[benchmark tests](https://sharp.pixelplumbing.com/performance) and
-[changelog](https://sharp.pixelplumbing.com/changelog).
-
-### Contributing
+## Contributing
 
 A [guide for contributors](https://github.com/lovell/sharp/blob/master/.github/CONTRIBUTING.md)
 covers reporting bugs, requesting features and submitting code changes.
 
-### Licensing
+[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.svg?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
+[![N-API v3](https://img.shields.io/badge/N--API-v3-green.svg)](https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api_version_matrix)
 
-Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
+## Licensing
+
+Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Lovell Fuller and contributors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

binding.gyp

@@ -140,8 +140,7 @@
             'link_settings': {
               'library_dirs': ['<(sharp_vendor_dir)/lib'],
               'libraries': [
-                'libvips-cpp.42.dylib',
-                'libvips.42.dylib'
+                'libvips-cpp.42.dylib'
               ]
             },
             'xcode_settings': {
@@ -153,13 +152,12 @@
           }],
           ['OS == "linux"', {
             'defines': [
-              '_GLIBCXX_USE_CXX11_ABI=0'
+              '_GLIBCXX_USE_CXX11_ABI=1'
             ],
             'link_settings': {
               'library_dirs': ['<(sharp_vendor_dir)/lib'],
               'libraries': [
-                '-l:libvips-cpp.so.42',
-                '-l:libvips.so.42'
+                '-l:libvips-cpp.so.42'
               ],
               'ldflags': [
                 # Ensure runtime linking is relative to sharp.node

docs/README.md

@@ -50,6 +50,10 @@ no child processes are spawned and Promises/async/await are supported.
 
 ### Optimal
 
+The features of `mozjpeg` and `pngquant` can be used
+to optimise the file size of JPEG and PNG images respectively,
+without having to invoke separate `imagemin` processes.
+
 Huffman tables are optimised when generating JPEG output images
 without having to use separate command line tools like
 [jpegoptim](https://github.com/tjko/jpegoptim) and
@@ -66,7 +70,7 @@ covers reporting bugs, requesting features and submitting code changes.
 
 ### Licensing
 
-Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
+Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Lovell Fuller and contributors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

docs/api-colour.md

@@ -48,6 +48,14 @@ By default output image will be web-friendly sRGB, with additional channels inte
 
 -   `colourspace` **[string][1]?** output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][6]
 
+### Examples
+
+```javascript
+// Output 16 bits per pixel RGB
+await sharp(input)
+ .toColourspace('rgb16')
+ .toFile('16-bpp.png')
+```
 
 -   Throws **[Error][4]** Invalid parameters
 

docs/api-constructor.md

@@ -13,32 +13,36 @@ Implements the [stream.Duplex][1] class.
 
 ### Parameters
 
--   `input` **([Buffer][2] \| [string][3])?** if present, can be
-     a Buffer containing JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data, or
+-   `input` **([Buffer][2] \| [Uint8Array][3] \| [Uint8ClampedArray][4] \| [string][5])?** if present, can be
+     a Buffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data, or
      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.
--   `options` **[Object][4]?** if present, is an Object with optional attributes.
-    -   `options.failOnError` **[boolean][5]** by default halt processing and raise an error when loading invalid images.
+-   `options` **[Object][6]?** if present, is an Object with optional attributes.
+    -   `options.failOnError` **[boolean][7]** 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][6] \| [boolean][5])** Do not process input images where the number of pixels
+    -   `options.limitInputPixels` **([number][8] \| [boolean][7])** 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.sequentialRead` **[boolean][5]** Set this to `true` to use sequential rather than random access where possible.
+    -   `options.sequentialRead` **[boolean][7]** 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][6]** number representing the DPI for vector images in the range 1 to 100000. (optional, default `72`)
-    -   `options.pages` **[number][6]** 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][6]** page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based. (optional, default `0`)
-    -   `options.level` **[number][6]** level to extract from a multi-level input (OpenSlide), zero based. (optional, default `0`)
-    -   `options.animated` **[boolean][5]** Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`). (optional, default `false`)
-    -   `options.raw` **[Object][4]?** describes raw pixel input image data. See `raw()` for pixel ordering.
-        -   `options.raw.width` **[number][6]?** 
-        -   `options.raw.height` **[number][6]?** 
-        -   `options.raw.channels` **[number][6]?** 1-4
-    -   `options.create` **[Object][4]?** describes a new image to be created.
-        -   `options.create.width` **[number][6]?** 
-        -   `options.create.height` **[number][6]?** 
-        -   `options.create.channels` **[number][6]?** 3-4
-        -   `options.create.background` **([string][3] \| [Object][4])?** parsed by the [color][7] module to extract values for red, green, blue and alpha.
+    -   `options.density` **[number][8]** number representing the DPI for vector images in the range 1 to 100000. (optional, default `72`)
+    -   `options.pages` **[number][8]** 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][8]** page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based. (optional, default `0`)
+    -   `options.level` **[number][8]** level to extract from a multi-level input (OpenSlide), zero based. (optional, default `0`)
+    -   `options.animated` **[boolean][7]** Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`). (optional, default `false`)
+    -   `options.raw` **[Object][6]?** describes raw pixel input image data. See `raw()` for pixel ordering.
+        -   `options.raw.width` **[number][8]?** integral number of pixels wide.
+        -   `options.raw.height` **[number][8]?** integral number of pixels high.
+        -   `options.raw.channels` **[number][8]?** integral number of channels, between 1 and 4.
+    -   `options.create` **[Object][6]?** describes a new image to be created.
+        -   `options.create.width` **[number][8]?** integral number of pixels wide.
+        -   `options.create.height` **[number][8]?** integral number of pixels high.
+        -   `options.create.channels` **[number][8]?** integral number of channels, either 3 (RGB) or 4 (RGBA).
+        -   `options.create.background` **([string][5] \| [Object][6])?** parsed by the [color][9] module to extract values for red, green, blue and alpha.
+        -   `options.create.noise` **[Object][6]?** describes a noise to be created.
+            -   `options.create.noise.type` **[string][5]?** type of generated noise, currently only `gaussian` is supported.
+            -   `options.create.noise.mean` **[number][8]?** mean of pixels in generated noise.
+            -   `options.create.noise.sigma` **[number][8]?** standard deviation of pixels in generated noise.
 
 ### Examples
 
@@ -84,9 +88,40 @@ sharp({
 await sharp('in.gif', { animated: true }).toFile('out.webp');
 ```
 
--   Throws **[Error][8]** Invalid parameters
+```javascript
+// Read a raw array of pixels and save it to a png
+const input = Uint8Array.from([255, 255, 255, 0, 0, 0]); // or Uint8ClampedArray
+const image = sharp(input, {
+  // because the input does not contain its dimensions or how many channels it has
+  // we need to specify it in the constructor options
+  raw: {
+    width: 2,
+    height: 1,
+    channels: 3
+  }
+});
+await image.toFile('my-two-pixels.png');
+```
 
-Returns **[Sharp][9]** 
+```javascript
+// Generate RGB Gaussian noise
+await sharp({
+  create: {
+    width: 300,
+    height: 200,
+    channels: 3,
+    noise: {
+      type: 'gaussian',
+      mean: 128,
+      sigma: 30
+    }
+ }
+}).toFile('noise.png');
+```
+
+-   Throws **[Error][10]** Invalid parameters
+
+Returns **[Sharp][11]** 
 
 ## clone
 
@@ -154,22 +189,26 @@ Promise.all(promises)
   });
 ```
 
-Returns **[Sharp][9]** 
+Returns **[Sharp][11]** 
 
 [1]: http://nodejs.org/api/stream.html#stream_class_stream_duplex
 
 [2]: https://nodejs.org/api/buffer.html
 
-[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
 
-[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray
 
-[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
-[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[7]: https://www.npmjs.org/package/color
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
-[9]: #sharp
+[9]: https://www.npmjs.org/package/color
+
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[11]: #sharp

docs/api-operation.md

@@ -169,13 +169,21 @@ Returns **Sharp**
 
 ## flatten
 
-Merge alpha transparency channel, if any, with a background.
+Merge alpha transparency channel, if any, with a background, then remove the alpha channel.
 
 ### Parameters
 
 -   `options` **[Object][2]?** 
     -   `options.background` **([string][3] \| [Object][2])** background colour, parsed by the [color][4] module, defaults to black. (optional, default `{r:0,g:0,b:0}`)
 
+### Examples
+
+```javascript
+await sharp(rgbaInput)
+  .flatten('#F0A703')
+  .toBuffer();
+```
+
 Returns **Sharp** 
 
 ## gamma
@@ -263,7 +271,7 @@ Returns **Sharp**
 
 ## threshold
 
-Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+Any pixel value greater than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
 
 ### Parameters
 

docs/api-output.md

@@ -86,6 +86,23 @@ sharp(input)
   .catch(err => { ... });
 ```
 
+```javascript
+const { data, info } = await sharp('my-image.jpg')
+  // output the raw pixels
+  .raw()
+  .toBuffer({ resolveWithObject: true });
+
+// create a more type safe way to work with the raw pixel data
+// this will not copy the data, instead it will change `data`s underlying ArrayBuffer
+// so `data` and `pixelArray` point to the same memory location
+const pixelArray = new Uint8ClampedArray(data.buffer);
+
+// When you are done changing the pixelArray, sharp takes the `pixelArray` as an input
+const { width, height, channels } = info;
+await sharp(pixelArray, { raw: { width, height, channels } })
+  .toFile('my-changed-image.jpg');
+```
+
 Returns **[Promise][5]<[Buffer][8]>** when no callback is provided
 
 ## withMetadata
@@ -142,8 +159,6 @@ Returns **Sharp**
 
 Use these JPEG options for output image.
 
-Some of these options require the use of a globally-installed libvips compiled with support for mozjpeg.
-
 ### Parameters
 
 -   `options` **[Object][6]?** output options
@@ -152,12 +167,13 @@ Some of these options require the use of a globally-installed libvips compiled w
     -   `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.trellisQuantisation` **[boolean][7]** apply trellis quantisation, requires libvips compiled with support for mozjpeg (optional, default `false`)
-    -   `options.overshootDeringing` **[boolean][7]** apply overshoot deringing, requires libvips compiled with support for mozjpeg (optional, default `false`)
-    -   `options.optimiseScans` **[boolean][7]** optimise progressive scans, forces progressive, requires libvips compiled with support for mozjpeg (optional, default `false`)
-    -   `options.optimizeScans` **[boolean][7]** alternative spelling of optimiseScans, requires libvips compiled with support for mozjpeg (optional, default `false`)
-    -   `options.quantisationTable` **[number][9]** quantization table to use, integer 0-8, requires libvips compiled with support for mozjpeg (optional, default `0`)
-    -   `options.quantizationTable` **[number][9]** alternative spelling of quantisationTable, requires libvips compiled with support for mozjpeg (optional, default `0`)
+    -   `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`)
 
 ### Examples
@@ -172,6 +188,13 @@ const data = await sharp(input)
   .toBuffer();
 ```
 
+```javascript
+// Use mozjpeg to reduce output JPEG file size (slower)
+const data = await sharp(input)
+  .jpeg({ mozjpeg: true })
+  .toBuffer();
+```
+
 -   Throws **[Error][4]** Invalid options
 
 Returns **Sharp** 
@@ -180,33 +203,39 @@ Returns **Sharp**
 
 Use these PNG options for output image.
 
-PNG output is always full colour at 8 or 16 bits per pixel.
+By default, PNG output is full colour at 8 or 16 bits per pixel.
 Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
-
-Some of these options require the use of a globally-installed libvips compiled with support for libimagequant (GPL).
+Set `palette` to `true` for slower, indexed PNG output.
 
 ### Parameters
 
 -   `options` **[Object][6]?** 
     -   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
-    -   `options.compressionLevel` **[number][9]** zlib compression level, 0-9 (optional, default `9`)
+    -   `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, requires libvips compiled with support for libimagequant (optional, default `false`)
-    -   `options.quality` **[number][9]** use the lowest number of colours needed to achieve given quality, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `100`)
-    -   `options.colours` **[number][9]** maximum number of palette entries, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `256`)
-    -   `options.colors` **[number][9]** alternative spelling of `options.colours`, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `256`)
-    -   `options.dither` **[number][9]** level of Floyd-Steinberg error diffusion, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `1.0`)
+    -   `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.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`)
 
 ### Examples
 
 ```javascript
-// Convert any input to PNG output
+// Convert any input to full colour PNG output
 const data = await sharp(input)
   .png()
   .toBuffer();
 ```
 
+```javascript
+// Convert any input to indexed PNG output (slower)
+const data = await sharp(input)
+  .png({ palette: true })
+  .toBuffer();
+```
+
 -   Throws **[Error][4]** Invalid options
 
 Returns **Sharp** 
@@ -272,15 +301,15 @@ Use these TIFF options for output image.
 -   `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.compression` **[boolean][7]** compression options: lzw, deflate, jpeg, ccittfax4 (optional, default `'jpeg'`)
-    -   `options.predictor` **[boolean][7]** compression predictor options: none, horizontal, float (optional, default `'horizontal'`)
+    -   `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` **[boolean][7]** horizontal tile size (optional, default `256`)
-    -   `options.tileHeight` **[boolean][7]** vertical tile size (optional, default `256`)
+    -   `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.bitdepth` **[boolean][7]** reduce bitdepth to 1, 2 or 4 bit (optional, default `8`)
+    -   `options.bitdepth` **[number][9]** reduce bitdepth to 1, 2 or 4 bit (optional, default `8`)
 
 ### Examples
 
@@ -311,7 +340,8 @@ most web browsers do not display these properly.
 -   `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.speed` **[boolean][7]** CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest) (optional, default `5`)
+    -   `options.speed` **[number][9]** CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest) (optional, default `5`)
+    -   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0 (optional, default `'4:2:0'`)
 
 
 -   Throws **[Error][4]** Invalid options
@@ -333,9 +363,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.compression` **[boolean][7]** compression format: av1, hevc (optional, default `'av1'`)
+    -   `options.compression` **[string][2]** compression format: av1, hevc (optional, default `'av1'`)
     -   `options.lossless` **[boolean][7]** use lossless compression (optional, default `false`)
-    -   `options.speed` **[boolean][7]** CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest) (optional, default `5`)
+    -   `options.speed` **[number][9]** CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest) (optional, default `5`)
+    -   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0 (optional, default `'4:2:0'`)
 
 
 -   Throws **[Error][4]** Invalid options
@@ -394,6 +425,7 @@ Warning: multiple sharp instances concurrently producing tile output can expose
     -   `options.layout` **[string][2]** filesystem layout, possible values are `dz`, `iiif`, `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.id` **[string][2]** when `layout` is `iiif`, sets the `@id` attribute of `info.json` (optional, default `'https://example.com/iiif'`)
 
 ### Examples
 

docs/api-resize.md

@@ -137,10 +137,10 @@ This operation will always occur after resizing and extraction, if any.
 ### Parameters
 
 -   `extend` **([number][8] \| [Object][9])** single pixel count to add to all edges or an Object with per-edge counts
-    -   `extend.top` **[number][8]?** 
-    -   `extend.left` **[number][8]?** 
-    -   `extend.bottom` **[number][8]?** 
-    -   `extend.right` **[number][8]?** 
+    -   `extend.top` **[number][8]**  (optional, default `0`)
+    -   `extend.left` **[number][8]**  (optional, default `0`)
+    -   `extend.bottom` **[number][8]**  (optional, default `0`)
+    -   `extend.right` **[number][8]**  (optional, default `0`)
     -   `extend.background` **([String][10] \| [Object][9])** background colour, parsed by the [color][11] module, defaults to black without transparency. (optional, default `{r:0,g:0,b:0,alpha:1}`)
 
 ### Examples
@@ -160,6 +160,16 @@ sharp(input)
   ...
 ```
 
+```javascript
+// Add a row of 10 red pixels to the bottom
+sharp(input)
+  .extend({
+    bottom: 10,
+    background: 'red'
+  })
+  ...
+```
+
 -   Throws **[Error][13]** Invalid parameters
 
 Returns **Sharp** 

docs/api-utility.md

@@ -84,8 +84,12 @@ Returns **[Object][1]**
 
 Gets or, when a concurrency is provided, sets
 the number of threads _libvips'_ should create to process each image.
-The default value is the number of CPU cores.
-A value of `0` will reset to this default.
+
+The default value is the number of CPU cores,
+except when using glibc-based Linux without jemalloc,
+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.

docs/build.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const fs = require('fs').promises;
+const path = require('path');
+const documentation = require('documentation');
+
+[
+  'constructor',
+  'input',
+  'resize',
+  'composite',
+  'operation',
+  'colour',
+  'channel',
+  'output',
+  'utility'
+].forEach(async (m) => {
+  const input = path.join('lib', `${m}.js`);
+  const output = path.join('docs', `api-${m}.md`);
+
+  const ast = await documentation.build(input, { shallow: true });
+  const markdown = await documentation.formats.md(ast, { markdownToc: false });
+
+  await fs.writeFile(output, markdown);
+});

docs/changelog.md

@@ -1,9 +1,78 @@
 # Changelog
 
+## v0.28 - *bijou*
+
+Requires libvips v8.10.6
+
+### v0.28.0 - 29th March 2021
+
+* Prebuilt binaries now include mozjpeg and libimagequant (BSD 2-Clause).
+
+* Prebuilt binaries limit AVIF support to the most common 8-bit depth.
+
+* Add `mozjpeg` option to `jpeg` method, sets mozjpeg defaults.
+
+* Reduce the default PNG `compressionLevel` to the more commonly used 6.
+
+* Reduce concurrency on glibc-based Linux when using the default memory allocator to help prevent fragmentation.
+
+* Default missing edge properties of extend operation to zero.
+  [#2578](https://github.com/lovell/sharp/issues/2578)
+
+* Ensure composite does not clip top and left offsets.
+  [#2594](https://github.com/lovell/sharp/pull/2594)
+  [@SHG42](https://github.com/SHG42)
+
+* Improve error handling of network failure at install time.
+  [#2608](https://github.com/lovell/sharp/pull/2608)
+  [@abradley](https://github.com/abradley)
+
+* Ensure `@id` attribute can be set for IIIF tile-based output.
+  [#2612](https://github.com/lovell/sharp/issues/2612)
+  [@edsilv](https://github.com/edsilv)
+
+* Ensure composite replicates the correct number of tiles for centred gravities.
+  [#2626](https://github.com/lovell/sharp/issues/2626)
+
 ## v0.27 - *avif*
 
 Requires libvips v8.10.5
 
+### v0.27.2 - 22nd February 2021
+
+* macOS: Prevent use of globally-installed ARM64 libvips with Rosetta x64 emulation.
+  [#2460](https://github.com/lovell/sharp/issues/2460)
+
+* Linux (musl): Prevent use of prebuilt linuxmusl-x64 binaries with musl >= 1.2.0.
+  [#2570](https://github.com/lovell/sharp/issues/2570)
+
+* Improve 16-bit grey+alpha support by using libvips' `has_alpha` detection.
+  [#2569](https://github.com/lovell/sharp/issues/2569)
+
+* Allow the use of non lower case extensions with `toFormat`.
+  [#2581](https://github.com/lovell/sharp/pull/2581)
+  [@florian-busch](https://github.com/florian-busch)
+
+* Allow use of `recomb` operation with single channel input.
+  [#2584](https://github.com/lovell/sharp/issues/2584)
+
+### v0.27.1 - 27th January 2021
+
+* Ensure TIFF is cast when using float predictor.
+  [#2502](https://github.com/lovell/sharp/pull/2502)
+  [@randyridge](https://github.com/randyridge)
+
+* Add support for Uint8Array and Uint8ClampedArray input.
+  [#2511](https://github.com/lovell/sharp/pull/2511)
+  [@leon](https://github.com/leon)
+
+* Revert: ensure all platforms use fontconfig for font rendering.
+  [#2515](https://github.com/lovell/sharp/issues/2515)
+
+* Expose libvips gaussnoise operation to allow creation of Gaussian noise.
+  [#2527](https://github.com/lovell/sharp/pull/2527)
+  [@alza54](https://github.com/alza54)
+
 ### v0.27.0 - 22nd December 2020
 
 * Add support for AVIF to prebuilt binaries.

docs/firebase.json

@@ -4,6 +4,7 @@
     "public": ".",
     "ignore": [
       ".*",
+      "build.js",
       "firebase.json",
       "*.md",
       "image/**",

docs/humans.txt

@@ -206,3 +206,6 @@ GitHub: https://github.com/stefanprobst
 
 Name: Thomas Beiganz
 GitHub: https://github.com/beig
+
+Name: Florian Busch
+GitHub: https://github.com/florian-busch

docs/image/sharp-logo-mono.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="86 86 550 550">
+<!-- Creative Commons CC0 1.0 Universal Public Domain Dedication -->
+  <defs>
+    <mask id="c">
+      <path fill="none" stroke="#fff" stroke-width="80" d="M258.411 285.777l200.176-26.8M244.113 466.413L451.44 438.66m.001 0V238.484m0-150.121v171.572l178.725-23.917m-359.843 19.584V477.22m2.387 156.95V462.591L93.984 486.515"/>
+      <path fill="none" stroke="#000" stroke-width="112" d="M451.441 610.246V438.66l178.725-23.91M269.688 112.59v171.58L90.964 308.093"/>
+    </mask>
+  </defs>
+  <path mask="url(#c)" fill="none" stroke="#000" stroke-width="80" d="M258.411 285.777l200.176-26.8M244.113 466.413L451.44 438.66m.001 0V238.484m0-150.121v171.572l178.725-23.917m-359.843 19.584V477.22m2.387 156.95V462.591L93.984 486.515"/>
+  <path fill="none" stroke="#000" stroke-width="80" d="M451.441 610.246V438.66l178.725-23.91M269.688 112.59v171.58L90.964 308.093"/>
+</svg>

docs/image/sharp-logo.svg

@@ -1,5 +1,5 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="86 86 550 550">
-<!-- Copyright 2019 Lovell Fuller. This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) License. -->
+<!-- Creative Commons CC0 1.0 Universal Public Domain Dedication -->
 <path fill="none" stroke="#9c0" stroke-width="80" d="M258.411 285.777l200.176-26.8M244.113 466.413L451.44 438.66M451.441 438.66V238.484M451.441 88.363v171.572l178.725-23.917M270.323 255.602V477.22M272.71 634.17V462.591L93.984 486.515"/>
 <path fill="none" stroke="#090" stroke-width="80" d="M451.441 610.246V438.66l178.725-23.91M269.688 112.59v171.58L90.964 308.093"/>
 </svg>

docs/index.html

@@ -19,7 +19,7 @@
   <link rel="apple-touch-icon-precomposed" sizes="72x72" href="https://pixel.plumbing/px/72x72/sharp-logo.svg">
   <link rel="apple-touch-icon-precomposed" href="https://pixel.plumbing/px/57x57/sharp-logo.svg">
   <link rel="author" href="/humans.txt" type="text/plain">
-  <link rel="preload" href="https://cdn.jsdelivr.net/gh/lovell/sharp@v0.27.0/docs/README.md" as="fetch" type="text/markdown" crossorigin>
+  <link rel="preload" href="https://cdn.jsdelivr.net/gh/lovell/sharp@v0.28.0/docs/README.md" as="fetch" type="text/markdown" crossorigin>
   <link rel="preload" href="https://cdn.jsdelivr.net/gh/lovell/sharp@master/docs/image/sharp-logo.svg" as="image" type="image/svg+xml" crossorigin>
   <link rel="dns-prefetch" href="https://pixel.plumbing">
   <link rel="dns-prefetch" href="https://www.google-analytics.com">
@@ -38,7 +38,7 @@
       "@type": "Person",
       "name": "Lovell Fuller"
     },
-    "copyrightYear": [2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020],
+    "copyrightYear": [2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021],
     "license": "https://www.apache.org/licenses/LICENSE-2.0"
   }
   </script>
@@ -139,7 +139,7 @@
         docuteApiTitlePlugin,
         docuteApiSearchPlugin
       ],
-      sourcePath: 'https://cdn.jsdelivr.net/gh/lovell/sharp@v0.27.0/docs',
+      sourcePath: 'https://cdn.jsdelivr.net/gh/lovell/sharp@v0.28.0/docs',
       nav: [
         {
           title: 'Funding',

docs/install.md

@@ -19,11 +19,11 @@ Node.js v10+ on the most common platforms:
 
 * macOS x64 (>= 10.13)
 * Linux x64 (glibc >= 2.17, musl >= 1.1.24)
-* Linux ARM64 (glibc >= 2.29)
+* Linux ARM64 (glibc >= 2.29, musl >= 1.1.24)
 * Windows x64
 * Windows x86
 
-A ~9MB tarball containing libvips and its most commonly used dependencies
+An ~7.5MB tarball containing libvips and its most commonly used dependencies
 is downloaded via HTTPS and stored within `node_modules/sharp/vendor` during `npm install`.
 
 This provides support for the
@@ -31,16 +31,16 @@ JPEG, PNG, WebP, AVIF, TIFF, GIF (input) and SVG (input) image formats.
 
 The following platforms have prebuilt libvips but not sharp:
 
+* macOS ARM64
 * Linux ARMv6
 * Linux ARMv7 (glibc >= 2.28)
 * Windows ARM64
 
 The following platforms require compilation of both libvips and sharp from source:
 
-* macOS ARM64
 * Linux x86
 * Linux x64 (glibc <= 2.16, includes RHEL/CentOS 6)
-* Linux ARM64 (glibc <= 2.28, musl)
+* Linux ARM64 (glibc <= 2.28)
 * Linux PowerPC
 * FreeBSD
 * OpenBSD
@@ -50,12 +50,26 @@ The following platforms require compilation of both libvips and sharp from sourc
 The architecture and platform of Node.js used for `npm install`
 must be the same as the architecture and platform of Node.js used at runtime.
 
-The `npm install --unsafe-perm` flag must be used when installing as `root` or a `sudo` user.
+When using npm v6 or earlier, the `npm install --unsafe-perm` flag must be used when installing as `root` or a `sudo` user.
+
+When using npm v7, the user running `npm install` must own the directory it is run in.
 
 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.
 
+## Apple M1
+
+Prebuilt libvips binaries are provided for macOS on ARM64 (since sharp v0.28.0).
+
+During `npm install` sharp will be built locally,
+which requires Xcode and Python - see
+[building from source](#building-from-source).
+
+When this new ARM64 CPU is made freely available
+to open source projects via a CI service
+then prebuilt sharp binaries can also be provided.
+
 ## Custom libvips
 
 To use a custom, globally-installed version of libvips instead of the provided binaries,
@@ -135,6 +149,23 @@ pkg install -y pkgconf vips
 cd /usr/ports/graphics/vips/ && make install clean
 ```
 
+## Linux memory allocator
+
+The default memory allocator on most glibc-based Linux systems
+(e.g. Debian, Red Hat) is unsuitable for long-running, multi-threaded
+processes that involve lots of small memory allocations.
+
+For this reason, by default, sharp will limit the use of thread-based
+[concurrency](api-utility#concurrency) when the glibc allocator is
+detected at runtime.
+
+To help avoid fragmentation and improve performance on these systems,
+the use of an alternative memory allocator such as
+[jemalloc](https://github.com/jemalloc/jemalloc) is recommended.
+
+Those using musl-based Linux (e.g. Alpine) and non-Linux systems are
+unaffected.
+
 ## Heroku
 
 Add the
@@ -178,9 +209,34 @@ docker run -v "$PWD":/var/task lambci/lambda:build-nodejs12.x npm install sharp
 To get the best performance select the largest memory available.
 A 1536 MB function provides ~12x more CPU time than a 128 MB function.
 
+## Webpack
+
+Ensure sharp is added to the
+[externals](https://webpack.js.org/configuration/externals/)
+configuration.
+
+```js
+externals: {
+  'sharp': 'commonjs sharp'
+}
+```
+
 ## Worker threads
 
 The main thread must call `require('sharp')`
 before worker threads are created
 to ensure shared libraries remain loaded in memory
 until after all threads are complete.
+
+## Known conflicts
+
+### Canvas and Windows
+
+The prebuilt binaries provided by `canvas` for Windows depend on the unmaintained GTK 2, last updated in 2011.
+
+These conflict with the modern, up-to-date binaries provided by sharp.
+
+If both modules are used in the same Windows process, the following error will occur:
+```
+The specified procedure could not be found.
+```

docs/performance.md

@@ -5,10 +5,10 @@ A test to benchmark the performance of this module relative to alternatives.
 ## The contenders
 
 * [jimp](https://www.npmjs.com/package/jimp) v0.16.1 - Image processing in pure JavaScript. Provides bicubic interpolation.
-* [mapnik](https://www.npmjs.org/package/mapnik) v4.5.5 - Whilst primarily a map renderer, Mapnik contains bitmap image utilities.
+* [mapnik](https://www.npmjs.org/package/mapnik) v4.5.6 - Whilst primarily a map renderer, Mapnik contains bitmap image utilities.
 * [imagemagick](https://www.npmjs.com/package/imagemagick) v0.1.3 - Supports filesystem only and "*has been unmaintained for a long time*".
 * [gm](https://www.npmjs.com/package/gm) v1.23.1 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
-* sharp v0.27.0 / libvips v8.10.5 - Caching within libvips disabled to ensure a fair comparison.
+* sharp v0.28.0 / libvips v8.10.6 - Caching within libvips disabled to ensure a fair comparison.
 
 ## The task
 
@@ -18,25 +18,25 @@ then compress to JPEG at a "quality" setting of 80.
 
 ## Test environment
 
-* AWS EC2 eu-west-1 [c5d.large](https://aws.amazon.com/ec2/instance-types/c5/) (2x Xeon Platinum 8275CL CPU @ 3.00GHz)
-* Ubuntu 20.10 (ami-046cdbcee95cdd75c)
-* Node.js v14.15.3
+* AWS EC2 eu-west-1 [c5ad.xlarge](https://aws.amazon.com/ec2/instance-types/c5/) (4x AMD EPYC 7R32)
+* Ubuntu 20.10 (ami-03f10415e8b0bfb86)
+* Node.js v14.16.0
 
 ## Results
 
 | Module             | Input  | Output | Ops/sec | Speed-up |
 | :----------------- | :----- | :----- | ------: | -------: |
-| jimp               | buffer | buffer |    0.77 |      1.0 |
-| mapnik             | buffer | buffer |    3.39 |      4.4 |
-| gm                 | buffer | buffer |    4.30 |      5.6 |
-| gm                 | file   | file   |    4.33 |      5.6 |
-| imagemagick        | file   | file   |    4.39 |      5.7 |
-| sharp              | stream | stream |   23.81 |     30.9 |
-| sharp              | file   | file   |   25.09 |     32.6 |
-| sharp              | buffer | buffer |   25.60 |     33.2 |
+| jimp               | buffer | buffer |    0.78 |      1.0 |
+| mapnik             | buffer | buffer |    3.39 |      4.3 |
+| gm                 | buffer | buffer |    7.84 |     10.1 |
+| gm                 | file   | file   |    9.24 |     11.8 |
+| imagemagick        | file   | file   |    9.37 |     12.0 |
+| sharp              | stream | stream |   26.84 |     34.4 |
+| sharp              | file   | file   |   29.76 |     38.2 |
+| sharp              | buffer | buffer |   31.60 |     40.5 |
 
 Greater libvips performance can be expected with caching enabled (default)
-and using 4+ core machines, especially those with larger L1/L2 CPU caches.
+and using 8+ core machines, especially those with larger L1/L2 CPU caches.
 
 The I/O limits of the relevant (de)compression library will generally determine maximum throughput.
 
@@ -51,7 +51,7 @@ brew install mapnik
 ```
 
 ```sh
-sudo apt-get install imagemagick libmagick++-dev graphicsmagick libmapnik-dev
+sudo apt-get install build-essential imagemagick libmagick++-dev graphicsmagick libmapnik-dev
 ```
 
 ```sh
@@ -61,7 +61,7 @@ sudo yum install ImageMagick-devel ImageMagick-c++-devel GraphicsMagick mapnik-d
 ```sh
 git clone https://github.com/lovell/sharp.git
 cd sharp
-npm install
+npm install --build-from-source
 cd test/bench
 npm install
 npm test

docs/search-index/build.js

@@ -9,7 +9,7 @@ const searchIndex = [];
 // Install
 const contents = fs.readFileSync(path.join(__dirname, '..', 'install.md'), 'utf8');
 const matches = contents.matchAll(
-  /## (?<title>[A-Za-z ]+)\n\n(?<body>[^#]+)/gs
+  /## (?<title>[A-Za-z0-9 ]+)\n\n(?<body>[^#]+)/gs
 );
 for (const match of matches) {
   const { title, body } = match.groups;

docs/search-index/extract.js

@@ -8,7 +8,7 @@ const extractDescription = (str) =>
     .replace(/\s+/g, ' ')
     .replace(/[^A-Za-z0-9_/\-,. ]/g, '')
     .replace(/\s+/g, ' ')
-    .substr(0, 140)
+    .substr(0, 180)
     .trim();
 
 const extractKeywords = (str) =>
@@ -17,7 +17,7 @@ const extractKeywords = (str) =>
       str
         .split(/[ -/]/)
         .map((word) => word.toLowerCase().replace(/[^a-z]/g, ''))
-        .filter((word) => word.length > 2 && !stopWords.includes(word))
+        .filter((word) => word.length > 2 && word.length < 15 && !stopWords.includes(word))
     )
   ].join(' ');
 

docs/search-index/stop-words.js

@@ -4,21 +4,28 @@ module.exports = [
   'about',
   'after',
   'all',
+  'allows',
   'already',
+  'also',
   'alternative',
   'always',
   'and',
   'any',
   'are',
+  'based',
   'been',
   'before',
+  'both',
+  'call',
   'can',
   'containing',
   'default',
   'does',
   'each',
   'either',
+  'ensure',
   'etc',
+  'every',
   'for',
   'from',
   'get',
@@ -28,7 +35,10 @@ module.exports = [
   'have',
   'how',
   'image',
+  'involve',
   'its',
+  'least',
+  'lots',
   'may',
   'more',
   'most',
@@ -38,17 +48,24 @@ module.exports = [
   'not',
   'occur',
   'occurs',
+  'options',
   'over',
   'perform',
   'performs',
   'provide',
   'provided',
+  'ready',
+  'same',
+  'see',
   'set',
   'sets',
   'should',
+  'since',
   'spelling',
+  'such',
   'support',
   'supported',
+  'sure',
   'take',
   'that',
   'the',
@@ -57,6 +74,9 @@ module.exports = [
   'therefore',
   'these',
   'this',
+  'under',
+  'unless',
+  'until',
   'use',
   'used',
   'using',
@@ -67,5 +87,6 @@ module.exports = [
   'while',
   'will',
   'with',
-  'without'
+  'without',
+  'you'
 ];

install/dll-copy.js

@@ -4,7 +4,6 @@ const fs = require('fs');
 const path = require('path');
 
 const libvips = require('../lib/libvips');
-const npmLog = require('npmlog');
 
 const minimumLibvipsVersion = libvips.minimumLibvipsVersion;
 
@@ -12,13 +11,13 @@ const platform = process.env.npm_config_platform || process.platform;
 if (platform === 'win32') {
   const buildDir = path.join(__dirname, '..', 'build');
   const buildReleaseDir = path.join(buildDir, 'Release');
-  npmLog.info('sharp', `Creating ${buildReleaseDir}`);
+  libvips.log(`Creating ${buildReleaseDir}`);
   try {
     libvips.mkdirSync(buildDir);
     libvips.mkdirSync(buildReleaseDir);
   } catch (err) {}
   const vendorLibDir = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion, 'lib');
-  npmLog.info('sharp', `Copying DLLs from ${vendorLibDir} to ${buildReleaseDir}`);
+  libvips.log(`Copying DLLs from ${vendorLibDir} to ${buildReleaseDir}`);
   try {
     fs
       .readdirSync(vendorLibDir)
@@ -32,6 +31,7 @@ if (platform === 'win32') {
         );
       });
   } catch (err) {
-    npmLog.error('sharp', err.message);
+    libvips.log(err);
+    process.exit(1);
   }
 }

install/libvips.js

@@ -7,7 +7,6 @@ const stream = require('stream');
 const zlib = require('zlib');
 
 const detectLibc = require('detect-libc');
-const npmLog = require('npmlog');
 const semver = require('semver');
 const simpleGet = require('simple-get');
 const tarFs = require('tar-fs');
@@ -22,34 +21,50 @@ const minimumGlibcVersionByArch = {
   x64: '2.17'
 };
 
+const hasSharpPrebuild = [
+  'darwin-x64',
+  'linux-arm64',
+  'linux-x64',
+  'linuxmusl-x64',
+  'linuxmusl-arm64',
+  'win32-ia32',
+  'win32-x64'
+];
+
 const { minimumLibvipsVersion, minimumLibvipsVersionLabelled } = libvips;
 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 supportsBrotli = ('BrotliDecompress' in zlib);
 
 const fail = function (err) {
-  npmLog.error('sharp', err.message);
+  libvips.log(err);
   if (err.code === 'EACCES') {
-    npmLog.info('sharp', '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? Try again with the --unsafe-perm flag');
   }
-  npmLog.info('sharp', 'Attempting to build from source via node-gyp but this may fail due to the above error');
-  npmLog.info('sharp', 'Please see https://sharp.pixelplumbing.com/install for required dependencies');
+  libvips.log('Attempting to build from source via node-gyp but this may fail due to the above error');
+  libvips.log('Please see https://sharp.pixelplumbing.com/install for required dependencies');
   process.exit(1);
 };
 
-const extractTarball = function (tarPath) {
+const extractTarball = function (tarPath, platformAndArch) {
   const vendorPath = path.join(__dirname, '..', 'vendor');
   libvips.mkdirSync(vendorPath);
   const versionedVendorPath = path.join(vendorPath, minimumLibvipsVersion);
   libvips.mkdirSync(versionedVendorPath);
+
+  const ignoreVendorInclude = hasSharpPrebuild.includes(platformAndArch) && !process.env.npm_config_build_from_source;
+  const ignore = function (name) {
+    return ignoreVendorInclude && name.includes('include/');
+  };
+
   stream.pipeline(
     fs.createReadStream(tarPath),
     supportsBrotli ? new zlib.BrotliDecompress() : new zlib.Gunzip(),
-    tarFs.extract(versionedVendorPath),
+    tarFs.extract(versionedVendorPath, { ignore }),
     function (err) {
       if (err) {
         if (/unexpected end of file/.test(err.message)) {
-          npmLog.error('sharp', `Please delete ${tarPath} as it is not a valid tarball`);
+          fail(new Error(`Please delete ${tarPath} as it is not a valid tarball`));
         }
         fail(err);
       }
@@ -62,11 +77,11 @@ try {
 
   if (useGlobalLibvips) {
     const globalLibvipsVersion = libvips.globalLibvipsVersion();
-    npmLog.info('sharp', `Detected globally-installed libvips v${globalLibvipsVersion}`);
-    npmLog.info('sharp', 'Building from source via node-gyp');
+    libvips.log(`Detected globally-installed libvips v${globalLibvipsVersion}`);
+    libvips.log('Building from source via node-gyp');
     process.exit(1);
   } else if (libvips.hasVendoredLibvips()) {
-    npmLog.info('sharp', `Using existing vendored libvips v${minimumLibvipsVersion}`);
+    libvips.log(`Using existing vendored libvips v${minimumLibvipsVersion}`);
   } else {
     // Is this arch/platform supported?
     const arch = process.env.npm_config_arch || process.arch;
@@ -74,6 +89,9 @@ try {
     if (arch === 'ia32' && !platformAndArch.startsWith('win32')) {
       throw new Error(`Intel Architecture 32-bit systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
     }
+    if (platformAndArch === 'darwin-arm64') {
+      throw new Error("Please run 'brew install vips' to install libvips on Apple M1 (ARM64) systems");
+    }
     if (platformAndArch === 'freebsd-x64' || platformAndArch === 'openbsd-x64' || platformAndArch === 'sunos-x64') {
       throw new Error(`BSD/SunOS systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
     }
@@ -82,6 +100,11 @@ try {
         throw new Error(`Use with glibc ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
       }
     }
+    if (detectLibc.family === detectLibc.MUSL && detectLibc.version) {
+      if (semver.lt(detectLibc.version, '1.1.24')) {
+        throw new Error(`Use with musl ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
+      }
+    }
 
     const supportedNodeVersion = process.env.npm_package_engines_node || require('../package.json').engines.node;
     if (!semver.satisfies(process.versions.node, supportedNodeVersion)) {
@@ -94,13 +117,11 @@ try {
     const tarFilename = ['libvips', minimumLibvipsVersion, platformAndArch].join('-') + '.tar.' + extension;
     const tarPathCache = path.join(libvips.cachePath(), tarFilename);
     if (fs.existsSync(tarPathCache)) {
-      npmLog.info('sharp', `Using cached ${tarPathCache}`);
-      extractTarball(tarPathCache);
+      libvips.log(`Using cached ${tarPathCache}`);
+      extractTarball(tarPathCache, platformAndArch);
     } else {
-      const tarPathTemp = path.join(os.tmpdir(), `${process.pid}-${tarFilename}`);
-      const tmpFile = fs.createWriteStream(tarPathTemp);
       const url = distBaseUrl + tarFilename;
-      npmLog.info('sharp', `Downloading ${url}`);
+      libvips.log(`Downloading ${url}`);
       simpleGet({ url: url, agent: agent() }, function (err, response) {
         if (err) {
           fail(err);
@@ -109,24 +130,37 @@ try {
         } else if (response.statusCode !== 200) {
           fail(new Error(`Status ${response.statusCode} ${response.statusMessage}`));
         } else {
+          const tarPathTemp = path.join(os.tmpdir(), `${process.pid}-${tarFilename}`);
+          const tmpFileStream = fs.createWriteStream(tarPathTemp);
           response
-            .on('error', fail)
-            .pipe(tmpFile);
+            .on('error', function (err) {
+              tmpFileStream.destroy(err);
+            })
+            .on('close', function () {
+              if (!response.complete) {
+                tmpFileStream.destroy(new Error('Download incomplete (connection was terminated)'));
+              }
+            })
+            .pipe(tmpFileStream);
+          tmpFileStream
+            .on('error', function (err) {
+              // Clean up temporary file
+              fs.unlinkSync(tarPathTemp);
+              fail(err);
+            })
+            .on('close', function () {
+              try {
+                // Attempt to rename
+                fs.renameSync(tarPathTemp, tarPathCache);
+              } catch (err) {
+                // Fall back to copy and unlink
+                fs.copyFileSync(tarPathTemp, tarPathCache);
+                fs.unlinkSync(tarPathTemp);
+              }
+              extractTarball(tarPathCache);
+            });
         }
       });
-      tmpFile
-        .on('error', fail)
-        .on('close', function () {
-          try {
-            // Attempt to rename
-            fs.renameSync(tarPathTemp, tarPathCache);
-          } catch (err) {
-            // Fall back to copy and unlink
-            fs.copyFileSync(tarPathTemp, tarPathCache);
-            fs.unlinkSync(tarPathTemp);
-          }
-          extractTarball(tarPathCache);
-        });
     }
   }
 } catch (err) {

lib/colour.js

@@ -57,6 +57,13 @@ function grayscale (grayscale) {
 /**
  * Set the output colourspace.
  * By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
+ *
+ * @example
+ * // Output 16 bits per pixel RGB
+ * await sharp(input)
+ *  .toColourspace('rgb16')
+ *  .toFile('16-bpp.png')
+ *
  * @param {string} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
  * @returns {Sharp}
  * @throws {Error} Invalid parameters

lib/constructor.js

@@ -18,12 +18,10 @@ try {
     help.push(`- Ensure "${process.platform}" is used at install time as well as runtime`);
   } else if (/dylib/.test(err.message) && /Incompatible library version/.test(err.message)) {
     help.push('- Run "brew update && brew upgrade vips"');
-  } else if (/Cannot find module/.test(err.message)) {
-    help.push('- Run "npm rebuild --verbose sharp" and look for errors');
   } else {
     help.push(
       '- Remove the "node_modules/sharp" directory then run',
-      '  "npm install --ignore-scripts=false --verbose" and look for errors'
+      '  "npm install --ignore-scripts=false --verbose sharp" and look for errors'
     );
   }
   help.push(
@@ -90,8 +88,37 @@ const debuglog = util.debuglog('sharp');
  * // Convert an animated GIF to an animated WebP
  * await sharp('in.gif', { animated: true }).toFile('out.webp');
  *
- * @param {(Buffer|string)} [input] - if present, can be
- *  a Buffer containing JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data, or
+ * @example
+ * // Read a raw array of pixels and save it to a png
+ * const input = Uint8Array.from([255, 255, 255, 0, 0, 0]); // or Uint8ClampedArray
+ * const image = sharp(input, {
+ *   // because the input does not contain its dimensions or how many channels it has
+ *   // we need to specify it in the constructor options
+ *   raw: {
+ *     width: 2,
+ *     height: 1,
+ *     channels: 3
+ *   }
+ * });
+ * await image.toFile('my-two-pixels.png');
+ *
+ * @example
+ * // Generate RGB Gaussian noise
+ * await sharp({
+ *   create: {
+ *     width: 300,
+ *     height: 200,
+ *     channels: 3,
+ *     noise: {
+ *       type: 'gaussian',
+ *       mean: 128,
+ *       sigma: 30
+ *     }
+ *  }
+ * }).toFile('noise.png');
+ *
+ * @param {(Buffer|Uint8Array|Uint8ClampedArray|string)} [input] - if present, can be
+ *  a Buffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data, or
  *  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.
@@ -108,14 +135,18 @@ const debuglog = util.debuglog('sharp');
  * @param {number} [options.level=0] - level to extract from a multi-level input (OpenSlide), zero based.
  * @param {boolean} [options.animated=false] - Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`).
  * @param {Object} [options.raw] - describes raw pixel input image data. See `raw()` for pixel ordering.
- * @param {number} [options.raw.width]
- * @param {number} [options.raw.height]
- * @param {number} [options.raw.channels] - 1-4
+ * @param {number} [options.raw.width] - integral number of pixels wide.
+ * @param {number} [options.raw.height] - integral number of pixels high.
+ * @param {number} [options.raw.channels] - integral number of channels, between 1 and 4.
  * @param {Object} [options.create] - describes a new image to be created.
- * @param {number} [options.create.width]
- * @param {number} [options.create.height]
- * @param {number} [options.create.channels] - 3-4
+ * @param {number} [options.create.width] - integral number of pixels wide.
+ * @param {number} [options.create.height] - integral number of pixels high.
+ * @param {number} [options.create.channels] - integral number of channels, either 3 (RGB) or 4 (RGBA).
  * @param {string|Object} [options.create.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {Object} [options.create.noise] - describes a noise to be created.
+ * @param {string} [options.create.noise.type] - type of generated noise, currently only `gaussian` is supported.
+ * @param {number} [options.create.noise.mean] - mean of pixels in generated noise.
+ * @param {number} [options.create.noise.sigma] - standard deviation of pixels in generated noise.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -211,7 +242,7 @@ const Sharp = function (input, options) {
     jpegOptimiseCoding: true,
     jpegQuantisationTable: 0,
     pngProgressive: false,
-    pngCompressionLevel: 9,
+    pngCompressionLevel: 6,
     pngAdaptiveFiltering: false,
     pngPalette: false,
     pngQuality: 100,
@@ -237,6 +268,7 @@ const Sharp = function (input, options) {
     heifLossless: false,
     heifCompression: 'av1',
     heifSpeed: 5,
+    heifChromaSubsampling: '4:2:0',
     tileSize: 256,
     tileOverlap: 0,
     tileContainer: 'fs',
@@ -247,6 +279,7 @@ const Sharp = function (input, options) {
     tileSkipBlanks: -1,
     tileBackground: [255, 255, 255, 255],
     tileCentre: false,
+    tileId: 'https://example.com/iiif',
     linearA: 1,
     linearB: 0,
     // Function to notify of libvips warnings

lib/input.js

@@ -31,6 +31,9 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
   } else if (is.buffer(input)) {
     // Buffer
     inputDescriptor.buffer = input;
+  } else if (is.uint8Array(input)) {
+    // Uint8Array or Uint8ClampedArray
+    inputDescriptor.buffer = Buffer.from(input.buffer);
   } else if (is.plainObject(input) && !is.defined(inputOptions)) {
     // Plain Object descriptor, e.g. create
     inputOptions = input;
@@ -134,22 +137,50 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         is.object(inputOptions.create) &&
         is.integer(inputOptions.create.width) && inputOptions.create.width > 0 &&
         is.integer(inputOptions.create.height) && inputOptions.create.height > 0 &&
-        is.integer(inputOptions.create.channels) && is.inRange(inputOptions.create.channels, 3, 4) &&
-        is.defined(inputOptions.create.background)
+        is.integer(inputOptions.create.channels)
       ) {
         inputDescriptor.createWidth = inputOptions.create.width;
         inputDescriptor.createHeight = inputOptions.create.height;
         inputDescriptor.createChannels = inputOptions.create.channels;
-        const background = color(inputOptions.create.background);
-        inputDescriptor.createBackground = [
-          background.red(),
-          background.green(),
-          background.blue(),
-          Math.round(background.alpha() * 255)
-        ];
+        // Noise
+        if (is.defined(inputOptions.create.noise)) {
+          if (!is.object(inputOptions.create.noise)) {
+            throw new Error('Expected noise to be an object');
+          }
+          if (!is.inArray(inputOptions.create.noise.type, ['gaussian'])) {
+            throw new Error('Only gaussian noise is supported at the moment');
+          }
+          if (!is.inRange(inputOptions.create.channels, 1, 4)) {
+            throw is.invalidParameterError('create.channels', 'number between 1 and 4', inputOptions.create.channels);
+          }
+          inputDescriptor.createNoiseType = inputOptions.create.noise.type;
+          if (is.number(inputOptions.create.noise.mean) && is.inRange(inputOptions.create.noise.mean, 0, 10000)) {
+            inputDescriptor.createNoiseMean = inputOptions.create.noise.mean;
+          } else {
+            throw is.invalidParameterError('create.noise.mean', 'number between 0 and 10000', inputOptions.create.noise.mean);
+          }
+          if (is.number(inputOptions.create.noise.sigma) && is.inRange(inputOptions.create.noise.sigma, 0, 10000)) {
+            inputDescriptor.createNoiseSigma = inputOptions.create.noise.sigma;
+          } else {
+            throw is.invalidParameterError('create.noise.sigma', 'number between 0 and 10000', inputOptions.create.noise.sigma);
+          }
+        } else if (is.defined(inputOptions.create.background)) {
+          if (!is.inRange(inputOptions.create.channels, 3, 4)) {
+            throw is.invalidParameterError('create.channels', 'number between 3 and 4', inputOptions.create.channels);
+          }
+          const background = color(inputOptions.create.background);
+          inputDescriptor.createBackground = [
+            background.red(),
+            background.green(),
+            background.blue(),
+            Math.round(background.alpha() * 255)
+          ];
+        } else {
+          throw new Error('Expected valid noise or background to create a new input image');
+        }
         delete inputDescriptor.buffer;
       } else {
-        throw new Error('Expected width, height, channels and background to create a new input image');
+        throw new Error('Expected valid width, height and channels to create a new input image');
       }
     }
   } else if (is.defined(inputOptions)) {

lib/is.js

@@ -48,6 +48,15 @@ const buffer = function (val) {
   return val instanceof Buffer;
 };
 
+/**
+ * Is this value a Uint8Array or Uint8ClampedArray object?
+ * @private
+ */
+const uint8Array = function (val) {
+  // allow both since Uint8ClampedArray simply clamps the values between 0-255
+  return val instanceof Uint8Array || val instanceof Uint8ClampedArray;
+};
+
 /**
  * Is this value a non-empty string?
  * @private
@@ -110,6 +119,7 @@ module.exports = {
   fn: fn,
   bool: bool,
   buffer: buffer,
+  uint8Array: uint8Array,
   string: string,
   number: number,
   integer: integer,

lib/libvips.js

@@ -37,10 +37,28 @@ const cachePath = function () {
   return libvipsCachePath;
 };
 
+const log = function (item) {
+  if (item instanceof Error) {
+    console.error(`sharp: ${item.message}`);
+  } else {
+    console.log(`sharp: ${item}`);
+  }
+};
+
+const isRosetta = function () {
+  /* istanbul ignore next */
+  if (process.platform === 'darwin' && process.arch === 'x64') {
+    const translated = spawnSync('sysctl sysctl.proc_translated', spawnSyncOptions).stdout;
+    return (translated || '').trim() === 'sysctl.proc_translated: 1';
+  }
+  return false;
+};
+
 const globalLibvipsVersion = function () {
   if (process.platform !== 'win32') {
-    const globalLibvipsVersion = spawnSync(`PKG_CONFIG_PATH="${pkgConfigPath()}" pkg-config --modversion vips-cpp`, spawnSyncOptions).stdout || '';
-    return globalLibvipsVersion.trim();
+    const globalLibvipsVersion = spawnSync(`PKG_CONFIG_PATH="${pkgConfigPath()}" pkg-config --modversion vips-cpp`, spawnSyncOptions).stdout;
+    /* istanbul ignore next */
+    return (globalLibvipsVersion || '').trim();
   } else {
     return '';
   }
@@ -81,7 +99,10 @@ const useGlobalLibvips = function () {
   if (Boolean(env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
     return false;
   }
-
+  /* istanbul ignore next */
+  if (isRosetta()) {
+    return false;
+  }
   const globalVipsVersion = globalLibvipsVersion();
   return !!globalVipsVersion && /* istanbul ignore next */
     semver.gte(globalVipsVersion, minimumLibvipsVersion);
@@ -91,6 +112,7 @@ module.exports = {
   minimumLibvipsVersion,
   minimumLibvipsVersionLabelled,
   cachePath,
+  log,
   globalLibvipsVersion,
   hasVendoredLibvips,
   pkgConfigPath,

lib/operation.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const { flatten: flattenArray } = require('array-flatten');
 const color = require('color');
 const is = require('./is');
 
@@ -127,7 +126,7 @@ function flop (flop) {
  * @throws {Error} Invalid parameters
  */
 function affine (matrix, options) {
-  const flatMatrix = flattenArray(matrix);
+  const flatMatrix = [].concat(...matrix);
   if (flatMatrix.length === 4 && flatMatrix.every(is.number)) {
     this.options.affineMatrix = flatMatrix;
   } else {
@@ -269,7 +268,13 @@ function blur (sigma) {
 }
 
 /**
- * Merge alpha transparency channel, if any, with a background.
+ * Merge alpha transparency channel, if any, with a background, then remove the alpha channel.
+ *
+ * @example
+ * await sharp(rgbaInput)
+ *   .flatten('#F0A703')
+ *   .toBuffer();
+ *
  * @param {Object} [options]
  * @param {string|Object} [options.background={r: 0, g: 0, b: 0}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black.
  * @returns {Sharp}
@@ -397,7 +402,7 @@ function convolve (kernel) {
 }
 
 /**
- * Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+ * Any pixel value greater than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
  * @param {number} [threshold=128] - a value in the range 0-255 representing the level at which the threshold will be applied.
  * @param {Object} [options]
  * @param {Boolean} [options.greyscale=true] - convert to single channel greyscale.

lib/output.js

@@ -16,6 +16,8 @@ const formats = new Map([
   ['gif', 'gif']
 ]);
 
+const errMagickSave = new Error('GIF output requires libvips with support for ImageMagick');
+
 /**
  * Write output image data to a file.
  *
@@ -47,25 +49,23 @@ const formats = new Map([
  * @throws {Error} Invalid parameters
  */
 function toFile (fileOut, callback) {
-  if (!fileOut || fileOut.length === 0) {
-    const errOutputInvalid = new Error('Missing output file path');
+  let err;
+  if (!is.string(fileOut)) {
+    err = new Error('Missing output file path');
+  } else if (this.options.input.file === fileOut) {
+    err = new Error('Cannot use same file for input and output');
+  } else if (this.options.formatOut === 'input' && fileOut.toLowerCase().endsWith('.gif') && !this.constructor.format.magick.output.file) {
+    err = errMagickSave;
+  }
+  if (err) {
     if (is.fn(callback)) {
-      callback(errOutputInvalid);
+      callback(err);
     } else {
-      return Promise.reject(errOutputInvalid);
+      return Promise.reject(err);
     }
   } else {
-    if (this.options.input.file === fileOut) {
-      const errOutputIsInput = new Error('Cannot use same file for input and output');
-      if (is.fn(callback)) {
-        callback(errOutputIsInput);
-      } else {
-        return Promise.reject(errOutputIsInput);
-      }
-    } else {
-      this.options.fileOut = fileOut;
-      return this._pipeline(callback);
-    }
+    this.options.fileOut = fileOut;
+    return this._pipeline(callback);
   }
   return this;
 }
@@ -104,6 +104,22 @@ function toFile (fileOut, callback) {
  *   .then(({ data, info }) => { ... })
  *   .catch(err => { ... });
  *
+ * @example
+ * const { data, info } = await sharp('my-image.jpg')
+ *   // output the raw pixels
+ *   .raw()
+ *   .toBuffer({ resolveWithObject: true });
+ *
+ * // create a more type safe way to work with the raw pixel data
+ * // this will not copy the data, instead it will change `data`s underlying ArrayBuffer
+ * // so `data` and `pixelArray` point to the same memory location
+ * const pixelArray = new Uint8ClampedArray(data.buffer);
+ *
+ * // When you are done changing the pixelArray, sharp takes the `pixelArray` as an input
+ * const { width, height, channels } = info;
+ * await sharp(pixelArray, { raw: { width, height, channels } })
+ *   .toFile('my-changed-image.jpg');
+ *
  * @param {Object} [options]
  * @param {boolean} [options.resolveWithObject] Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
  * @param {Function} [callback]
@@ -174,7 +190,7 @@ function withMetadata (options) {
  * @throws {Error} unsupported format or options
  */
 function toFormat (format, options) {
-  const actualFormat = formats.get(is.object(format) && is.string(format.id) ? format.id : format);
+  const actualFormat = formats.get((is.object(format) && is.string(format.id) ? format.id : format).toLowerCase());
   if (!actualFormat) {
     throw is.invalidParameterError('format', `one of: ${[...formats.keys()].join(', ')}`, format);
   }
@@ -184,8 +200,6 @@ function toFormat (format, options) {
 /**
  * Use these JPEG options for output image.
  *
- * Some of these options require the use of a globally-installed libvips compiled with support for mozjpeg.
- *
  * @example
  * // Convert any input to very high quality JPEG output
  * const data = await sharp(input)
@@ -195,18 +209,25 @@ function toFormat (format, options) {
  *   })
  *   .toBuffer();
  *
+ * @example
+ * // Use mozjpeg to reduce output JPEG file size (slower)
+ * const data = await sharp(input)
+ *   .jpeg({ mozjpeg: true })
+ *   .toBuffer();
+ *
  * @param {Object} [options] - output options
  * @param {number} [options.quality=80] - quality, integer 1-100
  * @param {boolean} [options.progressive=false] - use progressive (interlace) scan
  * @param {string} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling
  * @param {boolean} [options.optimiseCoding=true] - optimise Huffman coding tables
  * @param {boolean} [options.optimizeCoding=true] - alternative spelling of optimiseCoding
- * @param {boolean} [options.trellisQuantisation=false] - apply trellis quantisation, requires libvips compiled with support for mozjpeg
- * @param {boolean} [options.overshootDeringing=false] - apply overshoot deringing, requires libvips compiled with support for mozjpeg
- * @param {boolean} [options.optimiseScans=false] - optimise progressive scans, forces progressive, requires libvips compiled with support for mozjpeg
- * @param {boolean} [options.optimizeScans=false] - alternative spelling of optimiseScans, requires libvips compiled with support for mozjpeg
- * @param {number} [options.quantisationTable=0] - quantization table to use, integer 0-8, requires libvips compiled with support for mozjpeg
- * @param {number} [options.quantizationTable=0] - alternative spelling of quantisationTable, requires libvips compiled with support for mozjpeg
+ * @param {boolean} [options.mozjpeg=false] - use mozjpeg defaults, equivalent to `{ trellisQuantisation: true, overshootDeringing: true, optimiseScans: true, quantisationTable: 3 }`
+ * @param {boolean} [options.trellisQuantisation=false] - apply trellis quantisation
+ * @param {boolean} [options.overshootDeringing=false] - apply overshoot deringing
+ * @param {boolean} [options.optimiseScans=false] - optimise progressive scans, forces progressive
+ * @param {boolean} [options.optimizeScans=false] - alternative spelling of optimiseScans
+ * @param {number} [options.quantisationTable=0] - quantization table to use, integer 0-8
+ * @param {number} [options.quantizationTable=0] - alternative spelling of quantisationTable
  * @param {boolean} [options.force=true] - force JPEG output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -230,6 +251,23 @@ function jpeg (options) {
         throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
       }
     }
+    const optimiseCoding = is.bool(options.optimizeCoding) ? options.optimizeCoding : options.optimiseCoding;
+    if (is.defined(optimiseCoding)) {
+      this._setBooleanOption('jpegOptimiseCoding', optimiseCoding);
+    }
+    if (is.defined(options.mozjpeg)) {
+      if (is.bool(options.mozjpeg)) {
+        if (options.mozjpeg) {
+          this.options.jpegTrellisQuantisation = true;
+          this.options.jpegOvershootDeringing = true;
+          this.options.jpegOptimiseScans = true;
+          this.options.jpegProgressive = true;
+          this.options.jpegQuantisationTable = 3;
+        }
+      } else {
+        throw is.invalidParameterError('mozjpeg', 'boolean', options.mozjpeg);
+      }
+    }
     const trellisQuantisation = is.bool(options.trellisQuantization) ? options.trellisQuantization : options.trellisQuantisation;
     if (is.defined(trellisQuantisation)) {
       this._setBooleanOption('jpegTrellisQuantisation', trellisQuantisation);
@@ -244,10 +282,6 @@ function jpeg (options) {
         this.options.jpegProgressive = true;
       }
     }
-    const optimiseCoding = is.bool(options.optimizeCoding) ? options.optimizeCoding : options.optimiseCoding;
-    if (is.defined(optimiseCoding)) {
-      this._setBooleanOption('jpegOptimiseCoding', optimiseCoding);
-    }
     const quantisationTable = is.number(options.quantizationTable) ? options.quantizationTable : options.quantisationTable;
     if (is.defined(quantisationTable)) {
       if (is.integer(quantisationTable) && is.inRange(quantisationTable, 0, 8)) {
@@ -263,26 +297,31 @@ function jpeg (options) {
 /**
  * Use these PNG options for output image.
  *
- * PNG output is always full colour at 8 or 16 bits per pixel.
+ * By default, PNG output is full colour at 8 or 16 bits per pixel.
  * Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
- *
- * Some of these options require the use of a globally-installed libvips compiled with support for libimagequant (GPL).
+ * Set `palette` to `true` for slower, indexed PNG output.
  *
  * @example
- * // Convert any input to PNG output
+ * // Convert any input to full colour PNG output
  * const data = await sharp(input)
  *   .png()
  *   .toBuffer();
  *
+ * @example
+ * // Convert any input to indexed PNG output (slower)
+ * const data = await sharp(input)
+ *   .png({ palette: true })
+ *   .toBuffer();
+ *
  * @param {Object} [options]
  * @param {boolean} [options.progressive=false] - use progressive (interlace) scan
- * @param {number} [options.compressionLevel=9] - zlib compression level, 0-9
+ * @param {number} [options.compressionLevel=6] - zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest)
  * @param {boolean} [options.adaptiveFiltering=false] - use adaptive row filtering
- * @param {boolean} [options.palette=false] - quantise to a palette-based image with alpha transparency support, requires libvips compiled with support for libimagequant
- * @param {number} [options.quality=100] - use the lowest number of colours needed to achieve given quality, sets `palette` to `true`, requires libvips compiled with support for libimagequant
- * @param {number} [options.colours=256] - maximum number of palette entries, sets `palette` to `true`, requires libvips compiled with support for libimagequant
- * @param {number} [options.colors=256] - alternative spelling of `options.colours`, sets `palette` to `true`, requires libvips compiled with support for libimagequant
- * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, sets `palette` to `true`, requires libvips compiled with support for libimagequant
+ * @param {boolean} [options.palette=false] - quantise to a palette-based image with alpha transparency support
+ * @param {number} [options.quality=100] - use the lowest number of colours needed to achieve given quality, sets `palette` to `true`
+ * @param {number} [options.colours=256] - maximum number of palette entries, sets `palette` to `true`
+ * @param {number} [options.colors=256] - alternative spelling of `options.colours`, sets `palette` to `true`
+ * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, sets `palette` to `true`
  * @param {boolean} [options.force=true] - force PNG output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -412,7 +451,7 @@ function webp (options) {
 /* istanbul ignore next */
 function gif (options) {
   if (!this.constructor.format.magick.output.buffer) {
-    throw new Error('The gif operation requires libvips to have been installed with support for ImageMagick');
+    throw errMagickSave;
   }
   trySetAnimationOptions(options, this.options);
   return this._updateFormatOut('gif', options);
@@ -472,15 +511,15 @@ function trySetAnimationOptions (source, target) {
  * @param {Object} [options] - output options
  * @param {number} [options.quality=80] - quality, integer 1-100
  * @param {boolean} [options.force=true] - force TIFF output, otherwise attempt to use input format
- * @param {boolean} [options.compression='jpeg'] - compression options: lzw, deflate, jpeg, ccittfax4
- * @param {boolean} [options.predictor='horizontal'] - compression predictor options: none, horizontal, float
+ * @param {string} [options.compression='jpeg'] - compression options: lzw, deflate, jpeg, ccittfax4
+ * @param {string} [options.predictor='horizontal'] - compression predictor options: none, horizontal, float
  * @param {boolean} [options.pyramid=false] - write an image pyramid
  * @param {boolean} [options.tile=false] - write a tiled tiff
- * @param {boolean} [options.tileWidth=256] - horizontal tile size
- * @param {boolean} [options.tileHeight=256] - vertical tile size
+ * @param {number} [options.tileWidth=256] - horizontal tile size
+ * @param {number} [options.tileHeight=256] - vertical tile size
  * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm
  * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm
- * @param {boolean} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit
+ * @param {number} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -568,7 +607,8 @@ function tiff (options) {
  * @param {Object} [options] - output options
  * @param {number} [options.quality=50] - quality, integer 1-100
  * @param {boolean} [options.lossless=false] - use lossless compression
- * @param {boolean} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
+ * @param {number} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
+ * @param {string} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -586,9 +626,10 @@ function avif (options) {
  *
  * @param {Object} [options] - output options
  * @param {number} [options.quality=50] - quality, integer 1-100
- * @param {boolean} [options.compression='av1'] - compression format: av1, hevc
+ * @param {string} [options.compression='av1'] - compression format: av1, hevc
  * @param {boolean} [options.lossless=false] - use lossless compression
- * @param {boolean} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
+ * @param {number} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
+ * @param {string} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -622,6 +663,13 @@ function heif (options) {
         throw is.invalidParameterError('speed', 'integer between 0 and 8', options.speed);
       }
     }
+    if (is.defined(options.chromaSubsampling)) {
+      if (is.string(options.chromaSubsampling) && is.inArray(options.chromaSubsampling, ['4:2:0', '4:4:4'])) {
+        this.options.heifChromaSubsampling = options.chromaSubsampling;
+      } else {
+        throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
+      }
+    }
   }
   return this._updateFormatOut('heif', options);
 }
@@ -681,6 +729,7 @@ function raw () {
  * @param {string} [options.layout='dz'] filesystem layout, possible values are `dz`, `iiif`, `zoomify` or `google`.
  * @param {boolean} [options.centre=false] centre image in tile.
  * @param {boolean} [options.center=false] alternative spelling of centre.
+ * @param {string} [options.id='https://example.com/iiif'] when `layout` is `iiif`, sets the `@id` attribute of `info.json`
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -754,6 +803,14 @@ function tile (options) {
     if (is.defined(centre)) {
       this._setBooleanOption('tileCentre', centre);
     }
+    // @id attribute for IIIF layout
+    if (is.defined(options.id)) {
+      if (is.string(options.id)) {
+        this.options.tileId = options.id;
+      } else {
+        throw is.invalidParameterError('id', 'string', options.id);
+      }
+    }
   }
   // Format
   if (is.inArray(this.options.formatOut, ['jpeg', 'png', 'webp'])) {

lib/resize.js

@@ -302,11 +302,20 @@ function resize (width, height, options) {
  *   })
  *   ...
  *
+* @example
+ * // Add a row of 10 red pixels to the bottom
+ * sharp(input)
+ *   .extend({
+ *     bottom: 10,
+ *     background: 'red'
+ *   })
+ *   ...
+ *
  * @param {(number|Object)} extend - single pixel count to add to all edges or an Object with per-edge counts
- * @param {number} [extend.top]
- * @param {number} [extend.left]
- * @param {number} [extend.bottom]
- * @param {number} [extend.right]
+ * @param {number} [extend.top=0]
+ * @param {number} [extend.left=0]
+ * @param {number} [extend.bottom=0]
+ * @param {number} [extend.right=0]
  * @param {String|Object} [extend.background={r: 0, g: 0, b: 0, alpha: 1}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black without transparency.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
@@ -317,17 +326,35 @@ function extend (extend) {
     this.options.extendBottom = extend;
     this.options.extendLeft = extend;
     this.options.extendRight = extend;
-  } else if (
-    is.object(extend) &&
-    is.integer(extend.top) && extend.top >= 0 &&
-    is.integer(extend.bottom) && extend.bottom >= 0 &&
-    is.integer(extend.left) && extend.left >= 0 &&
-    is.integer(extend.right) && extend.right >= 0
-  ) {
-    this.options.extendTop = extend.top;
-    this.options.extendBottom = extend.bottom;
-    this.options.extendLeft = extend.left;
-    this.options.extendRight = extend.right;
+  } else if (is.object(extend)) {
+    if (is.defined(extend.top)) {
+      if (is.integer(extend.top) && extend.top >= 0) {
+        this.options.extendTop = extend.top;
+      } else {
+        throw is.invalidParameterError('top', 'positive integer', extend.top);
+      }
+    }
+    if (is.defined(extend.bottom)) {
+      if (is.integer(extend.bottom) && extend.bottom >= 0) {
+        this.options.extendBottom = extend.bottom;
+      } else {
+        throw is.invalidParameterError('bottom', 'positive integer', extend.bottom);
+      }
+    }
+    if (is.defined(extend.left)) {
+      if (is.integer(extend.left) && extend.left >= 0) {
+        this.options.extendLeft = extend.left;
+      } else {
+        throw is.invalidParameterError('left', 'positive integer', extend.left);
+      }
+    }
+    if (is.defined(extend.right)) {
+      if (is.integer(extend.right) && extend.right >= 0) {
+        this.options.extendRight = extend.right;
+      } else {
+        throw is.invalidParameterError('right', 'positive integer', extend.right);
+      }
+    }
     this._setBackgroundColourOption('extendBackground', extend.background);
   } else {
     throw is.invalidParameterError('extend', 'integer or object', extend);

lib/utility.js

@@ -1,6 +1,8 @@
 'use strict';
 
 const events = require('events');
+const detectLibc = require('detect-libc');
+
 const is = require('./is');
 const sharp = require('../build/Release/sharp.node');
 
@@ -84,8 +86,12 @@ cache(true);
 /**
  * Gets or, when a concurrency is provided, sets
  * the number of threads _libvips'_ should create to process each image.
- * The default value is the number of CPU cores.
- * A value of `0` will reset to this default.
+ *
+ * The default value is the number of CPU cores,
+ * except when using glibc-based Linux without jemalloc,
+ * 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.
@@ -103,6 +109,11 @@ cache(true);
 function concurrency (concurrency) {
   return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
 }
+/* istanbul ignore next */
+if (detectLibc.family === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+  // Reduce default concurrency to 1 when using glibc memory allocator
+  sharp.concurrency(1);
+}
 
 /**
  * An EventEmitter that emits a `change` event when a task is either:
@@ -157,14 +168,10 @@ simd(true);
  * @private
  */
 module.exports = function (Sharp) {
-  [
-    cache,
-    concurrency,
-    counters,
-    simd
-  ].forEach(function (f) {
-    Sharp[f.name] = f;
-  });
+  Sharp.cache = cache;
+  Sharp.concurrency = concurrency;
+  Sharp.counters = counters;
+  Sharp.simd = simd;
   Sharp.format = format;
   Sharp.interpolators = interpolators;
   Sharp.versions = versions;

package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, AVIF and TIFF images",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -72,17 +72,19 @@
     "Robert O'Rourke <robert@o-rourke.org>",
     "Guillermo Alfonso Varela Chouciño <guillevch@gmail.com>",
     "Christian Flintrup <chr@gigahost.dk>",
-    "Manan Jadhav <manan@motionden.com>"
+    "Manan Jadhav <manan@motionden.com>",
+    "Leon Radley <leon@radley.se>",
+    "alza54 <alza54@thiocod.in>"
   ],
   "scripts": {
     "install": "(node install/libvips && node install/dll-copy && prebuild-install) || (node-gyp rebuild && node install/dll-copy)",
     "clean": "rm -rf node_modules/ build/ vendor/ .nyc_output/ coverage/ test/fixtures/output.*",
     "test": "semistandard && cpplint && npm run test-unit && npm run test-licensing",
-    "test-unit": "nyc --reporter=lcov --branches=99 mocha --slow=5000 --timeout=60000 ./test/unit/*.js",
+    "test-unit": "nyc --reporter=lcov --branches=99 mocha --slow=1000 --timeout=60000 ./test/unit/*.js",
     "test-licensing": "license-checker --production --summary --onlyAllow=\"Apache-2.0;BSD;ISC;MIT\"",
     "test-coverage": "./test/coverage/report.sh",
     "test-leak": "./test/leak/leak.sh",
-    "docs-build": "documentation lint lib && for m in constructor input resize composite operation colour channel output utility; do documentation build --shallow --format=md --markdown-toc=false lib/$m.js >docs/api-$m.md; done && node docs/search-index/build",
+    "docs-build": "documentation lint lib && node docs/build && node docs/search-index/build",
     "docs-serve": "cd docs && npx serve",
     "docs-publish": "cd docs && npx firebase-tools deploy --project pixelplumbing --only hosting:pixelplumbing-sharp"
   },
@@ -115,26 +117,24 @@
     "vips"
   ],
   "dependencies": {
-    "array-flatten": "^3.0.0",
     "color": "^3.1.3",
     "detect-libc": "^1.0.3",
     "node-addon-api": "^3.1.0",
-    "npmlog": "^4.1.2",
-    "prebuild-install": "^6.0.0",
-    "semver": "^7.3.4",
-    "simple-get": "^4.0.0",
+    "prebuild-install": "^6.0.1",
+    "semver": "^7.3.5",
+    "simple-get": "^3.1.0",
     "tar-fs": "^2.1.1",
     "tunnel-agent": "^0.6.0"
   },
   "devDependencies": {
     "async": "^3.2.0",
     "cc": "^3.0.1",
-    "decompress-zip": "^0.3.2",
-    "documentation": "^13.1.0",
+    "decompress-zip": "^0.3.3",
+    "documentation": "^13.2.0",
     "exif-reader": "^1.0.3",
     "icc": "^2.0.0",
     "license-checker": "^25.0.1",
-    "mocha": "^8.2.1",
+    "mocha": "^8.3.2",
     "mock-fs": "^4.13.0",
     "nyc": "^15.1.0",
     "prebuild": "^10.0.1",
@@ -143,7 +143,7 @@
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.10.5",
+    "libvips": "8.10.6",
     "runtime": "napi",
     "target": 3
   },

src/common.cc

@@ -109,7 +109,13 @@ namespace sharp {
       descriptor->createChannels = AttrAsUint32(input, "createChannels");
       descriptor->createWidth = AttrAsUint32(input, "createWidth");
       descriptor->createHeight = AttrAsUint32(input, "createHeight");
-      descriptor->createBackground = AttrAsVectorOfDouble(input, "createBackground");
+      if (HasAttr(input, "createNoiseType")) {
+        descriptor->createNoiseType = AttrAsStr(input, "createNoiseType");
+        descriptor->createNoiseMean = AttrAsDouble(input, "createNoiseMean");
+        descriptor->createNoiseSigma = AttrAsDouble(input, "createNoiseSigma");
+      } else {
+        descriptor->createBackground = AttrAsVectorOfDouble(input, "createBackground");
+      }
     }
     // Limit input images to a given number of pixels, where pixels = width * height
     descriptor->limitInputPixels = AttrAsUint32(input, "limitInputPixels");
@@ -189,31 +195,40 @@ namespace sharp {
     return id;
   }
 
+  /**
+   * Regenerate this table with something like:
+   *
+   * $ vips -l foreign | grep -i load | awk '{ print $2, $1; }'
+   *
+   * Plus a bit of editing.
+   */
   std::map<std::string, ImageType> loaderToType = {
-    { "jpegload", ImageType::JPEG },
-    { "jpegload_buffer", ImageType::JPEG },
-    { "pngload", ImageType::PNG },
-    { "pngload_buffer", ImageType::PNG },
-    { "webpload", ImageType::WEBP },
-    { "webpload_buffer", ImageType::WEBP },
-    { "tiffload", ImageType::TIFF },
-    { "tiffload_buffer", ImageType::TIFF },
-    { "gifload", ImageType::GIF },
-    { "gifload_buffer", ImageType::GIF },
-    { "svgload", ImageType::SVG },
-    { "svgload_buffer", ImageType::SVG },
-    { "heifload", ImageType::HEIF },
-    { "heifload_buffer", ImageType::HEIF },
-    { "pdfload", ImageType::PDF },
-    { "pdfload_buffer", ImageType::PDF },
-    { "magickload", ImageType::MAGICK },
-    { "magickload_buffer", ImageType::MAGICK },
-    { "openslideload", ImageType::OPENSLIDE },
-    { "ppmload", ImageType::PPM },
-    { "fitsload", ImageType::FITS },
-    { "openexrload", ImageType::EXR },
-    { "vipsload", ImageType::VIPS },
-    { "rawload", ImageType::RAW }
+    { "VipsForeignLoadJpegFile", ImageType::JPEG },
+    { "VipsForeignLoadJpegBuffer", ImageType::JPEG },
+    { "VipsForeignLoadPngFile", ImageType::PNG },
+    { "VipsForeignLoadPngBuffer", ImageType::PNG },
+    { "VipsForeignLoadWebpFile", ImageType::WEBP },
+    { "VipsForeignLoadWebpBuffer", ImageType::WEBP },
+    { "VipsForeignLoadTiffFile", ImageType::TIFF },
+    { "VipsForeignLoadTiffBuffer", ImageType::TIFF },
+    { "VipsForeignLoadGifFile", ImageType::GIF },
+    { "VipsForeignLoadGifBuffer", ImageType::GIF },
+    { "VipsForeignLoadNsgifFile", ImageType::GIF },
+    { "VipsForeignLoadNsgifBuffer", ImageType::GIF },
+    { "VipsForeignLoadSvgFile", ImageType::SVG },
+    { "VipsForeignLoadSvgBuffer", ImageType::SVG },
+    { "VipsForeignLoadHeifFile", ImageType::HEIF },
+    { "VipsForeignLoadHeifBuffer", ImageType::HEIF },
+    { "VipsForeignLoadPdfFile", ImageType::PDF },
+    { "VipsForeignLoadPdfBuffer", ImageType::PDF },
+    { "VipsForeignLoadMagickFile", ImageType::MAGICK },
+    { "VipsForeignLoadMagickBuffer", ImageType::MAGICK },
+    { "VipsForeignLoadOpenslide", ImageType::OPENSLIDE },
+    { "VipsForeignLoadPpmFile", ImageType::PPM },
+    { "VipsForeignLoadFits", ImageType::FITS },
+    { "VipsForeignLoadOpenexr", ImageType::EXR },
+    { "VipsForeignLoadVips", ImageType::VIPS },
+    { "VipsForeignLoadRaw", ImageType::RAW }
   };
 
   /*
@@ -223,7 +238,7 @@ namespace sharp {
     ImageType imageType = ImageType::UNKNOWN;
     char const *load = vips_foreign_find_load_buffer(buffer, length);
     if (load != nullptr) {
-      auto it = loaderToType.find(vips_nickname_find(g_type_from_name(load)));
+      auto it = loaderToType.find(load);
       if (it != loaderToType.end()) {
         imageType = it->second;
       }
@@ -238,7 +253,7 @@ namespace sharp {
     ImageType imageType = ImageType::UNKNOWN;
     char const *load = vips_foreign_find_load(file);
     if (load != nullptr) {
-      auto it = loaderToType.find(vips_nickname_find(g_type_from_name(load)));
+      auto it = loaderToType.find(load);
       if (it != loaderToType.end()) {
         imageType = it->second;
       }
@@ -318,15 +333,35 @@ namespace sharp {
     } else {
       if (descriptor->createChannels > 0) {
         // Create new image
-        std::vector<double> background = {
-          descriptor->createBackground[0],
-          descriptor->createBackground[1],
-          descriptor->createBackground[2]
-        };
-        if (descriptor->createChannels == 4) {
-          background.push_back(descriptor->createBackground[3]);
+        if (descriptor->createNoiseType == "gaussian") {
+          int const channels = descriptor->createChannels;
+          image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight);
+          std::vector<VImage> bands = {};
+          bands.reserve(channels);
+          for (int _band = 0; _band < channels; _band++) {
+            bands.push_back(image.gaussnoise(
+              descriptor->createWidth,
+              descriptor->createHeight,
+              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],
+            descriptor->createBackground[1],
+            descriptor->createBackground[2]
+          };
+          if (descriptor->createChannels == 4) {
+            background.push_back(descriptor->createBackground[3]);
+          }
+          image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight).new_from_image(background);
         }
-        image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight).new_from_image(background);
         image.get_image()->Type = VIPS_INTERPRETATION_sRGB;
         imageType = ImageType::RAW;
       } else {
@@ -388,12 +423,7 @@ namespace sharp {
     Uses colour space interpretation with number of channels to guess this.
   */
   bool HasAlpha(VImage image) {
-    int const bands = image.bands();
-    VipsInterpretation const interpretation = image.interpretation();
-    return (
-      (bands == 2 && interpretation == VIPS_INTERPRETATION_B_W) ||
-      (bands == 4 && interpretation != VIPS_INTERPRETATION_CMYK) ||
-      (bands == 5 && interpretation == VIPS_INTERPRETATION_CMYK));
+    return image.has_alpha();
   }
 
   /*

src/common.h

@@ -26,8 +26,8 @@
 
 #if (VIPS_MAJOR_VERSION < 8) || \
   (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 10) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 10 && VIPS_MICRO_VERSION < 5)
-#error "libvips version 8.10.5+ is required - please see https://sharp.pixelplumbing.com/install"
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 10 && VIPS_MICRO_VERSION < 6)
+#error "libvips version 8.10.6+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -64,6 +64,9 @@ namespace sharp {
     int createWidth;
     int createHeight;
     std::vector<double> createBackground;
+    std::string createNoiseType;
+    double createNoiseMean;
+    double createNoiseSigma;
 
     InputDescriptor():
       buffer(nullptr),
@@ -82,7 +85,9 @@ namespace sharp {
       createChannels(0),
       createWidth(0),
       createHeight(0),
-      createBackground{ 0.0, 0.0, 0.0, 255.0 } {}
+      createBackground{ 0.0, 0.0, 0.0, 255.0 },
+      createNoiseMean(0.0),
+      createNoiseSigma(0.0) {}
   };
 
   // Convenience methods to access the attributes of a Napi::Object

src/metadata.cc

@@ -74,6 +74,9 @@ class MetadataWorker : public Napi::AsyncWorker {
       if (image.get_typeof("heif-primary") == G_TYPE_INT) {
         baton->pagePrimary = image.get_int("heif-primary");
       }
+      if (image.get_typeof("heif-compression") == VIPS_TYPE_REF_STRING) {
+        baton->compression = image.get_string("heif-compression");
+      }
       if (image.get_typeof("openslide.level-count") == VIPS_TYPE_REF_STRING) {
         int const levels = std::stoi(image.get_string("openslide.level-count"));
         for (int l = 0; l < levels; l++) {
@@ -186,6 +189,9 @@ class MetadataWorker : public Napi::AsyncWorker {
       if (baton->pagePrimary > -1) {
         info.Set("pagePrimary", baton->pagePrimary);
       }
+      if (!baton->compression.empty()) {
+        info.Set("compression", baton->compression);
+      }
       if (!baton->levels.empty()) {
         int i = 0;
         Napi::Array levels = Napi::Array::New(env, static_cast<size_t>(baton->levels.size()));

src/metadata.h

@@ -39,6 +39,7 @@ struct MetadataBaton {
   int loop;
   std::vector<int> delay;
   int pagePrimary;
+  std::string compression;
   std::vector<std::pair<int, int>> levels;
   bool hasProfile;
   bool hasAlpha;

src/operations.cc

@@ -149,8 +149,8 @@ namespace sharp {
    */
   VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix) {
     double *m = matrix.get();
+    image = image.colourspace(VIPS_INTERPRETATION_sRGB);
     return image
-      .colourspace(VIPS_INTERPRETATION_sRGB)
       .recomb(image.bands() == 3
         ? VImage::new_from_memory(
           m, 9 * sizeof(double), 3, 3, 1, VIPS_FORMAT_DOUBLE

src/pipeline.cc

@@ -562,9 +562,17 @@ class PipelineWorker : public Napi::AsyncWorker {
             // Use gravity in overlay
             if (compositeImage.width() <= baton->width) {
               across = static_cast<int>(ceil(static_cast<double>(image.width()) / compositeImage.width()));
+              // Ensure odd number of tiles across when gravity is centre, north or south
+              if (composite->gravity == 0 || composite->gravity == 1 || composite->gravity == 3) {
+                across |= 1;
+              }
             }
             if (compositeImage.height() <= baton->height) {
               down = static_cast<int>(ceil(static_cast<double>(image.height()) / compositeImage.height()));
+              // Ensure odd number of tiles down when gravity is centre, east or west
+              if (composite->gravity == 0 || composite->gravity == 2 || composite->gravity == 4) {
+                down |= 1;
+              }
             }
             if (across != 0 || down != 0) {
               int left;
@@ -594,8 +602,13 @@ class PipelineWorker : public Napi::AsyncWorker {
           int top;
           if (composite->hasOffset) {
             // Composite image at given offsets
-            std::tie(left, top) = sharp::CalculateCrop(image.width(), image.height(),
-              compositeImage.width(), compositeImage.height(), composite->left, composite->top);
+            if (composite->tile) {
+              std::tie(left, top) = sharp::CalculateCrop(image.width(), image.height(),
+                compositeImage.width(), compositeImage.height(), composite->left, composite->top);
+            } else {
+              left = composite->left;
+              top = composite->top;
+            }
           } else {
             // Composite image with given gravity
             std::tie(left, top) = sharp::CalculateCrop(image.width(), image.height(),
@@ -730,7 +743,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         if (baton->formatOut == "jpeg" || (baton->formatOut == "input" && inputImageType == sharp::ImageType::JPEG)) {
           // Write JPEG to buffer
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
-          VipsArea *area = VIPS_AREA(image.jpegsave_buffer(VImage::option()
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.jpegsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->jpegQuality)
             ->set("interlace", baton->jpegProgressive)
@@ -757,7 +770,7 @@ class PipelineWorker : public Napi::AsyncWorker {
            inputImageType == sharp::ImageType::SVG))) {
           // Write PNG to buffer
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::PNG);
-          VipsArea *area = VIPS_AREA(image.pngsave_buffer(VImage::option()
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.pngsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("interlace", baton->pngProgressive)
             ->set("compression", baton->pngCompressionLevel)
@@ -775,7 +788,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::WEBP)) {
           // Write WEBP to buffer
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::WEBP);
-          VipsArea *area = VIPS_AREA(image.webpsave_buffer(VImage::option()
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.webpsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->webpQuality)
             ->set("lossless", baton->webpLossless)
@@ -792,7 +805,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::GIF && supportsGifOutput)) {
           // Write GIF to buffer
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::GIF);
-          VipsArea *area = VIPS_AREA(image.magicksave_buffer(VImage::option()
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.magicksave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("optimize_gif_frames", TRUE)
             ->set("optimize_gif_transparency", TRUE)
@@ -813,7 +826,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           if (baton->tiffPredictor == VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT) {
             image = image.cast(VIPS_FORMAT_FLOAT);
           }
-          VipsArea *area = VIPS_AREA(image.tiffsave_buffer(VImage::option()
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.tiffsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->tiffQuality)
             ->set("bitdepth", baton->tiffBitdepth)
@@ -833,11 +846,15 @@ class PipelineWorker : public Napi::AsyncWorker {
         } else if (baton->formatOut == "heif" ||
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::HEIF)) {
           // Write HEIF to buffer
-          VipsArea *area = VIPS_AREA(image.heifsave_buffer(VImage::option()
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.heifsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("compression", baton->heifCompression)
             ->set("Q", baton->heifQuality)
             ->set("speed", baton->heifSpeed)
+#if defined(VIPS_TYPE_FOREIGN_SUBSAMPLE)
+            ->set("subsample_mode", baton->heifChromaSubsampling == "4:4:4"
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
+#endif
             ->set("lossless", baton->heifLossless)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -951,6 +968,10 @@ class PipelineWorker : public Napi::AsyncWorker {
             sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
             baton->channels = std::min(baton->channels, 3);
           }
+          // Cast pixel values to float, if required
+          if (baton->tiffPredictor == VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT) {
+            image = image.cast(VIPS_FORMAT_FLOAT);
+          }
           image.tiffsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->tiffQuality)
@@ -972,6 +993,10 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("Q", baton->heifQuality)
             ->set("compression", baton->heifCompression)
             ->set("speed", baton->heifSpeed)
+#if defined(VIPS_TYPE_FOREIGN_SUBSAMPLE)
+            ->set("subsample_mode", baton->heifChromaSubsampling == "4:4:4"
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
+#endif
             ->set("lossless", baton->heifLossless));
           baton->formatOut = "heif";
         } else if (baton->formatOut == "dz" || isDz || isDzZip) {
@@ -1026,6 +1051,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("angle", CalculateAngleRotation(baton->tileAngle))
             ->set("background", baton->tileBackground)
             ->set("centre", baton->tileCentre)
+            ->set("id", const_cast<char*>(baton->tileId.data()))
             ->set("skip_blanks", baton->tileSkipBlanks);
           // libvips chooses a default depth based on layout. Instead of replicating that logic here by
           // not passing anything - libvips will handle choice
@@ -1396,6 +1422,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_HEIF_COMPRESSION,
     sharp::AttrAsStr(options, "heifCompression").data()));
   baton->heifSpeed = sharp::AttrAsUint32(options, "heifSpeed");
+  baton->heifChromaSubsampling = sharp::AttrAsStr(options, "heifChromaSubsampling");
 
   // Animated output
   if (sharp::HasAttr(options, "pageHeight")) {
@@ -1425,6 +1452,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_DZ_DEPTH,
     sharp::AttrAsStr(options, "tileDepth").data()));
   baton->tileCentre = sharp::AttrAsBool(options, "tileCentre");
+  baton->tileId = sharp::AttrAsStr(options, "tileId");
 
   // Force random access for certain operations
   if (baton->input->access == VIPS_ACCESS_SEQUENTIAL) {

src/pipeline.h

@@ -162,6 +162,7 @@ struct PipelineBaton {
   int heifQuality;
   VipsForeignHeifCompression heifCompression;
   int heifSpeed;
+  std::string heifChromaSubsampling;
   bool heifLossless;
   std::string err;
   bool withMetadata;
@@ -191,6 +192,7 @@ struct PipelineBaton {
   std::vector<double> tileBackground;
   int tileSkipBlanks;
   VipsForeignDzDepth tileDepth;
+  std::string tileId;
   std::unique_ptr<double[]> recombMatrix;
 
   PipelineBaton():
@@ -257,7 +259,7 @@ struct PipelineBaton {
     jpegOptimiseScans(false),
     jpegOptimiseCoding(true),
     pngProgressive(false),
-    pngCompressionLevel(9),
+    pngCompressionLevel(6),
     pngAdaptiveFiltering(false),
     pngPalette(false),
     pngQuality(100),
@@ -282,6 +284,7 @@ struct PipelineBaton {
     heifQuality(50),
     heifCompression(VIPS_FOREIGN_HEIF_COMPRESSION_AV1),
     heifSpeed(5),
+    heifChromaSubsampling("4:2:0"),
     heifLossless(false),
     withMetadata(false),
     withMetadataOrientation(-1),

src/sharp.cc

@@ -23,7 +23,6 @@
 
 static void* sharp_vips_init(void*) {
   g_setenv("VIPS_MIN_STACK_SIZE", "2m", FALSE);
-  g_setenv("PANGOCAIRO_BACKEND", "fontconfig", FALSE);
   vips_init("sharp");
   return nullptr;
 }
@@ -45,6 +44,7 @@ Napi::Object init(Napi::Env env, Napi::Object exports) {
   exports.Set("libvipsVersion", Napi::Function::New(env, libvipsVersion));
   exports.Set("format", Napi::Function::New(env, format));
   exports.Set("_maxColourDistance", Napi::Function::New(env, _maxColourDistance));
+  exports.Set("_isUsingJemalloc", Napi::Function::New(env, _isUsingJemalloc));
   exports.Set("stats", Napi::Function::New(env, stats));
   return exports;
 }

src/utilities.cc

@@ -225,3 +225,19 @@ Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {
 
   return Napi::Number::New(env, maxColourDistance);
 }
+
+#if defined(__GNUC__)
+// mallctl will be resolved by the runtime linker when jemalloc is being used
+extern "C" {
+  int mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp, size_t newlen) __attribute__((weak));
+}
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, mallctl != nullptr);
+}
+#else
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, false);
+}
+#endif

src/utilities.h

@@ -24,5 +24,6 @@ Napi::Value simd(const Napi::CallbackInfo& info);
 Napi::Value libvipsVersion(const Napi::CallbackInfo& info);
 Napi::Value format(const Napi::CallbackInfo& info);
 Napi::Value _maxColourDistance(const Napi::CallbackInfo& info);
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info);
 
 #endif  // SRC_UTILITIES_H_

test/bench/package.json

@@ -13,7 +13,7 @@
     "gm": "1.23.1",
     "imagemagick": "0.1.3",
     "jimp": "0.16.1",
-    "mapnik": "4.5.5",
+    "mapnik": "4.5.6",
     "semver": "7.3.4"
   },
   "license": "Apache-2.0",

test/bench/perf.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const os = require('os');
 const fs = require('fs');
 
 const async = require('async');
@@ -15,12 +16,19 @@ const jimp = require('jimp');
 
 const fixtures = require('../fixtures');
 
+const outputJpg = fixtures.path('output.jpg');
+const outputPng = fixtures.path('output.png');
+const outputWebP = fixtures.path('output.webp');
+
 const width = 720;
 const height = 588;
 
 // Disable libvips cache to ensure tests are as fair as they can be
 sharp.cache(false);
 
+// Spawn one thread per CPU
+sharp.concurrency(os.cpus().length);
+
 async.series({
   jpeg: function (callback) {
     const inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
@@ -56,7 +64,7 @@ async.series({
             image
               .resize(width, height, jimp.RESIZE_BICUBIC)
               .quality(80)
-              .write(fixtures.outputJpg, function (err) {
+              .write(outputJpg, function (err) {
                 if (err) {
                   throw err;
                 } else {
@@ -77,7 +85,7 @@ async.series({
             .resize(width, height, {
               scaling_method: mapnik.imageScaling.lanczos
             })
-            .save(fixtures.outputJpg, 'jpeg:quality=80', function (err) {
+            .save(outputJpg, 'jpeg:quality=80', function (err) {
               if (err) throw err;
               deferred.resolve();
             });
@@ -105,7 +113,7 @@ async.series({
       fn: function (deferred) {
         imagemagick.resize({
           srcPath: fixtures.inputJpg,
-          dstPath: fixtures.outputJpg,
+          dstPath: outputJpg,
           quality: 0.8,
           width: width,
           height: height,
@@ -128,7 +136,7 @@ async.series({
           .filter('Lanczos')
           .resize(width, height)
           .quality(80)
-          .write(fixtures.outputJpg, function (err) {
+          .write(outputJpg, function (err) {
             if (err) {
               throw err;
             } else {
@@ -159,7 +167,7 @@ async.series({
           .filter('Lanczos')
           .resize(width, height)
           .quality(80)
-          .write(fixtures.outputJpg, function (err) {
+          .write(outputJpg, function (err) {
             if (err) {
               throw err;
             } else {
@@ -190,7 +198,7 @@ async.series({
       fn: function (deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .toFile(fixtures.outputJpg, function (err) {
+          .toFile(outputJpg, function (err) {
             if (err) {
               throw err;
             } else {
@@ -217,7 +225,7 @@ async.series({
       fn: function (deferred) {
         sharp(fixtures.inputJpg)
           .resize(width, height)
-          .toFile(fixtures.outputJpg, function (err) {
+          .toFile(outputJpg, function (err) {
             if (err) {
               throw err;
             } else {
@@ -229,7 +237,7 @@ async.series({
       defer: true,
       fn: function (deferred) {
         const readable = fs.createReadStream(fixtures.inputJpg);
-        const writable = fs.createWriteStream(fixtures.outputJpg);
+        const writable = fs.createWriteStream(outputJpg);
         writable.on('finish', function () {
           deferred.resolve();
         });
@@ -600,7 +608,7 @@ async.series({
               .resize(width, height)
               .deflateLevel(6)
               .filterType(0)
-              .write(fixtures.outputPng, function (err) {
+              .write(outputPng, function (err) {
                 if (err) {
                   throw err;
                 } else {
@@ -625,7 +633,7 @@ async.series({
               if (err) throw err;
               img.demultiply(function (err, img) {
                 if (err) throw err;
-                img.save(fixtures.outputPng, 'png', function (err) {
+                img.save(outputPng, 'png', function (err) {
                   if (err) throw err;
                   deferred.resolve();
                 });
@@ -663,7 +671,7 @@ async.series({
       fn: function (deferred) {
         imagemagick.resize({
           srcPath: fixtures.inputPngAlphaPremultiplicationLarge,
-          dstPath: fixtures.outputPng,
+          dstPath: outputPng,
           width: width,
           height: height,
           filter: 'Lanczos',
@@ -689,7 +697,7 @@ async.series({
           .resize(width, height)
           .define('PNG:compression-level=6')
           .define('PNG:compression-filter=0')
-          .write(fixtures.outputPng, function (err) {
+          .write(outputPng, function (err) {
             if (err) {
               throw err;
             } else {
@@ -723,7 +731,7 @@ async.series({
         sharp(inputPngBuffer)
           .resize(width, height)
           .png({ compressionLevel: 6 })
-          .toFile(fixtures.outputPng, function (err) {
+          .toFile(outputPng, function (err) {
             if (err) {
               throw err;
             } else {
@@ -754,7 +762,7 @@ async.series({
         sharp(fixtures.inputPngAlphaPremultiplicationLarge)
           .resize(width, height)
           .png({ compressionLevel: 6 })
-          .toFile(fixtures.outputPng, function (err) {
+          .toFile(outputPng, function (err) {
             if (err) {
               throw err;
             } else {
@@ -841,7 +849,7 @@ async.series({
       fn: function (deferred) {
         sharp(inputWebPBuffer)
           .resize(width, height)
-          .toFile(fixtures.outputWebP, function (err) {
+          .toFile(outputWebP, function (err) {
             if (err) {
               throw err;
             } else {
@@ -868,7 +876,7 @@ async.series({
       fn: function (deferred) {
         sharp(fixtures.inputWebP)
           .resize(width, height)
-          .toFile(fixtures.outputWebP, function (err) {
+          .toFile(outputWebP, function (err) {
             if (err) {
               throw err;
             } else {

test/bench/random.js

@@ -23,7 +23,7 @@ new Benchmark.Suite('random').add('imagemagick', {
   fn: function (deferred) {
     imagemagick.resize({
       srcPath: fixtures.inputJpg,
-      dstPath: fixtures.outputJpg,
+      dstPath: fixtures.path('output.jpg'),
       quality: 0.8,
       width: randomDimension(),
       height: randomDimension(),

test/fixtures/index.js

@@ -109,7 +109,7 @@ module.exports = {
   inputSvg: getPath('check.svg'), // http://dev.w3.org/SVG/tools/svgweb/samples/svg-files/check.svg
   inputSvgSmallViewBox: getPath('circle.svg'),
   inputSvgWithEmbeddedImages: getPath('struct-image-04-t.svg'), // https://dev.w3.org/SVG/profiles/1.2T/test/svg/struct-image-04-t.svg
-  inputAvif: getPath('cosmos_frame12924_yuv420_10bpc_bt2020_pq_q50.avif'), // CC by-nc-nd https://github.com/AOMediaCodec/av1-avif/tree/master/testFiles/Netflix
+  inputAvif: getPath('sdr_cosmos12920_cicp1-13-6_yuv444_full_qp10.avif'), // CC by-nc-nd https://github.com/AOMediaCodec/av1-avif/tree/master/testFiles/Netflix
 
   inputJPGBig: getPath('flowers.jpeg'),
 
@@ -120,13 +120,6 @@ module.exports = {
 
   inputV: getPath('vfile.v'),
 
-  outputJpg: getPath('output.jpg'),
-  outputPng: getPath('output.png'),
-  outputWebP: getPath('output.webp'),
-  outputV: getPath('output.v'),
-  outputTiff: getPath('output.tiff'),
-  outputZoinks: getPath('output.zoinks'), // an 'unknown' file extension
-
   testPattern: getPath('test-pattern.png'),
 
   // Path for tests requiring human inspection

test/leak/sharp.supp

@@ -426,6 +426,16 @@
   ...
   fun:vips_target_finish
 }
+{
+  value8_libvips_static
+  Memcheck:Value8
+  obj:*/libvips-cpp.so.*
+}
+{
+  cond_libvips_static
+  Memcheck:Cond
+  obj:*/libvips-cpp.so.*
+}
 {
   leak_libvips_init
   Memcheck:Leak
@@ -440,7 +450,7 @@
   match-leak-kinds: definite
   fun:malloc
   ...
-  fun:rsvg_rust_handle_new_from_stream_sync
+  fun:rsvg_handle_new_from_stream_sync
 }
 {
   leak_rsvg_rsvg_rust_handle_new_from_gfile_sync
@@ -448,7 +458,7 @@
   match-leak-kinds: definite
   fun:malloc
   ...
-  fun:rsvg_rust_handle_new_from_gfile_sync
+  fun:rsvg_handle_new_from_gfile_sync
 }
 {
   leak_rsvg_rust_handle_new_from_stream_sync
@@ -458,7 +468,7 @@
   ...
   fun:xmlParseElement
   ...
-  fun:rsvg_rust_handle_new_from_stream_sync
+  fun:rsvg_handle_new_from_stream_sync
 }
 {
   leak_rsvg_rust_handle_new_from_gfile_sync
@@ -468,7 +478,7 @@
   ...
   fun:xmlParseElement
   ...
-  fun:rsvg_rust_handle_new_from_gfile_sync
+  fun:rsvg_handle_new_from_gfile_sync
 }
 
 # libuv warnings

test/unit/avif.js

@@ -12,29 +12,6 @@ describe('AVIF', () => {
     });
   });
 
-  it('can passthrough AVIF', async () => {
-    const data = await sharp(inputAvif)
-      .resize(32)
-      .toBuffer();
-    const metadata = await sharp(data)
-      .metadata();
-    const { size, ...metadataWithoutSize } = metadata;
-    assert.deepStrictEqual(metadataWithoutSize, {
-      channels: 3,
-      depth: 'uchar',
-      format: 'heif',
-      hasAlpha: false,
-      hasProfile: false,
-      height: 12,
-      isProgressive: false,
-      pageHeight: 12,
-      pagePrimary: 0,
-      pages: 1,
-      space: 'srgb',
-      width: 32
-    });
-  });
-
   it('can convert AVIF to JPEG', async () => {
     const data = await sharp(inputAvif)
       .resize(32)
@@ -42,7 +19,7 @@ describe('AVIF', () => {
       .toBuffer();
     const metadata = await sharp(data)
       .metadata();
-    const { size, ...metadataWithoutSize } = metadata;
+    const { compression, size, ...metadataWithoutSize } = metadata;
     assert.deepStrictEqual(metadataWithoutSize, {
       channels: 3,
       chromaSubsampling: '4:2:0',
@@ -65,7 +42,7 @@ describe('AVIF', () => {
       .toBuffer();
     const metadata = await sharp(data)
       .metadata();
-    const { size, ...metadataWithoutSize } = metadata;
+    const { compression, size, ...metadataWithoutSize } = metadata;
     assert.deepStrictEqual(metadataWithoutSize, {
       channels: 3,
       depth: 'uchar',
@@ -81,4 +58,27 @@ describe('AVIF', () => {
       width: 32
     });
   });
+
+  it('can passthrough AVIF', async () => {
+    const data = await sharp(inputAvif)
+      .resize(32)
+      .toBuffer();
+    const metadata = await sharp(data)
+      .metadata();
+    const { compression, size, ...metadataWithoutSize } = metadata;
+    assert.deepStrictEqual(metadataWithoutSize, {
+      channels: 3,
+      depth: 'uchar',
+      format: 'heif',
+      hasAlpha: false,
+      hasProfile: false,
+      height: 12,
+      isProgressive: false,
+      pageHeight: 12,
+      pagePrimary: 0,
+      pages: 1,
+      space: 'srgb',
+      width: 32
+    });
+  });
 });

test/unit/colourspace.js

@@ -42,18 +42,15 @@ describe('Colour space conversion', function () {
       });
   });
 
-  if (sharp.format.tiff.input.file && sharp.format.webp.output.buffer) {
-    it('From 1-bit TIFF to sRGB WebP [slow]', function (done) {
-      sharp(fixtures.inputTiff)
-        .webp()
-        .toBuffer(function (err, data, info) {
-          if (err) throw err;
-          assert.strictEqual(true, data.length > 0);
-          assert.strictEqual('webp', info.format);
-          done();
-        });
-    });
-  }
+  it('From 1-bit TIFF to sRGB WebP', async () => {
+    const data = await sharp(fixtures.inputTiff)
+      .resize(8, 8)
+      .webp()
+      .toBuffer();
+
+    const { format } = await sharp(data).metadata();
+    assert.strictEqual(format, 'webp');
+  });
 
   it('From CMYK to sRGB', function (done) {
     sharp(fixtures.inputJpgWithCmykProfile)

test/unit/composite.js

@@ -225,6 +225,24 @@ describe('composite', () => {
       });
   });
 
+  it('centre gravity should replicate correct number of tiles', async () => {
+    const red = { r: 255, g: 0, b: 0 };
+    const [r, g, b] = await sharp({
+      create: {
+        width: 40, height: 40, channels: 4, background: red
+      }
+    })
+      .composite([{
+        input: fixtures.inputPngWithTransparency16bit,
+        gravity: 'centre',
+        tile: true
+      }])
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual({ r, g, b }, red);
+  });
+
   it('cutout via dest-in', done => {
     sharp(fixtures.inputJpg)
       .resize(300, 300)
@@ -390,4 +408,20 @@ describe('composite', () => {
       }, /Expected valid gravity for gravity but received invalid of type string/);
     });
   });
+
+  it('Allow offset beyond bottom/right edge', async () => {
+    const red = { r: 255, g: 0, b: 0 };
+    const blue = { r: 0, g: 0, b: 255 };
+
+    const [r, g, b] = await sharp({ create: { width: 2, height: 2, channels: 4, background: red } })
+      .composite([{
+        input: { create: { width: 2, height: 2, channels: 4, background: blue } },
+        top: 1,
+        left: 1
+      }])
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual(red, { r, g, b });
+  });
 });

test/unit/extend.js

@@ -41,7 +41,6 @@ describe('Extend', function () {
       .resize(120)
       .extend({
         top: 50,
-        bottom: 0,
         left: 10,
         right: 35,
         background: { r: 0, g: 0, b: 0, alpha: 0 }
@@ -64,18 +63,38 @@ describe('Extend', function () {
       sharp().extend(-1);
     });
   });
-  it('partial object fails', function () {
-    assert.throws(function () {
-      sharp().extend({ top: 1 });
-    });
+  it('invalid top fails', () => {
+    assert.throws(
+      () => sharp().extend({ top: 'fail' }),
+      /Expected positive integer for top but received fail of type string/
+    );
+  });
+  it('invalid bottom fails', () => {
+    assert.throws(
+      () => sharp().extend({ bottom: -1 }),
+      /Expected positive integer for bottom but received -1 of type number/
+    );
+  });
+  it('invalid left fails', () => {
+    assert.throws(
+      () => sharp().extend({ left: 0.1 }),
+      /Expected positive integer for left but received 0.1 of type number/
+    );
+  });
+  it('invalid right fails', () => {
+    assert.throws(
+      () => sharp().extend({ right: {} }),
+      /Expected positive integer for right but received \[object Object\] of type object/
+    );
+  });
+  it('can set all edges apart from right', () => {
+    assert.doesNotThrow(() => sharp().extend({ top: 1, left: 2, bottom: 3 }));
   });
 
   it('should add alpha channel before extending with a transparent Background', function (done) {
     sharp(fixtures.inputJpgWithLandscapeExif1)
       .extend({
-        top: 0,
         bottom: 10,
-        left: 0,
         right: 10,
         background: { r: 0, g: 0, b: 0, alpha: 0 }
       })
@@ -91,9 +110,7 @@ describe('Extend', function () {
   it('PNG with 2 channels', function (done) {
     sharp(fixtures.inputPngWithGreyAlpha)
       .extend({
-        top: 0,
         bottom: 20,
-        left: 0,
         right: 20,
         background: 'transparent'
       })

test/unit/extract.js

@@ -28,32 +28,28 @@ describe('Partial image extraction', function () {
       });
   });
 
-  if (sharp.format.webp.output.file) {
-    it('WebP', function (done) {
-      sharp(fixtures.inputWebP)
-        .extract({ left: 100, top: 50, width: 125, height: 200 })
-        .toBuffer(function (err, data, info) {
-          if (err) throw err;
-          assert.strictEqual(125, info.width);
-          assert.strictEqual(200, info.height);
-          fixtures.assertSimilar(fixtures.expected('extract.webp'), data, done);
-        });
-    });
-  }
+  it('WebP', function (done) {
+    sharp(fixtures.inputWebP)
+      .extract({ left: 100, top: 50, width: 125, height: 200 })
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(125, info.width);
+        assert.strictEqual(200, info.height);
+        fixtures.assertSimilar(fixtures.expected('extract.webp'), data, done);
+      });
+  });
 
-  if (sharp.format.tiff.output.file) {
-    it('TIFF', function (done) {
-      sharp(fixtures.inputTiff)
-        .extract({ left: 34, top: 63, width: 341, height: 529 })
-        .jpeg()
-        .toBuffer(function (err, data, info) {
-          if (err) throw err;
-          assert.strictEqual(341, info.width);
-          assert.strictEqual(529, info.height);
-          fixtures.assertSimilar(fixtures.expected('extract.tiff'), data, done);
-        });
-    });
-  }
+  it('TIFF', function (done) {
+    sharp(fixtures.inputTiff)
+      .extract({ left: 34, top: 63, width: 341, height: 529 })
+      .jpeg()
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(341, info.width);
+        assert.strictEqual(529, info.height);
+        fixtures.assertSimilar(fixtures.expected('extract.tiff'), data, done);
+      });
+  });
 
   it('Before resize', function (done) {
     sharp(fixtures.inputJpg)

test/unit/extractChannel.js

@@ -107,7 +107,7 @@ describe('Image channel extraction', function () {
     });
   });
 
-  it('Non-existant channel', function (done) {
+  it('Non-existent channel', function (done) {
     sharp(fixtures.inputPng)
       .extractChannel(1)
       .toBuffer(function (err) {

test/unit/failOnError.js

@@ -53,7 +53,7 @@ describe('failOnError', function () {
 
   it('returns errors to callback for truncated JPEG', function (done) {
     sharp(fixtures.inputJpgTruncated).toBuffer(function (err, data, info) {
-      assert.ok(err.message.includes('VipsJpeg: Premature end of JPEG file'), err);
+      assert.ok(err.message.includes('VipsJpeg: Premature end of'), err);
       assert.strictEqual(data, undefined);
       assert.strictEqual(info, undefined);
       done();
@@ -76,7 +76,7 @@ describe('failOnError', function () {
         throw new Error('Expected rejection');
       })
       .catch(err => {
-        done(err.message.includes('VipsJpeg: Premature end of JPEG file') ? undefined : err);
+        done(err.message.includes('VipsJpeg: Premature end of') ? undefined : err);
       });
   });
 

test/unit/gif.js

@@ -63,12 +63,17 @@ describe('GIF input', () => {
   );
 
   if (!sharp.format.magick.output.buffer) {
-    it('GIF output should fail due to missing ImageMagick', () => {
+    it('GIF buffer output should fail due to missing ImageMagick', () => {
       assert.throws(
-        () => {
-          sharp().gif();
-        },
-        /The gif operation requires libvips to have been installed with support for ImageMagick/
+        () => sharp().gif(),
+        /GIF output requires libvips with support for ImageMagick/
+      );
+    });
+
+    it('GIF file output should fail due to missing ImageMagick', () => {
+      assert.rejects(
+        async () => await sharp().toFile('test.gif'),
+        /GIF output requires libvips with support for ImageMagick/
       );
     });
   }

test/unit/heif.js

@@ -65,4 +65,14 @@ describe('HEIF', () => {
       sharp().heif({ compression: 'fail' });
     });
   });
+  it('invalid chromaSubsampling should throw an error', () => {
+    assert.throws(() => {
+      sharp().heif({ chromaSubsampling: 'fail' });
+    });
+  });
+  it('valid chromaSubsampling does not throw an error', () => {
+    assert.doesNotThrow(() => {
+      sharp().heif({ chromaSubsampling: '4:4:4' });
+    });
+  });
 });

test/unit/io.js

@@ -7,6 +7,8 @@ const rimraf = require('rimraf');
 const sharp = require('../../');
 const fixtures = require('../fixtures');
 
+const outputJpg = fixtures.path('output.jpg');
+
 describe('Input/output', function () {
   beforeEach(function () {
     sharp.cache(false);
@@ -16,16 +18,16 @@ describe('Input/output', function () {
   });
 
   it('Read from File and write to Stream', function (done) {
-    const writable = fs.createWriteStream(fixtures.outputJpg);
+    const writable = fs.createWriteStream(outputJpg);
     writable.on('close', function () {
-      sharp(fixtures.outputJpg).toBuffer(function (err, data, info) {
+      sharp(outputJpg).toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);
         assert.strictEqual(data.length, info.size);
         assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(240, info.height);
-        rimraf(fixtures.outputJpg, done);
+        rimraf(outputJpg, done);
       });
     });
     sharp(fixtures.inputJpg).resize(320, 240).pipe(writable);
@@ -33,16 +35,16 @@ describe('Input/output', function () {
 
   it('Read from Buffer and write to Stream', function (done) {
     const inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
-    const writable = fs.createWriteStream(fixtures.outputJpg);
+    const writable = fs.createWriteStream(outputJpg);
     writable.on('close', function () {
-      sharp(fixtures.outputJpg).toBuffer(function (err, data, info) {
+      sharp(outputJpg).toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);
         assert.strictEqual(data.length, info.size);
         assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(240, info.height);
-        rimraf(fixtures.outputJpg, done);
+        rimraf(outputJpg, done);
       });
     });
     sharp(inputJpgBuffer).resize(320, 240).pipe(writable);
@@ -50,13 +52,13 @@ describe('Input/output', function () {
 
   it('Read from Stream and write to File', function (done) {
     const readable = fs.createReadStream(fixtures.inputJpg);
-    const pipeline = sharp().resize(320, 240).toFile(fixtures.outputJpg, function (err, info) {
+    const pipeline = sharp().resize(320, 240).toFile(outputJpg, function (err, info) {
       if (err) throw err;
       assert.strictEqual(true, info.size > 0);
       assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
-      rimraf(fixtures.outputJpg, done);
+      rimraf(outputJpg, done);
     });
     readable.pipe(pipeline);
   });
@@ -131,25 +133,57 @@ describe('Input/output', function () {
 
   it('Read from Stream and write to Stream', function (done) {
     const readable = fs.createReadStream(fixtures.inputJpg);
-    const writable = fs.createWriteStream(fixtures.outputJpg);
+    const writable = fs.createWriteStream(outputJpg);
     writable.on('close', function () {
-      sharp(fixtures.outputJpg).toBuffer(function (err, data, info) {
+      sharp(outputJpg).toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);
         assert.strictEqual(data.length, info.size);
         assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(240, info.height);
-        rimraf(fixtures.outputJpg, done);
+        rimraf(outputJpg, done);
       });
     });
     const pipeline = sharp().resize(320, 240);
     readable.pipe(pipeline).pipe(writable);
   });
 
+  it('Read from Uint8Array and write to Buffer', async () => {
+    const uint8array = Uint8Array.from([255, 255, 255, 0, 0, 0]);
+    const { data, info } = await sharp(uint8array, {
+      raw: {
+        width: 2,
+        height: 1,
+        channels: 3
+      }
+    }).toBuffer({ resolveWithObject: true });
+
+    assert.deepStrictEqual(uint8array, new Uint8Array(data));
+    assert.strictEqual(info.width, 2);
+    assert.strictEqual(info.height, 1);
+  });
+
+  it('Read from Uint8ClampedArray 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([255, 255, 255, 0, 0, 0]);
+    const { data, info } = await sharp(uint8array, {
+      raw: {
+        width: 2,
+        height: 1,
+        channels: 3
+      }
+    }).toBuffer({ resolveWithObject: true });
+
+    assert.deepStrictEqual(uint8array, 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(fixtures.outputJpg);
+    const writable = fs.createWriteStream(outputJpg);
     const pipeline = sharp().resize(320, 240);
     let infoEventEmitted = false;
     pipeline.on('info', function (info) {
@@ -161,7 +195,7 @@ describe('Input/output', function () {
     });
     writable.on('close', function () {
       assert.strictEqual(true, infoEventEmitted);
-      rimraf(fixtures.outputJpg, done);
+      rimraf(outputJpg, done);
     });
     readable.pipe(pipeline).pipe(writable);
   });
@@ -173,10 +207,10 @@ describe('Input/output', function () {
       anErrorWasEmitted = !!err;
     }).on('end', function () {
       assert(anErrorWasEmitted);
-      rimraf(fixtures.outputJpg, done);
+      rimraf(outputJpg, done);
     });
     const readableButNotAnImage = fs.createReadStream(__filename);
-    const writable = fs.createWriteStream(fixtures.outputJpg);
+    const writable = fs.createWriteStream(outputJpg);
     readableButNotAnImage.pipe(pipeline).pipe(writable);
   });
 
@@ -187,24 +221,24 @@ describe('Input/output', function () {
       anErrorWasEmitted = !!err;
     }).on('end', function () {
       assert(anErrorWasEmitted);
-      rimraf(fixtures.outputJpg, done);
+      rimraf(outputJpg, done);
     });
-    const writable = fs.createWriteStream(fixtures.outputJpg);
+    const writable = fs.createWriteStream(outputJpg);
     readableButNotAnImage.pipe(writable);
   });
 
   it('Readable side of Stream can start flowing after Writable side has finished', function (done) {
     const readable = fs.createReadStream(fixtures.inputJpg);
-    const writable = fs.createWriteStream(fixtures.outputJpg);
+    const writable = fs.createWriteStream(outputJpg);
     writable.on('close', function () {
-      sharp(fixtures.outputJpg).toBuffer(function (err, data, info) {
+      sharp(outputJpg).toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);
         assert.strictEqual(data.length, info.size);
         assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(240, info.height);
-        rimraf(fixtures.outputJpg, done);
+        rimraf(outputJpg, done);
       });
     });
     const pipeline = sharp().resize(320, 240);
@@ -411,68 +445,70 @@ describe('Input/output', function () {
   });
 
   describe('Output filename with unknown extension', function () {
+    const outputZoinks = fixtures.path('output.zoinks');
+
     it('Match JPEG input', function (done) {
       sharp(fixtures.inputJpg)
         .resize(320, 80)
-        .toFile(fixtures.outputZoinks, function (err, info) {
+        .toFile(outputZoinks, function (err, info) {
           if (err) throw err;
           assert.strictEqual(true, info.size > 0);
           assert.strictEqual('jpeg', info.format);
           assert.strictEqual(320, info.width);
           assert.strictEqual(80, info.height);
-          rimraf(fixtures.outputZoinks, done);
+          rimraf(outputZoinks, done);
         });
     });
 
     it('Match PNG input', function (done) {
       sharp(fixtures.inputPng)
         .resize(320, 80)
-        .toFile(fixtures.outputZoinks, function (err, info) {
+        .toFile(outputZoinks, function (err, info) {
           if (err) throw err;
           assert.strictEqual(true, info.size > 0);
           assert.strictEqual('png', info.format);
           assert.strictEqual(320, info.width);
           assert.strictEqual(80, info.height);
-          rimraf(fixtures.outputZoinks, done);
+          rimraf(outputZoinks, done);
         });
     });
 
     it('Match WebP input', function (done) {
       sharp(fixtures.inputWebP)
         .resize(320, 80)
-        .toFile(fixtures.outputZoinks, function (err, info) {
+        .toFile(outputZoinks, function (err, info) {
           if (err) throw err;
           assert.strictEqual(true, info.size > 0);
           assert.strictEqual('webp', info.format);
           assert.strictEqual(320, info.width);
           assert.strictEqual(80, info.height);
-          rimraf(fixtures.outputZoinks, done);
+          rimraf(outputZoinks, done);
         });
     });
 
     it('Match TIFF input', function (done) {
       sharp(fixtures.inputTiff)
         .resize(320, 80)
-        .toFile(fixtures.outputZoinks, function (err, info) {
+        .toFile(outputZoinks, function (err, info) {
           if (err) throw err;
           assert.strictEqual(true, info.size > 0);
           assert.strictEqual('tiff', info.format);
           assert.strictEqual(320, info.width);
           assert.strictEqual(80, info.height);
-          rimraf(fixtures.outputZoinks, done);
+          rimraf(outputZoinks, done);
         });
     });
 
     it('Autoconvert GIF input to PNG output', function (done) {
       sharp(fixtures.inputGif)
         .resize(320, 80)
-        .toFile(fixtures.outputZoinks, function (err, info) {
+        .toFile(outputZoinks, function (err, info) {
           if (err) throw err;
           assert.strictEqual(true, info.size > 0);
           assert.strictEqual(sharp.format.magick.input.buffer ? 'gif' : 'png', info.format);
           assert.strictEqual(320, info.width);
           assert.strictEqual(80, info.height);
-          rimraf(fixtures.outputZoinks, done);
+          rimraf(outputZoinks, done);
         });
     });
 
@@ -480,13 +516,13 @@ describe('Input/output', function () {
       sharp(fixtures.inputPng)
         .resize(320, 80)
         .jpeg()
-        .toFile(fixtures.outputZoinks, function (err, info) {
+        .toFile(outputZoinks, function (err, info) {
           if (err) throw err;
           assert.strictEqual(true, info.size > 0);
           assert.strictEqual('jpeg', info.format);
           assert.strictEqual(320, info.width);
           assert.strictEqual(80, info.height);
-          rimraf(fixtures.outputZoinks, done);
+          rimraf(outputZoinks, done);
         });
     });
   });
@@ -516,19 +552,20 @@ describe('Input/output', function () {
   });
 
   it('toFormat=JPEG takes precedence over WebP extension', function (done) {
+    const outputWebP = fixtures.path('output.webp');
     sharp(fixtures.inputPng)
       .jpeg()
-      .toFile(fixtures.outputWebP, function (err, info) {
+      .toFile(outputWebP, function (err, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);
-        done();
+        rimraf(outputWebP, done);
       });
   });
 
   it('toFormat=WebP takes precedence over JPEG extension', function (done) {
     sharp(fixtures.inputPng)
       .webp()
-      .toFile(fixtures.outputJpg, function (err, info) {
+      .toFile(outputJpg, function (err, info) {
         if (err) throw err;
         assert.strictEqual('webp', info.format);
         done();
@@ -549,15 +586,16 @@ describe('Input/output', function () {
   });
 
   it('Save Vips V file', function (done) {
+    const outputV = fixtures.path('output.v');
     sharp(fixtures.inputJpg)
       .extract({ left: 910, top: 1105, width: 70, height: 60 })
-      .toFile(fixtures.outputV, function (err, info) {
+      .toFile(outputV, function (err, info) {
         if (err) throw err;
         assert.strictEqual(true, info.size > 0);
         assert.strictEqual('v', info.format);
         assert.strictEqual(70, info.width);
         assert.strictEqual(60, info.height);
-        rimraf(fixtures.outputV, done);
+        rimraf(outputV, done);
       });
   });
 

test/unit/jpeg.js

@@ -290,4 +290,24 @@ describe('JPEG', function () {
           });
       });
   });
+
+  it('Can use mozjpeg defaults', async () => {
+    const withoutData = await sharp(fixtures.inputJpg)
+      .resize(32, 24)
+      .jpeg({ mozjpeg: false })
+      .toBuffer();
+    const withoutMeta = await sharp(withoutData).metadata();
+    assert.strictEqual(false, withoutMeta.isProgressive);
+
+    const withData = await sharp(fixtures.inputJpg)
+      .resize(32, 24)
+      .jpeg({ mozjpeg: true })
+      .toBuffer();
+    const withMeta = await sharp(withData).metadata();
+    assert.strictEqual(true, withMeta.isProgressive);
+  });
+
+  it('Invalid mozjpeg value throws error', () => {
+    assert.throws(() => sharp().jpeg({ mozjpeg: 'fail' }));
+  });
 });

test/unit/libvips.js

@@ -105,4 +105,30 @@ describe('libvips binaries', function () {
       assert.strictEqual(true, fs.existsSync(nestedDirPath));
     });
   });
+
+  describe('logger', function () {
+    const consoleLog = console.log;
+    const consoleError = console.error;
+
+    after(function () {
+      console.log = consoleLog;
+      console.error = consoleError;
+    });
+
+    it('logs an info message', function (done) {
+      console.log = function (msg) {
+        assert.strictEqual(msg, 'sharp: progress');
+        done();
+      };
+      libvips.log('progress');
+    });
+
+    it('logs an error message', function (done) {
+      console.error = function (msg) {
+        assert.strictEqual(msg, 'sharp: problem');
+        done();
+      };
+      libvips.log(new Error('problem'));
+    });
+  });
 });

test/unit/metadata.js

@@ -504,6 +504,7 @@ describe('Image metadata', function () {
   it('Apply CMYK output ICC profile', function (done) {
     const output = fixtures.path('output.icc-cmyk.jpg');
     sharp(fixtures.inputJpg)
+      .resize(64)
       .withMetadata({ icc: 'cmyk' })
       .toFile(output, function (err, info) {
         if (err) throw err;
@@ -528,11 +529,11 @@ describe('Image metadata', function () {
   it('Apply custom output ICC profile', function (done) {
     const output = fixtures.path('output.hilutite.jpg');
     sharp(fixtures.inputJpg)
+      .resize(64)
       .withMetadata({ icc: fixtures.path('hilutite.icm') })
       .toFile(output, function (err, info) {
         if (err) throw err;
-        fixtures.assertMaxColourDistance(output, fixtures.path('expected/hilutite.jpg'), 0);
-        fixtures.assertMaxColourDistance(output, fixtures.inputJpg, 16.5);
+        fixtures.assertMaxColourDistance(output, fixtures.path('expected/hilutite.jpg'), 9);
         done();
       });
   });
@@ -667,7 +668,7 @@ describe('Image metadata', function () {
     sharp(fixtures.inputJpgWithCorruptHeader)
       .metadata(function (err) {
         assert.strictEqual(true, !!err);
-        assert.strictEqual(true, /Input file has corrupt header: VipsJpeg: Premature end of JPEG file/.test(err.message));
+        assert.ok(err.message.includes('Input file has corrupt header: VipsJpeg: Premature end of'), err);
         done();
       });
   });
@@ -676,7 +677,7 @@ describe('Image metadata', function () {
     sharp(fs.readFileSync(fixtures.inputJpgWithCorruptHeader))
       .metadata(function (err) {
         assert.strictEqual(true, !!err);
-        assert.strictEqual(true, /Input buffer has corrupt header: VipsJpeg: Premature end of JPEG file/.test(err.message));
+        assert.ok(err.message.includes('Input buffer has corrupt header: VipsJpeg: Premature end of'), err);
         done();
       });
   });

test/unit/modulate.js

@@ -28,115 +28,138 @@ describe('Modulate', function () {
     });
   });
 
-  it('should be able to hue-rotate', function () {
-    const base = 'modulate-hue-120.jpg';
-    const actual = fixtures.path('output.' + base);
-    const expected = fixtures.expected(base);
-
-    return sharp(fixtures.inputJpg)
+  it('should be able to hue-rotate', async () => {
+    const [r, g, b] = await sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 3,
+        background: { r: 153, g: 68, b: 68 }
+      }
+    })
       .modulate({ hue: 120 })
-      .toFile(actual)
-      .then(function () {
-        fixtures.assertMaxColourDistance(actual, expected, 25);
-      });
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual({ r: 41, g: 107, b: 57 }, { r, g, b });
   });
 
-  it('should be able to brighten', function () {
-    const base = 'modulate-brightness-2.jpg';
-    const actual = fixtures.path('output.' + base);
-    const expected = fixtures.expected(base);
-
-    return sharp(fixtures.inputJpg)
+  it('should be able to brighten', async () => {
+    const [r, g, b] = await sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 3,
+        background: { r: 153, g: 68, b: 68 }
+      }
+    })
       .modulate({ brightness: 2 })
-      .toFile(actual)
-      .then(function () {
-        fixtures.assertMaxColourDistance(actual, expected, 25);
-      });
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual({ r: 255, g: 173, b: 168 }, { r, g, b });
   });
 
-  it('should be able to unbrighten', function () {
-    const base = 'modulate-brightness-0-5.jpg';
-    const actual = fixtures.path('output.' + base);
-    const expected = fixtures.expected(base);
-
-    return sharp(fixtures.inputJpg)
+  it('should be able to darken', async () => {
+    const [r, g, b] = await sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 3,
+        background: { r: 153, g: 68, b: 68 }
+      }
+    })
       .modulate({ brightness: 0.5 })
-      .toFile(actual)
-      .then(function () {
-        fixtures.assertMaxColourDistance(actual, expected, 25);
-      });
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual({ r: 97, g: 17, b: 25 }, { r, g, b });
   });
 
-  it('should be able to saturate', function () {
-    const base = 'modulate-saturation-2.jpg';
-    const actual = fixtures.path('output.' + base);
-    const expected = fixtures.expected(base);
-
-    return sharp(fixtures.inputJpg)
+  it('should be able to saturate', async () => {
+    const [r, g, b] = await sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 3,
+        background: { r: 153, g: 68, b: 68 }
+      }
+    })
       .modulate({ saturation: 2 })
-      .toFile(actual)
-      .then(function () {
-        fixtures.assertMaxColourDistance(actual, expected, 30);
-      });
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual({ r: 198, g: 0, b: 43 }, { r, g, b });
   });
 
-  it('should be able to desaturate', function () {
-    const base = 'modulate-saturation-0.5.jpg';
-    const actual = fixtures.path('output.' + base);
-    const expected = fixtures.expected(base);
-
-    return sharp(fixtures.inputJpg)
+  it('should be able to desaturate', async () => {
+    const [r, g, b] = await sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 3,
+        background: { r: 153, g: 68, b: 68 }
+      }
+    })
       .modulate({ saturation: 0.5 })
-      .toFile(actual)
-      .then(function () {
-        fixtures.assertMaxColourDistance(actual, expected, 25);
-      });
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual({ r: 127, g: 83, b: 81 }, { r, g, b });
   });
 
-  it('should be able to modulate all channels', function () {
-    const base = 'modulate-all.jpg';
-    const actual = fixtures.path('output.' + base);
-    const expected = fixtures.expected(base);
-
-    return sharp(fixtures.inputJpg)
+  it('should be able to modulate all channels', async () => {
+    const [r, g, b] = await sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 3,
+        background: { r: 153, g: 68, b: 68 }
+      }
+    })
       .modulate({ brightness: 2, saturation: 0.5, hue: 180 })
-      .toFile(actual)
-      .then(function () {
-        fixtures.assertMaxColourDistance(actual, expected, 25);
-      });
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual({ r: 149, g: 209, b: 214 }, { r, g, b });
   });
 
-  describe('hue-rotate', function (done) {
-    [30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330, 360].forEach(function (angle) {
-      it('should properly hue rotate by ' + angle + 'deg', function () {
-        const base = 'modulate-hue-angle-' + angle + '.png';
-        const actual = fixtures.path('output.' + base);
+  it('should be able to use linear and modulate together', async () => {
+    const contrast = 1.5;
+    const brightness = 0.5;
+
+    const [r, g, b] = await sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 3,
+        background: { r: 153, g: 68, b: 68 }
+      }
+    })
+      .linear(contrast, -(128 * contrast) + 128)
+      .modulate({ brightness })
+      .raw()
+      .toBuffer();
+
+    assert.deepStrictEqual({ r: 81, g: 0, b: 0 }, { r, g, b });
+  });
+
+  describe('hue-rotate', () => {
+    [30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330, 360].forEach(angle => {
+      it(`should hue rotate by ${angle} deg`, async () => {
+        const base = `modulate-hue-angle-${angle}.png`;
+        const actual = fixtures.path(`output.${base}`);
         const expected = fixtures.expected(base);
 
-        return sharp(fixtures.testPattern)
+        await sharp(fixtures.testPattern)
+          .resize(320)
           .modulate({ hue: angle })
+          .png({ compressionLevel: 0 })
           .toFile(actual)
-          .then(function () {
-            fixtures.assertMaxColourDistance(actual, expected, 25);
+          .then(() => {
+            fixtures.assertMaxColourDistance(actual, expected);
           });
       });
     });
   });
-
-  it('should be able to use linear and modulate together', function () {
-    const base = 'modulate-linear.jpg';
-    const actual = fixtures.path('output.' + base);
-    const expected = fixtures.expected(base);
-
-    const contrast = 1.5;
-    const brightness = 0.5;
-
-    return sharp(fixtures.testPattern)
-      .linear(contrast, -(128 * contrast) + 128)
-      .modulate({ brightness })
-      .toFile(actual)
-      .then(function () {
-        fixtures.assertMaxColourDistance(actual, expected);
-      });
-  });
 });

test/unit/noise.js

@@ -0,0 +1,258 @@
+'use strict';
+
+const assert = require('assert');
+
+const sharp = require('../../');
+const fixtures = require('../fixtures');
+
+describe('Gaussian noise', function () {
+  it('generate single-channel gaussian noise', function (done) {
+    const output = fixtures.path('output.noise-1-channel.png');
+    const noise = sharp({
+      create: {
+        width: 1024,
+        height: 768,
+        channels: 1, // b-w
+        noise: {
+          type: 'gaussian',
+          mean: 128,
+          sigma: 30
+        }
+      }
+    });
+    noise.toFile(output, function (err, info) {
+      if (err) throw err;
+      assert.strictEqual('png', info.format);
+      assert.strictEqual(1024, info.width);
+      assert.strictEqual(768, info.height);
+      assert.strictEqual(1, info.channels);
+      sharp(output).metadata(function (err, metadata) {
+        if (err) throw err;
+        assert.strictEqual('b-w', metadata.space);
+        assert.strictEqual('uchar', metadata.depth);
+        done();
+      });
+    });
+  });
+
+  it('generate 3-channels gaussian noise', function (done) {
+    const output = fixtures.path('output.noise-3-channels.png');
+    const noise = sharp({
+      create: {
+        width: 1024,
+        height: 768,
+        channels: 3, // sRGB
+        noise: {
+          type: 'gaussian',
+          mean: 128,
+          sigma: 30
+        }
+      }
+    });
+    noise.toFile(output, function (err, info) {
+      if (err) throw err;
+      assert.strictEqual('png', info.format);
+      assert.strictEqual(1024, info.width);
+      assert.strictEqual(768, info.height);
+      assert.strictEqual(3, info.channels);
+      sharp(output).metadata(function (err, metadata) {
+        if (err) throw err;
+        assert.strictEqual('srgb', metadata.space);
+        assert.strictEqual('uchar', metadata.depth);
+        done();
+      });
+    });
+  });
+
+  it('overlay 3-channels gaussian noise over image', function (done) {
+    const output = fixtures.path('output.noise-image.jpg');
+    const noise = sharp({
+      create: {
+        width: 320,
+        height: 240,
+        channels: 3,
+        noise: {
+          type: 'gaussian',
+          mean: 0,
+          sigma: 5
+        }
+      }
+    });
+    noise.toBuffer(function (err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(3, info.channels);
+      sharp(fixtures.inputJpg)
+        .resize(320, 240)
+        .composite([
+          {
+            input: data,
+            blend: 'exclusion',
+            raw: {
+              width: info.width,
+              height: info.height,
+              channels: info.channels
+            }
+          }
+        ])
+        .toFile(output, function (err, info) {
+          if (err) throw err;
+          assert.strictEqual('jpeg', info.format);
+          assert.strictEqual(320, info.width);
+          assert.strictEqual(240, info.height);
+          assert.strictEqual(3, info.channels);
+          // perceptual hashing detects that images are the same (difference is <=1%)
+          fixtures.assertSimilar(output, fixtures.inputJpg, function (err) {
+            if (err) throw err;
+            done();
+          });
+        });
+    });
+  });
+
+  it('overlay strong single-channel (sRGB) gaussian noise with 25% transparency over transparent png image', function (done) {
+    const output = fixtures.path('output.noise-image-transparent.png');
+    const width = 320;
+    const height = 240;
+    const rawData = {
+      width,
+      height,
+      channels: 1
+    };
+    const noise = sharp({
+      create: {
+        width,
+        height,
+        channels: 1,
+        noise: {
+          type: 'gaussian',
+          mean: 200,
+          sigma: 30
+        }
+      }
+    });
+    noise
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(1, info.channels);
+        sharp(data, { raw: rawData })
+          .joinChannel(data, { raw: rawData }) // r channel
+          .joinChannel(data, { raw: rawData }) // b channel
+          .joinChannel(Buffer.alloc(width * height, 64), { raw: rawData }) // alpha channel
+          .toBuffer(function (err, data, info) {
+            if (err) throw err;
+            assert.strictEqual(4, info.channels);
+            sharp(fixtures.inputPngRGBWithAlpha)
+              .resize(width, height)
+              .composite([
+                {
+                  input: data,
+                  blend: 'exclusion',
+                  raw: {
+                    width: info.width,
+                    height: info.height,
+                    channels: info.channels
+                  }
+                }
+              ])
+              .toFile(output, function (err, info) {
+                if (err) throw err;
+                assert.strictEqual('png', info.format);
+                assert.strictEqual(width, info.width);
+                assert.strictEqual(height, info.height);
+                assert.strictEqual(4, info.channels);
+                fixtures.assertSimilar(output, fixtures.inputPngRGBWithAlpha, { threshold: 10 }, function (err) {
+                  if (err) throw err;
+                  done();
+                });
+              });
+          });
+      });
+  });
+
+  it('no create object properties specified', function () {
+    assert.throws(function () {
+      sharp({
+        create: {}
+      });
+    });
+  });
+
+  it('invalid noise object', function () {
+    assert.throws(function () {
+      sharp({
+        create: {
+          width: 100,
+          height: 100,
+          channels: 3,
+          noise: 'gaussian'
+        }
+      });
+    });
+  });
+
+  it('unknown type of noise', function () {
+    assert.throws(function () {
+      sharp({
+        create: {
+          width: 100,
+          height: 100,
+          channels: 3,
+          noise: {
+            type: 'unknown'
+          }
+        }
+      });
+    });
+  });
+
+  it('gaussian noise, invalid amount of channels', function () {
+    assert.throws(function () {
+      sharp({
+        create: {
+          width: 100,
+          height: 100,
+          channels: 5,
+          noise: {
+            type: 'gaussian',
+            mean: 5,
+            sigma: 10
+          }
+        }
+      });
+    });
+  });
+
+  it('gaussian noise, invalid mean', function () {
+    assert.throws(function () {
+      sharp({
+        create: {
+          width: 100,
+          height: 100,
+          channels: 1,
+          noise: {
+            type: 'gaussian',
+            mean: -1.5,
+            sigma: 10
+          }
+        }
+      });
+    });
+  });
+
+  it('gaussian noise, invalid sigma', function () {
+    assert.throws(function () {
+      sharp({
+        create: {
+          width: 100,
+          height: 100,
+          channels: 1,
+          noise: {
+            type: 'gaussian',
+            mean: 0,
+            sigma: -1.5
+          }
+        }
+      });
+    });
+  });
+});

test/unit/normalize.js

@@ -54,6 +54,7 @@ describe('Normalization', function () {
 
   it('keeps an existing alpha channel', function (done) {
     sharp(fixtures.inputPngWithTransparency)
+      .resize(8, 8)
       .normalize()
       .toBuffer(function (err, data) {
         if (err) throw err;
@@ -69,6 +70,7 @@ describe('Normalization', function () {
 
   it('keeps the alpha channel of greyscale images intact', function (done) {
     sharp(fixtures.inputPngWithGreyAlpha)
+      .resize(8, 8)
       .normalise()
       .toBuffer(function (err, data) {
         if (err) throw err;

test/unit/png.js

@@ -19,7 +19,7 @@ describe('PNG', function () {
     });
   });
 
-  it('default compressionLevel generates smaller file than compressionLevel=6', function (done) {
+  it('default compressionLevel generates smaller file than compressionLevel=0', function (done) {
     // First generate with default compressionLevel
     sharp(fixtures.inputPng)
       .resize(320, 240)
@@ -31,7 +31,7 @@ describe('PNG', function () {
         // Then generate with compressionLevel=6
         sharp(fixtures.inputPng)
           .resize(320, 240)
-          .png({ compressionLevel: 6 })
+          .png({ compressionLevel: 0 })
           .toBuffer(function (err, largerData, largerInfo) {
             if (err) throw err;
             assert.strictEqual(true, largerData.length > 0);

test/unit/recomb.js

@@ -5,15 +5,17 @@ const assert = require('assert');
 const sharp = require('../../');
 const fixtures = require('../fixtures');
 
+const sepia = [
+  [0.3588, 0.7044, 0.1368],
+  [0.299, 0.587, 0.114],
+  [0.2392, 0.4696, 0.0912]
+];
+
 describe('Recomb', function () {
   it('applies a sepia filter using recomb', function (done) {
     const output = fixtures.path('output.recomb-sepia.jpg');
     sharp(fixtures.inputJpgWithLandscapeExif1)
-      .recomb([
-        [0.3588, 0.7044, 0.1368],
-        [0.299, 0.587, 0.114],
-        [0.2392, 0.4696, 0.0912]
-      ])
+      .recomb(sepia)
       .toFile(output, function (err, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);
@@ -31,11 +33,7 @@ describe('Recomb', function () {
   it('applies a sepia filter using recomb to an PNG with Alpha', function (done) {
     const output = fixtures.path('output.recomb-sepia.png');
     sharp(fixtures.inputPngAlphaPremultiplicationSmall)
-      .recomb([
-        [0.3588, 0.7044, 0.1368],
-        [0.299, 0.587, 0.114],
-        [0.2392, 0.4696, 0.0912]
-      ])
+      .recomb(sepia)
       .toFile(output, function (err, info) {
         if (err) throw err;
         assert.strictEqual('png', info.format);
@@ -50,6 +48,20 @@ describe('Recomb', function () {
       });
   });
 
+  it('recomb with a single channel input', async () => {
+    const { info } = await sharp(Buffer.alloc(64), {
+      raw: {
+        width: 8,
+        height: 8,
+        channels: 1
+      }
+    })
+      .recomb(sepia)
+      .toBuffer({ resolveWithObject: true });
+
+    assert.strictEqual(3, info.channels);
+  });
+
   it('applies a different sepia filter using recomb', function (done) {
     const output = fixtures.path('output.recomb-sepia2.jpg');
     sharp(fixtures.inputJpgWithLandscapeExif1)

test/unit/svg.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const fs = require('fs');
 const assert = require('assert');
 
 const sharp = require('../../');
@@ -99,4 +100,18 @@ describe('SVG input', function () {
         fixtures.assertSimilar(fixtures.expected('svg-embedded.png'), data, done);
       });
   });
+
+  it('Converts SVG with truncated embedded PNG', async () => {
+    const truncatedPng = fs.readFileSync(fixtures.inputPngTruncated).toString('base64');
+    const svg = `<?xml version="1.0" encoding="UTF-8"?>
+      <svg width="294" height="240" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+        <image width="294" height="240" xlink:href="data:image/png;base64,${truncatedPng}"/>
+      </svg>`;
+
+    const { info } = await sharp(Buffer.from(svg)).toBuffer({ resolveWithObject: true });
+    assert.strictEqual(info.format, 'png');
+    assert.strictEqual(info.width, 294);
+    assert.strictEqual(info.height, 240);
+    assert.strictEqual(info.channels, 4);
+  });
 });

test/unit/tiff.js

@@ -8,6 +8,8 @@ const rimraf = require('rimraf');
 const sharp = require('../../');
 const fixtures = require('../fixtures');
 
+const outputTiff = fixtures.path('output.tiff');
+
 describe('TIFF', function () {
   it('Load TIFF from Buffer', function (done) {
     const inputTiffBuffer = fs.readFileSync(fixtures.inputTiff);
@@ -88,9 +90,11 @@ describe('TIFF', function () {
 
   it('Increasing TIFF quality increases file size', () =>
     sharp(fixtures.inputJpgWithLandscapeExif1)
+      .resize(320, 240)
       .tiff({ quality: 40 })
       .toBuffer()
       .then(tiff40 => sharp(fixtures.inputJpgWithLandscapeExif1)
+        .resize(320, 240)
         .tiff({ quality: 90 })
         .toBuffer()
         .then(tiff90 =>
@@ -120,11 +124,11 @@ describe('TIFF', function () {
         compression: 'none',
         predictor: 'none'
       })
-      .toFile(fixtures.outputTiff, (err, info) => {
+      .toFile(outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
         assert.strictEqual(startSize, info.size);
-        rimraf(fixtures.outputTiff, done);
+        rimraf(outputTiff, done);
       });
   });
 
@@ -137,11 +141,11 @@ describe('TIFF', function () {
         compression: 'none',
         predictor: 'none'
       })
-      .toFile(fixtures.outputTiff, (err, info) => {
+      .toFile(outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
         assert(info.size < (startSize / 2));
-        rimraf(fixtures.outputTiff, done);
+        rimraf(outputTiff, done);
       });
   });
 
@@ -153,22 +157,24 @@ describe('TIFF', function () {
 
   it('TIFF setting xres and yres on file', () =>
     sharp(fixtures.inputTiff)
+      .resize(8, 8)
       .tiff({
         xres: 1000,
         yres: 1000
       })
-      .toFile(fixtures.outputTiff)
-      .then(() => sharp(fixtures.outputTiff)
+      .toFile(outputTiff)
+      .then(() => sharp(outputTiff)
         .metadata()
         .then(({ density }) => {
           assert.strictEqual(25400, density);
-          return promisify(rimraf)(fixtures.outputTiff);
+          return promisify(rimraf)(outputTiff);
         })
       )
   );
 
   it('TIFF setting xres and yres on buffer', () =>
     sharp(fixtures.inputTiff)
+      .resize(8, 8)
       .tiff({
         xres: 1000,
         yres: 1000
@@ -201,12 +207,12 @@ describe('TIFF', function () {
         compression: 'lzw',
         predictor: 'horizontal'
       })
-      .toFile(fixtures.outputTiff, (err, info) => {
+      .toFile(outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
         assert.strictEqual(3, info.channels);
         assert(info.size < startSize);
-        rimraf(fixtures.outputTiff, done);
+        rimraf(outputTiff, done);
       });
   });
 
@@ -222,7 +228,7 @@ describe('TIFF', function () {
       .tiff({
         compression: 'lzw'
       })
-      .toFile(fixtures.outputTiff)
+      .toFile(outputTiff)
       .then(info => {
         assert.strictEqual(4, info.channels);
       })
@@ -254,11 +260,11 @@ describe('TIFF', function () {
         bitdepth: 1,
         compression: 'ccittfax4'
       })
-      .toFile(fixtures.outputTiff, (err, info) => {
+      .toFile(outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
         assert(info.size < startSize);
-        rimraf(fixtures.outputTiff, done);
+        rimraf(outputTiff, done);
       });
   });
 
@@ -269,11 +275,11 @@ describe('TIFF', function () {
         compression: 'deflate',
         predictor: 'horizontal'
       })
-      .toFile(fixtures.outputTiff, (err, info) => {
+      .toFile(outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
         assert(info.size < startSize);
-        rimraf(fixtures.outputTiff, done);
+        rimraf(outputTiff, done);
       });
   });
 
@@ -284,11 +290,11 @@ describe('TIFF', function () {
         compression: 'deflate',
         predictor: 'float'
       })
-      .toFile(fixtures.outputTiff, (err, info) => {
+      .toFile(outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
-        assert(info.size < startSize);
-        rimraf(fixtures.outputTiff, done);
+        assert(startSize > info.size);
+        rimraf(outputTiff, done);
       });
   });
 
@@ -299,11 +305,11 @@ describe('TIFF', function () {
         compression: 'deflate',
         predictor: 'none'
       })
-      .toFile(fixtures.outputTiff, (err, info) => {
+      .toFile(outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
         assert(info.size < startSize);
-        rimraf(fixtures.outputTiff, done);
+        rimraf(outputTiff, done);
       });
   });
 
@@ -313,11 +319,11 @@ describe('TIFF', function () {
       .tiff({
         compression: 'jpeg'
       })
-      .toFile(fixtures.outputTiff, (err, info) => {
+      .toFile(outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
         assert(info.size < startSize);
-        rimraf(fixtures.outputTiff, done);
+        rimraf(outputTiff, done);
       });
   });
 
@@ -385,11 +391,11 @@ describe('TIFF', function () {
         tileHeight: 256,
         tileWidth: 256
       })
-      .toFile(fixtures.outputTiff, (err, info) => {
+      .toFile(outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
         assert(info.size > startSize);
-        rimraf(fixtures.outputTiff, done);
+        rimraf(outputTiff, done);
       });
   });
 

test/unit/tile.js

@@ -297,6 +297,22 @@ describe('Tile', function () {
     });
   });
 
+  it('Valid id parameter value passes', function () {
+    assert.doesNotThrow(function () {
+      sharp().tile({
+        id: 'test'
+      });
+    });
+  });
+
+  it('Invalid id parameter value fails', function () {
+    assert.throws(function () {
+      sharp().tile({
+        id: true
+      });
+    });
+  });
+
   it('Deep Zoom layout', function (done) {
     const directory = fixtures.path('output.dzi_files');
     rimraf(directory, function () {
@@ -613,7 +629,7 @@ describe('Tile', function () {
     rimraf(directory, function () {
       sharp(fixtures.inputJpg)
         .png({
-          compressionLevel: 1
+          compressionLevel: 0
         })
         .tile({
           layout: 'google'
@@ -650,7 +666,8 @@ describe('Tile', function () {
     rimraf(directory, function () {
       sharp(fixtures.inputJpg)
         .webp({
-          quality: 1
+          quality: 1,
+          reductionEffort: 0
         })
         .tile({
           layout: 'google'
@@ -814,11 +831,14 @@ describe('Tile', function () {
   });
 
   it('IIIF layout', function (done) {
-    const directory = fixtures.path('output.iiif.info');
+    const name = 'output.iiif.info';
+    const directory = fixtures.path(name);
     rimraf(directory, function () {
+      const id = 'https://sharp.test.com/iiif';
       sharp(fixtures.inputJpg)
         .tile({
-          layout: 'iiif'
+          layout: 'iiif',
+          id
         })
         .toFile(directory, function (err, info) {
           if (err) throw err;
@@ -827,6 +847,8 @@ describe('Tile', function () {
           assert.strictEqual(2225, info.height);
           assert.strictEqual(3, info.channels);
           assert.strictEqual('number', typeof info.size);
+          const infoJson = require(path.join(directory, 'info.json'));
+          assert.strictEqual(`${id}/${name}`, infoJson['@id']);
           fs.stat(path.join(directory, '0,0,256,256', '256,', '0', 'default.jpg'), function (err, stat) {
             if (err) throw err;
             assert.strictEqual(true, stat.isFile());

test/unit/toBuffer.js

@@ -6,22 +6,19 @@ const sharp = require('../../');
 const fixtures = require('../fixtures');
 
 describe('toBuffer', () => {
-  it('reusing same sharp object does not reset previously passed parameters to toBuffer', (done) => {
+  it('reusing same sharp object does not reset previously passed parameters to toBuffer', async () => {
     const image = sharp(fixtures.inputJpg);
-    image.toBuffer({ resolveWithObject: true }).then((obj) => {
-      image.toBuffer().then((buff) => {
-        assert.strictEqual(Buffer.isBuffer(buff), true);
-        assert.strictEqual(typeof obj, 'object');
-        done();
-      });
-    });
+    const obj = await image.toBuffer({ resolveWithObject: true });
+    assert.strictEqual(typeof obj, 'object');
+    assert.strictEqual(typeof obj.info, 'object');
+    assert.strictEqual(Buffer.isBuffer(obj.data), true);
+    const data = await image.toBuffer();
+    assert.strictEqual(Buffer.isBuffer(data), true);
   });
 
-  it('correctly process animated webp with height > 16383', (done) => {
-    const image = sharp(fixtures.inputWebPAnimatedBigHeight, { animated: true });
-    image.toBuffer().then((buff) => {
-      assert.strictEqual(Buffer.isBuffer(buff), true);
-      done();
-    });
+  it('correctly process animated webp with height > 16383', async () => {
+    const data = await sharp(fixtures.inputWebPAnimatedBigHeight, { animated: true })
+      .toBuffer();
+    assert.strictEqual(Buffer.isBuffer(data), true);
   });
 });

test/unit/toFormat.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const assert = require('assert');
+const sharp = require('../../');
+const fixtures = require('../fixtures');
+
+describe('toFormat', () => {
+  it('accepts upper case characters as format parameter (string)', async () => {
+    const data = await sharp(fixtures.inputJpg)
+      .resize(8, 8)
+      .toFormat('PNG')
+      .toBuffer();
+
+    const { format } = await sharp(data).metadata();
+    assert.strictEqual(format, 'png');
+  });
+
+  it('accepts upper case characters as format parameter (object)', async () => {
+    const data = await sharp(fixtures.inputJpg)
+      .resize(8, 8)
+      .toFormat({ id: 'PNG' })
+      .toBuffer();
+
+    const { format } = await sharp(data).metadata();
+    assert.strictEqual(format, 'png');
+  });
+});

test/unit/util.js

@@ -3,8 +3,6 @@
 const assert = require('assert');
 const sharp = require('../../');
 
-const defaultConcurrency = sharp.concurrency();
-
 describe('Utilities', function () {
   describe('Cache', function () {
     it('Can be disabled', function () {
@@ -60,10 +58,10 @@ describe('Utilities', function () {
     });
     it('Can be reset to default', function () {
       sharp.concurrency(0);
-      assert.strictEqual(defaultConcurrency, sharp.concurrency());
+      assert.strictEqual(true, sharp.concurrency() > 0);
     });
     it('Ignores invalid values', function () {
-      sharp.concurrency(0);
+      const defaultConcurrency = sharp.concurrency();
       sharp.concurrency('spoons');
       assert.strictEqual(defaultConcurrency, sharp.concurrency());
     });