Release v0.22.0

background, crop, embed, ignoreAspectRatio, max, min, withoutEnlargement

.npmignore

@@ -8,6 +8,7 @@ test
 .travis.yml
 appveyor.yml
 mkdocs.yml
+docs/css/
 vendor
 .prebuildrc
 .nyc_output

.travis.yml

@@ -1,34 +1,79 @@
-language: node_js
 matrix:
   include:
-    - os: linux
-      dist: trusty
-      sudo: false
-      node_js: "4"
-    - os: linux
+    - name: "Linux (glibc) - Node 6"
+      os: linux
       dist: trusty
       sudo: false
+      language: node_js
       node_js: "6"
-    - os: linux
+    - name: "Linux (glibc) - Node 8"
+      os: linux
       dist: trusty
       sudo: false
+      language: node_js
       node_js: "8"
-    - os: linux
+    - name: "Linux (glibc) - Node 10"
+      os: linux
       dist: trusty
       sudo: false
+      language: node_js
       node_js: "10"
-    - os: osx
-      osx_image: xcode8.3
-      node_js: "4"
-    - os: osx
-      osx_image: xcode8.3
-      node_js: "6"
-    - os: osx
-      osx_image: xcode8.3
-      node_js: "8"
-    - os: osx
-      osx_image: xcode8.3
-      node_js: "10"
-after_success:
+      after_success:
         - npm install coveralls
         - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js
+    - name: "Linux (glibc) - Node 11"
+      os: linux
+      dist: trusty
+      sudo: false
+      language: node_js
+      node_js: "11"
+    - name: "Linux (musl) - Node 8"
+      os: linux
+      dist: trusty
+      sudo: true
+      language: minimal
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:8-alpine
+        - sudo docker exec sharp apk add build-base git python2 --update-cache
+      install: sudo docker exec sharp sh -c "npm install --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+    - name: "Linux (musl) - Node 10"
+      os: linux
+      dist: trusty
+      sudo: true
+      language: minimal
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:10-alpine
+        - sudo docker exec sharp apk add build-base git python2 --update-cache
+      install: sudo docker exec sharp sh -c "npm install --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+    - name: "Linux (musl) - Node 11"
+      os: linux
+      dist: trusty
+      sudo: true
+      language: minimal
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:11-alpine
+        - sudo docker exec sharp apk add build-base git python2 --update-cache
+      install: sudo docker exec sharp sh -c "npm install --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+    - name: "OS X - Node 6"
+      os: osx
+      osx_image: xcode9.2
+      language: node_js
+      node_js: "6"
+    - name: "OS X - Node 8"
+      os: osx
+      osx_image: xcode9.2
+      language: node_js
+      node_js: "8"
+    - name: "OS X - Node 10"
+      os: osx
+      osx_image: xcode9.2
+      language: node_js
+      node_js: "10"
+    - name: "OS X - Node 11"
+      os: osx
+      osx_image: xcode9.2
+      language: node_js
+      node_js: "11"

CONTRIBUTING.md

@@ -14,7 +14,7 @@ New bugs are assigned a `triage` label whilst under investigation.
 
 If a [similar request](https://github.com/lovell/sharp/labels/enhancement) exists, it's probably fastest to add a comment to it about your requirement.
 
-Implementation is usually straightforward if _libvips_ [already supports](https://jcupitt.github.io/libvips/API/current/) the feature you need.
+Implementation is usually straightforward if _libvips_ [already supports](https://libvips.github.io/libvips/API/current/) the feature you need.
 
 ## Submit a Pull Request to fix a bug
 
@@ -41,8 +41,8 @@ Any change that modifies the existing public API should be added to the relevant
 
 | Release | WIP branch |
 | ------: | :--------- |
-| v0.21.0 | teeth      |
 | v0.22.0 | uptake     |
+| v0.23.0 | vision     |
 
 Please squash your changes into a single commit using a command like `git rebase -i upstream/<wip-branch>`.
 

README.md

@@ -1,13 +1,11 @@
 # sharp
 
+<img src="https://raw.githubusercontent.com/lovell/sharp/master/docs/image/sharp-logo.svg?sanitize=true" width="160" height="160" alt="sharp logo" align="right">
+
 ```sh
 npm install sharp
 ```
 
-```sh
-yarn add sharp
-```
-
 The typical use case for this high speed Node.js module
 is to convert large images in common formats to
 smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
@@ -21,8 +19,8 @@ Lanczos resampling ensures quality is not sacrificed for speed.
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
 
-Most modern 64-bit OS X, Windows and Linux (glibc) systems running
-Node versions 4, 6, 8 and 10
+Most modern 64-bit OS X, Windows and Linux systems running
+Node versions 6, 8, 10 and 11
 do not require any additional install or runtime dependencies.
 
 ## Examples
@@ -31,31 +29,54 @@ do not require any additional install or runtime dependencies.
 const sharp = require('sharp');
 ```
 
+### Callback
+
 ```javascript
 sharp(inputBuffer)
   .resize(320, 240)
-  .toFile('output.webp', (err, info) => ... );
-  // A Promises/A+ promise is returned when callback is not provided.
+  .toFile('output.webp', (err, info) => { ... });
 ```
 
+### Promise
+
 ```javascript
 sharp('input.jpg')
   .rotate()
   .resize(200)
   .toBuffer()
-  .then( data => ... )
-  .catch( err => ... );
+  .then( data => { ... })
+  .catch( err => { ... });
 ```
 
+### Async/await
+
 ```javascript
-const roundedCorners = new Buffer(
+const semiTransparentRedPng = await sharp({
+  create: {
+    width: 48,
+    height: 48,
+    channels: 4,
+    background: { r: 255, g: 0, b: 0, alpha: 0.5 }
+  }
+})
+  .png()
+  .toBuffer();
+```
+
+### Stream
+
+```javascript
+const roundedCorners = Buffer.from(
   '<svg><rect x="0" y="0" width="200" height="200" rx="50" ry="50"/></svg>'
 );
 
 const roundedCornerResizer =
   sharp()
     .resize(200, 200)
-    .overlayWith(roundedCorners, { cutout: true })
+    .composite([{
+      input: roundedCorners,
+      blend: 'dest-in'
+    }])
     .png();
 
 readableStream
@@ -63,29 +84,29 @@ readableStream
   .pipe(writableStream);
 ```
 
-[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
+[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.svg?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
 
 ### Documentation
 
-Visit [sharp.pixelplumbing.com](http://sharp.pixelplumbing.com/) for complete
-[installation instructions](http://sharp.pixelplumbing.com/page/install),
-[API documentation](http://sharp.pixelplumbing.com/page/api),
-[benchmark tests](http://sharp.pixelplumbing.com/page/performance) and
-[changelog](http://sharp.pixelplumbing.com/page/changelog).
+Visit [sharp.pixelplumbing.com](https://sharp.pixelplumbing.com/) for complete
+[installation instructions](https://sharp.pixelplumbing.com/page/install),
+[API documentation](https://sharp.pixelplumbing.com/page/api),
+[benchmark tests](https://sharp.pixelplumbing.com/page/performance) and
+[changelog](https://sharp.pixelplumbing.com/page/changelog).
 
 ### Contributing
 
 A [guide for contributors](https://github.com/lovell/sharp/blob/master/CONTRIBUTING.md)
 covers reporting bugs, requesting features and submitting code changes.
 
-### Licence
+### Licensing
 
-Copyright 2013, 2014, 2015, 2016, 2017, 2018 Lovell Fuller and contributors.
+Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
 You may obtain a copy of the License at
-[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
+[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,

appveyor.yml

@@ -4,10 +4,10 @@ build: off
 platform: x64
 environment:
   matrix:
-  - nodejs_version: "4"
   - nodejs_version: "6"
   - nodejs_version: "8"
   - nodejs_version: "10"
+  - nodejs_version: "11"
 install:
   - ps: Install-Product node $env:nodejs_version x64
   - npm install -g npm@5

binding.gyp

@@ -128,9 +128,11 @@
               '../vendor/lib/libcairo.so',
               '../vendor/lib/libcroco-0.6.so',
               '../vendor/lib/libexif.so',
+              '../vendor/lib/libexpat.so',
               '../vendor/lib/libffi.so',
               '../vendor/lib/libfontconfig.so',
               '../vendor/lib/libfreetype.so',
+              '../vendor/lib/libfribidi.so',
               '../vendor/lib/libgdk_pixbuf-2.0.so',
               '../vendor/lib/libgif.so',
               '../vendor/lib/libgio-2.0.so',
@@ -149,6 +151,8 @@
               '../vendor/lib/librsvg-2.so',
               '../vendor/lib/libtiff.so',
               '../vendor/lib/libwebp.so',
+              '../vendor/lib/libwebpdemux.so',
+              '../vendor/lib/libwebpmux.so',
               '../vendor/lib/libxml2.so',
               '../vendor/lib/libz.so',
               # Ensure runtime linking is relative to sharp.node
@@ -178,13 +182,23 @@
     },
     'configurations': {
       'Release': {
+        'cflags_cc': [
+          '-Wno-cast-function-type',
+          '-Wno-deprecated-declarations'
+        ],
+        'xcode_settings': {
+          'OTHER_CPLUSPLUSFLAGS': [
+            '-Wno-deprecated-declarations'
+          ]
+        },
         'msvs_settings': {
           'VCCLCompilerTool': {
             'ExceptionHandling': 1
           }
         },
         'msvs_disabled_warnings': [
-          4275
+          4275,
+          4996
         ]
       }
     },

docs/api-channel.md

@@ -1,20 +1,46 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-### Table of Contents
+## removeAlpha
 
--   [extractChannel][1]
--   [joinChannel][2]
--   [bandbool][3]
+Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel.
+
+### Examples
+
+```javascript
+sharp('rgba.png')
+  .removeAlpha()
+  .toFile('rgb.png', function(err, info) {
+    // rgb.png is a 3 channel image without an alpha channel
+  });
+```
+
+Returns **Sharp** 
+
+## ensureAlpha
+
+Ensure alpha channel, if missing. The added alpha channel will be fully opaque. This is a no-op if the image already has an alpha channel.
+
+### Examples
+
+```javascript
+sharp('rgb.jpg')
+  .ensureAlpha()
+  .toFile('rgba.png', function(err, info) {
+    // rgba.png is a 4 channel image with a fully opaque alpha channel
+  });
+```
+
+Returns **Sharp** 
 
 ## extractChannel
 
 Extract a single channel from a multi-channel image.
 
-**Parameters**
+### Parameters
 
--   `channel` **([Number][4] \| [String][5])** zero-indexed band number to extract, or `red`, `green` or `blue` as alternative to `0`, `1` or `2` respectively.
+-   `channel` **([Number][1] \| [String][2])** zero-indexed band number to extract, or `red`, `green` or `blue` as alternative to `0`, `1` or `2` respectively.
 
-**Examples**
+### Examples
 
 ```javascript
 sharp(input)
@@ -25,7 +51,7 @@ sharp(input)
    });
 ```
 
--   Throws **[Error][6]** Invalid channel
+-   Throws **[Error][3]** Invalid channel
 
 Returns **Sharp** 
 
@@ -42,13 +68,13 @@ Channel ordering follows vips convention:
 Buffers may be any of the image formats supported by sharp: JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data.
 For raw pixel input, the `options` object should contain a `raw` attribute, which follows the format of the attribute of the same name in the `sharp()` constructor.
 
-**Parameters**
+### Parameters
 
--   `images` **([Array][7]&lt;([String][5] \| [Buffer][8])> | [String][5] \| [Buffer][8])** one or more images (file paths, Buffers).
--   `options` **[Object][9]** image options, see `sharp()` constructor.
+-   `images` **([Array][4]&lt;([String][2] \| [Buffer][5])> | [String][2] \| [Buffer][5])** one or more images (file paths, Buffers).
+-   `options` **[Object][6]** image options, see `sharp()` constructor.
 
 
--   Throws **[Error][6]** Invalid parameters
+-   Throws **[Error][3]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -56,11 +82,11 @@ Returns **Sharp**
 
 Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
 
-**Parameters**
+### Parameters
 
--   `boolOp` **[String][5]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
+-   `boolOp` **[String][2]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
 
-**Examples**
+### Examples
 
 ```javascript
 sharp('3-channel-rgb-input.png')
@@ -72,24 +98,18 @@ sharp('3-channel-rgb-input.png')
   });
 ```
 
--   Throws **[Error][6]** Invalid parameters
+-   Throws **[Error][3]** Invalid parameters
 
 Returns **Sharp** 
 
-[1]: #extractchannel
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
-[2]: #joinchannel
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
-[3]: #bandbool
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
 
-[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
 
-[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[5]: https://nodejs.org/api/buffer.html
 
-[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
-
-[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
-
-[8]: https://nodejs.org/api/buffer.html
-
-[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object

docs/api-colour.md

@@ -1,43 +1,16 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-### Table of Contents
-
--   [background][1]
--   [tint][2]
--   [greyscale][3]
--   [grayscale][4]
--   [toColourspace][5]
--   [toColorspace][6]
-
-## background
-
-Set the background for the `embed`, `flatten` and `extend` operations.
-The default background is `{r: 0, g: 0, b: 0, alpha: 1}`, black without transparency.
-
-Delegates to the _color_ module, which can throw an Error
-but is liberal in what it accepts, clipping values to sensible min/max.
-The alpha value is a float between `0` (transparent) and `1` (opaque).
-
-**Parameters**
-
--   `rgba` **([String][7] \| [Object][8])** parsed by the [color][9] module to extract values for red, green, blue and alpha.
-
-
--   Throws **[Error][10]** Invalid parameter
-
-Returns **Sharp** 
-
 ## tint
 
 Tint the image using the provided chroma while preserving the image luminance.
 An alpha channel may be present and will be unchanged by the operation.
 
-**Parameters**
+### Parameters
 
--   `rgb` **([String][7] \| [Object][8])** parsed by the [color][9] module to extract chroma values.
+-   `rgb` **([String][1] \| [Object][2])** parsed by the [color][3] module to extract chroma values.
 
 
--   Throws **[Error][10]** Invalid parameter
+-   Throws **[Error][4]** Invalid parameter
 
 Returns **Sharp** 
 
@@ -50,9 +23,9 @@ This may be overridden by other sharp operations such as `toColourspace('b-w')`,
 which will produce an output image containing one color channel.
 An alpha channel may be present, and will be unchanged by the operation.
 
-**Parameters**
+### Parameters
 
--   `greyscale` **[Boolean][11]**  (optional, default `true`)
+-   `greyscale` **[Boolean][5]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -60,9 +33,9 @@ Returns **Sharp**
 
 Alternative spelling of `greyscale`.
 
-**Parameters**
+### Parameters
 
--   `grayscale` **[Boolean][11]**  (optional, default `true`)
+-   `grayscale` **[Boolean][5]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -71,12 +44,12 @@ Returns **Sharp**
 Set the output colourspace.
 By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
 
-**Parameters**
+### Parameters
 
--   `colourspace` **[String][7]?** output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][12]
+-   `colourspace` **[String][1]?** output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][6]
 
 
--   Throws **[Error][10]** Invalid parameters
+-   Throws **[Error][4]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -84,35 +57,23 @@ Returns **Sharp**
 
 Alternative spelling of `toColourspace`.
 
-**Parameters**
+### Parameters
 
--   `colorspace` **[String][7]?** output colorspace.
+-   `colorspace` **[String][1]?** output colorspace.
 
 
--   Throws **[Error][10]** Invalid parameters
+-   Throws **[Error][4]** Invalid parameters
 
 Returns **Sharp** 
 
-[1]: #background
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
-[2]: #tint
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[3]: #greyscale
+[3]: https://www.npmjs.org/package/color
 
-[4]: #grayscale
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
 
-[5]: #tocolourspace
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[6]: #tocolorspace
-
-[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
-
-[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
-
-[9]: https://www.npmjs.org/package/color
-
-[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
-
-[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-
-[12]: https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568
+[6]: https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568

docs/api-composite.md

@@ -1,51 +1,53 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-### Table of Contents
+## composite
 
--   [overlayWith][1]
+Composite image(s) over the processed (resized, extracted etc.) image.
 
-## overlayWith
-
-Overlay (composite) an image over the processed (resized, extracted etc.) image.
-
-The overlay image must be the same size or smaller than the processed image.
+The images to composite must be the same size or smaller than the processed image.
 If both `top` and `left` options are provided, they take precedence over `gravity`.
 
-If the overlay image contains an alpha channel then composition with premultiplication will occur.
+The `blend` option can be one of `clear`, `source`, `over`, `in`, `out`, `atop`,
+`dest`, `dest-over`, `dest-in`, `dest-out`, `dest-atop`,
+`xor`, `add`, `saturate`, `multiply`, `screen`, `overlay`, `darken`, `lighten`,
+`colour-dodge`, `color-dodge`, `colour-burn`,`color-burn`,
+`hard-light`, `soft-light`, `difference`, `exclusion`.
 
-**Parameters**
+More information about blend modes can be found at
+[https://libvips.github.io/libvips/API/current/libvips-conversion.html#VipsBlendMode][1]
+and [https://www.cairographics.org/operators/][2]
 
--   `overlay` **([Buffer][2] \| [String][3])** Buffer containing image data or String containing the path to an image file.
--   `options` **[Object][4]?** 
-    -   `options.gravity` **[String][3]** gravity at which to place the overlay. (optional, default `'centre'`)
-    -   `options.top` **[Number][5]?** the pixel offset from the top edge.
-    -   `options.left` **[Number][5]?** the pixel offset from the left edge.
-    -   `options.tile` **[Boolean][6]** set to true to repeat the overlay image across the entire image with the given `gravity`. (optional, default `false`)
-    -   `options.cutout` **[Boolean][6]** set to true to apply only the alpha channel of the overlay image to the input image, giving the appearance of one image being cut out of another. (optional, default `false`)
-    -   `options.density` **[Number][5]** integral number representing the DPI for vector overlay image. (optional, default `72`)
-    -   `options.raw` **[Object][4]?** describes overlay when using raw pixel data.
-        -   `options.raw.width` **[Number][5]?** 
-        -   `options.raw.height` **[Number][5]?** 
-        -   `options.raw.channels` **[Number][5]?** 
-    -   `options.create` **[Object][4]?** describes a blank overlay to be created.
-        -   `options.create.width` **[Number][5]?** 
-        -   `options.create.height` **[Number][5]?** 
-        -   `options.create.channels` **[Number][5]?** 3-4
-        -   `options.create.background` **([String][3] \| [Object][4])?** parsed by the [color][7] module to extract values for red, green, blue and alpha.
+### Parameters
 
-**Examples**
+-   `images` **[Array][3]&lt;[Object][4]>** Ordered list of images to composite
+    -   `images[].input` **([Buffer][5] \| [String][6])?** Buffer containing image data or String containing the path to an image file.
+    -   `images[].blend` **[String][6]** how to blend this image with the image below. (optional, default `'over'`)
+    -   `images[].gravity` **[String][6]** gravity at which to place the overlay. (optional, default `'centre'`)
+    -   `images[].top` **[Number][7]?** the pixel offset from the top edge.
+    -   `images[].left` **[Number][7]?** the pixel offset from the left edge.
+    -   `images[].tile` **[Boolean][8]** set to true to repeat the overlay image across the entire image with the given `gravity`. (optional, default `false`)
+    -   `images[].density` **[Number][7]** number representing the DPI for vector overlay image. (optional, default `72`)
+    -   `images[].raw` **[Object][4]?** describes overlay when using raw pixel data.
+        -   `images[].raw.width` **[Number][7]?** 
+        -   `images[].raw.height` **[Number][7]?** 
+        -   `images[].raw.channels` **[Number][7]?** 
+    -   `images[].create` **[Object][4]?** describes a blank overlay to be created.
+        -   `images[].create.width` **[Number][7]?** 
+        -   `images[].create.height` **[Number][7]?** 
+        -   `images[].create.channels` **[Number][7]?** 3-4
+        -   `images[].create.background` **([String][6] \| [Object][4])?** parsed by the [color][9] module to extract values for red, green, blue and alpha.
+
+### Examples
 
 ```javascript
 sharp('input.png')
   .rotate(180)
   .resize(300)
-  .flatten()
-  .background('#ff6600')
-  .overlayWith('overlay.png', { gravity: sharp.gravity.southeast } )
+  .flatten( { background: '#ff6600' } )
+  .composite([{ input: 'overlay.png', gravity: 'southeast' }])
   .sharpen()
   .withMetadata()
-  .quality(90)
-  .webp()
+  .webp( { quality: 90 } )
   .toBuffer()
   .then(function(outputBuffer) {
     // outputBuffer contains upside down, 300px wide, alpha channel flattened
@@ -54,22 +56,26 @@ sharp('input.png')
   });
 ```
 
--   Throws **[Error][8]** Invalid parameters
+-   Throws **[Error][10]** Invalid parameters
 
 Returns **Sharp** 
 
-[1]: #overlaywith
+[1]: https://libvips.github.io/libvips/API/current/libvips-conversion.html#VipsBlendMode
 
-[2]: https://nodejs.org/api/buffer.html
+[2]: https://www.cairographics.org/operators/
 
-[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
 
 [4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[5]: https://nodejs.org/api/buffer.html
 
-[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
-[7]: https://www.npmjs.org/package/color
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
-[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[9]: https://www.npmjs.org/package/color
+
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error

docs/api-constructor.md

@@ -1,37 +1,30 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-### Table of Contents
-
--   [Sharp][1]
-    -   [format][2]
-    -   [versions][3]
--   [queue][4]
-
 ## Sharp
 
-**Parameters**
+### Parameters
 
--   `input` **([Buffer][5] \| [String][6])?** if present, can be
+-   `input` **([Buffer][1] \| [String][2])?** if present, can be
      a Buffer containing JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data, or
      a String containing the path to an JPEG, PNG, WebP, GIF, SVG or TIFF image file.
      JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
--   `options` **[Object][7]?** if present, is an Object with optional attributes.
-    -   `options.failOnError` **[Boolean][8]** by default apply a "best effort"
-         to decode images, even if the data is corrupt or invalid. Set this flag to true
-         if you'd rather halt processing and raise an error when loading invalid images. (optional, default `false`)
-    -   `options.density` **[Number][9]** integral number representing the DPI for vector images. (optional, default `72`)
-    -   `options.page` **[Number][9]** page number to extract for multi-page input (GIF, TIFF) (optional, default `0`)
-    -   `options.raw` **[Object][7]?** describes raw pixel input image data. See `raw()` for pixel ordering.
-        -   `options.raw.width` **[Number][9]?** 
-        -   `options.raw.height` **[Number][9]?** 
-        -   `options.raw.channels` **[Number][9]?** 1-4
-    -   `options.create` **[Object][7]?** describes a new image to be created.
-        -   `options.create.width` **[Number][9]?** 
-        -   `options.create.height` **[Number][9]?** 
-        -   `options.create.channels` **[Number][9]?** 3-4
-        -   `options.create.background` **([String][6] \| [Object][7])?** parsed by the [color][10] module to extract values for red, green, blue and alpha.
+-   `options` **[Object][3]?** if present, is an Object with optional attributes.
+    -   `options.failOnError` **[Boolean][4]** 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.density` **[Number][5]** number representing the DPI for vector images. (optional, default `72`)
+    -   `options.pages` **[Number][5]** number of pages to extract for multi-page input (GIF, TIFF, PDF), use -1 for all pages. (optional, default `1`)
+    -   `options.page` **[Number][5]** page number to start extracting from for multi-page input (GIF, TIFF, PDF), zero based. (optional, default `0`)
+    -   `options.raw` **[Object][3]?** describes raw pixel input image data. See `raw()` for pixel ordering.
+        -   `options.raw.width` **[Number][5]?** 
+        -   `options.raw.height` **[Number][5]?** 
+        -   `options.raw.channels` **[Number][5]?** 1-4
+    -   `options.create` **[Object][3]?** describes a new image to be created.
+        -   `options.create.width` **[Number][5]?** 
+        -   `options.create.height` **[Number][5]?** 
+        -   `options.create.channels` **[Number][5]?** 3-4
+        -   `options.create.background` **([String][2] \| [Object][3])?** parsed by the [color][6] module to extract values for red, green, blue and alpha.
 
-**Examples**
+### Examples
 
 ```javascript
 sharp('input.jpg')
@@ -62,7 +55,7 @@ sharp({
     width: 300,
     height: 200,
     channels: 4,
-    background: { r: 255, g: 0, b: 0, alpha: 128 }
+    background: { r: 255, g: 0, b: 0, alpha: 0.5 }
   }
 })
 .png()
@@ -70,27 +63,27 @@ sharp({
 .then( ... );
 ```
 
--   Throws **[Error][11]** Invalid parameters
+-   Throws **[Error][7]** Invalid parameters
 
-Returns **[Sharp][12]** 
+Returns **[Sharp][8]** 
 
 ### format
 
 An Object containing nested boolean values representing the available input and output formats/methods.
 
-**Examples**
+#### Examples
 
 ```javascript
 console.log(sharp.format);
 ```
 
-Returns **[Object][7]** 
+Returns **[Object][3]** 
 
 ### versions
 
 An Object containing the version numbers of libvips and its dependencies.
 
-**Examples**
+#### Examples
 
 ```javascript
 console.log(sharp.versions);
@@ -103,7 +96,7 @@ An EventEmitter that emits a `change` event when a task is either:
 -   queued, waiting for _libuv_ to provide a worker thread
 -   complete
 
-**Examples**
+### Examples
 
 ```javascript
 sharp.queue.on('change', function(queueLength) {
@@ -111,26 +104,18 @@ sharp.queue.on('change', function(queueLength) {
 });
 ```
 
-[1]: #sharp
+[1]: https://nodejs.org/api/buffer.html
 
-[2]: #format
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
-[3]: #versions
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[4]: #queue
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[5]: https://nodejs.org/api/buffer.html
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
-[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[6]: https://www.npmjs.org/package/color
 
-[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
 
-[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-
-[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
-
-[10]: https://www.npmjs.org/package/color
-
-[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
-
-[12]: #sharp
+[8]: #sharp

docs/api-input.md

@@ -1,20 +1,12 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-### Table of Contents
-
--   [clone][1]
--   [metadata][2]
--   [stats][3]
--   [limitInputPixels][4]
--   [sequentialRead][5]
-
 ## clone
 
 Take a "snapshot" of the Sharp instance, returning a new instance.
 Cloned instances inherit the input of their parent instance.
 This allows multiple output Streams and therefore multiple processing pipelines to share a single input Stream.
 
-**Examples**
+### Examples
 
 ```javascript
 const pipeline = sharp().rotate();
@@ -30,28 +22,33 @@ Returns **Sharp**
 ## metadata
 
 Fast access to (uncached) image metadata without decoding any compressed image data.
-A Promises/A+ promise is returned when `callback` is not provided.
+A `Promise` is returned when `callback` is not provided.
 
 -   `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
+-   `size`: Total size of image in bytes, for Stream and Buffer input only
 -   `width`: Number of pixels wide (EXIF orientation is not taken into consideration)
 -   `height`: Number of pixels high (EXIF orientation is not taken into consideration)
--   `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][6]
+-   `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][1]
 -   `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
--   `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...][7]
+-   `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...][2]
 -   `density`: Number of pixels per inch (DPI), if present
+-   `chromaSubsampling`: String containing JPEG chroma subsampling, `4:2:0` or `4:4:4` for RGB, `4:2:0:4` or `4:4:4:4` for CMYK
+-   `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
+-   `pages`: Number of pages/frames contained within the image, with support for TIFF, PDF, animated GIF and animated WebP
+-   `pageHeight`: Number of pixels high each page in this PDF image will be.
 -   `hasProfile`: Boolean indicating the presence of an embedded ICC profile
 -   `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
 -   `orientation`: Number value of the EXIF Orientation header, if present
 -   `exif`: Buffer containing raw EXIF data, if present
--   `icc`: Buffer containing raw [ICC][8] profile data, if present
+-   `icc`: Buffer containing raw [ICC][3] profile data, if present
 -   `iptc`: Buffer containing raw IPTC data, if present
 -   `xmp`: Buffer containing raw XMP data, if present
 
-**Parameters**
+### Parameters
 
--   `callback` **[Function][9]?** called with the arguments `(err, metadata)`
+-   `callback` **[Function][4]?** called with the arguments `(err, metadata)`
 
-**Examples**
+### Examples
 
 ```javascript
 const image = sharp(inputJpg);
@@ -68,12 +65,12 @@ image
   });
 ```
 
-Returns **([Promise][10]&lt;[Object][11]> | Sharp)** 
+Returns **([Promise][5]&lt;[Object][6]> | Sharp)** 
 
 ## stats
 
 Access to pixel-derived image statistics for every channel in the image.
-A Promise is returned when `callback` is not provided.
+A `Promise` is returned when `callback` is not provided.
 
 -   `channels`: Array of channel statistics for each channel in the image. Each channel statistic contains
     -   `min` (minimum value in the channel)
@@ -87,12 +84,13 @@ A Promise is returned when `callback` is not provided.
     -   `maxX` (x-coordinate of one of the pixel where the maximum lies)
     -   `maxY` (y-coordinate of one of the pixel where the maximum lies)
 -   `isOpaque`: Value to identify if the image is opaque or transparent, based on the presence and use of alpha channel
+-   `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any (experimental)
 
-**Parameters**
+### Parameters
 
--   `callback` **[Function][9]?** called with the arguments `(err, stats)`
+-   `callback` **[Function][4]?** called with the arguments `(err, stats)`
 
-**Examples**
+### Examples
 
 ```javascript
 const image = sharp(inputJpg);
@@ -103,20 +101,20 @@ image
   });
 ```
 
-Returns **[Promise][10]&lt;[Object][11]>** 
+Returns **[Promise][5]&lt;[Object][6]>** 
 
 ## limitInputPixels
 
-Do not process input images where the number of pixels (width _ height) exceeds this limit.
+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.
-The default limit is 268402689 (0x3FFF _ 0x3FFF) pixels.
+The default limit is 268402689 (0x3FFF x 0x3FFF) pixels.
 
-**Parameters**
+### Parameters
 
--   `limit` **([Number][12] \| [Boolean][13])** an integral Number of pixels, zero or false to remove limit, true to use default limit.
+-   `limit` **([Number][7] \| [Boolean][8])** an integral Number of pixels, zero or false to remove limit, true to use default limit.
 
 
--   Throws **[Error][14]** Invalid limit
+-   Throws **[Error][9]** Invalid limit
 
 Returns **Sharp** 
 
@@ -127,36 +125,26 @@ This will reduce memory usage and can improve performance on some systems.
 
 The default behaviour _before_ function call is `false`, meaning the libvips access method is not sequential.
 
-**Parameters**
+### Parameters
 
--   `sequentialRead` **[Boolean][13]**  (optional, default `true`)
+-   `sequentialRead` **[Boolean][8]**  (optional, default `true`)
 
 Returns **Sharp** 
 
-[1]: #clone
+[1]: https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L636
 
-[2]: #metadata
+[2]: https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L672
 
-[3]: #stats
+[3]: https://www.npmjs.com/package/icc
 
-[4]: #limitinputpixels
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function
 
-[5]: #sequentialread
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
 
-[6]: https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L636
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[7]: https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L672
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
-[8]: https://www.npmjs.com/package/icc
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function
-
-[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
-
-[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
-
-[12]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
-
-[13]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-
-[14]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error

docs/api-operation.md

@@ -1,34 +1,16 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-### Table of Contents
-
--   [rotate][1]
--   [extract][2]
--   [flip][3]
--   [flop][4]
--   [sharpen][5]
--   [median][6]
--   [blur][7]
--   [extend][8]
--   [flatten][9]
--   [trim][10]
--   [gamma][11]
--   [negate][12]
--   [normalise][13]
--   [normalize][14]
--   [convolve][15]
--   [threshold][16]
--   [boolean][17]
--   [linear][18]
-
 ## rotate
 
 Rotate the output image by either an explicit angle
 or auto-orient based on the EXIF `Orientation` tag.
 
-If an angle is provided, it is converted to a valid 90/180/270deg rotation.
+If an angle is provided, it is converted to a valid positive degree rotation.
 For example, `-450` will produce a 270deg rotation.
 
+When rotating by an angle other than a multiple of 90,
+the background colour can be provided with the `background` option.
+
 If no angle is provided, it is determined from the EXIF data.
 Mirroring is supported and may infer the use of a flip operation.
 
@@ -37,11 +19,13 @@ The use of `rotate` implies the removal of the EXIF `Orientation` tag, if any.
 Method order is important when both rotating and extracting regions,
 for example `rotate(x).extract(y)` will produce a different result to `extract(y).rotate(x)`.
 
-**Parameters**
+### Parameters
 
--   `angle` **[Number][19]** angle of rotation, must be a multiple of 90. (optional, default `auto`)
+-   `angle` **[Number][1]** angle of rotation. (optional, default `auto`)
+-   `options` **[Object][2]?** if present, is an Object with optional attributes.
+    -   `options.background` **([String][3] \| [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
 
-**Examples**
+### Examples
 
 ```javascript
 const pipeline = sharp()
@@ -55,47 +39,7 @@ const pipeline = sharp()
 readableStream.pipe(pipeline);
 ```
 
--   Throws **[Error][20]** Invalid parameters
-
-Returns **Sharp** 
-
-## extract
-
-Extract a region of the image.
-
--   Use `extract` before `resize` for pre-resize extraction.
--   Use `extract` after `resize` for post-resize extraction.
--   Use `extract` before and after for both.
-
-**Parameters**
-
--   `options` **[Object][21]** 
-    -   `options.left` **[Number][19]** zero-indexed offset from left edge
-    -   `options.top` **[Number][19]** zero-indexed offset from top edge
-    -   `options.width` **[Number][19]** dimension of extracted image
-    -   `options.height` **[Number][19]** dimension of extracted image
-
-**Examples**
-
-```javascript
-sharp(input)
-  .extract({ left: left, top: top, width: width, height: height })
-  .toFile(output, function(err) {
-    // Extract a region of the input image, saving in the same format.
-  });
-```
-
-```javascript
-sharp(input)
-  .extract({ left: leftOffsetPre, top: topOffsetPre, width: widthPre, height: heightPre })
-  .resize(width, height)
-  .extract({ left: leftOffsetPost, top: topOffsetPost, width: widthPost, height: heightPost })
-  .toFile(output, function(err) {
-    // Extract a region, resize, then extract from the resized image
-  });
-```
-
--   Throws **[Error][20]** Invalid parameters
+-   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -104,9 +48,9 @@ Returns **Sharp**
 Flip the image about the vertical Y axis. This always occurs after rotation, if any.
 The use of `flip` implies the removal of the EXIF `Orientation` tag, if any.
 
-**Parameters**
+### Parameters
 
--   `flip` **[Boolean][22]**  (optional, default `true`)
+-   `flip` **[Boolean][6]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -115,9 +59,9 @@ Returns **Sharp**
 Flop the image about the horizontal X axis. This always occurs after rotation, if any.
 The use of `flop` implies the removal of the EXIF `Orientation` tag, if any.
 
-**Parameters**
+### Parameters
 
--   `flop` **[Boolean][22]**  (optional, default `true`)
+-   `flop` **[Boolean][6]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -128,14 +72,14 @@ When used without parameters, performs a fast, mild sharpen of the output image.
 When a `sigma` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space.
 Separate control over the level of sharpening in "flat" and "jagged" areas is available.
 
-**Parameters**
+### Parameters
 
--   `sigma` **[Number][19]?** the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
--   `flat` **[Number][19]** the level of sharpening to apply to "flat" areas. (optional, default `1.0`)
--   `jagged` **[Number][19]** the level of sharpening to apply to "jagged" areas. (optional, default `2.0`)
+-   `sigma` **[Number][1]?** the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+-   `flat` **[Number][1]** the level of sharpening to apply to "flat" areas. (optional, default `1.0`)
+-   `jagged` **[Number][1]** the level of sharpening to apply to "jagged" areas. (optional, default `2.0`)
 
 
--   Throws **[Error][20]** Invalid parameters
+-   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -144,12 +88,12 @@ Returns **Sharp**
 Apply median filter.
 When used without parameters the default window is 3x3.
 
-**Parameters**
+### Parameters
 
--   `size` **[Number][19]** square mask size: size x size (optional, default `3`)
+-   `size` **[Number][1]** square mask size: size x size (optional, default `3`)
 
 
--   Throws **[Error][20]** Invalid parameters
+-   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -159,64 +103,23 @@ Blur the image.
 When used without parameters, performs a fast, mild blur of the output image.
 When a `sigma` is provided, performs a slower, more accurate Gaussian blur.
 
-**Parameters**
+### Parameters
 
--   `sigma` **[Number][19]?** a value between 0.3 and 1000 representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+-   `sigma` **[Number][1]?** a value between 0.3 and 1000 representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
 
 
--   Throws **[Error][20]** Invalid parameters
-
-Returns **Sharp** 
-
-## extend
-
-Extends/pads the edges of the image with the colour provided to the `background` method.
-This operation will always occur after resizing and extraction, if any.
-
-**Parameters**
-
--   `extend` **([Number][19] \| [Object][21])** single pixel count to add to all edges or an Object with per-edge counts
-    -   `extend.top` **[Number][19]?** 
-    -   `extend.left` **[Number][19]?** 
-    -   `extend.bottom` **[Number][19]?** 
-    -   `extend.right` **[Number][19]?** 
-
-**Examples**
-
-```javascript
-// Resize to 140 pixels wide, then add 10 transparent pixels
-// to the top, left and right edges and 20 to the bottom edge
-sharp(input)
-  .resize(140)
-  .background({r: 0, g: 0, b: 0, alpha: 0})
-  .extend({top: 10, bottom: 20, left: 10, right: 10})
-  ...
-```
-
--   Throws **[Error][20]** Invalid parameters
+-   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
 ## flatten
 
-Merge alpha transparency channel, if any, with `background`.
+Merge alpha transparency channel, if any, with a background.
 
-**Parameters**
+### Parameters
 
--   `flatten` **[Boolean][22]**  (optional, default `true`)
-
-Returns **Sharp** 
-
-## trim
-
-Trim "boring" pixels from all edges that contain values within a percentage similarity of the top-left pixel.
-
-**Parameters**
-
--   `tolerance` **[Number][19]** value between 1 and 99 representing the percentage similarity. (optional, default `10`)
-
-
--   Throws **[Error][20]** Invalid 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}`)
 
 Returns **Sharp** 
 
@@ -228,12 +131,15 @@ This can improve the perceived brightness of a resized image in non-linear colou
 JPEG and WebP input images will not take advantage of the shrink-on-load performance optimisation
 when applying a gamma correction.
 
-**Parameters**
+Supply a second argument to use a different output gamma value, otherwise the first value is used in both cases.
 
--   `gamma` **[Number][19]** value between 1.0 and 3.0. (optional, default `2.2`)
+### Parameters
+
+-   `gamma` **[Number][1]** value between 1.0 and 3.0. (optional, default `2.2`)
+-   `gammaOut` **[Number][1]?** value between 1.0 and 3.0. (optional, defaults to same as `gamma`)
 
 
--   Throws **[Error][20]** Invalid parameters
+-   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -241,9 +147,9 @@ Returns **Sharp**
 
 Produce the "negative" of the image.
 
-**Parameters**
+### Parameters
 
--   `negate` **[Boolean][22]**  (optional, default `true`)
+-   `negate` **[Boolean][6]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -251,9 +157,9 @@ Returns **Sharp**
 
 Enhance output image contrast by stretching its luminance to cover the full dynamic range.
 
-**Parameters**
+### Parameters
 
--   `normalise` **[Boolean][22]**  (optional, default `true`)
+-   `normalise` **[Boolean][6]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -261,9 +167,9 @@ Returns **Sharp**
 
 Alternative spelling of normalise.
 
-**Parameters**
+### Parameters
 
--   `normalize` **[Boolean][22]**  (optional, default `true`)
+-   `normalize` **[Boolean][6]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -271,16 +177,16 @@ Returns **Sharp**
 
 Convolve the image with the specified kernel.
 
-**Parameters**
+### Parameters
 
--   `kernel` **[Object][21]** 
-    -   `kernel.width` **[Number][19]** width of the kernel in pixels.
-    -   `kernel.height` **[Number][19]** width of the kernel in pixels.
-    -   `kernel.kernel` **[Array][23]&lt;[Number][19]>** Array of length `width*height` containing the kernel values.
-    -   `kernel.scale` **[Number][19]** the scale of the kernel in pixels. (optional, default `sum`)
-    -   `kernel.offset` **[Number][19]** the offset of the kernel in pixels. (optional, default `0`)
+-   `kernel` **[Object][2]** 
+    -   `kernel.width` **[Number][1]** width of the kernel in pixels.
+    -   `kernel.height` **[Number][1]** width of the kernel in pixels.
+    -   `kernel.kernel` **[Array][7]&lt;[Number][1]>** Array of length `width*height` containing the kernel values.
+    -   `kernel.scale` **[Number][1]** the scale of the kernel in pixels. (optional, default `sum`)
+    -   `kernel.offset` **[Number][1]** the offset of the kernel in pixels. (optional, default `0`)
 
-**Examples**
+### Examples
 
 ```javascript
 sharp(input)
@@ -296,7 +202,7 @@ sharp(input)
   });
 ```
 
--   Throws **[Error][20]** Invalid parameters
+-   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -304,15 +210,15 @@ Returns **Sharp**
 
 Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
 
-**Parameters**
+### Parameters
 
--   `threshold` **[Number][19]** a value in the range 0-255 representing the level at which the threshold will be applied. (optional, default `128`)
--   `options` **[Object][21]?** 
-    -   `options.greyscale` **[Boolean][22]** convert to single channel greyscale. (optional, default `true`)
-    -   `options.grayscale` **[Boolean][22]** alternative spelling for greyscale. (optional, default `true`)
+-   `threshold` **[Number][1]** a value in the range 0-255 representing the level at which the threshold will be applied. (optional, default `128`)
+-   `options` **[Object][2]?** 
+    -   `options.greyscale` **[Boolean][6]** convert to single channel greyscale. (optional, default `true`)
+    -   `options.grayscale` **[Boolean][6]** alternative spelling for greyscale. (optional, default `true`)
 
 
--   Throws **[Error][20]** Invalid parameters
+-   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -323,18 +229,18 @@ Perform a bitwise boolean operation with operand image.
 This operation creates an output image where each pixel is the result of
 the selected bitwise boolean `operation` between the corresponding pixels of the input images.
 
-**Parameters**
+### Parameters
 
--   `operand` **([Buffer][24] \| [String][25])** Buffer containing image data or String containing the path to an image file.
--   `operator` **[String][25]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
--   `options` **[Object][21]?** 
-    -   `options.raw` **[Object][21]?** describes operand when using raw pixel data.
-        -   `options.raw.width` **[Number][19]?** 
-        -   `options.raw.height` **[Number][19]?** 
-        -   `options.raw.channels` **[Number][19]?** 
+-   `operand` **([Buffer][8] \| [String][3])** Buffer containing image data or String containing the path to an image file.
+-   `operator` **[String][3]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
+-   `options` **[Object][2]?** 
+    -   `options.raw` **[Object][2]?** describes operand when using raw pixel data.
+        -   `options.raw.width` **[Number][1]?** 
+        -   `options.raw.height` **[Number][1]?** 
+        -   `options.raw.channels` **[Number][1]?** 
 
 
--   Throws **[Error][20]** Invalid parameters
+-   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -342,62 +248,57 @@ Returns **Sharp**
 
 Apply the linear formula a \* input + b to the image (levels adjustment)
 
-**Parameters**
+### Parameters
 
--   `a` **[Number][19]** multiplier (optional, default `1.0`)
--   `b` **[Number][19]** offset (optional, default `0.0`)
+-   `a` **[Number][1]** multiplier (optional, default `1.0`)
+-   `b` **[Number][1]** offset (optional, default `0.0`)
 
 
--   Throws **[Error][20]** Invalid parameters
+-   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
-[1]: #rotate
+## recomb
 
-[2]: #extract
+Recomb the image with the specified matrix.
 
-[3]: #flip
+### Parameters
 
-[4]: #flop
+-   `inputMatrix`  
+-   `3x3` **[Array][7]&lt;[Array][7]&lt;[Number][1]>>** Recombination matrix
 
-[5]: #sharpen
+### Examples
 
-[6]: #median
+```javascript
+sharp(input)
+  .recomb([
+   [0.3588, 0.7044, 0.1368],
+   [0.2990, 0.5870, 0.1140],
+   [0.2392, 0.4696, 0.0912],
+  ])
+  .raw()
+  .toBuffer(function(err, data, info) {
+    // data contains the raw pixel data after applying the recomb
+    // With this example input, a sepia filter has been applied
+  });
+```
 
-[7]: #blur
+-   Throws **[Error][5]** Invalid parameters
 
-[8]: #extend
+Returns **Sharp** 
 
-[9]: #flatten
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
-[10]: #trim
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[11]: #gamma
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
-[12]: #negate
+[4]: https://www.npmjs.org/package/color
 
-[13]: #normalise
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
 
-[14]: #normalize
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[15]: #convolve
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
 
-[16]: #threshold
-
-[17]: #boolean
-
-[18]: #linear
-
-[19]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
-
-[20]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
-
-[21]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
-
-[22]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-
-[23]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
-
-[24]: https://nodejs.org/api/buffer.html
-
-[25]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[8]: https://nodejs.org/api/buffer.html

docs/api-output.md

@@ -1,18 +1,5 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-### Table of Contents
-
--   [toFile][1]
--   [toBuffer][2]
--   [withMetadata][3]
--   [jpeg][4]
--   [png][5]
--   [webp][6]
--   [tiff][7]
--   [raw][8]
--   [toFormat][9]
--   [tile][10]
-
 ## toFile
 
 Write output image data to a file.
@@ -23,15 +10,15 @@ Note that raw pixel data is only supported for buffer output.
 
 A `Promise` is returned when `callback` is not provided.
 
-**Parameters**
+### Parameters
 
--   `fileOut` **[String][11]** the path to write the image data to.
--   `callback` **[Function][12]?** called on completion with two arguments `(err, info)`.
+-   `fileOut` **[String][1]** the path to write the image data to.
+-   `callback` **[Function][2]?** called on completion with two arguments `(err, info)`.
     `info` contains the output image `format`, `size` (bytes), `width`, `height`,
     `channels` and `premultiplied` (indicating if premultiplication was used).
     When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
 
-**Examples**
+### Examples
 
 ```javascript
 sharp(input)
@@ -45,9 +32,9 @@ sharp(input)
   .catch(err => { ... });
 ```
 
--   Throws **[Error][13]** Invalid parameters
+-   Throws **[Error][3]** Invalid parameters
 
-Returns **[Promise][14]&lt;[Object][15]>** when no callback is provided
+Returns **[Promise][4]&lt;[Object][5]>** when no callback is provided
 
 ## toBuffer
 
@@ -65,13 +52,13 @@ By default, the format will match the input image, except GIF and SVG input whic
 
 A `Promise` is returned when `callback` is not provided.
 
-**Parameters**
+### Parameters
 
--   `options` **[Object][15]?** 
-    -   `options.resolveWithObject` **[Boolean][16]?** Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
--   `callback` **[Function][12]?** 
+-   `options` **[Object][5]?** 
+    -   `options.resolveWithObject` **[Boolean][6]?** Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
+-   `callback` **[Function][2]?** 
 
-**Examples**
+### Examples
 
 ```javascript
 sharp(input)
@@ -92,7 +79,7 @@ sharp(input)
   .catch(err => { ... });
 ```
 
-Returns **[Promise][14]&lt;[Buffer][17]>** when no callback is provided
+Returns **[Promise][4]&lt;[Buffer][7]>** when no callback is provided
 
 ## withMetadata
 
@@ -100,12 +87,12 @@ Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
 The default behaviour, when `withMetadata` is not used, is to strip all metadata and convert to the device-independent sRGB colour space.
 This will also convert to and add a web-friendly sRGB ICC profile.
 
-**Parameters**
+### Parameters
 
--   `withMetadata` **[Object][15]?** 
-    -   `withMetadata.orientation` **[Number][18]?** value between 1 and 8, used to update the EXIF `Orientation` tag.
+-   `withMetadata` **[Object][5]?** 
+    -   `withMetadata.orientation` **[Number][8]?** value between 1 and 8, used to update the EXIF `Orientation` tag.
 
-**Examples**
+### Examples
 
 ```javascript
 sharp('input.jpg')
@@ -114,7 +101,7 @@ sharp('input.jpg')
   .then(info => { ... });
 ```
 
--   Throws **[Error][13]** Invalid parameters
+-   Throws **[Error][3]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -122,19 +109,23 @@ Returns **Sharp**
 
 Use these JPEG options for output image.
 
-**Parameters**
+### Parameters
 
--   `options` **[Object][15]?** output options
-    -   `options.quality` **[Number][18]** quality, integer 1-100 (optional, default `80`)
-    -   `options.progressive` **[Boolean][16]** use progressive (interlace) scan (optional, default `false`)
-    -   `options.chromaSubsampling` **[String][11]** set to '4:4:4' to prevent chroma subsampling when quality &lt;= 90 (optional, default `'4:2:0'`)
-    -   `options.trellisQuantisation` **[Boolean][16]** apply trellis quantisation, requires mozjpeg (optional, default `false`)
-    -   `options.overshootDeringing` **[Boolean][16]** apply overshoot deringing, requires mozjpeg (optional, default `false`)
-    -   `options.optimiseScans` **[Boolean][16]** optimise progressive scans, forces progressive, requires mozjpeg (optional, default `false`)
-    -   `options.optimizeScans` **[Boolean][16]** alternative spelling of optimiseScans (optional, default `false`)
-    -   `options.force` **[Boolean][16]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
+-   `options` **[Object][5]?** output options
+    -   `options.quality` **[Number][8]** quality, integer 1-100 (optional, default `80`)
+    -   `options.progressive` **[Boolean][6]** use progressive (interlace) scan (optional, default `false`)
+    -   `options.chromaSubsampling` **[String][1]** set to '4:4:4' to prevent chroma subsampling when quality &lt;= 90 (optional, default `'4:2:0'`)
+    -   `options.trellisQuantisation` **[Boolean][6]** apply trellis quantisation, requires mozjpeg (optional, default `false`)
+    -   `options.overshootDeringing` **[Boolean][6]** apply overshoot deringing, requires mozjpeg (optional, default `false`)
+    -   `options.optimiseScans` **[Boolean][6]** optimise progressive scans, forces progressive, requires mozjpeg (optional, default `false`)
+    -   `options.optimizeScans` **[Boolean][6]** alternative spelling of optimiseScans (optional, default `false`)
+    -   `options.optimiseCoding` **[Boolean][6]** optimise Huffman coding tables (optional, default `true`)
+    -   `options.optimizeCoding` **[Boolean][6]** alternative spelling of optimiseCoding (optional, default `true`)
+    -   `options.quantisationTable` **[Number][8]** quantization table to use, integer 0-8, requires mozjpeg (optional, default `0`)
+    -   `options.quantizationTable` **[Number][8]** alternative spelling of quantisationTable (optional, default `0`)
+    -   `options.force` **[Boolean][6]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
 
-**Examples**
+### Examples
 
 ```javascript
 // Convert any input to very high quality JPEG output
@@ -146,7 +137,7 @@ const data = await sharp(input)
   .toBuffer();
 ```
 
--   Throws **[Error][13]** Invalid options
+-   Throws **[Error][3]** Invalid options
 
 Returns **Sharp** 
 
@@ -157,15 +148,20 @@ Use these PNG options for output image.
 PNG output is always 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.
 
-**Parameters**
+### Parameters
 
--   `options` **[Object][15]?** 
-    -   `options.progressive` **[Boolean][16]** use progressive (interlace) scan (optional, default `false`)
-    -   `options.compressionLevel` **[Number][18]** zlib compression level, 0-9 (optional, default `9`)
-    -   `options.adaptiveFiltering` **[Boolean][16]** use adaptive row filtering (optional, default `false`)
-    -   `options.force` **[Boolean][16]** force PNG output, otherwise attempt to use input format (optional, default `true`)
+-   `options` **[Object][5]?** 
+    -   `options.progressive` **[Boolean][6]** use progressive (interlace) scan (optional, default `false`)
+    -   `options.compressionLevel` **[Number][8]** zlib compression level, 0-9 (optional, default `9`)
+    -   `options.adaptiveFiltering` **[Boolean][6]** use adaptive row filtering (optional, default `false`)
+    -   `options.palette` **[Boolean][6]** quantise to a palette-based image with alpha transparency support, requires libimagequant (optional, default `false`)
+    -   `options.quality` **[Number][8]** use the lowest number of colours needed to achieve given quality, requires libimagequant (optional, default `100`)
+    -   `options.colours` **[Number][8]** maximum number of palette entries, requires libimagequant (optional, default `256`)
+    -   `options.colors` **[Number][8]** alternative spelling of `options.colours`, requires libimagequant (optional, default `256`)
+    -   `options.dither` **[Number][8]** level of Floyd-Steinberg error diffusion, requires libimagequant (optional, default `1.0`)
+    -   `options.force` **[Boolean][6]** force PNG output, otherwise attempt to use input format (optional, default `true`)
 
-**Examples**
+### Examples
 
 ```javascript
 // Convert any input to PNG output
@@ -174,7 +170,7 @@ const data = await sharp(input)
   .toBuffer();
 ```
 
--   Throws **[Error][13]** Invalid options
+-   Throws **[Error][3]** Invalid options
 
 Returns **Sharp** 
 
@@ -182,16 +178,16 @@ Returns **Sharp**
 
 Use these WebP options for output image.
 
-**Parameters**
+### Parameters
 
--   `options` **[Object][15]?** output options
-    -   `options.quality` **[Number][18]** quality, integer 1-100 (optional, default `80`)
-    -   `options.alphaQuality` **[Number][18]** quality of alpha layer, integer 0-100 (optional, default `100`)
-    -   `options.lossless` **[Boolean][16]** use lossless compression mode (optional, default `false`)
-    -   `options.nearLossless` **[Boolean][16]** use near_lossless compression mode (optional, default `false`)
-    -   `options.force` **[Boolean][16]** force WebP output, otherwise attempt to use input format (optional, default `true`)
+-   `options` **[Object][5]?** output options
+    -   `options.quality` **[Number][8]** quality, integer 1-100 (optional, default `80`)
+    -   `options.alphaQuality` **[Number][8]** quality of alpha layer, integer 0-100 (optional, default `100`)
+    -   `options.lossless` **[Boolean][6]** use lossless compression mode (optional, default `false`)
+    -   `options.nearLossless` **[Boolean][6]** use near_lossless compression mode (optional, default `false`)
+    -   `options.force` **[Boolean][6]** force WebP output, otherwise attempt to use input format (optional, default `true`)
 
-**Examples**
+### Examples
 
 ```javascript
 // Convert any input to lossless WebP output
@@ -200,7 +196,7 @@ const data = await sharp(input)
   .toBuffer();
 ```
 
--   Throws **[Error][13]** Invalid options
+-   Throws **[Error][3]** Invalid options
 
 Returns **Sharp** 
 
@@ -208,18 +204,22 @@ Returns **Sharp**
 
 Use these TIFF options for output image.
 
-**Parameters**
+### Parameters
 
--   `options` **[Object][15]?** output options
-    -   `options.quality` **[Number][18]** quality, integer 1-100 (optional, default `80`)
-    -   `options.force` **[Boolean][16]** force TIFF output, otherwise attempt to use input format (optional, default `true`)
-    -   `options.compression` **[Boolean][16]** compression options: lzw, deflate, jpeg, ccittfax4 (optional, default `'jpeg'`)
-    -   `options.predictor` **[Boolean][16]** compression predictor options: none, horizontal, float (optional, default `'horizontal'`)
-    -   `options.xres` **[Number][18]** horizontal resolution in pixels/mm (optional, default `1.0`)
-    -   `options.yres` **[Number][18]** vertical resolution in pixels/mm (optional, default `1.0`)
-    -   `options.squash` **[Boolean][16]** squash 8-bit images down to 1 bit (optional, default `false`)
+-   `options` **[Object][5]?** output options
+    -   `options.quality` **[Number][8]** quality, integer 1-100 (optional, default `80`)
+    -   `options.force` **[Boolean][6]** force TIFF output, otherwise attempt to use input format (optional, default `true`)
+    -   `options.compression` **[Boolean][6]** compression options: lzw, deflate, jpeg, ccittfax4 (optional, default `'jpeg'`)
+    -   `options.predictor` **[Boolean][6]** compression predictor options: none, horizontal, float (optional, default `'horizontal'`)
+    -   `options.pyramid` **[Boolean][6]** write an image pyramid (optional, default `false`)
+    -   `options.tile` **[Boolean][6]** write a tiled tiff (optional, default `false`)
+    -   `options.tileWidth` **[Boolean][6]** horizontal tile size (optional, default `256`)
+    -   `options.tileHeight` **[Boolean][6]** vertical tile size (optional, default `256`)
+    -   `options.xres` **[Number][8]** horizontal resolution in pixels/mm (optional, default `1.0`)
+    -   `options.yres` **[Number][8]** vertical resolution in pixels/mm (optional, default `1.0`)
+    -   `options.squash` **[Boolean][6]** squash 8-bit images down to 1 bit (optional, default `false`)
 
-**Examples**
+### Examples
 
 ```javascript
 // Convert SVG input to LZW-compressed, 1 bit per pixel TIFF output
@@ -232,7 +232,7 @@ sharp('input.svg')
   .then(info => { ... });
 ```
 
--   Throws **[Error][13]** Invalid options
+-   Throws **[Error][3]** Invalid options
 
 Returns **Sharp** 
 
@@ -240,7 +240,7 @@ Returns **Sharp**
 
 Force output to be raw, uncompressed uint8 pixel data.
 
-**Examples**
+### Examples
 
 ```javascript
 // Extract raw RGB pixel data from JPEG input
@@ -255,12 +255,12 @@ Returns **Sharp**
 
 Force output to a given format.
 
-**Parameters**
+### Parameters
 
--   `format` **([String][11] \| [Object][15])** as a String or an Object with an 'id' attribute
--   `options` **[Object][15]** output options
+-   `format` **([String][1] \| [Object][5])** as a String or an Object with an 'id' attribute
+-   `options` **[Object][5]** output options
 
-**Examples**
+### Examples
 
 ```javascript
 // Convert any input to PNG output
@@ -269,7 +269,7 @@ const data = await sharp(input)
   .toBuffer();
 ```
 
--   Throws **[Error][13]** unsupported format or options
+-   Throws **[Error][3]** unsupported format or options
 
 Returns **Sharp** 
 
@@ -279,16 +279,19 @@ Use tile-based deep zoom (image pyramid) output.
 Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
 Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed archive file format.
 
-**Parameters**
+Warning: multiple sharp instances concurrently producing tile output can expose a possible race condition in some versions of libgsf.
 
--   `tile` **[Object][15]?** 
-    -   `tile.size` **[Number][18]** tile size in pixels, a value between 1 and 8192. (optional, default `256`)
-    -   `tile.overlap` **[Number][18]** tile overlap in pixels, a value between 0 and 8192. (optional, default `0`)
-    -   `tile.angle` **[Number][18]** tile angle of rotation, must be a multiple of 90. (optional, default `0`)
-    -   `tile.container` **[String][11]** tile container, with value `fs` (filesystem) or `zip` (compressed file). (optional, default `'fs'`)
-    -   `tile.layout` **[String][11]** filesystem layout, possible values are `dz`, `zoomify` or `google`. (optional, default `'dz'`)
+### Parameters
 
-**Examples**
+-   `tile` **[Object][5]?** 
+    -   `tile.size` **[Number][8]** tile size in pixels, a value between 1 and 8192. (optional, default `256`)
+    -   `tile.overlap` **[Number][8]** tile overlap in pixels, a value between 0 and 8192. (optional, default `0`)
+    -   `tile.angle` **[Number][8]** tile angle of rotation, must be a multiple of 90. (optional, default `0`)
+    -   `tile.depth` **[String][1]?** how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
+    -   `tile.container` **[String][1]** tile container, with value `fs` (filesystem) or `zip` (compressed file). (optional, default `'fs'`)
+    -   `tile.layout` **[String][1]** filesystem layout, possible values are `dz`, `zoomify` or `google`. (optional, default `'dz'`)
+
+### Examples
 
 ```javascript
 sharp('input.tiff')
@@ -302,42 +305,22 @@ sharp('input.tiff')
   });
 ```
 
--   Throws **[Error][13]** Invalid parameters
+-   Throws **[Error][3]** Invalid parameters
 
 Returns **Sharp** 
 
-[1]: #tofile
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
-[2]: #tobuffer
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function
 
-[3]: #withmetadata
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
 
-[4]: #jpeg
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
 
-[5]: #png
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[6]: #webp
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[7]: #tiff
+[7]: https://nodejs.org/api/buffer.html
 
-[8]: #raw
-
-[9]: #toformat
-
-[10]: #tile
-
-[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
-
-[12]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function
-
-[13]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
-
-[14]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
-
-[15]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
-
-[16]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-
-[17]: https://nodejs.org/api/buffer.html
-
-[18]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number

docs/api-resize.md

@@ -1,206 +1,234 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-### Table of Contents
-
--   [resize][1]
--   [crop][2]
--   [embed][3]
--   [max][4]
--   [min][5]
--   [ignoreAspectRatio][6]
--   [withoutEnlargement][7]
-
 ## resize
 
-Resize image to `width` x `height`.
-By default, the resized image is centre cropped to the exact size specified.
+Resize image to `width`, `height` or `width x height`.
 
-Possible kernels are:
+When both a `width` and `height` are provided, the possible methods by which the image should **fit** these are:
 
--   `nearest`: Use [nearest neighbour interpolation][8].
--   `cubic`: Use a [Catmull-Rom spline][9].
--   `lanczos2`: Use a [Lanczos kernel][10] with `a=2`.
--   `lanczos3`: Use a Lanczos kernel with `a=3` (the default).
+-   `cover`: Crop to cover both provided dimensions (the default).
+-   `contain`: Embed within both provided dimensions.
+-   `fill`: Ignore the aspect ratio of the input and stretch to both provided dimensions.
+-   `inside`: Preserving aspect ratio, resize the image to be as large as possible while ensuring its dimensions are less than or equal to both those specified.
+-   `outside`: Preserving aspect ratio, resize the image to be as small as possible while ensuring its dimensions are greater than or equal to both those specified.
+    Some of these values are based on the [object-fit][1] CSS property.
 
-**Parameters**
+When using a `fit` of `cover` or `contain`, the default **position** is `centre`. Other options are:
 
--   `width` **[Number][11]?** pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
--   `height` **[Number][11]?** pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
--   `options` **[Object][12]?** 
-    -   `options.kernel` **[String][13]** the kernel to use for image reduction. (optional, default `'lanczos3'`)
-    -   `options.fastShrinkOnLoad` **[Boolean][14]** take greater advantage of the JPEG and WebP shrink-on-load feature, which can lead to a slight moiré pattern on some images. (optional, default `true`)
-
-**Examples**
-
-```javascript
-sharp(inputBuffer)
-  .resize(200, 300, {
-    kernel: sharp.kernel.nearest
-  })
-  .background('white')
-  .embed()
-  .toFile('output.tiff')
-  .then(function() {
-    // output.tiff is a 200 pixels wide and 300 pixels high image
-    // containing a nearest-neighbour scaled version, embedded on a white canvas,
-    // of the image data in inputBuffer
-  });
-```
-
--   Throws **[Error][15]** Invalid parameters
-
-Returns **Sharp** 
-
-## crop
-
-Crop the resized image to the exact size specified, the default behaviour.
-
-Possible attributes of the optional `sharp.gravity` are `north`, `northeast`, `east`, `southeast`, `south`,
-`southwest`, `west`, `northwest`, `center` and `centre`.
+-   `sharp.position`: `top`, `right top`, `right`, `right bottom`, `bottom`, `left bottom`, `left`, `left top`.
+-   `sharp.gravity`: `north`, `northeast`, `east`, `southeast`, `south`, `southwest`, `west`, `northwest`, `center` or `centre`.
+-   `sharp.strategy`: `cover` only, dynamically crop using either the `entropy` or `attention` strategy.
+    Some of these values are based on the [object-position][2] CSS property.
 
 The experimental strategy-based approach resizes so one dimension is at its target length
 then repeatedly ranks edge regions, discarding the edge with the lowest score based on the selected strategy.
 
--   `entropy`: focus on the region with the highest [Shannon entropy][16].
+-   `entropy`: focus on the region with the highest [Shannon entropy][3].
 -   `attention`: focus on the region with the highest luminance frequency, colour saturation and presence of skin tones.
 
-**Parameters**
+Possible interpolation kernels are:
 
--   `crop` **[String][13]** A member of `sharp.gravity` to crop to an edge/corner or `sharp.strategy` to crop dynamically. (optional, default `'centre'`)
+-   `nearest`: Use [nearest neighbour interpolation][4].
+-   `cubic`: Use a [Catmull-Rom spline][5].
+-   `mitchell`: Use a [Mitchell-Netravali spline][6].
+-   `lanczos2`: Use a [Lanczos kernel][7] with `a=2`.
+-   `lanczos3`: Use a Lanczos kernel with `a=3` (the default).
 
-**Examples**
+### Parameters
+
+-   `width` **[Number][8]?** pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
+-   `height` **[Number][8]?** pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
+-   `options` **[Object][9]?** 
+    -   `options.width` **[String][10]?** alternative means of specifying `width`. If both are present this take priority.
+    -   `options.height` **[String][10]?** alternative means of specifying `height`. If both are present this take priority.
+    -   `options.fit` **[String][10]** how the image should be resized to fit both provided dimensions, one of `cover`, `contain`, `fill`, `inside` or `outside`. (optional, default `'cover'`)
+    -   `options.position` **[String][10]** position, gravity or strategy to use when `fit` is `cover` or `contain`. (optional, default `'centre'`)
+    -   `options.background` **([String][10] \| [Object][9])** background colour when using a `fit` of `contain`, parsed by the [color][11] module, defaults to black without transparency. (optional, default `{r:0,g:0,b:0,alpha:1}`)
+    -   `options.kernel` **[String][10]** the kernel to use for image reduction. (optional, default `'lanczos3'`)
+    -   `options.withoutEnlargement` **[Boolean][12]** do not enlarge if the width _or_ height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option. (optional, default `false`)
+    -   `options.fastShrinkOnLoad` **[Boolean][12]** take greater advantage of the JPEG and WebP shrink-on-load feature, which can lead to a slight moiré pattern on some images. (optional, default `true`)
+
+### Examples
+
+```javascript
+sharp(input)
+  .resize({ width: 100 })
+  .toBuffer()
+  .then(data => {
+    // 100 pixels wide, auto-scaled height
+  });
+```
+
+```javascript
+sharp(input)
+  .resize({ height: 100 })
+  .toBuffer()
+  .then(data => {
+    // 100 pixels high, auto-scaled width
+  });
+```
+
+```javascript
+sharp(input)
+  .resize(200, 300, {
+    kernel: sharp.kernel.nearest,
+    fit: 'contain',
+    position: 'right top',
+    background: { r: 255, g: 255, b: 255, alpha: 0.5 }
+  })
+  .toFile('output.png')
+  .then(() => {
+    // output.png is a 200 pixels wide and 300 pixels high image
+    // containing a nearest-neighbour scaled version
+    // contained within the north-east corner of a semi-transparent white canvas
+  });
+```
 
 ```javascript
 const transformer = sharp()
-  .resize(200, 200)
-  .crop(sharp.strategy.entropy)
-  .on('error', function(err) {
-    console.log(err);
+  .resize({
+    width: 200,
+    height: 200,
+    fit: sharp.fit.cover,
+    position: sharp.strategy.entropy
   });
 // Read image data from readableStream
 // Write 200px square auto-cropped image data to writableStream
-readableStream.pipe(transformer).pipe(writableStream);
+readableStream
+  .pipe(transformer)
+  .pipe(writableStream);
 ```
 
--   Throws **[Error][15]** Invalid parameters
-
-Returns **Sharp** 
-
-## embed
-
-Preserving aspect ratio, resize the image to the maximum `width` or `height` specified
-then embed on a background of the exact `width` and `height` specified.
-
-If the background contains an alpha value then WebP and PNG format output images will
-contain an alpha channel, even when the input image does not.
-
-**Parameters**
-
--   `embed` **[String][13]** A member of `sharp.gravity` to embed to an edge/corner. (optional, default `'centre'`)
-
-**Examples**
-
 ```javascript
-sharp('input.gif')
-  .resize(200, 300)
-  .background({r: 0, g: 0, b: 0, alpha: 0})
-  .embed()
-  .toFormat(sharp.format.webp)
-  .toBuffer(function(err, outputBuffer) {
-    if (err) {
-      throw err;
-    }
-    // outputBuffer contains WebP image data of a 200 pixels wide and 300 pixels high
-    // containing a scaled version, embedded on a transparent canvas, of input.gif
-  });
-```
-
--   Throws **[Error][15]** Invalid parameters
-
-Returns **Sharp** 
-
-## max
-
-Preserving aspect ratio, resize the image to be as large as possible
-while ensuring its dimensions are less than or equal to the `width` and `height` specified.
-
-Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
-
-**Examples**
-
-```javascript
-sharp(inputBuffer)
-  .resize(200, 200)
-  .max()
+sharp(input)
+  .resize(200, 200, {
+    fit: sharp.fit.inside,
+    withoutEnlargement: true
+  })
   .toFormat('jpeg')
   .toBuffer()
   .then(function(outputBuffer) {
-    // outputBuffer contains JPEG image data no wider than 200 pixels and no higher
-    // than 200 pixels regardless of the inputBuffer image dimensions
+    // outputBuffer contains JPEG image data
+    // no wider and no higher than 200 pixels
+    // and no larger than the input image
   });
 ```
 
-Returns **Sharp** 
-
-## min
-
-Preserving aspect ratio, resize the image to be as small as possible
-while ensuring its dimensions are greater than or equal to the `width` and `height` specified.
-
-Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
+-   Throws **[Error][13]** Invalid parameters
 
 Returns **Sharp** 
 
-## ignoreAspectRatio
+## extend
 
-Ignoring the aspect ratio of the input, stretch the image to
-the exact `width` and/or `height` provided via `resize`.
+Extends/pads the edges of the image with the provided background colour.
+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.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
+
+```javascript
+// Resize to 140 pixels wide, then add 10 transparent pixels
+// to the top, left and right edges and 20 to the bottom edge
+sharp(input)
+  .resize(140)
+  .extend({
+    top: 10,
+    bottom: 20,
+    left: 10,
+    right: 10,
+    background: { r: 0, g: 0, b: 0, alpha: 0 }
+  })
+  ...
+```
+
+-   Throws **[Error][13]** Invalid parameters
 
 Returns **Sharp** 
 
-## withoutEnlargement
+## extract
 
-Do not enlarge the output image if the input image width _or_ height are already less than the required dimensions.
-This is equivalent to GraphicsMagick's `>` geometry option:
-"_change the dimensions of the image only if its width or height exceeds the geometry specification_".
-Use with `max()` to preserve the image's aspect ratio.
+Extract a region of the image.
 
-The default behaviour _before_ function call is `false`, meaning the image will be enlarged.
+-   Use `extract` before `resize` for pre-resize extraction.
+-   Use `extract` after `resize` for post-resize extraction.
+-   Use `extract` before and after for both.
 
-**Parameters**
+### Parameters
 
--   `withoutEnlargement` **[Boolean][14]**  (optional, default `true`)
+-   `options` **[Object][9]** 
+    -   `options.left` **[Number][8]** zero-indexed offset from left edge
+    -   `options.top` **[Number][8]** zero-indexed offset from top edge
+    -   `options.width` **[Number][8]** dimension of extracted image
+    -   `options.height` **[Number][8]** dimension of extracted image
+
+### Examples
+
+```javascript
+sharp(input)
+  .extract({ left: left, top: top, width: width, height: height })
+  .toFile(output, function(err) {
+    // Extract a region of the input image, saving in the same format.
+  });
+```
+
+```javascript
+sharp(input)
+  .extract({ left: leftOffsetPre, top: topOffsetPre, width: widthPre, height: heightPre })
+  .resize(width, height)
+  .extract({ left: leftOffsetPost, top: topOffsetPost, width: widthPost, height: heightPost })
+  .toFile(output, function(err) {
+    // Extract a region, resize, then extract from the resized image
+  });
+```
+
+-   Throws **[Error][13]** Invalid parameters
 
 Returns **Sharp** 
 
-[1]: #resize
+## trim
 
-[2]: #crop
+Trim "boring" pixels from all edges that contain values similar to the top-left pixel.
+The `info` response Object will contain `trimOffsetLeft` and `trimOffsetTop` properties.
 
-[3]: #embed
+### Parameters
 
-[4]: #max
+-   `threshold` **[Number][8]** the allowed difference from the top-left pixel, a number greater than zero. (optional, default `10`)
 
-[5]: #min
 
-[6]: #ignoreaspectratio
+-   Throws **[Error][13]** Invalid parameters
 
-[7]: #withoutenlargement
+Returns **Sharp** 
 
-[8]: http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation
+[1]: https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit
 
-[9]: https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline
+[2]: https://developer.mozilla.org/en-US/docs/Web/CSS/object-position
 
-[10]: https://en.wikipedia.org/wiki/Lanczos_resampling#Lanczos_kernel
+[3]: https://en.wikipedia.org/wiki/Entropy_%28information_theory%29
 
-[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[4]: http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation
 
-[12]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+[5]: https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline
 
-[13]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[6]: https://www.cs.utexas.edu/~fussell/courses/cs384g-fall2013/lectures/mitchell/Mitchell.pdf
 
-[14]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[7]: https://en.wikipedia.org/wiki/Lanczos_resampling#Lanczos_kernel
 
-[15]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
-[16]: https://en.wikipedia.org/wiki/Entropy_%28information_theory%29
+[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[11]: https://www.npmjs.org/package/color
+
+[12]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[13]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error

docs/api-utility.md

@@ -1,12 +1,5 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-### Table of Contents
-
--   [cache][1]
--   [concurrency][2]
--   [counters][3]
--   [simd][4]
-
 ## cache
 
 Gets or, when options are provided, sets the limits of _libvips'_ operation cache.
@@ -14,14 +7,14 @@ Existing entries in the cache will be trimmed after any change in limits.
 This method always returns cache statistics,
 useful for determining how much working memory is required for a particular task.
 
-**Parameters**
+### Parameters
 
--   `options` **([Object][5] \| [Boolean][6])** Object with the following attributes, or Boolean where true uses default cache settings and false removes all caching (optional, default `true`)
-    -   `options.memory` **[Number][7]** is the maximum memory in MB to use for this cache (optional, default `50`)
-    -   `options.files` **[Number][7]** is the maximum number of files to hold open (optional, default `20`)
-    -   `options.items` **[Number][7]** is the maximum number of operations to cache (optional, default `100`)
+-   `options` **([Object][1] \| [Boolean][2])** Object with the following attributes, or Boolean where true uses default cache settings and false removes all caching (optional, default `true`)
+    -   `options.memory` **[Number][3]** is the maximum memory in MB to use for this cache (optional, default `50`)
+    -   `options.files` **[Number][3]** is the maximum number of files to hold open (optional, default `20`)
+    -   `options.items` **[Number][3]** is the maximum number of operations to cache (optional, default `100`)
 
-**Examples**
+### Examples
 
 ```javascript
 const stats = sharp.cache();
@@ -33,7 +26,7 @@ sharp.cache( { files: 0 } );
 sharp.cache(false);
 ```
 
-Returns **[Object][5]** 
+Returns **[Object][1]** 
 
 ## concurrency
 
@@ -47,11 +40,11 @@ is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
 
 This method always returns the current concurrency.
 
-**Parameters**
+### Parameters
 
--   `concurrency` **[Number][7]?** 
+-   `concurrency` **[Number][3]?** 
 
-**Examples**
+### Examples
 
 ```javascript
 const threads = sharp.concurrency(); // 4
@@ -59,7 +52,7 @@ sharp.concurrency(2); // 2
 sharp.concurrency(0); // 4
 ```
 
-Returns **[Number][7]** concurrency
+Returns **[Number][3]** concurrency
 
 ## counters
 
@@ -68,13 +61,13 @@ Provides access to internal task counters.
 -   queue is the number of tasks this module has queued waiting for _libuv_ to provide a worker thread from its pool.
 -   process is the number of resize tasks currently being processed.
 
-**Examples**
+### Examples
 
 ```javascript
 const counters = sharp.counters(); // { queue: 2, process: 4 }
 ```
 
-Returns **[Object][5]** 
+Returns **[Object][1]** 
 
 ## simd
 
@@ -84,37 +77,26 @@ Requires libvips to have been compiled with liborc support.
 Improves the performance of `resize`, `blur` and `sharpen` operations
 by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM NEON.
 
-This feature is currently off by default but future versions may reverse this.
-Versions of liborc prior to 0.4.25 are known to segfault under heavy load.
+### Parameters
 
-**Parameters**
+-   `simd` **[Boolean][2]**  (optional, default `true`)
 
--   `simd` **[Boolean][6]**  (optional, default `false`)
-
-**Examples**
+### Examples
 
 ```javascript
 const simd = sharp.simd();
-// simd is `true` if SIMD is currently enabled
+// simd is `true` if the runtime use of liborc is currently enabled
 ```
 
 ```javascript
-const simd = sharp.simd(true);
-// attempts to enable the use of SIMD, returning true if available
+const simd = sharp.simd(false);
+// prevent libvips from using liborc at runtime
 ```
 
-Returns **[Boolean][6]** 
+Returns **[Boolean][2]** 
 
-[1]: #cache
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 
-[2]: #concurrency
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[3]: #counters
-
-[4]: #simd
-
-[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
-
-[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-
-[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number

docs/changelog.md

@@ -1,9 +1,201 @@
 # Changelog
 
+### v0.22 - "*uptake*"
+
+Requires libvips v8.7.4.
+
+#### v0.22.0 - 18<sup>th</sup> March 2019
+
+* Remove functions previously deprecated in v0.21.0:
+    `background`, `crop`, `embed`, `ignoreAspectRatio`, `max`, `min` and `withoutEnlargement`.
+
+* Add `composite` operation supporting multiple images and blend modes; deprecate `overlayWith`.
+  [#728](https://github.com/lovell/sharp/issues/728)
+
+* Add support for `pages` input option for multi-page input.
+  [#1566](https://github.com/lovell/sharp/issues/1566)
+
+* Allow Stream-based input of raw pixel data.
+  [#1579](https://github.com/lovell/sharp/issues/1579)
+
+* Add support for `page` input option to GIF and PDF.
+  [#1595](https://github.com/lovell/sharp/pull/1595)
+  [@ramiel](https://github.com/ramiel)
+
+### v0.21 - "*teeth*"
+
+Requires libvips v8.7.0.
+
+#### v0.21.3 - 19<sup>th</sup> January 2019
+
+* Input image decoding now fails fast, set `failOnError` to change this behaviour.
+
+* Failed filesystem-based input now separates missing file and invalid format errors.
+  [#1542](https://github.com/lovell/sharp/issues/1542)
+
+#### v0.21.2 - 13<sup>th</sup> January 2019
+
+* Ensure all metadata is removed from PNG output unless `withMetadata` used.
+
+* Ensure shortest edge is at least one pixel after resizing.
+  [#1003](https://github.com/lovell/sharp/issues/1003)
+
+* Add `ensureAlpha` operation to add an alpha channel, if missing.
+  [#1153](https://github.com/lovell/sharp/issues/1153)
+
+* Expose `pages` and `pageHeight` metadata for multi-page input images.
+  [#1205](https://github.com/lovell/sharp/issues/1205)
+
+* Expose PNG output options requiring libimagequant.
+  [#1484](https://github.com/lovell/sharp/issues/1484)
+
+* Expose underlying error message for invalid input.
+  [#1505](https://github.com/lovell/sharp/issues/1505)
+
+* Prevent mutatation of options passed to `jpeg`.
+  [#1516](https://github.com/lovell/sharp/issues/1516)
+
+* Ensure forced output format applied correctly when output chaining.
+  [#1528](https://github.com/lovell/sharp/issues/1528)
+
+#### v0.21.1 - 7<sup>th</sup> December 2018
+
+* Install: support `sharp_dist_base_url` npm config, like existing `SHARP_DIST_BASE_URL`.
+  [#1422](https://github.com/lovell/sharp/pull/1422)
+  [@SethWen](https://github.com/SethWen)
+
+* Ensure `channel` metadata is correct for raw, greyscale output.
+  [#1425](https://github.com/lovell/sharp/issues/1425)
+
+* Add support for the "mitchell" kernel for image reductions.
+  [#1438](https://github.com/lovell/sharp/pull/1438)
+  [@Daiz](https://github.com/Daiz)
+
+* Allow separate parameters for gamma encoding and decoding.
+  [#1439](https://github.com/lovell/sharp/pull/1439)
+  [@Daiz](https://github.com/Daiz)
+
+* Build prototype with `Object.assign` to allow minification.
+  [#1475](https://github.com/lovell/sharp/pull/1475)
+  [@jaubourg](https://github.com/jaubourg)
+
+* Expose libvips' recombination matrix operation.
+  [#1477](https://github.com/lovell/sharp/pull/1477)
+  [@fromkeith](https://github.com/fromkeith)
+
+* Expose libvips' pyramid/tile options for TIFF output.
+  [#1483](https://github.com/lovell/sharp/pull/1483)
+  [@mbklein](https://github.com/mbklein)
+
+#### v0.21.0 - 4<sup>th</sup> October 2018
+
+* Deprecate the following resize-related functions:
+    `crop`, `embed`, `ignoreAspectRatio`, `max`, `min` and `withoutEnlargement`.
+  Access to these is now via options passed to the `resize` function.
+  For example:
+    `embed('north')` is now `resize(width, height, { fit: 'contain', position: 'north' })`,
+    `crop('attention')` is now `resize(width, height, { fit: 'cover', position: 'attention' })`,
+    `max().withoutEnlargement()` is now `resize(width, height, { fit: 'inside', withoutEnlargement: true })`.
+  [#1135](https://github.com/lovell/sharp/issues/1135)
+
+* Deprecate the `background` function.
+    Per-operation `background` options added to `resize`, `extend` and `flatten` operations.
+  [#1392](https://github.com/lovell/sharp/issues/1392)
+
+* Add `size` to `metadata` response (Stream and Buffer input only).
+  [#695](https://github.com/lovell/sharp/issues/695)
+
+* Switch from custom trim operation to `vips_find_trim`.
+  [#914](https://github.com/lovell/sharp/issues/914)
+
+* Add `chromaSubsampling` and `isProgressive` properties to `metadata` response.
+  [#1186](https://github.com/lovell/sharp/issues/1186)
+
+* Drop Node 4 support.
+  [#1212](https://github.com/lovell/sharp/issues/1212)
+
+* Enable SIMD convolution by default.
+  [#1213](https://github.com/lovell/sharp/issues/1213)
+
+* Add experimental prebuilt binaries for musl-based Linux.
+  [#1379](https://github.com/lovell/sharp/issues/1379)
+
+* Add support for arbitrary rotation angle via vips_rotate.
+  [#1385](https://github.com/lovell/sharp/pull/1385)
+  [@freezy](https://github.com/freezy)
+
 ### v0.20 - "*prebuild*"
 
 Requires libvips v8.6.1.
 
+#### v0.20.8 - 5<sup>th</sup> September 2018
+
+* Avoid race conditions when creating directories during installation.
+  [#1358](https://github.com/lovell/sharp/pull/1358)
+  [@ajhool](https://github.com/ajhool)
+
+* Accept floating point values for input density parameter.
+  [#1362](https://github.com/lovell/sharp/pull/1362)
+  [@aeirola](https://github.com/aeirola)
+
+#### v0.20.7 - 21<sup>st</sup> August 2018
+
+* Use copy+unlink if rename operation fails during installation.
+  [#1345](https://github.com/lovell/sharp/issues/1345)
+
+#### v0.20.6 - 20<sup>th</sup> August 2018
+
+* Add removeAlpha operation to remove alpha channel, if any.
+  [#1248](https://github.com/lovell/sharp/issues/1248)
+
+* Expose mozjpeg quant_table flag.
+  [#1285](https://github.com/lovell/sharp/pull/1285)
+  [@rexxars](https://github.com/rexxars)
+
+* Allow full WebP alphaQuality range of 0-100.
+  [#1290](https://github.com/lovell/sharp/pull/1290)
+  [@sylvaindumont](https://github.com/sylvaindumont)
+
+* Cache libvips binaries to reduce re-install time.
+  [#1301](https://github.com/lovell/sharp/issues/1301)
+
+* Ensure vendor platform mismatch throws error at install time.
+  [#1303](https://github.com/lovell/sharp/issues/1303)
+
+* Improve install time error messages for FreeBSD users.
+  [#1310](https://github.com/lovell/sharp/issues/1310)
+
+* Ensure extractChannel works with 16-bit images.
+  [#1330](https://github.com/lovell/sharp/issues/1330)
+
+* Expose depth option for tile-based output.
+  [#1342](https://github.com/lovell/sharp/pull/1342)
+  [@alundavies](https://github.com/alundavies)
+
+* Add experimental entropy field to stats response.
+
+#### v0.20.5 - 27<sup>th</sup> June 2018
+
+* Expose libjpeg optimize_coding flag.
+  [#1265](https://github.com/lovell/sharp/pull/1265)
+  [@tomlokhorst](https://github.com/tomlokhorst)
+
+#### v0.20.4 - 20<sup>th</sup> June 2018
+
+* Prevent possible rounding error when using shrink-on-load and 90/270 degree rotation.
+  [#1241](https://github.com/lovell/sharp/issues/1241)
+  [@anahit42](https://github.com/anahit42)
+
+* Ensure extractChannel sets correct single-channel colour space interpretation.
+  [#1257](https://github.com/lovell/sharp/issues/1257)
+  [@jeremychone](https://github.com/jeremychone)
+
+#### v0.20.3 - 29<sup>th</sup> May 2018
+
+* Fix tint operation by ensuring LAB interpretation and allowing negative values.
+  [#1235](https://github.com/lovell/sharp/issues/1235)
+  [@wezside](https://github.com/wezside)
+
 #### v0.20.2 - 28<sup>th</sup> April 2018
 
 * Add tint operation to set image chroma.

docs/css/extra.css

@@ -0,0 +1,5 @@
+/* Nest document subheadings in navigation */
+ul.subnav ul:not(.subnav) {
+  padding-left: 2em;
+  font-size: 80%;
+}

docs/image/sharp-logo.svg

@@ -0,0 +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. -->
+<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.md

@@ -1,5 +1,7 @@
 # sharp
 
+<img src="image/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
+
 The typical use case for this high speed Node.js module
 is to convert large images in common formats to
 smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
@@ -13,8 +15,8 @@ Lanczos resampling ensures quality is not sacrificed for speed.
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
 
-Most 64-bit OS X, Windows and Linux (glibc) systems running
-Node versions 4, 6, 8 and 10
+Most modern 64-bit OS X, Windows and Linux systems running
+Node versions 6, 8 and 10
 do not require any additional install or runtime dependencies.
 
 [![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
@@ -37,7 +39,7 @@ and [Leaflet](https://github.com/turban/Leaflet.Zoomify).
 ### Fast
 
 This module is powered by the blazingly fast
-[libvips](https://github.com/jcupitt/libvips) image processing library,
+[libvips](https://github.com/libvips/libvips) image processing library,
 originally created in 1989 at Birkbeck College
 and currently maintained by
 [John Cupitt](https://github.com/jcupitt).
@@ -112,17 +114,27 @@ the help and code contributions of the following people:
 * [Rik Heywood](https://github.com/rikh42)
 * [Thomas Parisot](https://github.com/oncletom)
 * [Nathan Graves](https://github.com/woolite64)
+* [Tom Lokhorst](https://github.com/tomlokhorst)
+* [Espen Hovlandsdal](https://github.com/rexxars)
+* [Sylvain Dumont](https://github.com/sylvaindumont)
+* [Alun Davies](https://github.com/alundavies)
+* [Aidan Hoolachan](https://github.com/ajhool)
+* [Axel Eirola](https://github.com/aeirola)
+* [Freezy](https://github.com/freezy)
+* [Julian Aubourg](https://github.com/jaubourg)
+* [Keith Belovay](https://github.com/fromkeith)
+* [Michael B. Klein](https://github.com/mbklein)
 
 Thank you!
 
-### Licence
+### Licensing
 
-Copyright 2013, 2014, 2015, 2016, 2017, 2018 Lovell Fuller and contributors.
+Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
 You may obtain a copy of the License at
-[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
+[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,

docs/install.md

@@ -15,7 +15,7 @@ yarn add sharp
 ### Building from source
 
 Pre-compiled binaries for sharp are provided for use with
-Node versions 4, 6, 8 and 9 on
+Node versions 6, 8, 10 and 11 on
 64-bit Windows, OS X and Linux platforms.
 
 Sharp will be built from source at install time when:
@@ -27,7 +27,7 @@ Sharp will be built from source at install time when:
 Building from source requires:
 
 * C++11 compatible compiler such as gcc 4.8+, clang 3.0+ or MSVC 2013+
-* [node-gyp](https://github.com/TooTallNate/node-gyp#installation) and its dependencies (includes Python)
+* [node-gyp](https://github.com/nodejs/node-gyp#installation) and its dependencies (includes Python 2.7)
 
 ## libvips
 
@@ -36,13 +36,14 @@ Building from source requires:
 [![Ubuntu 16.04 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
 
 libvips and its dependencies are fetched and stored within `node_modules/sharp/vendor` during `npm install`.
-This involves an automated HTTPS download of approximately 7MB.
+This involves an automated HTTPS download of approximately 9MB.
 
-Most recent Linux-based operating systems with glibc running on x64 and ARMv6+ CPUs should "just work", e.g.:
+Most Linux-based (glibc, musl) operating systems running on x64 and ARMv6+ CPUs should "just work", e.g.:
 
 * Debian 7+
 * Ubuntu 14.04+
 * Centos 7+
+* Alpine 3.8+ (Node 8 and 10)
 * Fedora
 * openSUSE 13.2+
 * Archlinux
@@ -61,9 +62,9 @@ and `LD_LIBRARY_PATH` at runtime.
 This allows the use of newer versions of libvips with older versions of sharp.
 
 For 32-bit Intel CPUs and older Linux-based operating systems such as Centos 6,
-it is recommended to install a system-wide installation of libvips from source:
+compiling libvips from source is recommended.
 
-https://jcupitt.github.io/libvips/install.html#building-libvips-from-a-source-tarball
+[https://libvips.github.io/libvips/install.html#building-libvips-from-a-source-tarball](https://libvips.github.io/libvips/install.html#building-libvips-from-a-source-tarball)
 
 #### Alpine Linux
 
@@ -71,7 +72,9 @@ libvips is available in the
 [testing repository](https://pkgs.alpinelinux.org/packages?name=vips-dev):
 
 ```sh
-apk add vips-dev fftw-dev --update-cache --repository https://dl-3.alpinelinux.org/alpine/edge/testing/
+apk add vips-dev fftw-dev build-base --update-cache \
+    --repository https://alpine.global.ssl.fastly.net/alpine/edge/testing/ \
+    --repository https://alpine.global.ssl.fastly.net/alpine/edge/main
 ```
 
 The smaller stack size of musl libc means
@@ -83,7 +86,7 @@ via `sharp.cache(false)` to avoid a stack overflow.
 [![OS X 10.12 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
 
 libvips and its dependencies are fetched and stored within `node_modules/sharp/vendor` during `npm install`.
-This involves an automated HTTPS download of approximately 7MB.
+This involves an automated HTTPS download of approximately 8MB.
 
 To use your own version of libvips instead of the provided binaries, make sure it is
 at least the version listed under `config.libvips` in the `package.json` file and
@@ -94,7 +97,9 @@ that it can be located using `pkg-config --modversion vips-cpp`.
 [![Windows x64 Build Status](https://ci.appveyor.com/api/projects/status/pgtul704nkhhg6sg)](https://ci.appveyor.com/project/lovell/sharp)
 
 libvips and its dependencies are fetched and stored within `node_modules\sharp\vendor` during `npm install`.
-This involves an automated HTTPS download of approximately 12MB.
+This involves an automated HTTPS download of approximately 14MB.
+If you are having issues during installation consider removing the directory
+`C:\Users\[user]\AppData\Roaming\npm-cache\_libvips`.
 
 Only 64-bit (x64) `node.exe` is supported.
 
@@ -117,9 +122,6 @@ https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=193528
 
 ### Heroku
 
-libvips and its dependencies are fetched and stored within `node_modules\sharp\vendor` during `npm install`.
-This involves an automated HTTPS download of approximately 7MB.
-
 Set [NODE_MODULES_CACHE](https://devcenter.heroku.com/articles/nodejs-support#cache-behavior)
 to `false` when using the `yarn` package manager.
 
@@ -148,18 +150,40 @@ docker pull tailor/docker-libvips
 
 ### AWS Lambda
 
-A [deployment package](http://docs.aws.amazon.com/lambda/latest/dg/nodejs-create-deployment-pkg.html) for the
-[Lambda Execution Environment](http://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html)
-can be built using Docker.
+Set the Lambda runtime to Node.js 8.10.
+
+The binaries in the `node_modules` directory of the
+[deployment package](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-create-deployment-pkg.html)
+must be for the Linux x64 platform/architecture.
+
+On non-Linux machines such as OS X and Windows run the following:
 
 ```sh
 rm -rf node_modules/sharp
-docker run -v "$PWD":/var/task lambci/lambda:build-nodejs6.10 npm install
+npm install --arch=x64 --platform=linux --target=8.10.0 sharp
 ```
 
-Set the Lambda runtime to Node.js 6.10.
+Alternatively a Docker container closely matching the Lambda runtime can be used:
 
-To get the best performance select the largest memory available. A 1536 MB function provides ~12x more CPU time than a 128 MB function.
+```sh
+rm -rf node_modules/sharp
+docker run -v "$PWD":/var/task lambci/lambda:build-nodejs8.10 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.
+
+### NW.js
+
+Run the `nw-gyp` tool after installation.
+
+```sh
+cd node-modules/sharp
+nw-gyp rebuild --arch=x64 --target=[your nw version]
+node node_modules/sharp/install/dll-copy
+```
+
+[http://docs.nwjs.io/en/latest/For%20Users/Advanced/Use%20Native%20Node%20Modules/](http://docs.nwjs.io/en/latest/For%20Users/Advanced/Use%20Native%20Node%20Modules/)
 
 ### Build tools
 
@@ -187,28 +211,6 @@ and [Valgrind](http://valgrind.org/) have been used to test
 the most popular web-based formats, as well as libvips itself,
 you are advised to perform your own testing and sandboxing.
 
-ImageMagick in particular has a relatively large attack surface,
-which can be partially mitigated with a
-[policy.xml](http://www.imagemagick.org/script/resources.php)
-configuration file to prevent the use of coders known to be vulnerable.
-
-```xml
-<policymap>
-  <policy domain="coder" rights="none" pattern="EPHEMERAL" />
-  <policy domain="coder" rights="none" pattern="URL" />
-  <policy domain="coder" rights="none" pattern="HTTPS" />
-  <policy domain="coder" rights="none" pattern="MVG" />
-  <policy domain="coder" rights="none" pattern="MSL" />
-  <policy domain="coder" rights="none" pattern="TEXT" />
-  <policy domain="coder" rights="none" pattern="SHOW" />
-  <policy domain="coder" rights="none" pattern="WIN" />
-  <policy domain="coder" rights="none" pattern="PLT" />
-</policymap>
-```
-
-Set the `MAGICK_CONFIGURE_PATH` environment variable
-to the directory containing the `policy.xml` file.
-
 ### Pre-compiled libvips binaries
 
 This module will attempt to download a pre-compiled bundle of libvips
@@ -224,10 +226,18 @@ SHARP_IGNORE_GLOBAL_LIBVIPS=1 npm install sharp
 ```
 
 Should you need to manually download and inspect these files,
-you can do so via https://github.com/lovell/sharp-libvips/releases
+you can do so via
+[https://github.com/lovell/sharp-libvips/releases](https://github.com/lovell/sharp-libvips/releases)
 
 Should you wish to install these from your own location,
-set the `SHARP_DIST_BASE_URL` environment variable, e.g.
+set the `sharp_dist_base_url` npm config option, e.g.
+
+```sh
+npm config set sharp_dist_base_url "https://hostname/path/"
+npm install sharp
+```
+
+or set the `SHARP_DIST_BASE_URL` environment variable, e.g.
 
 ```sh
 SHARP_DIST_BASE_URL="https://hostname/path/" npm install sharp
@@ -253,6 +263,8 @@ Use of libraries under the terms of the LGPLv3 is via the
 | expat         | MIT Licence                                                                                              |
 | fontconfig    | [fontconfig Licence](https://cgit.freedesktop.org/fontconfig/tree/COPYING) (BSD-like)                    |
 | freetype      | [freetype Licence](http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT) (BSD-like) |
+| fribidi       | LGPLv3                                                                                                   |
+| gettext       | LGPLv3                                                                                                   |
 | giflib        | MIT Licence                                                                                              |
 | glib          | LGPLv3                                                                                                   |
 | harfbuzz      | MIT Licence                                                                                              |

docs/performance.md

@@ -3,19 +3,17 @@
 ### Test environment
 
 * AWS EC2 eu-west-1 [c5.large](https://aws.amazon.com/ec2/instance-types/c5/) (2x Xeon Platinum 8124M CPU @ 3.00GHz)
-* Ubuntu 17.10 (hvm:ebs-ssd, 20180102, ami-0741d47e)
-* Node.js v8.9.4
+* Ubuntu 18.04 (hvm-ssd/ubuntu-bionic-18.04-amd64-server-20180912 ami-00035f41c82244dab)
+* Node.js v10.11.0
 
 ### The contenders
 
-* [jimp](https://www.npmjs.com/package/jimp) v0.2.28 - Image processing in pure JavaScript. Bilinear interpolation only.
-* [pajk-lwip](https://www.npmjs.com/package/pajk-lwip) v0.2.0 (fork) - Wrapper around CImg that compiles dependencies from source.
-* [mapnik](https://www.npmjs.org/package/mapnik) v3.6.2 - Whilst primarily a map renderer, Mapnik contains bitmap image utilities.
+* [jimp](https://www.npmjs.com/package/jimp) v0.5.3 - Image processing in pure JavaScript. Provides bicubic interpolation.
+* [mapnik](https://www.npmjs.org/package/mapnik) v4.0.1 - Whilst primarily a map renderer, Mapnik contains bitmap image utilities.
 * [imagemagick-native](https://www.npmjs.com/package/imagemagick-native) v1.9.3 - Wrapper around libmagick++, supports Buffers only.
 * [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.
-* [images](https://www.npmjs.com/package/images) v3.0.1 - Compiles dependencies from source. Provides bicubic interpolation.
-* sharp v0.19.0 / libvips v8.6.1 - Caching within libvips disabled to ensure a fair comparison.
+* sharp v0.21.0 / libvips v8.7.0 - Caching within libvips disabled to ensure a fair comparison.
 
 ### The task
 
@@ -27,19 +25,14 @@ then compress to JPEG at a "quality" setting of 80.
 
 | Module             | Input  | Output | Ops/sec | Speed-up |
 | :----------------- | :----- | :----- | ------: | -------: |
-| jimp (bilinear)    | buffer | buffer |    1.14 |      1.0 |
-| lwip               | buffer | buffer |    1.86 |      1.6 |
-| mapnik             | buffer | buffer |    3.34 |      2.9 |
-| imagemagick-native | buffer | buffer |    4.13 |      3.6 |
-| gm                 | buffer | buffer |    4.21 |      3.7 |
-| gm                 | file   | file   |    4.27 |      3.7 |
-| imagemagick        | file   | file   |    4.67 |      4.1 |
-| images (bicubic)   | file   | file   |    6.22 |      5.5 |
-| sharp              | stream | stream |   24.43 |     21.4 |
-| sharp              | file   | file   |   25.97 |     22.7 |
-| sharp              | file   | buffer |   26.00 |     22.8 |
-| sharp              | buffer | file   |   26.33 |     23.0 |
-| sharp              | buffer | buffer |   26.43 |     23.1 |
+| jimp               | buffer | buffer |    0.71 |      1.0 |
+| mapnik             | buffer | buffer |    3.32 |      4.7 |
+| gm                 | buffer | buffer |    3.97 |      5.6 |
+| imagemagick-native | buffer | buffer |    4.06 |      5.7 |
+| imagemagick        | file   | file   |    4.24 |      6.0 |
+| sharp              | stream | stream |   25.30 |     35.6 |
+| sharp              | file   | file   |   26.17 |     36.9 |
+| sharp              | buffer | buffer |   26.45 |     37.3 |
 
 Greater libvips performance can be expected with caching enabled (default)
 and using 8+ core machines, especially those with larger L1/L2 CPU caches.
@@ -57,7 +50,7 @@ brew install mapnik
 ```
 
 ```sh
-sudo apt-get install imagemagick libmagick++-dev graphicsmagick mapnik-dev
+sudo apt-get install imagemagick libmagick++-dev graphicsmagick libmapnik-dev
 ```
 
 ```sh

install/dll-copy.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const path = require('path');
 
 const copyFileSync = require('fs-copy-file-sync');
+const libvips = require('../lib/libvips');
 const npmLog = require('npmlog');
 
 if (process.platform === 'win32') {
@@ -11,8 +12,8 @@ if (process.platform === 'win32') {
   const buildReleaseDir = path.join(buildDir, 'Release');
   npmLog.info('sharp', `Creating ${buildReleaseDir}`);
   try {
-    fs.mkdirSync(buildDir);
-    fs.mkdirSync(buildReleaseDir);
+    libvips.mkdirSync(buildDir);
+    libvips.mkdirSync(buildReleaseDir);
   } catch (err) {}
   const vendorLibDir = path.join(__dirname, '..', 'vendor', 'lib');
   npmLog.info('sharp', `Copying DLLs from ${vendorLibDir} to ${buildReleaseDir}`);

install/libvips.js

@@ -9,13 +9,38 @@ const npmLog = require('npmlog');
 const semver = require('semver');
 const simpleGet = require('simple-get');
 const tar = require('tar');
+const copyFileSync = require('fs-copy-file-sync');
 
 const agent = require('../lib/agent');
 const libvips = require('../lib/libvips');
 const platform = require('../lib/platform');
 
 const minimumLibvipsVersion = libvips.minimumLibvipsVersion;
-const distBaseUrl = process.env.SHARP_DIST_BASE_URL || `https://github.com/lovell/sharp-libvips/releases/download/v${minimumLibvipsVersion}/`;
+const distBaseUrl = process.env.npm_config_sharp_dist_base_url || process.env.SHARP_DIST_BASE_URL || `https://github.com/lovell/sharp-libvips/releases/download/v${minimumLibvipsVersion}/`;
+
+const fail = function (err) {
+  npmLog.error('sharp', err.message);
+  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/page/install for required dependencies');
+  process.exit(1);
+};
+
+const extractTarball = function (tarPath) {
+  const vendorPath = path.join(__dirname, '..', 'vendor');
+  libvips.mkdirSync(vendorPath);
+  tar
+    .extract({
+      file: tarPath,
+      cwd: vendorPath,
+      strict: true
+    })
+    .catch(function (err) {
+      if (/unexpected end of file/.test(err.message)) {
+        npmLog.error('sharp', `Please delete ${tarPath} as it is not a valid tarball`);
+      }
+      fail(err);
+    });
+};
 
 try {
   const useGlobalLibvips = libvips.useGlobalLibvips();
@@ -29,20 +54,26 @@ try {
   } else {
     // Is this arch/platform supported?
     const arch = process.env.npm_config_arch || process.arch;
-    if (platform() === 'win32-ia32') {
+    const platformAndArch = platform();
+    if (platformAndArch === 'win32-ia32') {
       throw new Error('Windows x86 (32-bit) node.exe is not supported');
     }
     if (arch === 'ia32') {
-      throw new Error(`Intel Architecture 32-bit systems require manual installation of libvips >= ${minimumLibvipsVersion}\n`);
+      throw new Error(`Intel Architecture 32-bit systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
     }
-    if (detectLibc.isNonGlibcLinux) {
-      throw new Error(`Use with ${detectLibc.family} libc requires manual installation of libvips >= ${minimumLibvipsVersion}`);
+    if (platformAndArch === 'freebsd-x64' || platformAndArch === 'openbsd-x64' || platformAndArch === 'sunos-x64') {
+      throw new Error(`BSD/SunOS systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
     }
     if (detectLibc.family === detectLibc.GLIBC && detectLibc.version && semver.lt(`${detectLibc.version}.0`, '2.13.0')) {
       throw new Error(`Use with glibc version ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
     }
     // Download to per-process temporary file
-    const tarFilename = ['libvips', minimumLibvipsVersion, platform()].join('-') + '.tar.gz';
+    const tarFilename = ['libvips', minimumLibvipsVersion, platformAndArch].join('-') + '.tar.gz';
+    const tarPathCache = path.join(libvips.cachePath(), tarFilename);
+    if (fs.existsSync(tarPathCache)) {
+      npmLog.info('sharp', `Using cached ${tarPathCache}`);
+      extractTarball(tarPathCache);
+    } else {
       const tarPathTemp = path.join(os.tmpdir(), `${process.pid}-${tarFilename}`);
       const tmpFile = fs.createWriteStream(tarPathTemp);
       const url = distBaseUrl + tarFilename;
@@ -54,29 +85,25 @@ try {
         if (response.statusCode !== 200) {
           throw new Error(`Status ${response.statusCode}`);
         }
-      response.pipe(tmpFile);
+        response
+          .on('error', fail)
+          .pipe(tmpFile);
       });
-    tmpFile.on('close', function () {
-      const vendorPath = path.join(__dirname, '..', 'vendor');
-      fs.mkdirSync(vendorPath);
-      tar
-        .extract({
-          file: tarPathTemp,
-          cwd: vendorPath,
-          strict: true
-        })
-        .then(function () {
+      tmpFile
+        .on('error', fail)
+        .on('close', function () {
           try {
+            // Attempt to rename
+            fs.renameSync(tarPathTemp, tarPathCache);
+          } catch (err) {
+            // Fall back to copy and unlink
+            copyFileSync(tarPathTemp, tarPathCache);
             fs.unlinkSync(tarPathTemp);
-          } catch (err) {}
-        })
-        .catch(function (err) {
-          throw err;
-        });
+          }
+          extractTarball(tarPathCache);
         });
     }
+  }
 } catch (err) {
-  npmLog.error('sharp', err.message);
-  npmLog.error('sharp', 'Please see http://sharp.pixelplumbing.com/page/install');
-  process.exit(1);
+  fail(err);
 }

lib/channel.js

@@ -12,6 +12,40 @@ const bool = {
   eor: 'eor'
 };
 
+/**
+ * Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel.
+ *
+ * @example
+ * sharp('rgba.png')
+ *   .removeAlpha()
+ *   .toFile('rgb.png', function(err, info) {
+ *     // rgb.png is a 3 channel image without an alpha channel
+ *   });
+ *
+ * @returns {Sharp}
+ */
+function removeAlpha () {
+  this.options.removeAlpha = true;
+  return this;
+}
+
+/**
+ * Ensure alpha channel, if missing. The added alpha channel will be fully opaque. This is a no-op if the image already has an alpha channel.
+ *
+ * @example
+ * sharp('rgb.jpg')
+ *   .ensureAlpha()
+ *   .toFile('rgba.png', function(err, info) {
+ *     // rgba.png is a 4 channel image with a fully opaque alpha channel
+ *   });
+ *
+ * @returns {Sharp}
+ */
+function ensureAlpha () {
+  this.options.ensureAlpha = true;
+  return this;
+}
+
 /**
  * Extract a single channel from a multi-channel image.
  *
@@ -100,13 +134,13 @@ function bandbool (boolOp) {
  * @private
  */
 module.exports = function (Sharp) {
+  Object.assign(Sharp.prototype, {
     // Public instance functions
-  [
+    removeAlpha,
+    ensureAlpha,
     extractChannel,
     joinChannel,
     bandbool
-  ].forEach(function (f) {
-    Sharp.prototype[f.name] = f;
   });
   // Class attributes
   Sharp.bool = bool;

lib/colour.js

@@ -15,29 +15,6 @@ const colourspace = {
   srgb: 'srgb'
 };
 
-/**
- * Set the background for the `embed`, `flatten` and `extend` operations.
- * The default background is `{r: 0, g: 0, b: 0, alpha: 1}`, black without transparency.
- *
- * Delegates to the _color_ module, which can throw an Error
- * but is liberal in what it accepts, clipping values to sensible min/max.
- * The alpha value is a float between `0` (transparent) and `1` (opaque).
- *
- * @param {String|Object} rgba - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
- * @returns {Sharp}
- * @throws {Error} Invalid parameter
- */
-function background (rgba) {
-  const colour = color(rgba);
-  this.options.background = [
-    colour.red(),
-    colour.green(),
-    colour.blue(),
-    Math.round(colour.alpha() * 255)
-  ];
-  return this;
-}
-
 /**
  * Tint the image using the provided chroma while preserving the image luminance.
  * An alpha channel may be present and will be unchanged by the operation.
@@ -80,7 +57,7 @@ function grayscale (grayscale) {
 /**
  * Set the output colourspace.
  * By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
- * @param {String} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
+ * @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
  */
@@ -102,21 +79,39 @@ function toColorspace (colorspace) {
   return this.toColourspace(colorspace);
 }
 
+/**
+ * Update a colour attribute of the this.options Object.
+ * @private
+ * @param {String} key
+ * @param {String|Object} val
+ * @throws {Error} Invalid key
+ */
+function _setColourOption (key, val) {
+  if (is.object(val) || is.string(val)) {
+    const colour = color(val);
+    this.options[key] = [
+      colour.red(),
+      colour.green(),
+      colour.blue(),
+      Math.round(colour.alpha() * 255)
+    ];
+  }
+}
+
 /**
  * Decorate the Sharp prototype with colour-related functions.
  * @private
  */
 module.exports = function (Sharp) {
-  // Public instance functions
-  [
-    background,
+  Object.assign(Sharp.prototype, {
+    // Public
     tint,
     greyscale,
     grayscale,
     toColourspace,
-    toColorspace
-  ].forEach(function (f) {
-    Sharp.prototype[f.name] = f;
+    toColorspace,
+    // Private
+    _setColourOption
   });
   // Class attributes
   Sharp.colourspace = colourspace;

lib/composite.js

@@ -1,26 +1,69 @@
 'use strict';
 
+const deprecate = require('util').deprecate;
+
 const is = require('./is');
 
 /**
- * Overlay (composite) an image over the processed (resized, extracted etc.) image.
+ * Blend modes.
+ * @member
+ * @private
+ */
+const blend = {
+  clear: 'clear',
+  source: 'source',
+  over: 'over',
+  in: 'in',
+  out: 'out',
+  atop: 'atop',
+  dest: 'dest',
+  'dest-over': 'dest-over',
+  'dest-in': 'dest-in',
+  'dest-out': 'dest-out',
+  'dest-atop': 'dest-atop',
+  xor: 'xor',
+  add: 'add',
+  saturate: 'saturate',
+  multiply: 'multiply',
+  screen: 'screen',
+  overlay: 'overlay',
+  darken: 'darken',
+  lighten: 'lighten',
+  'colour-dodge': 'colour-dodge',
+  'color-dodge': 'colour-dodge',
+  'colour-burn': 'colour-burn',
+  'color-burn': 'colour-burn',
+  'hard-light': 'hard-light',
+  'soft-light': 'soft-light',
+  difference: 'difference',
+  exclusion: 'exclusion'
+};
+
+/**
+ * Composite image(s) over the processed (resized, extracted etc.) image.
  *
- * The overlay image must be the same size or smaller than the processed image.
+ * The images to composite must be the same size or smaller than the processed image.
  * If both `top` and `left` options are provided, they take precedence over `gravity`.
  *
- * If the overlay image contains an alpha channel then composition with premultiplication will occur.
+ * The `blend` option can be one of `clear`, `source`, `over`, `in`, `out`, `atop`,
+ * `dest`, `dest-over`, `dest-in`, `dest-out`, `dest-atop`,
+ * `xor`, `add`, `saturate`, `multiply`, `screen`, `overlay`, `darken`, `lighten`,
+ * `colour-dodge`, `color-dodge`, `colour-burn`,`color-burn`,
+ * `hard-light`, `soft-light`, `difference`, `exclusion`.
+ *
+ * More information about blend modes can be found at
+ * https://libvips.github.io/libvips/API/current/libvips-conversion.html#VipsBlendMode
+ * and https://www.cairographics.org/operators/
  *
  * @example
  * sharp('input.png')
  *   .rotate(180)
  *   .resize(300)
- *   .flatten()
- *   .background('#ff6600')
- *   .overlayWith('overlay.png', { gravity: sharp.gravity.southeast } )
+ *   .flatten( { background: '#ff6600' } )
+ *   .composite([{ input: 'overlay.png', gravity: 'southeast' }])
  *   .sharpen()
  *   .withMetadata()
- *   .quality(90)
- *   .webp()
+ *   .webp( { quality: 90 } )
  *   .toBuffer()
  *   .then(function(outputBuffer) {
  *     // outputBuffer contains upside down, 300px wide, alpha channel flattened
@@ -28,70 +71,104 @@ const is = require('./is');
  *     // sharpened, with metadata, 90% quality WebP image data. Phew!
  *   });
  *
- * @param {(Buffer|String)} overlay - Buffer containing image data or String containing the path to an image file.
- * @param {Object} [options]
- * @param {String} [options.gravity='centre'] - gravity at which to place the overlay.
- * @param {Number} [options.top] - the pixel offset from the top edge.
- * @param {Number} [options.left] - the pixel offset from the left edge.
- * @param {Boolean} [options.tile=false] - set to true to repeat the overlay image across the entire image with the given `gravity`.
- * @param {Boolean} [options.cutout=false] - set to true to apply only the alpha channel of the overlay image to the input image, giving the appearance of one image being cut out of another.
- * @param {Number} [options.density=72] - integral number representing the DPI for vector overlay image.
- * @param {Object} [options.raw] - describes overlay when using raw pixel data.
- * @param {Number} [options.raw.width]
- * @param {Number} [options.raw.height]
- * @param {Number} [options.raw.channels]
- * @param {Object} [options.create] - describes a blank overlay to be created.
- * @param {Number} [options.create.width]
- * @param {Number} [options.create.height]
- * @param {Number} [options.create.channels] - 3-4
- * @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[]} images - Ordered list of images to composite
+ * @param {Buffer|String} [images[].input] - Buffer containing image data or String containing the path to an image file.
+ * @param {String} [images[].blend='over'] - how to blend this image with the image below.
+ * @param {String} [images[].gravity='centre'] - gravity at which to place the overlay.
+ * @param {Number} [images[].top] - the pixel offset from the top edge.
+ * @param {Number} [images[].left] - the pixel offset from the left edge.
+ * @param {Boolean} [images[].tile=false] - set to true to repeat the overlay image across the entire image with the given `gravity`.
+ * @param {Number} [images[].density=72] - number representing the DPI for vector overlay image.
+ * @param {Object} [images[].raw] - describes overlay when using raw pixel data.
+ * @param {Number} [images[].raw.width]
+ * @param {Number} [images[].raw.height]
+ * @param {Number} [images[].raw.channels]
+ * @param {Object} [images[].create] - describes a blank overlay to be created.
+ * @param {Number} [images[].create.width]
+ * @param {Number} [images[].create.height]
+ * @param {Number} [images[].create.channels] - 3-4
+ * @param {String|Object} [images[].create.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
-function overlayWith (overlay, options) {
-  this.options.overlay = this._createInputDescriptor(overlay, options, {
-    allowStream: false
+function composite (images) {
+  if (!Array.isArray(images)) {
+    throw is.invalidParameterError('images to composite', 'array', images);
+  }
+  this.options.composite = images.map(image => {
+    if (!is.object(image)) {
+      throw is.invalidParameterError('image to composite', 'object', image);
+    }
+    const { raw, density } = image;
+    const inputOptions = (raw || density) ? { raw, density } : undefined;
+    const composite = {
+      input: this._createInputDescriptor(image.input, inputOptions, { allowStream: false }),
+      blend: 'over',
+      tile: false,
+      left: -1,
+      top: -1,
+      gravity: 0
+    };
+    if (is.defined(image.blend)) {
+      if (is.string(blend[image.blend])) {
+        composite.blend = blend[image.blend];
+      } else {
+        throw is.invalidParameterError('blend', 'valid blend name', image.blend);
+      }
+    }
+    if (is.defined(image.tile)) {
+      if (is.bool(image.tile)) {
+        composite.tile = image.tile;
+      } else {
+        throw is.invalidParameterError('tile', 'boolean', image.tile);
+      }
+    }
+    if (is.defined(image.left)) {
+      if (is.integer(image.left) && image.left >= 0) {
+        composite.left = image.left;
+      } else {
+        throw is.invalidParameterError('left', 'positive integer', image.left);
+      }
+    }
+    if (is.defined(image.top)) {
+      if (is.integer(image.top) && image.top >= 0) {
+        composite.top = image.top;
+      } else {
+        throw is.invalidParameterError('top', 'positive integer', image.top);
+      }
+    }
+    if (composite.left !== composite.top && Math.min(composite.left, composite.top) === -1) {
+      throw new Error('Expected both left and top to be set');
+    }
+    if (is.defined(image.gravity)) {
+      if (is.integer(image.gravity) && is.inRange(image.gravity, 0, 8)) {
+        composite.gravity = image.gravity;
+      } else if (is.string(image.gravity) && is.integer(this.constructor.gravity[image.gravity])) {
+        composite.gravity = this.constructor.gravity[image.gravity];
+      } else {
+        throw is.invalidParameterError('gravity', 'valid gravity', image.gravity);
+      }
+    }
+    return composite;
   });
-  if (is.object(options)) {
-    if (is.defined(options.tile)) {
-      if (is.bool(options.tile)) {
-        this.options.overlayTile = options.tile;
-      } else {
-        throw new Error('Invalid overlay tile ' + options.tile);
-      }
-    }
-    if (is.defined(options.cutout)) {
-      if (is.bool(options.cutout)) {
-        this.options.overlayCutout = options.cutout;
-      } else {
-        throw new Error('Invalid overlay cutout ' + options.cutout);
-      }
-    }
-    if (is.defined(options.left) || is.defined(options.top)) {
-      if (is.integer(options.left) && options.left >= 0 && is.integer(options.top) && options.top >= 0) {
-        this.options.overlayXOffset = options.left;
-        this.options.overlayYOffset = options.top;
-      } else {
-        throw new Error('Invalid overlay left ' + options.left + ' and/or top ' + options.top);
-      }
-    }
-    if (is.defined(options.gravity)) {
-      if (is.integer(options.gravity) && is.inRange(options.gravity, 0, 8)) {
-        this.options.overlayGravity = options.gravity;
-      } else if (is.string(options.gravity) && is.integer(this.constructor.gravity[options.gravity])) {
-        this.options.overlayGravity = this.constructor.gravity[options.gravity];
-      } else {
-        throw new Error('Unsupported overlay gravity ' + options.gravity);
-      }
-    }
-  }
   return this;
 }
 
+/**
+ * @deprecated
+ * @private
+ */
+function overlayWith (input, options) {
+  const blend = (is.object(options) && options.cutout) ? 'dest-in' : 'over';
+  return this.composite([Object.assign({ input, blend }, options)]);
+}
+
 /**
  * Decorate the Sharp prototype with composite-related functions.
  * @private
  */
 module.exports = function (Sharp) {
-  Sharp.prototype.overlayWith = overlayWith;
+  Sharp.prototype.composite = composite;
+  Sharp.prototype.overlayWith = deprecate(overlayWith, 'overlayWith(input, options) is deprecated, use composite([{ input, ...options }]) instead');
+  Sharp.blend = blend;
 };

lib/constructor.js

@@ -4,42 +4,10 @@ const path = require('path');
 const util = require('util');
 const stream = require('stream');
 const events = require('events');
-const semver = require('semver');
 const is = require('./is');
-const platform = require('./platform');
-const sharp = require('../build/Release/sharp.node');
 
-// Vendor platform
-(function () {
-  let vendorPlatformId;
-  try {
-    vendorPlatformId = require('../vendor/platform.json');
-  } catch (err) {
-    return;
-  }
-  const currentPlatformId = platform();
-  /* istanbul ignore if */
-  if (currentPlatformId !== vendorPlatformId) {
-    throw new Error(`'${vendorPlatformId}' binaries cannot be used on the '${currentPlatformId}' platform. Please remove the 'node_modules/sharp/vendor' directory and run 'npm rebuild'.`);
-  }
-})();
-
-// Versioning
-let versions = {
-  vips: sharp.libvipsVersion()
-};
-(function () {
-  // Does libvips meet minimum requirement?
-  const libvipsVersionMin = require('../package.json').config.libvips;
-  /* istanbul ignore if */
-  if (semver.lt(versions.vips, libvipsVersionMin)) {
-    throw new Error('Found libvips ' + versions.vips + ' but require at least ' + libvipsVersionMin);
-  }
-  // Include versions of dependencies, if present
-  try {
-    versions = require('../vendor/versions.json');
-  } catch (err) {}
-})();
+require('./libvips').hasVendoredLibvips();
+const sharp = require('bindings')('sharp.node');
 
 // Use NODE_DEBUG=sharp to enable libvips warnings
 const debuglog = util.debuglog('sharp');
@@ -81,7 +49,7 @@ const debuglog = util.debuglog('sharp');
  *     width: 300,
  *     height: 200,
  *     channels: 4,
- *     background: { r: 255, g: 0, b: 0, alpha: 128 }
+ *     background: { r: 255, g: 0, b: 0, alpha: 0.5 }
  *   }
  * })
  * .png()
@@ -93,11 +61,11 @@ const debuglog = util.debuglog('sharp');
  *  a String containing the path to an JPEG, PNG, WebP, GIF, SVG or TIFF image file.
  *  JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
  * @param {Object} [options] - if present, is an Object with optional attributes.
- * @param {Boolean} [options.failOnError=false] - by default apply a "best effort"
- *  to decode images, even if the data is corrupt or invalid. Set this flag to true
- *  if you'd rather halt processing and raise an error when loading invalid images.
- * @param {Number} [options.density=72] - integral number representing the DPI for vector images.
- * @param {Number} [options.page=0] - page number to extract for multi-page input (GIF, TIFF)
+ * @param {Boolean} [options.failOnError=true] - by default halt processing and raise an error when loading invalid images.
+ *  Set this flag to `false` if you'd rather apply a "best effort" to decode images, even if the data is corrupt or invalid.
+ * @param {Number} [options.density=72] - number representing the DPI for vector images.
+ * @param {Number} [options.pages=1] - number of pages to extract for multi-page input (GIF, TIFF, PDF), use -1 for all pages.
+ * @param {Number} [options.page=0] - page number to start extracting from for multi-page input (GIF, TIFF, PDF), zero based.
  * @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]
@@ -136,10 +104,12 @@ const Sharp = function (input, options) {
     width: -1,
     height: -1,
     canvas: 'crop',
-    crop: 0,
-    embed: 0,
+    position: 0,
+    resizeBackground: [0, 0, 0, 255],
     useExifOrientation: false,
     angle: 0,
+    rotationAngle: 0,
+    rotationBackground: [0, 0, 0, 255],
     rotateBeforePreExtract: false,
     flip: false,
     flop: false,
@@ -147,14 +117,15 @@ const Sharp = function (input, options) {
     extendBottom: 0,
     extendLeft: 0,
     extendRight: 0,
+    extendBackground: [0, 0, 0, 255],
     withoutEnlargement: false,
     kernel: 'lanczos3',
     fastShrinkOnLoad: true,
     // operations
-    background: [0, 0, 0, 255],
-    tintA: 0,
-    tintB: 0,
+    tintA: 128,
+    tintB: 128,
     flatten: false,
+    flattenBackground: [0, 0, 0],
     negate: false,
     medianSize: 0,
     blurSigma: 0,
@@ -163,21 +134,19 @@ const Sharp = function (input, options) {
     sharpenJagged: 2,
     threshold: 0,
     thresholdGrayscale: true,
-    trimTolerance: 0,
+    trimThreshold: 0,
     gamma: 0,
+    gammaOut: 0,
     greyscale: false,
     normalise: 0,
     booleanBufferIn: null,
     booleanFileIn: '',
     joinChannelIn: [],
     extractChannel: -1,
+    removeAlpha: false,
+    ensureAlpha: false,
     colourspace: 'srgb',
-    // overlay
-    overlayGravity: 0,
-    overlayXOffset: -1,
-    overlayYOffset: -1,
-    overlayTile: false,
-    overlayCutout: false,
+    composite: [],
     // output
     fileOut: '',
     formatOut: 'input',
@@ -192,9 +161,15 @@ const Sharp = function (input, options) {
     jpegTrellisQuantisation: false,
     jpegOvershootDeringing: false,
     jpegOptimiseScans: false,
+    jpegOptimiseCoding: true,
+    jpegQuantisationTable: 0,
     pngProgressive: false,
     pngCompressionLevel: 9,
     pngAdaptiveFiltering: false,
+    pngPalette: false,
+    pngQuality: 100,
+    pngColours: 256,
+    pngDither: 1,
     webpQuality: 80,
     webpAlphaQuality: 100,
     webpLossless: false,
@@ -202,7 +177,11 @@ const Sharp = function (input, options) {
     tiffQuality: 80,
     tiffCompression: 'jpeg',
     tiffPredictor: 'horizontal',
+    tiffPyramid: false,
     tiffSquash: false,
+    tiffTile: false,
+    tiffTileHeight: 256,
+    tiffTileWidth: 256,
     tiffXres: 1.0,
     tiffYres: 1.0,
     tileSize: 256,
@@ -248,7 +227,12 @@ Sharp.format = sharp.format();
  * @example
  * console.log(sharp.versions);
  */
-Sharp.versions = versions;
+Sharp.versions = {
+  vips: sharp.libvipsVersion()
+};
+try {
+  Sharp.versions = require('../vendor/versions.json');
+} catch (err) {}
 
 /**
  * Export constructor.

lib/input.js

@@ -9,7 +9,7 @@ const sharp = require('../build/Release/sharp.node');
  * @private
  */
 function _createInputDescriptor (input, inputOptions, containerOptions) {
-  const inputDescriptor = { failOnError: false };
+  const inputDescriptor = { failOnError: true };
   if (is.string(input)) {
     // filesystem
     inputDescriptor.file = input;
@@ -19,6 +19,10 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
   } else if (is.plainObject(input) && !is.defined(inputOptions)) {
     // Plain Object descriptor, e.g. create
     inputOptions = input;
+    if (is.plainObject(inputOptions.raw)) {
+      // Raw Stream
+      inputDescriptor.buffer = [];
+    }
   } else if (!is.defined(input) && is.object(containerOptions) && containerOptions.allowStream) {
     // Stream
     inputDescriptor.buffer = [];
@@ -36,7 +40,7 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     }
     // Density
     if (is.defined(inputOptions.density)) {
-      if (is.integer(inputOptions.density) && is.inRange(inputOptions.density, 1, 2400)) {
+      if (is.inRange(inputOptions.density, 1, 2400)) {
         inputDescriptor.density = inputOptions.density;
       } else {
         throw new Error('Invalid density (1 to 2400) ' + inputOptions.density);
@@ -57,7 +61,12 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw new Error('Expected width, height and channels for raw pixel input');
       }
     }
-    // Page input for multi-page TIFF
+    // Multi-page input (GIF, TIFF, PDF)
+    if (is.defined(inputOptions.pages)) {
+      if (is.integer(inputOptions.pages) && is.inRange(inputOptions.pages, -1, 100000)) {
+        inputDescriptor.pages = inputOptions.pages;
+      }
+    }
     if (is.defined(inputOptions.page)) {
       if (is.integer(inputOptions.page) && is.inRange(inputOptions.page, 0, 100000)) {
         inputDescriptor.page = inputOptions.page;
@@ -174,15 +183,20 @@ function clone () {
 
 /**
  * Fast access to (uncached) image metadata without decoding any compressed image data.
- * A Promises/A+ promise is returned when `callback` is not provided.
+ * A `Promise` is returned when `callback` is not provided.
  *
  * - `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
+ * - `size`: Total size of image in bytes, for Stream and Buffer input only
  * - `width`: Number of pixels wide (EXIF orientation is not taken into consideration)
  * - `height`: Number of pixels high (EXIF orientation is not taken into consideration)
- * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L636)
+ * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L636)
  * - `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
- * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L672)
+ * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L672)
  * - `density`: Number of pixels per inch (DPI), if present
+ * - `chromaSubsampling`: String containing JPEG chroma subsampling, `4:2:0` or `4:4:4` for RGB, `4:2:0:4` or `4:4:4:4` for CMYK
+ * - `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
+ * - `pages`: Number of pages/frames contained within the image, with support for TIFF, PDF, animated GIF and animated WebP
+ * - `pageHeight`: Number of pixels high each page in this PDF image will be.
  * - `hasProfile`: Boolean indicating the presence of an embedded ICC profile
  * - `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
  * - `orientation`: Number value of the EXIF Orientation header, if present
@@ -250,7 +264,7 @@ function metadata (callback) {
 
 /**
  * Access to pixel-derived image statistics for every channel in the image.
- * A Promise is returned when `callback` is not provided.
+ * A `Promise` is returned when `callback` is not provided.
  *
  * - `channels`: Array of channel statistics for each channel in the image. Each channel statistic contains
  *     - `min` (minimum value in the channel)
@@ -264,6 +278,7 @@ function metadata (callback) {
  *     - `maxX` (x-coordinate of one of the pixel where the maximum lies)
  *     - `maxY` (y-coordinate of one of the pixel where the maximum lies)
  * - `isOpaque`: Value to identify if the image is opaque or transparent, based on the presence and use of alpha channel
+ * - `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any (experimental)
  *
  * @example
  * const image = sharp(inputJpg);
@@ -317,9 +332,9 @@ function stats (callback) {
 }
 
 /**
- * Do not process input images where the number of pixels (width * height) exceeds this limit.
+ * 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.
- * The default limit is 268402689 (0x3FFF * 0x3FFF) pixels.
+ * The default limit is 268402689 (0x3FFF x 0x3FFF) pixels.
  * @param {(Number|Boolean)} limit - an integral Number of pixels, zero or false to remove limit, true to use default limit.
  * @returns {Sharp}
  * @throws {Error} Invalid limit
@@ -358,7 +373,7 @@ function sequentialRead (sequentialRead) {
  * @private
  */
 module.exports = function (Sharp) {
-  [
+  Object.assign(Sharp.prototype, {
     // Private
     _createInputDescriptor,
     _write,
@@ -370,7 +385,5 @@ module.exports = function (Sharp) {
     stats,
     limitInputPixels,
     sequentialRead
-  ].forEach(function (f) {
-    Sharp.prototype[f.name] = f;
   });
 };

lib/libvips.js

@@ -1,17 +1,38 @@
 'use strict';
 
+const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const spawnSync = require('child_process').spawnSync;
 const semver = require('semver');
 const platform = require('./platform');
 
-const minimumLibvipsVersion = process.env.npm_package_config_libvips || require('../package.json').config.libvips;
+const env = process.env;
+const minimumLibvipsVersion = env.npm_package_config_libvips || require('../package.json').config.libvips;
 
 const spawnSyncOptions = {
   encoding: 'utf8',
   shell: true
 };
 
+const mkdirSync = function (dirPath) {
+  try {
+    fs.mkdirSync(dirPath);
+  } catch (err) {
+    if (err.code !== 'EEXIST') {
+      throw err;
+    }
+  }
+};
+
+const cachePath = function () {
+  const npmCachePath = env.npm_config_cache || (env.APPDATA ? path.join(env.APPDATA, 'npm-cache') : path.join(os.homedir(), '.npm'));
+  mkdirSync(npmCachePath);
+  const libvipsCachePath = path.join(npmCachePath, '_libvips');
+  mkdirSync(libvipsCachePath);
+  return libvipsCachePath;
+};
+
 const globalLibvipsVersion = function () {
   if (process.platform !== 'win32') {
     const globalLibvipsVersion = spawnSync(`PKG_CONFIG_PATH="${pkgConfigPath()}" pkg-config --modversion vips-cpp`, spawnSyncOptions).stdout || '';
@@ -23,21 +44,30 @@ const globalLibvipsVersion = function () {
 
 const hasVendoredLibvips = function () {
   const currentPlatformId = platform();
+  const vendorPath = path.join(__dirname, '..', 'vendor');
+  let vendorVersionId;
+  let vendorPlatformId;
   try {
-    const vendorPlatformId = require(path.join(__dirname, '..', 'vendor', 'platform.json'));
+    vendorVersionId = require(path.join(vendorPath, 'versions.json')).vips;
+    vendorPlatformId = require(path.join(vendorPath, 'platform.json'));
+  } catch (err) {}
+  if (vendorVersionId && vendorVersionId !== minimumLibvipsVersion) {
+    throw new Error(`Found vendored libvips v${vendorVersionId} but require v${minimumLibvipsVersion}. Please remove the 'node_modules/sharp/vendor' directory and run 'npm install'.`);
+  }
+  if (vendorPlatformId) {
     if (currentPlatformId === vendorPlatformId) {
       return true;
     } else {
       throw new Error(`'${vendorPlatformId}' binaries cannot be used on the '${currentPlatformId}' platform. Please remove the 'node_modules/sharp/vendor' directory and run 'npm install'.`);
     }
-  } catch (err) {}
+  }
   return false;
 };
 
 const pkgConfigPath = function () {
   if (process.platform !== 'win32') {
     const brewPkgConfigPath = spawnSync('which brew >/dev/null 2>&1 && eval $(brew --env) && echo $PKG_CONFIG_LIBDIR', spawnSyncOptions).stdout || '';
-    return [brewPkgConfigPath.trim(), process.env.PKG_CONFIG_PATH, '/usr/local/lib/pkgconfig', '/usr/lib/pkgconfig']
+    return [brewPkgConfigPath.trim(), env.PKG_CONFIG_PATH, '/usr/local/lib/pkgconfig', '/usr/lib/pkgconfig']
       .filter(function (p) { return !!p; })
       .join(':');
   } else {
@@ -46,7 +76,7 @@ const pkgConfigPath = function () {
 };
 
 const useGlobalLibvips = function () {
-  if (Boolean(process.env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
+  if (Boolean(env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
     return false;
   }
 
@@ -56,8 +86,10 @@ const useGlobalLibvips = function () {
 
 module.exports = {
   minimumLibvipsVersion: minimumLibvipsVersion,
+  cachePath: cachePath,
   globalLibvipsVersion: globalLibvipsVersion,
   hasVendoredLibvips: hasVendoredLibvips,
   pkgConfigPath: pkgConfigPath,
-  useGlobalLibvips: useGlobalLibvips
+  useGlobalLibvips: useGlobalLibvips,
+  mkdirSync: mkdirSync
 };

lib/operation.js

@@ -1,14 +1,18 @@
 'use strict';
 
+const color = require('color');
 const is = require('./is');
 
 /**
  * Rotate the output image by either an explicit angle
  * or auto-orient based on the EXIF `Orientation` tag.
  *
- * If an angle is provided, it is converted to a valid 90/180/270deg rotation.
+ * If an angle is provided, it is converted to a valid positive degree rotation.
  * For example, `-450` will produce a 270deg rotation.
  *
+ * When rotating by an angle other than a multiple of 90,
+ * the background colour can be provided with the `background` option.
+ *
  * If no angle is provided, it is determined from the EXIF data.
  * Mirroring is supported and may infer the use of a flip operation.
  *
@@ -28,64 +32,30 @@ const is = require('./is');
  *   });
  * readableStream.pipe(pipeline);
  *
- * @param {Number} [angle=auto] angle of rotation, must be a multiple of 90.
+ * @param {Number} [angle=auto] angle of rotation.
+ * @param {Object} [options] - if present, is an Object with optional attributes.
+ * @param {String|Object} [options.background="#000000"] parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
-function rotate (angle) {
+function rotate (angle, options) {
   if (!is.defined(angle)) {
     this.options.useExifOrientation = true;
   } else if (is.integer(angle) && !(angle % 90)) {
     this.options.angle = angle;
-  } else {
-    throw new Error('Unsupported angle: angle must be a positive/negative multiple of 90 ' + angle);
+  } else if (is.number(angle)) {
+    this.options.rotationAngle = angle;
+    if (is.object(options) && options.background) {
+      const backgroundColour = color(options.background);
+      this.options.rotationBackground = [
+        backgroundColour.red(),
+        backgroundColour.green(),
+        backgroundColour.blue(),
+        Math.round(backgroundColour.alpha() * 255)
+      ];
     }
-  return this;
-}
-
-/**
- * Extract a region of the image.
- *
- * - Use `extract` before `resize` for pre-resize extraction.
- * - Use `extract` after `resize` for post-resize extraction.
- * - Use `extract` before and after for both.
- *
- * @example
- * sharp(input)
- *   .extract({ left: left, top: top, width: width, height: height })
- *   .toFile(output, function(err) {
- *     // Extract a region of the input image, saving in the same format.
- *   });
- * @example
- * sharp(input)
- *   .extract({ left: leftOffsetPre, top: topOffsetPre, width: widthPre, height: heightPre })
- *   .resize(width, height)
- *   .extract({ left: leftOffsetPost, top: topOffsetPost, width: widthPost, height: heightPost })
- *   .toFile(output, function(err) {
- *     // Extract a region, resize, then extract from the resized image
- *   });
- *
- * @param {Object} options
- * @param {Number} options.left - zero-indexed offset from left edge
- * @param {Number} options.top - zero-indexed offset from top edge
- * @param {Number} options.width - dimension of extracted image
- * @param {Number} options.height - dimension of extracted image
- * @returns {Sharp}
- * @throws {Error} Invalid parameters
- */
-function extract (options) {
-  const suffix = this.options.width === -1 && this.options.height === -1 ? 'Pre' : 'Post';
-  ['left', 'top', 'width', 'height'].forEach(function (name) {
-    const value = options[name];
-    if (is.integer(value) && value >= 0) {
-      this.options[name + (name === 'left' || name === 'top' ? 'Offset' : '') + suffix] = value;
   } else {
-      throw new Error('Non-integer value for ' + name + ' of ' + value);
-    }
-  }, this);
-  // Ensure existing rotation occurs before pre-resize extraction
-  if (suffix === 'Pre' && ((this.options.angle % 360) !== 0 || this.options.useExifOrientation === true)) {
-    this.options.rotateBeforePreExtract = true;
+    throw new Error('Unsupported angle: must be a number.');
   }
   return this;
 }
@@ -201,72 +171,15 @@ function blur (sigma) {
 }
 
 /**
- * Extends/pads the edges of the image with the colour provided to the `background` method.
- * This operation will always occur after resizing and extraction, if any.
- *
- * @example
- * // Resize to 140 pixels wide, then add 10 transparent pixels
- * // to the top, left and right edges and 20 to the bottom edge
- * sharp(input)
- *   .resize(140)
- *   .background({r: 0, g: 0, b: 0, alpha: 0})
- *   .extend({top: 10, bottom: 20, left: 10, right: 10})
- *   ...
- *
- * @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]
- * @returns {Sharp}
- * @throws {Error} Invalid parameters
-*/
-function extend (extend) {
-  if (is.integer(extend) && extend > 0) {
-    this.options.extendTop = 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 {
-    throw new Error('Invalid edge extension ' + extend);
-  }
-  return this;
-}
-
-/**
- * Merge alpha transparency channel, if any, with `background`.
- * @param {Boolean} [flatten=true]
+ * Merge alpha transparency channel, if any, with a background.
+ * @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}
  */
-function flatten (flatten) {
-  this.options.flatten = is.bool(flatten) ? flatten : true;
-  return this;
-}
-
-/**
- * Trim "boring" pixels from all edges that contain values within a percentage similarity of the top-left pixel.
- * @param {Number} [tolerance=10] value between 1 and 99 representing the percentage similarity.
- * @returns {Sharp}
- * @throws {Error} Invalid parameters
- */
-function trim (tolerance) {
-  if (!is.defined(tolerance)) {
-    this.options.trimTolerance = 10;
-  } else if (is.integer(tolerance) && is.inRange(tolerance, 1, 99)) {
-    this.options.trimTolerance = tolerance;
-  } else {
-    throw new Error('Invalid trim tolerance (1 to 99) ' + tolerance);
+function flatten (options) {
+  this.options.flatten = is.bool(options) ? options : true;
+  if (is.object(options)) {
+    this._setColourOption('flattenBackground', options.background);
   }
   return this;
 }
@@ -277,11 +190,15 @@ function trim (tolerance) {
  * This can improve the perceived brightness of a resized image in non-linear colour spaces.
  * JPEG and WebP input images will not take advantage of the shrink-on-load performance optimisation
  * when applying a gamma correction.
+ *
+ * Supply a second argument to use a different output gamma value, otherwise the first value is used in both cases.
+ *
  * @param {Number} [gamma=2.2] value between 1.0 and 3.0.
+ * @param {Number} [gammaOut] value between 1.0 and 3.0. (optional, defaults to same as `gamma`)
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
-function gamma (gamma) {
+function gamma (gamma, gammaOut) {
   if (!is.defined(gamma)) {
     // Default gamma correction of 2.2 (sRGB)
     this.options.gamma = 2.2;
@@ -290,6 +207,14 @@ function gamma (gamma) {
   } else {
     throw new Error('Invalid gamma correction (1.0 to 3.0) ' + gamma);
   }
+  if (!is.defined(gammaOut)) {
+    // Default gamma correction for output is same as input
+    this.options.gammaOut = this.options.gamma;
+  } else if (is.number(gammaOut) && is.inRange(gammaOut, 1, 3)) {
+    this.options.gammaOut = gammaOut;
+  } else {
+    throw new Error('Invalid output gamma correction (1.0 to 3.0) ' + gammaOut);
+  }
   return this;
 }
 
@@ -453,22 +378,56 @@ function linear (a, b) {
   return this;
 }
 
+/**
+ * Recomb the image with the specified matrix.
+ *
+ * @example
+ * sharp(input)
+ *   .recomb([
+ *    [0.3588, 0.7044, 0.1368],
+ *    [0.2990, 0.5870, 0.1140],
+ *    [0.2392, 0.4696, 0.0912],
+ *   ])
+ *   .raw()
+ *   .toBuffer(function(err, data, info) {
+ *     // data contains the raw pixel data after applying the recomb
+ *     // With this example input, a sepia filter has been applied
+ *   });
+ *
+ * @param {Array<Array<Number>>} 3x3 Recombination matrix
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function recomb (inputMatrix) {
+  if (!Array.isArray(inputMatrix) || inputMatrix.length !== 3 ||
+      inputMatrix[0].length !== 3 ||
+      inputMatrix[1].length !== 3 ||
+      inputMatrix[2].length !== 3
+  ) {
+    // must pass in a kernel
+    throw new Error('Invalid Recomb Matrix');
+  }
+  this.options.recombMatrix = [
+    inputMatrix[0][0], inputMatrix[0][1], inputMatrix[0][2],
+    inputMatrix[1][0], inputMatrix[1][1], inputMatrix[1][2],
+    inputMatrix[2][0], inputMatrix[2][1], inputMatrix[2][2]
+  ].map(Number);
+  return this;
+}
+
 /**
  * Decorate the Sharp prototype with operation-related functions.
  * @private
  */
 module.exports = function (Sharp) {
-  [
+  Object.assign(Sharp.prototype, {
     rotate,
-    extract,
     flip,
     flop,
     sharpen,
     median,
     blur,
-    extend,
     flatten,
-    trim,
     gamma,
     negate,
     normalise,
@@ -476,8 +435,7 @@ module.exports = function (Sharp) {
     convolve,
     threshold,
     boolean,
-    linear
-  ].forEach(function (f) {
-    Sharp.prototype[f.name] = f;
+    linear,
+    recomb
   });
 };

lib/output.js

@@ -32,7 +32,7 @@ const sharp = require('../build/Release/sharp.node');
  */
 function toFile (fileOut, callback) {
   if (!fileOut || fileOut.length === 0) {
-    const errOutputInvalid = new Error('Invalid output');
+    const errOutputInvalid = new Error('Missing output file path');
     if (is.fn(callback)) {
       callback(errOutputInvalid);
     } else {
@@ -148,6 +148,10 @@ function withMetadata (withMetadata) {
  * @param {Boolean} [options.overshootDeringing=false] - apply overshoot deringing, requires mozjpeg
  * @param {Boolean} [options.optimiseScans=false] - optimise progressive scans, forces progressive, requires mozjpeg
  * @param {Boolean} [options.optimizeScans=false] - alternative spelling of optimiseScans
+ * @param {Boolean} [options.optimiseCoding=true] - optimise Huffman coding tables
+ * @param {Boolean} [options.optimizeCoding=true] - alternative spelling of optimiseCoding
+ * @param {Number} [options.quantisationTable=0] - quantization table to use, integer 0-8, requires mozjpeg
+ * @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
@@ -171,20 +175,32 @@ function jpeg (options) {
         throw new Error('Invalid chromaSubsampling (4:2:0, 4:4:4) ' + options.chromaSubsampling);
       }
     }
-    options.trellisQuantisation = is.bool(options.trellisQuantization) ? options.trellisQuantization : options.trellisQuantisation;
-    if (is.defined(options.trellisQuantisation)) {
-      this._setBooleanOption('jpegTrellisQuantisation', options.trellisQuantisation);
+    const trellisQuantisation = is.bool(options.trellisQuantization) ? options.trellisQuantization : options.trellisQuantisation;
+    if (is.defined(trellisQuantisation)) {
+      this._setBooleanOption('jpegTrellisQuantisation', trellisQuantisation);
     }
     if (is.defined(options.overshootDeringing)) {
       this._setBooleanOption('jpegOvershootDeringing', options.overshootDeringing);
     }
-    options.optimiseScans = is.bool(options.optimizeScans) ? options.optimizeScans : options.optimiseScans;
-    if (is.defined(options.optimiseScans)) {
-      this._setBooleanOption('jpegOptimiseScans', options.optimiseScans);
-      if (options.optimiseScans) {
+    const optimiseScans = is.bool(options.optimizeScans) ? options.optimizeScans : options.optimiseScans;
+    if (is.defined(optimiseScans)) {
+      this._setBooleanOption('jpegOptimiseScans', optimiseScans);
+      if (optimiseScans) {
         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)) {
+        this.options.jpegQuantisationTable = quantisationTable;
+      } else {
+        throw new Error('Invalid quantisation table (integer, 0-8) ' + quantisationTable);
+      }
+    }
   }
   return this._updateFormatOut('jpeg', options);
 }
@@ -205,6 +221,11 @@ function jpeg (options) {
  * @param {Boolean} [options.progressive=false] - use progressive (interlace) scan
  * @param {Number} [options.compressionLevel=9] - zlib compression level, 0-9
  * @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 libimagequant
+ * @param {Number} [options.quality=100] - use the lowest number of colours needed to achieve given quality, requires libimagequant
+ * @param {Number} [options.colours=256] - maximum number of palette entries, requires libimagequant
+ * @param {Number} [options.colors=256] - alternative spelling of `options.colours`, requires libimagequant
+ * @param {Number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, requires libimagequant
  * @param {Boolean} [options.force=true] - force PNG output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -224,6 +245,33 @@ function png (options) {
     if (is.defined(options.adaptiveFiltering)) {
       this._setBooleanOption('pngAdaptiveFiltering', options.adaptiveFiltering);
     }
+    if (is.defined(options.palette)) {
+      this._setBooleanOption('pngPalette', options.palette);
+      if (this.options.pngPalette) {
+        if (is.defined(options.quality)) {
+          if (is.integer(options.quality) && is.inRange(options.quality, 0, 100)) {
+            this.options.pngQuality = options.quality;
+          } else {
+            throw is.invalidParameterError('quality', 'integer between 0 and 100', options.quality);
+          }
+        }
+        const colours = options.colours || options.colors;
+        if (is.defined(colours)) {
+          if (is.integer(colours) && is.inRange(colours, 2, 256)) {
+            this.options.pngColours = colours;
+          } else {
+            throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
+          }
+        }
+        if (is.defined(options.dither)) {
+          if (is.number(options.dither) && is.inRange(options.dither, 0, 1)) {
+            this.options.pngDither = options.dither;
+          } else {
+            throw is.invalidParameterError('dither', 'number between 0.0 and 1.0', options.dither);
+          }
+        }
+      }
+    }
   }
   return this._updateFormatOut('png', options);
 }
@@ -255,10 +303,10 @@ function webp (options) {
     }
   }
   if (is.object(options) && is.defined(options.alphaQuality)) {
-    if (is.integer(options.alphaQuality) && is.inRange(options.alphaQuality, 1, 100)) {
+    if (is.integer(options.alphaQuality) && is.inRange(options.alphaQuality, 0, 100)) {
       this.options.webpAlphaQuality = options.alphaQuality;
     } else {
-      throw new Error('Invalid webp alpha quality (integer, 1-100) ' + options.alphaQuality);
+      throw new Error('Invalid webp alpha quality (integer, 0-100) ' + options.alphaQuality);
     }
   }
   if (is.object(options) && is.defined(options.lossless)) {
@@ -288,6 +336,10 @@ function webp (options) {
  * @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 {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.xres=1.0] - horizontal resolution in pixels/mm
  * @param {Number} [options.yres=1.0] - vertical resolution in pixels/mm
  * @param {Boolean} [options.squash=false] - squash 8-bit images down to 1 bit
@@ -295,29 +347,60 @@ function webp (options) {
  * @throws {Error} Invalid options
  */
 function tiff (options) {
-  if (is.object(options) && is.defined(options.quality)) {
+  if (is.object(options)) {
+    if (is.defined(options.quality)) {
       if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
         this.options.tiffQuality = options.quality;
       } else {
         throw new Error('Invalid quality (integer, 1-100) ' + options.quality);
       }
     }
-  if (is.object(options) && is.defined(options.squash)) {
+    if (is.defined(options.squash)) {
       if (is.bool(options.squash)) {
         this.options.tiffSquash = options.squash;
       } else {
         throw new Error('Invalid Value for squash ' + options.squash + ' Only Boolean Values allowed for options.squash.');
       }
     }
+    // tiling
+    if (is.defined(options.tile)) {
+      if (is.bool(options.tile)) {
+        this.options.tiffTile = options.tile;
+      } else {
+        throw new Error('Invalid Value for tile ' + options.tile + ' Only Boolean values allowed for options.tile');
+      }
+    }
+    if (is.defined(options.tileWidth)) {
+      if (is.number(options.tileWidth) && options.tileWidth > 0) {
+        this.options.tiffTileWidth = options.tileWidth;
+      } else {
+        throw new Error('Invalid Value for tileWidth ' + options.tileWidth + ' Only positive numeric values allowed for options.tileWidth');
+      }
+    }
+    if (is.defined(options.tileHeight)) {
+      if (is.number(options.tileHeight) && options.tileHeight > 0) {
+        this.options.tiffTileHeight = options.tileHeight;
+      } else {
+        throw new Error('Invalid Value for tileHeight ' + options.tileHeight + ' Only positive numeric values allowed for options.tileHeight');
+      }
+    }
+    // pyramid
+    if (is.defined(options.pyramid)) {
+      if (is.bool(options.pyramid)) {
+        this.options.tiffPyramid = options.pyramid;
+      } else {
+        throw new Error('Invalid Value for pyramid ' + options.pyramid + ' Only Boolean values allowed for options.pyramid');
+      }
+    }
     // resolution
-  if (is.object(options) && is.defined(options.xres)) {
+    if (is.defined(options.xres)) {
       if (is.number(options.xres)) {
         this.options.tiffXres = options.xres;
       } else {
         throw new Error('Invalid Value for xres ' + options.xres + ' Only numeric values allowed for options.xres');
       }
     }
-  if (is.object(options) && is.defined(options.yres)) {
+    if (is.defined(options.yres)) {
       if (is.number(options.yres)) {
         this.options.tiffYres = options.yres;
       } else {
@@ -325,7 +408,7 @@ function tiff (options) {
       }
     }
     // compression
-  if (is.defined(options) && is.defined(options.compression)) {
+    if (is.defined(options.compression)) {
       if (is.string(options.compression) && is.inArray(options.compression, ['lzw', 'deflate', 'jpeg', 'ccittfax4', 'none'])) {
         this.options.tiffCompression = options.compression;
       } else {
@@ -334,7 +417,7 @@ function tiff (options) {
       }
     }
     // predictor
-  if (is.defined(options) && is.defined(options.predictor)) {
+    if (is.defined(options.predictor)) {
       if (is.string(options.predictor) && is.inArray(options.predictor, ['none', 'horizontal', 'float'])) {
         this.options.tiffPredictor = options.predictor;
       } else {
@@ -342,6 +425,7 @@ function tiff (options) {
         throw new Error(message);
       }
     }
+  }
   return this._updateFormatOut('tiff', options);
 }
 
@@ -390,6 +474,8 @@ function toFormat (format, options) {
  * Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
  * Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed archive file format.
  *
+ * Warning: multiple sharp instances concurrently producing tile output can expose a possible race condition in some versions of libgsf.
+ *
  * @example
  *  sharp('input.tiff')
  *   .png()
@@ -405,6 +491,7 @@ function toFormat (format, options) {
  * @param {Number} [tile.size=256] tile size in pixels, a value between 1 and 8192.
  * @param {Number} [tile.overlap=0] tile overlap in pixels, a value between 0 and 8192.
  * @param {Number} [tile.angle=0] tile angle of rotation, must be a multiple of 90.
+ * @param {String} [tile.depth] how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
  * @param {String} [tile.container='fs'] tile container, with value `fs` (filesystem) or `zip` (compressed file).
  * @param {String} [tile.layout='dz'] filesystem layout, possible values are `dz`, `zoomify` or `google`.
  * @returns {Sharp}
@@ -456,6 +543,15 @@ function tile (tile) {
         throw new Error('Unsupported angle: angle must be a positive/negative multiple of 90 ' + tile.angle);
       }
     }
+
+    // Depth of tiles
+    if (is.defined(tile.depth)) {
+      if (is.string(tile.depth) && is.inArray(tile.depth, ['onepixel', 'onetile', 'one'])) {
+        this.options.tileDepth = tile.depth;
+      } else {
+        throw new Error("Invalid tile depth '" + tile.depth + "', should be one of 'onepixel', 'onetile' or 'one'");
+      }
+    }
   }
   // Format
   if (is.inArray(this.options.formatOut, ['jpeg', 'png', 'webp'])) {
@@ -477,7 +573,9 @@ function tile (tile) {
  * @returns {Sharp}
  */
 function _updateFormatOut (formatOut, options) {
-  this.options.formatOut = (is.object(options) && options.force === false) ? 'input' : formatOut;
+  if (!(is.object(options) && options.force === false)) {
+    this.options.formatOut = formatOut;
+  }
   return this;
 }
 
@@ -613,7 +711,7 @@ function _pipeline (callback) {
  * @private
  */
 module.exports = function (Sharp) {
-  [
+  Object.assign(Sharp.prototype, {
     // Public
     toFile,
     toBuffer,
@@ -630,7 +728,5 @@ module.exports = function (Sharp) {
     _setBooleanOption,
     _read,
     _pipeline
-  ].forEach(function (f) {
-    Sharp.prototype[f.name] = f;
   });
 };

lib/platform.js

@@ -1,15 +1,23 @@
 'use strict';
 
-module.exports = function () {
-  const arch = process.env.npm_config_arch || process.arch;
-  const platform = process.env.npm_config_platform || process.platform;
+const detectLibc = require('detect-libc');
 
-  const platformId = [platform];
-  if (arch === 'arm' || arch === 'armhf' || arch === 'arm64') {
-    const armVersion = (arch === 'arm64') ? '8' : process.env.npm_config_armv || process.config.variables.arm_version || '6';
-    platformId.push(`armv${armVersion}`);
+const env = process.env;
+
+module.exports = function () {
+  const arch = env.npm_config_arch || process.arch;
+  const platform = env.npm_config_platform || process.platform;
+  const libc = (platform === 'linux' && detectLibc.isNonGlibcLinux) ? detectLibc.family : '';
+
+  const platformId = [`${platform}${libc}`];
+
+  if (arch === 'arm') {
+    platformId.push(`armv${env.npm_config_arm_version || process.config.variables.arm_version || '6'}`);
+  } else if (arch === 'arm64') {
+    platformId.push(`arm64v${env.npm_config_arm_version || '8'}`);
   } else {
     platformId.push(arch);
   }
+
   return platformId.join('-');
 };

lib/resize.js

@@ -3,7 +3,7 @@
 const is = require('./is');
 
 /**
- * Weighting to apply to image crop.
+ * Weighting to apply when using contain/cover fit.
  * @member
  * @private
  */
@@ -21,7 +21,23 @@ const gravity = {
 };
 
 /**
- * Strategies for automagic crop behaviour.
+ * Position to apply when using contain/cover fit.
+ * @member
+ * @private
+ */
+const position = {
+  top: 1,
+  right: 2,
+  bottom: 3,
+  left: 4,
+  'right top': 5,
+  'right bottom': 6,
+  'left bottom': 7,
+  'left top': 8
+};
+
+/**
+ * Strategies for automagic cover behaviour.
  * @member
  * @private
  */
@@ -38,45 +54,144 @@ const strategy = {
 const kernel = {
   nearest: 'nearest',
   cubic: 'cubic',
+  mitchell: 'mitchell',
   lanczos2: 'lanczos2',
   lanczos3: 'lanczos3'
 };
 
 /**
- * Resize image to `width` x `height`.
- * By default, the resized image is centre cropped to the exact size specified.
+ * Methods by which an image can be resized to fit the provided dimensions.
+ * @member
+ * @private
+ */
+const fit = {
+  contain: 'contain',
+  cover: 'cover',
+  fill: 'fill',
+  inside: 'inside',
+  outside: 'outside'
+};
+
+/**
+ * Map external fit property to internal canvas property.
+ * @member
+ * @private
+ */
+const mapFitToCanvas = {
+  contain: 'embed',
+  cover: 'crop',
+  fill: 'ignore_aspect',
+  inside: 'max',
+  outside: 'min'
+};
+
+/**
+ * Resize image to `width`, `height` or `width x height`.
  *
- * Possible kernels are:
+ * When both a `width` and `height` are provided, the possible methods by which the image should **fit** these are:
+ * - `cover`: Crop to cover both provided dimensions (the default).
+ * - `contain`: Embed within both provided dimensions.
+ * - `fill`: Ignore the aspect ratio of the input and stretch to both provided dimensions.
+ * - `inside`: Preserving aspect ratio, resize the image to be as large as possible while ensuring its dimensions are less than or equal to both those specified.
+ * - `outside`: Preserving aspect ratio, resize the image to be as small as possible while ensuring its dimensions are greater than or equal to both those specified.
+ * Some of these values are based on the [object-fit](https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit) CSS property.
+ *
+ * When using a `fit` of `cover` or `contain`, the default **position** is `centre`. Other options are:
+ * - `sharp.position`: `top`, `right top`, `right`, `right bottom`, `bottom`, `left bottom`, `left`, `left top`.
+ * - `sharp.gravity`: `north`, `northeast`, `east`, `southeast`, `south`, `southwest`, `west`, `northwest`, `center` or `centre`.
+ * - `sharp.strategy`: `cover` only, dynamically crop using either the `entropy` or `attention` strategy.
+ * Some of these values are based on the [object-position](https://developer.mozilla.org/en-US/docs/Web/CSS/object-position) CSS property.
+ *
+ * The experimental strategy-based approach resizes so one dimension is at its target length
+ * then repeatedly ranks edge regions, discarding the edge with the lowest score based on the selected strategy.
+ * - `entropy`: focus on the region with the highest [Shannon entropy](https://en.wikipedia.org/wiki/Entropy_%28information_theory%29).
+ * - `attention`: focus on the region with the highest luminance frequency, colour saturation and presence of skin tones.
+ *
+ * Possible interpolation kernels are:
  * - `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation).
  * - `cubic`: Use a [Catmull-Rom spline](https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline).
+ * - `mitchell`: Use a [Mitchell-Netravali spline](https://www.cs.utexas.edu/~fussell/courses/cs384g-fall2013/lectures/mitchell/Mitchell.pdf).
  * - `lanczos2`: Use a [Lanczos kernel](https://en.wikipedia.org/wiki/Lanczos_resampling#Lanczos_kernel) with `a=2`.
  * - `lanczos3`: Use a Lanczos kernel with `a=3` (the default).
  *
  * @example
- * sharp(inputBuffer)
+ * sharp(input)
+ *   .resize({ width: 100 })
+ *   .toBuffer()
+ *   .then(data => {
+ *     // 100 pixels wide, auto-scaled height
+ *   });
+ *
+ * @example
+ * sharp(input)
+ *   .resize({ height: 100 })
+ *   .toBuffer()
+ *   .then(data => {
+ *     // 100 pixels high, auto-scaled width
+ *   });
+ *
+ * @example
+ * sharp(input)
  *   .resize(200, 300, {
- *     kernel: sharp.kernel.nearest
+ *     kernel: sharp.kernel.nearest,
+ *     fit: 'contain',
+ *     position: 'right top',
+ *     background: { r: 255, g: 255, b: 255, alpha: 0.5 }
  *   })
- *   .background('white')
- *   .embed()
- *   .toFile('output.tiff')
- *   .then(function() {
- *     // output.tiff is a 200 pixels wide and 300 pixels high image
- *     // containing a nearest-neighbour scaled version, embedded on a white canvas,
- *     // of the image data in inputBuffer
+ *   .toFile('output.png')
+ *   .then(() => {
+ *     // output.png is a 200 pixels wide and 300 pixels high image
+ *     // containing a nearest-neighbour scaled version
+ *     // contained within the north-east corner of a semi-transparent white canvas
+ *   });
+ *
+ * @example
+ * const transformer = sharp()
+ *   .resize({
+ *     width: 200,
+ *     height: 200,
+ *     fit: sharp.fit.cover,
+ *     position: sharp.strategy.entropy
+ *   });
+ * // Read image data from readableStream
+ * // Write 200px square auto-cropped image data to writableStream
+ * readableStream
+ *   .pipe(transformer)
+ *   .pipe(writableStream);
+ *
+ * @example
+ * sharp(input)
+ *   .resize(200, 200, {
+ *     fit: sharp.fit.inside,
+ *     withoutEnlargement: true
+ *   })
+ *   .toFormat('jpeg')
+ *   .toBuffer()
+ *   .then(function(outputBuffer) {
+ *     // outputBuffer contains JPEG image data
+ *     // no wider and no higher than 200 pixels
+ *     // and no larger than the input image
  *   });
  *
  * @param {Number} [width] - pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
  * @param {Number} [height] - pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
  * @param {Object} [options]
+ * @param {String} [options.width] - alternative means of specifying `width`. If both are present this take priority.
+ * @param {String} [options.height] - alternative means of specifying `height`. If both are present this take priority.
+ * @param {String} [options.fit='cover'] - how the image should be resized to fit both provided dimensions, one of `cover`, `contain`, `fill`, `inside` or `outside`.
+ * @param {String} [options.position='centre'] - position, gravity or strategy to use when `fit` is `cover` or `contain`.
+ * @param {String|Object} [options.background={r: 0, g: 0, b: 0, alpha: 1}] - background colour when using a `fit` of `contain`, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black without transparency.
  * @param {String} [options.kernel='lanczos3'] - the kernel to use for image reduction.
+ * @param {Boolean} [options.withoutEnlargement=false] - do not enlarge if the width *or* height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option.
  * @param {Boolean} [options.fastShrinkOnLoad=true] - take greater advantage of the JPEG and WebP shrink-on-load feature, which can lead to a slight moiré pattern on some images.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
 function resize (width, height, options) {
   if (is.defined(width)) {
-    if (is.integer(width) && width > 0) {
+    if (is.object(width) && !is.defined(options)) {
+      options = width;
+    } else if (is.integer(width) && width > 0) {
       this.options.width = width;
     } else {
       throw is.invalidParameterError('width', 'positive integer', width);
@@ -94,6 +209,38 @@ function resize (width, height, options) {
     this.options.height = -1;
   }
   if (is.object(options)) {
+    // Width
+    if (is.integer(options.width) && options.width > 0) {
+      this.options.width = options.width;
+    }
+    // Height
+    if (is.integer(options.height) && options.height > 0) {
+      this.options.height = options.height;
+    }
+    // Fit
+    if (is.defined(options.fit)) {
+      const canvas = mapFitToCanvas[options.fit];
+      if (is.string(canvas)) {
+        this.options.canvas = canvas;
+      } else {
+        throw is.invalidParameterError('fit', 'valid fit', options.fit);
+      }
+    }
+    // Position
+    if (is.defined(options.position)) {
+      const pos = is.integer(options.position)
+        ? options.position
+        : strategy[options.position] || position[options.position] || gravity[options.position];
+      if (is.integer(pos) && (is.inRange(pos, 0, 8) || is.inRange(pos, 16, 17))) {
+        this.options.position = pos;
+      } else {
+        throw is.invalidParameterError('position', 'valid position/gravity/strategy', options.position);
+      }
+    }
+    // Background
+    if (is.defined(options.background)) {
+      this._setColourOption('resizeBackground', options.background);
+    }
     // Kernel
     if (is.defined(options.kernel)) {
       if (is.string(kernel[options.kernel])) {
@@ -102,6 +249,10 @@ function resize (width, height, options) {
         throw is.invalidParameterError('kernel', 'valid kernel name', options.kernel);
       }
     }
+    // Without enlargement
+    if (is.defined(options.withoutEnlargement)) {
+      this._setBooleanOption('withoutEnlargement', options.withoutEnlargement);
+    }
     // Shrink on load
     if (is.defined(options.fastShrinkOnLoad)) {
       this._setBooleanOption('fastShrinkOnLoad', options.fastShrinkOnLoad);
@@ -111,157 +262,118 @@ function resize (width, height, options) {
 }
 
 /**
- * Crop the resized image to the exact size specified, the default behaviour.
- *
- * Possible attributes of the optional `sharp.gravity` are `north`, `northeast`, `east`, `southeast`, `south`,
- * `southwest`, `west`, `northwest`, `center` and `centre`.
- *
- * The experimental strategy-based approach resizes so one dimension is at its target length
- * then repeatedly ranks edge regions, discarding the edge with the lowest score based on the selected strategy.
- * - `entropy`: focus on the region with the highest [Shannon entropy](https://en.wikipedia.org/wiki/Entropy_%28information_theory%29).
- * - `attention`: focus on the region with the highest luminance frequency, colour saturation and presence of skin tones.
+ * Extends/pads the edges of the image with the provided background colour.
+ * This operation will always occur after resizing and extraction, if any.
  *
  * @example
- * const transformer = sharp()
- *   .resize(200, 200)
- *   .crop(sharp.strategy.entropy)
- *   .on('error', function(err) {
- *     console.log(err);
- *   });
- * // Read image data from readableStream
- * // Write 200px square auto-cropped image data to writableStream
- * readableStream.pipe(transformer).pipe(writableStream);
+ * // Resize to 140 pixels wide, then add 10 transparent pixels
+ * // to the top, left and right edges and 20 to the bottom edge
+ * sharp(input)
+ *   .resize(140)
+ *   .extend({
+ *     top: 10,
+ *     bottom: 20,
+ *     left: 10,
+ *     right: 10,
+ *     background: { r: 0, g: 0, b: 0, alpha: 0 }
+ *   })
+ *   ...
  *
- * @param {String} [crop='centre'] - A member of `sharp.gravity` to crop to an edge/corner or `sharp.strategy` to crop dynamically.
+ * @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 {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
- */
-function crop (crop) {
-  this.options.canvas = 'crop';
-  if (!is.defined(crop)) {
-    // Default
-    this.options.crop = gravity.center;
-  } else if (is.integer(crop) && is.inRange(crop, 0, 8)) {
-    // Gravity (numeric)
-    this.options.crop = crop;
-  } else if (is.string(crop) && is.integer(gravity[crop])) {
-    // Gravity (string)
-    this.options.crop = gravity[crop];
-  } else if (is.integer(crop) && crop >= strategy.entropy) {
-    // Strategy
-    this.options.crop = crop;
-  } else if (is.string(crop) && is.integer(strategy[crop])) {
-    // Strategy (string)
-    this.options.crop = strategy[crop];
-  } else {
-    throw is.invalidParameterError('crop', 'valid crop id/name/strategy', crop);
-  }
-  return this;
-}
-
-/**
- * Preserving aspect ratio, resize the image to the maximum `width` or `height` specified
- * then embed on a background of the exact `width` and `height` specified.
- *
- * If the background contains an alpha value then WebP and PNG format output images will
- * contain an alpha channel, even when the input image does not.
- *
- * @example
- * sharp('input.gif')
- *   .resize(200, 300)
- *   .background({r: 0, g: 0, b: 0, alpha: 0})
- *   .embed()
- *   .toFormat(sharp.format.webp)
- *   .toBuffer(function(err, outputBuffer) {
- *     if (err) {
- *       throw err;
- *     }
- *     // outputBuffer contains WebP image data of a 200 pixels wide and 300 pixels high
- *     // containing a scaled version, embedded on a transparent canvas, of input.gif
- *   });
- * @param {String} [embed='centre'] - A member of `sharp.gravity` to embed to an edge/corner.
- * @returns {Sharp}
- * @throws {Error} Invalid parameters
- */
-function embed (embed) {
-  this.options.canvas = 'embed';
-
-  if (!is.defined(embed)) {
-    // Default
-    this.options.embed = gravity.center;
-  } else if (is.integer(embed) && is.inRange(embed, 0, 8)) {
-    // Gravity (numeric)
-    this.options.embed = embed;
-  } else if (is.string(embed) && is.integer(gravity[embed])) {
-    // Gravity (string)
-    this.options.embed = gravity[embed];
-  } else {
-    throw is.invalidParameterError('embed', 'valid embed id/name', embed);
-  }
-
-  return this;
-}
-
-/**
- * Preserving aspect ratio, resize the image to be as large as possible
- * while ensuring its dimensions are less than or equal to the `width` and `height` specified.
- *
- * Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
- *
- * @example
- * sharp(inputBuffer)
- *   .resize(200, 200)
- *   .max()
- *   .toFormat('jpeg')
- *   .toBuffer()
- *   .then(function(outputBuffer) {
- *     // outputBuffer contains JPEG image data no wider than 200 pixels and no higher
- *     // than 200 pixels regardless of the inputBuffer image dimensions
- *   });
- *
- * @returns {Sharp}
- */
-function max () {
-  this.options.canvas = 'max';
-  return this;
-}
-
-/**
- * Preserving aspect ratio, resize the image to be as small as possible
- * while ensuring its dimensions are greater than or equal to the `width` and `height` specified.
- *
- * Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
- *
- * @returns {Sharp}
- */
-function min () {
-  this.options.canvas = 'min';
-  return this;
-}
-
-/**
- * Ignoring the aspect ratio of the input, stretch the image to
- * the exact `width` and/or `height` provided via `resize`.
- * @returns {Sharp}
- */
-function ignoreAspectRatio () {
-  this.options.canvas = 'ignore_aspect';
-  return this;
-}
-
-/**
- * Do not enlarge the output image if the input image width *or* height are already less than the required dimensions.
- * This is equivalent to GraphicsMagick's `>` geometry option:
- * "*change the dimensions of the image only if its width or height exceeds the geometry specification*".
- * Use with `max()` to preserve the image's aspect ratio.
- *
- * The default behaviour *before* function call is `false`, meaning the image will be enlarged.
- *
- * @param {Boolean} [withoutEnlargement=true]
- * @returns {Sharp}
 */
-function withoutEnlargement (withoutEnlargement) {
-  this.options.withoutEnlargement = is.bool(withoutEnlargement) ? withoutEnlargement : true;
+function extend (extend) {
+  if (is.integer(extend) && extend > 0) {
+    this.options.extendTop = 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;
+    this._setColourOption('extendBackground', extend.background);
+  } else {
+    throw new Error('Invalid edge extension ' + extend);
+  }
+  return this;
+}
+
+/**
+ * Extract a region of the image.
+ *
+ * - Use `extract` before `resize` for pre-resize extraction.
+ * - Use `extract` after `resize` for post-resize extraction.
+ * - Use `extract` before and after for both.
+ *
+ * @example
+ * sharp(input)
+ *   .extract({ left: left, top: top, width: width, height: height })
+ *   .toFile(output, function(err) {
+ *     // Extract a region of the input image, saving in the same format.
+ *   });
+ * @example
+ * sharp(input)
+ *   .extract({ left: leftOffsetPre, top: topOffsetPre, width: widthPre, height: heightPre })
+ *   .resize(width, height)
+ *   .extract({ left: leftOffsetPost, top: topOffsetPost, width: widthPost, height: heightPost })
+ *   .toFile(output, function(err) {
+ *     // Extract a region, resize, then extract from the resized image
+ *   });
+ *
+ * @param {Object} options
+ * @param {Number} options.left - zero-indexed offset from left edge
+ * @param {Number} options.top - zero-indexed offset from top edge
+ * @param {Number} options.width - dimension of extracted image
+ * @param {Number} options.height - dimension of extracted image
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function extract (options) {
+  const suffix = this.options.width === -1 && this.options.height === -1 ? 'Pre' : 'Post';
+  ['left', 'top', 'width', 'height'].forEach(function (name) {
+    const value = options[name];
+    if (is.integer(value) && value >= 0) {
+      this.options[name + (name === 'left' || name === 'top' ? 'Offset' : '') + suffix] = value;
+    } else {
+      throw new Error('Non-integer value for ' + name + ' of ' + value);
+    }
+  }, this);
+  // Ensure existing rotation occurs before pre-resize extraction
+  if (suffix === 'Pre' && ((this.options.angle % 360) !== 0 || this.options.useExifOrientation === true)) {
+    this.options.rotateBeforePreExtract = true;
+  }
+  return this;
+}
+
+/**
+ * Trim "boring" pixels from all edges that contain values similar to the top-left pixel.
+ * The `info` response Object will contain `trimOffsetLeft` and `trimOffsetTop` properties.
+ * @param {Number} [threshold=10] the allowed difference from the top-left pixel, a number greater than zero.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function trim (threshold) {
+  if (!is.defined(threshold)) {
+    this.options.trimThreshold = 10;
+  } else if (is.number(threshold) && threshold > 0) {
+    this.options.trimThreshold = threshold;
+  } else {
+    throw is.invalidParameterError('threshold', 'number greater than zero', threshold);
+  }
   return this;
 }
 
@@ -270,19 +382,16 @@ function withoutEnlargement (withoutEnlargement) {
  * @private
  */
 module.exports = function (Sharp) {
-  [
+  Object.assign(Sharp.prototype, {
     resize,
-    crop,
-    embed,
-    max,
-    min,
-    ignoreAspectRatio,
-    withoutEnlargement
-  ].forEach(function (f) {
-    Sharp.prototype[f.name] = f;
+    extend,
+    extract,
+    trim
   });
   // Class attributes
   Sharp.gravity = gravity;
   Sharp.strategy = strategy;
   Sharp.kernel = kernel;
+  Sharp.fit = fit;
+  Sharp.position = position;
 };

lib/utility.js

@@ -82,23 +82,20 @@ function counters () {
  * Improves the performance of `resize`, `blur` and `sharpen` operations
  * by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM NEON.
  *
- * This feature is currently off by default but future versions may reverse this.
- * Versions of liborc prior to 0.4.25 are known to segfault under heavy load.
- *
  * @example
  * const simd = sharp.simd();
- * // simd is `true` if SIMD is currently enabled
+ * // simd is `true` if the runtime use of liborc is currently enabled
  * @example
- * const simd = sharp.simd(true);
- * // attempts to enable the use of SIMD, returning true if available
+ * const simd = sharp.simd(false);
+ * // prevent libvips from using liborc at runtime
  *
- * @param {Boolean} [simd=false]
+ * @param {Boolean} [simd=true]
  * @returns {Boolean}
  */
 function simd (simd) {
   return sharp.simd(is.bool(simd) ? simd : null);
 }
-simd(false);
+simd(true);
 
 /**
  * Decorate the Sharp class with utility-related functions.

mkdocs.yml

@@ -1,10 +1,12 @@
 site_name: sharp
-site_url: http://sharp.pixelplumbing.com/
+site_url: https://sharp.pixelplumbing.com/
 repo_url: https://github.com/lovell/sharp
 site_description: High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images
 copyright: <a href="https://pixelplumbing.com/">pixelplumbing.com</a>
 google_analytics: ['UA-13034748-12', 'sharp.pixelplumbing.com']
 theme: readthedocs
+extra_css:
+  - css/extra.css
 markdown_extensions:
   - toc:
       permalink: True

package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images",
-  "version": "0.20.2",
+  "version": "0.22.0",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -48,15 +48,28 @@
     "Andrea Bianco <andrea.bianco@unibas.ch>",
     "Rik Heywood <rik@rik.org>",
     "Thomas Parisot <hi@oncletom.io>",
-    "Nathan Graves <nathanrgraves+github@gmail.com>"
+    "Nathan Graves <nathanrgraves+github@gmail.com>",
+    "Tom Lokhorst <tom@lokhorst.eu>",
+    "Espen Hovlandsdal <espen@hovlandsdal.com>",
+    "Sylvain Dumont <sylvain.dumont35@gmail.com>",
+    "Alun Davies <alun.owain.davies@googlemail.com>",
+    "Aidan Hoolachan <ajhoolachan21@gmail.com>",
+    "Axel Eirola <axel.eirola@iki.fi>",
+    "Freezy <freezy@xbmc.org>",
+    "Daiz <taneli.vatanen@gmail.com>",
+    "Julian Aubourg <j@ubourg.net>",
+    "Keith Belovay <keith@picthrive.com>",
+    "Michael B. Klein <mbklein@gmail.com>"
   ],
   "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/ coverage/ test/fixtures/output.*",
-    "test": "semistandard && cc && nyc --reporter=lcov --branches=99 mocha --slow=5000 --timeout=60000 ./test/unit/*.js && prebuild-ci",
-    "coverage": "./test/coverage/report.sh",
+    "clean": "rm -rf node_modules/ build/ vendor/ .nyc_output/ coverage/ test/fixtures/output.*",
+    "test": "semistandard && cc && npm run test-unit && npm run test-licensing && prebuild-ci",
+    "test-unit": "nyc --reporter=lcov --branches=99 mocha --slow=5000 --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": "for m in constructor input resize composite operation colour channel output utility; do documentation build --shallow --format=md lib/$m.js >docs/api-$m.md; done"
+    "docs": "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"
   },
   "main": "lib/index.js",
   "repository": {
@@ -80,37 +93,40 @@
     "vips"
   ],
   "dependencies": {
-    "color": "^3.0.0",
+    "bindings": "^1.5.0",
+    "color": "^3.1.0",
     "detect-libc": "^1.0.3",
-    "nan": "^2.10.0",
-    "fs-copy-file-sync": "^1.0.1",
+    "fs-copy-file-sync": "^1.1.1",
+    "nan": "^2.13.1",
     "npmlog": "^4.1.2",
-    "prebuild-install": "^2.5.3",
-    "semver": "^5.5.0",
-    "simple-get": "^2.8.1",
-    "tar": "^4.4.1",
+    "prebuild-install": "^5.2.5",
+    "semver": "^5.6.0",
+    "simple-get": "^3.0.3",
+    "tar": "^4.4.8",
     "tunnel-agent": "^0.6.0"
   },
   "devDependencies": {
-    "async": "^2.6.0",
+    "async": "^2.6.2",
     "cc": "^1.0.2",
-    "decompress-zip": "^0.3.1",
-    "documentation": "^6.3.2",
+    "decompress-zip": "^0.3.2",
+    "documentation": "^9.3.1",
     "exif-reader": "^1.0.2",
     "icc": "^1.0.0",
-    "mocha": "^5.1.1",
-    "nyc": "^11.7.1",
-    "prebuild": "^7.4.0",
-    "prebuild-ci": "^2.2.3",
-    "rimraf": "^2.6.2",
-    "semistandard": "^12.0.1"
+    "license-checker": "^25.0.1",
+    "mocha": "^6.0.2",
+    "mock-fs": "^4.8.0",
+    "nyc": "^13.3.0",
+    "prebuild": "8.1.0",
+    "prebuild-ci": "^2.3.0",
+    "rimraf": "^2.6.3",
+    "semistandard": "^13.0.1"
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.6.1"
+    "libvips": "8.7.4"
   },
   "engines": {
-    "node": ">=4.5.0"
+    "node": ">=6"
   },
   "semistandard": {
     "env": [

src/common.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -37,6 +37,14 @@ namespace sharp {
   std::string AttrAsStr(v8::Handle<v8::Object> obj, std::string attr) {
     return *Nan::Utf8String(Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked());
   }
+  std::vector<double> AttrAsRgba(v8::Handle<v8::Object> obj, std::string attr) {
+    v8::Local<v8::Object> background = AttrAs<v8::Object>(obj, attr);
+    std::vector<double> rgba(4);
+    for (unsigned int i = 0; i < 4; i++) {
+      rgba[i] = AttrTo<double>(background, i);
+    }
+    return rgba;
+  }
 
   // Create an InputDescriptor instance from a v8::Object describing an input image
   InputDescriptor* CreateInputDescriptor(
@@ -55,7 +63,7 @@ namespace sharp {
     descriptor->failOnError = AttrTo<bool>(input, "failOnError");
     // Density for vector-based input
     if (HasAttr(input, "density")) {
-      descriptor->density = AttrTo<uint32_t>(input, "density");
+      descriptor->density = AttrTo<double>(input, "density");
     }
     // Raw pixel input
     if (HasAttr(input, "rawChannels")) {
@@ -63,7 +71,10 @@ namespace sharp {
       descriptor->rawWidth = AttrTo<uint32_t>(input, "rawWidth");
       descriptor->rawHeight = AttrTo<uint32_t>(input, "rawHeight");
     }
-    // Page input for multi-page TIFF
+    // Multi-page input (GIF, TIFF, PDF)
+    if (HasAttr(input, "pages")) {
+      descriptor->pages = AttrTo<int32_t>(input, "pages");
+    }
     if (HasAttr(input, "page")) {
       descriptor->page = AttrTo<uint32_t>(input, "page");
     }
@@ -72,10 +83,7 @@ namespace sharp {
       descriptor->createChannels = AttrTo<uint32_t>(input, "createChannels");
       descriptor->createWidth = AttrTo<uint32_t>(input, "createWidth");
       descriptor->createHeight = AttrTo<uint32_t>(input, "createHeight");
-      v8::Local<v8::Object> createBackground = AttrAs<v8::Object>(input, "createBackground");
-      for (unsigned int i = 0; i < 4; i++) {
-        descriptor->createBackground[i] = AttrTo<double>(createBackground, i);
-      }
+      descriptor->createBackground = AttrAsRgba(input, "createBackground");
     }
     return descriptor;
   }
@@ -132,6 +140,7 @@ namespace sharp {
       case ImageType::VIPS: id = "v"; break;
       case ImageType::RAW: id = "raw"; break;
       case ImageType::UNKNOWN: id = "unknown"; break;
+      case ImageType::MISSING: id = "missing"; break;
     }
     return id;
   }
@@ -198,10 +207,24 @@ namespace sharp {
       } else if (EndsWith(loader, "Magick") || EndsWith(loader, "MagickFile")) {
         imageType = ImageType::MAGICK;
       }
+    } else {
+      if (EndsWith(vips::VError().what(), " not found\n")) {
+        imageType = ImageType::MISSING;
+      }
     }
     return imageType;
   }
 
+  /*
+    Does this image type support multiple pages?
+  */
+  bool ImageTypeSupportsPage(ImageType imageType) {
+    return
+      imageType == ImageType::GIF ||
+      imageType == ImageType::TIFF ||
+      imageType == ImageType::PDF;
+  }
+
   /*
     Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
@@ -228,20 +251,21 @@ namespace sharp {
               ->set("access", accessMethod)
               ->set("fail", descriptor->failOnError);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
-              option->set("dpi", static_cast<double>(descriptor->density));
+              option->set("dpi", descriptor->density);
             }
             if (imageType == ImageType::MAGICK) {
               option->set("density", std::to_string(descriptor->density).data());
             }
-            if (imageType == ImageType::TIFF) {
+            if (ImageTypeSupportsPage(imageType)) {
+              option->set("n", descriptor->pages);
               option->set("page", descriptor->page);
             }
             image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               SetDensity(image, descriptor->density);
             }
-          } catch (...) {
-            throw vips::VError("Input buffer has corrupt header");
+          } catch (vips::VError const &err) {
+            throw vips::VError(std::string("Input buffer has corrupt header: ") + err.what());
           }
         } else {
           throw vips::VError("Input buffer contains unsupported image format");
@@ -264,29 +288,33 @@ namespace sharp {
       } else {
         // From filesystem
         imageType = DetermineImageType(descriptor->file.data());
+        if (imageType == ImageType::MISSING) {
+          throw vips::VError("Input file is missing");
+        }
         if (imageType != ImageType::UNKNOWN) {
           try {
             vips::VOption *option = VImage::option()
               ->set("access", accessMethod)
               ->set("fail", descriptor->failOnError);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
-              option->set("dpi", static_cast<double>(descriptor->density));
+              option->set("dpi", descriptor->density);
             }
             if (imageType == ImageType::MAGICK) {
               option->set("density", std::to_string(descriptor->density).data());
             }
-            if (imageType == ImageType::TIFF) {
+            if (ImageTypeSupportsPage(imageType)) {
+              option->set("n", descriptor->pages);
               option->set("page", descriptor->page);
             }
             image = VImage::new_from_file(descriptor->file.data(), option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               SetDensity(image, descriptor->density);
             }
-          } catch (...) {
-            throw vips::VError("Input file has corrupt header");
+          } catch (vips::VError const &err) {
+            throw vips::VError(std::string("Input file has corrupt header: ") + err.what());
           }
         } else {
-          throw vips::VError("Input file is missing or of an unsupported image format");
+          throw vips::VError("Input file contains unsupported image format");
         }
       }
     }
@@ -355,8 +383,8 @@ namespace sharp {
   /*
     Set pixels/mm resolution based on a pixels/inch density.
   */
-  void SetDensity(VImage image, const int density) {
-    const double pixelsPerMm = static_cast<double>(density) / 25.4;
+  void SetDensity(VImage image, const double density) {
+    const double pixelsPerMm = density / 25.4;
     image.set("Xres", pixelsPerMm);
     image.set("Yres", pixelsPerMm);
     image.set(VIPS_META_RESOLUTION_UNIT, "in");
@@ -370,10 +398,6 @@ namespace sharp {
       if (image.width() > 65535 || image.height() > 65535) {
         throw vips::VError("Processed image is too large for the JPEG format");
       }
-    } else if (imageType == ImageType::PNG) {
-      if (image.width() > 2147483647 || image.height() > 2147483647) {
-        throw vips::VError("Processed image is too large for the PNG format");
-      }
     } else if (imageType == ImageType::WEBP) {
       if (image.width() > 16383 || image.height() > 16383) {
         throw vips::VError("Processed image is too large for the WebP format");
@@ -606,4 +630,40 @@ namespace sharp {
     }
   }
 
+  /*
+    Apply the alpha channel to a given colour
+  */
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour) {
+    // Scale up 8-bit values to match 16-bit input image
+    double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
+    // Create alphaColour colour
+    std::vector<double> alphaColour;
+    if (image.bands() > 2) {
+      alphaColour = {
+        multiplier * colour[0],
+        multiplier * colour[1],
+        multiplier * colour[2]
+      };
+    } else {
+      // Convert sRGB to greyscale
+      alphaColour = { multiplier * (
+        0.2126 * colour[0] +
+        0.7152 * colour[1] +
+        0.0722 * colour[2])
+      };
+    }
+    // Add alpha channel to alphaColour colour
+    if (colour[3] < 255.0 || HasAlpha(image)) {
+      alphaColour.push_back(colour[3] * multiplier);
+    }
+    // Ensure alphaColour colour uses correct colourspace
+    alphaColour = sharp::GetRgbaAsColourspace(alphaColour, image.interpretation());
+    // Add non-transparent alpha channel, if required
+    if (colour[3] < 255.0 && !HasAlpha(image)) {
+      image = image.bandjoin(
+        VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier));
+    }
+    return std::make_tuple(image, alphaColour);
+  }
+
 }  // namespace sharp

src/common.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -25,8 +25,8 @@
 
 // Verify platform and compiler compatibility
 
-#if (VIPS_MAJOR_VERSION < 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 6))
-#error libvips version 8.6.1+ is required - see sharp.pixelplumbing.com/page/install
+#if (VIPS_MAJOR_VERSION < 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 7))
+#error libvips version 8.7.0+ is required - see sharp.pixelplumbing.com/page/install
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -49,38 +49,37 @@ namespace sharp {
     char *buffer;
     bool failOnError;
     size_t bufferLength;
-    int density;
+    double density;
     int rawChannels;
     int rawWidth;
     int rawHeight;
+    int pages;
     int page;
     int createChannels;
     int createWidth;
     int createHeight;
-    double createBackground[4];
+    std::vector<double> createBackground;
 
     InputDescriptor():
       buffer(nullptr),
-      failOnError(FALSE),
+      failOnError(TRUE),
       bufferLength(0),
-      density(72),
+      density(72.0),
       rawChannels(0),
       rawWidth(0),
       rawHeight(0),
+      pages(1),
       page(0),
       createChannels(0),
       createWidth(0),
-      createHeight(0) {
-        createBackground[0] = 0.0;
-        createBackground[1] = 0.0;
-        createBackground[2] = 0.0;
-        createBackground[3] = 255.0;
-      }
+      createHeight(0),
+      createBackground{ 0.0, 0.0, 0.0, 255.0 } {}
   };
 
   // Convenience methods to access the attributes of a v8::Object
   bool HasAttr(v8::Handle<v8::Object> obj, std::string attr);
   std::string AttrAsStr(v8::Handle<v8::Object> obj, std::string attr);
+  std::vector<double> AttrAsRgba(v8::Handle<v8::Object> obj, std::string attr);
   template<typename T> v8::Local<T> AttrAs(v8::Handle<v8::Object> obj, std::string attr) {
     return Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked().As<T>();
   }
@@ -109,7 +108,8 @@ namespace sharp {
     FITS,
     VIPS,
     RAW,
-    UNKNOWN
+    UNKNOWN,
+    MISSING
   };
 
   // How many tasks are in the queue?
@@ -142,6 +142,11 @@ namespace sharp {
   */
   ImageType DetermineImageType(char const *file);
 
+  /*
+    Does this image type support multiple pages?
+  */
+  bool ImageTypeSupportsPage(ImageType imageType);
+
   /*
     Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
@@ -186,7 +191,7 @@ namespace sharp {
   /*
     Set pixels/mm resolution based on a pixels/inch density.
   */
-  void SetDensity(VImage image, const int density);
+  void SetDensity(VImage image, const double density);
 
   /*
     Check the proposed format supports the current dimensions.
@@ -255,6 +260,11 @@ namespace sharp {
   */
   std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba, VipsInterpretation const interpretation);
 
+  /*
+    Apply the alpha channel to a given colour
+   */
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour);
+
 }  // namespace sharp
 
 #endif  // SRC_COMMON_H_

src/libvips/cplusplus/VImage.cpp

@@ -613,7 +613,7 @@ VImage::new_matrixv( int width, int height, ... )
 }
 
 VImage
-VImage::write( VImage out )
+VImage::write( VImage out ) const
 {
 	if( vips_image_write( this->get_image(), out.get_image() ) )
 		throw VError(); 
@@ -622,7 +622,7 @@ VImage::write( VImage out )
 }
 
 void 
-VImage::write_to_file( const char *name, VOption *options )
+VImage::write_to_file( const char *name, VOption *options ) const
 {
 	char filename[VIPS_PATH_MAX];
 	char option_string[VIPS_PATH_MAX];
@@ -642,7 +642,7 @@ VImage::write_to_file( const char *name, VOption *options )
 
 void 
 VImage::write_to_buffer( const char *suffix, void **buf, size_t *size, 
-	VOption *options )
+	VOption *options ) const
 {
 	char filename[VIPS_PATH_MAX];
 	char option_string[VIPS_PATH_MAX];
@@ -675,7 +675,7 @@ VImage::write_to_buffer( const char *suffix, void **buf, size_t *size,
 #include "vips-operators.cpp"
 
 std::vector<VImage> 
-VImage::bandsplit( VOption *options )
+VImage::bandsplit( VOption *options ) const
 {
 	std::vector<VImage> b; 
 
@@ -686,7 +686,7 @@ VImage::bandsplit( VOption *options )
 }
 
 VImage 
-VImage::bandjoin( VImage other, VOption *options )
+VImage::bandjoin( VImage other, VOption *options ) const
 {
 	VImage v[2] = { *this, other }; 
 	std::vector<VImage> vec( v, v + VIPS_NUMBER( v ) );
@@ -695,7 +695,7 @@ VImage::bandjoin( VImage other, VOption *options )
 }
 
 VImage 
-VImage::composite( VImage other, VipsBlendMode mode, VOption *options )
+VImage::composite( VImage other, VipsBlendMode mode, VOption *options ) const
 {
 	VImage v[2] = { *this, other }; 
 	std::vector<VImage> ivec( v, v + VIPS_NUMBER( v ) );
@@ -706,7 +706,7 @@ VImage::composite( VImage other, VipsBlendMode mode, VOption *options )
 }
 
 std::complex<double> 
-VImage::minpos( VOption *options )
+VImage::minpos( VOption *options ) const
 {
 	double x, y;
 
@@ -719,7 +719,7 @@ VImage::minpos( VOption *options )
 }
 
 std::complex<double> 
-VImage::maxpos( VOption *options )
+VImage::maxpos( VOption *options ) const
 {
 	double x, y;
 
@@ -734,43 +734,43 @@ VImage::maxpos( VOption *options )
 // Operator overloads
 
 VImage 
-VImage::operator[]( int index ) 
+VImage::operator[]( int index ) const
 {
 	return( this->extract_band( index ) ); 
 }
 
 std::vector<double> 
-VImage::operator()( int x, int y )
+VImage::operator()( int x, int y ) const
 {
 	return( this->getpoint( x, y ) ); 
 }
 
 VImage 
-operator+( VImage a, VImage b ) 
+operator+( const VImage a, const VImage b )
 {
 	return( a.add( b ) );
 }
 
 VImage 
-operator+( double a, VImage b ) 
+operator+( double a, const VImage b ) 
 {
 	return( b.linear( 1.0, a ) ); 
 }
 
 VImage 
-operator+( VImage a, double b ) 
+operator+( const VImage a, double b ) 
 { 
 	return( a.linear( 1.0, b ) ); 
 }
 
 VImage 
-operator+( std::vector<double> a, VImage b ) 
+operator+( const std::vector<double> a, const VImage b ) 
 {
 	return( b.linear( 1.0, a ) ); 
 }
 
 VImage 
-operator+( VImage a, std::vector<double> b ) 
+operator+( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.linear( 1.0, b ) ); 
 }
@@ -788,37 +788,37 @@ operator+=( VImage &a, const double b )
 }
 
 VImage & 
-operator+=( VImage &a, std::vector<double> b )
+operator+=( VImage &a, const std::vector<double> b )
 {
 	return( a = a + b ); 
 }
 
 VImage 
-operator-( VImage a, VImage b ) 
+operator-( const VImage a, const VImage b ) 
 {
 	return( a.subtract( b ) );
 }
 
 VImage 
-operator-( double a, VImage b ) 
+operator-( double a, const VImage b ) 
 {
 	return( b.linear( -1.0, a ) ); 
 }
 
 VImage 
-operator-( VImage a, double b ) 
+operator-( const VImage a, double b ) 
 { 
 	return( a.linear( 1.0, -b ) ); 
 }
 
 VImage 
-operator-( std::vector<double> a, VImage b ) 
+operator-( const std::vector<double> a, const VImage b ) 
 {
 	return( b.linear( -1.0, a ) ); 
 }
 
 VImage 
-operator-( VImage a, std::vector<double> b ) 
+operator-( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.linear( 1.0, vips::negate( b ) ) ); 
 }
@@ -836,43 +836,43 @@ operator-=( VImage &a, const double b )
 }
 
 VImage & 
-operator-=( VImage &a, std::vector<double> b )
+operator-=( VImage &a, const std::vector<double> b )
 {
 	return( a = a - b ); 
 }
 
 VImage 
-operator-( VImage a ) 
+operator-( const VImage a ) 
 { 
 	return( a * -1 );
 }
 
 VImage 
-operator*( VImage a, VImage b ) 
+operator*( const VImage a, const VImage b ) 
 {
 	return( a.multiply( b ) );
 }
 
 VImage 
-operator*( double a, VImage b ) 
+operator*( double a, const VImage b ) 
 {
 	return( b.linear( a, 0.0 ) ); 
 }
 
 VImage 
-operator*( VImage a, double b ) 
+operator*( const VImage a, double b ) 
 { 
 	return( a.linear( b, 0.0 ) ); 
 }
 
 VImage 
-operator*( std::vector<double> a, VImage b ) 
+operator*( const std::vector<double> a, const VImage b ) 
 {
 	return( b.linear( a, 0.0 ) ); 
 }
 
 VImage 
-operator*( VImage a, std::vector<double> b ) 
+operator*( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.linear( b, 0.0 ) ); 
 }
@@ -890,37 +890,37 @@ operator*=( VImage &a, const double b )
 }
 
 VImage & 
-operator*=( VImage &a, std::vector<double> b )
+operator*=( VImage &a, const std::vector<double> b )
 {
 	return( a = a * b ); 
 }
 
 VImage 
-operator/( VImage a, VImage b ) 
+operator/( const VImage a, const VImage b ) 
 {
 	return( a.divide( b ) );
 }
 
 VImage 
-operator/( double a, VImage b ) 
+operator/( double a, const VImage b ) 
 {
 	return( b.pow( -1.0 ).linear( a, 0.0 ) ); 
 }
 
 VImage 
-operator/( VImage a, double b ) 
+operator/( const VImage a, double b ) 
 { 
 	return( a.linear( 1.0 / b, 0.0 ) ); 
 }
 
 VImage 
-operator/( std::vector<double> a, VImage b ) 
+operator/( const std::vector<double> a, const VImage b ) 
 {
 	return( b.pow( -1.0 ).linear( a, 0.0 ) ); 
 }
 
 VImage 
-operator/( VImage a, std::vector<double> b ) 
+operator/( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.linear( vips::invert( b ), 0.0 ) ); 
 }
@@ -938,25 +938,25 @@ operator/=( VImage &a, const double b )
 }
 
 VImage & 
-operator/=( VImage &a, std::vector<double> b )
+operator/=( VImage &a, const std::vector<double> b )
 {
 	return( a = a / b ); 
 }
 
 VImage 
-operator%( VImage a, VImage b ) 
+operator%( const VImage a, const VImage b ) 
 {
 	return( a.remainder( b ) );
 }
 
 VImage 
-operator%( VImage a, double b ) 
+operator%( const VImage a, const double b ) 
 { 
 	return( a.remainder_const( to_vector( b ) ) ); 
 }
 
 VImage 
-operator%( VImage a, std::vector<double> b ) 
+operator%( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.remainder_const( b ) ); 
 }
@@ -974,243 +974,243 @@ operator%=( VImage &a, const double b )
 }
 
 VImage & 
-operator%=( VImage &a, std::vector<double> b )
+operator%=( VImage &a, const std::vector<double> b )
 {
 	return( a = a % b ); 
 }
 
 VImage 
-operator<( VImage a, VImage b ) 
+operator<( const VImage a, const VImage b ) 
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESS ) );
 }
 
 VImage 
-operator<( double a, VImage b ) 
+operator<( const double a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE, 
 		to_vector( a ) ) ); 
 }
 
 VImage 
-operator<( VImage a, double b ) 
+operator<( const VImage a, const double b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS, 
 		to_vector( b ) ) );  
 }
 
 VImage 
-operator<( std::vector<double> a, VImage b ) 
+operator<( const std::vector<double> a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE, 
 		a ) );  
 }
 
 VImage 
-operator<( VImage a, std::vector<double> b ) 
+operator<( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS, 
 		b ) ); 
 }
 
 VImage 
-operator<=( VImage a, VImage b ) 
+operator<=( const VImage a, const VImage b ) 
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESSEQ ) );
 }
 
 VImage 
-operator<=( double a, VImage b ) 
+operator<=( const double a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ, 
 		to_vector( a ) ) );  
 }
 
 VImage 
-operator<=( VImage a, double b ) 
+operator<=( const VImage a, const double b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ, 
 		to_vector( b ) ) );  
 }
 
 VImage 
-operator<=( std::vector<double> a, VImage b ) 
+operator<=( const std::vector<double> a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ, 
 		a ) );
 }
 
 VImage 
-operator<=( VImage a, std::vector<double> b ) 
+operator<=( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
 		b ) );
 }
 
 VImage 
-operator>( VImage a, VImage b ) 
+operator>( const VImage a, const VImage b ) 
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_MORE ) );
 }
 
 VImage 
-operator>( double a, VImage b ) 
+operator>( const double a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS, 
 		to_vector( a ) ) ); 
 }
 
 VImage 
-operator>( VImage a, double b ) 
+operator>( const VImage a, const double b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE, 
 		to_vector( b ) ) );
 }
 
 VImage 
-operator>( std::vector<double> a, VImage b ) 
+operator>( const std::vector<double> a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS, 
 		a ) );
 }
 
 VImage 
-operator>( VImage a, std::vector<double> b ) 
+operator>( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE, 
 		b ) );
 }
 
 VImage 
-operator>=( VImage a, VImage b ) 
+operator>=( const VImage a, const VImage b ) 
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_MOREEQ ) );
 }
 
 VImage 
-operator>=( double a, VImage b ) 
+operator>=( const double a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ, 
 		to_vector( a ) ) );  
 }
 
 VImage 
-operator>=( VImage a, double b ) 
+operator>=( const VImage a, const double b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ, 
 		to_vector( b ) ) ); 
 }
 
 VImage 
-operator>=( std::vector<double> a, VImage b ) 
+operator>=( const std::vector<double> a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ, 
 		a ) );
 }
 
 VImage 
-operator>=( VImage a, std::vector<double> b ) 
+operator>=( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ, 
 		b ) );
 }
 
 VImage 
-operator==( VImage a, VImage b ) 
+operator==( const VImage a, const VImage b ) 
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_EQUAL ) );
 }
 
 VImage 
-operator==( double a, VImage b ) 
+operator==( const double a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL, 
 		to_vector( a ) ) );
 }
 
 VImage 
-operator==( VImage a, double b ) 
+operator==( const VImage a, const double b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL, 
 		to_vector( b ) ) );
 }
 
 VImage 
-operator==( std::vector<double> a, VImage b ) 
+operator==( const std::vector<double> a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL, 
 		a ) );
 }
 
 VImage 
-operator==( VImage a, std::vector<double> b ) 
+operator==( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL, 
 		b ) );
 }
 
 VImage 
-operator!=( VImage a, VImage b ) 
+operator!=( const VImage a, const VImage b ) 
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_NOTEQ ) );
 }
 
 VImage 
-operator!=( double a, VImage b ) 
+operator!=( const double a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
 		to_vector( a ) ) );  
 }
 
 VImage 
-operator!=( VImage a, double b ) 
+operator!=( const VImage a, const double b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ, 
 		to_vector( b ) ) );
 }
 
 VImage 
-operator!=( std::vector<double> a, VImage b ) 
+operator!=( const std::vector<double> a, const VImage b ) 
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
 		a ) );
 }
 
 VImage 
-operator!=( VImage a, std::vector<double> b ) 
+operator!=( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
 		b ) );
 }
 
 VImage 
-operator&( VImage a, VImage b ) 
+operator&( const VImage a, const VImage b ) 
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_AND ) );
 }
 
 VImage 
-operator&( double a, VImage b ) 
+operator&( const double a, const VImage b ) 
 {
 	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_AND, 
 		to_vector( a ) ) );  
 }
 
 VImage 
-operator&( VImage a, double b ) 
+operator&( const VImage a, const double b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_AND, 
 		to_vector( b ) ) );
 }
 
 VImage 
-operator&( std::vector<double> a, VImage b ) 
+operator&( const std::vector<double> a, const VImage b ) 
 {
 	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_AND, a ) );
 }
 
 VImage 
-operator&( VImage a, std::vector<double> b ) 
+operator&( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_AND, b ) );
 }
@@ -1228,40 +1228,40 @@ operator&=( VImage &a, const double b )
 }
 
 VImage & 
-operator&=( VImage &a, std::vector<double> b )
+operator&=( VImage &a, const std::vector<double> b )
 {
 	return( a = a & b ); 
 }
 
 VImage 
-operator|( VImage a, VImage b ) 
+operator|( const VImage a, const VImage b ) 
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_OR ) );
 }
 
 VImage 
-operator|( double a, VImage b ) 
+operator|( const double a, const VImage b ) 
 {
 	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR, 
 		to_vector( a ) ) ); 
 }
 
 VImage 
-operator|( VImage a, double b ) 
+operator|( const VImage a, const double b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR, 
 		to_vector( b ) ) );
 }
 
 VImage 
-operator|( std::vector<double> a, VImage b ) 
+operator|( const std::vector<double> a, const VImage b ) 
 {
 	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR, 
 		a ) );
 }
 
 VImage 
-operator|( VImage a, std::vector<double> b ) 
+operator|( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR, 
 		b ) );
@@ -1280,40 +1280,40 @@ operator|=( VImage &a, const double b )
 }
 
 VImage & 
-operator|=( VImage &a, std::vector<double> b )
+operator|=( VImage &a, const std::vector<double> b )
 {
 	return( a = a | b ); 
 }
 
 VImage 
-operator^( VImage a, VImage b ) 
+operator^( const VImage a, const VImage b ) 
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_EOR ) );
 }
 
 VImage 
-operator^( double a, VImage b ) 
+operator^( const double a, const VImage b ) 
 {
 	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_EOR, 
 		to_vector( a ) ) ); 
 }
 
 VImage 
-operator^( VImage a, double b ) 
+operator^( const VImage a, const double b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_EOR, 
 		to_vector( b ) ) ); 
 }
 
 VImage 
-operator^( std::vector<double> a, VImage b ) 
+operator^( const std::vector<double> a, const VImage b ) 
 {
 	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
 		a ) );
 }
 
 VImage 
-operator^( VImage a, std::vector<double> b ) 
+operator^( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
 		b ) );
@@ -1332,26 +1332,26 @@ operator^=( VImage &a, const double b )
 }
 
 VImage & 
-operator^=( VImage &a, std::vector<double> b )
+operator^=( VImage &a, const std::vector<double> b )
 {
 	return( a = a ^ b ); 
 }
 
 VImage 
-operator<<( VImage a, VImage b ) 
+operator<<( const VImage a, const VImage b ) 
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) );
 }
 
 VImage 
-operator<<( VImage a, double b ) 
+operator<<( const VImage a, const double b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT, 
 		to_vector( b ) ) ); 
 }
 
 VImage 
-operator<<( VImage a, std::vector<double> b ) 
+operator<<( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT, 
 		b ) ); 
@@ -1370,26 +1370,26 @@ operator<<=( VImage &a, const double b )
 }
 
 VImage & 
-operator<<=( VImage &a, std::vector<double> b )
+operator<<=( VImage &a, const std::vector<double> b )
 {
 	return( a = a << b ); 
 }
 
 VImage 
-operator>>( VImage a, VImage b ) 
+operator>>( const VImage a, const VImage b ) 
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) );
 }
 
 VImage 
-operator>>( VImage a, double b ) 
+operator>>( const VImage a, const double b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_RSHIFT, 
 		to_vector( b ) ) );  
 }
 
 VImage 
-operator>>( VImage a, std::vector<double> b ) 
+operator>>( const VImage a, const std::vector<double> b ) 
 { 
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_RSHIFT,
 		b ) ); 
@@ -1408,7 +1408,7 @@ operator>>=( VImage &a, const double b )
 }
 
 VImage & 
-operator>>=( VImage &a, std::vector<double> b )
+operator>>=( VImage &a, const std::vector<double> b )
 {
 	return( a = a << b ); 
 }

src/metadata.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -62,6 +62,21 @@ class MetadataWorker : public Nan::AsyncWorker {
       if (sharp::HasDensity(image)) {
         baton->density = sharp::GetDensity(image);
       }
+      if (image.get_typeof("jpeg-chroma-subsample") == VIPS_TYPE_REF_STRING) {
+        baton->chromaSubsampling = image.get_string("jpeg-chroma-subsample");
+      }
+      if (image.get_typeof("interlaced") == G_TYPE_INT) {
+        baton->isProgressive = image.get_int("interlaced") == 1;
+      }
+      if (image.get_typeof("palette-bit-depth") == G_TYPE_INT) {
+        baton->paletteBitDepth = image.get_int("palette-bit-depth");
+      }
+      if (image.get_typeof(VIPS_META_N_PAGES) == G_TYPE_INT) {
+        baton->pages = image.get_int(VIPS_META_N_PAGES);
+      }
+      if (image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT) {
+        baton->pageHeight = image.get_int(VIPS_META_PAGE_HEIGHT);
+      }
       baton->hasProfile = sharp::HasProfile(image);
       // Derived attributes
       baton->hasAlpha = sharp::HasAlpha(image);
@@ -83,9 +98,9 @@ class MetadataWorker : public Nan::AsyncWorker {
         baton->iccLength = iccLength;
       }
       // IPTC
-      if (image.get_typeof(VIPS_META_IPCT_NAME) == VIPS_TYPE_BLOB) {
+      if (image.get_typeof(VIPS_META_IPTC_NAME) == VIPS_TYPE_BLOB) {
         size_t iptcLength;
-        void const *iptc = image.get_blob(VIPS_META_IPCT_NAME, &iptcLength);
+        void const *iptc = image.get_blob(VIPS_META_IPTC_NAME, &iptcLength);
         baton->iptc = static_cast<char *>(g_malloc(iptcLength));
         memcpy(baton->iptc, iptc, iptcLength);
         baton->iptcLength = iptcLength;
@@ -117,6 +132,9 @@ class MetadataWorker : public Nan::AsyncWorker {
       // Metadata Object
       v8::Local<v8::Object> info = New<v8::Object>();
       Set(info, New("format").ToLocalChecked(), New<v8::String>(baton->format).ToLocalChecked());
+      if (baton->input->bufferLength > 0) {
+        Set(info, New("size").ToLocalChecked(), New<v8::Uint32>(static_cast<uint32_t>(baton->input->bufferLength)));
+      }
       Set(info, New("width").ToLocalChecked(), New<v8::Uint32>(baton->width));
       Set(info, New("height").ToLocalChecked(), New<v8::Uint32>(baton->height));
       Set(info, New("space").ToLocalChecked(), New<v8::String>(baton->space).ToLocalChecked());
@@ -125,6 +143,21 @@ class MetadataWorker : public Nan::AsyncWorker {
       if (baton->density > 0) {
         Set(info, New("density").ToLocalChecked(), New<v8::Uint32>(baton->density));
       }
+      if (!baton->chromaSubsampling.empty()) {
+        Set(info,
+          New("chromaSubsampling").ToLocalChecked(),
+          New<v8::String>(baton->chromaSubsampling).ToLocalChecked());
+      }
+      Set(info, New("isProgressive").ToLocalChecked(), New<v8::Boolean>(baton->isProgressive));
+      if (baton->paletteBitDepth > 0) {
+        Set(info, New("paletteBitDepth").ToLocalChecked(), New<v8::Uint32>(baton->paletteBitDepth));
+      }
+      if (baton->pages > 0) {
+        Set(info, New("pages").ToLocalChecked(), New<v8::Uint32>(baton->pages));
+      }
+      if (baton->pageHeight > 0) {
+        Set(info, New("pageHeight").ToLocalChecked(), New<v8::Uint32>(baton->pageHeight));
+      }
       Set(info, New("hasProfile").ToLocalChecked(), New<v8::Boolean>(baton->hasProfile));
       Set(info, New("hasAlpha").ToLocalChecked(), New<v8::Boolean>(baton->hasAlpha));
       if (baton->orientation > 0) {

src/metadata.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -31,6 +31,11 @@ struct MetadataBaton {
   int channels;
   std::string depth;
   int density;
+  std::string chromaSubsampling;
+  bool isProgressive;
+  int paletteBitDepth;
+  int pages;
+  int pageHeight;
   bool hasProfile;
   bool hasAlpha;
   int orientation;
@@ -50,6 +55,10 @@ struct MetadataBaton {
     height(0),
     channels(0),
     density(0),
+    isProgressive(false),
+    paletteBitDepth(0),
+    pages(0),
+    pageHeight(0),
     hasProfile(false),
     hasAlpha(false),
     orientation(0),

src/operations.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -29,127 +29,25 @@ using vips::VError;
 namespace sharp {
 
   /*
-    Composite overlayImage over image at given position
-    Assumes alpha channels are already premultiplied and will be unpremultiplied after
+    Removes alpha channel, if any.
   */
-  VImage Composite(VImage image, VImage overlayImage, int const left, int const top) {
-    if (HasAlpha(overlayImage)) {
-      // Alpha composite
-      if (overlayImage.width() < image.width() || overlayImage.height() < image.height()) {
-        // Enlarge overlay
-        std::vector<double> const background { 0.0, 0.0, 0.0, 0.0 };
-        overlayImage = overlayImage.embed(left, top, image.width(), image.height(), VImage::option()
-          ->set("extend", VIPS_EXTEND_BACKGROUND)
-          ->set("background", background));
-      }
-      return AlphaComposite(image, overlayImage);
-    } else {
+  VImage RemoveAlpha(VImage image) {
     if (HasAlpha(image)) {
-        // Add alpha channel to overlayImage so channels match
-        double const multiplier = sharp::Is16Bit(overlayImage.interpretation()) ? 256.0 : 1.0;
-        overlayImage = overlayImage.bandjoin(
-          VImage::new_matrix(overlayImage.width(), overlayImage.height()).new_from_image(255 * multiplier));
+      image = image.extract_band(0, VImage::option()->set("n", image.bands() - 1));
     }
-      return image.insert(overlayImage, left, top);
-    }
-  }
-
-  VImage AlphaComposite(VImage dst, VImage src) {
-    // Split src into non-alpha and alpha channels
-    VImage srcWithoutAlpha = src.extract_band(0, VImage::option()->set("n", src.bands() - 1));
-    VImage srcAlpha = src[src.bands() - 1] * (1.0 / 255.0);
-
-    // Split dst into non-alpha and alpha channels
-    VImage dstWithoutAlpha = dst.extract_band(0, VImage::option()->set("n", dst.bands() - 1));
-    VImage dstAlpha = dst[dst.bands() - 1] * (1.0 / 255.0);
-
-    //
-    // Compute normalized output alpha channel:
-    //
-    // References:
-    // - http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending
-    // - https://github.com/jcupitt/ruby-vips/issues/28#issuecomment-9014826
-    //
-    // out_a = src_a + dst_a * (1 - src_a)
-    //                         ^^^^^^^^^^^
-    //                            t0
-    VImage t0 = srcAlpha.linear(-1.0, 1.0);
-    VImage outAlphaNormalized = srcAlpha + dstAlpha * t0;
-
-    //
-    // Compute output RGB channels:
-    //
-    // Wikipedia:
-    // out_rgb = (src_rgb * src_a + dst_rgb * dst_a * (1 - src_a)) / out_a
-    //                                                ^^^^^^^^^^^
-    //                                                    t0
-    //
-    // Omit division by `out_a` since `Compose` is supposed to output a
-    // premultiplied RGBA image as reversal of premultiplication is handled
-    // externally.
-    //
-    VImage outRGBPremultiplied = srcWithoutAlpha + dstWithoutAlpha * t0;
-
-    // Combine RGB and alpha channel into output image:
-    return outRGBPremultiplied.bandjoin(outAlphaNormalized * 255.0);
+    return image;
   }
 
   /*
-    Cutout src over dst with given gravity.
+    Ensures alpha channel, if missing.
   */
-  VImage Cutout(VImage mask, VImage dst, const int gravity) {
-    using sharp::CalculateCrop;
-    using sharp::HasAlpha;
-    using sharp::MaximumImageAlpha;
-
-    bool maskHasAlpha = HasAlpha(mask);
-
-    if (!maskHasAlpha && mask.bands() > 1) {
-      throw VError("Overlay image must have an alpha channel or one band");
+  VImage EnsureAlpha(VImage image) {
+    if (!HasAlpha(image)) {
+      std::vector<double> alpha;
+      alpha.push_back(sharp::MaximumImageAlpha(image.interpretation()));
+      image = image.bandjoin_const(alpha);
     }
-    if (!HasAlpha(dst)) {
-      throw VError("Image to be overlaid must have an alpha channel");
-    }
-    if (mask.width() > dst.width() || mask.height() > dst.height()) {
-      throw VError("Overlay image must have same dimensions or smaller");
-    }
-
-    // Enlarge overlay mask, if required
-    if (mask.width() < dst.width() || mask.height() < dst.height()) {
-      // Calculate the (left, top) coordinates of the output image within the input image, applying the given gravity.
-      int left;
-      int top;
-      std::tie(left, top) = CalculateCrop(dst.width(), dst.height(), mask.width(), mask.height(), gravity);
-      // Embed onto transparent background
-      std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
-      mask = mask.embed(left, top, dst.width(), dst.height(), VImage::option()
-              ->set("extend", VIPS_EXTEND_BACKGROUND)
-              ->set("background", background));
-    }
-
-    // we use the mask alpha if it has alpha
-    if (maskHasAlpha) {
-      mask = mask.extract_band(mask.bands() - 1, VImage::option()->set("n", 1));;
-    }
-
-    // Split dst into an optional alpha
-    VImage dstAlpha = dst.extract_band(dst.bands() - 1, VImage::option()->set("n", 1));
-
-    // we use the dst non-alpha
-    dst = dst.extract_band(0, VImage::option()->set("n", dst.bands() - 1));
-
-    // the range of the mask and the image need to match .. one could be
-    // 16-bit, one 8-bit
-    double const dstMax = MaximumImageAlpha(dst.interpretation());
-    double const maskMax = MaximumImageAlpha(mask.interpretation());
-
-    // combine the new mask and the existing alpha ... there are
-    // many ways of doing this, mult is the simplest
-    mask = dstMax * ((mask / maskMax) * (dstAlpha / dstMax));
-
-    // append the mask to the image data ... the mask might be float now,
-    // we must cast the format down to match the image data
-    return dst.bandjoin(mask.cast(dst.format()));
+    return image;
   }
 
   /*
@@ -161,13 +59,14 @@ namespace sharp {
     if (typeBeforeTint == VIPS_INTERPRETATION_RGB) {
       typeBeforeTint = VIPS_INTERPRETATION_sRGB;
     }
-    // Create 2 band image with every pixel set to the tint chroma
-    std::vector<double> chromaPixel {a, b};
-    VImage chroma = image.new_from_image(chromaPixel);
     // Extract luminance
     VImage luminance = image.colourspace(VIPS_INTERPRETATION_LAB)[0];
     // Create the tinted version by combining the L from the original and the chroma from the tint
-    VImage tinted = luminance.bandjoin(chroma).colourspace(typeBeforeTint);
+    std::vector<double> chroma {a, b};
+    VImage tinted = luminance
+      .bandjoin(chroma)
+      .copy(VImage::option()->set("interpretation", VIPS_INTERPRETATION_LAB))
+      .colourspace(typeBeforeTint);
     // Attach original alpha channel, if any
     if (HasAlpha(image)) {
       // Extract original alpha channel
@@ -222,10 +121,8 @@ namespace sharp {
   VImage Gamma(VImage image, double const exponent) {
     if (HasAlpha(image)) {
       // Separate alpha channel
-      VImage imageWithoutAlpha = image.extract_band(0,
-        VImage::option()->set("n", image.bands() - 1));
       VImage alpha = image[image.bands() - 1];
-      return imageWithoutAlpha.gamma(VImage::option()->set("exponent", exponent)).bandjoin(alpha);
+      return RemoveAlpha(image).gamma(VImage::option()->set("exponent", exponent)).bandjoin(alpha);
     } else {
       return image.gamma(VImage::option()->set("exponent", exponent));
     }
@@ -269,6 +166,25 @@ namespace sharp {
     return image.conv(kernel);
   }
 
+  /*
+   * Recomb with a Matrix of the given bands/channel size.
+   * Eg. RGB will be a 3x3 matrix.
+   */
+  VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix) {
+    double *m = matrix.get();
+    return image
+      .colourspace(VIPS_INTERPRETATION_sRGB)
+      .recomb(image.bands() == 3
+        ? VImage::new_from_memory(
+          m, 9 * sizeof(double), 3, 3, 1, VIPS_FORMAT_DOUBLE
+        )
+        : VImage::new_matrixv(4, 4,
+          m[0], m[1], m[2], 0.0,
+          m[3], m[4], m[5], 0.0,
+          m[6], m[7], m[8], 0.0,
+          0.0, 0.0, 0.0, 1.0));
+  }
+
   /*
    * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
    */
@@ -315,55 +231,22 @@ namespace sharp {
     return image.boolean(imageR, boolean);
   }
 
-  VImage Trim(VImage image, int const tolerance) {
-    using sharp::MaximumImageAlpha;
-    // An equivalent of ImageMagick's -trim in C++ ... automatically remove
-    // "boring" image edges.
-
-    // We use .project to sum the rows and columns of a 0/255 mask image, the first
-    // non-zero row or column is the object edge. We make the mask image with an
-    // amount-different-from-background image plus a threshold.
-
-    // find the value of the pixel at (0, 0) ... we will search for all pixels
-    // significantly different from this
-    std::vector<double> background = image(0, 0);
-
-    double const max = MaximumImageAlpha(image.interpretation());
-
-    // we need to smooth the image, subtract the background from every pixel, take
-    // the absolute value of the difference, then threshold
-    VImage mask = (image.median(3) - background).abs() > (max * tolerance / 100);
-
-    // sum mask rows and columns, then search for the first non-zero sum in each
-    // direction
-    VImage rows;
-    VImage columns = mask.project(&rows);
-
-    VImage profileLeftV;
-    VImage profileLeftH = columns.profile(&profileLeftV);
-
-    VImage profileRightV;
-    VImage profileRightH = columns.fliphor().profile(&profileRightV);
-
-    VImage profileTopV;
-    VImage profileTopH = rows.profile(&profileTopV);
-
-    VImage profileBottomV;
-    VImage profileBottomH = rows.flipver().profile(&profileBottomV);
-
-    int left = static_cast<int>(floor(profileLeftV.min()));
-    int right = columns.width() - static_cast<int>(floor(profileRightV.min()));
-    int top = static_cast<int>(floor(profileTopH.min()));
-    int bottom = rows.height() - static_cast<int>(floor(profileBottomH.min()));
-
-    int width = right - left;
-    int height = bottom - top;
-
-    if (width <= 0 || height <= 0) {
+  /*
+    Trim an image
+  */
+  VImage Trim(VImage image, double const threshold) {
+    // Top-left pixel provides the background colour
+    VImage background = image.extract_area(0, 0, 1, 1);
+    if (HasAlpha(background)) {
+      background = background.flatten();
+    }
+    int top, width, height;
+    int const left = image.find_trim(&top, &width, &height, VImage::option()
+      ->set("background", background(0, 0))
+      ->set("threshold", threshold));
+    if (width == 0 || height == 0) {
       throw VError("Unexpected error while trimming. Try to lower the tolerance");
     }
-
-    // and now crop the original image
     return image.extract_area(left, top, width, height);
   }
 
@@ -373,10 +256,8 @@ namespace sharp {
   VImage Linear(VImage image, double const a, double const b) {
     if (HasAlpha(image)) {
       // Separate alpha channel
-      VImage imageWithoutAlpha = image.extract_band(0,
-        VImage::option()->set("n", image.bands() - 1));
       VImage alpha = image[image.bands() - 1];
-      return imageWithoutAlpha.linear(a, b).bandjoin(alpha);
+      return RemoveAlpha(image).linear(a, b).bandjoin(alpha);
     } else {
       return image.linear(a, b);
     }

src/operations.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -26,25 +26,14 @@ using vips::VImage;
 namespace sharp {
 
   /*
-    Alpha composite src over dst with given gravity.
-    Assumes alpha channels are already premultiplied and will be unpremultiplied after.
+    Removes alpha channel, if any.
   */
-  VImage Composite(VImage src, VImage dst, const int gravity);
+  VImage RemoveAlpha(VImage image);
 
   /*
-    Composite overlayImage over image at given position
+    Ensures alpha channel, if missing.
   */
-  VImage Composite(VImage image, VImage overlayImage, int const x, int const y);
-
-  /*
-    Alpha composite overlayImage over image, assumes matching dimensions
-  */
-  VImage AlphaComposite(VImage image, VImage overlayImage);
-
-  /*
-    Cutout src over dst with given gravity.
-  */
-  VImage Cutout(VImage src, VImage dst, const int gravity);
+  VImage EnsureAlpha(VImage image);
 
   /*
    * Tint an image using the specified chroma, preserving the original image luminance
@@ -95,13 +84,19 @@ namespace sharp {
   /*
     Trim an image
   */
-  VImage Trim(VImage image, int const tolerance);
+  VImage Trim(VImage image, double const threshold);
 
   /*
    * Linear adjustment (a * in + b)
    */
   VImage Linear(VImage image, double const a, double const b);
 
+  /*
+   * Recomb with a Matrix of the given bands/channel size.
+   * Eg. RGB will be a 3x3 matrix.
+   */
+  VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix);
+
 }  // namespace sharp
 
 #endif  // SRC_OPERATIONS_H_

src/pipeline.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -100,8 +100,10 @@ class PipelineWorker : public Nan::AsyncWorker {
       }
 
       // Trim
-      if (baton->trimTolerance != 0) {
-        image = sharp::Trim(image, baton->trimTolerance);
+      if (baton->trimThreshold > 0.0) {
+        image = sharp::Trim(image, baton->trimThreshold);
+        baton->trimOffsetLeft = image.xoffset();
+        baton->trimOffsetTop = image.yoffset();
       }
 
       // Pre extraction
@@ -233,7 +235,7 @@ class PipelineWorker : public Nan::AsyncWorker {
       if (
         xshrink == yshrink && xshrink >= 2 * shrink_on_load_factor &&
         (inputImageType == ImageType::JPEG || inputImageType == ImageType::WEBP) &&
-        baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimTolerance == 0
+        baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold == 0.0
       ) {
         if (xshrink >= 8 * shrink_on_load_factor) {
           xfactor = xfactor / 8;
@@ -281,19 +283,21 @@ class PipelineWorker : public Nan::AsyncWorker {
           }
         }
         // Recalculate integral shrink and double residual
-        int shrunkOnLoadWidth = image.width();
-        int shrunkOnLoadHeight = image.height();
+        int const shrunkOnLoadWidth = image.width();
+        int const shrunkOnLoadHeight = image.height();
         if (!baton->rotateBeforePreExtract &&
           (rotation == VIPS_ANGLE_D90 || rotation == VIPS_ANGLE_D270)) {
-          // Swap input output width and height when rotating by 90 or 270 degrees
-          std::swap(shrunkOnLoadWidth, shrunkOnLoadHeight);
-        }
+          // Swap when rotating by 90 or 270 degrees
+          xfactor = static_cast<double>(shrunkOnLoadWidth) / static_cast<double>(targetResizeHeight);
+          yfactor = static_cast<double>(shrunkOnLoadHeight) / static_cast<double>(targetResizeWidth);
+        } else {
           xfactor = static_cast<double>(shrunkOnLoadWidth) / static_cast<double>(targetResizeWidth);
           yfactor = static_cast<double>(shrunkOnLoadHeight) / static_cast<double>(targetResizeHeight);
         }
+      }
 
       // Ensure we're using a device-independent colour space
-      if (sharp::HasProfile(image)) {
+      if (sharp::HasProfile(image) && image.interpretation() != VIPS_INTERPRETATION_LABS) {
         // Convert to sRGB using embedded profile
         try {
           image = image.icc_transform(
@@ -316,9 +320,9 @@ class PipelineWorker : public Nan::AsyncWorker {
         double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
         // Background colour
         std::vector<double> background {
-          baton->background[0] * multiplier,
-          baton->background[1] * multiplier,
-          baton->background[2] * multiplier
+          baton->flattenBackground[0] * multiplier,
+          baton->flattenBackground[1] * multiplier,
+          baton->flattenBackground[2] * multiplier
         };
         image = image.flatten(VImage::option()
           ->set("background", background));
@@ -339,30 +343,19 @@ class PipelineWorker : public Nan::AsyncWorker {
         image = image.colourspace(VIPS_INTERPRETATION_B_W);
       }
 
-      // Ensure image has an alpha channel when there is an overlay with an alpha channel
-      VImage overlayImage;
-      ImageType overlayImageType = ImageType::UNKNOWN;
-      bool shouldOverlayWithAlpha = FALSE;
-      if (baton->overlay != nullptr) {
-        std::tie(overlayImage, overlayImageType) = OpenInput(baton->overlay, baton->accessMethod);
-        if (HasAlpha(overlayImage)) {
-          shouldOverlayWithAlpha = !baton->overlayCutout;
-          if (!HasAlpha(image)) {
-            double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
-            image = image.bandjoin(
-              VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier));
-          }
-        }
-      }
-
       bool const shouldResize = xfactor != 1.0 || yfactor != 1.0;
       bool const shouldBlur = baton->blurSigma != 0.0;
       bool const shouldConv = baton->convKernelWidth * baton->convKernelHeight > 0;
       bool const shouldSharpen = baton->sharpenSigma != 0.0;
       bool const shouldApplyMedian = baton->medianSize > 0;
+      bool const shouldComposite = !baton->composite.empty();
+
+      if (shouldComposite && !HasAlpha(image)) {
+        image = sharp::EnsureAlpha(image);
+      }
 
       bool const shouldPremultiplyAlpha = HasAlpha(image) &&
-        (shouldResize || shouldBlur || shouldConv || shouldSharpen || shouldOverlayWithAlpha);
+        (shouldResize || shouldBlur || shouldConv || shouldSharpen || shouldComposite);
 
       // Premultiply image alpha channel before all transformations to avoid
       // dark fringing around bright pixels
@@ -377,11 +370,19 @@ class PipelineWorker : public Nan::AsyncWorker {
           vips_enum_from_nick(nullptr, VIPS_TYPE_KERNEL, baton->kernel.data()));
         if (
           kernel != VIPS_KERNEL_NEAREST && kernel != VIPS_KERNEL_CUBIC && kernel != VIPS_KERNEL_LANCZOS2 &&
-          kernel != VIPS_KERNEL_LANCZOS3
+          kernel != VIPS_KERNEL_LANCZOS3 && kernel != VIPS_KERNEL_MITCHELL
         ) {
           throw vips::VError("Unknown kernel");
         }
-
+        // Ensure shortest edge is at least 1 pixel
+        if (image.width() / xfactor < 0.5) {
+          xfactor = 2 * image.width();
+          baton->width = 1;
+        }
+        if (image.height() / yfactor < 0.5) {
+          yfactor = 2 * image.height();
+          baton->height = 1;
+        }
         image = image.resize(1.0 / xfactor, VImage::option()
           ->set("vscale", 1.0 / yfactor)
           ->set("kernel", kernel));
@@ -420,35 +421,8 @@ class PipelineWorker : public Nan::AsyncWorker {
       // Crop/embed
       if (image.width() != baton->width || image.height() != baton->height) {
         if (baton->canvas == Canvas::EMBED) {
-          // Scale up 8-bit values to match 16-bit input image
-          double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
-          // Create background colour
           std::vector<double> background;
-          if (image.bands() > 2) {
-            background = {
-              multiplier * baton->background[0],
-              multiplier * baton->background[1],
-              multiplier * baton->background[2]
-            };
-          } else {
-            // Convert sRGB to greyscale
-            background = { multiplier * (
-              0.2126 * baton->background[0] +
-              0.7152 * baton->background[1] +
-              0.0722 * baton->background[2])
-            };
-          }
-          // Add alpha channel to background colour
-          if (baton->background[3] < 255.0 || HasAlpha(image)) {
-            background.push_back(baton->background[3] * multiplier);
-          }
-          // Ensure background colour uses correct colourspace
-          background = sharp::GetRgbaAsColourspace(background, image.interpretation());
-          // Add non-transparent alpha channel, if required
-          if (baton->background[3] < 255.0 && !HasAlpha(image)) {
-            image = image.bandjoin(
-              VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier));
-          }
+          std::tie(image, background) = sharp::ApplyAlpha(image, baton->resizeBackground);
 
           // Embed
 
@@ -462,7 +436,7 @@ class PipelineWorker : public Nan::AsyncWorker {
           int width = std::max(image.width(), baton->width);
           int height = std::max(image.height(), baton->height);
           std::tie(left, top) = sharp::CalculateEmbedPosition(
-            image.width(), image.height(), baton->width, baton->height, baton->embed);
+            image.width(), image.height(), baton->width, baton->height, baton->position);
 
           image = image.embed(left, top, width, height, VImage::option()
             ->set("extend", VIPS_EXTEND_BACKGROUND)
@@ -473,12 +447,12 @@ class PipelineWorker : public Nan::AsyncWorker {
           (image.width() > baton->width || image.height() > baton->height)
         ) {
           // Crop/max/min
-          if (baton->crop < 9) {
+          if (baton->position < 9) {
             // Gravity-based crop
             int left;
             int top;
             std::tie(left, top) = sharp::CalculateCrop(
-              image.width(), image.height(), baton->width, baton->height, baton->crop);
+              image.width(), image.height(), baton->width, baton->height, baton->position);
             int width = std::min(image.width(), baton->width);
             int height = std::min(image.height(), baton->height);
             image = image.extract_area(left, top, width, height);
@@ -494,7 +468,7 @@ class PipelineWorker : public Nan::AsyncWorker {
               ->set("access", baton->accessMethod)
               ->set("threaded", TRUE));
             image = image.smartcrop(baton->width, baton->height, VImage::option()
-              ->set("interesting", baton->crop == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION));
+              ->set("interesting", baton->position == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION));
             baton->hasCropOffset = true;
             baton->cropOffsetLeft = static_cast<int>(image.xoffset());
             baton->cropOffsetTop = static_cast<int>(image.yoffset());
@@ -502,6 +476,13 @@ class PipelineWorker : public Nan::AsyncWorker {
         }
       }
 
+      // Rotate by degree
+      if (baton->rotationAngle != 0.0) {
+        std::vector<double> background;
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground);
+        image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background));
+      }
+
       // Post extraction
       if (baton->topOffsetPost != -1) {
         image = image.extract_area(
@@ -510,35 +491,9 @@ class PipelineWorker : public Nan::AsyncWorker {
 
       // Extend edges
       if (baton->extendTop > 0 || baton->extendBottom > 0 || baton->extendLeft > 0 || baton->extendRight > 0) {
-        // Scale up 8-bit values to match 16-bit input image
-        double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
-        // Create background colour
         std::vector<double> background;
-        if (image.bands() > 2) {
-          background = {
-            multiplier * baton->background[0],
-            multiplier * baton->background[1],
-            multiplier * baton->background[2]
-          };
-        } else {
-          // Convert sRGB to greyscale
-          background = { multiplier * (
-            0.2126 * baton->background[0] +
-            0.7152 * baton->background[1] +
-            0.0722 * baton->background[2])
-          };
-        }
-        // Add alpha channel to background colour
-        if (baton->background[3] < 255.0 || HasAlpha(image)) {
-          background.push_back(baton->background[3] * multiplier);
-        }
-        // Ensure background colour uses correct colourspace
-        background = sharp::GetRgbaAsColourspace(background, image.interpretation());
-        // Add non-transparent alpha channel, if required
-        if (baton->background[3] < 255.0 && !HasAlpha(image)) {
-          image = image.bandjoin(
-            VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier));
-        }
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->extendBackground);
+
         // Embed
         baton->width = image.width() + baton->extendLeft + baton->extendRight;
         baton->height = image.height() + baton->extendTop + baton->extendBottom;
@@ -568,77 +523,77 @@ class PipelineWorker : public Nan::AsyncWorker {
           baton->convKernel);
       }
 
+      // Recomb
+      if (baton->recombMatrix != NULL) {
+        image = sharp::Recomb(image, baton->recombMatrix);
+      }
+
       // Sharpen
       if (shouldSharpen) {
         image = sharp::Sharpen(image, baton->sharpenSigma, baton->sharpenFlat, baton->sharpenJagged);
       }
 
-      // Composite with overlay, if present
-      if (baton->overlay != nullptr) {
-        // Verify overlay image is within current dimensions
-        if (overlayImage.width() > image.width() || overlayImage.height() > image.height()) {
-          throw vips::VError("Overlay image must have same dimensions or smaller");
+      // Composite
+      if (shouldComposite) {
+        for (Composite *composite : baton->composite) {
+          VImage compositeImage;
+          ImageType compositeImageType = ImageType::UNKNOWN;
+          std::tie(compositeImage, compositeImageType) = OpenInput(composite->input, baton->accessMethod);
+          // Verify within current dimensions
+          if (compositeImage.width() > image.width() || compositeImage.height() > image.height()) {
+            throw vips::VError("Image to composite must have same dimensions or smaller");
           }
           // Check if overlay is tiled
-        if (baton->overlayTile) {
-          int const overlayImageWidth = overlayImage.width();
-          int const overlayImageHeight = overlayImage.height();
+          if (composite->tile) {
             int across = 0;
             int down = 0;
             // Use gravity in overlay
-          if (overlayImageWidth <= baton->width) {
-            across = static_cast<int>(ceil(static_cast<double>(image.width()) / overlayImageWidth));
+            if (compositeImage.width() <= baton->width) {
+              across = static_cast<int>(ceil(static_cast<double>(image.width()) / compositeImage.width()));
             }
-          if (overlayImageHeight <= baton->height) {
-            down = static_cast<int>(ceil(static_cast<double>(image.height()) / overlayImageHeight));
+            if (compositeImage.height() <= baton->height) {
+              down = static_cast<int>(ceil(static_cast<double>(image.height()) / compositeImage.height()));
             }
             if (across != 0 || down != 0) {
               int left;
               int top;
-            overlayImage = overlayImage.replicate(across, down);
-            if (baton->overlayXOffset >= 0 && baton->overlayYOffset >= 0) {
-              // the overlayX/YOffsets will now be used to CalculateCrop for extract_area
+              compositeImage = compositeImage.replicate(across, down);
+              if (composite->left >= 0 && composite->top >= 0) {
                 std::tie(left, top) = sharp::CalculateCrop(
-                overlayImage.width(), overlayImage.height(), image.width(), image.height(),
-                baton->overlayXOffset, baton->overlayYOffset);
+                  compositeImage.width(), compositeImage.height(), image.width(), image.height(),
+                  composite->left, composite->top);
               } else {
-              // the overlayGravity will now be used to CalculateCrop for extract_area
                 std::tie(left, top) = sharp::CalculateCrop(
-                overlayImage.width(), overlayImage.height(), image.width(), image.height(), baton->overlayGravity);
+                  compositeImage.width(), compositeImage.height(), image.width(), image.height(), composite->gravity);
               }
-            overlayImage = overlayImage.extract_area(left, top, image.width(), image.height());
+              compositeImage = compositeImage.extract_area(left, top, image.width(), image.height());
             }
-          // the overlayGravity was used for extract_area, therefore set it back to its default value of 0
-          baton->overlayGravity = 0;
+            // gravity was used for extract_area, set it back to its default value of 0
+            composite->gravity = 0;
           }
-        if (baton->overlayCutout) {
-          // 'cut out' the image, premultiplication is not required
-          image = sharp::Cutout(overlayImage, image, baton->overlayGravity);
-        } else {
-          // Ensure overlay is sRGB
-          overlayImage = overlayImage.colourspace(VIPS_INTERPRETATION_sRGB);
-          // Ensure overlay matches premultiplication state
-          if (shouldPremultiplyAlpha) {
-            // Ensure overlay has alpha channel
-            if (!HasAlpha(overlayImage)) {
-              double const multiplier = sharp::Is16Bit(overlayImage.interpretation()) ? 256.0 : 1.0;
-              overlayImage = overlayImage.bandjoin(
-                VImage::new_matrix(overlayImage.width(), overlayImage.height()).new_from_image(255 * multiplier));
-            }
-            overlayImage = overlayImage.premultiply();
+          // Ensure image to composite is sRGB with premultiplied alpha
+          compositeImage = compositeImage.colourspace(VIPS_INTERPRETATION_sRGB);
+          if (!HasAlpha(compositeImage)) {
+            compositeImage = sharp::EnsureAlpha(compositeImage);
           }
+          compositeImage = compositeImage.premultiply();
+          // Calculate position
           int left;
           int top;
-          if (baton->overlayXOffset >= 0 && baton->overlayYOffset >= 0) {
-            // Composite images at given offsets
+          if (composite->left >= 0 && composite->top >= 0) {
+            // Composite image at given offsets
             std::tie(left, top) = sharp::CalculateCrop(image.width(), image.height(),
-              overlayImage.width(), overlayImage.height(), baton->overlayXOffset, baton->overlayYOffset);
+              compositeImage.width(), compositeImage.height(), composite->left, composite->top);
           } else {
-            // Composite images with given gravity
+            // Composite image with given gravity
             std::tie(left, top) = sharp::CalculateCrop(image.width(), image.height(),
-              overlayImage.width(), overlayImage.height(), baton->overlayGravity);
+              compositeImage.width(), compositeImage.height(), composite->gravity);
           }
-          image = sharp::Composite(image, overlayImage, left, top);
+          // Composite
+          image = image.composite2(compositeImage, composite->mode, VImage::option()
+            ->set("premultiplied", TRUE)
+            ->set("x", left)
+            ->set("y", top));
         }
       }
 
@@ -655,8 +610,8 @@ class PipelineWorker : public Nan::AsyncWorker {
       baton->premultiplied = shouldPremultiplyAlpha;
 
       // Gamma decoding (brighten)
-      if (baton->gamma >= 1 && baton->gamma <= 3) {
-        image = sharp::Gamma(image, baton->gamma);
+      if (baton->gammaOut >= 1 && baton->gammaOut <= 3) {
+        image = sharp::Gamma(image, baton->gammaOut);
       }
 
       // Linear adjustment (a * in + b)
@@ -683,7 +638,7 @@ class PipelineWorker : public Nan::AsyncWorker {
       }
 
       // Tint the image
-      if (baton->tintA > 0 || baton->tintB > 0) {
+      if (baton->tintA < 128.0 || baton->tintB < 128.0) {
         image = sharp::Tint(image, baton->tintA, baton->tintB);
       }
 
@@ -693,8 +648,24 @@ class PipelineWorker : public Nan::AsyncWorker {
           (baton->err).append("Cannot extract channel from image. Too few channels in image.");
           return Error();
         }
-        image = image.extract_band(baton->extractChannel);
+        VipsInterpretation const interpretation = sharp::Is16Bit(image.interpretation())
+          ? VIPS_INTERPRETATION_GREY16
+          : VIPS_INTERPRETATION_B_W;
+        image = image
+          .extract_band(baton->extractChannel)
+          .copy(VImage::option()->set("interpretation", interpretation));
       }
+
+      // Remove alpha channel, if any
+      if (baton->removeAlpha) {
+        image = sharp::RemoveAlpha(image);
+      }
+
+      // Ensure alpha channel, if missing
+      if (baton->ensureAlpha) {
+        image = sharp::EnsureAlpha(image);
+      }
+
       // Convert image to sRGB, if not already
       if (sharp::Is16Bit(image.interpretation())) {
         image = image.cast(VIPS_FORMAT_USHORT);
@@ -730,9 +701,10 @@ class PipelineWorker : public Nan::AsyncWorker {
             ->set("interlace", baton->jpegProgressive)
             ->set("no_subsample", baton->jpegChromaSubsampling == "4:4:4")
             ->set("trellis_quant", baton->jpegTrellisQuantisation)
+            ->set("quant_table", baton->jpegQuantisationTable)
             ->set("overshoot_deringing", baton->jpegOvershootDeringing)
             ->set("optimize_scans", baton->jpegOptimiseScans)
-            ->set("optimize_coding", TRUE)));
+            ->set("optimize_coding", baton->jpegOptimiseCoding)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
           area->free_fn = nullptr;
@@ -747,14 +719,15 @@ class PipelineWorker : public Nan::AsyncWorker {
           (inputImageType == ImageType::PNG || inputImageType == ImageType::GIF || inputImageType == ImageType::SVG))) {
           // Write PNG to buffer
           sharp::AssertImageTypeDimensions(image, ImageType::PNG);
-          // Strip profile
-          if (!baton->withMetadata) {
-            vips_image_remove(image.get_image(), VIPS_META_ICC_NAME);
-          }
           VipsArea *area = VIPS_AREA(image.pngsave_buffer(VImage::option()
+            ->set("strip", !baton->withMetadata)
             ->set("interlace", baton->pngProgressive)
             ->set("compression", baton->pngCompressionLevel)
-            ->set("filter", baton->pngAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_ALL : VIPS_FOREIGN_PNG_FILTER_NONE)));
+            ->set("filter", baton->pngAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_ALL : VIPS_FOREIGN_PNG_FILTER_NONE)
+            ->set("palette", baton->pngPalette)
+            ->set("Q", baton->pngQuality)
+            ->set("colours", baton->pngColours)
+            ->set("dither", baton->pngDither)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
           area->free_fn = nullptr;
@@ -789,6 +762,10 @@ class PipelineWorker : public Nan::AsyncWorker {
             ->set("squash", baton->tiffSquash)
             ->set("compression", baton->tiffCompression)
             ->set("predictor", baton->tiffPredictor)
+            ->set("pyramid", baton->tiffPyramid)
+            ->set("tile", baton->tiffTile)
+            ->set("tile_height", baton->tiffTileHeight)
+            ->set("tile_width", baton->tiffTileWidth)
             ->set("xres", baton->tiffXres)
             ->set("yres", baton->tiffYres)));
           baton->bufferOut = static_cast<char*>(area->data);
@@ -802,6 +779,7 @@ class PipelineWorker : public Nan::AsyncWorker {
           if (baton->greyscale || image.interpretation() == VIPS_INTERPRETATION_B_W) {
             // Extract first band for greyscale image
             image = image[0];
+            baton->channels = 1;
           }
           if (image.format() != VIPS_FORMAT_UCHAR) {
             // Cast pixels to uint8 (unsigned char)
@@ -845,23 +823,25 @@ class PipelineWorker : public Nan::AsyncWorker {
             ->set("interlace", baton->jpegProgressive)
             ->set("no_subsample", baton->jpegChromaSubsampling == "4:4:4")
             ->set("trellis_quant", baton->jpegTrellisQuantisation)
+            ->set("quant_table", baton->jpegQuantisationTable)
             ->set("overshoot_deringing", baton->jpegOvershootDeringing)
             ->set("optimize_scans", baton->jpegOptimiseScans)
-            ->set("optimize_coding", TRUE));
+            ->set("optimize_coding", baton->jpegOptimiseCoding));
           baton->formatOut = "jpeg";
           baton->channels = std::min(baton->channels, 3);
         } else if (baton->formatOut == "png" || (mightMatchInput && isPng) || (willMatchInput &&
           (inputImageType == ImageType::PNG || inputImageType == ImageType::GIF || inputImageType == ImageType::SVG))) {
           // Write PNG to file
           sharp::AssertImageTypeDimensions(image, ImageType::PNG);
-          // Strip profile
-          if (!baton->withMetadata) {
-            vips_image_remove(image.get_image(), VIPS_META_ICC_NAME);
-          }
           image.pngsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+            ->set("strip", !baton->withMetadata)
             ->set("interlace", baton->pngProgressive)
             ->set("compression", baton->pngCompressionLevel)
-            ->set("filter", baton->pngAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_ALL : VIPS_FOREIGN_PNG_FILTER_NONE));
+            ->set("filter", baton->pngAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_ALL : VIPS_FOREIGN_PNG_FILTER_NONE)
+            ->set("palette", baton->pngPalette)
+            ->set("Q", baton->pngQuality)
+            ->set("colours", baton->pngColours)
+            ->set("dither", baton->pngDither));
           baton->formatOut = "png";
         } else if (baton->formatOut == "webp" || (mightMatchInput && isWebp) ||
           (willMatchInput && inputImageType == ImageType::WEBP)) {
@@ -880,16 +860,16 @@ class PipelineWorker : public Nan::AsyncWorker {
           if (baton->tiffCompression == VIPS_FOREIGN_TIFF_COMPRESSION_JPEG) {
             sharp::AssertImageTypeDimensions(image, ImageType::JPEG);
           }
-          // 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)
             ->set("squash", baton->tiffSquash)
             ->set("compression", baton->tiffCompression)
             ->set("predictor", baton->tiffPredictor)
+            ->set("pyramid", baton->tiffPyramid)
+            ->set("tile", baton->tiffTile)
+            ->set("tile_height", baton->tiffTileHeight)
+            ->set("tile_width", baton->tiffTileWidth)
             ->set("xres", baton->tiffXres)
             ->set("yres", baton->tiffYres));
           baton->formatOut = "tiff";
@@ -924,21 +904,30 @@ class PipelineWorker : public Nan::AsyncWorker {
               {"interlace", baton->jpegProgressive ? "TRUE" : "FALSE"},
               {"no_subsample", baton->jpegChromaSubsampling == "4:4:4" ? "TRUE": "FALSE"},
               {"trellis_quant", baton->jpegTrellisQuantisation ? "TRUE" : "FALSE"},
+              {"quant_table", std::to_string(baton->jpegQuantisationTable)},
               {"overshoot_deringing", baton->jpegOvershootDeringing ? "TRUE": "FALSE"},
               {"optimize_scans", baton->jpegOptimiseScans ? "TRUE": "FALSE"},
-              {"optimize_coding", "TRUE"}
+              {"optimize_coding", baton->jpegOptimiseCoding ? "TRUE": "FALSE"}
             };
             suffix = AssembleSuffixString(extname, options);
           }
           // Write DZ to file
-          image.dzsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+          vips::VOption *options = VImage::option()
                                        ->set("strip", !baton->withMetadata)
                                        ->set("tile_size", baton->tileSize)
                                        ->set("overlap", baton->tileOverlap)
                                        ->set("container", baton->tileContainer)
                                        ->set("layout", baton->tileLayout)
                                        ->set("suffix", const_cast<char*>(suffix.data()))
-            ->set("angle", CalculateAngleRotation(baton->tileAngle)));
+                                       ->set("angle", CalculateAngleRotation(baton->tileAngle));
+
+          // libvips chooses a default depth based on layout. Instead of replicating that logic here by
+          // not passing anything - libvips will handle choice
+          if (baton->tileDepth < VIPS_FOREIGN_DZ_DEPTH_LAST) {
+            options->set("depth", baton->tileDepth);
+          }
+
+          image.dzsave(const_cast<char*>(baton->fileOut.data()), options);
           baton->formatOut = "dz";
         } else if (baton->formatOut == "v" || (mightMatchInput && isV) ||
           (willMatchInput && inputImageType == ImageType::VIPS)) {
@@ -993,6 +982,12 @@ class PipelineWorker : public Nan::AsyncWorker {
         Set(info, New("cropOffsetTop").ToLocalChecked(),
           New<v8::Int32>(static_cast<int32_t>(baton->cropOffsetTop)));
       }
+      if (baton->trimThreshold > 0.0) {
+        Set(info, New("trimOffsetLeft").ToLocalChecked(),
+          New<v8::Int32>(static_cast<int32_t>(baton->trimOffsetLeft)));
+        Set(info, New("trimOffsetTop").ToLocalChecked(),
+          New<v8::Int32>(static_cast<int32_t>(baton->trimOffsetTop)));
+      }
 
       if (baton->bufferOutLength > 0) {
         // Pass ownership of output data to Buffer instance
@@ -1018,13 +1013,17 @@ class PipelineWorker : public Nan::AsyncWorker {
         GetFromPersistent(index);
         return index + 1;
       });
+
+    // Delete baton
     delete baton->input;
-    delete baton->overlay;
     delete baton->boolean;
-    for_each(baton->joinChannelIn.begin(), baton->joinChannelIn.end(),
-      [this](sharp::InputDescriptor *joinChannelIn) {
-        delete joinChannelIn;
-      });
+    for (Composite *composite : baton->composite) {
+      delete composite->input;
+      delete composite;
+    }
+    for (sharp::InputDescriptor *input : baton->joinChannelIn) {
+      delete input;
+    }
     delete baton;
 
     // Handle warnings
@@ -1124,6 +1123,7 @@ NAN_METHOD(pipeline) {
   using sharp::AttrTo;
   using sharp::AttrAs;
   using sharp::AttrAsStr;
+  using sharp::AttrAsRgba;
   using sharp::CreateInputDescriptor;
 
   // Input Buffers must not undergo GC compaction during processing
@@ -1167,27 +1167,29 @@ NAN_METHOD(pipeline) {
   } else if (canvas == "ignore_aspect") {
     baton->canvas = Canvas::IGNORE_ASPECT;
   }
-  // Background colour
-  v8::Local<v8::Object> background = AttrAs<v8::Object>(options, "background");
-  for (unsigned int i = 0; i < 4; i++) {
-    baton->background[i] = AttrTo<double>(background, i);
-  }
   // Tint chroma
   baton->tintA = AttrTo<double>(options, "tintA");
   baton->tintB = AttrTo<double>(options, "tintB");
-  // Overlay options
-  if (HasAttr(options, "overlay")) {
-    baton->overlay = CreateInputDescriptor(AttrAs<v8::Object>(options, "overlay"), buffersToPersist);
-    baton->overlayGravity = AttrTo<int32_t>(options, "overlayGravity");
-    baton->overlayXOffset = AttrTo<int32_t>(options, "overlayXOffset");
-    baton->overlayYOffset = AttrTo<int32_t>(options, "overlayYOffset");
-    baton->overlayTile = AttrTo<bool>(options, "overlayTile");
-    baton->overlayCutout = AttrTo<bool>(options, "overlayCutout");
+  // Composite
+  v8::Local<v8::Array> compositeArray = Nan::Get(options, Nan::New("composite").ToLocalChecked())
+    .ToLocalChecked().As<v8::Array>();
+  int const compositeArrayLength = AttrTo<uint32_t>(compositeArray, "length");
+  for (int i = 0; i < compositeArrayLength; i++) {
+    v8::Local<v8::Object> compositeObject = Nan::Get(compositeArray, i).ToLocalChecked().As<v8::Object>();
+    Composite *composite = new Composite;
+    composite->input = CreateInputDescriptor(AttrAs<v8::Object>(compositeObject, "input"), buffersToPersist);
+    composite->mode = static_cast<VipsBlendMode>(
+      vips_enum_from_nick(nullptr, VIPS_TYPE_BLEND_MODE, AttrAsStr(compositeObject, "blend").data()));
+    composite->gravity = AttrTo<uint32_t>(compositeObject, "gravity");
+    composite->left = AttrTo<int32_t>(compositeObject, "left");
+    composite->top = AttrTo<int32_t>(compositeObject, "top");
+    composite->tile = AttrTo<bool>(compositeObject, "tile");
+    baton->composite.push_back(composite);
   }
   // Resize options
   baton->withoutEnlargement = AttrTo<bool>(options, "withoutEnlargement");
-  baton->crop = AttrTo<int32_t>(options, "crop");
-  baton->embed = AttrTo<int32_t>(options, "embed");
+  baton->position = AttrTo<int32_t>(options, "position");
+  baton->resizeBackground = AttrAsRgba(options, "resizeBackground");
   baton->kernel = AttrAsStr(options, "kernel");
   baton->fastShrinkOnLoad = AttrTo<bool>(options, "fastShrinkOnLoad");
   // Join Channel Options
@@ -1205,6 +1207,7 @@ NAN_METHOD(pipeline) {
   }
   // Operators
   baton->flatten = AttrTo<bool>(options, "flatten");
+  baton->flattenBackground = AttrAsRgba(options, "flattenBackground");
   baton->negate = AttrTo<bool>(options, "negate");
   baton->blurSigma = AttrTo<double>(options, "blurSigma");
   baton->medianSize = AttrTo<uint32_t>(options, "medianSize");
@@ -1213,14 +1216,17 @@ NAN_METHOD(pipeline) {
   baton->sharpenJagged = AttrTo<double>(options, "sharpenJagged");
   baton->threshold = AttrTo<int32_t>(options, "threshold");
   baton->thresholdGrayscale = AttrTo<bool>(options, "thresholdGrayscale");
-  baton->trimTolerance = AttrTo<int32_t>(options, "trimTolerance");
+  baton->trimThreshold = AttrTo<double>(options, "trimThreshold");
   baton->gamma = AttrTo<double>(options, "gamma");
+  baton->gammaOut = AttrTo<double>(options, "gammaOut");
   baton->linearA = AttrTo<double>(options, "linearA");
   baton->linearB = AttrTo<double>(options, "linearB");
   baton->greyscale = AttrTo<bool>(options, "greyscale");
   baton->normalise = AttrTo<bool>(options, "normalise");
   baton->useExifOrientation = AttrTo<bool>(options, "useExifOrientation");
   baton->angle = AttrTo<int32_t>(options, "angle");
+  baton->rotationAngle = AttrTo<double>(options, "rotationAngle");
+  baton->rotationBackground = AttrAsRgba(options, "rotationBackground");
   baton->rotateBeforePreExtract = AttrTo<bool>(options, "rotateBeforePreExtract");
   baton->flip = AttrTo<bool>(options, "flip");
   baton->flop = AttrTo<bool>(options, "flop");
@@ -1228,7 +1234,11 @@ NAN_METHOD(pipeline) {
   baton->extendBottom = AttrTo<int32_t>(options, "extendBottom");
   baton->extendLeft = AttrTo<int32_t>(options, "extendLeft");
   baton->extendRight = AttrTo<int32_t>(options, "extendRight");
+  baton->extendBackground = AttrAsRgba(options, "extendBackground");
   baton->extractChannel = AttrTo<int32_t>(options, "extractChannel");
+
+  baton->removeAlpha = AttrTo<bool>(options, "removeAlpha");
+  baton->ensureAlpha = AttrTo<bool>(options, "ensureAlpha");
   if (HasAttr(options, "boolean")) {
     baton->boolean = CreateInputDescriptor(AttrAs<v8::Object>(options, "boolean"), buffersToPersist);
     baton->booleanOp = sharp::GetBooleanOperation(AttrAsStr(options, "booleanOp"));
@@ -1249,6 +1259,13 @@ NAN_METHOD(pipeline) {
       baton->convKernel[i] = AttrTo<double>(kdata, i);
     }
   }
+  if (HasAttr(options, "recombMatrix")) {
+    baton->recombMatrix = std::unique_ptr<double[]>(new double[9]);
+    v8::Local<v8::Array> recombMatrix = AttrAs<v8::Array>(options, "recombMatrix");
+    for (unsigned int i = 0; i < 9; i++) {
+       baton->recombMatrix[i] = AttrTo<double>(recombMatrix, i);
+    }
+  }
   baton->colourspace = sharp::GetInterpretation(AttrAsStr(options, "colourspace"));
   if (baton->colourspace == VIPS_INTERPRETATION_ERROR) {
     baton->colourspace = VIPS_INTERPRETATION_sRGB;
@@ -1263,17 +1280,27 @@ NAN_METHOD(pipeline) {
   baton->jpegProgressive = AttrTo<bool>(options, "jpegProgressive");
   baton->jpegChromaSubsampling = AttrAsStr(options, "jpegChromaSubsampling");
   baton->jpegTrellisQuantisation = AttrTo<bool>(options, "jpegTrellisQuantisation");
+  baton->jpegQuantisationTable = AttrTo<uint32_t>(options, "jpegQuantisationTable");
   baton->jpegOvershootDeringing = AttrTo<bool>(options, "jpegOvershootDeringing");
   baton->jpegOptimiseScans = AttrTo<bool>(options, "jpegOptimiseScans");
+  baton->jpegOptimiseCoding = AttrTo<bool>(options, "jpegOptimiseCoding");
   baton->pngProgressive = AttrTo<bool>(options, "pngProgressive");
   baton->pngCompressionLevel = AttrTo<uint32_t>(options, "pngCompressionLevel");
   baton->pngAdaptiveFiltering = AttrTo<bool>(options, "pngAdaptiveFiltering");
+  baton->pngPalette = AttrTo<bool>(options, "pngPalette");
+  baton->pngQuality = AttrTo<uint32_t>(options, "pngQuality");
+  baton->pngColours = AttrTo<uint32_t>(options, "pngColours");
+  baton->pngDither = AttrTo<double>(options, "pngDither");
   baton->webpQuality = AttrTo<uint32_t>(options, "webpQuality");
   baton->webpAlphaQuality = AttrTo<uint32_t>(options, "webpAlphaQuality");
   baton->webpLossless = AttrTo<bool>(options, "webpLossless");
   baton->webpNearLossless = AttrTo<bool>(options, "webpNearLossless");
   baton->tiffQuality = AttrTo<uint32_t>(options, "tiffQuality");
+  baton->tiffPyramid = AttrTo<bool>(options, "tiffPyramid");
   baton->tiffSquash = AttrTo<bool>(options, "tiffSquash");
+  baton->tiffTile = AttrTo<bool>(options, "tiffTile");
+  baton->tiffTileWidth = AttrTo<uint32_t>(options, "tiffTileWidth");
+  baton->tiffTileHeight = AttrTo<uint32_t>(options, "tiffTileHeight");
   baton->tiffXres = AttrTo<double>(options, "tiffXres");
   baton->tiffYres = AttrTo<double>(options, "tiffYres");
   // tiff compression options
@@ -1303,10 +1330,21 @@ NAN_METHOD(pipeline) {
     baton->tileLayout = VIPS_FOREIGN_DZ_LAYOUT_DZ;
   }
   baton->tileFormat = AttrAsStr(options, "tileFormat");
+  std::string tileDepth = AttrAsStr(options, "tileDepth");
+  if (tileDepth == "onetile") {
+    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_ONETILE;
+  } else if (tileDepth == "one") {
+    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_ONE;
+  } else if (tileDepth == "onepixel") {
+    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL;
+  } else {
+    // signal that we do not want to pass any value to dzSave
+    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_LAST;
+  }
   // Force random access for certain operations
   if (baton->accessMethod == VIPS_ACCESS_SEQUENTIAL && (
-    baton->trimTolerance != 0 || baton->normalise ||
-    baton->crop == 16 || baton->crop == 17)) {
+    baton->trimThreshold > 0.0 || baton->normalise ||
+    baton->position == 16 || baton->position == 17)) {
     baton->accessMethod = VIPS_ACCESS_RANDOM;
   }
 

src/pipeline.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -34,6 +34,23 @@ enum class Canvas {
   IGNORE_ASPECT
 };
 
+struct Composite {
+  sharp::InputDescriptor *input;
+  VipsBlendMode mode;
+  int gravity;
+  int left;
+  int top;
+  bool tile;
+
+  Composite():
+    input(nullptr),
+    mode(VIPS_BLEND_MODE_OVER),
+    gravity(0),
+    left(-1),
+    top(-1),
+    tile(false) {}
+};
+
 struct PipelineBaton {
   sharp::InputDescriptor *input;
   std::string iccProfilePath;
@@ -42,12 +59,7 @@ struct PipelineBaton {
   std::string fileOut;
   void *bufferOut;
   size_t bufferOutLength;
-  sharp::InputDescriptor *overlay;
-  int overlayGravity;
-  int overlayXOffset;
-  int overlayYOffset;
-  bool overlayTile;
-  bool overlayCutout;
+  std::vector<Composite *> composite;
   std::vector<sharp::InputDescriptor *> joinChannelIn;
   int topOffsetPre;
   int leftOffsetPre;
@@ -61,18 +73,18 @@ struct PipelineBaton {
   int height;
   int channels;
   Canvas canvas;
-  int crop;
-  int embed;
+  int position;
+  std::vector<double> resizeBackground;
   bool hasCropOffset;
   int cropOffsetLeft;
   int cropOffsetTop;
   bool premultiplied;
   std::string kernel;
   bool fastShrinkOnLoad;
-  double background[4];
   double tintA;
   double tintB;
   bool flatten;
+  std::vector<double> flattenBackground;
   bool negate;
   double blurSigma;
   int medianSize;
@@ -81,14 +93,19 @@ struct PipelineBaton {
   double sharpenJagged;
   int threshold;
   bool thresholdGrayscale;
-  int trimTolerance;
+  double trimThreshold;
+  int trimOffsetLeft;
+  int trimOffsetTop;
   double linearA;
   double linearB;
   double gamma;
+  double gammaOut;
   bool greyscale;
   bool normalise;
   bool useExifOrientation;
   int angle;
+  double rotationAngle;
+  std::vector<double> rotationBackground;
   bool rotateBeforePreExtract;
   bool flip;
   bool flop;
@@ -96,17 +113,24 @@ struct PipelineBaton {
   int extendBottom;
   int extendLeft;
   int extendRight;
+  std::vector<double> extendBackground;
   bool withoutEnlargement;
   VipsAccess accessMethod;
   int jpegQuality;
   bool jpegProgressive;
   std::string jpegChromaSubsampling;
   bool jpegTrellisQuantisation;
+  int jpegQuantisationTable;
   bool jpegOvershootDeringing;
   bool jpegOptimiseScans;
+  bool jpegOptimiseCoding;
   bool pngProgressive;
   int pngCompressionLevel;
   bool pngAdaptiveFiltering;
+  bool pngPalette;
+  int pngQuality;
+  int pngColours;
+  double pngDither;
   int webpQuality;
   int webpAlphaQuality;
   bool webpNearLossless;
@@ -114,7 +138,11 @@ struct PipelineBaton {
   int tiffQuality;
   VipsForeignTiffCompression tiffCompression;
   VipsForeignTiffPredictor tiffPredictor;
+  bool tiffPyramid;
   bool tiffSquash;
+  bool tiffTile;
+  int tiffTileHeight;
+  int tiffTileWidth;
   double tiffXres;
   double tiffYres;
   std::string err;
@@ -129,6 +157,8 @@ struct PipelineBaton {
   VipsOperationBoolean booleanOp;
   VipsOperationBoolean bandBoolOp;
   int extractChannel;
+  bool removeAlpha;
+  bool ensureAlpha;
   VipsInterpretation colourspace;
   int tileSize;
   int tileOverlap;
@@ -136,30 +166,27 @@ struct PipelineBaton {
   VipsForeignDzLayout tileLayout;
   std::string tileFormat;
   int tileAngle;
+  VipsForeignDzDepth tileDepth;
+  std::unique_ptr<double[]> recombMatrix;
 
   PipelineBaton():
     input(nullptr),
     limitInputPixels(0),
     bufferOutLength(0),
-    overlay(nullptr),
-    overlayGravity(0),
-    overlayXOffset(-1),
-    overlayYOffset(-1),
-    overlayTile(false),
-    overlayCutout(false),
     topOffsetPre(-1),
     topOffsetPost(-1),
     channels(0),
     canvas(Canvas::CROP),
-    crop(0),
-    embed(0),
+    position(0),
+    resizeBackground{ 0.0, 0.0, 0.0, 255.0 },
     hasCropOffset(false),
     cropOffsetLeft(0),
     cropOffsetTop(0),
     premultiplied(false),
-    tintA(0.0),
-    tintB(0.0),
+    tintA(128.0),
+    tintB(128.0),
     flatten(false),
+    flattenBackground{ 0.0, 0.0, 0.0 },
     negate(false),
     blurSigma(0.0),
     medianSize(0),
@@ -168,7 +195,9 @@ struct PipelineBaton {
     sharpenJagged(2.0),
     threshold(0),
     thresholdGrayscale(true),
-    trimTolerance(0),
+    trimThreshold(0.0),
+    trimOffsetLeft(0),
+    trimOffsetTop(0),
     linearA(1.0),
     linearB(0.0),
     gamma(0.0),
@@ -176,27 +205,40 @@ struct PipelineBaton {
     normalise(false),
     useExifOrientation(false),
     angle(0),
+    rotationAngle(0.0),
+    rotationBackground{ 0.0, 0.0, 0.0, 255.0 },
     flip(false),
     flop(false),
     extendTop(0),
     extendBottom(0),
     extendLeft(0),
     extendRight(0),
+    extendBackground{ 0.0, 0.0, 0.0, 255.0 },
     withoutEnlargement(false),
     jpegQuality(80),
     jpegProgressive(false),
     jpegChromaSubsampling("4:2:0"),
     jpegTrellisQuantisation(false),
+    jpegQuantisationTable(0),
     jpegOvershootDeringing(false),
     jpegOptimiseScans(false),
+    jpegOptimiseCoding(true),
     pngProgressive(false),
     pngCompressionLevel(9),
     pngAdaptiveFiltering(false),
+    pngPalette(false),
+    pngQuality(100),
+    pngColours(256),
+    pngDither(1.0),
     webpQuality(80),
     tiffQuality(80),
     tiffCompression(VIPS_FOREIGN_TIFF_COMPRESSION_JPEG),
     tiffPredictor(VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL),
+    tiffPyramid(false),
     tiffSquash(false),
+    tiffTile(false),
+    tiffTileHeight(256),
+    tiffTileWidth(256),
     tiffXres(1.0),
     tiffYres(1.0),
     withMetadata(false),
@@ -209,17 +251,15 @@ struct PipelineBaton {
     booleanOp(VIPS_OPERATION_BOOLEAN_LAST),
     bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
     extractChannel(-1),
+    removeAlpha(false),
+    ensureAlpha(false),
     colourspace(VIPS_INTERPRETATION_LAST),
     tileSize(256),
     tileOverlap(0),
     tileContainer(VIPS_FOREIGN_DZ_CONTAINER_FS),
     tileLayout(VIPS_FOREIGN_DZ_LAYOUT_DZ),
-    tileAngle(0){
-      background[0] = 0.0;
-      background[1] = 0.0;
-      background[2] = 0.0;
-      background[3] = 255.0;
-    }
+    tileAngle(0),
+    tileDepth(VIPS_FOREIGN_DZ_DEPTH_LAST) {}
 };
 
 #endif  // SRC_PIPELINE_H_

src/sharp.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.

src/stats.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -59,7 +59,6 @@ class StatsWorker : public Nan::AsyncWorker {
     using sharp::MaximumImageAlpha;
 
     vips::VImage image;
-    vips::VImage stats;
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
 
     try {
@@ -69,9 +68,8 @@ class StatsWorker : public Nan::AsyncWorker {
     }
     if (imageType != sharp::ImageType::UNKNOWN) {
       try {
-        stats = image.stats();
-        int bands = image.bands();
-        double const max = MaximumImageAlpha(image.interpretation());
+        vips::VImage stats = image.stats();
+        int const bands = image.bands();
         for (int b = 1; b <= bands; b++) {
           ChannelStats cStats(static_cast<int>(stats.getpoint(STAT_MIN_INDEX, b).front()),
                               static_cast<int>(stats.getpoint(STAT_MAX_INDEX, b).front()),
@@ -83,11 +81,15 @@ class StatsWorker : public Nan::AsyncWorker {
                               static_cast<int>(stats.getpoint(STAT_MAXY_INDEX, b).front()));
           baton->channelStats.push_back(cStats);
         }
-
-        // alpha layer is there and the last band i.e. alpha has its max value greater than 0)
-        if (sharp::HasAlpha(image) && stats.getpoint(STAT_MIN_INDEX, bands).front() != max) {
+        // Image is not opaque when alpha layer is present and contains a non-mamixa value
+        if (sharp::HasAlpha(image)) {
+          double const minAlpha = static_cast<double>(stats.getpoint(STAT_MIN_INDEX, bands).front());
+          if (minAlpha != MaximumImageAlpha(image.interpretation())) {
             baton->isOpaque = false;
           }
+        }
+        // Estimate entropy via histogram of greyscale value frequency
+        baton->entropy = std::abs(image.colourspace(VIPS_INTERPRETATION_B_W)[0].hist_find().hist_entropy());
       } catch (vips::VError const &err) {
         (baton->err).append(err.what());
       }
@@ -130,6 +132,7 @@ class StatsWorker : public Nan::AsyncWorker {
 
       Set(info, New("channels").ToLocalChecked(), channels);
       Set(info, New("isOpaque").ToLocalChecked(), New<v8::Boolean>(baton->isOpaque));
+      Set(info, New("entropy").ToLocalChecked(), New<v8::Number>(baton->entropy));
       argv[1] = info;
     }
 

src/stats.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -51,12 +51,14 @@ struct StatsBaton {
   // Output
   std::vector<ChannelStats> channelStats;
   bool isOpaque;
+  double entropy;
 
   std::string err;
 
   StatsBaton():
     input(nullptr),
-    isOpaque(true)
+    isOpaque(true),
+    entropy(0.0)
     {}
 };
 

src/utilities.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.
@@ -259,7 +259,7 @@ NAN_METHOD(_maxColourDistance) {
     }
     // Calculate colour distance
     maxColourDistance = image1.dE00(image2).max();
-  } catch (VError err) {
+  } catch (VError const &err) {
     return ThrowError(err.what());
   }
 

src/utilities.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017 Lovell Fuller and contributors.
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 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.

test/bench/package.json

@@ -8,19 +8,17 @@
     "test": "node perf && node random && node parallel"
   },
   "devDependencies": {
-    "async": "^2.6.0",
+    "async": "^2.6.1",
     "benchmark": "^2.1.4",
     "gm": "^1.23.1",
     "imagemagick": "^0.1.3",
     "imagemagick-native": "^1.9.3",
-    "images": "^3.0.1",
-    "jimp": "^0.2.28",
-    "mapnik": "^3.6.2",
-    "pajk-lwip": "^0.2.0",
-    "semver": "^5.4.1"
+    "jimp": "^0.5.3",
+    "mapnik": "^4.0.1",
+    "semver": "^5.5.1"
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=4"
+    "node": ">=6"
   }
 }

test/bench/perf.js

@@ -12,24 +12,12 @@ const gm = require('gm');
 const imagemagick = require('imagemagick');
 const mapnik = require('mapnik');
 const jimp = require('jimp');
-let images;
-try {
-  images = require('images');
-} catch (err) {
-  console.log('Excluding node-images');
-}
 let imagemagickNative;
 try {
   imagemagickNative = require('imagemagick-native');
 } catch (err) {
   console.log('Excluding imagemagick-native');
 }
-let lwip;
-try {
-  lwip = require('pajk-lwip');
-} catch (err) {
-  console.log('Excluding lwip');
-}
 
 const fixtures = require('../fixtures');
 
@@ -38,8 +26,6 @@ const height = 588;
 
 // Disable libvips cache to ensure tests are as fair as they can be
 sharp.cache(false);
-// Enable use of SIMD
-sharp.simd(true);
 
 async.series({
   'jpeg': function (callback) {
@@ -54,7 +40,7 @@ async.series({
             throw err;
           } else {
             image
-              .resize(width, height)
+              .resize(width, height, jimp.RESIZE_BICUBIC)
               .quality(80)
               .getBuffer(jimp.MIME_JPEG, function (err) {
                 if (err) {
@@ -74,7 +60,7 @@ async.series({
             throw err;
           } else {
             image
-              .resize(width, height)
+              .resize(width, height, jimp.RESIZE_BICUBIC)
               .quality(80)
               .write(fixtures.outputJpg, function (err) {
                 if (err) {
@@ -87,51 +73,6 @@ async.series({
         });
       }
     });
-    // lwip
-    if (typeof lwip !== 'undefined') {
-      jpegSuite.add('lwip-file-file', {
-        defer: true,
-        fn: function (deferred) {
-          lwip.open(fixtures.inputJpg, function (err, image) {
-            if (err) {
-              throw err;
-            }
-            image.resize(width, height, 'lanczos', function (err, image) {
-              if (err) {
-                throw err;
-              }
-              image.writeFile(fixtures.outputJpg, {quality: 80}, function (err) {
-                if (err) {
-                  throw err;
-                }
-                deferred.resolve();
-              });
-            });
-          });
-        }
-      }).add('lwip-buffer-buffer', {
-        defer: true,
-        fn: function (deferred) {
-          lwip.open(inputJpgBuffer, 'jpg', function (err, image) {
-            if (err) {
-              throw err;
-            }
-            image.resize(width, height, 'lanczos', function (err, image) {
-              if (err) {
-                throw err;
-              }
-              image.toBuffer('jpg', {quality: 80}, function (err, buffer) {
-                if (err) {
-                  throw err;
-                }
-                assert.notStrictEqual(null, buffer);
-                deferred.resolve();
-              });
-            });
-          });
-        }
-      });
-    }
     // mapnik
     jpegSuite.add('mapnik-file-file', {
       defer: true,
@@ -272,14 +213,6 @@ async.series({
           });
       }
     });
-    // images
-    if (typeof images !== 'undefined') {
-      jpegSuite.add('images-file-file', function () {
-        images(fixtures.inputJpg)
-          .resize(width, height)
-          .save(fixtures.outputJpg, { quality: 80 });
-      });
-    }
     // sharp
     jpegSuite.add('sharp-buffer-file', {
       defer: true,
@@ -569,8 +502,10 @@ async.series({
       defer: true,
       fn: function (deferred) {
         sharp(inputJpgBuffer)
-          .resize(width, height)
-          .crop(sharp.strategy.entropy)
+          .resize(width, height, {
+            fit: 'cover',
+            position: sharp.strategy.entropy
+          })
           .toBuffer(function (err, buffer) {
             if (err) {
               throw err;
@@ -584,8 +519,10 @@ async.series({
       defer: true,
       fn: function (deferred) {
         sharp(inputJpgBuffer)
-          .resize(width, height)
-          .crop(sharp.strategy.attention)
+          .resize(width, height, {
+            fit: 'cover',
+            position: sharp.strategy.attention
+          })
           .toBuffer(function (err, buffer) {
             if (err) {
               throw err;
@@ -696,31 +633,6 @@ async.series({
         });
       }
     });
-    // lwip
-    if (typeof lwip !== 'undefined') {
-      pngSuite.add('lwip-buffer-buffer', {
-        defer: true,
-        fn: function (deferred) {
-          lwip.open(inputPngBuffer, 'png', function (err, image) {
-            if (err) {
-              throw err;
-            }
-            image.resize(width, height, 'lanczos', function (err, image) {
-              if (err) {
-                throw err;
-              }
-              image.toBuffer('png', function (err, buffer) {
-                if (err) {
-                  throw err;
-                }
-                assert.notStrictEqual(null, buffer);
-                deferred.resolve();
-              });
-            });
-          });
-        }
-      });
-    }
     // mapnik
     pngSuite.add('mapnik-file-file', {
       defer: true,
@@ -833,14 +745,6 @@ async.series({
           });
       }
     });
-    // images
-    if (typeof images !== 'undefined') {
-      pngSuite.add('images-file-file', function () {
-        images(fixtures.inputPng)
-          .resize(width, height)
-          .save(fixtures.outputPng);
-      });
-    }
     // sharp
     pngSuite.add('sharp-buffer-file', {
       defer: true,

test/fixtures/index.js

@@ -15,8 +15,7 @@ const fingerprint = function (image, callback) {
   sharp(image)
     .greyscale()
     .normalise()
-    .resize(9, 8)
-    .ignoreAspectRatio()
+    .resize(9, 8, { fit: sharp.fit.fill })
     .raw()
     .toBuffer(function (err, data) {
       if (err) {
@@ -71,6 +70,7 @@ module.exports = {
   inputJpgCenteredImage: getPath('centered_image.jpeg'),
   inputJpgRandom: getPath('random.jpg'), // convert -size 200x200 xc:   +noise Random   random.jpg
   inputJpgThRandom: getPath('thRandom.jpg'), // convert random.jpg  -channel G -threshold 5% -separate +channel -negate thRandom.jpg
+  inputJpgLossless: getPath('testimgl.jpg'), // Lossless JPEG from ftp://ftp.fu-berlin.de/unix/X11/graphics/ImageMagick/delegates/ljpeg-6b.tar.gz
 
   inputPng: getPath('50020484-00001.png'), // http://c.searspartsdirect.com/lis_png/PLDM/50020484-00001.png
   inputPngWithTransparency: getPath('blackbug.png'), // public domain
@@ -100,6 +100,7 @@ module.exports = {
   inputTiff8BitDepth: getPath('8bit_depth.tiff'),
   inputGif: getPath('Crash_test.gif'), // http://upload.wikimedia.org/wikipedia/commons/e/e3/Crash_test.gif
   inputGifGreyPlusAlpha: getPath('grey-plus-alpha.gif'), // http://i.imgur.com/gZ5jlmE.gif
+  inputGifAnimated: getPath('rotating-squares.gif'), // CC0 https://loading.io/spinner/blocks/-rotating-squares-preloader-gif
   inputSvg: getPath('check.svg'), // http://dev.w3.org/SVG/tools/svgweb/samples/svg-files/check.svg
   inputSvgWithEmbeddedImages: getPath('struct-image-04-t.svg'), // https://dev.w3.org/SVG/profiles/1.2T/test/svg/struct-image-04-t.svg
 

test/leak/leak.sh

@@ -5,7 +5,7 @@ if ! type valgrind >/dev/null; then
   exit 1
 fi
 
-curl -o ./test/leak/libvips.supp https://raw.githubusercontent.com/jcupitt/libvips/master/libvips.supp
+curl -s -o ./test/leak/libvips.supp https://raw.githubusercontent.com/libvips/libvips/master/libvips.supp
 
 for test in ./test/unit/*.js; do
   G_SLICE=always-malloc G_DEBUG=gc-friendly valgrind \
@@ -16,5 +16,5 @@ for test in ./test/unit/*.js; do
     --show-leak-kinds=definite,indirect,possible \
     --num-callers=20 \
     --trace-children=yes \
-    mocha --slow=60000 --timeout=120000 "$test";
+    node node_modules/.bin/mocha --slow=60000 --timeout=120000 --file test/unit/beforeEach.js "$test";
 done

test/leak/sharp.supp

@@ -147,6 +147,47 @@
   ...
   fun:WebPDecode
 }
+{
+  cond_libwebp_generic
+  Memcheck:Cond
+  obj:/usr/lib/x86_64-linux-gnu/libwebp.so.6.0.2
+}
+
+# tiff
+{
+  param_tiff_write_encoded_tile
+  Memcheck:Param
+  write(buf)
+  fun:write
+  ...
+  fun:TIFFWriteEncodedTile
+}
+
+# gsf
+{
+  param_gsf_output_write
+  Memcheck:Param
+  write(buf)
+  fun:write
+  ...
+  fun:gsf_output_write
+}
+{
+  value_gsf_output_write_crc32_little
+  Memcheck:Value8
+  fun:crc32_little
+  ...
+  fun:gsf_output_write
+}
+
+# fontconfig
+{
+  leak_fontconfig_FcConfigSubstituteWithPat
+  Memcheck:Leak
+  match-leak-kinds: definite,indirect
+  ...
+  fun:FcConfigSubstituteWithPat
+}
 
 # libvips
 {
@@ -197,6 +238,11 @@
   ...
   fun:vips_region_prepare_to
 }
+{
+  cond_libvips_vips_stats_scan
+  Memcheck:Cond
+  fun:vips_stats_scan
+}
 {
   value_libvips_vips_region_fill
   Memcheck:Value8
@@ -204,6 +250,17 @@
   fun:vips_region_fill
   fun:vips_region_prepare
 }
+{
+  value_libvips_vips_hist_find_uchar_scan
+  Memcheck:Value8
+  fun:vips_hist_find_uchar_scan
+}
+{
+  value_libvips_write_webp_image
+  Memcheck:Value8
+  ...
+  fun:write_webp_image
+}
 {
   leak_libvips_init
   Memcheck:Leak
@@ -233,7 +290,13 @@
   ...
   fun:uv__work_done
 }
-
+{
+  leak_libuv_FlushForegroundTasks
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN4node12NodePlatform28FlushForegroundTasksInternalEv
+}
 # nodejs warnings
 {
   param_nodejs_write_buffer
@@ -360,6 +423,81 @@
   ...
   fun:_ZN2v84base6Thread5StartEv
 }
+{
+  leak_nodejs_thread_TracingController
+  Memcheck:Leak
+  match-leak-kinds: possible
+  fun:calloc
+  fun:allocate_dtv
+  fun:_dl_allocate_tls
+  fun:allocate_stack
+  ...
+  fun:_ZN4node12NodePlatformC1EiPN2v817TracingControllerE
+}
+{
+  param_nodejs_delayed_task_scheduler
+  Memcheck:Param
+  epoll_ctl(event)
+  fun:epoll_ctl
+  fun:uv__io_poll
+  fun:uv_run
+  fun:_ZZN4node20BackgroundTaskRunner20DelayedTaskScheduler5StartEvENUlPvE_4_FUNES2_
+}
+{
+  param_nodejs_isolate_data
+  Memcheck:Param
+  epoll_ctl(event)
+  fun:epoll_ctl
+  fun:uv__io_poll
+  fun:uv_run
+  fun:_ZN4node5StartEPN2v87IsolateEPNS_11IsolateDataERKSt6vectorISsSaISsEES9_
+}
+{
+  param_nodejs_try_init_and_run_loop
+  Memcheck:Param
+  epoll_ctl(event)
+  fun:epoll_ctl
+  fun:uv__io_poll
+  fun:uv_run
+  fun:_ZN4node17SyncProcessRunner23TryInitializeAndRunLoopEN2v85LocalINS1_5ValueEEE
+}
+{
+  param_nodejs_run_exit_handlers
+  Memcheck:Param
+  epoll_ctl(event)
+  fun:epoll_ctl
+  fun:uv__io_poll
+  fun:uv_run
+  fun:_ZN4node7tracing5AgentD1Ev
+  fun:_ZN4node5._215D1Ev
+  fun:__run_exit_handlers
+}
+{
+  leak_nodejs_crypto_entropy_source
+  Memcheck:Leak
+  ...
+  fun:_ZN4node6crypto13EntropySourceEPhm
+}
+{
+  leak_nodejs_debug_options
+  Memcheck:Leak
+  ...
+  fun:_ZN4node9inspector5Agent5StartERKSsSt10shared_ptrINS_12DebugOptionsEEb
+}
+{
+  leak_nodejs_start
+  Memcheck:Leak
+  match-leak-kinds: definite
+  fun:_Znwm
+  fun:_ZN4node5StartEiPPc
+}
+{
+  leak_nodejs_start_background_task_runner
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN4node20BackgroundTaskRunnerC1Ei
+}
 {
   leak_nan_FunctionCallbackInfo
   Memcheck:Leak

test/saliency/report.js

@@ -7,7 +7,6 @@ const async = require('async');
 const sharp = require('../../');
 
 const crops = {
-  centre: sharp.gravity.centre,
   entropy: sharp.strategy.entropy,
   attention: sharp.strategy.attention
 };
@@ -34,23 +33,35 @@ async.eachLimit(files, concurrency, function (file, done) {
   const salientHeight = userData[file].bottom - userData[file].top;
   sharp(filename).metadata(function (err, metadata) {
     if (err) console.log(err);
+    const marginWidth = metadata.width - salientWidth;
+    const marginHeight = metadata.height - salientHeight;
     async.each(Object.keys(crops), function (crop, done) {
       async.parallel([
         // Left edge accuracy
         function (done) {
+          if (marginWidth) {
             sharp(filename).resize(salientWidth, metadata.height).crop(crops[crop]).toBuffer(function (err, data, info) {
-            const accuracy = Math.round(Math.abs(userData[file].left - info.cropCalcLeft) / (metadata.width - salientWidth) * 100);
+              const delta = Math.abs(userData[file].left + info.cropOffsetLeft);
+              const accuracy = Math.round(marginWidth / (marginWidth + delta) * 100);
               incrementScore(accuracy, crop);
               done(err);
             });
+          } else {
+            done();
+          }
         },
         // Top edge accuracy
         function (done) {
+          if (marginHeight) {
             sharp(filename).resize(metadata.width, salientHeight).crop(crops[crop]).toBuffer(function (err, data, info) {
-            const accuracy = Math.round(Math.abs(userData[file].top - info.cropCalcTop) / (metadata.height - salientHeight) * 100);
+              const delta = Math.abs(userData[file].top + info.cropOffsetTop);
+              const accuracy = Math.round(marginHeight / (marginHeight + delta) * 100);
               incrementScore(accuracy, crop);
               done(err);
             });
+          } else {
+            done();
+          }
         }
       ], done);
     }, done);
@@ -60,7 +71,7 @@ async.eachLimit(files, concurrency, function (file, done) {
   Object.keys(scores).forEach(function (accuracy) {
     report.push(
       Object.assign({
-        accuracy: parseInt(accuracy, 10)
+        accuracy: Number(accuracy)
       }, scores[accuracy])
     );
   });

test/saliency/userData.js

@@ -22,7 +22,7 @@ const median = function (values) {
 // List of files
 fs.readdirSync(userDataDir).forEach(function (file) {
   // Contents of file
-  const lines = fs.readFileSync(path.join(userDataDir, file), {encoding: 'utf-8'}).split(/\r\n/);
+  const lines = fs.readFileSync(path.join(userDataDir, file), { encoding: 'utf-8' }).split(/\r\n/);
   // First line = number of entries
   const entries = parseInt(lines[0], 10);
   // Verify number of entries

test/unit/alpha.js

@@ -19,9 +19,10 @@ describe('Alpha transparency', function () {
 
   it('Flatten to RGB orange', function (done) {
     sharp(fixtures.inputPngWithTransparency)
-      .flatten()
-      .background({r: 255, g: 102, b: 0})
       .resize(400, 300)
+      .flatten({
+        background: { r: 255, g: 102, b: 0 }
+      })
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(400, info.width);
@@ -32,9 +33,8 @@ describe('Alpha transparency', function () {
 
   it('Flatten to CSS/hex orange', function (done) {
     sharp(fixtures.inputPngWithTransparency)
-      .flatten()
-      .background('#ff6600')
       .resize(400, 300)
+      .flatten({ background: '#ff6600' })
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(400, info.width);
@@ -46,8 +46,9 @@ describe('Alpha transparency', function () {
   it('Flatten 16-bit PNG with transparency to orange', function (done) {
     const output = fixtures.path('output.flatten-rgb16-orange.jpg');
     sharp(fixtures.inputPngWithTransparency16bit)
-      .flatten()
-      .background({r: 255, g: 102, b: 0})
+      .flatten({
+        background: { r: 255, g: 102, b: 0 }
+      })
       .toFile(output, function (err, info) {
         if (err) throw err;
         assert.strictEqual(true, info.size > 0);
@@ -71,8 +72,7 @@ describe('Alpha transparency', function () {
 
   it('Ignored for JPEG', function (done) {
     sharp(fixtures.inputJpg)
-      .background('#ff0000')
-      .flatten()
+      .flatten({ background: '#ff0000' })
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);
@@ -81,35 +81,66 @@ describe('Alpha transparency', function () {
       });
   });
 
-  it('Enlargement with non-nearest neighbor interpolation shouldn’t cause dark edges', function (done) {
+  it('Enlargement with non-nearest neighbor interpolation shouldn’t cause dark edges', function () {
     const base = 'alpha-premultiply-enlargement-2048x1536-paper.png';
     const actual = fixtures.path('output.' + base);
     const expected = fixtures.expected(base);
-    sharp(fixtures.inputPngAlphaPremultiplicationSmall)
+    return sharp(fixtures.inputPngAlphaPremultiplicationSmall)
       .resize(2048, 1536)
-      .toFile(actual, function (err) {
-        if (err) {
-          done(err);
-        } else {
+      .toFile(actual)
+      .then(function () {
         fixtures.assertMaxColourDistance(actual, expected, 102);
-          done();
-        }
       });
   });
 
-  it('Reduction with non-nearest neighbor interpolation shouldn’t cause dark edges', function (done) {
+  it('Reduction with non-nearest neighbor interpolation shouldn’t cause dark edges', function () {
     const base = 'alpha-premultiply-reduction-1024x768-paper.png';
     const actual = fixtures.path('output.' + base);
     const expected = fixtures.expected(base);
-    sharp(fixtures.inputPngAlphaPremultiplicationLarge)
+    return sharp(fixtures.inputPngAlphaPremultiplicationLarge)
       .resize(1024, 768)
-      .toFile(actual, function (err) {
-        if (err) {
-          done(err);
-        } else {
+      .toFile(actual)
+      .then(function () {
         fixtures.assertMaxColourDistance(actual, expected, 102);
-          done();
-        }
       });
   });
+
+  it('Removes alpha from fixtures with transparency, ignores those without', function () {
+    return Promise.all([
+      fixtures.inputPngWithTransparency,
+      fixtures.inputPngWithTransparency16bit,
+      fixtures.inputWebPWithTransparency,
+      fixtures.inputJpg,
+      fixtures.inputPng,
+      fixtures.inputWebP
+    ].map(function (input) {
+      return sharp(input)
+        .resize(10)
+        .removeAlpha()
+        .toBuffer({ resolveWithObject: true })
+        .then(function (result) {
+          assert.strictEqual(3, result.info.channels);
+        });
+    }));
+  });
+
+  it('Ensures alpha from fixtures without transparency, ignores those with', function () {
+    return Promise.all([
+      fixtures.inputPngWithTransparency,
+      fixtures.inputPngWithTransparency16bit,
+      fixtures.inputWebPWithTransparency,
+      fixtures.inputJpg,
+      fixtures.inputPng,
+      fixtures.inputWebP
+    ].map(function (input) {
+      return sharp(input)
+        .resize(10)
+        .ensureAlpha()
+        .png()
+        .toBuffer({ resolveWithObject: true })
+        .then(function (result) {
+          assert.strictEqual(4, result.info.channels);
+        });
+    }));
+  });
 });

test/unit/beforeEach.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const detectLibc = require('detect-libc');
+const sharp = require('../../');
+
+const usingCache = detectLibc.family !== detectLibc.MUSL;
+const usingSimd = !process.env.G_DEBUG;
+
+beforeEach(function () {
+  sharp.cache(usingCache);
+  sharp.simd(usingSimd);
+});

test/unit/cache.js

@@ -1,9 +0,0 @@
-'use strict';
-
-const sharp = require('../../');
-
-// Define SHARP_TEST_WITHOUT_CACHE environment variable to prevent use of libvips' cache
-
-beforeEach(function () {
-  sharp.cache(!process.env.SHARP_TEST_WITHOUT_CACHE);
-});

test/unit/colourspace.js

@@ -69,9 +69,10 @@ describe('Colour space conversion', function () {
 
   it('From CMYK to sRGB with white background, not yellow', function (done) {
     sharp(fixtures.inputJpgWithCmykProfile)
-      .resize(320, 240)
-      .background('white')
-      .embed()
+      .resize(320, 240, {
+        fit: sharp.fit.contain,
+        background: 'white'
+      })
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);

test/unit/composite.js

@@ -0,0 +1,298 @@
+'use strict';
+
+const assert = require('assert');
+
+const fixtures = require('../fixtures');
+const sharp = require('../../');
+
+const red = { r: 255, g: 0, b: 0, alpha: 0.5 };
+const green = { r: 0, g: 255, b: 0, alpha: 0.5 };
+const blue = { r: 0, g: 0, b: 255, alpha: 0.5 };
+
+const redRect = {
+  create: {
+    width: 80,
+    height: 60,
+    channels: 4,
+    background: red
+  }
+};
+
+const greenRect = {
+  create: {
+    width: 40,
+    height: 40,
+    channels: 4,
+    background: green
+  }
+};
+
+const blueRect = {
+  create: {
+    width: 60,
+    height: 40,
+    channels: 4,
+    background: blue
+  }
+};
+
+const blends = [
+  'over',
+  'xor',
+  'saturate',
+  'dest-over'
+];
+
+// Test
+describe('composite', () => {
+  it('blend', () => Promise.all(
+    blends.map(blend => {
+      const filename = `composite.blend.${blend}.png`;
+      const actual = fixtures.path(`output.${filename}`);
+      const expected = fixtures.expected(filename);
+      return sharp(redRect)
+        .composite([{
+          input: blueRect,
+          blend
+        }])
+        .toFile(actual)
+        .then(() => {
+          fixtures.assertMaxColourDistance(actual, expected);
+        });
+    })
+  ));
+
+  it('multiple', () => {
+    const filename = 'composite-multiple.png';
+    const actual = fixtures.path(`output.${filename}`);
+    const expected = fixtures.expected(filename);
+    return sharp(redRect)
+      .composite([{
+        input: blueRect,
+        gravity: 'northeast'
+      }, {
+        input: greenRect,
+        gravity: 'southwest'
+      }])
+      .toFile(actual)
+      .then(() => {
+        fixtures.assertMaxColourDistance(actual, expected);
+      });
+  });
+
+  it('zero offset', done => {
+    sharp(fixtures.inputJpg)
+      .resize(400)
+      .composite([{
+        input: fixtures.inputPngWithTransparency16bit,
+        top: 0,
+        left: 0
+      }])
+      .toBuffer((err, data, info) => {
+        if (err) throw err;
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(3, info.channels);
+        fixtures.assertSimilar(fixtures.expected('overlay-offset-0.jpg'), data, done);
+      });
+  });
+
+  it('offset and gravity', done => {
+    sharp(fixtures.inputJpg)
+      .resize(400)
+      .composite([{
+        input: fixtures.inputPngWithTransparency16bit,
+        left: 10,
+        top: 10,
+        gravity: 4
+      }])
+      .toBuffer((err, data, info) => {
+        if (err) throw err;
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(3, info.channels);
+        fixtures.assertSimilar(fixtures.expected('overlay-offset-with-gravity.jpg'), data, done);
+      });
+  });
+
+  it('offset, gravity and tile', done => {
+    sharp(fixtures.inputJpg)
+      .resize(400)
+      .composite([{
+        input: fixtures.inputPngWithTransparency16bit,
+        left: 10,
+        top: 10,
+        gravity: 4,
+        tile: true
+      }])
+      .toBuffer((err, data, info) => {
+        if (err) throw err;
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(3, info.channels);
+        fixtures.assertSimilar(fixtures.expected('overlay-offset-with-gravity-tile.jpg'), data, done);
+      });
+  });
+
+  it('offset and tile', done => {
+    sharp(fixtures.inputJpg)
+      .resize(400)
+      .composite([{
+        input: fixtures.inputPngWithTransparency16bit,
+        left: 10,
+        top: 10,
+        tile: true
+      }])
+      .toBuffer((err, data, info) => {
+        if (err) throw err;
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(3, info.channels);
+        fixtures.assertSimilar(fixtures.expected('overlay-offset-with-tile.jpg'), data, done);
+      });
+  });
+
+  it('cutout via dest-in', done => {
+    sharp(fixtures.inputJpg)
+      .resize(300, 300)
+      .composite([{
+        input: Buffer.from('<svg><rect x="0" y="0" width="200" height="200" rx="50" ry="50"/></svg>'),
+        density: 96,
+        blend: 'dest-in',
+        cutout: true
+      }])
+      .png()
+      .toBuffer((err, data, info) => {
+        if (err) throw err;
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(300, info.width);
+        assert.strictEqual(300, info.height);
+        assert.strictEqual(4, info.channels);
+        fixtures.assertSimilar(fixtures.expected('composite-cutout.png'), data, done);
+      });
+  });
+
+  describe('numeric gravity', () => {
+    Object.keys(sharp.gravity).forEach(gravity => {
+      it(gravity, done => {
+        sharp(fixtures.inputJpg)
+          .resize(80)
+          .composite([{
+            input: fixtures.inputPngWithTransparency16bit,
+            gravity: gravity
+          }])
+          .toBuffer((err, data, info) => {
+            if (err) throw err;
+            assert.strictEqual('jpeg', info.format);
+            assert.strictEqual(80, info.width);
+            assert.strictEqual(65, info.height);
+            assert.strictEqual(3, info.channels);
+            fixtures.assertSimilar(fixtures.expected(`overlay-gravity-${gravity}.jpg`), data, done);
+          });
+      });
+    });
+  });
+
+  describe('string gravity', () => {
+    Object.keys(sharp.gravity).forEach(gravity => {
+      it(gravity, done => {
+        const expected = fixtures.expected('overlay-gravity-' + gravity + '.jpg');
+        sharp(fixtures.inputJpg)
+          .resize(80)
+          .composite([{
+            input: fixtures.inputPngWithTransparency16bit,
+            gravity: sharp.gravity[gravity]
+          }])
+          .toBuffer((err, data, info) => {
+            if (err) throw err;
+            assert.strictEqual('jpeg', info.format);
+            assert.strictEqual(80, info.width);
+            assert.strictEqual(65, info.height);
+            assert.strictEqual(3, info.channels);
+            fixtures.assertSimilar(expected, data, done);
+          });
+      });
+    });
+  });
+
+  describe('tile and gravity', () => {
+    Object.keys(sharp.gravity).forEach(gravity => {
+      it(gravity, done => {
+        const expected = fixtures.expected('overlay-tile-gravity-' + gravity + '.jpg');
+        sharp(fixtures.inputJpg)
+          .resize(80)
+          .composite([{
+            input: fixtures.inputPngWithTransparency16bit,
+            tile: true,
+            gravity: gravity
+          }])
+          .toBuffer((err, data, info) => {
+            if (err) throw err;
+            assert.strictEqual('jpeg', info.format);
+            assert.strictEqual(80, info.width);
+            assert.strictEqual(65, info.height);
+            assert.strictEqual(3, info.channels);
+            fixtures.assertSimilar(expected, data, done);
+          });
+      });
+    });
+  });
+
+  describe('validation', () => {
+    it('missing images', () => {
+      assert.throws(() => {
+        sharp().composite();
+      }, /Expected array for images to composite but received undefined of type undefined/);
+    });
+
+    it('invalid images', () => {
+      assert.throws(() => {
+        sharp().composite(['invalid']);
+      }, /Expected object for image to composite but received invalid of type string/);
+    });
+
+    it('missing input', () => {
+      assert.throws(() => {
+        sharp().composite([{}]);
+      }, /Unsupported input/);
+    });
+
+    it('invalid blend', () => {
+      assert.throws(() => {
+        sharp().composite([{ input: 'test', blend: 'invalid' }]);
+      }, /Expected valid blend name for blend but received invalid of type string/);
+    });
+
+    it('invalid tile', () => {
+      assert.throws(() => {
+        sharp().composite([{ input: 'test', tile: 'invalid' }]);
+      }, /Expected boolean for tile but received invalid of type string/);
+    });
+
+    it('invalid left', () => {
+      assert.throws(() => {
+        sharp().composite([{ input: 'test', left: 0.5 }]);
+      }, /Expected positive integer for left but received 0.5 of type number/);
+    });
+
+    it('invalid top', () => {
+      assert.throws(() => {
+        sharp().composite([{ input: 'test', top: -1 }]);
+      }, /Expected positive integer for top but received -1 of type number/);
+    });
+
+    it('left but no top', () => {
+      assert.throws(() => {
+        sharp().composite([{ input: 'test', left: 1 }]);
+      }, /Expected both left and top to be set/);
+    });
+
+    it('top but no left', () => {
+      assert.throws(() => {
+        sharp().composite([{ input: 'test', top: 1 }]);
+      }, /Expected both left and top to be set/);
+    });
+
+    it('invalid gravity', () => {
+      assert.throws(() => {
+        sharp().composite([{ input: 'test', gravity: 'invalid' }]);
+      }, /Expected valid gravity for gravity but received invalid of type string/);
+    });
+  });
+});

test/unit/embed.js

@@ -1,457 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-const sharp = require('../../');
-const fixtures = require('../fixtures');
-
-describe('Embed', function () {
-  it('Allows specifying the gravity as a string', function (done) {
-    sharp(fixtures.inputJpg)
-      .resize(320, 240)
-      .embed('center')
-      .png()
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(320, info.width);
-        assert.strictEqual(240, info.height);
-        fixtures.assertSimilar(fixtures.expected('embed-3-into-3.png'), data, done);
-      });
-  });
-
-  it('JPEG within PNG, no alpha channel', function (done) {
-    sharp(fixtures.inputJpg)
-      .embed()
-      .resize(320, 240)
-      .png()
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(320, info.width);
-        assert.strictEqual(240, info.height);
-        assert.strictEqual(3, info.channels);
-        fixtures.assertSimilar(fixtures.expected('embed-3-into-3.png'), data, done);
-      });
-  });
-
-  it('JPEG within WebP, to include alpha channel', function (done) {
-    sharp(fixtures.inputJpg)
-      .resize(320, 240)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed()
-      .webp()
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('webp', info.format);
-        assert.strictEqual(320, info.width);
-        assert.strictEqual(240, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('embed-3-into-4.webp'), data, done);
-      });
-  });
-
-  it('PNG with alpha channel', function (done) {
-    sharp(fixtures.inputPngWithTransparency)
-      .resize(50, 50)
-      .embed()
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(50, info.width);
-        assert.strictEqual(50, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('embed-4-into-4.png'), data, done);
-      });
-  });
-
-  it('16-bit PNG with alpha channel', function (done) {
-    sharp(fixtures.inputPngWithTransparency16bit)
-      .resize(32, 16)
-      .embed()
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(32, info.width);
-        assert.strictEqual(16, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('embed-16bit.png'), data, done);
-      });
-  });
-
-  it('16-bit PNG with alpha channel onto RGBA', function (done) {
-    sharp(fixtures.inputPngWithTransparency16bit)
-      .resize(32, 16)
-      .embed()
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(32, info.width);
-        assert.strictEqual(16, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('embed-16bit-rgba.png'), data, done);
-      });
-  });
-
-  it('PNG with 2 channels', function (done) {
-    sharp(fixtures.inputPngWithGreyAlpha)
-      .resize(32, 16)
-      .embed()
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(32, info.width);
-        assert.strictEqual(16, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('embed-2channel.png'), data, done);
-      });
-  });
-
-  it.skip('embed TIFF in LAB colourspace onto RGBA background', function (done) {
-    sharp(fixtures.inputTiffCielab)
-      .resize(64, 128)
-      .embed()
-      .background({r: 255, g: 102, b: 0, alpha: 0.5})
-      .png()
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(64, info.width);
-        assert.strictEqual(128, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('embed-lab-into-rgba.png'), data, done);
-      });
-  });
-
-  it('Enlarge and embed', function (done) {
-    sharp(fixtures.inputPngWithOneColor)
-      .embed()
-      .resize(320, 240)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(320, info.width);
-        assert.strictEqual(240, info.height);
-        assert.strictEqual(3, info.channels);
-        fixtures.assertSimilar(fixtures.expected('embed-enlarge.png'), data, done);
-      });
-  });
-
-  it('Embed invalid param values should fail', function () {
-    assert.throws(function () {
-      sharp().embed(-1);
-    });
-    assert.throws(function () {
-      sharp().embed(8.1);
-    });
-    assert.throws(function () {
-      sharp().embed(9);
-    });
-    assert.throws(function () {
-      sharp().embed(1000000);
-    });
-    assert.throws(function () {
-      sharp().embed(false);
-    });
-    assert.throws(function () {
-      sharp().embed('vallejo');
-    });
-  });
-
-  it('Embed gravity horizontal northwest', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 100)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.northwest)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(100, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/a1-nw.png'), data, done);
-      });
-  });
-
-  it('Embed gravity horizontal north', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 100)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.north)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(100, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/a2-n.png'), data, done);
-      });
-  });
-
-  it('Embed gravity horizontal northeast', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 100)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.northeast)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(100, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/a3-ne.png'), data, done);
-      });
-  });
-
-  it('Embed gravity horizontal east', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 100)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.east)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(100, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/a4-e.png'), data, done);
-      });
-  });
-
-  it('Embed gravity horizontal southeast', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 100)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.southeast)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(100, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/a5-se.png'), data, done);
-      });
-  });
-
-  it('Embed gravity horizontal south', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 100)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.south)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(100, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/a6-s.png'), data, done);
-      });
-  });
-
-  it('Embed gravity horizontal southwest', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 100)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.southwest)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(100, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/a7-sw.png'), data, done);
-      });
-  });
-
-  it('Embed gravity horizontal west', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 100)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.west)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(100, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/a8-w.png'), data, done);
-      });
-  });
-
-  it('Embed gravity horizontal center', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 100)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.center)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(100, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/a9-c.png'), data, done);
-      });
-  });
-
-  it('Embed gravity vertical northwest', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 200)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.northwest)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(200, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/1-nw.png'), data, done);
-      });
-  });
-
-  it('Embed gravity vertical north', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 200)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.north)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(200, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/2-n.png'), data, done);
-      });
-  });
-
-  it('Embed gravity vertical northeast', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 200)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.northeast)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(200, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/3-ne.png'), data, done);
-      });
-  });
-
-  it('Embed gravity vertical east', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 200)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.east)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(200, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/4-e.png'), data, done);
-      });
-  });
-
-  it('Embed gravity vertical southeast', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 200)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.southeast)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(200, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/5-se.png'), data, done);
-      });
-  });
-
-  it('Embed gravity vertical south', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 200)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.south)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(200, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/6-s.png'), data, done);
-      });
-  });
-
-  it('Embed gravity vertical southwest', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 200)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.southwest)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(200, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/7-sw.png'), data, done);
-      });
-  });
-
-  it('Embed gravity vertical west', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 200)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.west)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(200, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/8-w.png'), data, done);
-      });
-  });
-
-  it('Embed gravity vertical center', function (done) {
-    sharp(fixtures.inputPngEmbed)
-      .resize(200, 200)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .embed(sharp.gravity.center)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual('png', info.format);
-        assert.strictEqual(200, info.width);
-        assert.strictEqual(200, info.height);
-        assert.strictEqual(4, info.channels);
-        fixtures.assertSimilar(fixtures.expected('./embedgravitybird/9-c.png'), data, done);
-      });
-  });
-});

test/unit/extend.js

@@ -9,8 +9,13 @@ describe('Extend', function () {
   it('extend all sides equally with RGB', function (done) {
     sharp(fixtures.inputJpg)
       .resize(120)
-      .background({r: 255, g: 0, b: 0})
-      .extend(10)
+      .extend({
+        top: 10,
+        bottom: 10,
+        left: 10,
+        right: 10,
+        background: { r: 255, g: 0, b: 0 }
+      })
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(140, info.width);
@@ -22,8 +27,13 @@ describe('Extend', function () {
   it('extend sides unequally with RGBA', function (done) {
     sharp(fixtures.inputPngWithTransparency16bit)
       .resize(120)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
-      .extend({top: 50, bottom: 0, left: 10, right: 35})
+      .extend({
+        top: 50,
+        bottom: 0,
+        left: 10,
+        right: 35,
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      })
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(165, info.width);
@@ -44,15 +54,20 @@ describe('Extend', function () {
   });
   it('partial object fails', function () {
     assert.throws(function () {
-      sharp().extend({top: 1});
+      sharp().extend({ top: 1 });
     });
   });
 
   it('should add alpha channel before extending with a transparent Background', function (done) {
     sharp(fixtures.inputJpgWithLandscapeExif1)
-      .background({r: 0, g: 0, b: 0, alpha: 0})
+      .extend({
+        top: 0,
+        bottom: 10,
+        left: 0,
+        right: 10,
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      })
       .toFormat(sharp.format.png)
-      .extend({top: 0, bottom: 10, left: 0, right: 10})
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(610, info.width);
@@ -63,8 +78,13 @@ describe('Extend', function () {
 
   it('PNG with 2 channels', function (done) {
     sharp(fixtures.inputPngWithGreyAlpha)
-      .background('transparent')
-      .extend({top: 0, bottom: 20, left: 0, right: 20})
+      .extend({
+        top: 0,
+        bottom: 20,
+        left: 0,
+        right: 20,
+        background: 'transparent'
+      })
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);

test/unit/extract.js

@@ -69,8 +69,9 @@ describe('Partial image extraction', function () {
 
   it('After resize and crop', function (done) {
     sharp(fixtures.inputJpg)
-      .resize(500, 500)
-      .crop(sharp.gravity.north)
+      .resize(500, 500, {
+        position: sharp.gravity.north
+      })
       .extract({ left: 10, top: 10, width: 100, height: 100 })
       .toBuffer(function (err, data, info) {
         if (err) throw err;
@@ -83,8 +84,9 @@ describe('Partial image extraction', function () {
   it('Before and after resize and crop', function (done) {
     sharp(fixtures.inputJpg)
       .extract({ left: 0, top: 0, width: 700, height: 700 })
-      .resize(500, 500)
-      .crop(sharp.gravity.north)
+      .resize(500, 500, {
+        position: sharp.gravity.north
+      })
       .extract({ left: 10, top: 10, width: 100, height: 100 })
       .toBuffer(function (err, data, info) {
         if (err) throw err;
@@ -115,7 +117,7 @@ describe('Partial image extraction', function () {
         if (err) throw err;
         assert.strictEqual(280, info.width);
         assert.strictEqual(380, info.height);
-        fixtures.assertSimilar(fixtures.expected('rotate-extract.jpg'), data, { threshold: 6 }, done);
+        fixtures.assertSimilar(fixtures.expected('rotate-extract.jpg'), data, { threshold: 7 }, done);
       });
   });
 

test/unit/extractChannel.js

@@ -54,6 +54,32 @@ describe('Image channel extraction', function () {
       });
   });
 
+  it('With colorspace conversion', function (done) {
+    const output = fixtures.path('output.extract-lch.jpg');
+    sharp(fixtures.inputJpg)
+      .toColourspace('lch')
+      .extractChannel(1)
+      .resize(320, 240, { fastShrinkOnLoad: false })
+      .toFile(output, function (err, info) {
+        if (err) throw err;
+        assert.strictEqual(320, info.width);
+        assert.strictEqual(240, info.height);
+        fixtures.assertMaxColourDistance(output, fixtures.expected('extract-lch.jpg'), 9);
+        done();
+      });
+  });
+
+  it('Alpha from 16-bit PNG', function (done) {
+    const output = fixtures.path('output.extract-alpha-16bit.jpg');
+    sharp(fixtures.inputPngWithTransparency16bit)
+      .extractChannel(3)
+      .toFile(output, function (err, info) {
+        if (err) throw err;
+        fixtures.assertMaxColourDistance(output, fixtures.expected('extract-alpha-16bit.jpg'));
+        done();
+      });
+  });
+
   it('Invalid channel number', function () {
     assert.throws(function () {
       sharp(fixtures.inputJpg)

test/unit/failOnError.js

@@ -6,10 +6,9 @@ const sharp = require('../../');
 const fixtures = require('../fixtures');
 
 describe('failOnError', function () {
-  it('handles truncated JPEG by default', function (done) {
-    sharp(fixtures.inputJpgTruncated)
+  it('handles truncated JPEG', function (done) {
+    sharp(fixtures.inputJpgTruncated, { failOnError: false })
       .resize(320, 240)
-      // .toFile(fixtures.expected('truncated.jpg'), done);
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);
@@ -19,10 +18,9 @@ describe('failOnError', function () {
       });
   });
 
-  it('handles truncated PNG by default', function (done) {
-    sharp(fixtures.inputPngTruncated)
+  it('handles truncated PNG', function (done) {
+    sharp(fixtures.inputPngTruncated, { failOnError: false })
       .resize(320, 240)
-      // .toFile(fixtures.expected('truncated.png'), done);
       .toBuffer(function (err, data, info) {
         if (err) throw err;
         assert.strictEqual('png', info.format);
@@ -46,26 +44,26 @@ describe('failOnError', function () {
     });
   });
 
-  it('returns errors to callback for truncated JPEG when failOnError is set', function (done) {
-    sharp(fixtures.inputJpgTruncated, { failOnError: true }).toBuffer(function (err, data, info) {
+  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.equal(data, null);
-      assert.equal(info, null);
+      assert.strictEqual(data, null);
+      assert.strictEqual(info, null);
       done();
     });
   });
 
-  it('returns errors to callback for truncated PNG when failOnError is set', function (done) {
-    sharp(fixtures.inputPngTruncated, { failOnError: true }).toBuffer(function (err, data, info) {
+  it('returns errors to callback for truncated PNG', function (done) {
+    sharp(fixtures.inputPngTruncated).toBuffer(function (err, data, info) {
       assert.ok(err.message.includes('vipspng: libpng read error'), err);
-      assert.equal(data, null);
-      assert.equal(info, null);
+      assert.strictEqual(data, null);
+      assert.strictEqual(info, null);
       done();
     });
   });
 
-  it('rejects promises for truncated JPEG when failOnError is set', function (done) {
-    sharp(fixtures.inputJpgTruncated, { failOnError: true })
+  it('rejects promises for truncated JPEG', function (done) {
+    sharp(fixtures.inputJpgTruncated)
       .toBuffer()
       .then(() => {
         throw new Error('Expected rejection');

test/unit/gamma.js

@@ -44,6 +44,19 @@ describe('Gamma correction', function () {
       });
   });
 
+  it('input value of 2.2, output value of 3.0', function (done) {
+    sharp(fixtures.inputJpgWithGammaHoliness)
+      .resize(129, 111)
+      .gamma(2.2, 3.0)
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(129, info.width);
+        assert.strictEqual(111, info.height);
+        fixtures.assertSimilar(fixtures.expected('gamma-in-2.2-out-3.0.jpg'), data, { threshold: 6 }, done);
+      });
+  });
+
   it('alpha transparency', function (done) {
     sharp(fixtures.inputPngOverlayLayer1)
       .resize(320)
@@ -57,9 +70,15 @@ describe('Gamma correction', function () {
       });
   });
 
-  it('invalid value', function () {
+  it('invalid first parameter value', function () {
     assert.throws(function () {
       sharp(fixtures.inputJpgWithGammaHoliness).gamma(4);
     });
   });
+
+  it('invalid second parameter value', function () {
+    assert.throws(function () {
+      sharp(fixtures.inputJpgWithGammaHoliness).gamma(2.2, 4);
+    });
+  });
 });

test/unit/gif.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const fs = require('fs');
+const assert = require('assert');
+
+const sharp = require('../../');
+const fixtures = require('../fixtures');
+
+describe('GIF input', () => {
+  it('GIF Buffer to JPEG Buffer', () =>
+    sharp(fs.readFileSync(fixtures.inputGif))
+      .resize(8, 4)
+      .jpeg()
+      .toBuffer({ resolveWithObject: true })
+      .then(({ data, info }) => {
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(data.length, info.size);
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(8, info.width);
+        assert.strictEqual(4, info.height);
+      })
+  );
+
+  it('2 channel GIF file to PNG Buffer', () =>
+    sharp(fixtures.inputGifGreyPlusAlpha)
+      .resize(8, 4)
+      .png()
+      .toBuffer({ resolveWithObject: true })
+      .then(({ data, info }) => {
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(data.length, info.size);
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(8, info.width);
+        assert.strictEqual(4, info.height);
+        assert.strictEqual(4, info.channels);
+      })
+  );
+
+  it('Animated GIF first page to PNG', () =>
+    sharp(fixtures.inputGifAnimated)
+      .toBuffer({ resolveWithObject: true })
+      .then(({ data, info }) => {
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(data.length, info.size);
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(80, info.width);
+        assert.strictEqual(80, info.height);
+        assert.strictEqual(4, info.channels);
+      })
+  );
+
+  it('Animated GIF all pages to PNG "toilet roll"', () =>
+    sharp(fixtures.inputGifAnimated, { pages: -1 })
+      .toBuffer({ resolveWithObject: true })
+      .then(({ data, info }) => {
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(data.length, info.size);
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(80, info.width);
+        assert.strictEqual(2400, info.height);
+        assert.strictEqual(4, info.channels);
+      })
+  );
+});

test/unit/joinChannel.js

@@ -138,7 +138,7 @@ describe('Image channel insertion', function () {
 
   it('Invalid raw buffer description', function () {
     assert.throws(function () {
-      sharp().joinChannel(fs.readFileSync(fixtures.inputPng), {raw: {}});
+      sharp().joinChannel(fs.readFileSync(fixtures.inputPng), { raw: {} });
     });
   });
 

test/unit/jpeg.js

@@ -0,0 +1,262 @@
+'use strict';
+
+const assert = require('assert');
+
+const sharp = require('../../');
+const fixtures = require('../fixtures');
+
+describe('JPEG', function () {
+  it('JPEG quality', function (done) {
+    sharp(fixtures.inputJpg)
+      .resize(320, 240)
+      .jpeg({ quality: 70 })
+      .toBuffer(function (err, buffer70) {
+        if (err) throw err;
+        sharp(fixtures.inputJpg)
+          .resize(320, 240)
+          .toBuffer(function (err, buffer80) {
+            if (err) throw err;
+            sharp(fixtures.inputJpg)
+              .resize(320, 240)
+              .jpeg({ quality: 90 })
+              .toBuffer(function (err, buffer90) {
+                if (err) throw err;
+                assert(buffer70.length < buffer80.length);
+                assert(buffer80.length < buffer90.length);
+                done();
+              });
+          });
+      });
+  });
+
+  describe('Invalid JPEG quality', function () {
+    [-1, 88.2, 'test'].forEach(function (quality) {
+      it(quality.toString(), function () {
+        assert.throws(function () {
+          sharp().jpeg({ quality: quality });
+        });
+      });
+    });
+  });
+
+  describe('Invalid JPEG quantisation table', function () {
+    [-1, 88.2, 'test'].forEach(function (table) {
+      it(table.toString(), function () {
+        assert.throws(function () {
+          sharp().jpeg({ quantisationTable: table });
+        });
+      });
+    });
+  });
+
+  it('Progressive JPEG image', function (done) {
+    sharp(fixtures.inputJpg)
+      .resize(320, 240)
+      .jpeg({ progressive: false })
+      .toBuffer(function (err, nonProgressiveData, nonProgressiveInfo) {
+        if (err) throw err;
+        assert.strictEqual(true, nonProgressiveData.length > 0);
+        assert.strictEqual(nonProgressiveData.length, nonProgressiveInfo.size);
+        assert.strictEqual('jpeg', nonProgressiveInfo.format);
+        assert.strictEqual(320, nonProgressiveInfo.width);
+        assert.strictEqual(240, nonProgressiveInfo.height);
+        sharp(fixtures.inputJpg)
+          .resize(320, 240)
+          .jpeg({ progressive: true })
+          .toBuffer(function (err, progressiveData, progressiveInfo) {
+            if (err) throw err;
+            assert.strictEqual(true, progressiveData.length > 0);
+            assert.strictEqual(progressiveData.length, progressiveInfo.size);
+            assert.strictEqual(false, progressiveData.length === nonProgressiveData.length);
+            assert.strictEqual('jpeg', progressiveInfo.format);
+            assert.strictEqual(320, progressiveInfo.width);
+            assert.strictEqual(240, progressiveInfo.height);
+            done();
+          });
+      });
+  });
+
+  it('Without chroma subsampling generates larger file', function (done) {
+    // First generate with chroma subsampling (default)
+    sharp(fixtures.inputJpg)
+      .resize(320, 240)
+      .jpeg({ chromaSubsampling: '4:2:0' })
+      .toBuffer(function (err, withChromaSubsamplingData, withChromaSubsamplingInfo) {
+        if (err) throw err;
+        assert.strictEqual(true, withChromaSubsamplingData.length > 0);
+        assert.strictEqual(withChromaSubsamplingData.length, withChromaSubsamplingInfo.size);
+        assert.strictEqual('jpeg', withChromaSubsamplingInfo.format);
+        assert.strictEqual(320, withChromaSubsamplingInfo.width);
+        assert.strictEqual(240, withChromaSubsamplingInfo.height);
+        // Then generate without
+        sharp(fixtures.inputJpg)
+          .resize(320, 240)
+          .jpeg({ chromaSubsampling: '4:4:4' })
+          .toBuffer(function (err, withoutChromaSubsamplingData, withoutChromaSubsamplingInfo) {
+            if (err) throw err;
+            assert.strictEqual(true, withoutChromaSubsamplingData.length > 0);
+            assert.strictEqual(withoutChromaSubsamplingData.length, withoutChromaSubsamplingInfo.size);
+            assert.strictEqual('jpeg', withoutChromaSubsamplingInfo.format);
+            assert.strictEqual(320, withoutChromaSubsamplingInfo.width);
+            assert.strictEqual(240, withoutChromaSubsamplingInfo.height);
+            assert.strictEqual(true, withChromaSubsamplingData.length < withoutChromaSubsamplingData.length);
+            done();
+          });
+      });
+  });
+
+  it('Invalid JPEG chromaSubsampling value throws error', function () {
+    assert.throws(function () {
+      sharp().jpeg({ chromaSubsampling: '4:2:2' });
+    });
+  });
+
+  it('Trellis quantisation', function (done) {
+    // First generate without
+    sharp(fixtures.inputJpg)
+      .resize(320, 240)
+      .jpeg({ trellisQuantisation: false })
+      .toBuffer(function (err, withoutData, withoutInfo) {
+        if (err) throw err;
+        assert.strictEqual(true, withoutData.length > 0);
+        assert.strictEqual(withoutData.length, withoutInfo.size);
+        assert.strictEqual('jpeg', withoutInfo.format);
+        assert.strictEqual(320, withoutInfo.width);
+        assert.strictEqual(240, withoutInfo.height);
+        // Then generate with
+        sharp(fixtures.inputJpg)
+          .resize(320, 240)
+          .jpeg({ trellisQuantization: true })
+          .toBuffer(function (err, withData, withInfo) {
+            if (err) throw err;
+            assert.strictEqual(true, withData.length > 0);
+            assert.strictEqual(withData.length, withInfo.size);
+            assert.strictEqual('jpeg', withInfo.format);
+            assert.strictEqual(320, withInfo.width);
+            assert.strictEqual(240, withInfo.height);
+            // Verify image is same (as mozjpeg may not be present) size or less
+            assert.strictEqual(true, withData.length <= withoutData.length);
+            done();
+          });
+      });
+  });
+
+  it('Overshoot deringing', function (done) {
+    // First generate without
+    sharp(fixtures.inputJpg)
+      .resize(320, 240)
+      .jpeg({ overshootDeringing: false })
+      .toBuffer(function (err, withoutData, withoutInfo) {
+        if (err) throw err;
+        assert.strictEqual(true, withoutData.length > 0);
+        assert.strictEqual(withoutData.length, withoutInfo.size);
+        assert.strictEqual('jpeg', withoutInfo.format);
+        assert.strictEqual(320, withoutInfo.width);
+        assert.strictEqual(240, withoutInfo.height);
+        // Then generate with
+        sharp(fixtures.inputJpg)
+          .resize(320, 240)
+          .jpeg({ overshootDeringing: true })
+          .toBuffer(function (err, withData, withInfo) {
+            if (err) throw err;
+            assert.strictEqual(true, withData.length > 0);
+            assert.strictEqual(withData.length, withInfo.size);
+            assert.strictEqual('jpeg', withInfo.format);
+            assert.strictEqual(320, withInfo.width);
+            assert.strictEqual(240, withInfo.height);
+            done();
+          });
+      });
+  });
+
+  it('Optimise scans generates different output length', function (done) {
+    // First generate without
+    sharp(fixtures.inputJpg)
+      .resize(320, 240)
+      .jpeg({ optimiseScans: false })
+      .toBuffer(function (err, withoutData, withoutInfo) {
+        if (err) throw err;
+        assert.strictEqual(true, withoutData.length > 0);
+        assert.strictEqual(withoutData.length, withoutInfo.size);
+        assert.strictEqual('jpeg', withoutInfo.format);
+        assert.strictEqual(320, withoutInfo.width);
+        assert.strictEqual(240, withoutInfo.height);
+        // Then generate with
+        sharp(fixtures.inputJpg)
+          .resize(320, 240)
+          .jpeg({ optimizeScans: true })
+          .toBuffer(function (err, withData, withInfo) {
+            if (err) throw err;
+            assert.strictEqual(true, withData.length > 0);
+            assert.strictEqual(withData.length, withInfo.size);
+            assert.strictEqual('jpeg', withInfo.format);
+            assert.strictEqual(320, withInfo.width);
+            assert.strictEqual(240, withInfo.height);
+            // Verify image is of a different size (progressive output even without mozjpeg)
+            assert.notStrictEqual(withData.length, withoutData.length);
+            done();
+          });
+      });
+  });
+
+  it('Optimise coding generates smaller output length', function (done) {
+    // First generate with optimize coding enabled (default)
+    sharp(fixtures.inputJpg)
+      .resize(320, 240)
+      .jpeg()
+      .toBuffer(function (err, withOptimiseCoding, withInfo) {
+        if (err) throw err;
+        assert.strictEqual(true, withOptimiseCoding.length > 0);
+        assert.strictEqual(withOptimiseCoding.length, withInfo.size);
+        assert.strictEqual('jpeg', withInfo.format);
+        assert.strictEqual(320, withInfo.width);
+        assert.strictEqual(240, withInfo.height);
+        // Then generate with coding disabled
+        sharp(fixtures.inputJpg)
+          .resize(320, 240)
+          .jpeg({ optimizeCoding: false })
+          .toBuffer(function (err, withoutOptimiseCoding, withoutInfo) {
+            if (err) throw err;
+            assert.strictEqual(true, withoutOptimiseCoding.length > 0);
+            assert.strictEqual(withoutOptimiseCoding.length, withoutInfo.size);
+            assert.strictEqual('jpeg', withoutInfo.format);
+            assert.strictEqual(320, withoutInfo.width);
+            assert.strictEqual(240, withoutInfo.height);
+            // Verify optimised image is of a smaller size
+            assert.strictEqual(true, withOptimiseCoding.length < withoutOptimiseCoding.length);
+            done();
+          });
+      });
+  });
+
+  it('Specifying quantisation table provides different JPEG', function (done) {
+    // First generate with default quantisation table
+    sharp(fixtures.inputJpg)
+      .resize(320, 240)
+      .jpeg({ optimiseCoding: false })
+      .toBuffer(function (err, withDefaultQuantisationTable, withInfo) {
+        if (err) throw err;
+        assert.strictEqual(true, withDefaultQuantisationTable.length > 0);
+        assert.strictEqual(withDefaultQuantisationTable.length, withInfo.size);
+        assert.strictEqual('jpeg', withInfo.format);
+        assert.strictEqual(320, withInfo.width);
+        assert.strictEqual(240, withInfo.height);
+        // Then generate with different quantisation table
+        sharp(fixtures.inputJpg)
+          .resize(320, 240)
+          .jpeg({ optimiseCoding: false, quantisationTable: 3 })
+          .toBuffer(function (err, withQuantTable3, withoutInfo) {
+            if (err) throw err;
+            assert.strictEqual(true, withQuantTable3.length > 0);
+            assert.strictEqual(withQuantTable3.length, withoutInfo.size);
+            assert.strictEqual('jpeg', withoutInfo.format);
+            assert.strictEqual(320, withoutInfo.width);
+            assert.strictEqual(240, withoutInfo.height);
+
+            // Verify image is same (as mozjpeg may not be present) size or less
+            assert.strictEqual(true, withQuantTable3.length <= withDefaultQuantisationTable.length);
+            done();
+          });
+      });
+  });
+});

test/unit/libvips.js

@@ -1,8 +1,10 @@
 'use strict';
 
 const assert = require('assert');
+const fs = require('fs');
 const semver = require('semver');
 const libvips = require('../../lib/libvips');
+const mockFS = require('mock-fs');
 
 const originalPlatform = process.platform;
 
@@ -66,5 +68,41 @@ describe('libvips binaries', function () {
 
       delete process.env.SHARP_IGNORE_GLOBAL_LIBVIPS;
     });
+    it('cachePath returns a valid path ending with _libvips', function () {
+      const cachePath = libvips.cachePath();
+      assert.strictEqual('string', typeof cachePath);
+      assert.strictEqual('_libvips', cachePath.substr(-8));
+      assert.strictEqual(true, fs.existsSync(cachePath));
+    });
+  });
+
+  describe('safe directory creation', function () {
+    before(function () {
+      mockFS({
+        exampleDirA: {
+          exampleDirB: {
+            exampleFile: 'Example test file'
+          }
+        }
+      });
+    });
+    after(function () { mockFS.restore(); });
+
+    it('mkdirSync creates a directory', function () {
+      const dirPath = 'createdDir';
+
+      libvips.mkdirSync(dirPath);
+      assert.strictEqual(true, fs.existsSync(dirPath));
+    });
+    it('mkdirSync does not throw error or overwrite an existing dir', function () {
+      const dirPath = 'exampleDirA';
+      const nestedDirPath = 'exampleDirA/exampleDirB';
+      assert.strictEqual(true, fs.existsSync(dirPath));
+
+      libvips.mkdirSync(dirPath);
+
+      assert.strictEqual(true, fs.existsSync(dirPath));
+      assert.strictEqual(true, fs.existsSync(nestedDirPath));
+    });
   });
 });

test/unit/metadata.js

@@ -13,12 +13,15 @@ describe('Image metadata', function () {
     sharp(fixtures.inputJpg).metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(2725, metadata.width);
       assert.strictEqual(2225, metadata.height);
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual('4:2:0', metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
@@ -32,12 +35,15 @@ describe('Image metadata', function () {
     sharp(fixtures.inputJpgWithExif).metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(450, metadata.width);
       assert.strictEqual(600, metadata.height);
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual(72, metadata.density);
+      assert.strictEqual('4:2:0', metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(true, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual(8, metadata.orientation);
@@ -79,12 +85,38 @@ describe('Image metadata', function () {
     sharp(fixtures.inputTiff).metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('tiff', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(2464, metadata.width);
       assert.strictEqual(3248, metadata.height);
       assert.strictEqual('b-w', metadata.space);
       assert.strictEqual(1, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual(300, metadata.density);
+      assert.strictEqual('undefined', typeof metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
+      assert.strictEqual(false, metadata.hasProfile);
+      assert.strictEqual(false, metadata.hasAlpha);
+      assert.strictEqual(1, metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
+      done();
+    });
+  });
+
+  it('Multipage TIFF', function (done) {
+    sharp(fixtures.inputTiffMultipage).metadata(function (err, metadata) {
+      if (err) throw err;
+      assert.strictEqual('tiff', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
+      assert.strictEqual(2464, metadata.width);
+      assert.strictEqual(3248, metadata.height);
+      assert.strictEqual('b-w', metadata.space);
+      assert.strictEqual(1, metadata.channels);
+      assert.strictEqual('uchar', metadata.depth);
+      assert.strictEqual(300, metadata.density);
+      assert.strictEqual('undefined', typeof metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
+      assert.strictEqual(2, metadata.pages);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual(1, metadata.orientation);
@@ -98,12 +130,15 @@ describe('Image metadata', function () {
     sharp(fixtures.inputPng).metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('png', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(2809, metadata.width);
       assert.strictEqual(2074, metadata.height);
       assert.strictEqual('b-w', metadata.space);
       assert.strictEqual(1, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual(300, metadata.density);
+      assert.strictEqual('undefined', typeof metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
@@ -117,12 +152,15 @@ describe('Image metadata', function () {
     sharp(fixtures.inputPngWithTransparency).metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('png', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(2048, metadata.width);
       assert.strictEqual(1536, metadata.height);
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(4, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual(72, metadata.density);
+      assert.strictEqual('undefined', typeof metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(true, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
@@ -136,12 +174,15 @@ describe('Image metadata', function () {
     sharp(fixtures.inputWebP).metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('webp', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(1024, metadata.width);
       assert.strictEqual(772, metadata.height);
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual('undefined', typeof metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
@@ -155,11 +196,14 @@ describe('Image metadata', function () {
     sharp(fixtures.inputGif).metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('gif', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(800, metadata.width);
       assert.strictEqual(533, metadata.height);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual('undefined', typeof metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
@@ -172,11 +216,14 @@ describe('Image metadata', function () {
     sharp(fixtures.inputGifGreyPlusAlpha).metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('gif', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(2, metadata.width);
       assert.strictEqual(1, metadata.height);
       assert.strictEqual(2, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual('undefined', typeof metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(true, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
@@ -189,12 +236,15 @@ describe('Image metadata', function () {
   it('File in, Promise out', function (done) {
     sharp(fixtures.inputJpg).metadata().then(function (metadata) {
       assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(2725, metadata.width);
       assert.strictEqual(2225, metadata.height);
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual('4:2:0', metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
@@ -218,21 +268,22 @@ describe('Image metadata', function () {
     const pipeline = sharp();
     pipeline.metadata().then(function (metadata) {
       assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual(829183, metadata.size);
       assert.strictEqual(2725, metadata.width);
       assert.strictEqual(2225, metadata.height);
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual('4:2:0', metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
       assert.strictEqual('undefined', typeof metadata.exif);
       assert.strictEqual('undefined', typeof metadata.icc);
       done();
-    }).catch(function (err) {
-      throw err;
-    });
+    }).catch(done);
     readable.pipe(pipeline);
   });
 
@@ -241,12 +292,15 @@ describe('Image metadata', function () {
     const pipeline = sharp().metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual(829183, metadata.size);
       assert.strictEqual(2725, metadata.width);
       assert.strictEqual(2225, metadata.height);
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual('4:2:0', metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
@@ -262,12 +316,15 @@ describe('Image metadata', function () {
     image.metadata(function (err, metadata) {
       if (err) throw err;
       assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual('undefined', typeof metadata.size);
       assert.strictEqual(2725, metadata.width);
       assert.strictEqual(2225, metadata.height);
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
       assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual('4:2:0', metadata.chromaSubsampling);
+      assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
@@ -346,10 +403,61 @@ describe('Image metadata', function () {
       });
   });
 
+  it('chromaSubsampling 4:4:4:4 CMYK JPEG', function () {
+    return sharp(fixtures.inputJpgWithCmykProfile)
+      .metadata()
+      .then(function (metadata) {
+        assert.strictEqual('4:4:4:4', metadata.chromaSubsampling);
+      });
+  });
+
+  it('chromaSubsampling 4:4:4 RGB JPEG', function () {
+    return sharp(fixtures.inputJpg)
+      .resize(10, 10)
+      .jpeg({ chromaSubsampling: '4:4:4' })
+      .toBuffer()
+      .then(function (data) {
+        return sharp(data)
+          .metadata()
+          .then(function (metadata) {
+            assert.strictEqual('4:4:4', metadata.chromaSubsampling);
+          });
+      });
+  });
+
+  it('isProgressive JPEG', function () {
+    return sharp(fixtures.inputJpg)
+      .resize(10, 10)
+      .jpeg({ progressive: true })
+      .toBuffer()
+      .then(function (data) {
+        return sharp(data)
+          .metadata()
+          .then(function (metadata) {
+            assert.strictEqual(true, metadata.isProgressive);
+          });
+      });
+  });
+
+  it('isProgressive PNG', function () {
+    return sharp(fixtures.inputJpg)
+      .resize(10, 10)
+      .png({ progressive: true })
+      .toBuffer()
+      .then(function (data) {
+        return sharp(data)
+          .metadata()
+          .then(function (metadata) {
+            assert.strictEqual(true, metadata.isProgressive);
+          });
+      });
+  });
+
   it('File input with corrupt header fails gracefully', function (done) {
     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));
         done();
       });
   });
@@ -358,6 +466,16 @@ 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));
+        done();
+      });
+  });
+
+  it('Unsupported lossless JPEG passes underlying error message', function (done) {
+    sharp(fixtures.inputJpgLossless)
+      .metadata(function (err) {
+        assert.strictEqual(true, !!err);
+        assert.strictEqual(true, /Input file has corrupt header: VipsJpeg: Unsupported JPEG process: SOF type 0xc3/.test(err.message));
         done();
       });
   });
@@ -365,12 +483,12 @@ describe('Image metadata', function () {
   describe('Invalid withMetadata parameters', function () {
     it('String orientation', function () {
       assert.throws(function () {
-        sharp().withMetadata({orientation: 'zoinks'});
+        sharp().withMetadata({ orientation: 'zoinks' });
       });
     });
     it('Negative orientation', function () {
       assert.throws(function () {
-        sharp().withMetadata({orientation: -1});
+        sharp().withMetadata({ orientation: -1 });
       });
     });
     it('Zero orientation', function () {
@@ -380,7 +498,7 @@ describe('Image metadata', function () {
     });
     it('Too large orientation', function () {
       assert.throws(function () {
-        sharp().withMetadata({orientation: 9});
+        sharp().withMetadata({ orientation: 9 });
       });
     });
   });