Release v0.16.2

Useful for pkgconfig without -L, e.g. Alpine Linux
See also commit 07d66da

.editorconfig

@@ -0,0 +1,12 @@
+# http://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

.gitignore

@@ -2,8 +2,15 @@ build
 node_modules
 coverage
 test/bench/node_modules
-test/fixtures/output.*
+test/fixtures/output*
 test/leak/libvips.supp
-
-# Mac OS X
+test/saliency/report.json
+test/saliency/Image*
+test/saliency/[Uu]serData*
+!test/saliency/userData.js
+lib
+include
+packaging/libvips*
+packaging/*.log
+!packaging/build
 .DS_Store

.jshintignore

@@ -1,3 +1,4 @@
 node_modules
 test/bench/node_modules
+test/saliency/humanae/node_modules
 coverage

.jshintrc

@@ -1,7 +1,11 @@
 {
   "strict": true,
   "node": true,
+  "maxparams": 4,
+  "maxcomplexity": 14,
   "globals": {
+    "beforeEach": true,
+    "afterEach": true,
     "describe": true,
     "it": true
   }

.npmignore

@@ -1,8 +1,16 @@
 build
 node_modules
 coverage
+.editorconfig
 .jshintignore
 .jshintrc
 .gitignore
 test
 .travis.yml
+appveyor.yml
+circle.yml
+mkdocs.yml
+lib
+include
+packaging
+preinstall.sh

.travis.yml

@@ -1,8 +1,21 @@
 language: node_js
 node_js:
   - "0.10"
-  - "0.11"
+  - "0.12"
+  - "4"
+  - "6"
+os:
+  - linux
+  - osx
+sudo: false
+addons:
+  apt:
+    sources:
+    - ubuntu-toolchain-r-test
+    packages:
+    - g++-4.8
+osx_image: xcode8
 before_install:
-  - curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -
+  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then export CXX=g++-4.8; fi
 after_success:
   - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js

CONTRIBUTING.md

@@ -0,0 +1,93 @@
+# Contributing to sharp
+
+Hello, thank you for your interest in helping!
+
+## Submit a new bug report
+
+Please create a [new issue](https://github.com/lovell/sharp/issues/new) containing the steps to reproduce the problem.
+
+If you're having installation problems, please include the output of running `npm install --verbose sharp`.
+
+New bugs are assigned a `triage` label whilst under investigation.
+
+## Submit a new feature request
+
+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](http://www.vips.ecs.soton.ac.uk/supported/current/doc/html/libvips/ch03.html) the feature you need.
+
+## Submit a Pull Request to fix a bug
+
+Thank you! To prevent the problem occurring again, please add unit tests that would have failed.
+
+Please select the `master` branch as the destination for your Pull Request so your fix can be included in the next minor release.
+
+Please squash your changes into a single commit using a command like `git rebase -i upstream/master`.
+
+To test C++ changes, you can compile the module using `npm install` and then run the tests using `npm test`.
+
+## Submit a Pull Request with a new feature
+
+Please add JavaScript [unit tests](https://github.com/lovell/sharp/tree/master/test/unit) to cover your new feature.
+A test coverage report for the JavaScript code is generated in the `coverage/lcov-report` directory.
+
+Where possible, the functional tests use gradient-based perceptual hashes
+based on [dHash](http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html)
+to compare expected vs actual images.
+
+You deserve to add your details to the [list of contributors](https://github.com/lovell/sharp/blob/master/package.json#L5).
+
+Any change that modifies the existing public API should be added to the relevant work-in-progress branch for inclusion in the next major release.
+
+| Release | WIP branch |
+| ------: | :--------- |
+| v0.16.0 | pencil     |
+| v0.17.0 | quill      |
+| v0.18.0 | ridge      |
+
+Please squash your changes into a single commit using a command like `git rebase -i upstream/<wip-branch>`.
+
+### Add a new public method
+
+The API tries to be as fluent as possible. Image processing concepts follow the naming conventions from _libvips_ and, to a lesser extent, _ImageMagick_.
+
+Most methods have optional parameters and assume sensible defaults. Methods with mandatory parameters often have names like `doSomethingWith(X)`.
+
+Please ensure backwards compatibility where possible. Methods to modify previously default behaviour often have names like `withoutOptionY()` or `withExtraZ()`.
+
+Feel free to create a [new issue](https://github.com/lovell/sharp/issues/new) to gather feedback on a potential API change.
+
+### Remove an existing public method
+
+A method to be removed should be deprecated in the next major version then removed in the following major version.
+
+By way of example, the [bilinearInterpolation method](https://github.com/lovell/sharp/blob/v0.6.0/index.js#L155) present in v0.5.0 was deprecated in v0.6.0 and removed in v0.7.0.
+
+## Run the tests
+
+### Functional tests and static code analysis
+
+```sh
+npm test
+```
+
+### Memory leak tests
+
+Requires [Valgrind](http://valgrind.org/).
+
+```sh
+npm run test-leak
+```
+
+### Packaging tests
+
+Tests the installation on a number of Linux-based operating systems.
+Requires docker.
+
+```sh
+npm run test-packaging
+```
+
+## Finally
+
+Please feel free to ask any questions via a [new issue](https://github.com/lovell/sharp/issues/new) or contact me by [e-mail](https://github.com/lovell/sharp/blob/master/package.json#L4).

README.md

@@ -1,608 +1,85 @@
 # sharp
 
-* [Installation](https://github.com/lovell/sharp#installation)
-* [Usage examples](https://github.com/lovell/sharp#usage-examples)
-* [API](https://github.com/lovell/sharp#api)
-* [Testing](https://github.com/lovell/sharp#testing)
-* [Performance](https://github.com/lovell/sharp#performance)
-* [Thanks](https://github.com/lovell/sharp#thanks)
-* [Licence](https://github.com/lovell/sharp#licence)
+```sh
+npm install sharp
+```
 
-The typical use case for this high speed Node.js module is to convert large images of many formats to smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
+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.
 
-The performance of JPEG resizing is typically 8x faster than ImageMagick and GraphicsMagick, based mainly on the number of CPU cores available.
+Resizing an image is typically 4x-5x faster than using the
+quickest ImageMagick and GraphicsMagick settings.
 
-Memory usage is kept to a minimum, no child processes are spawned, everything remains non-blocking thanks to _libuv_ and Promises/A+ are supported.
+Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
+Lanczos resampling ensures quality is not sacrificed for speed.
 
-This module supports reading and writing JPEG, PNG and WebP images to and from Streams, Buffer objects and the filesystem. It also supports reading images of many other types from the filesystem via libmagick++ or libgraphicsmagick++ if present.
+As well as image resizing, operations such as
+rotation, extraction, compositing and gamma correction are available.
 
-When generating JPEG output all metadata is removed and Huffman tables optimised without having to use separate command line tools like [jpegoptim](https://github.com/tjko/jpegoptim) and [jpegtran](http://jpegclub.org/jpegtran/).
+OS X, Windows (x64), Linux (x64, ARM) systems do not require
+the installation of any external runtime dependencies.
 
-Anyone who has used the Node.js bindings for [GraphicsMagick](https://github.com/aheckmann/gm) will find the API similarly fluent.
-
-This module is powered by the blazingly fast [libvips](https://github.com/jcupitt/libvips) image processing library, originally created in 1989 at Birkbeck College and currently maintained by [John Cupitt](https://github.com/jcupitt).
-
-## Installation
-
-	npm install sharp
-
-### Prerequisites
-
-* Node.js v0.10+
-* [libvips](https://github.com/jcupitt/libvips) v7.40.0+ (7.42.0+ recommended)
-
-To install the most suitable version of libvips on the following Operating Systems:
-
-* Mac OS
-  * Homebrew
-  * MacPorts
-* Debian Linux
-  * Debian 7, 8
-  * Ubuntu 12.04, 14.04, 14.10, 15.04
-  * Mint 13, 17
-* Red Hat Linux
-  * RHEL/Centos/Scientific 6, 7
-  * Fedora 21, 22
-
-run the following as a user with `sudo` access:
-
-	curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -
-
-or run the following as `root`:
-
-	curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | bash -
-
-The [preinstall.sh](https://github.com/lovell/sharp/blob/master/preinstall.sh) script requires `curl` and `pkg-config`.
-
-### Mac OS tips
-
-Manual install via homebrew:
-
-	brew install homebrew/science/vips --with-webp --with-graphicsmagick
-
-A missing or incorrectly configured _Xcode Command Line Tools_ installation [can lead](https://github.com/lovell/sharp/issues/80) to a `library not found for -ljpeg` error. If so, please try:
-
-	xcode-select --install
-
-The _gettext_ dependency of _libvips_ [can lead](https://github.com/lovell/sharp/issues/9) to a `library not found for -lintl` error. If so, please try:
-
-	brew link gettext --force
-
-### Install libvips on Heroku
-
-[Alessandro Tagliapietra](https://github.com/alex88) maintains an [Heroku buildpack for libvips](https://github.com/alex88/heroku-buildpack-vips) and its dependencies.
-
-### Using with gulp.js
-
-[Eugeny Vlasenko](https://github.com/mahnunchik) maintains [gulp-responsive](https://www.npmjs.org/package/gulp-responsive) and [Mohammad Prabowo](https://github.com/rizalp) maintains [gulp-sharp](https://www.npmjs.org/package/gulp-sharp).
-
-## Usage examples
+## Examples
 
 ```javascript
-var sharp = require('sharp');
+import sharp from 'sharp';
 ```
 
 ```javascript
-sharp('input.jpg').resize(300, 200).toFile('output.jpg', function(err) {
-  if (err) {
-    throw err;
-  }
-  // output.jpg is a 300 pixels wide and 200 pixels high image
-  // containing a scaled and cropped version of input.jpg
-});
+sharp(inputBuffer)
+  .resize(320, 240)
+  .toFile('output.webp', (err, info) => ... );
 ```
 
 ```javascript
-var transformer = sharp().resize(300, 200).crop(sharp.gravity.north);
-readableStream.pipe(transformer).pipe(writableStream);
-// Read image data from readableStream, resize and write image data to writableStream
-```
-
-```javascript
-var image = sharp(inputJpg);
-image.metadata(function(err, metadata) {
-  image.resize(metadata.width / 2).webp().toBuffer(function(err, outputBuffer, info) {
-    // outputBuffer contains a WebP image half the width and height of the original JPEG
-  });
-});
-```
-
-```javascript
-var pipeline = sharp()
+sharp('input.jpg')
   .rotate()
-  .resize(null, 200)
-  .progressive()
-  .toBuffer(function(err, outputBuffer, info) {
-    if (err) {
-      throw err;
-    }
-    // outputBuffer contains 200px high progressive JPEG image data,
-    // auto-rotated using EXIF Orientation tag
-    // info.width and info.height contain the dimensions of the resized image
-  });
-readableStream.pipe(pipeline);
-```
-
-```javascript
-sharp('input.png')
-  .rotate(180)
-  .resize(300)
-  .flatten()
-  .background('#ff6600')
-  .sharpen()
-  .withMetadata()
-  .quality(90)
-  .webp()
+  .resize(200)
   .toBuffer()
-  .then(function(outputBuffer) {
-    // outputBuffer contains upside down, 300px wide, alpha channel flattened
-    // onto orange background, sharpened, with metadata, 90% quality WebP image
-    // data
-  });
+  .then( data => ... )
+  .catch( err => ... );
 ```
 
 ```javascript
-http.createServer(function(request, response) {
-  response.writeHead(200, {'Content-Type': 'image/webp'});
-  sharp('input.jpg').rotate().resize(200).webp().pipe(response);
-}).listen(8000);
-// Create HTTP server that always returns auto-rotated 'input.jpg',
-// resized to 200 pixels wide, in WebP format
+const roundedCorners = new Buffer(
+  '<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 })
+    .png();
+
+readableStream
+  .pipe(roundedCornerResizer)
+  .pipe(writableStream);
 ```
 
-```javascript
-sharp(input)
-  .extract(top, left, width, height)
-  .toFile(output);
-  // Extract a region of the input image, saving in the same format.
-```
-
-```javascript
-sharp(input)
-  .extract(topOffsetPre, leftOffsetPre, widthPre, heightPre)
-  .resize(width, height)
-  .extract(topOffsetPost, leftOffsetPost, widthPost, heightPost)
-  .toFile(output);
-  // Extract a region, resize, then extract from the resized image
-```
-
-```javascript
-sharp(inputBuffer)
-  .resize(200, 300)
-  .interpolateWith(sharp.interpolator.nohalo)
-  .background('white')
-  .embed()
-  .toFile('output.tiff')
-  .then(function() {
-    // output.tiff is a 200 pixels wide and 300 pixels high image
-    // containing a bicubic scaled version, embedded on a white canvas,
-    // of the image data in inputBuffer
-  });
-```
-
-```javascript
-sharp('input.gif')
-  .resize(200, 300)
-  .background({r: 0, g: 0, b: 0, a: 0})
-  .embed()
-  .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
-  });
-```
-
-```javascript
-sharp(inputBuffer)
-  .resize(200, 200)
-  .max()
-  .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
-  });
-```
-
-## API
-
-### Input methods
-
-#### sharp([input])
-
-Constructor to which further methods are chained. `input`, if present, can be one of:
-
-* Buffer containing JPEG, PNG, WebP or TIFF image data, or
-* String containing the filename of an image, with most major formats supported.
-
-The object returned implements the [stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
-
-JPEG, PNG, WebP or TIFF format image data can be streamed into the object when `input` is not provided.
-
-JPEG, PNG or WebP format image data can be streamed out from this object.
-
-#### metadata([callback])
-
-Fast access to image metadata without decoding any compressed image data.
-
-`callback`, if present, gets the arguments `(err, metadata)` where `metadata` has the attributes:
-
-* `format`: Name of decoder to be used to decompress image data e.g. `jpeg`, `png`, `webp` (for file-based input additionally `tiff` and `magick`)
-* `width`: Number of pixels wide
-* `height`: Number of pixels high
-* `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `scrgb`, `cmyk`, `lab`, `xyz`, `b-w` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L522)
-* `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
-* `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
-* `orientation`: Number value of the EXIF Orientation header, if present
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-#### sequentialRead()
-
-An advanced setting that switches the libvips access method to `VIPS_ACCESS_SEQUENTIAL`. This will reduce memory usage and can improve performance on some systems.
-
-### Image transformation options
-
-#### resize(width, [height])
-
-Scale output to `width` x `height`. By default, the resized image is cropped to the exact size specified.
-
-`width` is the Number of pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
-
-`height` is the Number of pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
-
-#### extract(top, left, width, height)
-
-Extract a region of the image. Can be used with or without a `resize` operation.
-
-`top` and `left` are the offset, in pixels, from the top-left corner.
-
-`width` and `height` are the dimensions of the extracted image.
-
-Use `extract` before `resize` for pre-resize extraction. Use `extract` after `resize` for post-resize extraction. Use `extract` before and after for both.
-
-#### crop([gravity])
-
-Crop the resized image to the exact size specified, the default behaviour.
-
-`gravity`, if present, is an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north`.
-
-Possible values are `north`, `east`, `south`, `west`, `center` and `centre`. The default gravity is `center`/`centre`.
-
-#### max()
-
-Preserving aspect ratio, resize the image to the maximum `width` or `height` specified.
-
-Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
-
-#### background(rgba)
-
-Set the background for the `embed` and `flatten` operations.
-
-`rgba` is parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
-
-The alpha value is a float between `0` (transparent) and `1` (opaque).
-
-The default background is `{r: 0, g: 0, b: 0, a: 1}`, black without transparency.
-
-#### 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.
-
-#### flatten()
-
-Merge alpha transparency channel, if any, with `background`.
-
-#### rotate([angle])
-
-Rotate the output image by either an explicit angle or auto-orient based on the EXIF `Orientation` tag.
-
-`angle`, if present, is a Number with a value of `0`, `90`, `180` or `270`.
-
-Use this method without `angle` to determine the angle from EXIF data. Mirroring is supported and may infer the use of a `flip` operation.
-
-#### flip()
-
-Flip the image about the vertical Y axis. This always occurs after rotation, if any.
-
-#### flop()
-
-Flop the image about the horizontal X axis. This always occurs after rotation, if any.
-
-#### withoutEnlargement()
-
-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".
-
-#### blur([radius])
-
-When used without parameters, performs a fast, mild blur of the output image. This typically reduces performance by 10%.
-
-When a `radius` is provided, performs a slower, more accurate Gaussian blur. This typically reduces performance by 30%.
-
-* `radius`, if present, is an integral Number representing the approximate blur mask radius in pixels.
-
-#### sharpen([radius], [flat], [jagged])
-
-When used without parameters, performs a fast, mild sharpen of the output image. This typically reduces performance by 10%.
-
-When a `radius` 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. This typically reduces performance by 50%.
-
-* `radius`, if present, is an integral Number representing the sharpen mask radius in pixels.
-* `flat`, if present, is a Number representing the level of sharpening to apply to "flat" areas, defaulting to a value of 1.0.
-* `jagged`, if present, is a Number representing the level of sharpening to apply to "jagged" areas, defaulting to a value of 2.0.
-
-#### interpolateWith(interpolator)
-
-Use the given interpolator for image resizing, where `interpolator` is an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.bicubic`.
-
-Possible interpolators, in order of performance, are:
-
-* `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation), suitable for image enlargement only.
-* `bilinear`: Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation), the default and fastest image reduction interpolation.
-* `bicubic`: Use [bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation), which typically reduces performance by 5%.
-* `vertexSplitQuadraticBasisSpline`: Use [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48), which prevents "staircasing" and typically reduces performance by 5%.
-* `locallyBoundedBicubic`: Use [LBB interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100), which prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" and typically reduces performance by a factor of 2.
-* `nohalo`: Use [Nohalo interpolation](http://eprints.soton.ac.uk/268086/), which prevents acutance and typically reduces performance by a factor of 3.
-
-#### gamma([gamma])
-
-Apply a gamma correction by reducing the encoding (darken) pre-resize at a factor of `1/gamma` then increasing the encoding (brighten) post-resize at a factor of `gamma`.
-
-`gamma`, if present, is a Number betweem 1 and 3. The default value is `2.2`, a suitable approximation for sRGB images.
-
-This can improve the perceived brightness of a resized image in non-linear colour spaces.
-
-JPEG input images will not take advantage of the shrink-on-load performance optimisation when applying a gamma correction.
-
-#### grayscale() / greyscale()
-
-Convert to 8-bit greyscale; 256 shades of grey.
-
-This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use `gamma()` with `greyscale()` for the best results.
-
-The output image will still be web-friendly sRGB and contain three (identical) channels.
-
-### Output options
-
-#### jpeg()
-
-Use JPEG format for the output image.
-
-#### png()
-
-Use PNG format for the output image.
-
-#### webp()
-
-Use WebP format for the output image.
-
-#### quality(quality)
-
-The output quality to use for lossy JPEG, WebP and TIFF output formats. The default quality is `80`.
-
-`quality` is a Number between 1 and 100.
-
-#### progressive()
-
-Use progressive (interlace) scan for JPEG and PNG output. This typically reduces compression performance by 30% but results in an image that can be rendered sooner when decompressed.
-
-#### withMetadata()
-
-Include all metadata (ICC, EXIF, XMP) from the input image in the output image. The default behaviour is to strip all metadata.
-
-#### compressionLevel(compressionLevel)
-
-An advanced setting for the _zlib_ compression level of the lossless PNG output format. The default level is `6`.
-
-`compressionLevel` is a Number between 0 and 9.
-
-#### withoutAdaptiveFiltering()
-
-_Requires libvips 7.41.0+_
-
-An advanced and experimental PNG output setting to disable adaptive row filtering.
-
-### Output methods
-
-#### toFile(filename, [callback])
-
-`filename` is a String containing the filename to write the image data to. The format is inferred from the extension, with JPEG, PNG, WebP and TIFF supported.
-
-`callback`, if present, is called with two arguments `(err, info)` where:
-
-* `err` contains an error message, if any.
-* `info` contains the output image `format`, `width` and `height`.
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-#### toBuffer([callback])
-
-Write image data to a Buffer, the format of which will match the input image by default. JPEG, PNG and WebP are supported.
-
-`callback`, if present, gets three arguments `(err, buffer, info)` where:
-
-* `err` is an error message, if any.
-* `buffer` is the output image data.
-* `info` contains the output image `format`, `width` and `height`.
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-### Utility methods
-
-#### sharp.cache([memory], [items])
-
-If `memory` or `items` are provided, set the limits of _libvips'_ operation cache.
-
-* `memory` is the maximum memory in MB to use for this cache, with a default value of 100
-* `items` is the maximum number of operations to cache, with a default value of 500
-
-This method always returns cache statistics, useful for determining how much working memory is required for a particular task.
-
-```javascript
-var stats = sharp.cache(); // { current: 75, high: 99, memory: 100, items: 500 }
-sharp.cache(200); // { current: 75, high: 99, memory: 200, items: 500 }
-sharp.cache(50, 200); // { current: 49, high: 99, memory: 50, items: 200}
-```
-
-#### sharp.concurrency([threads])
-
-`threads`, if provided, is the Number of threads _libvips'_ should create for image processing. The default value is the number of CPU cores. A value of `0` will reset to this default.
-
-This method always returns the current concurrency.
-
-```javascript
-var threads = sharp.concurrency(); // 4
-sharp.concurrency(2); // 2
-sharp.concurrency(0); // 4
-```
-
-#### sharp.counters()
-
-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.
-
-```javascript
-var counters = sharp.counters(); // { queue: 2, process: 4 }
-```
-
-## Testing
-
-### Functional tests
-
-#### Coverage
-
 [![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
 
-#### Ubuntu 12.04
+### Documentation
 
-[![Ubuntu 12.04 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
+Visit [sharp.dimens.io](http://sharp.dimens.io/) for complete
+[installation instructions](http://sharp.dimens.io/page/install),
+[API documentation](http://sharp.dimens.io/page/api),
+[benchmark tests](http://sharp.dimens.io/page/performance) and
+[changelog](http://sharp.dimens.io/page/changelog).
 
-#### Centos 6.5
+### Contributing
 
-[![Centos 6.5 Build Status](https://snap-ci.com/lovell/sharp/branch/master/build_image)](https://snap-ci.com/lovell/sharp/branch/master)
+A [guide for contributors](https://github.com/lovell/sharp/blob/master/CONTRIBUTING.md)
+covers reporting bugs, requesting features and submitting code changes.
 
-#### It worked on my machine
+### Licence
 
-```
-npm test
-```
-
-### Memory leak tests
-
-```
-cd sharp/test/leak
-./leak.sh
-```
-
-Requires _valgrind_:
-
-```
-brew install valgrind
-```
-
-```
-sudo apt-get install -qq valgrind
-```
-
-### Benchmark tests
-
-```
-cd sharp/test/bench
-npm install
-npm test
-```
-
-Requires both _ImageMagick_ and _GraphicsMagick_:
-
-```
-brew install imagemagick
-brew install graphicsmagick
-```
-
-```
-sudo apt-get install -qq imagemagick graphicsmagick libmagick++-dev
-```
-
-```
-sudo yum install ImageMagick
-sudo yum install -y http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
-sudo yum install -y --enablerepo=epel GraphicsMagick
-```
-
-## Performance
-
-### Test environment
-
-* AWS EC2 [c3.xlarge](http://aws.amazon.com/ec2/instance-types/#Compute_Optimized)
-* Ubuntu 14.04
-* libvips 7.40.8
-* liborc 0.4.22
-
-### The contenders
-
-* [imagemagick-native](https://github.com/mash/node-imagemagick-native) v1.2.2 - Supports Buffers only and blocks main V8 thread whilst processing.
-* [imagemagick](https://github.com/yourdeveloper/node-imagemagick) v0.1.3 - Supports filesystem only and "has been unmaintained for a long time".
-* [gm](https://github.com/aheckmann/gm) v1.16.0 - Fully featured wrapper around GraphicsMagick.
-* sharp v0.6.2 - Caching within libvips disabled to ensure a fair comparison.
-
-### The task
-
-Decompress a 2725x2225 JPEG image, resize and crop to 720x480, then compress to JPEG.
-
-### Results
-
-| Module                | Input  | Output | Ops/sec | Speed-up |
-| :-------------------- | :----- | :----- | ------: | -------: |
-| imagemagick-native    | buffer | buffer |    1.58 |        1 |
-| imagemagick           | file   | file   |    6.23 |      3.9 |
-| gm                    | buffer | file   |    5.32 |      3.4 |
-| gm                    | buffer | buffer |    5.32 |      3.4 |
-| gm                    | file   | file   |    5.36 |      3.4 |
-| gm                    | file   | buffer |    5.36 |      3.4 |
-| sharp                 | buffer | file   |   22.05 |     14.0 |
-| sharp                 | buffer | buffer |   22.14 |     14.0 |
-| sharp                 | file   | file   |   21.79 |     13.8 |
-| sharp                 | file   | buffer |   21.90 |     13.9 |
-| sharp                 | stream | stream |   20.87 |     13.2 |
-| sharp +promise        | file   | buffer |   21.89 |     13.9 |
-| sharp +sharpen        | file   | buffer |   19.69 |     12.5 |
-| sharp +progressive    | file   | buffer |   16.93 |     10.7 |
-| sharp +sequentialRead | file   | buffer |   21.60 |     13.7 |
-
-You can expect greater performance with caching enabled (default) and using 8+ core machines.
-
-## Thanks
-
-This module would never have been possible without the help and code contributions of the following people:
-
-* [John Cupitt](https://github.com/jcupitt)
-* [Pierre Inglebert](https://github.com/pierreinglebert)
-* [Jonathan Ong](https://github.com/jonathanong)
-* [Chanon Sajjamanochai](https://github.com/chanon)
-* [Juliano Julio](https://github.com/julianojulio)
-* [Daniel Gasienica](https://github.com/gasi)
-* [Julian Walker](https://github.com/julianwa)
-* [Amit Pitaru](https://github.com/apitaru)
-* [Brandon Aaron](https://github.com/brandonaaron)
-* [Andreas Lind](https://github.com/papandreou)
-
-Thank you!
-
-## Licence
-
-Copyright 2013, 2014 Lovell Fuller and contributors.
+Copyright 2013, 2014, 2015, 2016 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)
+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)
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,

appveyor.yml

@@ -0,0 +1,16 @@
+os: Visual Studio 2015
+version: "{build}"
+build: off
+platform: x64
+environment:
+  VIPS_WARNING: 0
+  matrix:
+  - nodejs_version: "0.12"
+  - nodejs_version: "4"
+  - nodejs_version: "6"
+install:
+  - ps: Install-Product node $env:nodejs_version x64
+  - npm install -g npm@latest
+  - npm install
+test_script:
+  - npm run-script test-win

binding.gyp

@@ -1,23 +1,193 @@
 {
   'targets': [{
+    'target_name': 'libvips-cpp',
+    'conditions': [
+      ['OS == "win"', {
+        # Build libvips C++ binding for Windows due to MSVC std library ABI changes
+        'type': 'shared_library',
+        'variables': {
+          'download_vips': '<!(node -e "require(\'./binding\').download_vips()")'
+        },
+        'defines': [
+          'VIPS_CPLUSPLUS_EXPORTS',
+          '_ALLOW_KEYWORD_MACROS'
+        ],
+        'sources': [
+          'src/libvips/cplusplus/VError.cpp',
+          'src/libvips/cplusplus/VInterpolate.cpp',
+          'src/libvips/cplusplus/VImage.cpp'
+        ],
+        'include_dirs': [
+          'include',
+          'include/glib-2.0',
+          'lib/glib-2.0/include'
+        ],
+        'libraries': [
+          '../lib/libvips.lib',
+          '../lib/libglib-2.0.lib',
+          '../lib/libgobject-2.0.lib'
+        ],
+        'configurations': {
+          'Release': {
+            'msvs_settings': {
+              'VCCLCompilerTool': {
+                'ExceptionHandling': 1
+              }
+            },
+            'msvs_disabled_warnings': [
+              4275
+            ]
+          }
+        }
+      }, {
+        # Ignore this target for non-Windows
+        'type': 'none'
+      }]
+    ]
+  }, {
     'target_name': 'sharp',
+    'dependencies': [
+      'libvips-cpp'
+    ],
+    # Nested variables "pattern" borrowed from http://src.chromium.org/viewvc/chrome/trunk/src/build/common.gypi
+    'variables': {
+      'variables': {
+        'variables': {
+          'conditions': [
+            ['OS != "win"', {
+              # Build the PKG_CONFIG_PATH environment variable with all possible combinations
+              'pkg_config_path': '<!(which brew >/dev/null 2>&1 && eval $(brew --env) && echo $PKG_CONFIG_LIBDIR || true):$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig'
+            }, {
+              'pkg_config_path': ''
+            }]
+          ],
+        },
+        'conditions': [
+          ['OS != "win"', {
+            # Which version, if any, of libvips is available globally via pkg-config?
+            'global_vips_version': '<!(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --modversion vips-cpp 2>/dev/null || true)'
+          }, {
+            'global_vips_version': ''
+          }]
+        ],
+        'pkg_config_path%': '<(pkg_config_path)'
+      },
+      'pkg_config_path%': '<(pkg_config_path)',
+      'runtime_link%': 'shared',
+      'conditions': [
+        ['OS != "win"', {
+          # Does the globally available version of libvips, if any, meet the minimum version requirement?
+          'use_global_vips': '<!(GLOBAL_VIPS_VERSION="<(global_vips_version)" node -e "require(\'./binding\').use_global_vips()")'
+        }, {
+          'use_global_vips': ''
+        }]
+      ]
+    },
     'sources': [
       'src/common.cc',
-      'src/utilities.cc',
       'src/metadata.cc',
-      'src/resize.cc',
-      'src/sharp.cc'
-    ],
-    'variables': {
-      'PKG_CONFIG_PATH': '<!(which brew >/dev/null 2>&1 && eval $(brew --env) && echo $PKG_CONFIG_LIBDIR || true):$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig'
-    },
-    'libraries': [
-      '<!(PKG_CONFIG_PATH="<(PKG_CONFIG_PATH)" pkg-config --libs vips)'
+      'src/operations.cc',
+      'src/pipeline.cc',
+      'src/sharp.cc',
+      'src/utilities.cc'
     ],
     'include_dirs': [
-      '<!(PKG_CONFIG_PATH="<(PKG_CONFIG_PATH)" pkg-config --cflags vips glib-2.0)',
       '<!(node -e "require(\'nan\')")'
     ],
+    'conditions': [
+      ['use_global_vips == "true"', {
+        # Use pkg-config for include and lib
+        'include_dirs': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --cflags-only-I vips-cpp vips glib-2.0 | sed s\/-I//g)'],
+        'conditions': [
+          ['runtime_link == "static"', {
+            'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs --static vips-cpp)']
+          }, {
+            'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs vips-cpp)']
+          }],
+          ['OS == "linux"', {
+            'defines': [
+              # Inspect libvips-cpp.so to determine which C++11 ABI version was used and set _GLIBCXX_USE_CXX11_ABI accordingly. This is quite horrible.
+              '_GLIBCXX_USE_CXX11_ABI=<!(if readelf -Ws "$(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs-only-L vips-cpp | cut -c 3- | sed -e "s/^$/\/usr\/lib/")/libvips-cpp.so" | c++filt | grep -qF __cxx11;then echo "1";else echo "0";fi)'
+            ]
+          }]
+        ]
+      }, {
+        # Attempt to download pre-built libvips and install locally within node_modules
+        'include_dirs': [
+          'include',
+          'include/glib-2.0',
+          'lib/glib-2.0/include'
+        ],
+        'conditions': [
+          ['OS == "win"', {
+            'defines': [
+              '_ALLOW_KEYWORD_MACROS'
+            ],
+            'libraries': [
+              '../lib/libvips.lib',
+              '../lib/libglib-2.0.lib',
+              '../lib/libgobject-2.0.lib'
+            ]
+          }],
+          ['OS == "mac"', {
+            'variables': {
+              'download_vips': '<!(node -e "require(\'./binding\').download_vips()")'
+            },
+            'libraries': [
+              '../lib/libvips-cpp.42.dylib',
+              '../lib/libvips.42.dylib',
+              '../lib/libglib-2.0.0.dylib',
+              '../lib/libgobject-2.0.0.dylib',
+              # Ensure runtime linking is relative to sharp.node
+              '-rpath \'@loader_path/../../lib\''
+            ]
+          }],
+          ['OS == "linux"', {
+            'variables': {
+              'download_vips': '<!(LDD_VERSION="<!(ldd --version 2>&1 || true)" node -e "require(\'./binding\').download_vips()")'
+            },
+            'defines': [
+              '_GLIBCXX_USE_CXX11_ABI=0'
+            ],
+            'libraries': [
+              '../lib/libvips-cpp.so',
+              '../lib/libvips.so',
+              '../lib/libglib-2.0.so',
+              '../lib/libgobject-2.0.so',
+              # Dependencies of dependencies, included for openSUSE support
+              '../lib/libcairo.so',
+              '../lib/libcroco-0.6.so',
+              '../lib/libexif.so',
+              '../lib/libffi.so',
+              '../lib/libfontconfig.so',
+              '../lib/libfreetype.so',
+              '../lib/libgdk_pixbuf-2.0.so',
+              '../lib/libgif.so',
+              '../lib/libgio-2.0.so',
+              '../lib/libgmodule-2.0.so',
+              '../lib/libgsf-1.so',
+              '../lib/libgthread-2.0.so',
+              '../lib/libharfbuzz.so',
+              '../lib/libjpeg.so',
+              '../lib/liblcms2.so',
+              '../lib/liborc-0.4.so',
+              '../lib/libpango-1.0.so',
+              '../lib/libpangocairo-1.0.so',
+              '../lib/libpangoft2-1.0.so',
+              '../lib/libpixman-1.so',
+              '../lib/libpng.so',
+              '../lib/librsvg-2.so',
+              '../lib/libtiff.so',
+              '../lib/libwebp.so',
+              '../lib/libxml2.so',
+              '../lib/libz.so',
+              # Ensure runtime linking is relative to sharp.node
+              '-Wl,--disable-new-dtags -Wl,-rpath=\'$${ORIGIN}/../../lib\''
+            ]
+          }]
+        ]
+      }]
+    ],
     'cflags_cc': [
       '-std=c++0x',
       '-fexceptions',
@@ -25,14 +195,84 @@
       '-O3'
     ],
     'xcode_settings': {
+      'CLANG_CXX_LANGUAGE_STANDARD': 'c++11',
+      'CLANG_CXX_LIBRARY': 'libc++',
+      'MACOSX_DEPLOYMENT_TARGET': '10.7',
+      'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+      'GCC_ENABLE_CPP_RTTI': 'YES',
       'OTHER_CPLUSPLUSFLAGS': [
-        '-std=c++11',
-        '-stdlib=libc++',
         '-fexceptions',
         '-Wall',
         '-O3'
-      ],
-      'MACOSX_DEPLOYMENT_TARGET': '10.7'
-    }
+      ]
+    },
+    'configurations': {
+      'Release': {
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'ExceptionHandling': 1
+          }
+        },
+        'msvs_disabled_warnings': [
+          4275
+        ]
+      }
+    },
+  }, {
+    'target_name': 'win_copy_dlls',
+    'type': 'none',
+    'dependencies': [
+      'sharp'
+    ],
+    'conditions': [
+      ['OS == "win"', {
+        # Windows lacks support for rpath
+        'copies': [{
+          'destination': 'build/Release',
+          'files': [
+            'lib/GNU.Gettext.dll',
+            'lib/libasprintf-0.dll',
+            'lib/libcairo-2.dll',
+            'lib/libcairo-gobject-2.dll',
+            'lib/libcairo-script-interpreter-2.dll',
+            'lib/libcharset-1.dll',
+            'lib/libcroco-0.6-3.dll',
+            'lib/libexif-12.dll',
+            'lib/libexpat-1.dll',
+            'lib/libffi-6.dll',
+            'lib/libfftw3-3.dll',
+            'lib/libfontconfig-1.dll',
+            'lib/libfreetype-6.dll',
+            'lib/libgcc_s_seh-1.dll',
+            'lib/libgdk_pixbuf-2.0-0.dll',
+            'lib/libgif-7.dll',
+            'lib/libgio-2.0-0.dll',
+            'lib/libglib-2.0-0.dll',
+            'lib/libgmodule-2.0-0.dll',
+            'lib/libgobject-2.0-0.dll',
+            'lib/libgsf-1-114.dll',
+            'lib/libgthread-2.0-0.dll',
+            'lib/libiconv-2.dll',
+            'lib/libintl-8.dll',
+            'lib/libjpeg-62.dll',
+            'lib/liblcms2-2.dll',
+            'lib/libpango-1.0-0.dll',
+            'lib/libpangocairo-1.0-0.dll',
+            'lib/libpangowin32-1.0-0.dll',
+            'lib/libpixman-1-0.dll',
+            'lib/libpng16-16.dll',
+            'lib/libquadmath-0.dll',
+            'lib/librsvg-2-2.dll',
+            'lib/libssp-0.dll',
+            'lib/libstdc++-6.dll',
+            'lib/libtiff-5.dll',
+            'lib/libvips-42.dll',
+            'lib/libwebp-6.dll',
+            'lib/libxml2-2.dll',
+            'lib/zlib1.dll'
+          ]
+        }]
+      }]
+    ]
   }]
 }

binding.js

@@ -0,0 +1,151 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var zlib = require('zlib');
+
+var semver = require('semver');
+var request = require('request');
+var tar = require('tar');
+
+var tmp = require('os').tmpdir();
+
+var distBaseUrl = 'https://dl.bintray.com/lovell/sharp/';
+
+// Use NPM-provided environment variable where available, falling back to require-based method for Electron
+var minimumLibvipsVersion = process.env.npm_package_config_libvips || require('./package.json').config.libvips;
+
+var vipsHeaderPath = path.join(__dirname, 'include', 'vips', 'vips.h');
+
+var platform = process.env.npm_config_platform || process.platform;
+
+var arch = process.env.npm_config_arch || process.arch;
+var arm_version = process.env.npm_config_armv || process.config.variables.arm_version;
+
+if (arch === 'arch64' || arch === 'armhf') {
+  arch = 'arm';
+  if (arch === 'arch64') arm_version = '8';
+}
+
+// -- Helpers
+
+// Does this file exist?
+var isFile = function(file) {
+  var exists = false;
+  try {
+    exists = fs.statSync(file).isFile();
+  } catch (err) {}
+  return exists;
+};
+
+var unpack = function(tarPath, done) {
+  var extractor = tar.Extract({
+    path: __dirname
+  });
+  extractor.on('error', error);
+  extractor.on('end', function() {
+    if (!isFile(vipsHeaderPath)) {
+      error('Could not unpack ' + tarPath);
+    }
+    if (typeof done === 'function') {
+      done();
+    }
+  });
+  fs.createReadStream(tarPath).on('error', error)
+    .pipe(zlib.Unzip())
+    .pipe(extractor);
+};
+
+var platformId = function() {
+  var id = [platform, arch].join('-');
+  if (arch === 'arm') {
+    switch(arm_version) {
+      case '8':
+        id = id + 'v8';
+        break;
+      case '7':
+        id = id + 'v7';
+        break;
+      default:
+        id = id + 'v6';
+        break;
+    }
+  }
+  return id;
+};
+
+// Error
+var error = function(msg) {
+  if (msg instanceof Error) {
+    msg = msg.message;
+  }
+  process.stderr.write('ERROR: ' + msg + '\n');
+  process.exit(1);
+};
+
+// -- Binary downloaders
+
+module.exports.download_vips = function() {
+  // Has vips been installed locally?
+  if (!isFile(vipsHeaderPath)) {
+    // Ensure Intel 64-bit or ARM
+    if (arch === 'ia32') {
+      error('Intel Architecture 32-bit systems require manual installation - please see http://sharp.dimens.io/en/stable/install/');
+    }
+    // Ensure glibc >= 2.15
+    var lddVersion = process.env.LDD_VERSION;
+    if (lddVersion) {
+      if (/(glibc|gnu libc)/i.test(lddVersion)) {
+        var glibcVersion = lddVersion ? lddVersion.split(/\n/)[0].split(' ').slice(-1)[0].trim() : '';
+        if (glibcVersion && semver.lt(glibcVersion + '.0', '2.13.0')) {
+          error('glibc version ' + glibcVersion + ' requires manual installation - please see http://sharp.dimens.io/en/stable/install/');
+        }
+      } else {
+        error(lddVersion.split(/\n/)[0] + ' requires manual installation - please see http://sharp.dimens.io/en/stable/install/');
+      }
+    }
+    // Arch/platform-specific .tar.gz
+    var tarFilename = ['libvips', minimumLibvipsVersion, platformId()].join('-') + '.tar.gz';
+    var tarPath = path.join(__dirname, 'packaging', tarFilename);
+    if (isFile(tarPath)) {
+      unpack(tarPath);
+    } else {
+      // Download to per-process temporary file
+      tarPath = path.join(tmp, process.pid + '-' + tarFilename);
+      var tmpFile = fs.createWriteStream(tarPath).on('finish', function() {
+        unpack(tarPath, function() {
+          // Attempt to remove temporary file
+          try {
+            fs.unlinkSync(tarPath);
+          } catch (err) {}
+        });
+      });
+      var options = {
+        url: distBaseUrl + tarFilename
+      };
+      if (process.env.npm_config_https_proxy) {
+        // Use the NPM-configured HTTPS proxy
+        options.proxy = process.env.npm_config_https_proxy;
+      }
+      request(options).on('response', function(response) {
+        if (response.statusCode !== 200) {
+          error(distBaseUrl + tarFilename + ' status code ' + response.statusCode);
+        }
+      }).on('error', function(err) {
+        error('Download from ' + distBaseUrl + tarFilename + ' failed: ' + err.message);
+      }).pipe(tmpFile);
+    }
+  }
+};
+
+module.exports.use_global_vips = function() {
+  var useGlobalVips = false;
+  var globalVipsVersion = process.env.GLOBAL_VIPS_VERSION;
+  if (globalVipsVersion) {
+    useGlobalVips = semver.gte(
+      globalVipsVersion,
+      minimumLibvipsVersion
+    );
+  }
+  process.stdout.write(useGlobalVips ? 'true' : 'false');
+};

circle.yml

@@ -0,0 +1,6 @@
+machine:
+  services:
+    - docker
+test:
+  override:
+    - ./packaging/test-linux-x64.sh

docs/api.md

@@ -0,0 +1,838 @@
+# API
+
+```javascript
+var sharp = require('sharp');
+```
+
+### Input
+
+#### sharp([input], [options])
+
+Constructor to which further methods are chained.
+
+`input`, if present, can be one of:
+
+* Buffer containing JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data, or
+* 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 `input` is `null` or `undefined`.
+
+`options`, if present, is an Object with the following optional attributes:
+
+* `density` an integral number representing the DPI for vector images, defaulting to 72.
+* `raw` an Object containing `width`, `height` and `channels` when providing uncompressed data. See `raw()` for pixel ordering.
+
+The object returned by the constructor implements the
+[stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
+
+JPEG, PNG or WebP format image data can be streamed out from this object.
+When using Stream based output, derived attributes are available from the `info` event.
+
+```javascript
+sharp('input.jpg')
+  .resize(300, 200)
+  .toFile('output.jpg', function(err) {
+    // output.jpg is a 300 pixels wide and 200 pixels high image
+    // containing a scaled and cropped version of input.jpg
+  });
+```
+
+```javascript
+// Read image data from readableStream,
+// resize to 300 pixels wide,
+// emit an 'info' event with calculated dimensions
+// and finally write image data to writableStream
+var transformer = sharp()
+  .resize(300)
+  .on('info', function(info) {
+    console.log('Image height is ' + info.height);
+  });
+readableStream.pipe(transformer).pipe(writableStream);
+```
+
+#### metadata([callback])
+
+Fast access to image metadata without decoding any compressed image data.
+
+`callback`, if present, gets the arguments `(err, metadata)` where `metadata` has the attributes:
+
+* `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
+* `width`: Number of pixels wide
+* `height`: Number of pixels high
+* `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `scrgb`, `cmyk`, `lab`, `xyz`, `b-w` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
+* `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
+* `density`: Number of pixels per inch (DPI), if present
+* `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](https://www.npmjs.com/package/icc) profile data, if present
+
+A Promises/A+ promise is returned when `callback` is not provided.
+
+```javascript
+var image = sharp(inputJpg);
+image
+  .metadata()
+  .then(function(metadata) {
+    return image
+      .resize(Math.round(metadata.width / 2))
+      .webp()
+      .toBuffer();
+  })
+  .then(function(data) {
+    // data contains a WebP image half the width and height of the original JPEG
+  });
+```
+
+#### clone()
+
+Takes a "snapshot" of the 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.
+
+```javascript
+var pipeline = sharp().rotate();
+pipeline.clone().resize(800, 600).pipe(firstWritableStream);
+pipeline.clone().extract({ left: 20, top: 20, width: 100, height: 100 }).pipe(secondWritableStream);
+readableStream.pipe(pipeline);
+// firstWritableStream receives auto-rotated, resized readableStream
+// secondWritableStream receives auto-rotated, extracted region of readableStream
+```
+
+#### sequentialRead()
+
+An advanced setting that switches the libvips access method to `VIPS_ACCESS_SEQUENTIAL`.
+This will reduce memory usage and can improve performance on some systems.
+
+#### limitInputPixels(pixels)
+
+Do not process input images where the number of pixels (width * height) exceeds this limit.
+
+`pixels` is either an integral Number of pixels, with a value between 1 and the default 268402689 (0x3FFF * 0x3FFF) or
+ a boolean. `false` will disable checking while `true` will revert to the default limit.
+
+### Resizing
+
+#### resize([width], [height], [options])
+
+Scale output to `width` x `height`. By default, the resized image is cropped to the exact size specified.
+
+`width` is the integral Number of pixels wide the resultant image should be, between 1 and 16383 (0x3FFF). Use `null` or `undefined` to auto-scale the width to match the height.
+
+`height` is the integral Number of pixels high the resultant image should be, between 1 and 16383. Use `null` or `undefined` to auto-scale the height to match the width.
+
+`options` is an optional Object. If present, it can contain one or more of:
+
+* `options.kernel`, the kernel to use for image reduction, defaulting to `lanczos3`.
+* `options.interpolator`, the interpolator to use for image enlargement, defaulting to `bicubic`.
+
+Possible kernels are:
+
+* `cubic`: Use a [Catmull-Rom spline](https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline).
+* `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).
+
+Possible interpolators are:
+
+* `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation).
+* `bilinear`: Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation), faster than bicubic but with less smooth results.
+* `vertexSplitQuadraticBasisSpline`: Use the smoother [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48) to prevent "staircasing" when enlarging.
+* `bicubic`: Use [bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default).
+* `locallyBoundedBicubic`: Use [LBB interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100), which prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2.
+* `nohalo`: Use [Nohalo interpolation](http://eprints.soton.ac.uk/268086/), which prevents acutance but typically reduces performance by a factor of 3.
+
+```javascript
+sharp(inputBuffer)
+  .resize(200, 300, {
+    kernel: sharp.kernel.lanczos2,
+    interpolator: sharp.interpolator.nohalo
+  })
+  .background('white')
+  .embed()
+  .toFile('output.tiff')
+  .then(function() {
+    // output.tiff is a 200 pixels wide and 300 pixels high image
+    // containing a lanczos2/nohalo scaled version, embedded on a white canvas,
+    // of the image data in inputBuffer
+  });
+```
+
+#### crop([option])
+
+Crop the resized image to the exact size specified, the default behaviour.
+
+`option`, if present, is an attribute of:
+
+* `sharp.gravity` e.g. `sharp.gravity.north`, to crop to an edge or corner, or
+* `sharp.strategy` e.g. `sharp.strategy.entropy`, to crop dynamically.
+
+Possible attributes of `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.
+
+The default crop option is a `center`/`centre` gravity.
+
+```javascript
+var 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);
+```
+
+#### 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.
+
+```javascript
+sharp('input.gif')
+  .resize(200, 300)
+  .background({r: 0, g: 0, b: 0, a: 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
+  });
+```
+
+#### 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`.
+
+```javascript
+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
+  });
+```
+
+#### 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`.
+
+#### withoutEnlargement()
+
+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*".
+
+#### ignoreAspectRatio()
+
+Ignoring the aspect ratio of the input, stretch the image to the exact `width` and/or `height` provided via `resize`.
+
+### Operations
+
+#### extract({ left: left, top: top, width: width, height: height })
+
+Extract a region of the image. Can be used with or without a `resize` operation.
+
+`left` and `top` are the offset, in pixels, from the top-left corner.
+
+`width` and `height` are the dimensions of the extracted image.
+
+Use `extract` before `resize` for pre-resize extraction. Use `extract` after `resize` for post-resize extraction. Use `extract` before and after for both.
+
+```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
+  });
+```
+
+#### trim([tolerance])
+
+Trim "boring" pixels from all edges that contain values within a percentage similarity of the top-left pixel.
+
+* `tolerance`, if present, is an integral Number between 1 and 99 representing the percentage similarity, defaulting to 10.
+
+#### background(rgba)
+
+Set the background for the `embed`, `flatten` and `extend` operations.
+
+`rgba` is parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+
+The alpha value is a float between `0` (transparent) and `1` (opaque).
+
+The default background is `{r: 0, g: 0, b: 0, a: 1}`, black without transparency.
+
+#### flatten()
+
+Merge alpha transparency channel, if any, with `background`.
+
+#### extend(extension)
+
+Extends/pads the edges of the image with `background`, where `extension` is one of:
+
+* a Number representing the pixel count to add to each edge, or
+* an Object containing `top`, `left`, `bottom` and `right` attributes, each a Number of pixels to add to that edge.
+
+This operation will always occur after resizing and extraction, if any.
+
+```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, a: 0})
+  .extend({top: 10, bottom: 20, left: 10, right: 10})
+  ...
+```
+
+#### negate()
+
+Produces the "negative" of the image.  White => Black, Black => White, Blue => Yellow, etc.
+
+#### rotate([angle])
+
+Rotate the output image by either an explicit angle or auto-orient based on the EXIF `Orientation` tag.
+
+`angle`, if present, is a Number with a value of `0`, `90`, `180` or `270`.
+
+Use this method without `angle` to determine the angle from EXIF data. Mirroring is supported and may infer the use of a `flip` operation.
+
+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)`.
+
+The use of `rotate` implies the removal of the EXIF `Orientation` tag, if any.
+
+```javascript
+var pipeline = sharp()
+  .rotate()
+  .resize(null, 200)
+  .progressive()
+  .toBuffer(function(err, outputBuffer, info) {
+    if (err) {
+      throw err;
+    }
+    // outputBuffer contains 200px high progressive JPEG image data,
+    // auto-rotated using EXIF Orientation tag
+    // info.width and info.height contain the dimensions of the resized image
+  });
+readableStream.pipe(pipeline);
+```
+
+#### flip()
+
+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.
+
+#### flop()
+
+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.
+
+#### blur([sigma])
+
+When used without parameters, performs a fast, mild blur of the output image. This typically reduces performance by 10%.
+
+When a `sigma` is provided, performs a slower, more accurate Gaussian blur. This typically reduces performance by 25%.
+
+* `sigma`, if present, is a Number between 0.3 and 1000 representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+
+#### convolve(kernel)
+
+Convolve the image with the specified `kernel`, an Object with the following attributes:
+
+* `width` is an integral Number representing the width of the kernel in pixels.
+* `height` is an integral Number representing the width of the kernel in pixels.
+* `kernel` is an Array of length `width*height` containing the kernel values.
+* `scale`, if present, is a Number representing the scale of the kernel in pixels, defaulting to the sum of the kernel's values.
+* `offset`, if present, is a Number representing the offset of the kernel in pixels, defaulting to 0.
+
+```javascript
+sharp(input)
+  .convolve({
+    width: 3,
+    height: 3,
+    kernel: [-1, 0, 1, -2, 0, 2, -1, 0, 1]
+  })
+  .raw()
+  .toBuffer(function(err, data, info) {
+    // data contains the raw pixel data representing the convolution
+    // of the input image with the horizontal Sobel operator
+  });
+```
+
+#### sharpen([sigma], [flat], [jagged])
+
+When used without parameters, performs a fast, mild sharpen of the output image. This typically reduces performance by 10%.
+
+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. This typically reduces performance by 50%.
+
+* `sigma`, if present, is a Number representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+* `flat`, if present, is a Number representing the level of sharpening to apply to "flat" areas, defaulting to a value of 1.0.
+* `jagged`, if present, is a Number representing the level of sharpening to apply to "jagged" areas, defaulting to a value of 2.0.
+
+#### threshold([threshold], [options])
+
+Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+By default, the image will be converted to single channel greyscale before thresholding.
+
+* `threshold`, if present, is a Number between 0 and 255, representing the level at which the threshold will be applied. The default threshold is 128.
+* `options`, if present, is an Object containing a Boolean `greyscale` (or `grayscale`). When `false` each channel will have the threshold applied independently.
+
+#### gamma([gamma])
+
+Apply a gamma correction by reducing the encoding (darken) pre-resize at a factor of `1/gamma` then increasing the encoding (brighten) post-resize at a factor of `gamma`.
+
+`gamma`, if present, is a Number between 1 and 3. The default value is `2.2`, a suitable approximation for sRGB images.
+
+This can improve the perceived brightness of a resized image in non-linear colour spaces.
+
+JPEG input images will not take advantage of the shrink-on-load performance optimisation when applying a gamma correction.
+
+#### grayscale() / greyscale()
+
+Convert to 8-bit greyscale; 256 shades of grey.
+
+This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use `gamma()` with `greyscale()` for the best results.
+
+By default the output image will be web-friendly sRGB and contain three (identical) color channels. 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.
+
+#### normalize() / normalise()
+
+Enhance output image contrast by stretching its luminance to cover the full dynamic range. This typically reduces performance by 30%.
+
+#### overlayWith(image, [options])
+
+Overlay (composite) a image over the processed (resized, extracted etc.) image.
+
+`image` is one of the following, and must be the same size or smaller than the processed image:
+
+* Buffer containing image data, or
+* String containing the path to an image file
+
+`options`, if present, is an Object with the following optional attributes:
+
+* `gravity` is a String or an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north` at which to place the overlay, defaulting to `center`/`centre`.
+* `top` is an integral Number representing the pixel offset from the top edge.
+* `left` is an integral Number representing the pixel offset from the left edge.
+* `tile` is a Boolean, defaulting to `false`. When set to `true` repeats the overlay image across the entire image with the given `gravity`.
+* `cutout` is a Boolean, defaulting to `false`. When set to `true` applies only the alpha channel of the overlay image to the image to be overlaid, giving the appearance of one image being cut out of another.
+* `raw` an Object containing `width`, `height` and `channels` when providing uncompressed data.
+
+If both `top` and `left` are provided, they take precedence over `gravity`.
+
+```javascript
+sharp('input.png')
+  .rotate(180)
+  .resize(300)
+  .flatten()
+  .background('#ff6600')
+  .overlayWith('overlay.png', { gravity: sharp.gravity.southeast } )
+  .sharpen()
+  .withMetadata()
+  .quality(90)
+  .webp()
+  .toBuffer()
+  .then(function(outputBuffer) {
+    // outputBuffer contains upside down, 300px wide, alpha channel flattened
+    // onto orange background, composited with overlay.png with SE gravity,
+    // sharpened, with metadata, 90% quality WebP image data. Phew!
+  });
+```
+
+#### toColourspace(colourspace) / toColorspace(colorspace)
+
+Set the output colourspace. By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.  
+  
+`colourspace` is a string or `sharp.colourspace` enum that identifies an output colourspace. String arguments comprise vips colour space interpretation names  e.g. `srgb`, `rgb`, `scrgb`, `cmyk`, `lab`, `xyz`, `b-w` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
+  
+#### extractChannel(channel)
+
+Extract a single channel from a multi-channel image.
+
+`channel` is a zero-indexed integral Number representing the band number to extract. `red`, `green` or `blue` are also accepted as an alternative to `0`, `1` or `2` respectively.
+
+```javascript
+sharp(input)
+  .extractChannel('green')
+  .toFile('input_green.jpg', function(err, info) {
+    // info.channels === 1
+    // input_green.jpg contains the green channel of the input image
+   });
+```
+
+#### joinChannel(channels, [options])
+
+Join a data channel to the image. The meaning of the added channels depends on the output colourspace, set with `toColourspace()`. By default the output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
+
+`channels` is one of
+* a single file path
+* an array of file paths
+* a single buffer
+* an array of buffers
+
+Note that channel ordering follows vips convention:
+* sRGB: 0: Red, 1: Green, 2: Blue, 3: Alpha
+* CMYK: 0: Magenta, 1: Cyan, 2: Yellow, 3: Black, 4: Alpha
+
+Buffers may be any of the image formats supported by sharp: JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data. In the case of a RAW buffer, the `options` object should contain a `raw` attribute, which follows the format of the attribute of the same name in the `sharp()` constructor. See `sharp()` for details. See `raw()` for pixel ordering. 
+
+#### bandbool(operation)
+
+Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
+
+`operation` is a string containing the name of the bitwise operator to be appled to image channels, which can be one of:
+
+* `and` performs a bitwise and operation, like the c-operator `&`.
+* `or` performs a bitwise or operation, like the c-operator `|`.
+* `eor` performs a bitwise exclusive or operation, like the c-operator `^`.
+
+```javascript
+sharp('input.png')
+  .bandbool(sharp.bool.and)
+  .toFile('output.png')
+```
+
+In the above example if `input.png` is a 3 channel RGB image, `output.png` will be a 1 channel grayscale image where each pixel `P = R & G & B`.
+For example, if `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]` then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
+
+#### boolean(image, operation, [options])
+
+Perform a bitwise boolean operation with `image`, where `image` is one of the following:
+
+* Buffer containing JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data, or
+* String containing the path to an image file
+
+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.
+The boolean operation can be one of the following:
+
+* `and` performs a bitwise and operation, like the c-operator `&`.
+* `or` performs a bitwise or operation, like the c-operator `|`.
+* `eor` performs a bitwise exclusive or operation, like the c-operator `^`.
+
+`options`, if present, is an Object with the following optional attributes:
+
+* `raw` an Object containing `width`, `height` and `channels` when providing uncompressed data.
+
+### Output
+
+#### toFile(path, [callback])
+
+`path` is a String containing the path to write the image data to.
+
+If an explicit output format is not selected, it will be inferred from the extension, with JPEG, PNG, WebP, TIFF, DZI, and VIPS V format supported. Note that RAW format is only supported for buffer output.
+
+`callback`, if present, is called with two arguments `(err, info)` where:
+
+* `err` contains an error message, if any.
+* `info` contains the output image `format`, `size` (bytes), `width`, `height` and `channels`.
+
+A Promises/A+ promise is returned when `callback` is not provided.
+
+#### toBuffer([callback])
+
+Write image data to a Buffer, the format of which will match the input image by default. JPEG, PNG, WebP, and RAW are supported.
+
+`callback`, if present, gets three arguments `(err, buffer, info)` where:
+
+* `err` is an error message, if any.
+* `buffer` is the output image data.
+* `info` contains the output image `format`, `size` (bytes), `width`, `height` and `channels`.
+
+A Promises/A+ promise is returned when `callback` is not provided.
+
+#### jpeg()
+
+Use JPEG format for the output image.
+
+#### png()
+
+Use PNG format for the output image.
+
+#### webp()
+
+Use WebP format for the output image.
+
+#### raw()
+
+Provide raw, uncompressed uint8 (unsigned char) image data for Buffer and Stream based output.
+
+The number of channels depends on the input image and selected options.
+
+* 1 channel for images converted to `greyscale()`, with each byte representing one pixel.
+* 3 channels for colour images without alpha transparency, with bytes ordered \[red, green, blue, red, green, blue, etc.\]).
+* 4 channels for colour images with alpha transparency, with bytes ordered \[red, green, blue, alpha, red, green, blue, alpha, etc.\].
+
+#### toFormat(format)
+
+Convenience method for the above output format methods, where `format` is either:
+
+* an attribute of the `sharp.format` Object e.g. `sharp.format.jpeg`, or
+* a String containing `jpeg`, `png`, `webp` or `raw`.
+
+#### quality(quality)
+
+The output quality to use for lossy JPEG, WebP and TIFF output formats. The default quality is `80`.
+
+`quality` is a Number between 1 and 100.
+
+#### progressive()
+
+Use progressive (interlace) scan for JPEG and PNG output. This typically reduces compression performance by 30% but results in an image that can be rendered sooner when decompressed.
+
+#### withMetadata([metadata])
+
+Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
+This will also convert to and add the latest web-friendly v2 sRGB ICC profile.
+
+The optional `metadata` parameter, if present, is an Object with the attributes to update.
+New attributes cannot be inserted, only existing attributes updated.
+
+* `orientation` is an integral Number between 1 and 8, used to update the value of the EXIF `Orientation` tag.
+This has no effect if the input image does not have an EXIF `Orientation` tag.
+
+The default behaviour, when `withMetadata` is not used, is to strip all metadata and convert to the device-independent sRGB colour space.
+
+#### tile(options)
+
+The size, overlap, container and directory layout to use when generating square Deep Zoom image pyramid tiles.
+
+`options` is an Object with one or more of the following attributes:
+
+* `size` is an integral Number between 1 and 8192. The default value is 256 pixels.
+* `overlap` is an integral Number between 0 and 8192. The default value is 0 pixels.
+* `container` is a String, with value `fs` or `zip`. The default value is `fs`.
+* `layout` is a String, with value `dz`, `zoomify` or `google`. The default value is `dz`.
+
+You can also use the file extension `.zip` or `.szi` to write to a compressed archive file format.
+
+```javascript
+sharp('input.tiff')
+  .tile({
+    size: 512
+  })
+  .toFile('output.dzi', function(err, info) {
+    // output.dzi is the Deep Zoom XML definition
+    // output_files contains 512x512 tiles grouped by zoom level
+  });
+```
+
+#### withoutChromaSubsampling()
+
+Disable the use of [chroma subsampling](http://en.wikipedia.org/wiki/Chroma_subsampling) with JPEG output (4:4:4).
+
+This can improve colour representation at higher quality settings (90+),
+but usually increases output file size and typically reduces performance by 25%.
+
+The default behaviour is to use chroma subsampling (4:2:0).
+
+#### compressionLevel(compressionLevel)
+
+An advanced setting for the _zlib_ compression level of the lossless PNG output format. The default level is `6`.
+
+`compressionLevel` is a Number between 0 and 9.
+
+#### withoutAdaptiveFiltering()
+
+An advanced setting to disable adaptive row filtering for the lossless PNG output format.
+
+#### trellisQuantisation() / trellisQuantization()
+
+_Requires libvips to have been compiled with mozjpeg support_
+
+An advanced setting to apply the use of
+[trellis quantisation](http://en.wikipedia.org/wiki/Trellis_quantization) with JPEG output.
+Reduces file size and slightly increases relative quality at the cost of increased compression time.
+
+#### overshootDeringing()
+
+_Requires libvips to have been compiled with mozjpeg support_
+
+An advanced setting to reduce the effects of
+[ringing](http://en.wikipedia.org/wiki/Ringing_%28signal%29) in JPEG output,
+in particular where black text appears on a white background (or vice versa).
+
+#### optimiseScans() / optimizeScans()
+
+_Requires libvips to have been compiled with mozjpeg support_
+
+An advanced setting for progressive (interlace) JPEG output.
+Calculates which spectrum of DCT coefficients uses the fewest bits.
+Usually reduces file size at the cost of increased compression time.
+
+### Attributes
+
+#### format
+
+An Object containing nested boolean values
+representing the available input and output formats/methods,
+for example:
+
+```javascript
+> console.dir(sharp.format);
+
+{ jpeg: { id: 'jpeg',
+    input: { file: true, buffer: true, stream: true },
+    output: { file: true, buffer: true, stream: true } },
+  png: { id: 'png',
+    input: { file: true, buffer: true, stream: true },
+    output: { file: true, buffer: true, stream: true } },
+  webp: { id: 'webp',
+    input: { file: true, buffer: true, stream: true },
+    output: { file: true, buffer: true, stream: true } },
+  tiff: { id: 'tiff',
+    input: { file: true, buffer: true, stream: true },
+    output: { file: true, buffer: false, stream: false } },
+  raw: { id: 'raw',
+    input: { file: false, buffer: false, stream: false },
+    output: { file: false, buffer: true, stream: true } } }
+```
+
+#### queue
+
+An EventEmitter that emits a `change` event when a task is either:
+
+* queued, waiting for _libuv_ to provide a worker thread
+* complete
+
+```javascript
+sharp.queue.on('change', function(queueLength) {
+  console.log('Queue contains ' + queueLength + ' task(s)');
+});
+```
+
+#### versions
+
+An Object containing the version numbers of libvips and, on Linux, its dependencies.
+
+```javascript
+console.log(sharp.versions);
+```
+
+### Utilities
+
+#### sharp.cache([options])
+
+If `options` is provided, sets the limits of _libvips'_ operation cache.
+
+* `options.memory` is the maximum memory in MB to use for this cache, with a default value of 50
+* `options.files` is the maximum number of files to hold open, with a default value of 20
+* `options.items` is the maximum number of operations to cache, with a default value of 100
+
+`options` can also be a boolean, where `true` enables the default cache settings and `false` disables all caching.
+
+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.
+
+```javascript
+var stats = sharp.cache();
+```
+
+```javascript
+sharp.cache( { items: 200 } );
+sharp.cache( { files: 0 } );
+sharp.cache(false);
+```
+
+#### sharp.concurrency([threads])
+
+`threads`, if provided, is the Number of threads _libvips'_ should create for processing each image. The default value is the number of CPU cores. A value of `0` will reset to this default.
+
+This method always returns the current concurrency.
+
+```javascript
+var threads = sharp.concurrency(); // 4
+sharp.concurrency(2); // 2
+sharp.concurrency(0); // 4
+```
+
+The maximum number of images that can be processed in parallel is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
+
+#### sharp.counters()
+
+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.
+
+```javascript
+var counters = sharp.counters(); // { queue: 2, process: 4 }
+```
+
+#### sharp.simd([enable])
+
+_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.
+
+* `enable`, if present, is a boolean where `true` enables and `false` disables the use of SIMD.
+
+This method always returns the current state.
+
+This feature is currently disabled by default
+but future versions may enable it by default.
+
+When enabled, versions of liborc prior to 0.4.24
+and versions of libvips prior to 8.2.0
+have been known to crash under heavy load.
+
+```javascript
+var simd = sharp.simd();
+// simd is `true` if SIMD is currently enabled
+```
+
+```javascript
+var simd = sharp.simd(true);
+// attempts to enable the use of SIMD, returning true if available
+```

docs/changelog.md

@@ -0,0 +1,449 @@
+# Changelog
+
+### v0.16 - "*pencil*"
+
+Requires libvips v8.3.3
+
+#### v0.16.2 - 22<sup>nd</sup> October 2016
+
+* Restrict readelf usage to Linux only when detecting global libvips version.
+  [#602](https://github.com/lovell/sharp/issues/602)
+  [@caoko](https://github.com/caoko)
+
+#### v0.16.1 - 13<sup>th</sup> October 2016
+
+* C++11 ABI version is now auto-detected, remove sharp-cxx11 installation flag.
+
+* Add experimental 'attention' crop strategy.
+  [#295](https://github.com/lovell/sharp/issues/295)
+
+* Include .node extension for Meteor's require() implementation.
+  [#537](https://github.com/lovell/sharp/issues/537)
+  [@isjackwild](https://github.com/isjackwild)
+
+* Ensure convolution kernel scale is clamped to a minimum value of 1.
+  [#561](https://github.com/lovell/sharp/issues/561)
+  [@abagshaw](https://github.com/abagshaw)
+
+* Correct calculation of y-axis placement when overlaying image at a fixed point.
+  [#566](https://github.com/lovell/sharp/issues/566)
+  [@Nateowami](https://github.com/Nateowami)
+
+#### v0.16.0 - 18<sup>th</sup> August 2016
+
+* Add pre-compiled libvips for OS X, ARMv7 and ARMv8.
+  [#312](https://github.com/lovell/sharp/issues/312)
+
+* Ensure boolean, bandbool, extractChannel ops occur before sRGB conversion.
+  [#504](https://github.com/lovell/sharp/pull/504)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Recalculate factors after WebP shrink-on-load to avoid round-to-zero errors.
+  [#508](https://github.com/lovell/sharp/issues/508)
+  [@asilvas](https://github.com/asilvas)
+
+* Prevent boolean errors during extract operation.
+  [#511](https://github.com/lovell/sharp/pull/511)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add joinChannel and toColourspace/toColorspace operations.
+  [#513](https://github.com/lovell/sharp/pull/513)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add support for raw pixel data with boolean and withOverlay operations.
+  [#516](https://github.com/lovell/sharp/pull/516)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Prevent bandbool creating a single channel sRGB image.
+  [#519](https://github.com/lovell/sharp/pull/519)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Ensure ICC profiles are removed from PNG output unless withMetadata used.
+  [#521](https://github.com/lovell/sharp/issues/521)
+  [@ChrisPinewood](https://github.com/ChrisPinewood)
+
+* Add alpha channels, if missing, to overlayWith images.
+  [#540](https://github.com/lovell/sharp/pull/540)
+  [@cmtt](https://github.com/cmtt)
+
+* Remove deprecated interpolateWith method - use resize(w, h, { interpolator: ... })
+  [#310](https://github.com/lovell/sharp/issues/310)
+
+### v0.15 - "*outfit*"
+
+Requires libvips v8.3.1
+
+#### v0.15.1 - 12<sup>th</sup> July 2016
+
+* Concat Stream-based input in single operation for ~+3% perf and less GC.
+  [#429](https://github.com/lovell/sharp/issues/429)
+  [@papandreou](https://github.com/papandreou)
+
+* Add alpha channel, if required, before extend operation.
+  [#439](https://github.com/lovell/sharp/pull/439)
+  [@frulo](https://github.com/frulo)
+
+* Allow overlay image to be repeated across entire image via tile option.
+  [#443](https://github.com/lovell/sharp/pull/443)
+  [@lemnisk8](https://github.com/lemnisk8)
+
+* Add cutout option to overlayWith feature, applies only the alpha channel of the overlay image.
+  [#448](https://github.com/lovell/sharp/pull/448)
+  [@kleisauke](https://github.com/kleisauke)
+
+* Ensure scaling factors are calculated independently to prevent rounding errors.
+  [#452](https://github.com/lovell/sharp/issues/452)
+  [@puzrin](https://github.com/puzrin)
+
+* Add --sharp-cxx11 flag to compile with gcc's new C++11 ABI.
+  [#456](https://github.com/lovell/sharp/pull/456)
+  [@kapouer](https://github.com/kapouer)
+
+* Add top/left offset support to overlayWith operation.
+  [#473](https://github.com/lovell/sharp/pull/473)
+  [@rnanwani](https://github.com/rnanwani)
+
+* Add convolve operation for kernel-based convolution.
+  [#479](https://github.com/lovell/sharp/pull/479)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add greyscale option to threshold operation for colourspace conversion control.
+  [#480](https://github.com/lovell/sharp/pull/480)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Ensure ICC profiles are licenced for distribution.
+  [#486](https://github.com/lovell/sharp/issues/486)
+  [@kapouer](https://github.com/kapouer)
+
+* Allow images with an alpha channel to work with LAB-colourspace based sharpen.
+  [#490](https://github.com/lovell/sharp/issues/490)
+  [@jwagner](https://github.com/jwagner)
+
+* Add trim operation to remove "boring" edges.
+  [#492](https://github.com/lovell/sharp/pull/492)
+  [@kleisauke](https://github.com/kleisauke)
+
+* Add bandbool feature for channel-wise boolean operations.
+  [#496](https://github.com/lovell/sharp/pull/496)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add extractChannel operation to extract a channel from an image.
+  [#497](https://github.com/lovell/sharp/pull/497)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add ability to read and write native libvips .v files.
+  [#500](https://github.com/lovell/sharp/pull/500)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add boolean feature for bitwise image operations.
+  [#501](https://github.com/lovell/sharp/pull/501)
+  [@mhirsch](https://github.com/mhirsch)
+
+#### v0.15.0 - 21<sup>st</sup> May 2016
+
+* Use libvips' new Lanczos 3 kernel as default for image reduction.
+  Deprecate interpolateWith method, now provided as a resize option.
+  [#310](https://github.com/lovell/sharp/issues/310)
+  [@jcupitt](https://github.com/jcupitt)
+
+* Take advantage of libvips v8.3 features.
+  Add support for libvips' new GIF and SVG loaders.
+  Pre-built binaries now include giflib and librsvg, exclude *magick.
+  Use shrink-on-load for WebP input.
+  Break existing sharpen API to accept sigma and improve precision.
+  [#369](https://github.com/lovell/sharp/issues/369)
+
+* Remove unnecessary (un)premultiply operations when not resizing/compositing.
+  [#413](https://github.com/lovell/sharp/issues/413)
+  [@jardakotesovec](https://github.com/jardakotesovec)
+
+### v0.14 - "*needle*"
+
+Requires libvips v8.2.3
+
+#### v0.14.1 - 16<sup>th</sup> April 2016
+
+* Allow removal of limitation on input pixel count via limitInputPixels. Use with care.
+  [#250](https://github.com/lovell/sharp/issues/250)
+  [#316](https://github.com/lovell/sharp/pull/316)
+  [@anandthakker](https://github.com/anandthakker)
+  [@kentongray](https://github.com/kentongray)
+
+* Use final output image for metadata passed to callback.
+  [#399](https://github.com/lovell/sharp/pull/399)
+  [@salzhrani](https://github.com/salzhrani)
+
+* Add support for writing tiled images to a zip container.
+  [#402](https://github.com/lovell/sharp/pull/402)
+  [@felixbuenemann](https://github.com/felixbuenemann)
+
+* Allow use of embed with 1 and 2 channel images.
+  [#411](https://github.com/lovell/sharp/issues/411)
+  [@janaz](https://github.com/janaz)
+
+* Improve Electron compatibility by allowing node-gyp rebuilds without npm.
+  [#412](https://github.com/lovell/sharp/issues/412)
+  [@nouh](https://github.com/nouh)
+
+#### v0.14.0 - 2<sup>nd</sup> April 2016
+
+* Add ability to extend (pad) the edges of an image.
+  [#128](https://github.com/lovell/sharp/issues/128)
+  [@blowsie](https://github.com/blowsie)
+
+* Add support for Zoomify and Google tile layouts. Breaks existing tile API.
+  [#223](https://github.com/lovell/sharp/issues/223)
+  [@bdunnette](https://github.com/bdunnette)
+
+* Improvements to overlayWith: differing sizes/formats, gravity, buffer input.
+  [#239](https://github.com/lovell/sharp/issues/239)
+  [@chrisriley](https://github.com/chrisriley)
+
+* Add entropy-based crop strategy to remove least interesting edges.
+  [#295](https://github.com/lovell/sharp/issues/295)
+  [@rightaway](https://github.com/rightaway)
+
+* Expose density metadata; set density of images from vector input.
+  [#338](https://github.com/lovell/sharp/issues/338)
+  [@lookfirst](https://github.com/lookfirst)
+
+* Emit post-processing 'info' event for Stream output.
+  [#367](https://github.com/lovell/sharp/issues/367)
+  [@salzhrani](https://github.com/salzhrani)
+
+* Ensure output image EXIF Orientation values are within 1-8 range.
+  [#385](https://github.com/lovell/sharp/pull/385)
+  [@jtobinisaniceguy](https://github.com/jtobinisaniceguy)
+
+* Ensure ratios are not swapped when rotating 90/270 and ignoring aspect.
+  [#387](https://github.com/lovell/sharp/issues/387)
+  [@kleisauke](https://github.com/kleisauke)
+
+* Remove deprecated style of calling extract API. Breaks calls using positional arguments.
+  [#276](https://github.com/lovell/sharp/issues/276)
+
+### v0.13 - "*mind*"
+
+Requires libvips v8.2.2
+
+#### v0.13.1 - 27<sup>th</sup> February 2016
+
+* Fix embedding onto transparent backgrounds; regression introduced in v0.13.0.
+  [#366](https://github.com/lovell/sharp/issues/366)
+  [@diegocsandrim](https://github.com/diegocsandrim)
+
+#### v0.13.0 - 15<sup>th</sup> February 2016
+
+* Improve vector image support by allowing control of density/DPI.
+  Switch pre-built libs from Imagemagick to Graphicsmagick.
+  [#110](https://github.com/lovell/sharp/issues/110)
+  [@bradisbell](https://github.com/bradisbell)
+
+* Add support for raw, uncompressed pixel Buffer/Stream input.
+  [#220](https://github.com/lovell/sharp/issues/220)
+  [@mikemorris](https://github.com/mikemorris)
+
+* Switch from libvips' C to C++ bindings, requires upgrade to v8.2.2.
+  [#299](https://github.com/lovell/sharp/issues/299)
+
+* Control number of open files in libvips' cache; breaks existing `cache` behaviour.
+  [#315](https://github.com/lovell/sharp/issues/315)
+  [@impomezia](https://github.com/impomezia)
+
+* Ensure 16-bit input images can be normalised and embedded onto transparent backgrounds.
+  [#339](https://github.com/lovell/sharp/issues/339)
+  [#340](https://github.com/lovell/sharp/issues/340)
+  [@janaz](https://github.com/janaz)
+
+* Ensure selected format takes precedence over any unknown output filename extension.
+  [#344](https://github.com/lovell/sharp/issues/344)
+  [@ubaltaci](https://github.com/ubaltaci)
+
+* Add support for libvips' PBM, PGM, PPM and FITS image format loaders.
+  [#347](https://github.com/lovell/sharp/issues/347)
+  [@oaleynik](https://github.com/oaleynik)
+
+* Ensure default crop gravity is center/centre.
+  [#351](https://github.com/lovell/sharp/pull/351)
+  [@joelmukuthu](https://github.com/joelmukuthu)
+
+* Improve support for musl libc systems e.g. Alpine Linux.
+  [#354](https://github.com/lovell/sharp/issues/354)
+  [#359](https://github.com/lovell/sharp/pull/359)
+  [@download13](https://github.com/download13)
+  [@wjordan](https://github.com/wjordan)
+
+* Small optimisation when reducing by an integral factor to favour shrink over affine.
+
+* Add support for gamma correction of images with an alpha channel.
+
+### v0.12 - "*look*"
+
+Requires libvips v8.2.0
+
+#### v0.12.2 - 16<sup>th</sup> January 2016
+
+* Upgrade libvips to v8.2.0 for improved vips_shrink.
+
+* Add pre-compiled libvips for ARMv6+ CPUs.
+
+* Ensure 16-bit input images work with embed option.
+  [#325](https://github.com/lovell/sharp/issues/325)
+  [@janaz](https://github.com/janaz)
+
+* Allow compilation with gmake to provide FreeBSD support.
+  [#326](https://github.com/lovell/sharp/issues/326)
+  [@c0decafe](https://github.com/c0decafe)
+
+* Attempt to remove temporary file after installation.
+  [#331](https://github.com/lovell/sharp/issues/331)
+  [@dtoubelis](https://github.com/dtoubelis)
+
+#### v0.12.1 - 12<sup>th</sup> December 2015
+
+* Allow use of SIMD vector instructions (via liborc) to be toggled on/off.
+  [#172](https://github.com/lovell/sharp/issues/172)
+  [@bkw](https://github.com/bkw)
+  [@puzrin](https://github.com/puzrin)
+
+* Ensure embedded ICC profiles output with perceptual intent.
+  [#321](https://github.com/lovell/sharp/issues/321)
+  [@vlapo](https://github.com/vlapo)
+
+* Use the NPM-configured HTTPS proxy, if any, for binary downloads.
+
+#### v0.12.0 - 23<sup>rd</sup> November 2015
+
+* Bundle pre-compiled libvips and its dependencies for 64-bit Linux and Windows.
+  [#42](https://github.com/lovell/sharp/issues/42)
+
+* Take advantage of libvips v8.1.0+ features.
+  [#152](https://github.com/lovell/sharp/issues/152)
+
+* Add support for 64-bit Windows. Drop support for 32-bit Windows.
+  [#224](https://github.com/lovell/sharp/issues/224)
+  [@sabrehagen](https://github.com/sabrehagen)
+
+* Switch default interpolator to bicubic.
+  [#289](https://github.com/lovell/sharp/issues/289)
+  [@mahnunchik](https://github.com/mahnunchik)
+
+* Pre-extract rotatation should not swap width/height.
+  [#296](https://github.com/lovell/sharp/issues/296)
+  [@asilvas](https://github.com/asilvas)
+
+* Ensure 16-bit+alpha input images are (un)premultiplied correctly.
+  [#301](https://github.com/lovell/sharp/issues/301)
+  [@izaakschroeder](https://github.com/izaakschroeder)
+
+* Add `threshold` operation.
+  [#303](https://github.com/lovell/sharp/pull/303)
+  [@dacarley](https://github.com/dacarley)
+
+* Add `negate` operation.
+  [#306](https://github.com/lovell/sharp/pull/306)
+  [@dacarley](https://github.com/dacarley)
+
+* Support `options` Object with existing `extract` operation.
+  [#309](https://github.com/lovell/sharp/pull/309)
+  [@papandreou](https://github.com/papandreou)
+
+### v0.11 - "*knife*"
+
+#### v0.11.4 - 5<sup>th</sup> November 2015
+
+* Add corners, e.g. `northeast`, to existing `gravity` option.
+  [#291](https://github.com/lovell/sharp/pull/291)
+  [@brandonaaron](https://github.com/brandonaaron)
+
+* Ensure correct auto-rotation for EXIF Orientation values 2 and 4.
+  [#288](https://github.com/lovell/sharp/pull/288)
+  [@brandonaaron](https://github.com/brandonaaron)
+
+* Make static linking possible via `--runtime_link` install option.
+  [#287](https://github.com/lovell/sharp/pull/287)
+  [@vlapo](https://github.com/vlapo)
+
+#### v0.11.3 - 8<sup>th</sup> September 2015
+
+* Intrepret blurSigma, sharpenFlat, and sharpenJagged as double precision.
+  [#263](https://github.com/lovell/sharp/pull/263)
+  [@chrisriley](https://github.com/chrisriley)
+
+#### v0.11.2 - 28<sup>th</sup> August 2015
+
+* Allow crop gravity to be provided as a String.
+  [#255](https://github.com/lovell/sharp/pull/255)
+  [@papandreou](https://github.com/papandreou)
+* Add support for io.js v3 and Node v4.
+  [#246](https://github.com/lovell/sharp/issues/246)
+
+#### v0.11.1 - 12<sup>th</sup> August 2015
+
+* Silence MSVC warning: "C4530: C++ exception handler used, but unwind semantics are not enabled".
+  [#244](https://github.com/lovell/sharp/pull/244)
+  [@TheThing](https://github.com/TheThing)
+
+* Suppress gamma correction for input image with alpha transparency.
+  [#249](https://github.com/lovell/sharp/issues/249)
+  [@compeak](https://github.com/compeak)
+
+#### v0.11.0 - 15<sup>th</sup> July 2015
+
+* Allow alpha transparency compositing via new `overlayWith` method.
+  [#97](https://github.com/lovell/sharp/issues/97)
+  [@gasi](https://github.com/gasi)
+
+* Expose raw ICC profile data as a Buffer when using `metadata`.
+  [#129](https://github.com/lovell/sharp/issues/129)
+  [@homerjam](https://github.com/homerjam)
+
+* Allow image header updates via a parameter passed to existing `withMetadata` method.
+  Provide initial support for EXIF `Orientation` tag,
+  which if present is now removed when using `rotate`, `flip` or `flop`.
+  [#189](https://github.com/lovell/sharp/issues/189)
+  [@h2non](https://github.com/h2non)
+
+* Tighten constructor parameter checks.
+  [#221](https://github.com/lovell/sharp/issues/221)
+  [@mikemorris](https://github.com/mikemorris)
+
+* Allow one input Stream to be shared with two or more output Streams via new `clone` method.
+  [#235](https://github.com/lovell/sharp/issues/235)
+  [@jaubourg](https://github.com/jaubourg)
+
+* Use `round` instead of `floor` when auto-scaling dimensions to avoid floating-point rounding errors.
+  [#238](https://github.com/lovell/sharp/issues/238)
+  [@richardadjogah](https://github.com/richardadjogah)
+
+### v0.10 - "*judgment*"
+
+#### v0.10.1 - 1<sup>st</sup> June 2015
+
+* Allow embed of image with alpha transparency onto non-transparent background.
+  [#204](https://github.com/lovell/sharp/issues/204)
+  [@mikemliu](https://github.com/mikemliu)
+
+* Include C standard library for `atoi` as Xcode 6.3 appears to no longer do this.
+  [#228](https://github.com/lovell/sharp/issues/228)
+  [@doggan](https://github.com/doggan)
+
+#### v0.10.0 - 23<sup>rd</sup> April 2015
+
+* Add support for Windows (x86).
+  [#19](https://github.com/lovell/sharp/issues/19)
+  [@DullReferenceException](https://github.com/DullReferenceException)
+  [@itsananderson](https://github.com/itsananderson)
+
+* Add support for Openslide input and DeepZoom output.
+  [#146](https://github.com/lovell/sharp/issues/146)
+  [@mvictoras](https://github.com/mvictoras)
+
+* Allow arbitrary aspect ratios when resizing images via new `ignoreAspectRatio` method.
+  [#192](https://github.com/lovell/sharp/issues/192)
+  [@skedastik](https://github.com/skedastik)
+
+* Enhance output image contrast by stretching its luminance to cover the full dynamic range via new `normalize` method.
+  [#194](https://github.com/lovell/sharp/issues/194)
+  [@bkw](https://github.com/bkw)
+  [@codingforce](https://github.com/codingforce)

docs/index.md

@@ -0,0 +1,113 @@
+# 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.
+
+Resizing an image is typically 4x-5x faster than using the
+quickest ImageMagick and GraphicsMagick settings.
+
+Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
+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.
+
+OS X, Windows (x64), Linux (x64, ARM) systems do not require
+the installation of any external runtime dependencies.
+
+[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
+
+### Formats
+
+This module supports reading JPEG, PNG, WebP, TIFF, GIF and SVG images.
+
+Output images can be in JPEG, PNG and WebP formats as well as uncompressed raw pixel data.
+
+Streams, Buffer objects and the filesystem can be used for input and output.
+
+A single input Stream can be split into multiple processing pipelines and output Streams.
+
+Deep Zoom image pyramids can be generated,
+suitable for use with "slippy map" tile viewers like
+[OpenSeadragon](https://github.com/openseadragon/openseadragon)
+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,
+originally created in 1989 at Birkbeck College
+and currently maintained by
+[John Cupitt](https://github.com/jcupitt).
+
+Only small regions of uncompressed image data
+are held in memory and processed at a time,
+taking full advantage of multiple CPU cores and L1/L2/L3 cache.
+
+Everything remains non-blocking thanks to _libuv_,
+no child processes are spawned and Promises/A+ are supported.
+
+### Optimal
+
+Huffman tables are optimised when generating JPEG output images
+without having to use separate command line tools like
+[jpegoptim](https://github.com/tjko/jpegoptim) and
+[jpegtran](http://jpegclub.org/jpegtran/).
+
+PNG filtering can be disabled,
+which for diagrams and line art often produces the same result
+as [pngcrush](http://pmt.sourceforge.net/pngcrush/).
+
+### Contributing
+
+A [guide for contributors](https://github.com/lovell/sharp/blob/master/CONTRIBUTING.md)
+covers reporting bugs, requesting features and submitting code changes.
+
+### Credits
+
+This module would never have been possible without
+the help and code contributions of the following people:
+
+* [John Cupitt](https://github.com/jcupitt)
+* [Pierre Inglebert](https://github.com/pierreinglebert)
+* [Jonathan Ong](https://github.com/jonathanong)
+* [Chanon Sajjamanochai](https://github.com/chanon)
+* [Juliano Julio](https://github.com/julianojulio)
+* [Daniel Gasienica](https://github.com/gasi)
+* [Julian Walker](https://github.com/julianwa)
+* [Amit Pitaru](https://github.com/apitaru)
+* [Brandon Aaron](https://github.com/brandonaaron)
+* [Andreas Lind](https://github.com/papandreou)
+* [Maurus Cuelenaere](https://github.com/mcuelenaere)
+* [Linus Unnebäck](https://github.com/LinusU)
+* [Victor Mateevitsi](https://github.com/mvictoras)
+* [Alaric Holloway](https://github.com/skedastik)
+* [Bernhard K. Weisshuhn](https://github.com/bkw)
+* [David A. Carley](https://github.com/dacarley)
+* [John Tobin](https://github.com/jtobinisaniceguy)
+* [Kenton Gray](https://github.com/kentongray)
+* [Felix Bünemann](https://github.com/felixbuenemann)
+* [Samy Al Zahrani](https://github.com/salzhrani)
+* [Chintan Thakkar](https://github.com/lemnisk8)
+* [F. Orlando Galashan](https://github.com/frulo)
+* [Kleis Auke Wolthuizen](https://github.com/kleisauke)
+* [Matt Hirsch](https://github.com/mhirsch)
+* [Rahul Nanwani](https://github.com/rnanwani)
+
+Thank you!
+
+### Licence
+
+Copyright 2013, 2014, 2015, 2016 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)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

docs/install.md

@@ -0,0 +1,216 @@
+# Installation
+
+```sh
+npm install sharp
+```
+
+### Prerequisites
+
+* 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
+
+### Linux
+
+[![Ubuntu 14.04 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
+[![Linux Build Status](https://circleci.com/gh/lovell/sharp.svg?style=svg&circle-token=6cb6d1d287a51af83722b19ed8885377fbc85e5c)](https://circleci.com/gh/lovell/sharp)
+
+libvips and its dependencies are fetched and stored within `node_modules/sharp/lib` during `npm install`.
+This involves an automated HTTPS download of approximately 6.5MB.
+
+Most recent Linux-based operating systems with glibc running on x64 and ARMv6+ CPUs should "just work", e.g.:
+
+* Debian 7, 8
+* Ubuntu 12.04, 14.04, 16.04
+* Centos 7
+* Fedora 23, 24
+* openSUSE 13.2
+* Archlinux
+* Raspbian Jessie
+* Amazon Linux 2016.03, 2016.09
+
+To use a globally-installed 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 that it can be located using `pkg-config --modversion vips-cpp`.
+
+If you are using non-stadard paths (anything other than `/usr` or `/usr/local`),
+you might need to set `PKG_CONFIG_PATH` during `npm install`
+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,
+a system-wide installation of the most suitable version of
+libvips and its dependencies can be achieved by running
+the following command as a user with `sudo` access
+(requires `curl` and `pkg-config`):
+
+```sh
+# WARNING: This script is deprecated. You probably don't need to run it. Please read above.
+curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -
+```
+
+For Linux-based operating systems such as Alpine that use musl libc,
+the smaller stack size means libvips' cache should be disabled
+via `sharp.cache(false)` to avoid a stack overflow.
+
+### Mac OS
+
+[![OS X 10.9.5 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/lib` during `npm install`.
+This involves an automated HTTPS download of approximately 6.5MB.
+
+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
+that it can be located using `pkg-config --modversion vips-cpp`.
+
+### Windows x64
+
+[![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` during `npm install`.
+This involves an automated HTTPS download of approximately 9MB.
+
+Only 64-bit (x64) `node.exe` is supported.
+
+### FreeBSD
+
+libvips must be installed before `npm install` is run.
+This can be achieved via [FreshPorts](https://www.freshports.org/graphics/vips/):
+
+```sh
+cd /usr/ports/graphics/vips/ && make install clean
+```
+
+### Heroku
+
+[Alessandro Tagliapietra](https://github.com/alex88) maintains an
+[Heroku buildpack for libvips](https://github.com/alex88/heroku-buildpack-vips)
+and its dependencies.
+
+### Docker
+
+[Marc Bachmann](https://github.com/marcbachmann) maintains an
+[Ubuntu-based Dockerfile for libvips](https://github.com/marcbachmann/dockerfile-libvips).
+
+```sh
+docker pull marcbachmann/libvips
+```
+
+[Will Jordan](https://github.com/wjordan) maintains an
+[Alpine-based Dockerfile for libvips](https://github.com/wjordan/dockerfile-libvips).
+
+```sh
+docker pull wjordan/libvips
+```
+
+### AWS Lambda
+
+In order to use sharp on AWS Lambda, you need to [create a deployment package](http://docs.aws.amazon.com/lambda/latest/dg/nodejs-create-deployment-pkg.html). Because sharp
+downloads and links libraries for the current platform during `npm install` you have to
+do this on a system similar to the [Lambda Execution Environment](http://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html). The easiest ways to do this, is to setup a
+small t2.micro instance using the AMI ID listed in the previous link, ssh into it as ec2-user
+and follow the instructions below.
+
+Install dependencies:
+
+```sh
+curl -s https://rpm.nodesource.com/setup_4.x | sudo bash -
+sudo yum install -y gcc-c++ nodejs
+```
+
+Copy your code and package.json to the instance using `scp` and create a deployment package:
+
+```sh
+cd sharp-lambda-example
+npm install
+zip -ur9 ../sharp-lambda-example.zip index.js node_modules
+```
+
+You can now download your deployment ZIP using `scp` and upload it to Lambda. Be sure to set your Lambda runtime to Node.js 4.3.
+
+**Performance Tip:** To get the best performance on Lambda choose the largest memory available because this also gives you the most cpu time (a 1536 MB function is 12x faster than a 128 MB function).
+
+### Build tools
+
+* [gulp-responsive](https://www.npmjs.com/package/gulp-responsive)
+* [grunt-sharp](https://www.npmjs.com/package/grunt-sharp)
+
+### Security
+
+Many users of this module process untrusted, user-supplied images,
+but there are aspects of security to consider when doing so.
+
+It is possible to compile libvips with support for various third-party image loaders.
+Each of these libraries has undergone differing levels of security testing.
+
+Whilst tools such as [American Fuzzy Lop](http://lcamtuf.coredump.cx/afl/)
+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.
+
+### Licences
+
+If a global installation of libvips that meets the
+minimum version requirement cannot be found,
+this module will download a pre-compiled bundle of libvips
+and its dependencies on Linux and Windows machines.
+
+Should you need to manually download and inspect these files,
+you can do so via https://dl.bintray.com/lovell/sharp/
+
+This module is licensed under the terms of the
+[Apache 2.0 Licence](https://github.com/lovell/sharp/blob/master/LICENSE).
+
+The libraries downloaded and used by this module
+are done so under the terms of the following licences,
+all of which are compatible with the Apache 2.0 Licence.
+
+Use of libraries under the terms of the LGPLv3 is via the
+"any later version" clause of the LGPLv2 or LGPLv2.1.
+
+| Library       | Used under the terms of                                                                                  |
+|---------------|----------------------------------------------------------------------------------------------------------|
+| cairo         | Mozilla Public License 2.0                                                                               |
+| 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) |
+| giflib        | MIT Licence                                                                                              |
+| glib          | LGPLv3                                                                                                   |
+| harfbuzz      | MIT Licence                                                                                              |
+| lcms          | MIT Licence                                                                                              |
+| libcroco      | LGPLv3                                                                                                   |
+| libexif       | LGPLv3                                                                                                   |
+| libffi        | MIT Licence                                                                                              |
+| libgsf        | LGPLv3                                                                                                   |
+| libjpeg-turbo | [zlib License, IJG License](https://github.com/libjpeg-turbo/libjpeg-turbo/blob/master/LICENSE.md)       |
+| libpng        | [libpng License](http://www.libpng.org/pub/png/src/libpng-LICENSE.txt)                                   |
+| librsvg       | LGPLv3                                                                                                   |
+| libtiff       | [libtiff License](http://www.libtiff.org/misc.html) (BSD-like)                                           |
+| libvips       | LGPLv3                                                                                                   |
+| libwebp       | New BSD License                                                                                          |
+| libxml2       | MIT Licence                                                                                              |
+| pango         | LGPLv3                                                                                                   |
+| pixman        | MIT Licence                                                                                              |
+| zlib          | [zlib Licence](https://github.com/madler/zlib/blob/master/zlib.h)                                        |

docs/performance.md

@@ -0,0 +1,73 @@
+# Performance
+
+### Test environment
+
+* AWS EC2 [c4.xlarge](http://aws.amazon.com/ec2/instance-types/#c4) (4x E5-2666 v3 @ 2.90GHz)
+* Amazon Linux AMI 2016.03.1 (HVM), SSD Volume Type
+* Node.js v6.2.0
+
+### The contenders
+
+* [jimp](https://www.npmjs.com/package/jimp) v0.2.24 - Image processing in pure JavaScript. Bilinear interpolation only.
+* [lwip](https://www.npmjs.com/package/lwip) v0.0.9 - Wrapper around CImg, compiles dependencies from source.
+* [imagemagick-native](https://www.npmjs.com/package/imagemagick-native) v1.9.2 - 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.22.0 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
+* sharp v0.15.0 / libvips v8.3.1 - Caching within libvips disabled to ensure a fair comparison.
+
+### The task
+
+Decompress a 2725x2225 JPEG image,
+resize to 720x480 using Lanczos 3 resampling (where available),
+then compress to JPEG.
+
+### Results
+
+| Module             | Input  | Output | Ops/sec | Speed-up |
+| :----------------- | :----- | :----- | ------: | -------: |
+| jimp (bilinear)    | file   | file   |    0.94 |      1.0 |
+| jimp (bilinear)    | buffer | buffer |    0.98 |      1.0 |
+| lwip               | file   | file   |    1.14 |      1.2 |
+| lwip               | buffer | buffer |    1.14 |      1.2 |
+| imagemagick-native | buffer | buffer |    1.66 |      1.8 |
+| imagemagick        | file   | file   |    5.08 |      5.4 |
+| gm                 | buffer | buffer |    5.43 |      5.7 |
+| gm                 | file   | file   |    5.46 |      5.8 |
+| sharp              | stream | stream |   26.52 |     28.2 |
+| sharp              | file   | file   |   28.16 |     30.0 |
+| sharp              | file   | buffer |   28.27 |     30.1 |
+| sharp              | buffer | file   |   28.42 |     30.2 |
+| sharp              | buffer | buffer |   28.42 |     30.2 |
+
+Greater libvips performance can be expected with caching enabled (default)
+and using 8+ core machines, especially those with larger L1/L2 CPU caches.
+
+The I/O limits of the relevant (de)compression library will generally determine maximum throughput.
+
+### Benchmark test prerequisites
+
+Requires both _ImageMagick_ and _GraphicsMagick_:
+
+```sh
+brew install imagemagick
+brew install graphicsmagick
+```
+
+```sh
+sudo apt-get install imagemagick libmagick++-dev graphicsmagick
+```
+
+```sh
+sudo yum install ImageMagick-devel ImageMagick-c++-devel GraphicsMagick
+```
+
+### Running the benchmark test
+
+```sh
+git clone https://github.com/lovell/sharp.git
+cd sharp
+npm install
+cd test/bench
+npm install
+npm test
+```

mkdocs.yml

@@ -0,0 +1,17 @@
+site_name: sharp
+site_url: http://sharp.dimens.io/
+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://dimens.io/">dimens.io</a>
+google_analytics: ['UA-13034748-12', 'sharp.dimens.io']
+theme: readthedocs
+markdown_extensions:
+  - toc:
+      permalink: True
+dev_addr: 0.0.0.0:10101
+pages:
+  - Home: index.md
+  - Installation: install.md
+  - API: api.md
+  - Performance: performance.md
+  - Changelog: changelog.md

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharp",
-  "version": "0.8.0",
+  "version": "0.16.2",
   "author": "Lovell Fuller <npm@lovell.info>",
   "contributors": [
     "Pierre Inglebert <pierre.inglebert@gmail.com>",
@@ -11,11 +11,32 @@
     "Julian Walker <julian@fiftythree.com>",
     "Amit Pitaru <pitaru.amit@gmail.com>",
     "Brandon Aaron <hello.brandon@aaron.sh>",
-    "Andreas Lind <andreas@one.com>"
+    "Andreas Lind <andreas@one.com>",
+    "Maurus Cuelenaere <mcuelenaere@gmail.com>",
+    "Linus Unnebäck <linus@folkdatorn.se>",
+    "Victor Mateevitsi <mvictoras@gmail.com>",
+    "Alaric Holloway <alaric.holloway@gmail.com>",
+    "Bernhard K. Weisshuhn <bkw@codingforce.com>",
+    "Chris Riley <criley@primedia.com>",
+    "David Carley <dacarley@gmail.com>",
+    "John Tobin <john@limelightmobileinc.com>",
+    "Kenton Gray <kentongray@gmail.com>",
+    "Felix Bünemann <Felix.Buenemann@gmail.com>",
+    "Samy Al Zahrani <samyalzahrany@gmail.com>",
+    "Chintan Thakkar <lemnisk8@gmail.com>",
+    "F. Orlando Galashan <frulo@gmx.de>",
+    "Kleis Auke Wolthuizen <info@kleisauke.nl>",
+    "Matt Hirsch <mhirsch@media.mit.edu>",
+    "Matthias Thoemmes <thoemmes@gmail.com>"
   ],
-  "description": "High performance Node.js module to resize JPEG, PNG, WebP and TIFF images using the libvips library",
+  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images",
   "scripts": {
-    "test": "node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- --slow=5000 --timeout=10000 ./test/unit/*.js"
+    "clean": "rm -rf node_modules/ build/ include/ lib/ coverage/ test/fixtures/output.*",
+    "test": "VIPS_WARNING=0 node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- --slow=5000 --timeout=30000 ./test/unit/*.js",
+    "test-win": "node ./node_modules/mocha/bin/mocha --slow=5000 --timeout=60000 ./test/unit/*.js",
+    "test-leak": "./test/leak/leak.sh",
+    "test-packaging": "./packaging/test-linux-x64.sh",
+    "test-clean": "rm -rf coverage/ test/fixtures/output.* && npm install && npm test"
   },
   "main": "index.js",
   "repository": {
@@ -28,29 +49,40 @@
     "webp",
     "tiff",
     "gif",
+    "svg",
+    "dzi",
+    "image",
     "resize",
     "thumbnail",
-    "sharpen",
     "crop",
-    "extract",
-    "embed",
     "libvips",
-    "vips",
-    "stream"
+    "vips"
   ],
   "dependencies": {
-    "bluebird": "^2.3.11",
-    "color": "^0.7.1",
-    "nan": "^1.4.1",
-    "semver": "^4.1.0"
+    "bluebird": "^3.4.6",
+    "color": "^0.11.3",
+    "nan": "^2.4.0",
+    "semver": "^5.3.0",
+    "request": "^2.75.0",
+    "tar": "^2.2.1"
   },
   "devDependencies": {
-    "mocha": "^2.0.1",
-    "mocha-jshint": "^0.0.9",
-    "istanbul": "^0.3.2",
-    "coveralls": "^2.11.2"
+    "async": "^2.1.2",
+    "bufferutil": "^1.2.1",
+    "coveralls": "^2.11.14",
+    "exif-reader": "^1.0.1",
+    "icc": "^0.0.2",
+    "istanbul": "^0.4.5",
+    "mocha": "^3.1.2",
+    "mocha-jshint": "^2.3.1",
+    "node-cpplint": "^0.4.0",
+    "rimraf": "^2.5.4",
+    "unzip": "^0.1.11"
+  },
+  "license": "Apache-2.0",
+  "config": {
+    "libvips": "8.3.3"
   },
-  "license": "Apache 2.0",
   "engines": {
     "node": ">=0.10"
   }

packaging/README.md

@@ -0,0 +1,57 @@
+# Packaging scripts
+
+libvips and its dependencies are provided as pre-compiled shared libraries
+for the most common operating systems and CPU architectures.
+
+During `npm install`, these binaries are fetched as tarballs from
+[Bintray](https://dl.bintray.com/lovell/sharp/) via HTTPS
+and stored locally within `node_modules/sharp`.
+
+## Using a custom tarball
+
+A custom tarball stored on the local filesystem can be used instead.
+Place it in the following location, where `x.y.z` is the libvips version,
+`platform` is the value of `process.platform` and
+`arch` is the value of `process.arch` (plus the version number for ARM).
+
+`node_modules/sharp/packaging/libvips-x.y.z-platform-arch.tar.gz`
+
+For example, for libvips v8.3.3 on an ARMv6 Linux machine, use:
+
+`node_modules/sharp/packaging/libvips-8.3.3-linux-armv6.tar.gz`
+
+Remove any `sharp/lib` and `sharp/include` directories
+before running `npm install` again.
+
+## Creating a tarball
+
+Most people will not need to do this; proceed with caution.
+
+The `packaging` directory contains the top-level [build script](build.sh).
+
+### Linux
+
+One [build script](build/lin.sh) is used to (cross-)compile
+the same shared libraries within multiple containers.
+
+* [x64](linux-x64/Dockerfile)
+* [ARMv6](linux-armv6/Dockerfile)
+* [ARMv7-A](linux-armv7/Dockerfile)
+* [ARMv8-A](linux-armv8/Dockerfile)
+
+The QEMU user mode emulation binaries are required to build for
+the ARMv6 platform as the Debian armhf cross-compiler erroneously
+generates unsupported Thumb 2 instructions.
+
+```sh
+sudo apt-get install qemu-user-static
+```
+
+### Windows
+
+The output of libvips' [build-win64](https://github.com/jcupitt/build-win64)
+"web" target is [post-processed](build/win.sh) within a [container](win32-x64/Dockerfile).
+
+### OS X
+
+See [package-libvips-darwin](https://github.com/lovell/package-libvips-darwin).

packaging/build.sh

@@ -0,0 +1,43 @@
+#!/bin/sh
+set -e
+
+if [ $# -lt 1 ]; then
+  echo
+  echo "Usage: $0 VERSION [PLATFORM]"
+  echo "Build shared libraries for libvips and its dependencies via containers"
+  echo
+  echo "Please specify the libvips VERSION, e.g. 8.3.3"
+  echo
+  echo "Optionally build for only one PLATFORM, defaults to building for all"
+  echo "Possible values for PLATFORM are: win32-x64, linux-x64, linux-armv6,"
+  echo "linux-armv7, linux-armv8"
+  echo
+  exit 1
+fi
+VERSION_VIPS="$1"
+PLATFORM="${2:-all}"
+
+# Is docker available?
+if ! type docker >/dev/null; then
+  echo "Please install docker"
+  exit 1
+fi
+
+# Windows (x64)
+if [ $PLATFORM = "all" ] || [ $PLATFORM = "win32-x64" ]; then
+  echo "Building win32-x64..."
+  docker build -t vips-dev-win32-x64 win32-x64
+  docker run --rm -e "VERSION_VIPS=${VERSION_VIPS}" -v $PWD:/packaging vips-dev-win32-x64 sh -c "/packaging/build/win.sh"
+fi
+
+# Linux (x64, ARMv6, ARMv7, ARMv8)
+for flavour in linux-x64 linux-armv6 linux-armv7 linux-armv8; do
+  if [ $PLATFORM = "all" ] || [ $PLATFORM = $flavour ]; then
+    echo "Building $flavour..."
+    docker build -t vips-dev-$flavour $flavour
+    docker run --rm -e "VERSION_VIPS=${VERSION_VIPS}" -v $PWD:/packaging vips-dev-$flavour sh -c "/packaging/build/lin.sh"
+  fi
+done
+
+# Display checksums
+sha256sum *.tar.gz

packaging/build/lin.sh

@@ -0,0 +1,236 @@
+#!/bin/sh
+set -e
+
+# Working directories
+DEPS=/deps
+TARGET=/target
+mkdir ${DEPS}
+mkdir ${TARGET}
+
+# Common build paths and flags
+export PKG_CONFIG_PATH="${PKG_CONFIG_PATH}:${TARGET}/lib/pkgconfig"
+export PATH="${PATH}:${TARGET}/bin"
+export CPPFLAGS="-I${TARGET}/include"
+export LDFLAGS="-L${TARGET}/lib"
+export CFLAGS="${FLAGS}"
+export CXXFLAGS="${FLAGS}"
+
+# Dependency version numbers
+VERSION_ZLIB=1.2.8
+VERSION_FFI=3.2.1
+VERSION_GLIB=2.49.4
+VERSION_XML2=2.9.4
+VERSION_GSF=1.14.39
+VERSION_EXIF=0.6.21
+VERSION_LCMS2=2.8
+VERSION_JPEG=1.5.0
+VERSION_PNG16=1.6.25
+VERSION_WEBP=0.5.1
+VERSION_TIFF=4.0.6
+VERSION_ORC=0.4.25
+VERSION_GDKPIXBUF=2.35.2
+VERSION_FREETYPE=2.6.5
+VERSION_FONTCONFIG=2.12.0
+VERSION_HARFBUZZ=1.3.0
+VERSION_PIXMAN=0.34.0
+VERSION_CAIRO=1.14.6
+VERSION_PANGO=1.40.1
+VERSION_CROCO=0.6.11
+VERSION_SVG=2.40.16
+VERSION_GIF=5.1.4
+
+# Least out-of-sync Sourceforge mirror
+SOURCEFORGE_MIRROR=netix
+
+mkdir ${DEPS}/zlib
+curl -Ls http://zlib.net/zlib-${VERSION_ZLIB}.tar.xz | tar xJC ${DEPS}/zlib --strip-components=1
+cd ${DEPS}/zlib
+./configure --prefix=${TARGET} --uname=linux
+make install
+rm ${TARGET}/lib/libz.a
+
+mkdir ${DEPS}/ffi
+curl -Ls ftp://sourceware.org/pub/libffi/libffi-${VERSION_FFI}.tar.gz | tar xzC ${DEPS}/ffi --strip-components=1
+cd ${DEPS}/ffi
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-builddir
+make install-strip
+
+mkdir ${DEPS}/glib
+curl -Ls https://download.gnome.org/sources/glib/2.49/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
+cd ${DEPS}/glib
+echo glib_cv_stack_grows=no >>glib.cache
+echo glib_cv_uscore=no >>glib.cache
+./configure --cache-file=glib.cache --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-pcre=internal
+make install-strip
+
+mkdir ${DEPS}/xml2
+curl -Ls http://xmlsoft.org/sources/libxml2-${VERSION_XML2}.tar.gz | tar xzC ${DEPS}/xml2 --strip-components=1
+cd ${DEPS}/xml2
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --without-python --without-debug --without-docbook --without-ftp --without-html --without-legacy \
+  --without-pattern --without-push --without-regexps --without-schemas --without-schematron --with-zlib=${TARGET}
+make install-strip
+
+mkdir ${DEPS}/gsf
+curl -Ls https://download.gnome.org/sources/libgsf/1.14/libgsf-${VERSION_GSF}.tar.xz | tar xJC ${DEPS}/gsf --strip-components=1
+cd ${DEPS}/gsf
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/exif
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
+cd ${DEPS}/exif
+autoreconf -fiv
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/lcms2
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
+cd ${DEPS}/lcms2
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/jpeg
+curl -Ls https://github.com/libjpeg-turbo/libjpeg-turbo/archive/${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
+cd ${DEPS}/jpeg
+autoreconf -fiv
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg
+make install-strip
+
+mkdir ${DEPS}/png16
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
+cd ${DEPS}/png16
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/webp
+curl -Ls http://downloads.webmproject.org/releases/webp/libwebp-${VERSION_WEBP}.tar.gz | tar xzC ${DEPS}/webp --strip-components=1
+cd ${DEPS}/webp
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-neon
+make install-strip
+
+mkdir ${DEPS}/tiff
+curl -Ls http://download.osgeo.org/libtiff/tiff-${VERSION_TIFF}.tar.gz | tar xzC ${DEPS}/tiff --strip-components=1
+cd ${DEPS}/tiff
+if [ -n "${CHOST}" ]; then autoreconf -fiv; fi
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-mdi --disable-cxx
+make install-strip
+
+mkdir ${DEPS}/orc
+curl -Ls http://gstreamer.freedesktop.org/data/src/orc/orc-${VERSION_ORC}.tar.xz | tar xJC ${DEPS}/orc --strip-components=1
+cd ${DEPS}/orc
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+cd ${TARGET}/lib
+rm -rf liborc-test-*
+
+mkdir ${DEPS}/gdkpixbuf
+curl -Ls https://download.gnome.org/sources/gdk-pixbuf/2.35/gdk-pixbuf-${VERSION_GDKPIXBUF}.tar.xz | tar xJC ${DEPS}/gdkpixbuf --strip-components=1
+cd ${DEPS}/gdkpixbuf
+LD_LIBRARY_PATH=${TARGET}/lib \
+./configure --cache-file=gdkpixbuf.cache --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-introspection --disable-modules --disable-gio-sniffing --without-libpng --without-libjpeg --without-libtiff --without-gdiplus --with-included-loaders=
+make install-strip
+
+mkdir ${DEPS}/freetype
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/freetype/freetype2/${VERSION_FREETYPE}/freetype-${VERSION_FREETYPE}.tar.gz | tar xzC ${DEPS}/freetype --strip-components=1
+cd ${DEPS}/freetype
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static
+make install
+
+mkdir ${DEPS}/fontconfig
+curl -Ls https://www.freedesktop.org/software/fontconfig/release/fontconfig-${VERSION_FONTCONFIG}.tar.bz2 | tar xjC ${DEPS}/fontconfig --strip-components=1
+cd ${DEPS}/fontconfig
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --enable-libxml2
+make install-strip
+
+mkdir ${DEPS}/harfbuzz
+curl -Ls https://www.freedesktop.org/software/harfbuzz/release/harfbuzz-${VERSION_HARFBUZZ}.tar.bz2 | tar xjC ${DEPS}/harfbuzz --strip-components=1
+cd ${DEPS}/harfbuzz
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/pixman
+curl -Ls http://cairographics.org/releases/pixman-${VERSION_PIXMAN}.tar.gz | tar xzC ${DEPS}/pixman --strip-components=1
+cd ${DEPS}/pixman
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-libpng --disable-arm-iwmmxt
+make install-strip
+
+mkdir ${DEPS}/cairo
+curl -Ls http://cairographics.org/releases/cairo-${VERSION_CAIRO}.tar.xz | tar xJC ${DEPS}/cairo --strip-components=1
+cd ${DEPS}/cairo
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-xlib --disable-xcb --disable-quartz --disable-win32 --disable-egl --disable-glx --disable-wgl \
+  --disable-script --disable-ps --disable-gobject --disable-trace --disable-interpreter
+make install-strip
+
+mkdir ${DEPS}/pango
+curl -Ls https://download.gnome.org/sources/pango/1.40/pango-${VERSION_PANGO}.tar.xz | tar xJC ${DEPS}/pango --strip-components=1
+cd ${DEPS}/pango
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/croco
+curl -Ls https://download.gnome.org/sources/libcroco/0.6/libcroco-${VERSION_CROCO}.tar.xz | tar xJC ${DEPS}/croco --strip-components=1
+cd ${DEPS}/croco
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/svg
+curl -Ls https://download.gnome.org/sources/librsvg/2.40/librsvg-${VERSION_SVG}.tar.xz | tar xJC ${DEPS}/svg --strip-components=1
+cd ${DEPS}/svg
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-introspection --disable-tools --disable-pixbuf-loader
+make install-strip
+
+mkdir ${DEPS}/gif
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/giflib/giflib-${VERSION_GIF}.tar.gz | tar xzC ${DEPS}/gif --strip-components=1
+cd ${DEPS}/gif
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/vips
+curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.3/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
+cd ${DEPS}/vips
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-debug --disable-introspection --without-python --without-fftw \
+  --without-magick --without-pangoft2 --without-ppm --without-analyze --without-radiance \
+  --with-zip-includes=${TARGET}/include --with-zip-libraries=${TARGET}/lib \
+  --with-jpeg-includes=${TARGET}/include --with-jpeg-libraries=${TARGET}/lib
+make install-strip
+
+# Remove the old C++ bindings
+cd ${TARGET}/include
+rm -rf vips/vipsc++.h vips/vipscpp.h
+cd ${TARGET}/lib
+rm -rf pkgconfig .libs *.la libvipsCC*
+
+# Create JSON file of version numbers
+cd ${TARGET}
+echo "{\n\
+  \"cairo\": \"${VERSION_CAIRO}\",\n\
+  \"croco\": \"${VERSION_CROCO}\",\n\
+  \"exif\": \"${VERSION_EXIF}\",\n\
+  \"ffi\": \"${VERSION_FFI}\",\n\
+  \"fontconfig\": \"${VERSION_FONTCONFIG}\",\n\
+  \"freetype\": \"${VERSION_FREETYPE}\",\n\
+  \"gdkpixbuf\": \"${VERSION_GDKPIXBUF}\",\n\
+  \"gif\": \"${VERSION_GIF}\",\n\
+  \"glib\": \"${VERSION_GLIB}\",\n\
+  \"gsf\": \"${VERSION_GSF}\",\n\
+  \"harfbuzz\": \"${VERSION_HARFBUZZ}\",\n\
+  \"jpeg\": \"${VERSION_JPEG}\",\n\
+  \"lcms\": \"${VERSION_LCMS2}\",\n\
+  \"orc\": \"${VERSION_ORC}\",\n\
+  \"pango\": \"${VERSION_PANGO}\",\n\
+  \"pixman\": \"${VERSION_PIXMAN}\",\n\
+  \"png\": \"${VERSION_PNG16}\",\n\
+  \"svg\": \"${VERSION_SVG}\",\n\
+  \"tiff\": \"${VERSION_TIFF}\",\n\
+  \"vips\": \"${VERSION_VIPS}\",\n\
+  \"webp\": \"${VERSION_WEBP}\",\n\
+  \"xml\": \"${VERSION_XML2}\",\n\
+  \"zlib\": \"${VERSION_ZLIB}\"\n\
+}" >lib/versions.json
+
+# Create .tar.gz
+tar czf /packaging/libvips-${VERSION_VIPS}-${PLATFORM}.tar.gz include lib
+advdef --recompress --shrink-insane /packaging/libvips-${VERSION_VIPS}-${PLATFORM}.tar.gz

packaging/build/win.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+set -e
+
+# Fetch and unzip
+mkdir /vips
+cd /vips
+curl -L -O https://github.com/lovell/build-win64/releases/download/v${VERSION_VIPS}/vips-dev-w64-web-${VERSION_VIPS}.zip
+unzip vips-dev-w64-web-${VERSION_VIPS}.zip
+
+# Clean and zip
+cd /vips/vips-dev-8.3
+rm bin/libvipsCC-42.dll bin/libvips-cpp-42.dll bin/libgsf-win32-1-114.dll
+cp bin/*.dll lib/
+cp -r lib64/* lib/
+
+echo "Creating tarball"
+tar czf /packaging/libvips-${VERSION_VIPS}-${PLATFORM}.tar.gz include lib/glib-2.0 lib/libvips.lib lib/libglib-2.0.lib lib/libgobject-2.0.lib lib/*.dll
+echo "Shrinking tarball"
+advdef --recompress --shrink-insane /packaging/libvips-${VERSION_VIPS}-${PLATFORM}.tar.gz

packaging/linux-armv6/Dockerfile

@@ -0,0 +1,15 @@
+FROM socialdefect/raspbian-jessie-core
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Rasbian-based container suitable for compiling Linux ARMv6 binaries
+# Requires the QEMU user mode emulation binaries on the host machine
+
+# Build dependencies
+RUN \
+  apt-get update && \
+  apt-get install -y build-essential curl autoconf libtool nasm gtk-doc-tools texinfo advancecomp libglib2.0-dev
+
+# Compiler settings
+ENV \
+  PLATFORM=linux-armv6 \
+  FLAGS="-Os"

packaging/linux-armv7/Dockerfile

@@ -0,0 +1,20 @@
+FROM debian:jessie
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Debian-based container suitable for cross-compiling Linux ARMv7-A binaries
+
+# Build dependencies
+RUN \
+  apt-get update && \
+  apt-get install -y curl && \
+  echo "deb http://emdebian.org/tools/debian/ jessie main" | tee /etc/apt/sources.list.d/crosstools.list && \
+  curl http://emdebian.org/tools/debian/emdebian-toolchain-archive.key | apt-key add - && \
+  dpkg --add-architecture armhf && \
+  apt-get update && \
+  apt-get install -y crossbuild-essential-armhf autoconf libtool nasm gtk-doc-tools texinfo advancecomp libglib2.0-dev
+
+# Compiler settings
+ENV \
+  PLATFORM=linux-armv7 \
+  CHOST=arm-linux-gnueabihf \
+  FLAGS="-marm -march=armv7-a -mfpu=neon-vfpv4 -mfloat-abi=hard -Os"

packaging/linux-armv8/Dockerfile

@@ -0,0 +1,18 @@
+FROM debian:stretch
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Debian-based container suitable for cross-compiling Linux ARMv8-A binaries
+
+# Build dependencies
+RUN \
+  apt-get update && \
+  apt-get install -y curl && \
+  dpkg --add-architecture arm64 && \
+  apt-get update && \
+  apt-get install -y crossbuild-essential-arm64 autoconf libtool nasm gtk-doc-tools texinfo advancecomp libglib2.0-dev
+
+# Compiler settings
+ENV \
+  PLATFORM=linux-armv8 \
+  CHOST=aarch64-linux-gnu \
+  FLAGS="-march=armv8-a -Os -D_GLIBCXX_USE_CXX11_ABI=0"

packaging/linux-x64/Dockerfile

@@ -0,0 +1,14 @@
+FROM debian:wheezy
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Debian-based container suitable for building Linux x64 binaries
+
+# Build dependencies
+RUN \
+  apt-get update && \
+  apt-get install -y build-essential autoconf libtool nasm gtk-doc-tools texinfo advancecomp
+
+# Compiler settings
+ENV \
+  PLATFORM="linux-x64" \
+  FLAGS="-O3"

packaging/test-linux-arm.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+if [ $# -lt 1 ]; then
+  echo "Usage: $0 IP"
+  echo "Test sharp on ARM using Docker, where IP is"
+  echo "the address of a Raspberry Pi running HypriotOS"
+  exit 1
+fi
+IP="$1"
+
+echo "Verifying connectivity to $IP"
+if ! ping -c 1 $IP; then
+  echo "Could not connect to $IP"
+  exit 1
+fi
+
+if ! type sshpass >/dev/null; then
+  echo "Please install sshpass"
+  exit 1
+fi
+
+export SSHPASS=hypriot
+
+echo "Copying sharp source to device"
+sshpass -e scp -o PreferredAuthentications=password -r ../../sharp pirate@${IP}:/home/pirate/sharp
+
+echo "Compile and test within container"
+sshpass -e ssh -o PreferredAuthentications=password -t pirate@${IP} "docker run --rm -v \${PWD}/sharp:/s hypriot/rpi-node:6 sh -c 'cd /s && npm install --unsafe-perm && npm test'"

packaging/test-linux-x64.sh

@@ -0,0 +1,56 @@
+#!/bin/sh
+
+# Verify docker is available
+if ! type docker >/dev/null; then
+  echo "Please install docker"
+  exit 1
+fi
+
+version_node=6.3.0
+
+test="npm run clean; npm install --unsafe-perm; npm test"
+
+# Debian 7, 8
+# Ubuntu 14.04
+for dist in wheezy jessie trusty; do
+  echo "Testing $dist..."
+  if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/$dist:$version_node >packaging/$dist.log 2>&1 sh -c "cd /v; ./packaging/test/debian.sh; $test";
+  then echo "$dist OK"
+  else echo "$dist fail" && cat packaging/$dist.log
+  fi
+done
+
+# Centos 7
+echo "Testing centos7..."
+if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/centos7:$version_node >packaging/$dist.log 2>&1 sh -c "cd /v; $test";
+then echo "centos7 OK"
+else echo "centos7 fail" && cat packaging/$dist.log
+fi
+
+# Fedora 22
+echo "Testing fedora22..."
+if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/fedora22:$version_node >packaging/$dist.log 2>&1 sh -c "cd /v; $test";
+then echo "fedora22 OK"
+else echo "fedora22 fail" && cat packaging/$dist.log
+fi
+
+# openSUSE 13.2
+echo "Testing opensuse..."
+if docker run -i -t --rm -v $PWD:/v opensuse:13.2 >packaging/opensuse.log 2>&1 /bin/sh -c "cd /v; ./packaging/test/opensuse.sh; $test";
+then echo "opensuse OK"
+else echo "opensuse fail" && cat packaging/opensuse.log
+fi
+
+# Archlinux 2015.06.01
+echo "Testing archlinux..."
+if docker run -i -t --rm -v $PWD:/v pritunl/archlinux:latest >packaging/archlinux.log 2>&1 sh -c "cd /v; ./packaging/test/archlinux.sh; $test";
+then echo "archlinux OK"
+else echo "archlinux fail" && cat packaging/archlinux.log
+fi
+
+# Alpine
+echo "Testing alpine..."
+if docker run -i -t --rm -v $PWD:/v -e "SHARP_TEST_WITHOUT_CACHE=0" alpine:edge >packaging/alpine.log 2>&1 sh -c "cd /v; ./packaging/test/alpine.sh; $test";
+then echo "alpine OK"
+else echo "alpine fail" && cat packaging/alpine.log
+fi

packaging/test/alpine.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+# Install build dependencies
+apk add --update make gcc g++ python nodejs
+
+# Install libvips from aports/testing
+apk add --update --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing vips-dev

packaging/test/archlinux.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+# Install Node.js on Archlinux
+pacman -Sy --noconfirm gcc make python2 nodejs npm | cat
+ln -s /usr/bin/python2 /usr/bin/python

packaging/test/debian.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+# Install pkg-config on Debian/Ubuntu
+apt-get update
+apt-get install -y pkg-config

packaging/test/opensuse.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+# Install Node.js on openSUSE 13.2
+zypper addrepo http://download.opensuse.org/repositories/devel:languages:nodejs/openSUSE_13.2/devel:languages:nodejs.repo
+zypper --gpg-auto-import-keys refresh
+zypper --non-interactive install gcc-c++ make nodejs-devel npm
+npm install -g npm

packaging/win32-x64/Dockerfile

@@ -0,0 +1,8 @@
+FROM debian:jessie
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Debian-based container suitable for post-processing Windows x64 binaries
+
+RUN apt-get update && apt-get install -y curl zip advancecomp
+
+ENV PLATFORM=win32-x64

preinstall.sh

@@ -1,61 +1,117 @@
 #!/bin/sh
 
-# Ensures libvips is installed and attempts to install it if not
-# Currently supports:
-# * Mac OS
-# * Debian Linux
-#   * Debian 7, 8
-#   * Ubuntu 12.04, 14.04, 14.10, 15.04
-#   * Mint 13, 17
-# * Red Hat Linux
-#   * RHEL/Centos/Scientific 6, 7
-#   * Fedora 21, 22
+# Use of this script is deprecated
 
-vips_version_minimum=7.40.0
-vips_version_latest_major=7.40
-vips_version_latest_minor=11
+echo
+echo "WARNING: This script will stop working at the end of 2016"
+echo
+echo "WARNING: This script is no longer required on most 64-bit Linux systems when using sharp v0.12.0+"
+echo
+echo "See http://sharp.dimens.io/page/install#linux"
+echo
+echo "If you really, really need this script, it will attempt"
+echo "to globally install libvips if not already available."
+echo
+sleep 5
+
+vips_version_minimum=8.3.3
+vips_version_latest_major_minor=8.3
+vips_version_latest_patch=3
+
+openslide_version_minimum=3.4.0
+openslide_version_latest_major_minor=3.4
+openslide_version_latest_patch=1
 
 install_libvips_from_source() {
-  echo "Compiling libvips $vips_version_latest_major.$vips_version_latest_minor from source"
-  curl -O http://www.vips.ecs.soton.ac.uk/supported/$vips_version_latest_major/vips-$vips_version_latest_major.$vips_version_latest_minor.tar.gz
-  tar zvxf vips-$vips_version_latest_major.$vips_version_latest_minor.tar.gz
-  cd vips-$vips_version_latest_major.$vips_version_latest_minor
-  ./configure --enable-debug=no --enable-docs=no --enable-cxx=yes --without-python --without-orc --without-fftw $1
+  echo "Compiling libvips $vips_version_latest_major_minor.$vips_version_latest_patch from source"
+  curl -O http://www.vips.ecs.soton.ac.uk/supported/$vips_version_latest_major_minor/vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
+  tar zvxf vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
+  cd vips-$vips_version_latest_major_minor.$vips_version_latest_patch
+  CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=0" ./configure --disable-debug --disable-docs --disable-static --disable-introspection --disable-dependency-tracking --enable-cxx=yes --without-python --without-orc --without-fftw $1
   make
   make install
   cd ..
-  rm -rf vips-$vips_version_latest_major.$vips_version_latest_minor
-  rm vips-$vips_version_latest_major.$vips_version_latest_minor.tar.gz
+  rm -rf vips-$vips_version_latest_major_minor.$vips_version_latest_patch
+  rm vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
   ldconfig
-  echo "Installed libvips $vips_version_latest_major.$vips_version_latest_minor"
+  echo "Installed libvips $(PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig pkg-config --modversion vips)"
+}
+
+install_libopenslide_from_source() {
+  echo "Compiling openslide $openslide_version_latest_major_minor.$openslide_version_latest_patch from source"
+  curl -O -L https://github.com/openslide/openslide/releases/download/v$openslide_version_latest_major_minor.$openslide_version_latest_patch/openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch.tar.gz
+  tar xzvf openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch.tar.gz
+  cd openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch
+  PKG_CONFIG_PATH=$pkg_config_path ./configure $1
+  make
+  make install
+  cd ..
+  rm -rf openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch
+  rm openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch.tar.gz
+  ldconfig
+  echo "Installed libopenslide $openslide_version_latest_major_minor.$openslide_version_latest_patch"
 }
 
 sorry() {
-  echo "Sorry, I don't yet know how to install libvips on $1"
+  echo "Sorry, I don't yet know how to install lib$1 on $2"
   exit 1
 }
 
-# Is libvips already installed, and is it at least the minimum required version?
+pkg_config_path="$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig"
 
-if ! type pkg-config >/dev/null; then
-  sorry "a system without pkg-config"
+check_if_library_exists() {
+  PKG_CONFIG_PATH=$pkg_config_path pkg-config --exists $1
+  if [ $? -eq 0 ]; then
+    version_found=$(PKG_CONFIG_PATH=$pkg_config_path pkg-config --modversion $1)
+    PKG_CONFIG_PATH=$pkg_config_path pkg-config --atleast-version=$2 $1
+    if [ $? -eq 0 ]; then
+      # Found suitable version of libvips
+      echo "Found lib$1 $version_found"
+      return 1
+    fi
+    echo "Found lib$1 $version_found but require $2"
+  else
+    echo "Could not find lib$1 using a PKG_CONFIG_PATH of '$pkg_config_path'"
+  fi
+  return 0
+}
+
+enable_openslide=0
+# Is libvips already installed, and is it at least the minimum required version?
+if [ $# -eq 1 ]; then
+  if [ "$1" = "--with-openslide" ]; then
+    echo "Installing vips with openslide support"
+    enable_openslide=1
+  else
+    echo "Sorry, $1 is not supported. Did you mean --with-openslide?"
+    exit 1
+  fi
 fi
 
-pkg_config_path_homebrew=`which brew >/dev/null 2>&1 && eval $(brew --env) && echo $PKG_CONFIG_LIBDIR || true`
-pkg_config_path="$pkg_config_path_homebrew:$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig"
+if ! type pkg-config >/dev/null; then
+  sorry "vips" "a system without pkg-config"
+fi
 
-PKG_CONFIG_PATH=$pkg_config_path pkg-config --exists vips
-if [ $? -eq 0 ]; then
-  vips_version_found=$(PKG_CONFIG_PATH=$pkg_config_path pkg-config --modversion vips)
-  pkg-config --atleast-version=$vips_version_minimum vips
-  if [ $? -eq 0 ]; then
-    # Found suitable version of libvips
-    echo "Found libvips $vips_version_found"
-    exit 0
+openslide_exists=0
+if [ $enable_openslide -eq 1 ]; then
+  check_if_library_exists "openslide" "$openslide_version_minimum"
+  openslide_exists=$?
+fi
+
+check_if_library_exists "vips" "$vips_version_minimum"
+vips_exists=$?
+if [ $vips_exists -eq 1 ] && [ $enable_openslide -eq 1 ]; then
+  if [ $openslide_exists -eq 1 ]; then
+    # Check if vips compiled with openslide support
+    vips_with_openslide=`vips list classes | grep -i opensli`
+    if [ -z $vips_with_openslide ]; then
+      echo "Vips compiled without openslide support."
+    else
+      exit 0
+    fi
   fi
-  echo "Found libvips $vips_version_found but require $vips_version_minimum"
-else
-  echo "Could not find libvips using a PKG_CONFIG_PATH of '$pkg_config_path'"
+elif [ $vips_exists -eq 1 ] && [ $enable_openslide -eq 0 ]; then
+  exit 0
 fi
 
 # Verify root/sudo access
@@ -64,88 +120,197 @@ if [ "$(id -u)" -ne "0" ]; then
   exit 1
 fi
 
+# Deprecation warning
+if [ "$(arch)" == "x86_64" ]; then
+  echo "This script is no longer required on most 64-bit Linux systems when using sharp v0.12.0+"
+fi
+
+# OS-specific installations of libopenslide follows
+# Either openslide does not exist, or vips is installed without openslide support
+if [ $enable_openslide -eq 1 ] && [ -z $vips_with_openslide ] && [ $openslide_exists -eq 0 ]; then
+  if [ -f /etc/debian_version ]; then
+    # Debian Linux
+    DISTRO=$(lsb_release -c -s)
+    echo "Detected Debian Linux '$DISTRO'"
+    case "$DISTRO" in
+      jessie|vivid|wily|xenial)
+        # Debian 8, Ubuntu 15
+        echo "Installing libopenslide via apt-get"
+        apt-get install -y libopenslide-dev
+        ;;
+      trusty|utopic|qiana|rebecca|rafaela|freya)
+        # Ubuntu 14, Mint 17
+        echo "Installing libopenslide dependencies via apt-get"
+        apt-get install -y automake build-essential curl zlib1g-dev libopenjpeg-dev libpng12-dev libjpeg-dev libtiff5-dev libgdk-pixbuf2.0-dev libxml2-dev libsqlite3-dev libcairo2-dev libglib2.0-dev sqlite3 libsqlite3-dev
+        install_libopenslide_from_source
+        ;;
+      precise|wheezy|maya)
+        # Debian 7, Ubuntu 12.04, Mint 13
+        echo "Installing libopenslide dependencies via apt-get"
+        apt-get install -y automake build-essential curl zlib1g-dev libopenjpeg-dev libpng12-dev libjpeg-dev libtiff5-dev libgdk-pixbuf2.0-dev libxml2-dev libsqlite3-dev libcairo2-dev libglib2.0-dev sqlite3 libsqlite3-dev
+        install_libopenslide_from_source
+        ;;
+      *)
+        # Unsupported Debian-based OS
+        sorry "openslide" "Debian-based $DISTRO"
+        ;;
+    esac
+  elif [ -f /etc/redhat-release ]; then
+    # Red Hat Linux
+    RELEASE=$(cat /etc/redhat-release)
+    echo "Detected Red Hat Linux '$RELEASE'"
+    case $RELEASE in
+      "Red Hat Enterprise Linux release 7."*|"CentOS Linux release 7."*|"Scientific Linux release 7."*)
+        # RHEL/CentOS 7
+        echo "Installing libopenslide dependencies via yum"
+        yum groupinstall -y "Development Tools"
+        yum install -y tar curl libpng-devel libjpeg-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel gdk-pixbuf2-devel sqlite-devel cairo-devel glib2-devel
+        install_libopenslide_from_source "--prefix=/usr"
+        ;;
+      "Red Hat Enterprise Linux release 6."*|"CentOS release 6."*|"Scientific Linux release 6."*)
+        # RHEL/CentOS 6
+        echo "Installing libopenslide dependencies via yum"
+        yum groupinstall -y "Development Tools"
+        yum install -y tar curl libpng-devel libjpeg-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel gdk-pixbuf2-devel sqlite-devel cairo-devel glib2-devel
+        install_libopenslide_from_source "--prefix=/usr"
+        ;;
+      "Fedora release 21 "*|"Fedora release 22 "*)
+        # Fedora 21, 22
+        echo "Installing libopenslide via yum"
+        yum install -y openslide-devel
+        ;;
+      *)
+        # Unsupported RHEL-based OS
+        sorry "openslide" "$RELEASE"
+        ;;
+    esac
+  elif [ -f /etc/os-release ]; then
+    RELEASE=$(cat /etc/os-release | grep VERSION)
+    echo "Detected OpenSuse Linux '$RELEASE'"
+    case $RELEASE in
+      *"13.2"*)
+      echo "Installing libopenslide via zypper"
+      zypper --gpg-auto-import-keys install -y libopenslide-devel
+      ;;
+    esac
+  elif [ -f /etc/SuSE-brand ]; then
+    RELEASE=$(cat /etc/SuSE-brand | grep VERSION)
+    echo "Detected OpenSuse Linux '$RELEASE'"
+    case $RELEASE in
+      *"13.1")
+      echo "Installing libopenslide dependencies via zypper"
+      zypper --gpg-auto-import-keys install -y --type pattern devel_basis
+      zypper --gpg-auto-import-keys install -y tar curl libpng16-devel libjpeg-turbo libjpeg8-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel libgdk_pixbuf-2_0-0 sqlite3-devel cairo-devel glib2-devel
+      install_libopenslide_from_source
+      ;;
+    esac
+  else
+    # Unsupported OS
+    sorry "openslide" "$(uname -a)"
+  fi
+fi
+
 # OS-specific installations of libvips follows
 
-case $(uname -s) in
-  *[Dd]arwin*)
-    # Mac OS
-    echo "Detected Mac OS"
-    if type "brew" > /dev/null; then
-      echo "Installing libvips via homebrew"
-      brew install homebrew/science/vips --with-webp --with-graphicsmagick
-    elif type "port" > /dev/null; then
-      echo "Installing libvips via MacPorts"
-      port install vips
-    else
-      sorry "Mac OS without homebrew or MacPorts"
-    fi
+if [ -f /etc/debian_version ]; then
+  # Debian Linux
+  DISTRO=$(lsb_release -c -s)
+  echo "Detected Debian Linux '$DISTRO'"
+  case "$DISTRO" in
+    jessie|trusty|utopic|vivid|wily|xenial|qiana|rebecca|rafaela|freya)
+      # Debian 8, Ubuntu 14.04+, Mint 17
+      echo "Installing libvips dependencies via apt-get"
+      apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-dev libpng12-dev libwebp-dev libtiff5-dev libexif-dev libgsf-1-dev liblcms2-dev libxml2-dev swig libmagickcore-dev curl
+      install_libvips_from_source
+      ;;
+    precise|wheezy|maya)
+      # Debian 7, Ubuntu 12.04, Mint 13
+      echo "Installing libvips dependencies via apt-get"
+      add-apt-repository -y ppa:lyrasis/precise-backports
+      apt-get update
+      apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-dev libpng12-dev libwebp-dev libtiff4-dev libexif-dev libgsf-1-dev liblcms2-dev libxml2-dev swig libmagickcore-dev curl
+      install_libvips_from_source
+      ;;
+    *)
+      # Unsupported Debian-based OS
+      sorry "vips" "Debian-based $DISTRO"
+      ;;
+  esac
+elif [ -f /etc/redhat-release ]; then
+  # Red Hat Linux
+  RELEASE=$(cat /etc/redhat-release)
+  echo "Detected Red Hat Linux '$RELEASE'"
+  case $RELEASE in
+    "Red Hat Enterprise Linux release 7."*|"CentOS Linux release 7."*|"Scientific Linux release 7."*)
+      # RHEL/CentOS 7
+      echo "Installing libvips dependencies via yum"
+      yum groupinstall -y "Development Tools"
+      yum install -y tar curl gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
+      install_libvips_from_source "--prefix=/usr"
+      ;;
+    "Red Hat Enterprise Linux release 6."*|"CentOS release 6."*|"Scientific Linux release 6."*)
+      # RHEL/CentOS 6
+      echo "Installing libvips dependencies via yum"
+      yum groupinstall -y "Development Tools"
+      yum install -y tar curl gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms-devel ImageMagick-devel
+      yum install -y http://li.nux.ro/download/nux/dextop/el6/x86_64/nux-dextop-release-0-2.el6.nux.noarch.rpm
+      yum install -y --enablerepo=nux-dextop gobject-introspection-devel
+      yum install -y http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
+      yum install -y --enablerepo=remi libwebp-devel
+      install_libvips_from_source "--prefix=/usr"
+      ;;
+    "Fedora"*)
+      # Fedora 21, 22, 23
+      echo "Installing libvips dependencies via yum"
+      yum groupinstall -y "Development Tools"
+      yum install -y gcc-c++ gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel lcms-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
+      install_libvips_from_source "--prefix=/usr"
+      ;;
+    *)
+      # Unsupported RHEL-based OS
+      sorry "vips" "$RELEASE"
+      ;;
+  esac
+elif [ -f /etc/system-release ]; then
+  # Probably Amazon Linux
+  RELEASE=$(cat /etc/system-release)
+  case $RELEASE in
+    "Amazon Linux AMI release 2015.03"|"Amazon Linux AMI release 2015.09")
+      # Amazon Linux
+      echo "Detected '$RELEASE'"
+      echo "Installing libvips dependencies via yum"
+      yum groupinstall -y "Development Tools"
+      yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
+      install_libvips_from_source "--prefix=/usr"
+      ;;
+    *)
+      # Unsupported Amazon Linux version
+      sorry "vips" "$RELEASE"
+      ;;
+  esac
+elif [ -f /etc/os-release ]; then
+  RELEASE=$(cat /etc/os-release | grep VERSION)
+  echo "Detected OpenSuse Linux '$RELEASE'"
+  case $RELEASE in
+    *"13.2"*)
+    echo "Installing libvips dependencies via zypper"
+    zypper --gpg-auto-import-keys install -y --type pattern devel_basis
+    zypper --gpg-auto-import-keys install -y tar curl gtk-doc libxml2-devel libjpeg-turbo libjpeg8-devel libpng16-devel libtiff-devel libexif-devel liblcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
+    install_libvips_from_source
     ;;
-  *)
-    if [ -f /etc/debian_version ]; then
-      # Debian Linux
-      DISTRO=$(lsb_release -c -s)
-      echo "Detected Debian Linux '$DISTRO'"
-      case "$DISTRO" in
-        jessie|vivid)
-          # Debian 8, Ubuntu 15
-          echo "Installing libvips via apt-get"
-          apt-get install -y libvips-dev
-          ;;
-        trusty|utopic|qiana|rebecca)
-          # Ubuntu 14, Mint 17
-          echo "Installing libvips dependencies via apt-get"
-          apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-turbo8-dev libpng12-dev libwebp-dev libtiff5-dev libexif-dev libxml2-dev swig libmagickwand-dev curl
-          install_libvips_from_source
-          ;;
-        precise|wheezy|maya)
-          # Debian 7, Ubuntu 12.04, Mint 13
-          echo "Installing libvips dependencies via apt-get"
-          add-apt-repository -y ppa:lyrasis/precise-backports
-          apt-get update
-          apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-turbo8-dev libpng12-dev libwebp-dev libtiff4-dev libexif-dev libxml2-dev swig libmagickwand-dev curl
-          install_libvips_from_source
-          ;;
-        *)
-          # Unsupported Debian-based OS
-          sorry "Debian-based $DISTRO"
-          ;;
-      esac
-    elif [ -f /etc/redhat-release ]; then
-      # Red Hat Linux
-      RELEASE=$(cat /etc/redhat-release)
-      echo "Detected Red Hat Linux '$RELEASE'"
-      case $RELEASE in
-        "Red Hat Enterprise Linux release 7."*|"CentOS Linux release 7."*|"Scientific Linux release 7."*)
-          # RHEL/CentOS 7
-          echo "Installing libvips dependencies via yum"
-          yum groupinstall -y "Development Tools"
-          yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
-          install_libvips_from_source "--prefix=/usr"
-          ;;
-        "Red Hat Enterprise Linux release 6."*|"CentOS release 6."*|"Scientific Linux release 6."*)
-          # RHEL/CentOS 6
-          echo "Installing libvips dependencies via yum"
-          yum groupinstall -y "Development Tools"
-          yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel ImageMagick-devel curl
-          yum install -y http://li.nux.ro/download/nux/dextop/el6/x86_64/nux-dextop-release-0-2.el6.nux.noarch.rpm
-          yum install -y --enablerepo=nux-dextop gobject-introspection-devel
-          yum install -y http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
-          yum install -y --enablerepo=remi libwebp-devel
-          install_libvips_from_source "--prefix=/usr"
-          ;;
-        "Fedora release 21 "*|"Fedora release 22 "*)
-          # Fedora 21, 22
-          echo "Installing libvips via yum"
-          yum install vips-devel
-          ;;
-        *)
-          # Unsupported RHEL-based OS
-          sorry "$RELEASE"
-          ;;
-      esac
-    else
-      # Unsupported OS
-      sorry "$(uname -a)"
-    fi
+  esac
+elif [ -f /etc/SuSE-brand ]; then
+  RELEASE=$(cat /etc/SuSE-brand | grep VERSION)
+  echo "Detected OpenSuse Linux '$RELEASE'"
+  case $RELEASE in
+    *"13.1")
+    echo "Installing libvips dependencies via zypper"
+    zypper --gpg-auto-import-keys install -y --type pattern devel_basis
+    zypper --gpg-auto-import-keys install -y tar curl gtk-doc libxml2-devel libjpeg-turbo libjpeg8-devel libpng16-devel libtiff-devel libexif-devel liblcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
+    install_libvips_from_source
     ;;
-esac
+  esac
+else
+  # Unsupported OS
+  sorry "vips" "$(uname -a)"
+fi

src/common.cc

@@ -1,11 +1,53 @@
+#include <cstdlib>
 #include <string>
 #include <string.h>
-#include <vips/vips.h>
 
+#include <node.h>
+#include <node_buffer.h>
+#include <vips/vips8>
+
+#include "nan.h"
 #include "common.h"
 
+using vips::VImage;
+
 namespace sharp {
 
+  // Convenience methods to access the attributes of a v8::Object
+  bool HasAttr(v8::Handle<v8::Object> obj, std::string attr) {
+    return Nan::Has(obj, Nan::New(attr).ToLocalChecked()).FromJust();
+  }
+  std::string AttrAsStr(v8::Handle<v8::Object> obj, std::string attr) {
+    return *Nan::Utf8String(Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked());
+  }
+
+  // Create an InputDescriptor instance from a v8::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(
+    v8::Handle<v8::Object> input, std::vector<v8::Local<v8::Object>> buffersToPersist
+  ) {
+    Nan::HandleScope();
+    InputDescriptor *descriptor = new InputDescriptor;
+    if (HasAttr(input, "file")) {
+      descriptor->file = AttrAsStr(input, "file");
+    } else {
+      v8::Local<v8::Object> buffer = AttrAs<v8::Object>(input, "buffer");
+      descriptor->bufferLength = node::Buffer::Length(buffer);
+      descriptor->buffer = node::Buffer::Data(buffer);
+      buffersToPersist.push_back(buffer);
+    }
+    // Density for vector-based input
+    if (HasAttr(input, "density")) {
+      descriptor->density = AttrTo<uint32_t>(input, "density");
+    }
+    // Raw pixel input
+    if (HasAttr(input, "rawChannels")) {
+      descriptor->rawChannels = AttrTo<uint32_t>(input, "rawChannels");
+      descriptor->rawWidth = AttrTo<uint32_t>(input, "rawWidth");
+      descriptor->rawHeight = AttrTo<uint32_t>(input, "rawHeight");
+    }
+    return descriptor;
+  }
+
   // How many tasks are in the queue?
   volatile int counterQueue = 0;
 
@@ -28,19 +70,38 @@ namespace sharp {
   bool IsTiff(std::string const &str) {
     return EndsWith(str, ".tif") || EndsWith(str, ".tiff") || EndsWith(str, ".TIF") || EndsWith(str, ".TIFF");
   }
+  bool IsDz(std::string const &str) {
+    return EndsWith(str, ".dzi") || EndsWith(str, ".DZI");
+  }
+  bool IsDzZip(std::string const &str) {
+    return EndsWith(str, ".zip") || EndsWith(str, ".ZIP") || EndsWith(str, ".szi") || EndsWith(str, ".SZI");
+  }
+  bool IsV(std::string const &str) {
+    return EndsWith(str, ".v") || EndsWith(str, ".V") || EndsWith(str, ".vips") || EndsWith(str, ".VIPS");
+  }
 
-  // Buffer content checkers
-  unsigned char const MARKER_JPEG[] = {0xff, 0xd8};
-  unsigned char const MARKER_PNG[] = {0x89, 0x50};
-  unsigned char const MARKER_WEBP[] = {0x52, 0x49};
-
-  static bool buffer_is_tiff(char *buffer, size_t len) {
-    return (
-      len >= 4 && (
-        (buffer[0] == 'M' && buffer[1] == 'M' && buffer[2] == '\0' && (buffer[3] == '*' || buffer[3] == '+')) ||
-        (buffer[0] == 'I' && buffer[1] == 'I' && (buffer[2] == '*' || buffer[2] == '+') && buffer[3] == '\0')
-      )
-    );
+  /*
+    Provide a string identifier for the given image type.
+  */
+  std::string ImageTypeId(ImageType const imageType) {
+    std::string id;
+    switch (imageType) {
+      case ImageType::JPEG: id = "jpeg"; break;
+      case ImageType::PNG: id = "png"; break;
+      case ImageType::WEBP: id = "webp"; break;
+      case ImageType::TIFF: id = "tiff"; break;
+      case ImageType::GIF: id = "gif"; break;
+      case ImageType::SVG: id = "svg"; break;
+      case ImageType::PDF: id = "pdf"; break;
+      case ImageType::MAGICK: id = "magick"; break;
+      case ImageType::OPENSLIDE: id = "openslide"; break;
+      case ImageType::PPM: id = "ppm"; break;
+      case ImageType::FITS: id = "fits"; break;
+      case ImageType::VIPS: id = "v"; break;
+      case ImageType::RAW: id = "raw"; break;
+      case ImageType::UNKNOWN: id = "unknown"; break;
+    }
+    return id;
   }
 
   /*
@@ -48,111 +109,334 @@ namespace sharp {
   */
   ImageType DetermineImageType(void *buffer, size_t const length) {
     ImageType imageType = ImageType::UNKNOWN;
-    if (length >= 4) {
-      if (memcmp(MARKER_JPEG, buffer, 2) == 0) {
+    char const *load = vips_foreign_find_load_buffer(buffer, length);
+    if (load != NULL) {
+      std::string const loader = load;
+      if (EndsWith(loader, "JpegBuffer")) {
         imageType = ImageType::JPEG;
-      } else if (memcmp(MARKER_PNG, buffer, 2) == 0) {
+      } else if (EndsWith(loader, "PngBuffer")) {
         imageType = ImageType::PNG;
-      } else if (memcmp(MARKER_WEBP, buffer, 2) == 0) {
+      } else if (EndsWith(loader, "WebpBuffer")) {
         imageType = ImageType::WEBP;
-      } else if (buffer_is_tiff(static_cast<char*>(buffer), length)) {
+      } else if (EndsWith(loader, "TiffBuffer")) {
         imageType = ImageType::TIFF;
+      } else if (EndsWith(loader, "GifBuffer")) {
+        imageType = ImageType::GIF;
+      } else if (EndsWith(loader, "SvgBuffer")) {
+        imageType = ImageType::SVG;
+      } else if (EndsWith(loader, "PdfBuffer")) {
+        imageType = ImageType::PDF;
+      } else if (EndsWith(loader, "MagickBuffer")) {
+        imageType = ImageType::MAGICK;
       }
     }
     return imageType;
   }
 
   /*
-    Initialise and return a VipsImage from a buffer. Supports JPEG, PNG, WebP and TIFF.
-  */
-  VipsImage* InitImage(ImageType imageType, void *buffer, size_t const length, VipsAccess const access) {
-    VipsImage *image = NULL;
-    if (imageType == ImageType::JPEG) {
-      vips_jpegload_buffer(buffer, length, &image, "access", access, NULL);
-    } else if (imageType == ImageType::PNG) {
-      vips_pngload_buffer(buffer, length, &image, "access", access, NULL);
-    } else if (imageType == ImageType::WEBP) {
-      vips_webpload_buffer(buffer, length, &image, "access", access, NULL);
-    } else if (imageType == ImageType::TIFF) {
-      vips_tiffload_buffer(buffer, length, &image, "access", access, NULL);
-    }
-    return image;
-  }
-
-  /*
-    Inpect the first 2-4 bytes of a file to determine image format
+    Determine image format, reads the first few bytes of the file
   */
   ImageType DetermineImageType(char const *file) {
     ImageType imageType = ImageType::UNKNOWN;
-    if (vips_foreign_is_a("jpegload", file)) {
-      imageType = ImageType::JPEG;
-    } else if (vips_foreign_is_a("pngload", file)) {
-      imageType = ImageType::PNG;
-    } else if (vips_foreign_is_a("webpload", file)) {
-      imageType = ImageType::WEBP;
-    } else if (vips_foreign_is_a("tiffload", file)) {
-      imageType = ImageType::TIFF;
-    } else if(vips_foreign_is_a("magickload", file)) {
-      imageType = ImageType::MAGICK;
+    char const *load = vips_foreign_find_load(file);
+    if (load != nullptr) {
+      std::string const loader = load;
+      if (EndsWith(loader, "JpegFile")) {
+        imageType = ImageType::JPEG;
+      } else if (EndsWith(loader, "Png")) {
+        imageType = ImageType::PNG;
+      } else if (EndsWith(loader, "WebpFile")) {
+        imageType = ImageType::WEBP;
+      } else if (EndsWith(loader, "Openslide")) {
+        imageType = ImageType::OPENSLIDE;
+      } else if (EndsWith(loader, "TiffFile")) {
+        imageType = ImageType::TIFF;
+      } else if (EndsWith(loader, "GifFile")) {
+        imageType = ImageType::GIF;
+      } else if (EndsWith(loader, "SvgFile")) {
+        imageType = ImageType::SVG;
+      } else if (EndsWith(loader, "PdfFile")) {
+        imageType = ImageType::PDF;
+      } else if (EndsWith(loader, "Ppm")) {
+        imageType = ImageType::PPM;
+      } else if (EndsWith(loader, "Fits")) {
+        imageType = ImageType::FITS;
+      } else if (EndsWith(loader, "Vips")) {
+        imageType = ImageType::VIPS;
+      } else if (EndsWith(loader, "Magick") || EndsWith(loader, "MagickFile")) {
+        imageType = ImageType::MAGICK;
+      }
     }
     return imageType;
   }
 
   /*
-    Initialise and return a VipsImage from a file.
+    Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
-  VipsImage* InitImage(ImageType imageType, char const *file, VipsAccess const access) {
-    VipsImage *image = NULL;
-    if (imageType == ImageType::JPEG) {
-      vips_jpegload(file, &image, "access", access, NULL);
-    } else if (imageType == ImageType::PNG) {
-      vips_pngload(file, &image, "access", access, NULL);
-    } else if (imageType == ImageType::WEBP) {
-      vips_webpload(file, &image, "access", access, NULL);
-    } else if (imageType == ImageType::TIFF) {
-      vips_tiffload(file, &image, "access", access, NULL);
-    } else if (imageType == ImageType::MAGICK) {
-      vips_magickload(file, &image, "access", access, NULL);
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor, VipsAccess accessMethod) {
+    VImage image;
+    ImageType imageType;
+    if (descriptor->buffer != nullptr) {
+      // From buffer
+      if (descriptor->rawChannels > 0) {
+        // Raw, uncompressed pixel data
+        image = VImage::new_from_memory(descriptor->buffer, descriptor->bufferLength,
+          descriptor->rawWidth, descriptor->rawHeight, descriptor->rawChannels, VIPS_FORMAT_UCHAR);
+        if (descriptor->rawChannels < 3) {
+          image.get_image()->Type = VIPS_INTERPRETATION_B_W;
+        } else {
+          image.get_image()->Type = VIPS_INTERPRETATION_sRGB;
+        }
+        imageType = ImageType::RAW;
+      } else {
+        // Compressed data
+        imageType = DetermineImageType(descriptor->buffer, descriptor->bufferLength);
+        if (imageType != ImageType::UNKNOWN) {
+          try {
+            vips::VOption *option = VImage::option()->set("access", accessMethod);
+            if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
+              option->set("dpi", static_cast<double>(descriptor->density));
+            }
+            if (imageType == ImageType::MAGICK) {
+              option->set("density", std::to_string(descriptor->density).data());
+            }
+            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");
+          }
+        } else {
+          throw vips::VError("Input buffer contains unsupported image format");
+        }
+      }
+    } else {
+      // From filesystem
+      imageType = DetermineImageType(descriptor->file.data());
+      if (imageType != ImageType::UNKNOWN) {
+        try {
+          vips::VOption *option = VImage::option()->set("access", accessMethod);
+          if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
+            option->set("dpi", static_cast<double>(descriptor->density));
+          }
+          if (imageType == ImageType::MAGICK) {
+            option->set("density", std::to_string(descriptor->density).data());
+          }
+          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");
+        }
+      } else {
+        throw vips::VError("Input file is missing or of an unsupported image format");
+      }
     }
-    return image;
+    return std::make_tuple(image, imageType);
+  }
+
+  /*
+    Does this image have an embedded profile?
+  */
+  bool HasProfile(VImage image) {
+    return (image.get_typeof(VIPS_META_ICC_NAME) != 0) ? TRUE : FALSE;
   }
 
   /*
     Does this image have an alpha channel?
     Uses colour space interpretation with number of channels to guess this.
   */
-  bool HasAlpha(VipsImage *image) {
+  bool HasAlpha(VImage image) {
+    int const bands = image.bands();
+    VipsInterpretation const interpretation = image.interpretation();
     return (
-      (image->Bands == 2 && image->Type == VIPS_INTERPRETATION_B_W) ||
-      (image->Bands == 4 && image->Type != VIPS_INTERPRETATION_CMYK) ||
-      (image->Bands == 5 && image->Type == VIPS_INTERPRETATION_CMYK)
+      (bands == 2 && interpretation == VIPS_INTERPRETATION_B_W) ||
+      (bands == 4 && interpretation != VIPS_INTERPRETATION_CMYK) ||
+      (bands == 5 && interpretation == VIPS_INTERPRETATION_CMYK)
     );
   }
 
   /*
     Get EXIF Orientation of image, if any.
   */
-  int ExifOrientation(VipsImage const *image) {
+  int ExifOrientation(VImage image) {
     int orientation = 0;
-    const char *exif;
-    if (
-      vips_image_get_typeof(image, "exif-ifd0-Orientation") != 0 &&
-      !vips_image_get_string(image, "exif-ifd0-Orientation", &exif)
-    ) {
-      orientation = atoi(&exif[0]);
+    if (image.get_typeof(EXIF_IFD0_ORIENTATION) != 0) {
+      char const *exif = image.get_string(EXIF_IFD0_ORIENTATION);
+      if (exif != nullptr) {
+        orientation = atoi(&exif[0]);
+      }
     }
     return orientation;
   }
 
   /*
-    Returns the window size for the named interpolator. For example,
-    a window size of 3 means a 3x3 pixel grid is used for the calculation.
+    Set EXIF Orientation of image.
   */
-  int InterpolatorWindowSize(char const *name) {
-    VipsInterpolate *interpolator = vips_interpolate_new(name);
-    int window_size = vips_interpolate_get_window_size(interpolator);
-    g_object_unref(interpolator);
-    return window_size;
+  void SetExifOrientation(VImage image, int const orientation) {
+    char exif[3];
+    g_snprintf(exif, sizeof(exif), "%d", orientation);
+    image.set(EXIF_IFD0_ORIENTATION, exif);
   }
 
-} // namespace
+  /*
+    Remove EXIF Orientation from image.
+  */
+  void RemoveExifOrientation(VImage image) {
+    SetExifOrientation(image, 0);
+  }
+
+  /*
+    Does this image have a non-default density?
+  */
+  bool HasDensity(VImage image) {
+    return image.xres() > 1.0;
+  }
+
+  /*
+    Get pixels/mm resolution as pixels/inch density.
+  */
+  int GetDensity(VImage image) {
+    return static_cast<int>(round(image.xres() * 25.4));
+  }
+
+  /*
+    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;
+    image.set("Xres", pixelsPerMm);
+    image.set("Yres", pixelsPerMm);
+    image.set(VIPS_META_RESOLUTION_UNIT, "in");
+  }
+
+  /*
+    Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
+  */
+  void FreeCallback(char* data, void* hint) {
+    if (data != nullptr) {
+      g_free(data);
+    }
+  }
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity) {
+
+    int left = 0;
+    int top = 0;
+    switch (gravity) {
+      case 1:
+        // North
+        left = (inWidth - outWidth + 1) / 2;
+        break;
+      case 2:
+        // East
+        left = inWidth - outWidth;
+        top = (inHeight - outHeight + 1) / 2;
+        break;
+      case 3:
+        // South
+        left = (inWidth - outWidth + 1) / 2;
+        top = inHeight - outHeight;
+        break;
+      case 4:
+        // West
+        top = (inHeight - outHeight + 1) / 2;
+        break;
+      case 5:
+        // Northeast
+        left = inWidth - outWidth;
+        break;
+      case 6:
+        // Southeast
+        left = inWidth - outWidth;
+        top = inHeight - outHeight;
+      case 7:
+        // Southwest
+        top = inHeight - outHeight;
+      case 8:
+        // Northwest
+        break;
+      default:
+        // Centre
+        left = (inWidth - outWidth + 1) / 2;
+        top = (inHeight - outHeight + 1) / 2;
+    }
+    return std::make_tuple(left, top);
+  }
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given x and y offsets.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const x, int const y) {
+
+    // default values
+    int left = 0;
+    int top = 0;
+
+    // assign only if valid
+    if(x >= 0 && x < (inWidth - outWidth)) {
+      left = x;
+    } else if(x >= (inWidth - outWidth)) {
+      left = inWidth - outWidth;
+    }
+
+    if(y >= 0 && y < (inHeight - outHeight)) {
+      top = y;
+    } else if(y >= (inHeight - outHeight)) {
+      top = inHeight - outHeight;
+    }
+
+    // the resulting left and top could have been outside the image after calculation from bottom/right edges
+    if(left < 0) {
+      left = 0;
+    }
+    if(top < 0) {
+      top = 0;
+    }
+
+    return std::make_tuple(left, top);
+  }
+
+  /*
+    Are pixel values in this image 16-bit integer?
+  */
+  bool Is16Bit(VipsInterpretation const interpretation) {
+    return interpretation == VIPS_INTERPRETATION_RGB16 || interpretation == VIPS_INTERPRETATION_GREY16;
+  }
+
+  /*
+    Return the image alpha maximum. Useful for combining alpha bands. scRGB
+    images are 0 - 1 for image data, but the alpha is 0 - 255.
+  */
+  double MaximumImageAlpha(VipsInterpretation const interpretation) {
+    return Is16Bit(interpretation) ? 65535.0 : 255.0;
+  }
+
+  /*
+    Get boolean operation type from string
+  */
+  VipsOperationBoolean GetBooleanOperation(std::string const opStr) {
+    return static_cast<VipsOperationBoolean>(
+      vips_enum_from_nick(nullptr, VIPS_TYPE_OPERATION_BOOLEAN, opStr.data())
+    );
+  }
+
+  /*
+    Get interpretation type from string
+  */
+  VipsInterpretation GetInterpretation(std::string const typeStr) {
+    return static_cast<VipsInterpretation>(
+      vips_enum_from_nick(nullptr, VIPS_TYPE_INTERPRETATION, typeStr.data())
+    );
+  }
+
+}  // namespace sharp

src/common.h

@@ -1,15 +1,88 @@
-#ifndef SHARP_COMMON_H
-#define SHARP_COMMON_H
+#ifndef SRC_COMMON_H_
+#define SRC_COMMON_H_
+
+#include <string>
+#include <tuple>
+
+#include <node.h>
+#include <vips/vips8>
+
+#include "nan.h"
+
+// Verify platform and compiler compatibility
+
+#if (VIPS_MAJOR_VERSION < 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 3))
+#error libvips version 8.3.x required - see sharp.dimens.io/page/install
+#endif
+
+#if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
+#error GCC version 4.6+ is required for C++11 features - see sharp.dimens.io/page/install#prerequisites
+#endif
+
+#if (defined(__clang__) && defined(__has_feature))
+#if (!__has_feature(cxx_range_for))
+#error clang version 3.0+ is required for C++11 features - see sharp.dimens.io/page/install#prerequisites
+#endif
+#endif
+
+#define EXIF_IFD0_ORIENTATION "exif-ifd0-Orientation"
+
+using vips::VImage;
 
 namespace sharp {
 
+  struct InputDescriptor {
+    std::string name;
+    std::string file;
+    char *buffer;
+    size_t bufferLength;
+    int density;
+    int rawChannels;
+    int rawWidth;
+    int rawHeight;
+
+    InputDescriptor():
+      buffer(nullptr),
+      bufferLength(0),
+      density(72),
+      rawChannels(0),
+      rawWidth(0),
+      rawHeight(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);
+  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>();
+  }
+  template<typename T> T AttrTo(v8::Handle<v8::Object> obj, std::string attr) {
+    return Nan::To<T>(Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked()).FromJust();
+  }
+  template<typename T> T AttrTo(v8::Handle<v8::Object> obj, int attr) {
+    return Nan::To<T>(Nan::Get(obj, attr).ToLocalChecked()).FromJust();
+  }
+
+  // Create an InputDescriptor instance from a v8::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(
+    v8::Handle<v8::Object> input, std::vector<v8::Local<v8::Object>> buffersToPersist
+  );
+
   enum class ImageType {
-    UNKNOWN,
     JPEG,
     PNG,
     WEBP,
     TIFF,
-    MAGICK
+    GIF,
+    SVG,
+    PDF,
+    MAGICK,
+    OPENSLIDE,
+    PPM,
+    FITS,
+    VIPS,
+    RAW,
+    UNKNOWN
   };
 
   // How many tasks are in the queue?
@@ -23,6 +96,14 @@ namespace sharp {
   bool IsPng(std::string const &str);
   bool IsWebp(std::string const &str);
   bool IsTiff(std::string const &str);
+  bool IsDz(std::string const &str);
+  bool IsDzZip(std::string const &str);
+  bool IsV(std::string const &str);
+
+  /*
+    Provide a string identifier for the given image type.
+  */
+  std::string ImageTypeId(ImageType const imageType);
 
   /*
     Determine image format of a buffer.
@@ -35,32 +116,91 @@ namespace sharp {
   ImageType DetermineImageType(char const *file);
 
   /*
-    Initialise and return a VipsImage from a buffer. Supports JPEG, PNG, WebP and TIFF.
+    Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
-  VipsImage* InitImage(ImageType imageType, void *buffer, size_t const length, VipsAccess const access);
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor, VipsAccess accessMethod);
 
   /*
-    Initialise and return a VipsImage from a file.
+    Does this image have an embedded profile?
   */
-  VipsImage* InitImage(ImageType imageType, char const *file, VipsAccess const access);
+  bool HasProfile(VImage image);
 
   /*
     Does this image have an alpha channel?
     Uses colour space interpretation with number of channels to guess this.
   */
-  bool HasAlpha(VipsImage *image);
+  bool HasAlpha(VImage image);
 
   /*
     Get EXIF Orientation of image, if any.
   */
-  int ExifOrientation(VipsImage const *image);
+  int ExifOrientation(VImage image);
 
   /*
-    Returns the window size for the named interpolator. For example,
-    a window size of 3 means a 3x3 pixel grid is used for the calculation.
+    Set EXIF Orientation of image.
   */
-  int InterpolatorWindowSize(char const *name);
+  void SetExifOrientation(VImage image, int const orientation);
 
-} // namespace
+  /*
+    Remove EXIF Orientation from image.
+  */
+  void RemoveExifOrientation(VImage image);
 
-#endif
+  /*
+    Does this image have a non-default density?
+  */
+  bool HasDensity(VImage image);
+
+  /*
+    Get pixels/mm resolution as pixels/inch density.
+  */
+  int GetDensity(VImage image);
+
+  /*
+    Set pixels/mm resolution based on a pixels/inch density.
+  */
+  void SetDensity(VImage image, const int density);
+
+  /*
+    Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
+  */
+  void FreeCallback(char* data, void* hint);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given x and y offsets of the output image.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const x, int const y);
+
+  /*
+    Are pixel values in this image 16-bit integer?
+  */
+  bool Is16Bit(VipsInterpretation const interpretation);
+
+  /*
+    Return the image alpha maximum. Useful for combining alpha bands. scRGB
+    images are 0 - 1 for image data, but the alpha is 0 - 255.
+  */
+  double MaximumImageAlpha(VipsInterpretation const interpretation);
+
+  /*
+    Get boolean operation type from string
+  */
+  VipsOperationBoolean GetBooleanOperation(std::string const opStr);
+
+  /*
+    Get interpretation type from string
+  */
+  VipsInterpretation GetInterpretation(std::string const typeStr);
+
+}  // namespace sharp
+
+#endif  // SRC_COMMON_H_

src/libvips/cplusplus/VError.cpp

@@ -0,0 +1,52 @@
+// Code for error type
+
+/*
+
+    Copyright (C) 1991-2001 The National Gallery
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301  USA
+
+ */
+
+/*
+
+    These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
+
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /*HAVE_CONFIG_H*/
+#include <vips/intl.h>
+
+#include <iostream>
+
+#include <vips/vips8>
+
+VIPS_NAMESPACE_START
+
+std::ostream &operator<<( std::ostream &file, const VError &err )
+{
+	err.ostream_print( file );
+	return( file );
+}
+
+void VError::ostream_print( std::ostream &file ) const
+{
+	file << _what;
+}
+
+VIPS_NAMESPACE_END

src/libvips/cplusplus/VInterpolate.cpp

@@ -0,0 +1,76 @@
+/* Object part of VInterpolate class
+ */
+
+/*
+
+    Copyright (C) 1991-2001 The National Gallery
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301  USA
+
+ */
+
+/*
+
+    These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
+
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /*HAVE_CONFIG_H*/
+#include <vips/intl.h>
+
+#include <vips/vips8>
+
+#include <vips/debug.h>
+
+/*
+#define VIPS_DEBUG
+#define VIPS_DEBUG_VERBOSE
+ */
+
+VIPS_NAMESPACE_START
+
+VInterpolate 
+VInterpolate::new_from_name( const char *name, VOption *options )
+{
+	VipsInterpolate *interp;
+
+	if( !(interp = vips_interpolate_new( name )) ) {
+		delete options; 
+		throw VError(); 
+	}
+	delete options; 
+
+	VInterpolate out( interp ); 
+
+	return( out ); 
+}
+
+VOption *
+VOption::set( const char *name, VInterpolate value )
+{
+	Pair *pair = new Pair( name );
+
+	pair->input = true;
+	g_value_init( &pair->value, VIPS_TYPE_INTERPOLATE );
+	g_value_set_object( &pair->value, value.get_interpolate() );
+	options.push_back( pair );
+
+	return( this );
+}
+
+VIPS_NAMESPACE_END

src/metadata.cc

@@ -1,110 +1,124 @@
+#include <numeric>
+
 #include <node.h>
-#include <vips/vips.h>
+#include <vips/vips8>
 
 #include "nan.h"
-
 #include "common.h"
 #include "metadata.h"
 
-using namespace v8;
-using namespace sharp;
-
-struct MetadataBaton {
-  // Input
-  std::string fileIn;
-  void* bufferIn;
-  size_t bufferInLength;
-  // Output
-  std::string format;
-  int width;
-  int height;
-  std::string space;
-  int channels;
-  bool hasAlpha;
-  int orientation;
-  std::string err;
-
-  MetadataBaton():
-    bufferInLength(0),
-    orientation(0) {}
-};
-
-class MetadataWorker : public NanAsyncWorker {
-
+class MetadataWorker : public Nan::AsyncWorker {
  public:
-  MetadataWorker(NanCallback *callback, MetadataBaton *baton) : NanAsyncWorker(callback), baton(baton) {}
+  MetadataWorker(
+    Nan::Callback *callback, MetadataBaton *baton,
+    std::vector<v8::Local<v8::Object>> const buffersToPersist
+  ) : Nan::AsyncWorker(callback), baton(baton), buffersToPersist(buffersToPersist) {
+    // Protect Buffer objects from GC, keyed on index
+    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
+      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
+        SaveToPersistent(index, buffer);
+        return index + 1;
+      }
+    );
+  }
   ~MetadataWorker() {}
 
   void Execute() {
     // Decrement queued task counter
-    g_atomic_int_dec_and_test(&counterQueue);
+    g_atomic_int_dec_and_test(&sharp::counterQueue);
 
-    ImageType imageType = ImageType::UNKNOWN;
-    VipsImage *image = NULL;
-    if (baton->bufferInLength > 1) {
-      // From buffer
-      imageType = DetermineImageType(baton->bufferIn, baton->bufferInLength);
-      if (imageType != ImageType::UNKNOWN) {
-        image = InitImage(imageType, baton->bufferIn, baton->bufferInLength, VIPS_ACCESS_RANDOM);
-      } else {
-        (baton->err).append("Input buffer contains unsupported image format");
-      }
-    } else {
-      // From file
-      imageType = DetermineImageType(baton->fileIn.c_str());
-      if (imageType != ImageType::UNKNOWN) {
-        image = InitImage(imageType, baton->fileIn.c_str(), VIPS_ACCESS_RANDOM);
-      } else {
-        (baton->err).append("File is of an unsupported image format");
-      }
+    vips::VImage image;
+    sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
+    try {
+      std::tie(image, imageType) = OpenInput(baton->input, VIPS_ACCESS_SEQUENTIAL);
+    } catch (vips::VError const &err) {
+      (baton->err).append(err.what());
     }
-    if (image != NULL && imageType != ImageType::UNKNOWN) {
+    if (imageType != sharp::ImageType::UNKNOWN) {
       // Image type
-      switch (imageType) {
-        case ImageType::JPEG: baton->format = "jpeg"; break;
-        case ImageType::PNG: baton->format = "png"; break;
-        case ImageType::WEBP: baton->format = "webp"; break;
-        case ImageType::TIFF: baton->format = "tiff"; break;
-        case ImageType::MAGICK: baton->format = "magick"; break;
-        case ImageType::UNKNOWN: break;
-      }
+      baton->format = sharp::ImageTypeId(imageType);
       // VipsImage attributes
-      baton->width = image->Xsize;
-      baton->height = image->Ysize;
-      baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image->Type);
-      baton->channels = image->Bands;
+      baton->width = image.width();
+      baton->height = image.height();
+      baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image.interpretation());
+      baton->channels = image.bands();
+      if (sharp::HasDensity(image)) {
+        baton->density = sharp::GetDensity(image);
+      }
+      baton->hasProfile = sharp::HasProfile(image);
       // Derived attributes
-      baton->hasAlpha = HasAlpha(image);
-      baton->orientation = ExifOrientation(image);
-      // Drop image reference
-      g_object_unref(image);
+      baton->hasAlpha = sharp::HasAlpha(image);
+      baton->orientation = sharp::ExifOrientation(image);
+      // EXIF
+      if (image.get_typeof(VIPS_META_EXIF_NAME) == VIPS_TYPE_BLOB) {
+        size_t exifLength;
+        void const *exif = image.get_blob(VIPS_META_EXIF_NAME, &exifLength);
+        baton->exif = static_cast<char*>(g_malloc(exifLength));
+        memcpy(baton->exif, exif, exifLength);
+        baton->exifLength = exifLength;
+      }
+      // ICC profile
+      if (image.get_typeof(VIPS_META_ICC_NAME) == VIPS_TYPE_BLOB) {
+        size_t iccLength;
+        void const *icc = image.get_blob(VIPS_META_ICC_NAME, &iccLength);
+        baton->icc = static_cast<char*>(g_malloc(iccLength));
+        memcpy(baton->icc, icc, iccLength);
+        baton->iccLength = iccLength;
+      }
     }
+
     // Clean up
     vips_error_clear();
     vips_thread_shutdown();
   }
 
   void HandleOKCallback () {
-    NanScope();
+    using Nan::New;
+    using Nan::Set;
+    Nan::HandleScope();
 
-    Handle<Value> argv[2] = { NanNull(), NanNull() };
+    v8::Local<v8::Value> argv[2] = { Nan::Null(), Nan::Null() };
     if (!baton->err.empty()) {
-      // Error
-      argv[0] = Exception::Error(NanNew<String>(baton->err.data(), baton->err.size()));
+      argv[0] = Nan::Error(baton->err.data());
     } else {
       // Metadata Object
-      Local<Object> info = NanNew<Object>();
-      info->Set(NanNew<String>("format"), NanNew<String>(baton->format));
-      info->Set(NanNew<String>("width"), NanNew<Number>(baton->width));
-      info->Set(NanNew<String>("height"), NanNew<Number>(baton->height));
-      info->Set(NanNew<String>("space"), NanNew<String>(baton->space));
-      info->Set(NanNew<String>("channels"), NanNew<Number>(baton->channels));
-      info->Set(NanNew<String>("hasAlpha"), NanNew<Boolean>(baton->hasAlpha));
+      v8::Local<v8::Object> info = New<v8::Object>();
+      Set(info, New("format").ToLocalChecked(), New<v8::String>(baton->format).ToLocalChecked());
+      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());
+      Set(info, New("channels").ToLocalChecked(), New<v8::Uint32>(baton->channels));
+      if (baton->density > 0) {
+        Set(info, New("density").ToLocalChecked(), New<v8::Uint32>(baton->density));
+      }
+      Set(info, New("hasProfile").ToLocalChecked(), New<v8::Boolean>(baton->hasProfile));
+      Set(info, New("hasAlpha").ToLocalChecked(), New<v8::Boolean>(baton->hasAlpha));
       if (baton->orientation > 0) {
-        info->Set(NanNew<String>("orientation"), NanNew<Number>(baton->orientation));
+        Set(info, New("orientation").ToLocalChecked(), New<v8::Uint32>(baton->orientation));
+      }
+      if (baton->exifLength > 0) {
+        Set(info,
+          New("exif").ToLocalChecked(),
+          Nan::NewBuffer(baton->exif, baton->exifLength, sharp::FreeCallback, nullptr).ToLocalChecked()
+        );
+      }
+      if (baton->iccLength > 0) {
+        Set(info,
+          New("icc").ToLocalChecked(),
+          Nan::NewBuffer(baton->icc, baton->iccLength, sharp::FreeCallback, nullptr).ToLocalChecked()
+        );
       }
       argv[1] = info;
     }
+
+    // Dispose of Persistent wrapper around input Buffers so they can be garbage collected
+    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
+      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
+        GetFromPersistent(index);
+        return index + 1;
+      }
+    );
+    delete baton->input;
     delete baton;
 
     // Return to JavaScript
@@ -113,33 +127,27 @@ class MetadataWorker : public NanAsyncWorker {
 
  private:
   MetadataBaton* baton;
+  std::vector<v8::Local<v8::Object>> buffersToPersist;
 };
 
 /*
   metadata(options, callback)
 */
 NAN_METHOD(metadata) {
-  NanScope();
+  // Input Buffers must not undergo GC compaction during processing
+  std::vector<v8::Local<v8::Object>> buffersToPersist;
 
   // V8 objects are converted to non-V8 types held in the baton struct
   MetadataBaton *baton = new MetadataBaton;
-  Local<Object> options = args[0]->ToObject();
+  v8::Local<v8::Object> options = info[0].As<v8::Object>();
 
-  // Input filename
-  baton->fileIn = *String::Utf8Value(options->Get(NanNew<String>("fileIn"))->ToString());
-  // Input Buffer object
-  if (options->Get(NanNew<String>("bufferIn"))->IsObject()) {
-    Local<Object> buffer = options->Get(NanNew<String>("bufferIn"))->ToObject();
-    baton->bufferInLength = node::Buffer::Length(buffer);
-    baton->bufferIn = node::Buffer::Data(buffer);
-  }
+  // Input
+  baton->input = sharp::CreateInputDescriptor(sharp::AttrAs<v8::Object>(options, "input"), buffersToPersist);
 
   // Join queue for worker thread
-  NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
-  NanAsyncQueueWorker(new MetadataWorker(callback, baton));
+  Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
+  Nan::AsyncQueueWorker(new MetadataWorker(callback, baton, buffersToPersist));
 
   // Increment queued task counter
-  g_atomic_int_inc(&counterQueue);
-
-  NanReturnUndefined();
+  g_atomic_int_inc(&sharp::counterQueue);
 }

src/metadata.h

@@ -1,8 +1,43 @@
-#ifndef SHARP_METADATA_H
-#define SHARP_METADATA_H
+#ifndef SRC_METADATA_H_
+#define SRC_METADATA_H_
 
 #include "nan.h"
+#include "common.h"
+
+struct MetadataBaton {
+  // Input
+  sharp::InputDescriptor *input;
+  // Output
+  std::string format;
+  int width;
+  int height;
+  std::string space;
+  int channels;
+  int density;
+  bool hasProfile;
+  bool hasAlpha;
+  int orientation;
+  char *exif;
+  size_t exifLength;
+  char *icc;
+  size_t iccLength;
+  std::string err;
+
+  MetadataBaton():
+    input(nullptr),
+    width(0),
+    height(0),
+    channels(0),
+    density(0),
+    hasProfile(false),
+    hasAlpha(false),
+    orientation(0),
+    exif(nullptr),
+    exifLength(0),
+    icc(nullptr),
+    iccLength(0) {}
+};
 
 NAN_METHOD(metadata);
 
-#endif
+#endif  // SRC_METADATA_H_

src/operations.cc

@@ -0,0 +1,491 @@
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <tuple>
+#include <vips/vips8>
+
+#include "common.h"
+#include "operations.h"
+
+using vips::VImage;
+using vips::VError;
+
+namespace sharp {
+
+  /*
+    Alpha composite src over dst with given gravity.
+    Assumes alpha channels are already premultiplied and will be unpremultiplied after.
+   */
+  VImage Composite(VImage src, VImage dst, const int gravity) {
+    if(IsInputValidForComposition(src, dst)) {
+      // Enlarge overlay src, if required
+      if (src.width() < dst.width() || src.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(), src.width(), src.height(), gravity);
+        // Embed onto transparent background
+        std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
+        src = src.embed(left, top, dst.width(), dst.height(), VImage::option()
+          ->set("extend", VIPS_EXTEND_BACKGROUND)
+          ->set("background", background)
+        );
+      }
+      return CompositeImage(src, dst);
+    }
+    // If the input was not valid for composition the return the input image itself
+    return dst;
+  }
+
+
+  VImage Composite(VImage src, VImage dst, const int x, const int y) {
+    if(IsInputValidForComposition(src, dst)) {
+      // Enlarge overlay src, if required
+      if (src.width() < dst.width() || src.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(), src.width(), src.height(), x, y);
+        // Embed onto transparent background
+        std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
+        src = src.embed(left, top, dst.width(), dst.height(), VImage::option()
+          ->set("extend", VIPS_EXTEND_BACKGROUND)
+          ->set("background", background)
+        );
+      }
+      return CompositeImage(src, dst);
+    }
+    // If the input was not valid for composition the return the input image itself
+    return dst;
+  }
+
+  bool IsInputValidForComposition(VImage src, VImage dst) {
+    using sharp::CalculateCrop;
+    using sharp::HasAlpha;
+
+    if (!HasAlpha(src)) {
+      throw VError("Overlay image must have an alpha channel");
+    }
+    if (!HasAlpha(dst)) {
+      throw VError("Image to be overlaid must have an alpha channel");
+    }
+    if (src.width() > dst.width() || src.height() > dst.height()) {
+      throw VError("Overlay image must have same dimensions or smaller");
+    }
+
+    return true;
+  }
+
+  VImage CompositeImage(VImage src, VImage dst) {
+    // 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);
+  }
+
+  /*
+    Cutout src over dst with given gravity.
+   */
+  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");
+    }
+    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()));
+  }
+
+  /*
+   * Stretch luminance to cover full dynamic range.
+   */
+  VImage Normalize(VImage image) {
+    // Get original colourspace
+    VipsInterpretation typeBeforeNormalize = image.interpretation();
+    if (typeBeforeNormalize == VIPS_INTERPRETATION_RGB) {
+      typeBeforeNormalize = VIPS_INTERPRETATION_sRGB;
+    }
+    // Convert to LAB colourspace
+    VImage lab = image.colourspace(VIPS_INTERPRETATION_LAB);
+    // Extract luminance
+    VImage luminance = lab[0];
+    // Find luminance range
+    VImage stats = luminance.stats();
+    double min = stats(0, 0)[0];
+    double max = stats(1, 0)[0];
+    if (min != max) {
+      // Extract chroma
+      VImage chroma = lab.extract_band(1, VImage::option()->set("n", 2));
+      // Calculate multiplication factor and addition
+      double f = 100.0 / (max - min);
+      double a = -(min * f);
+      // Scale luminance, join to chroma, convert back to original colourspace
+      VImage normalized = luminance.linear(f, a).bandjoin(chroma).colourspace(typeBeforeNormalize);
+      // Attach original alpha channel, if any
+      if (HasAlpha(image)) {
+        // Extract original alpha channel
+        VImage alpha = image[image.bands() - 1];
+        // Join alpha channel to normalised image
+        return normalized.bandjoin(alpha);
+      } else {
+        return normalized;
+      }
+    }
+    return image;
+  }
+
+  /*
+   * Gamma encoding/decoding
+   */
+  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);
+    } else {
+      return image.gamma(VImage::option()->set("exponent", exponent));
+    }
+  }
+
+  /*
+   * Gaussian blur. Use sigma of -1.0 for fast blur.
+   */
+  VImage Blur(VImage image, double const sigma) {
+    if (sigma == -1.0) {
+      // Fast, mild blur - averages neighbouring pixels
+      VImage blur = VImage::new_matrixv(3, 3,
+        1.0, 1.0, 1.0,
+        1.0, 1.0, 1.0,
+        1.0, 1.0, 1.0);
+      blur.set("scale", 9.0);
+      return image.conv(blur);
+    } else {
+      // Slower, accurate Gaussian blur
+      return image.gaussblur(sigma);
+    }
+  }
+
+  /*
+   * Convolution with a kernel.
+   */
+  VImage Convolve(VImage image, int const width, int const height,
+    double const scale, double const offset,
+    std::unique_ptr<double[]> const &kernel_v
+  ) {
+    VImage kernel = VImage::new_from_memory(
+      kernel_v.get(),
+      width * height * sizeof(double),
+      width,
+      height,
+      1,
+      VIPS_FORMAT_DOUBLE);
+    kernel.set("scale", scale);
+    kernel.set("offset", offset);
+
+    return image.conv(kernel);
+  }
+
+  /*
+   * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
+   */
+  VImage Sharpen(VImage image, double const sigma, double const flat, double const jagged) {
+    if (sigma == -1.0) {
+      // Fast, mild sharpen
+      VImage sharpen = VImage::new_matrixv(3, 3,
+        -1.0, -1.0, -1.0,
+        -1.0, 32.0, -1.0,
+        -1.0, -1.0, -1.0);
+      sharpen.set("scale", 24.0);
+      return image.conv(sharpen);
+    } else {
+      // Slow, accurate sharpen in LAB colour space, with control over flat vs jagged areas
+      VipsInterpretation colourspaceBeforeSharpen = image.interpretation();
+      if (colourspaceBeforeSharpen == VIPS_INTERPRETATION_RGB) {
+        colourspaceBeforeSharpen = VIPS_INTERPRETATION_sRGB;
+      }
+      return image.sharpen(
+        VImage::option()->set("sigma", sigma)->set("m1", flat)->set("m2", jagged)
+      ).colourspace(colourspaceBeforeSharpen);
+    }
+  }
+
+  /*
+    Calculate the Shannon entropy
+  */
+  double EntropyStrategy::operator()(VImage image) {
+    return image.hist_find().hist_entropy();
+  }
+
+  /*
+    Calculate the intensity of edges, skin tone and saturation
+  */
+  double AttentionStrategy::operator()(VImage image) {
+    // Convert to LAB colourspace
+    VImage lab = image.colourspace(VIPS_INTERPRETATION_LAB);
+    VImage l = lab[0];
+    VImage a = lab[1];
+    VImage b = lab[2];
+    // Edge detect luminosity with the Sobel operator
+    VImage sobel = vips::VImage::new_matrixv(3, 3,
+      -1.0, 0.0, 1.0,
+      -2.0, 0.0, 2.0,
+      -1.0, 0.0, 1.0);
+    VImage edges = l.conv(sobel).abs() + l.conv(sobel.rot90()).abs();
+    // Skin tone chroma thresholds trained with http://humanae.tumblr.com/
+    VImage skin = (a >= 3) & (a <= 22) & (b >= 4) & (b <= 31);
+    // Chroma >~50% saturation
+    VImage lch = lab.colourspace(VIPS_INTERPRETATION_LCH);
+    VImage c = lch[1];
+    VImage saturation = c > 60;
+    // Find maximum in combined saliency mask
+    VImage mask = edges + skin + saturation;
+    return mask.max();
+  }
+
+  /*
+    Calculate crop area based on image entropy
+  */
+  std::tuple<int, int> Crop(
+    VImage image, int const outWidth, int const outHeight, std::function<double(VImage)> strategy
+  ) {
+    int left = 0;
+    int top = 0;
+    int const inWidth = image.width();
+    int const inHeight = image.height();
+    if (inWidth > outWidth) {
+      // Reduce width by repeated removing slices from edge with lowest score
+      int width = inWidth;
+      double leftScore = 0.0;
+      double rightScore = 0.0;
+      // Max width of each slice
+      int const maxSliceWidth = static_cast<int>(ceil((inWidth - outWidth) / 8.0));
+      while (width > outWidth) {
+        // Width of current slice
+        int const slice = std::min(width - outWidth, maxSliceWidth);
+        if (leftScore == 0.0) {
+          // Update score of left slice
+          leftScore = strategy(image.extract_area(left, 0, slice, inHeight));
+        }
+        if (rightScore == 0.0) {
+          // Update score of right slice
+          rightScore = strategy(image.extract_area(width - slice - 1, 0, slice, inHeight));
+        }
+        // Keep slice with highest score
+        if (leftScore >= rightScore) {
+          // Discard right slice
+          rightScore = 0.0;
+        } else {
+          // Discard left slice
+          leftScore = 0.0;
+          left = left + slice;
+        }
+        width = width - slice;
+      }
+    }
+    if (inHeight > outHeight) {
+      // Reduce height by repeated removing slices from edge with lowest score
+      int height = inHeight;
+      double topScore = 0.0;
+      double bottomScore = 0.0;
+      // Max height of each slice
+      int const maxSliceHeight = static_cast<int>(ceil((inHeight - outHeight) / 8.0));
+      while (height > outHeight) {
+        // Height of current slice
+        int const slice = std::min(height - outHeight, maxSliceHeight);
+        if (topScore == 0.0) {
+          // Update score of top slice
+          topScore = strategy(image.extract_area(0, top, inWidth, slice));
+        }
+        if (bottomScore == 0.0) {
+          // Update score of bottom slice
+          bottomScore = strategy(image.extract_area(0, height - slice - 1, inWidth, slice));
+        }
+        // Keep slice with highest score
+        if (topScore >= bottomScore) {
+          // Discard bottom slice
+          bottomScore = 0.0;
+        } else {
+          // Discard top slice
+          topScore = 0.0;
+          top = top + slice;
+        }
+        height = height - slice;
+      }
+    }
+    return std::make_tuple(left, top);
+  }
+
+  /*
+    Insert a tile cache to prevent over-computation of any previous operations in the pipeline
+  */
+  VImage TileCache(VImage image, double const factor) {
+    int tile_width;
+    int tile_height;
+    int scanline_count;
+    vips_get_tile_size(image.get_image(), &tile_width, &tile_height, &scanline_count);
+    double const need_lines = 1.2 * scanline_count / factor;
+    return image.tilecache(VImage::option()
+      ->set("tile_width", image.width())
+      ->set("tile_height", 10)
+      ->set("max_tiles", static_cast<int>(round(1.0 + need_lines / 10.0)))
+      ->set("access", VIPS_ACCESS_SEQUENTIAL)
+      ->set("threaded", TRUE)
+    );
+  }
+
+  VImage Threshold(VImage image, double const threshold, bool const thresholdGrayscale) {
+    if(!thresholdGrayscale) {
+      return image >= threshold;
+    }
+    return image.colourspace(VIPS_INTERPRETATION_B_W) >= threshold;
+  }
+
+  /*
+    Perform boolean/bitwise operation on image color channels - results in one channel image
+  */
+  VImage Bandbool(VImage image, VipsOperationBoolean const boolean) {
+    image = image.bandbool(boolean);
+    return image.copy(VImage::option()->set("interpretation", VIPS_INTERPRETATION_B_W));
+  }
+
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean) {
+    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) {
+      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);
+  }
+
+}  // namespace sharp

src/operations.h

@@ -0,0 +1,111 @@
+#ifndef SRC_OPERATIONS_H_
+#define SRC_OPERATIONS_H_
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <tuple>
+#include <vips/vips8>
+
+using vips::VImage;
+
+namespace sharp {
+
+  /*
+    Alpha composite src over dst with given gravity.
+    Assumes alpha channels are already premultiplied and will be unpremultiplied after.
+   */
+  VImage Composite(VImage src, VImage dst, const int gravity);
+
+  /*
+    Alpha composite src over dst with given x and y offsets.
+    Assumes alpha channels are already premultiplied and will be unpremultiplied after.
+   */
+  VImage Composite(VImage src, VImage dst, const int x, const int y);
+
+  /*
+    Check if the src and dst Images for composition operation are valid
+  */
+  bool IsInputValidForComposition(VImage src, VImage dst);
+
+  /*
+    Given a valid src and dst, returns the composite of the two images
+  */
+  VImage CompositeImage(VImage src, VImage dst);
+
+  /*
+    Cutout src over dst with given gravity.
+  */
+  VImage Cutout(VImage src, VImage dst, const int gravity);
+
+  /*
+   * Stretch luminance to cover full dynamic range.
+   */
+  VImage Normalize(VImage image);
+
+  /*
+   * Gamma encoding/decoding
+   */
+  VImage Gamma(VImage image, double const exponent);
+
+  /*
+   * Gaussian blur. Use sigma of -1.0 for fast blur.
+   */
+  VImage Blur(VImage image, double const sigma);
+
+  /*
+   * Convolution with a kernel.
+   */
+  VImage Convolve(VImage image, int const width, int const height,
+    double const scale, double const offset, std::unique_ptr<double[]> const &kernel_v);
+
+  /*
+   * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
+   */
+  VImage Sharpen(VImage image, double const sigma, double const flat, double const jagged);
+
+  /*
+    Crop strategy functors
+  */
+  struct EntropyStrategy {
+    double operator()(VImage image);
+  };
+  struct AttentionStrategy {
+    double operator()(VImage image);
+  };
+
+  /*
+    Calculate crop area based on given strategy (Entropy, Attention)
+  */
+  std::tuple<int, int> Crop(
+    VImage image, int const outWidth, int const outHeight, std::function<double(VImage)> strategy
+  );
+
+  /*
+    Insert a tile cache to prevent over-computation of any previous operations in the pipeline
+  */
+  VImage TileCache(VImage image, double const factor);
+
+  /*
+    Threshold an image
+  */
+  VImage Threshold(VImage image, double const threshold, bool const thresholdColor);
+
+  /*
+    Perform boolean/bitwise operation on image color channels - results in one channel image
+  */
+  VImage Bandbool(VImage image, VipsOperationBoolean const boolean);
+
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean);
+
+  /*
+    Trim an image
+  */
+  VImage Trim(VImage image, int const tolerance);
+
+}  // namespace sharp
+
+#endif  // SRC_OPERATIONS_H_

src/pipeline.h

@@ -0,0 +1,169 @@
+#ifndef SRC_PIPELINE_H_
+#define SRC_PIPELINE_H_
+
+#include <memory>
+
+#include <vips/vips8>
+
+#include "nan.h"
+#include "common.h"
+
+NAN_METHOD(pipeline);
+
+enum class Canvas {
+  CROP,
+  EMBED,
+  MAX,
+  MIN,
+  IGNORE_ASPECT
+};
+
+struct PipelineBaton {
+  sharp::InputDescriptor *input;
+  std::string iccProfilePath;
+  int limitInputPixels;
+  std::string formatOut;
+  std::string fileOut;
+  void *bufferOut;
+  size_t bufferOutLength;
+  sharp::InputDescriptor *overlay;
+  int overlayGravity;
+  int overlayXOffset;
+  int overlayYOffset;
+  bool overlayTile;
+  bool overlayCutout;
+  std::vector<sharp::InputDescriptor *> joinChannelIn;
+  int topOffsetPre;
+  int leftOffsetPre;
+  int widthPre;
+  int heightPre;
+  int topOffsetPost;
+  int leftOffsetPost;
+  int widthPost;
+  int heightPost;
+  int width;
+  int height;
+  int channels;
+  Canvas canvas;
+  int crop;
+  int cropCalcLeft;
+  int cropCalcTop;
+  std::string kernel;
+  std::string interpolator;
+  double background[4];
+  bool flatten;
+  bool negate;
+  double blurSigma;
+  double sharpenSigma;
+  double sharpenFlat;
+  double sharpenJagged;
+  int threshold;
+  bool thresholdGrayscale;
+  int trimTolerance;
+  double gamma;
+  bool greyscale;
+  bool normalize;
+  int angle;
+  bool rotateBeforePreExtract;
+  bool flip;
+  bool flop;
+  int extendTop;
+  int extendBottom;
+  int extendLeft;
+  int extendRight;
+  bool progressive;
+  bool withoutEnlargement;
+  VipsAccess accessMethod;
+  int quality;
+  int compressionLevel;
+  bool withoutAdaptiveFiltering;
+  bool withoutChromaSubsampling;
+  bool trellisQuantisation;
+  bool overshootDeringing;
+  bool optimiseScans;
+  std::string err;
+  bool withMetadata;
+  int withMetadataOrientation;
+  std::unique_ptr<double[]> convKernel;
+  int convKernelWidth;
+  int convKernelHeight;
+  double convKernelScale;
+  double convKernelOffset;
+  sharp::InputDescriptor *boolean;
+  VipsOperationBoolean booleanOp;
+  VipsOperationBoolean bandBoolOp;
+  int extractChannel;
+  VipsInterpretation colourspace;
+  int tileSize;
+  int tileOverlap;
+  VipsForeignDzContainer tileContainer;
+  VipsForeignDzLayout tileLayout;
+
+  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),
+    cropCalcLeft(-1),
+    cropCalcTop(-1),
+    flatten(false),
+    negate(false),
+    blurSigma(0.0),
+    sharpenSigma(0.0),
+    sharpenFlat(1.0),
+    sharpenJagged(2.0),
+    threshold(0),
+    thresholdGrayscale(true),
+    trimTolerance(0),
+    gamma(0.0),
+    greyscale(false),
+    normalize(false),
+    angle(0),
+    flip(false),
+    flop(false),
+    extendTop(0),
+    extendBottom(0),
+    extendLeft(0),
+    extendRight(0),
+    progressive(false),
+    withoutEnlargement(false),
+    quality(80),
+    compressionLevel(6),
+    withoutAdaptiveFiltering(false),
+    withoutChromaSubsampling(false),
+    trellisQuantisation(false),
+    overshootDeringing(false),
+    optimiseScans(false),
+    withMetadata(false),
+    withMetadataOrientation(-1),
+    convKernelWidth(0),
+    convKernelHeight(0),
+    convKernelScale(0.0),
+    convKernelOffset(0.0),
+    boolean(nullptr),
+    booleanOp(VIPS_OPERATION_BOOLEAN_LAST),
+    bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
+    extractChannel(-1),
+    colourspace(VIPS_INTERPRETATION_LAST),
+    tileSize(256),
+    tileOverlap(0),
+    tileContainer(VIPS_FOREIGN_DZ_CONTAINER_FS),
+    tileLayout(VIPS_FOREIGN_DZ_LAYOUT_DZ) {
+      background[0] = 0.0;
+      background[1] = 0.0;
+      background[2] = 0.0;
+      background[3] = 255.0;
+    }
+};
+
+#endif  // SRC_PIPELINE_H_

src/resize.cc

@@ -1,876 +0,0 @@
-#include <tuple>
-#include <algorithm>
-#include <cmath>
-#include <node.h>
-#include <node_buffer.h>
-#include <vips/vips.h>
-
-#include "nan.h"
-
-#include "common.h"
-#include "resize.h"
-
-using namespace v8;
-using namespace sharp;
-
-enum class Canvas {
-  CROP,
-  MAX,
-  EMBED
-};
-
-enum class Angle {
-	D0,
-	D90,
-	D180,
-	D270,
-	DLAST
-};
-
-struct ResizeBaton {
-  std::string fileIn;
-  void* bufferIn;
-  size_t bufferInLength;
-  std::string iccProfileCmyk;
-  std::string output;
-  std::string outputFormat;
-  void* bufferOut;
-  size_t bufferOutLength;
-  int topOffsetPre;
-  int leftOffsetPre;
-  int widthPre;
-  int heightPre;
-  int topOffsetPost;
-  int leftOffsetPost;
-  int widthPost;
-  int heightPost;
-  int width;
-  int height;
-  Canvas canvas;
-  int gravity;
-  std::string interpolator;
-  double background[4];
-  bool flatten;
-  int blurRadius;
-  int sharpenRadius;
-  double sharpenFlat;
-  double sharpenJagged;
-  double gamma;
-  bool greyscale;
-  int angle;
-  bool flip;
-  bool flop;
-  bool progressive;
-  bool withoutEnlargement;
-  VipsAccess accessMethod;
-  int quality;
-  int compressionLevel;
-  bool withoutAdaptiveFiltering;
-  std::string err;
-  bool withMetadata;
-
-  ResizeBaton():
-    bufferInLength(0),
-    outputFormat(""),
-    bufferOutLength(0),
-    topOffsetPre(-1),
-    topOffsetPost(-1),
-    canvas(Canvas::CROP),
-    gravity(0),
-    flatten(false),
-    blurRadius(0),
-    sharpenRadius(0),
-    sharpenFlat(1.0),
-    sharpenJagged(2.0),
-    gamma(0.0),
-    greyscale(false),
-    angle(0),
-    flip(false),
-    flop(false),
-    progressive(false),
-    withoutEnlargement(false),
-    quality(80),
-    compressionLevel(6),
-    withoutAdaptiveFiltering(false),
-    withMetadata(false) {
-      background[0] = 0.0;
-      background[1] = 0.0;
-      background[2] = 0.0;
-      background[3] = 255.0;
-    }
-};
-
-class ResizeWorker : public NanAsyncWorker {
-
- public:
-  ResizeWorker(NanCallback *callback, ResizeBaton *baton) : NanAsyncWorker(callback), baton(baton) {}
-  ~ResizeWorker() {}
-
-  /*
-    libuv worker
-  */
-  void Execute() {
-    // Decrement queued task counter
-    g_atomic_int_dec_and_test(&counterQueue);
-    // Increment processing task counter
-    g_atomic_int_inc(&counterProcess);
-
-    // Hang image references from this hook object
-    VipsObject *hook = reinterpret_cast<VipsObject*>(vips_image_new());
-
-    // Input
-    ImageType inputImageType = ImageType::UNKNOWN;
-    VipsImage *image;
-    if (baton->bufferInLength > 1) {
-      // From buffer
-      inputImageType = DetermineImageType(baton->bufferIn, baton->bufferInLength);
-      if (inputImageType != ImageType::UNKNOWN) {
-        image = InitImage(inputImageType, baton->bufferIn, baton->bufferInLength, baton->accessMethod);
-      } else {
-        (baton->err).append("Input buffer contains unsupported image format");
-      }
-    } else {
-      // From file
-      inputImageType = DetermineImageType(baton->fileIn.c_str());
-      if (inputImageType != ImageType::UNKNOWN) {
-        image = InitImage(inputImageType, baton->fileIn.c_str(), baton->accessMethod);
-      } else {
-        (baton->err).append("File is of an unsupported image format");
-      }
-    }
-    if (inputImageType == ImageType::UNKNOWN) {
-      return Error(baton, hook);
-    }
-    vips_object_local(hook, image);
-
-    // Pre extraction
-    if (baton->topOffsetPre != -1) {
-      VipsImage *extractedPre;
-      if (vips_extract_area(image, &extractedPre, baton->leftOffsetPre, baton->topOffsetPre, baton->widthPre, baton->heightPre, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, extractedPre);
-      image = extractedPre;
-    }
-
-    // Get input image width and height
-    int inputWidth = image->Xsize;
-    int inputHeight = image->Ysize;
-
-    // Calculate angle of rotation, to be carried out later
-    Angle rotation;
-    bool flip;
-    std::tie(rotation, flip) = CalculateRotationAndFlip(baton->angle, image);
-    if (rotation == Angle::D90 || rotation == Angle::D270) {
-      // Swap input output width and height when rotating by 90 or 270 degrees
-      int swap = inputWidth;
-      inputWidth = inputHeight;
-      inputHeight = swap;
-    }
-    if (flip && !baton->flip) {
-      // Add flip operation due to EXIF mirroring
-      baton->flip = TRUE;
-    }
-
-    // Get window size of interpolator, used for determining shrink vs affine
-    int interpolatorWindowSize = InterpolatorWindowSize(baton->interpolator.c_str());
-
-    // Scaling calculations
-    double factor;
-    if (baton->width > 0 && baton->height > 0) {
-      // Fixed width and height
-      double xfactor = static_cast<double>(inputWidth) / static_cast<double>(baton->width);
-      double yfactor = static_cast<double>(inputHeight) / static_cast<double>(baton->height);
-      factor = (baton->canvas == Canvas::CROP) ? std::min(xfactor, yfactor) : std::max(xfactor, yfactor);
-      // if max is set, we need to compute the real size of the thumb image
-      if (baton->canvas == Canvas::MAX) {
-        if (xfactor > yfactor) {
-          baton->height = round(static_cast<double>(inputHeight) / xfactor);
-        } else {
-          baton->width = round(static_cast<double>(inputWidth) / yfactor);
-        }
-      }
-    } else if (baton->width > 0) {
-      // Fixed width, auto height
-      factor = static_cast<double>(inputWidth) / static_cast<double>(baton->width);
-      baton->height = floor(static_cast<double>(inputHeight) / factor);
-    } else if (baton->height > 0) {
-      // Fixed height, auto width
-      factor = static_cast<double>(inputHeight) / static_cast<double>(baton->height);
-      baton->width = floor(static_cast<double>(inputWidth) / factor);
-    } else {
-      // Identity transform
-      factor = 1;
-      baton->width = inputWidth;
-      baton->height = inputHeight;
-    }
-
-    // Calculate integral box shrink
-    int shrink = 1;
-    if (factor >= 2 && interpolatorWindowSize > 3) {
-      // Shrink less, affine more with interpolators that use at least 4x4 pixel window, e.g. bicubic
-      shrink = floor(factor * 3.0 / interpolatorWindowSize);
-    } else {
-      shrink = floor(factor);
-    }
-    if (shrink < 1) {
-      shrink = 1;
-    }
-
-    // Calculate residual float affine transformation
-    double residual = static_cast<double>(shrink) / factor;
-
-    // Do not enlarge the output if the input width *or* height are already less than the required dimensions
-    if (baton->withoutEnlargement) {
-      if (inputWidth < baton->width || inputHeight < baton->height) {
-        factor = 1;
-        shrink = 1;
-        residual = 0;
-        baton->width = inputWidth;
-        baton->height = inputHeight;
-      }
-    }
-
-    // Try to use libjpeg shrink-on-load, but not when applying gamma correction or pre-resize extract
-    int shrink_on_load = 1;
-    if (inputImageType == ImageType::JPEG && shrink >= 2 && baton->gamma == 0 && baton->topOffsetPre == -1) {
-      if (shrink >= 8) {
-        factor = factor / 8;
-        shrink_on_load = 8;
-      } else if (shrink >= 4) {
-        factor = factor / 4;
-        shrink_on_load = 4;
-      } else if (shrink >= 2) {
-        factor = factor / 2;
-        shrink_on_load = 2;
-      }
-    }
-    if (shrink_on_load > 1) {
-      // Recalculate integral shrink and double residual
-      factor = std::max(factor, 1.0);
-      if (factor >= 2 && interpolatorWindowSize > 3) {
-        shrink = floor(factor * 3.0 / interpolatorWindowSize);
-      } else {
-        shrink = floor(factor);
-      }
-      residual = static_cast<double>(shrink) / factor;
-      // Reload input using shrink-on-load
-      VipsImage *shrunkOnLoad;
-      if (baton->bufferInLength > 1) {
-        if (vips_jpegload_buffer(baton->bufferIn, baton->bufferInLength, &shrunkOnLoad, "shrink", shrink_on_load, NULL)) {
-          return Error(baton, hook);
-        }
-      } else {
-        if (vips_jpegload((baton->fileIn).c_str(), &shrunkOnLoad, "shrink", shrink_on_load, NULL)) {
-          return Error(baton, hook);
-        }
-      }
-      vips_object_local(hook, shrunkOnLoad);
-      image = shrunkOnLoad;
-    }
-
-    // Handle colour profile, if any, for non sRGB images
-    if (image->Type != VIPS_INTERPRETATION_sRGB) {
-      // Get the input colour profile
-      if (vips_image_get_typeof(image, VIPS_META_ICC_NAME)) {
-        VipsImage *profile;
-        // Use embedded profile
-        if (vips_icc_import(image, &profile, "pcs", VIPS_PCS_XYZ, "embedded", TRUE, NULL)) {
-          return Error(baton, hook);
-        }
-        vips_object_local(hook, profile);
-        image = profile;
-      } else if (image->Type == VIPS_INTERPRETATION_CMYK) {
-        VipsImage *profile;
-        // CMYK with no embedded profile
-        if (vips_icc_import(image, &profile, "pcs", VIPS_PCS_XYZ, "input_profile", (baton->iccProfileCmyk).c_str(), NULL)) {
-          return Error(baton, hook);
-        }
-        vips_object_local(hook, profile);
-        image = profile;
-      }
-      // Attempt to convert to sRGB colour space
-      VipsImage *colourspaced;
-      if (vips_colourspace(image, &colourspaced, VIPS_INTERPRETATION_sRGB, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, colourspaced);
-      image = colourspaced;
-    }
-
-    // Flatten image to remove alpha channel
-    if (baton->flatten && HasAlpha(image)) {
-      // Background colour
-      VipsArrayDouble *background = vips_array_double_newv(
-        3, // Ignore alpha channel as we're about to remove it
-        baton->background[0],
-        baton->background[1],
-        baton->background[2]
-      );
-      VipsImage *flattened;
-      if (vips_flatten(image, &flattened, "background", background, NULL)) {
-        vips_area_unref(reinterpret_cast<VipsArea*>(background));
-        return Error(baton, hook);
-      };
-      vips_area_unref(reinterpret_cast<VipsArea*>(background));
-      vips_object_local(hook, flattened);
-      image = flattened;
-    }
-
-    // Gamma encoding (darken)
-    if (baton->gamma >= 1 && baton->gamma <= 3) {
-      VipsImage *gammaEncoded;
-      if (vips_gamma(image, &gammaEncoded, "exponent", 1.0 / baton->gamma, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, gammaEncoded);
-      image = gammaEncoded;
-    }
-
-    // Convert to greyscale (linear, therefore after gamma encoding, if any)
-    if (baton->greyscale) {
-      VipsImage *greyscale;
-      if (vips_colourspace(image, &greyscale, VIPS_INTERPRETATION_B_W, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, greyscale);
-      image = greyscale;
-    }
-
-    if (shrink > 1) {
-      VipsImage *shrunk;
-      // Use vips_shrink with the integral reduction
-      if (vips_shrink(image, &shrunk, shrink, shrink, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, shrunk);
-      image = shrunk;
-      // Recalculate residual float based on dimensions of required vs shrunk images
-      double shrunkWidth = shrunk->Xsize;
-      double shrunkHeight = shrunk->Ysize;
-      if (rotation == Angle::D90 || rotation == Angle::D270) {
-        // Swap input output width and height when rotating by 90 or 270 degrees
-        int swap = shrunkWidth;
-        shrunkWidth = shrunkHeight;
-        shrunkHeight = swap;
-      }
-      double residualx = static_cast<double>(baton->width) / static_cast<double>(shrunkWidth);
-      double residualy = static_cast<double>(baton->height) / static_cast<double>(shrunkHeight);
-      if (baton->canvas == Canvas::EMBED) {
-        residual = std::min(residualx, residualy);
-      } else {
-        residual = std::max(residualx, residualy);
-      }
-    }
-
-    // Use vips_affine with the remaining float part
-    if (residual != 0) {
-      // Apply variable blur radius of floor(residual) before large affine reductions
-      if (residual >= 1) {
-        VipsImage *blurred;
-        if (vips_gaussblur(image, &blurred, floor(residual), NULL)) {
-          return Error(baton, hook);
-        }
-        vips_object_local(hook, blurred);
-        image = blurred;
-      }
-      // Create interpolator - "bilinear" (default), "bicubic" or "nohalo"
-      VipsInterpolate *interpolator = vips_interpolate_new(baton->interpolator.c_str());
-      vips_object_local(hook, interpolator);
-      // Perform affine transformation
-      VipsImage *affined;
-      if (vips_affine(image, &affined, residual, 0, 0, residual, "interpolate", interpolator, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, affined);
-      image = affined;
-    }
-
-    // Rotate
-    if (rotation != Angle::D0) {
-      VipsImage *rotated;
-      if (vips_rot(image, &rotated, static_cast<VipsAngle>(rotation), NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, rotated);
-      image = rotated;
-    }
-
-    // Flip (mirror about Y axis)
-    if (baton->flip) {
-      VipsImage *flipped;
-      if (vips_flip(image, &flipped, VIPS_DIRECTION_VERTICAL, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, flipped);
-      image = flipped;
-    }
-
-    // Flop (mirror about X axis)
-    if (baton->flop) {
-      VipsImage *flopped;
-      if (vips_flip(image, &flopped, VIPS_DIRECTION_HORIZONTAL, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, flopped);
-      image = flopped;
-    }
-
-    // Crop/embed
-    if (image->Xsize != baton->width || image->Ysize != baton->height) {
-      if (baton->canvas == Canvas::EMBED) {
-        // Match background colour space, namely sRGB
-        if (image->Type != VIPS_INTERPRETATION_sRGB) {
-          // Convert to sRGB colour space
-          VipsImage *colourspaced;
-          if (vips_colourspace(image, &colourspaced, VIPS_INTERPRETATION_sRGB, NULL)) {
-            return Error(baton, hook);
-          }
-          vips_object_local(hook, colourspaced);
-          image = colourspaced;
-        }
-        // Add non-transparent alpha channel, if required
-        if (baton->background[3] < 255.0 && !HasAlpha(image)) {
-          // Create single-channel transparency
-          VipsImage *black;
-          if (vips_black(&black, image->Xsize, image->Ysize, "bands", 1, NULL)) {
-            return Error(baton, hook);
-          }
-          vips_object_local(hook, black);
-          // Invert to become non-transparent
-          VipsImage *alpha;
-          if (vips_invert(black, &alpha, NULL)) {
-            return Error(baton, hook);
-          }
-          vips_object_local(hook, alpha);
-          // Append alpha channel to existing image
-          VipsImage *joined;
-          if (vips_bandjoin2(image, alpha, &joined, NULL)) {
-            return Error(baton, hook);
-          }
-          vips_object_local(hook, joined);
-          image = joined;
-        }
-        // Create background
-        VipsArrayDouble *background;
-        if (baton->background[3] < 255.0) {
-          background = vips_array_double_newv(
-            4, baton->background[0], baton->background[1], baton->background[2], baton->background[3]
-          );
-        } else {
-          background = vips_array_double_newv(
-            3, baton->background[0], baton->background[1], baton->background[2]
-          );
-        }
-        // Embed
-        int left = (baton->width - image->Xsize) / 2;
-        int top = (baton->height - image->Ysize) / 2;
-        VipsImage *embedded;
-        if (vips_embed(image, &embedded, left, top, baton->width, baton->height,
-          "extend", VIPS_EXTEND_BACKGROUND, "background", background, NULL
-        )) {
-          vips_area_unref(reinterpret_cast<VipsArea*>(background));
-          return Error(baton, hook);
-        }
-        vips_area_unref(reinterpret_cast<VipsArea*>(background));
-        vips_object_local(hook, embedded);
-        image = embedded;
-      } else {
-        // Crop/max
-        int left;
-        int top;
-        std::tie(left, top) = CalculateCrop(image->Xsize, image->Ysize, baton->width, baton->height, baton->gravity);
-        int width = std::min(image->Xsize, baton->width);
-        int height = std::min(image->Ysize, baton->height);
-        VipsImage *extracted;
-        if (vips_extract_area(image, &extracted, left, top, width, height, NULL)) {
-          return Error(baton, hook);
-        }
-        vips_object_local(hook, extracted);
-        image = extracted;
-      }
-    }
-
-    // Post extraction
-    if (baton->topOffsetPost != -1) {
-      VipsImage *extractedPost;
-      if (vips_extract_area(image, &extractedPost, baton->leftOffsetPost, baton->topOffsetPost, baton->widthPost, baton->heightPost, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, extractedPost);
-      image = extractedPost;
-    }
-
-    // Blur
-    if (baton->blurRadius != 0) {
-      VipsImage *blurred;
-      if (baton->blurRadius == -1) {
-        // Fast, mild blur
-        VipsImage *blur = vips_image_new_matrixv(3, 3,
-          1.0, 1.0, 1.0,
-          1.0, 1.0, 1.0,
-          1.0, 1.0, 1.0);
-        vips_image_set_double(blur, "scale", 9);
-        vips_object_local(hook, blur);
-        if (vips_conv(image, &blurred, blur, NULL)) {
-          return Error(baton, hook);
-        }
-      } else {
-        // Slower, accurate Gaussian blur
-        if (vips_gaussblur(image, &blurred, baton->blurRadius, NULL)) {
-          return Error(baton, hook);
-        }
-      }
-      vips_object_local(hook, blurred);
-      image = blurred;
-    }
-
-    // Sharpen
-    if (baton->sharpenRadius != 0) {
-      VipsImage *sharpened;
-      if (baton->sharpenRadius == -1) {
-        // Fast, mild sharpen
-        VipsImage *sharpen = vips_image_new_matrixv(3, 3,
-          -1.0, -1.0, -1.0,
-          -1.0, 32.0, -1.0,
-          -1.0, -1.0, -1.0);
-        vips_image_set_double(sharpen, "scale", 24);
-        vips_object_local(hook, sharpen);
-        if (vips_conv(image, &sharpened, sharpen, NULL)) {
-          return Error(baton, hook);
-        }
-      } else {
-        // Slow, accurate sharpen in LAB colour space, with control over flat vs jagged areas
-        if (vips_sharpen(image, &sharpened, "radius", baton->sharpenRadius, "m1", baton->sharpenFlat, "m2", baton->sharpenJagged, NULL)) {
-          return Error(baton, hook);
-        }
-      }
-      vips_object_local(hook, sharpened);
-      image = sharpened;
-    }
-
-    // Gamma decoding (brighten)
-    if (baton->gamma >= 1 && baton->gamma <= 3) {
-      VipsImage *gammaDecoded;
-      if (vips_gamma(image, &gammaDecoded, "exponent", baton->gamma, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, gammaDecoded);
-      image = gammaDecoded;
-    }
-
-    // Convert to sRGB colour space, if not already
-    if (image->Type != VIPS_INTERPRETATION_sRGB) {
-      VipsImage *colourspaced;
-      if (vips_colourspace(image, &colourspaced, VIPS_INTERPRETATION_sRGB, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, colourspaced);
-      image = colourspaced;
-    }
-
-#if !(VIPS_MAJOR_VERSION >= 7 && VIPS_MINOR_VERSION >= 40 && VIPS_MINOR_VERSION >= 5)
-    // Generate image tile cache when interlace output is required - no longer required as of libvips 7.40.5+
-    if (baton->progressive) {
-      VipsImage *cached;
-      if (vips_tilecache(image, &cached, "threaded", TRUE, "persistent", TRUE, "max_tiles", -1, NULL)) {
-        return Error(baton, hook);
-      }
-      vips_object_local(hook, cached);
-      image = cached;
-    }
-#endif
-
-    // Output
-    if (baton->output == "__jpeg" || (baton->output == "__input" && inputImageType == ImageType::JPEG)) {
-      // Write JPEG to buffer
-      if (vips_jpegsave_buffer(image, &baton->bufferOut, &baton->bufferOutLength, "strip", !baton->withMetadata,
-        "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
-        return Error(baton, hook);
-      }
-      baton->outputFormat = "jpeg";
-    } else if (baton->output == "__png" || (baton->output == "__input" && inputImageType == ImageType::PNG)) {
-#if (VIPS_MAJOR_VERSION >= 7 && VIPS_MINOR_VERSION >= 41)
-      // Select PNG row filter
-      int filter = baton->withoutAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_NONE : VIPS_FOREIGN_PNG_FILTER_ALL;
-      // Write PNG to buffer
-      if (vips_pngsave_buffer(image, &baton->bufferOut, &baton->bufferOutLength, "strip", !baton->withMetadata,
-        "compression", baton->compressionLevel, "interlace", baton->progressive, "filter", filter, NULL)) {
-        return Error(baton, hook);
-      }
-#else
-      // Write PNG to buffer
-      if (vips_pngsave_buffer(image, &baton->bufferOut, &baton->bufferOutLength, "strip", !baton->withMetadata,
-        "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
-        return Error(baton, hook);
-      }
-#endif
-      baton->outputFormat = "png";
-    } else if (baton->output == "__webp" || (baton->output == "__input" && inputImageType == ImageType::WEBP)) {
-      // Write WEBP to buffer
-      if (vips_webpsave_buffer(image, &baton->bufferOut, &baton->bufferOutLength, "strip", !baton->withMetadata,
-        "Q", baton->quality, NULL)) {
-        return Error(baton, hook);
-      }
-      baton->outputFormat = "webp";
-    } else {
-      bool outputJpeg = IsJpeg(baton->output);
-      bool outputPng = IsPng(baton->output);
-      bool outputWebp = IsWebp(baton->output);
-      bool outputTiff = IsTiff(baton->output);
-      bool matchInput = !(outputJpeg || outputPng || outputWebp || outputTiff);
-      if (outputJpeg || (matchInput && inputImageType == ImageType::JPEG)) {
-        // Write JPEG to file
-        if (vips_jpegsave(image, baton->output.c_str(), "strip", !baton->withMetadata,
-          "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
-          return Error(baton, hook);
-        }
-        baton->outputFormat = "jpeg";
-      } else if (outputPng || (matchInput && inputImageType == ImageType::PNG)) {
-#if (VIPS_MAJOR_VERSION >= 7 && VIPS_MINOR_VERSION >= 41)
-        // Select PNG row filter
-        int filter = baton->withoutAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_NONE : VIPS_FOREIGN_PNG_FILTER_ALL;
-        // Write PNG to file
-        if (vips_pngsave(image, baton->output.c_str(), "strip", !baton->withMetadata,
-          "compression", baton->compressionLevel, "interlace", baton->progressive, "filter", filter, NULL)) {
-          return Error(baton, hook);
-        }
-#else
-        // Write PNG to file
-        if (vips_pngsave(image, baton->output.c_str(), "strip", !baton->withMetadata,
-          "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
-          return Error(baton, hook);
-        }
-#endif
-        baton->outputFormat = "png";
-      } else if (outputWebp || (matchInput && inputImageType == ImageType::WEBP)) {
-        // Write WEBP to file
-        if (vips_webpsave(image, baton->output.c_str(), "strip", !baton->withMetadata,
-          "Q", baton->quality, NULL)) {
-          return Error(baton, hook);
-        }
-        baton->outputFormat = "webp";
-      } else if (outputTiff || (matchInput && inputImageType == ImageType::TIFF)) {
-        // Write TIFF to file
-        if (vips_tiffsave(image, baton->output.c_str(), "strip", !baton->withMetadata,
-          "compression", VIPS_FOREIGN_TIFF_COMPRESSION_JPEG, "Q", baton->quality, NULL)) {
-          return Error(baton, hook);
-        }
-        baton->outputFormat = "tiff";
-      } else {
-        (baton->err).append("Unsupported output " + baton->output);
-        return Error(baton, hook);
-      }
-    }
-    // Clean up any dangling image references
-    g_object_unref(hook);
-    // Clean up libvips' per-request data and threads
-    vips_error_clear();
-    vips_thread_shutdown();
-  }
-
-  void HandleOKCallback () {
-    NanScope();
-
-    Handle<Value> argv[3] = { NanNull(), NanNull(),  NanNull() };
-    if (!baton->err.empty()) {
-      // Error
-      argv[0] = Exception::Error(NanNew<String>(baton->err.data(), baton->err.size()));
-    } else {
-      int width = baton->width;
-      int height = baton->height;
-      if (baton->topOffsetPre != -1 && (baton->width == -1 || baton->height == -1)) {
-        width = baton->widthPre;
-        height = baton->heightPre;
-      }
-      if (baton->topOffsetPost != -1) {
-        width = baton->widthPost;
-        height = baton->heightPost;
-      }
-      // Info Object
-      Local<Object> info = NanNew<Object>();
-      info->Set(NanNew<String>("format"), NanNew<String>(baton->outputFormat));
-      info->Set(NanNew<String>("width"), NanNew<Number>(width));
-      info->Set(NanNew<String>("height"), NanNew<Number>(height));
-
-      if (baton->bufferOutLength > 0) {
-        // Buffer
-        argv[1] = NanNewBufferHandle(static_cast<char*>(baton->bufferOut), baton->bufferOutLength);
-        g_free(baton->bufferOut);
-        argv[2] = info;
-      } else {
-        // File
-        argv[1] = info;
-      }
-    }
-    delete baton;
-
-    // Decrement processing task counter
-    g_atomic_int_dec_and_test(&counterProcess);
-
-    // Return to JavaScript
-    callback->Call(3, argv);
-  }
-
- private:
-  ResizeBaton* baton;
-
-  /*
-    Calculate the angle of rotation and need-to-flip for the output image.
-    In order of priority:
-     1. Use explicitly requested angle (supports 90, 180, 270)
-     2. Use input image EXIF Orientation header - supports mirroring
-     3. Otherwise default to zero, i.e. no rotation
-  */
-  std::tuple<Angle, bool>
-  CalculateRotationAndFlip(int const angle, VipsImage const *input) {
-    Angle rotate = Angle::D0;
-    bool flip = FALSE;
-    if (angle == -1) {
-      switch(ExifOrientation(input)) {
-        case 6: rotate = Angle::D90; break;
-        case 3: rotate = Angle::D180; break;
-        case 8: rotate = Angle::D270; break;
-        case 2: flip = TRUE; break; // flip 1
-        case 7: flip = TRUE; rotate = Angle::D90; break; // flip 6
-        case 4: flip = TRUE; rotate = Angle::D180; break; // flip 3
-        case 5: flip = TRUE; rotate = Angle::D270; break; // flip 8
-      }
-    } else {
-      if (angle == 90) {
-        rotate = Angle::D90;
-      } else if (angle == 180) {
-        rotate = Angle::D180;
-      } else if (angle == 270) {
-        rotate = Angle::D270;
-      }
-    }
-    return std::make_tuple(rotate, flip);
-  }
-
-  /*
-    Calculate the (left, top) coordinates of the output image
-    within the input image, applying the given gravity.
-  */
-  std::tuple<int, int>
-  CalculateCrop(int const inWidth, int const inHeight, int const outWidth, int const outHeight, int const gravity) {
-    int left = 0;
-    int top = 0;
-    switch (gravity) {
-      case 1: // North
-        left = (inWidth - outWidth + 1) / 2;
-        break;
-      case 2: // East
-        left = inWidth - outWidth;
-        top = (inHeight - outHeight + 1) / 2;
-        break;
-      case 3: // South
-        left = (inWidth - outWidth + 1) / 2;
-        top = inHeight - outHeight;
-        break;
-      case 4: // West
-        top = (inHeight - outHeight + 1) / 2;
-        break;
-      default: // Centre
-        left = (inWidth - outWidth + 1) / 2;
-        top = (inHeight - outHeight + 1) / 2;
-    }
-    return std::make_tuple(left, top);
-  }
-
-  /*
-    Copy then clear the error message.
-    Unref all transitional images on the hook.
-    Clear all thread-local data.
-  */
-  void Error(ResizeBaton *baton, VipsObject *hook) {
-    // Get libvips' error message
-    (baton->err).append(vips_error_buffer());
-    // Clean up any dangling image references
-    g_object_unref(hook);
-    // Clean up libvips' per-request data and threads
-    vips_error_clear();
-    vips_thread_shutdown();
-  }
-};
-
-/*
-  resize(options, output, callback)
-*/
-NAN_METHOD(resize) {
-  NanScope();
-
-  // V8 objects are converted to non-V8 types held in the baton struct
-  ResizeBaton *baton = new ResizeBaton;
-  Local<Object> options = args[0]->ToObject();
-
-  // Input filename
-  baton->fileIn = *String::Utf8Value(options->Get(NanNew<String>("fileIn"))->ToString());
-  baton->accessMethod = options->Get(NanNew<String>("sequentialRead"))->BooleanValue() ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
-  // Input Buffer object
-  if (options->Get(NanNew<String>("bufferIn"))->IsObject()) {
-    Local<Object> buffer = options->Get(NanNew<String>("bufferIn"))->ToObject();
-    baton->bufferInLength = node::Buffer::Length(buffer);
-    baton->bufferIn = node::Buffer::Data(buffer);
-  }
-  // ICC profile to use when input CMYK image has no embedded profile
-  baton->iccProfileCmyk = *String::Utf8Value(options->Get(NanNew<String>("iccProfileCmyk"))->ToString());
-  // Extract image options
-  baton->topOffsetPre = options->Get(NanNew<String>("topOffsetPre"))->Int32Value();
-  baton->leftOffsetPre = options->Get(NanNew<String>("leftOffsetPre"))->Int32Value();
-  baton->widthPre = options->Get(NanNew<String>("widthPre"))->Int32Value();
-  baton->heightPre = options->Get(NanNew<String>("heightPre"))->Int32Value();
-  baton->topOffsetPost = options->Get(NanNew<String>("topOffsetPost"))->Int32Value();
-  baton->leftOffsetPost = options->Get(NanNew<String>("leftOffsetPost"))->Int32Value();
-  baton->widthPost = options->Get(NanNew<String>("widthPost"))->Int32Value();
-  baton->heightPost = options->Get(NanNew<String>("heightPost"))->Int32Value();
-  // Output image dimensions
-  baton->width = options->Get(NanNew<String>("width"))->Int32Value();
-  baton->height = options->Get(NanNew<String>("height"))->Int32Value();
-  // Canvas option
-  Local<String> canvas = options->Get(NanNew<String>("canvas"))->ToString();
-  if (canvas->Equals(NanNew<String>("c"))) {
-    baton->canvas = Canvas::CROP;
-  } else if (canvas->Equals(NanNew<String>("m"))) {
-    baton->canvas = Canvas::MAX;
-  } else if (canvas->Equals(NanNew<String>("e"))) {
-    baton->canvas = Canvas::EMBED;
-  }
-  // Background colour
-  Local<Array> background = Local<Array>::Cast(options->Get(NanNew<String>("background")));
-  for (int i = 0; i < 4; i++) {
-    baton->background[i] = background->Get(i)->NumberValue();
-  }
-  // Resize options
-  baton->withoutEnlargement = options->Get(NanNew<String>("withoutEnlargement"))->BooleanValue();
-  baton->gravity = options->Get(NanNew<String>("gravity"))->Int32Value();
-  baton->interpolator = *String::Utf8Value(options->Get(NanNew<String>("interpolator"))->ToString());
-  // Operators
-  baton->flatten = options->Get(NanNew<String>("flatten"))->BooleanValue();
-  baton->blurRadius = options->Get(NanNew<String>("blurRadius"))->Int32Value();
-  baton->sharpenRadius = options->Get(NanNew<String>("sharpenRadius"))->Int32Value();
-  baton->sharpenFlat = options->Get(NanNew<String>("sharpenFlat"))->NumberValue();
-  baton->sharpenJagged = options->Get(NanNew<String>("sharpenJagged"))->NumberValue();
-  baton->gamma = options->Get(NanNew<String>("gamma"))->NumberValue();
-  baton->greyscale = options->Get(NanNew<String>("greyscale"))->BooleanValue();
-  baton->angle = options->Get(NanNew<String>("angle"))->Int32Value();
-  baton->flip = options->Get(NanNew<String>("flip"))->BooleanValue();
-  baton->flop = options->Get(NanNew<String>("flop"))->BooleanValue();
-  // Output options
-  baton->progressive = options->Get(NanNew<String>("progressive"))->BooleanValue();
-  baton->quality = options->Get(NanNew<String>("quality"))->Int32Value();
-  baton->compressionLevel = options->Get(NanNew<String>("compressionLevel"))->Int32Value();
-  baton->withoutAdaptiveFiltering = options->Get(NanNew<String>("withoutAdaptiveFiltering"))->BooleanValue();
-  baton->withMetadata = options->Get(NanNew<String>("withMetadata"))->BooleanValue();
-  // Output filename or __format for Buffer
-  baton->output = *String::Utf8Value(options->Get(NanNew<String>("output"))->ToString());
-
-  // Join queue for worker thread
-  NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
-  NanAsyncQueueWorker(new ResizeWorker(callback, baton));
-
-  // Increment queued task counter
-  g_atomic_int_inc(&counterQueue);
-
-  NanReturnUndefined();
-}

src/resize.h

@@ -1,8 +0,0 @@
-#ifndef SHARP_RESIZE_H
-#define SHARP_RESIZE_H
-
-#include "nan.h"
-
-NAN_METHOD(resize);
-
-#endif

src/sharp.cc

@@ -1,39 +1,35 @@
 #include <node.h>
-#include <vips/vips.h>
+#include <vips/vips8>
 
 #include "nan.h"
 
 #include "common.h"
 #include "metadata.h"
-#include "resize.h"
+#include "pipeline.h"
 #include "utilities.h"
 
-using namespace v8;
-
-static void at_exit(void* arg) {
-  NanScope();
-  vips_shutdown();
-}
-
-extern "C" void init(Handle<Object> target) {
-  NanScope();
+NAN_MODULE_INIT(init) {
   vips_init("sharp");
-  node::AtExit(at_exit);
-
-  // Set libvips operation cache limits
-  vips_cache_set_max_mem(100 * 1048576); // 100 MB
-  vips_cache_set_max(500); // 500 operations
-
-  // Notify the V8 garbage collector of max cache size
-  NanAdjustExternalMemory(vips_cache_get_max_mem());
 
   // Methods available to JavaScript
-  NODE_SET_METHOD(target, "metadata", metadata);
-  NODE_SET_METHOD(target, "resize", resize);
-  NODE_SET_METHOD(target, "cache", cache);
-  NODE_SET_METHOD(target, "concurrency", concurrency);
-  NODE_SET_METHOD(target, "counters", counters);
-  NODE_SET_METHOD(target, "libvipsVersion", libvipsVersion);
+  Nan::Set(target, Nan::New("metadata").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(metadata)).ToLocalChecked());
+  Nan::Set(target, Nan::New("pipeline").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(pipeline)).ToLocalChecked());
+  Nan::Set(target, Nan::New("cache").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(cache)).ToLocalChecked());
+  Nan::Set(target, Nan::New("concurrency").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(concurrency)).ToLocalChecked());
+  Nan::Set(target, Nan::New("counters").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(counters)).ToLocalChecked());
+  Nan::Set(target, Nan::New("simd").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(simd)).ToLocalChecked());
+  Nan::Set(target, Nan::New("libvipsVersion").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(libvipsVersion)).ToLocalChecked());
+  Nan::Set(target, Nan::New("format").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(format)).ToLocalChecked());
+  Nan::Set(target, Nan::New("_maxColourDistance").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(_maxColourDistance)).ToLocalChecked());
 }
 
 NODE_MODULE(sharp, init)

src/utilities.cc

@@ -1,75 +1,259 @@
+#include <cmath>
 #include <node.h>
-#include <vips/vips.h>
+#include <vips/vips8>
+#include <vips/vector.h>
 
 #include "nan.h"
 
 #include "common.h"
+#include "operations.h"
 #include "utilities.h"
 
-using namespace v8;
-using namespace sharp;
+using v8::Boolean;
+using v8::Integer;
+using v8::Local;
+using v8::Number;
+using v8::Object;
+using v8::String;
+
+using Nan::HandleScope;
+using Nan::New;
+using Nan::Set;
+using Nan::ThrowError;
+using Nan::To;
+using Nan::Utf8String;
 
 /*
-  Get and set cache memory and item limits
+  Get and set cache limits
 */
 NAN_METHOD(cache) {
-  NanScope();
+  HandleScope();
 
-  // Set cache memory limit
-  if (args[0]->IsInt32()) {
-    int newMax = args[0]->Int32Value() * 1048576;
-    int oldMax = vips_cache_get_max_mem();
-    vips_cache_set_max_mem(newMax);
-
-    // Notify the V8 garbage collector of delta in max cache size
-    NanAdjustExternalMemory(newMax - oldMax);
+  // Set memory limit
+  if (info[0]->IsInt32()) {
+    vips_cache_set_max_mem(To<int32_t>(info[0]).FromJust() * 1048576);
+  }
+  // Set file limit
+  if (info[1]->IsInt32()) {
+    vips_cache_set_max_files(To<int32_t>(info[1]).FromJust());
+  }
+  // Set items limit
+  if (info[2]->IsInt32()) {
+    vips_cache_set_max(To<int32_t>(info[2]).FromJust());
   }
 
-  // Set cache items limit
-  if (args[1]->IsInt32()) {
-    vips_cache_set_max(args[1]->Int32Value());
-  }
+  // Get memory stats
+  Local<Object> memory = New<Object>();
+  Set(memory, New("current").ToLocalChecked(),
+    New<Integer>(static_cast<int>(round(vips_tracked_get_mem() / 1048576)))
+  );
+  Set(memory, New("high").ToLocalChecked(),
+    New<Integer>(static_cast<int>(round(vips_tracked_get_mem_highwater() / 1048576)))
+  );
+  Set(memory, New("max").ToLocalChecked(),
+    New<Integer>(static_cast<int>(round(vips_cache_get_max_mem() / 1048576)))
+  );
+  // Get file stats
+  Local<Object> files = New<Object>();
+  Set(files, New("current").ToLocalChecked(), New<Integer>(vips_tracked_get_files()));
+  Set(files, New("max").ToLocalChecked(), New<Integer>(vips_cache_get_max_files()));
 
-  // Get cache statistics
-  Local<Object> cache = NanNew<Object>();
-  cache->Set(NanNew<String>("current"), NanNew<Number>(vips_tracked_get_mem() / 1048576));
-  cache->Set(NanNew<String>("high"), NanNew<Number>(vips_tracked_get_mem_highwater() / 1048576));
-  cache->Set(NanNew<String>("memory"), NanNew<Number>(vips_cache_get_max_mem() / 1048576));
-  cache->Set(NanNew<String>("items"), NanNew<Number>(vips_cache_get_max()));
-  NanReturnValue(cache);
+  // Get item stats
+  Local<Object> items = New<Object>();
+  Set(items, New("current").ToLocalChecked(), New<Integer>(vips_cache_get_size()));
+  Set(items, New("max").ToLocalChecked(), New<Integer>(vips_cache_get_max()));
+
+  Local<Object> cache = New<Object>();
+  Set(cache, New("memory").ToLocalChecked(), memory);
+  Set(cache, New("files").ToLocalChecked(), files);
+  Set(cache, New("items").ToLocalChecked(), items);
+  info.GetReturnValue().Set(cache);
 }
 
 /*
   Get and set size of thread pool
 */
 NAN_METHOD(concurrency) {
-  NanScope();
+  HandleScope();
 
   // Set concurrency
-  if (args[0]->IsInt32()) {
-    vips_concurrency_set(args[0]->Int32Value());
+  if (info[0]->IsInt32()) {
+    vips_concurrency_set(To<int32_t>(info[0]).FromJust());
   }
   // Get concurrency
-  NanReturnValue(NanNew<Number>(vips_concurrency_get()));
+  info.GetReturnValue().Set(New<Integer>(vips_concurrency_get()));
 }
 
 /*
   Get internal counters (queued tasks, processing tasks)
 */
 NAN_METHOD(counters) {
-  NanScope();
-  Local<Object> counters = NanNew<Object>();
-  counters->Set(NanNew<String>("queue"), NanNew<Number>(counterQueue));
-  counters->Set(NanNew<String>("process"), NanNew<Number>(counterProcess));
-  NanReturnValue(counters);
+  using sharp::counterProcess;
+  using sharp::counterQueue;
+
+  HandleScope();
+  Local<Object> counters = New<Object>();
+  Set(counters, New("queue").ToLocalChecked(), New<Integer>(counterQueue));
+  Set(counters, New("process").ToLocalChecked(), New<Integer>(counterProcess));
+  info.GetReturnValue().Set(counters);
+}
+
+/*
+  Get and set use of SIMD vector unit instructions
+*/
+NAN_METHOD(simd) {
+  HandleScope();
+
+  // Set state
+  if (info[0]->IsBoolean()) {
+    vips_vector_set_enabled(To<bool>(info[0]).FromJust());
+  }
+  // Get state
+  info.GetReturnValue().Set(New<Boolean>(vips_vector_isenabled()));
 }
 
 /*
   Get libvips version
 */
 NAN_METHOD(libvipsVersion) {
-  NanScope();
+  HandleScope();
   char version[9];
-  snprintf(version, 9, "%d.%d.%d", vips_version(0), vips_version(1), vips_version(2));
-  NanReturnValue(NanNew<String>(version));
+  g_snprintf(version, sizeof(version), "%d.%d.%d", vips_version(0), vips_version(1), vips_version(2));
+  info.GetReturnValue().Set(New(version).ToLocalChecked());
+}
+
+/*
+  Get available input/output file/buffer/stream formats
+*/
+NAN_METHOD(format) {
+  HandleScope();
+
+  // Attribute names
+  Local<String> attrId = New("id").ToLocalChecked();
+  Local<String> attrInput = New("input").ToLocalChecked();
+  Local<String> attrOutput = New("output").ToLocalChecked();
+  Local<String> attrFile = New("file").ToLocalChecked();
+  Local<String> attrBuffer = New("buffer").ToLocalChecked();
+  Local<String> attrStream = New("stream").ToLocalChecked();
+
+  // Which load/save operations are available for each compressed format?
+  Local<Object> format = New<Object>();
+  for (std::string f : {
+    "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz", "ppm", "fits", "gif", "svg", "pdf", "v"
+  }) {
+    // Input
+    Local<Boolean> hasInputFile =
+      New<Boolean>(vips_type_find("VipsOperation", (f + "load").c_str()));
+    Local<Boolean> hasInputBuffer =
+      New<Boolean>(vips_type_find("VipsOperation", (f + "load_buffer").c_str()));
+    Local<Object> input = New<Object>();
+    Set(input, attrFile, hasInputFile);
+    Set(input, attrBuffer, hasInputBuffer);
+    Set(input, attrStream, hasInputBuffer);
+    // Output
+    Local<Boolean> hasOutputFile =
+      New<Boolean>(vips_type_find("VipsOperation", (f + "save").c_str()));
+    Local<Boolean> hasOutputBuffer =
+      New<Boolean>(vips_type_find("VipsOperation", (f + "save_buffer").c_str()));
+    Local<Object> output = New<Object>();
+    Set(output, attrFile, hasOutputFile);
+    Set(output, attrBuffer, hasOutputBuffer);
+    Set(output, attrStream, hasOutputBuffer);
+    // Other attributes
+    Local<Object> container = New<Object>();
+    Local<String> formatId = New(f).ToLocalChecked();
+    Set(container, attrId, formatId);
+    Set(container, attrInput, input);
+    Set(container, attrOutput, output);
+    // Add to set of formats
+    Set(format, formatId, container);
+  }
+
+  // Raw, uncompressed data
+  Local<Object> raw = New<Object>();
+  Local<String> rawId = New("raw").ToLocalChecked();
+  Set(raw, attrId, rawId);
+  Set(format, rawId, raw);
+  Local<Boolean> supported = New<Boolean>(true);
+  Local<Boolean> unsupported = New<Boolean>(false);
+  Local<Object> rawInput = New<Object>();
+  Set(rawInput, attrFile, unsupported);
+  Set(rawInput, attrBuffer, supported);
+  Set(rawInput, attrStream, supported);
+  Set(raw, attrInput, rawInput);
+  Local<Object> rawOutput = New<Object>();
+  Set(rawOutput, attrFile, unsupported);
+  Set(rawOutput, attrBuffer, supported);
+  Set(rawOutput, attrStream, supported);
+  Set(raw, attrOutput, rawOutput);
+
+  info.GetReturnValue().Set(format);
+}
+
+/*
+  Synchronous, internal-only method used by some of the functional tests.
+  Calculates the maximum colour distance using the DE2000 algorithm
+  between two images of the same dimensions and number of channels.
+*/
+NAN_METHOD(_maxColourDistance) {
+  using vips::VImage;
+  using vips::VError;
+  using sharp::DetermineImageType;
+  using sharp::ImageType;
+  using sharp::HasAlpha;
+
+  HandleScope();
+
+  // Open input files
+  VImage image1;
+  ImageType imageType1 = DetermineImageType(*Utf8String(info[0]));
+  if (imageType1 != ImageType::UNKNOWN) {
+    try {
+      image1 = VImage::new_from_file(*Utf8String(info[0]));
+    } catch (...) {
+      return ThrowError("Input file 1 has corrupt header");
+    }
+  } else {
+    return ThrowError("Input file 1 is of an unsupported image format");
+  }
+  VImage image2;
+  ImageType imageType2 = DetermineImageType(*Utf8String(info[1]));
+  if (imageType2 != ImageType::UNKNOWN) {
+    try {
+      image2 = VImage::new_from_file(*Utf8String(info[1]));
+    } catch (...) {
+      return ThrowError("Input file 2 has corrupt header");
+    }
+  } else {
+    return ThrowError("Input file 2 is of an unsupported image format");
+  }
+  // Ensure same number of channels
+  if (image1.bands() != image2.bands()) {
+    return ThrowError("mismatchedBands");
+  }
+  // Ensure same dimensions
+  if (image1.width() != image2.width() || image1.height() != image2.height()) {
+    return ThrowError("mismatchedDimensions");
+  }
+
+  double maxColourDistance;
+  try {
+    // Premultiply and remove alpha
+    if (HasAlpha(image1)) {
+      image1 = image1.premultiply().extract_band(1, VImage::option()->set("n", image1.bands() - 1));
+    }
+    if (HasAlpha(image2)) {
+      image2 = image2.premultiply().extract_band(1, VImage::option()->set("n", image2.bands() - 1));
+    }
+    // Calculate colour distance
+    maxColourDistance = image1.dE00(image2).max();
+  } catch (VError err) {
+    return ThrowError(err.what());
+  }
+
+  // Clean up libvips' per-request data and threads
+  vips_error_clear();
+  vips_thread_shutdown();
+
+  info.GetReturnValue().Set(New<Number>(maxColourDistance));
 }

src/utilities.h

@@ -1,11 +1,14 @@
-#ifndef SHARP_UTILITIES_H
-#define SHARP_UTILITIES_H
+#ifndef SRC_UTILITIES_H_
+#define SRC_UTILITIES_H_
 
 #include "nan.h"
 
 NAN_METHOD(cache);
 NAN_METHOD(concurrency);
 NAN_METHOD(counters);
+NAN_METHOD(simd);
 NAN_METHOD(libvipsVersion);
+NAN_METHOD(format);
+NAN_METHOD(_maxColourDistance);
 
-#endif
+#endif  // SRC_UTILITIES_H_

test/bench/package.json

@@ -5,17 +5,19 @@
   "author": "Lovell Fuller <npm@lovell.info>",
   "description": "Benchmark and performance tests for sharp",
   "scripts": {
-    "test": "node perf && node random && node parallel"
+    "test": "VIPS_WARNING=0 node perf && node random && node parallel"
   },
   "devDependencies": {
+    "async": "^2.1.1",
+    "benchmark": "^2.1.1",
+    "gm": "^1.23.0",
     "imagemagick": "^0.1.3",
-    "imagemagick-native": "^1.5.0",
-    "gm": "^1.17.0",
-    "async": "^0.9.0",
-    "semver": "^4.1.0",
-    "benchmark": "^1.0.0"
+    "imagemagick-native": "^1.9.3",
+    "jimp": "^0.2.27",
+    "lwip": "^0.0.9",
+    "semver": "^5.3.0"
   },
-  "license": "Apache 2.0",
+  "license": "Apache-2.0",
   "engines": {
     "node": ">=0.10"
   }

test/bench/parallel.js

@@ -1,5 +1,7 @@
 'use strict';
 
+process.env.UV_THREADPOOL_SIZE = 64;
+
 var assert = require('assert');
 var async = require('async');
 
@@ -10,12 +12,13 @@ var width = 720;
 var height = 480;
 
 sharp.concurrency(1);
+sharp.simd(true);
 
 var timer = setInterval(function() {
   console.dir(sharp.counters());
 }, 100);
 
-async.mapSeries([1, 1, 2, 4, 8, 16, 32, 64, 128], function(parallelism, next) {
+async.mapSeries([1, 1, 2, 4, 8, 16, 32, 64], function(parallelism, next) {
   var start = new Date().getTime();
   async.times(parallelism,
     function(id, callback) {

test/bench/random.js

@@ -8,11 +8,14 @@ var Benchmark = require('benchmark');
 var sharp = require('../../index');
 var fixtures = require('../fixtures');
 
+sharp.cache(false);
+sharp.simd(true);
+
 var min = 320;
 var max = 960;
 
 var randomDimension = function() {
-  return Math.random() * (max - min) + min;
+  return Math.ceil(Math.random() * (max - min) + min);
 };
 
 new Benchmark.Suite('random').add('imagemagick', {
@@ -23,7 +26,9 @@ new Benchmark.Suite('random').add('imagemagick', {
       dstPath: fixtures.outputJpg,
       quality: 0.8,
       width: randomDimension(),
-      height: randomDimension()
+      height: randomDimension(),
+      format: 'jpg',
+      filter: 'Lanczos'
     }, function(err) {
       if (err) {
         throw err;
@@ -35,31 +40,36 @@ new Benchmark.Suite('random').add('imagemagick', {
 }).add('gm', {
   defer: true,
   fn: function(deferred) {
-    gm(fixtures.inputJpg).resize(randomDimension(), randomDimension()).quality(80).toBuffer(function (err, buffer) {
-      if (err) {
-        throw err;
-      } else {
-        assert.notStrictEqual(null, buffer);
-        deferred.resolve();
-      }
-    });
+    gm(fixtures.inputJpg)
+      .resize(randomDimension(), randomDimension())
+      .filter('Lanczos')
+      .quality(80)
+      .toBuffer(function (err, buffer) {
+        if (err) {
+          throw err;
+        } else {
+          assert.notStrictEqual(null, buffer);
+          deferred.resolve();
+        }
+      });
   }
 }).add('sharp', {
   defer: true,
   fn: function(deferred) {
-    sharp(fixtures.inputJpg).resize(randomDimension(), randomDimension()).toBuffer(function(err, buffer) {
-      if (err) {
-        throw err;
-      } else {
-        assert.notStrictEqual(null, buffer);
-        deferred.resolve();
-      }
-    });
+    sharp(fixtures.inputJpg)
+      .resize(randomDimension(), randomDimension())
+      .toBuffer(function(err, buffer) {
+        if (err) {
+          throw err;
+        } else {
+          assert.notStrictEqual(null, buffer);
+          deferred.resolve();
+        }
+      });
   }
 }).on('cycle', function(event) {
   console.log(String(event.target));
 }).on('complete', function() {
-  var winner = this.filter('fastest').pluck('name');
+  var winner = this.filter('fastest').map('name');
   assert.strictEqual('sharp', String(winner), 'sharp was slower than ' + winner);
-  console.dir(sharp.cache());
 }).run();

test/fixtures/check.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+      <path d="M30,76q6-14,13-26q6-12,14-23q8-12,13-17q3-4,6-6q1-1,5-2q8-1,12-1q1,0,1,1q0,1-1,2q-13,11-27,33q-14,21-24,44q-4,9-5,11q-1,2-9,2q-5,0-6-1q-1-1-5-6q-5-8-12-15q-3-4-3-6q0-2,4-5q3-2,6-2q3,0,8,3q5,4,10,14z" fill="green" />
+</svg>