Release v0.27.2

- For Rosetta x64, prevent use of global ARM64 libvips
- For ARM64, improve error message when global libvips not found

.cirrus.yml

@@ -0,0 +1,15 @@
+freebsd_instance:
+  image_family: freebsd-13-0-snap
+
+task:
+  name: FreeBSD 13.0
+  env:
+    IGNORE_OSVERSION: yes
+  prerequisites_script:
+    - pkg update -f
+    - pkg upgrade -y
+    - pkg install -y pkgconf vips node npm
+  install_script:
+    - npm install --build-from-source --unsafe-perm
+  test_script:
+    - npm test

.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

.gitattributes

@@ -0,0 +1 @@
+src/libvips/* linguist-vendored

.github/CONTRIBUTING.md

@@ -0,0 +1,97 @@
+# 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](https://libvips.github.io/libvips/API/current/func-list.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 --build-from-source` 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.
+
+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.
+Please ensure backwards compatibility where possible.
+
+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 `background()` method present in v0.20.0 was deprecated in v0.21.0 and removed in v0.22.0.
+
+## Documentation
+
+The public API is documented with [JSDoc](http://usejsdoc.org/) annotated comments.
+
+These can be converted to Markdown by running:
+```sh
+npm run docs-build
+```
+
+Please include documentation updates in any Pull Request that modifies the public API.
+
+## 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
+```
+
+## Finally
+
+Please feel free to ask any questions via a
+[new issue](https://github.com/lovell/sharp/issues/new).
+
+If you're unable to post details publicly, please
+[e-mail](https://github.com/lovell/sharp/blob/master/package.json#L5)
+for private, paid consulting.

.github/FUNDING.yml

@@ -0,0 +1 @@
+open_collective: libvips

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Documentation
+    url: https://sharp.pixelplumbing.com/
+    about: Installation instructions, complete API documentation with examples, changelog

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,16 @@
+---
+name: Feature request
+about: Suggest an idea
+labels: enhancement
+
+---
+
+What are you trying to achieve?
+
+Have you searched for similar feature requests?
+
+What would you expect the API to look like?
+
+What alternatives have you considered?
+
+Is there a sample image that helps explain?

.github/ISSUE_TEMPLATE/installation.md

@@ -0,0 +1,22 @@
+---
+name: Installation
+about: Something went wrong during either 'npm install sharp' or 'require("sharp")'
+labels: installation
+
+---
+
+Did you see the [documentation relating to installation](https://sharp.pixelplumbing.com/install)?
+
+Have you ensured the architecture and platform of Node.js used for `npm install` is the same as the architecture and platform of Node.js used at runtime?
+
+Are you using the latest version? Is the version currently in use as reported by `npm ls sharp` the same as the latest version as reported by `npm view sharp dist-tags.latest`?
+
+If you are using npm v6 or earlier and installing as a `root` or `sudo` user, have you tried with the `npm install --unsafe-perm` flag?
+
+If you are using npm v7, does the user running `npm install` own the directory it is run in?
+
+If you are using the `ignore-scripts` feature of `npm`, have you tried with the `npm install --ignore-scripts=false` flag?
+
+What is the complete output of running `npm install --verbose sharp`? Have you checked this output for useful error messages?
+
+What is the output of running `npx envinfo --binaries --system`?

.github/ISSUE_TEMPLATE/possible-bug.md

@@ -0,0 +1,20 @@
+---
+name: Possible bug
+about: Installation of sharp was successful but then something unexpected occurred using one of its features
+labels: triage
+
+---
+
+<!-- If this issue relates to installation, please use https://github.com/lovell/sharp/issues/new?labels=installation&template=installation.md instead. -->
+
+Are you using the latest version? Is the version currently in use as reported by `npm ls sharp` the same as the latest version as reported by `npm view sharp dist-tags.latest`?
+
+What are the steps to reproduce?
+
+What is the expected behaviour?
+
+Are you able to provide a minimal, standalone code sample, without other dependencies, that demonstrates this problem?
+
+Are you able to provide a sample image that helps explain the problem?
+
+What is the output of running `npx envinfo --binaries --system`?

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,16 @@
+---
+name: Question
+about: For help understanding an existing feature
+labels: question
+
+---
+
+<!-- If this issue relates to installation, please use https://github.com/lovell/sharp/issues/new?labels=installation&template=installation.md instead. -->
+
+What are you trying to achieve?
+
+Have you searched for similar questions?
+
+Are you able to provide a minimal, standalone code sample that demonstrates this question?
+
+Are you able to provide a sample image that helps explain the question?

.github/workflows/ci.yml

@@ -0,0 +1,85 @@
+on:
+  - push
+  - pull_request
+jobs:
+  CI:
+    runs-on: ${{ matrix.os }}
+    container: ${{ matrix.container }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+            container: centos:7
+            nodejs_version: 10
+            coverage: true
+            prebuild: true
+          - os: ubuntu-20.04
+            container: centos:7
+            nodejs_version: 12
+          - os: ubuntu-20.04
+            container: centos:7
+            nodejs_version: 14
+          - os: ubuntu-20.04
+            container: centos:7
+            nodejs_version: 15
+          - os: ubuntu-20.04
+            container: node:10-alpine3.11
+            prebuild: true
+          - os: ubuntu-20.04
+            container: node:12-alpine3.11
+          - os: ubuntu-20.04
+            container: node:14-alpine3.11
+          - os: ubuntu-20.04
+            container: node:15-alpine3.11
+          - os: macos-10.15
+            nodejs_version: 10
+            prebuild: true
+          - os: macos-10.15
+            nodejs_version: 12
+          - os: macos-10.15
+            nodejs_version: 14
+          - os: macos-10.15
+            nodejs_version: 15
+          - os: windows-2019
+            nodejs_version: 10
+            prebuild: true
+          - os: windows-2019
+            nodejs_version: 12
+          - os: windows-2019
+            nodejs_version: 14
+          - os: windows-2019
+            nodejs_version: 15
+    steps:
+      - name: Dependencies (Linux glibc)
+        if: contains(matrix.container, 'centos')
+        run: |
+          curl -sL https://rpm.nodesource.com/setup_${{ matrix.nodejs_version }}.x | bash -
+          yum install -y gcc-c++ make git python3 nodejs
+      - name: Dependencies (Linux musl)
+        if: contains(matrix.container, 'alpine')
+        run: apk add build-base git python3 --update-cache
+      - name: Dependencies (macOS, Windows)
+        if: contains(matrix.os, 'macos') || contains(matrix.os, 'windows')
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.nodejs_version }}
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Fix working directory ownership
+        if: matrix.container
+        run: chown root.root .
+      - name: Install
+        run: npm install --build-from-source --unsafe-perm
+      - name: Test
+        run: npm test
+      - name: Coverage
+        if: matrix.coverage
+        uses: coverallsapp/github-action@v1.1.2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Prebuild
+        if: matrix.prebuild && startsWith(github.ref, 'refs/tags/')
+        env:
+          prebuild_upload: ${{ secrets.GITHUB_TOKEN }}
+        run: npx prebuild --runtime napi --target 3

.gitignore

@@ -1,17 +1,18 @@
-lib-cov
-*.seed
-*.log
-*.csv
-*.dat
-*.out
-*.pid
-*.gz
-
-pids
-logs
-results
 build
 node_modules
-tests/output.jpg
-
-npm-debug.log
+/coverage
+test/bench/node_modules
+test/fixtures/output*
+test/leak/libvips.supp
+test/saliency/report.json
+test/saliency/Image*
+test/saliency/[Uu]serData*
+!test/saliency/userData.js
+vendor
+.gitattributes
+.DS_Store
+.nyc_output
+.vscode/
+package-lock.json
+.idea
+.firebase

.prebuildrc

@@ -0,0 +1,4 @@
+{
+  "include-regex": "(sharp\\.node|libvips-cpp\\.dll)",
+  "strip": true
+}

.travis.yml

@@ -1,8 +1,62 @@
-language: node_js
-node_js:
-  - "0.11"
-  - "0.10"
-before_install:
- - sudo apt-get update -qq
- - sudo apt-get install -qq libvips-dev imagemagick
- - sudo ln -s /usr/lib/pkgconfig/vips-7.26.pc /usr/lib/pkgconfig/vips.pc
+jobs:
+  include:
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 10"
+      arch: arm64
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp arm64v8/debian:bullseye
+        - sudo docker exec sharp sh -c "apt-get update && apt-get install -y build-essential git python3 curl"
+        - sudo docker exec sharp sh -c "curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add -"
+        - sudo docker exec sharp sh -c "echo 'deb https://deb.nodesource.com/node_10.x sid main' >/etc/apt/sources.list.d/nodesource.list"
+        - sudo docker exec sharp sh -c "apt-get update && apt-get install -y nodejs=10.*"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+      after_success: "[[ -n $TRAVIS_TAG ]] && sudo docker exec --env prebuild_upload sharp sh -c \"npx prebuild --runtime napi --target 3\""
+
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 12"
+      arch: arm64
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp arm64v8/debian:bullseye
+        - sudo docker exec sharp sh -c "apt-get update && apt-get install -y build-essential git python3 curl"
+        - sudo docker exec sharp sh -c "curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add -"
+        - sudo docker exec sharp sh -c "echo 'deb https://deb.nodesource.com/node_12.x sid main' >/etc/apt/sources.list.d/nodesource.list"
+        - sudo docker exec sharp sh -c "apt-get update && apt-get install -y nodejs"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 14"
+      arch: arm64
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp arm64v8/debian:bullseye
+        - sudo docker exec sharp sh -c "apt-get update && apt-get install -y build-essential git python3 curl"
+        - sudo docker exec sharp sh -c "curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add -"
+        - sudo docker exec sharp sh -c "echo 'deb https://deb.nodesource.com/node_14.x sid main' >/etc/apt/sources.list.d/nodesource.list"
+        - sudo docker exec sharp sh -c "apt-get update && apt-get install -y nodejs"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 15"
+      arch: arm64
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo chown 0.0 ${PWD}
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp arm64v8/debian:bullseye
+        - sudo docker exec sharp sh -c "apt-get update && apt-get install -y build-essential git python3 curl"
+        - sudo docker exec sharp sh -c "curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add -"
+        - sudo docker exec sharp sh -c "echo 'deb https://deb.nodesource.com/node_15.x sid main' >/etc/apt/sources.list.d/nodesource.list"
+        - sudo docker exec sharp sh -c "apt-get update && apt-get install -y nodejs"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+cache:
+  npm: false

README.md

@@ -1,117 +1,116 @@
-# sharp
+# sharp
 
-_adj_
+<img src="https://cdn.jsdelivr.net/gh/lovell/sharp@master/docs/image/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
 
-1. clearly defined; distinct: a sharp photographic image. 
-2. quick, brisk, or spirited. 
-3. shrewd or astute: a sharp bargainer. 
-4. (Informal.) very stylish: a sharp dresser; a sharp jacket. 
+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, WebP and AVIF images of varying dimensions.
 
-The typical use case for this high speed Node.js module is to convert a large JPEG image to smaller JPEG images of varying dimensions.
+Resizing an image is typically 4x-5x faster than using the
+quickest ImageMagick and GraphicsMagick settings
+due to its use of [libvips](https://github.com/libvips/libvips).
 
-It is somewhat opinionated in that it only deals with JPEG images, always obeys the requested dimensions by either cropping or embedding and insists on a mild sharpen of the resulting image.
+Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
+Lanczos resampling ensures quality is not sacrificed for speed.
 
-Under the hood you'll find the blazingly fast [libvips](https://github.com/jcupitt/libvips) image processing library, originally created in 1989 at Birkbeck College and currently maintained by the University of Southampton.
+As well as image resizing, operations such as
+rotation, extraction, compositing and gamma correction are available.
 
-Performance is 4x-8x faster than ImageMagick and 2x-4x faster than GraphicsMagick, based mainly on the number of CPU cores available.
+Most modern macOS, Windows and Linux systems running Node.js v10+
+do not require any additional install or runtime dependencies.
 
-## Prerequisites
-
-* Node.js v0.8+
-* node-gyp
-* libvips-dev 7.28+
+## Examples
 
+```sh
+npm install sharp
 ```
-sudo npm install -g node-gyp
-sudo apt-get install libvips-dev
-```
-
-When installed as a package, please symlink `vips-7.28.pc` (or later, installed with libvips-dev) as `/usr/lib/pkgconfig/vips.pc`. To do this in Ubuntu 13.04 (64-bit), use:
-
-	sudo ln -s /usr/lib/x86_64-linux-gnu/pkgconfig/vips-7.28.pc /usr/lib/pkgconfig/vips.pc
-
-## Install
-
-	npm install sharp
-
-## Usage
-
-	var sharp = require("sharp");
-
-### crop(inputPath, outputPath, width, height, callback)
-
-Scale and crop JPEG `inputPath` to `width` x `height` and write JPEG to `outputPath` calling `callback` when complete.
-
-Example:
 
 ```javascript
-sharp.crop("input.jpg", "output.jpg", 300, 200, 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
-});
+const sharp = require('sharp');
 ```
 
-### embedWhite(inputPath, outputPath, width, height, callback)
-
-Scale and embed JPEG `inputPath` to `width` x `height` using a white canvas and write JPEG to `outputPath` calling `callback` when complete.
+### Callback
 
 ```javascript
-sharp.embedWhite("input.jpg", "output.jpg", 200, 300, function(err) {
-  if (err) {
-    throw err;
-  }
-  // output.jpg is a 200 pixels wide and 300 pixels high image
-  // containing a scaled version of input.jpg embedded on a white canvas
-});
+sharp(inputBuffer)
+  .resize(320, 240)
+  .toFile('output.webp', (err, info) => { ... });
 ```
 
-### embedBlack(inputPath, outputPath, width, height, callback)
-
-Scale and embed JPEG `inputPath` to `width` x `height` using a black canvas and write JPEG to `outputPath` calling `callback` when complete.
+### Promise
 
 ```javascript
-sharp.embedBlack("input.jpg", "output.jpg", 200, 300, function(err) {
-  if (err) {
-    throw err;
-  }
-  // output.jpg is a 200 pixels wide and 300 pixels high image
-  // containing a scaled version of input.jpg embedded on a black canvas
-});
+sharp('input.jpg')
+  .rotate()
+  .resize(200)
+  .toBuffer()
+  .then( data => { ... })
+  .catch( err => { ... });
 ```
 
-## Testing
+### Async/await
 
-	npm install --dev sharp
-	npm test
+```javascript
+const semiTransparentRedPng = await sharp({
+  create: {
+    width: 48,
+    height: 48,
+    channels: 4,
+    background: { r: 255, g: 0, b: 0, alpha: 0.5 }
+  }
+})
+  .png()
+  .toBuffer();
+```
 
-## Performance
+### Stream
 
-### AMD Athlon 4x core 3.3GHz 512KB L2
+```javascript
+const roundedCorners = Buffer.from(
+  '<svg><rect x="0" y="0" width="200" height="200" rx="50" ry="50"/></svg>'
+);
 
-* imagemagick x 5.55 ops/sec ±0.45% (31 runs sampled)
-* gm x 10.31 ops/sec ±3.57% (53 runs sampled)
-* epeg x 27.79 ops/sec ±0.12% (69 runs sampled)
-* sharp x 31.52 ops/sec ±8.74% (80 runs sampled)
+const roundedCornerResizer =
+  sharp()
+    .resize(200, 200)
+    .composite([{
+      input: roundedCorners,
+      blend: 'dest-in'
+    }])
+    .png();
 
-### AWS t1.micro
+readableStream
+  .pipe(roundedCornerResizer)
+  .pipe(writableStream);
+```
 
-* imagemagick x 1.36 ops/sec ±0.96% (11 runs sampled)
-* sharp x 12.42 ops/sec ±5.84% (64 runs sampled)
+[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.svg?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
+[![N-API v3](https://img.shields.io/badge/N--API-v3-green.svg)](https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api_version_matrix)
 
-### AWS m1.medium
+### Documentation
 
-* imagemagick x 1.38 ops/sec ±0.45% (11 runs sampled)
-* sharp x 12.66 ops/sec ±5.54% (65 runs sampled)
+Visit [sharp.pixelplumbing.com](https://sharp.pixelplumbing.com/) for complete
+[installation instructions](https://sharp.pixelplumbing.com/install),
+[API documentation](https://sharp.pixelplumbing.com/api-constructor),
+[benchmark tests](https://sharp.pixelplumbing.com/performance) and
+[changelog](https://sharp.pixelplumbing.com/changelog).
 
-### AWS c1.medium
+### Contributing
 
-* imagemagick x 2.10 ops/sec ±0.67% (15 runs sampled)
-* sharp x 18.97 ops/sec ±10.54% (52 runs sampled)
+A [guide for contributors](https://github.com/lovell/sharp/blob/master/.github/CONTRIBUTING.md)
+covers reporting bugs, requesting features and submitting code changes.
 
-### AWS m3.xlarge
+### Licensing
 
-* imagemagick x 4.46 ops/sec ±0.33% (26 runs sampled)
-* sharp x 28.89 ops/sec ±7.75% (74 runs sampled)
+Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Lovell Fuller and contributors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.

appveyor.yml

@@ -0,0 +1,18 @@
+os: Visual Studio 2019
+version: "{build}"
+build: off
+platform: x86
+environment:
+  matrix:
+  - nodejs_version: "10"
+    prebuild: true
+  - nodejs_version: "12"
+  - nodejs_version: "14"
+  - nodejs_version: "15"
+install:
+  - ps: Update-NodeJsInstallation (Get-NodeJsLatestBuild $env:nodejs_version)
+  - npm install --build-from-source
+test_script:
+  - npm test
+on_success:
+  - if [%prebuild%] == [true] if [%APPVEYOR_REPO_TAG%] == [true] npx prebuild --runtime napi --target 3

binding.gyp

@@ -1,17 +1,232 @@
 {
+  'variables': {
+    'vips_version': '<!(node -p "require(\'./lib/libvips\').minimumLibvipsVersion")',
+    'sharp_vendor_dir': '<(module_root_dir)/vendor/<(vips_version)'
+  },
   'targets': [{
+    'target_name': 'libvips-cpp',
+    'conditions': [
+      ['OS == "win"', {
+        # Build libvips C++ binding for Windows due to MSVC std library ABI changes
+        'type': 'shared_library',
+        'defines': [
+          'VIPS_CPLUSPLUS_EXPORTS',
+          '_ALLOW_KEYWORD_MACROS'
+        ],
+        'sources': [
+          'src/libvips/cplusplus/VError.cpp',
+          'src/libvips/cplusplus/VConnection.cpp',
+          'src/libvips/cplusplus/VInterpolate.cpp',
+          'src/libvips/cplusplus/VImage.cpp'
+        ],
+        'include_dirs': [
+          '<(sharp_vendor_dir)/include',
+          '<(sharp_vendor_dir)/include/glib-2.0',
+          '<(sharp_vendor_dir)/lib/glib-2.0/include'
+        ],
+        'link_settings': {
+          'library_dirs': ['<(sharp_vendor_dir)/lib'],
+          'libraries': [
+            'libvips.lib',
+            'libglib-2.0.lib',
+            'libgobject-2.0.lib'
+          ],
+        },
+        'configurations': {
+          'Release': {
+            'msvs_settings': {
+              'VCCLCompilerTool': {
+                'ExceptionHandling': 1,
+                'WholeProgramOptimization': 'true'
+              },
+              'VCLibrarianTool': {
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              },
+              'VCLinkerTool': {
+                'ImageHasSafeExceptionHandlers': 'false',
+                'OptimizeReferences': 2,
+                'EnableCOMDATFolding': 2,
+                'LinkIncremental': 1,
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              }
+            },
+            'msvs_disabled_warnings': [
+              4275
+            ]
+          }
+        }
+      }, {
+        # Ignore this target for non-Windows
+        'type': 'none'
+      }]
+    ]
+  }, {
     'target_name': 'sharp',
-    'sources': ['src/sharp.cc'],
-    'libraries': [
-      '<!@(PKG_CONFIG_PATH="/usr/local/lib/pkgconfig" pkg-config --libs vips)',
-      '<!@(PKG_CONFIG_PATH="/usr/lib/pkgconfig" pkg-config --libs vips)'
+    'defines': [
+      'NAPI_VERSION=3'
+    ],
+    'dependencies': [
+      '<!(node -p "require(\'node-addon-api\').gyp")',
+      'libvips-cpp'
+    ],
+    'variables': {
+      'runtime_link%': 'shared',
+      'conditions': [
+        ['OS != "win"', {
+          'pkg_config_path': '<!(node -p "require(\'./lib/libvips\').pkgConfigPath()")',
+          'use_global_libvips': '<!(node -p "Boolean(require(\'./lib/libvips\').useGlobalLibvips()).toString()")'
+        }, {
+          'pkg_config_path': '',
+          'use_global_libvips': ''
+        }]
+      ]
+    },
+    'sources': [
+      'src/common.cc',
+      'src/metadata.cc',
+      'src/stats.cc',
+      'src/operations.cc',
+      'src/pipeline.cc',
+      'src/utilities.cc',
+      'src/sharp.cc'
     ],
     'include_dirs': [
-      '/usr/include/glib-2.0',
-      '/usr/lib/glib-2.0/include',
-      '/usr/lib/x86_64-linux-gnu/glib-2.0/include'
+      '<!(node -p "require(\'node-addon-api\').include_dir")',
     ],
-    'cflags': ['-fexceptions'],
-    'cflags_cc': ['-fexceptions']
+    'conditions': [
+      ['use_global_libvips == "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 --variable libdir vips-cpp)/libvips-cpp.so" | c++filt | grep -qF __cxx11;then echo "1";else echo "0";fi)'
+            ]
+          }]
+        ]
+      }, {
+        # Use pre-built libvips stored locally within node_modules
+        'include_dirs': [
+          '<(sharp_vendor_dir)/include',
+          '<(sharp_vendor_dir)/include/glib-2.0',
+          '<(sharp_vendor_dir)/lib/glib-2.0/include'
+        ],
+        'conditions': [
+          ['OS == "win"', {
+            'defines': [
+              '_ALLOW_KEYWORD_MACROS',
+              '_FILE_OFFSET_BITS=64'
+            ],
+            'link_settings': {
+              'library_dirs': ['<(sharp_vendor_dir)/lib'],
+              'libraries': [
+                'libvips.lib',
+                'libglib-2.0.lib',
+                'libgobject-2.0.lib'
+              ]
+            }
+          }],
+          ['OS == "mac"', {
+            'link_settings': {
+              'library_dirs': ['<(sharp_vendor_dir)/lib'],
+              'libraries': [
+                'libvips-cpp.42.dylib',
+                'libvips.42.dylib'
+              ]
+            },
+            'xcode_settings': {
+              'OTHER_LDFLAGS': [
+                # Ensure runtime linking is relative to sharp.node
+                '-Wl,-rpath,\'@loader_path/../../vendor/<(vips_version)/lib\''
+              ]
+            }
+          }],
+          ['OS == "linux"', {
+            'defines': [
+              '_GLIBCXX_USE_CXX11_ABI=0'
+            ],
+            'link_settings': {
+              'library_dirs': ['<(sharp_vendor_dir)/lib'],
+              'libraries': [
+                '-l:libvips-cpp.so.42',
+                '-l:libvips.so.42'
+              ],
+              'ldflags': [
+                # Ensure runtime linking is relative to sharp.node
+                '-Wl,-s -Wl,--disable-new-dtags -Wl,-rpath=\'$$ORIGIN/../../vendor/<(vips_version)/lib\''
+              ]
+            }
+          }]
+        ]
+      }]
+    ],
+    'cflags_cc': [
+      '-std=c++0x',
+      '-fexceptions',
+      '-Wall',
+      '-O3'
+    ],
+    'xcode_settings': {
+      'CLANG_CXX_LANGUAGE_STANDARD': 'c++11',
+      'MACOSX_DEPLOYMENT_TARGET': '10.9',
+      'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+      'GCC_ENABLE_CPP_RTTI': 'YES',
+      'OTHER_CPLUSPLUSFLAGS': [
+        '-fexceptions',
+        '-Wall',
+        '-O3'
+      ]
+    },
+    'configurations': {
+      'Release': {
+        'conditions': [
+          ['OS == "linux"', {
+            'cflags_cc': [
+              '-Wno-cast-function-type'
+            ]
+          }],
+          ['target_arch == "arm"', {
+            'cflags_cc': [
+              '-Wno-psabi'
+            ]
+          }],
+          ['OS == "win"', {
+            'msvs_settings': {
+              'VCCLCompilerTool': {
+                'ExceptionHandling': 1,
+                'WholeProgramOptimization': 'true'
+              },
+              'VCLibrarianTool': {
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              },
+              'VCLinkerTool': {
+                'ImageHasSafeExceptionHandlers': 'false',
+                'OptimizeReferences': 2,
+                'EnableCOMDATFolding': 2,
+                'LinkIncremental': 1,
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              }
+            },
+            'msvs_disabled_warnings': [
+              4275
+            ]
+          }]
+        ]
+      }
+    },
   }]
 }

docs/README.md

@@ -0,0 +1,80 @@
+# sharp
+
+<img src="https://cdn.jsdelivr.net/gh/lovell/sharp@master/docs/image/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
+
+The typical use case for this high speed Node.js module
+is to convert large images in common formats to
+smaller, web-friendly JPEG, PNG, AVIF and WebP images of varying dimensions.
+
+Resizing an image is typically 4x-5x faster than using the
+quickest ImageMagick and GraphicsMagick settings
+due to its use of [libvips](https://github.com/libvips/libvips).
+
+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.
+
+Most modern macOS, Windows and Linux systems running Node.js v10+
+do not require any additional install or runtime dependencies.
+
+### Formats
+
+This module supports reading JPEG, PNG, WebP, AVIF, TIFF, GIF and SVG images.
+
+Output images can be in JPEG, PNG, WebP, AVIF and TIFF 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).
+
+### Fast
+
+This module is powered by the blazingly fast
+[libvips](https://github.com/libvips/libvips) image processing library,
+originally created in 1989 at Birkbeck College
+and currently maintained by a small team led 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/async/await 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 is disabled by default,
+which for diagrams and line art often produces the same result
+as [pngcrush](https://pmt.sourceforge.io/pngcrush/).
+
+### Contributing
+
+A [guide for contributors](https://github.com/lovell/sharp/blob/master/.github/CONTRIBUTING.md)
+covers reporting bugs, requesting features and submitting code changes.
+
+### Licensing
+
+Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Lovell Fuller and contributors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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/api-channel.md

@@ -0,0 +1,120 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## removeAlpha
+
+Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel.
+
+### Examples
+
+```javascript
+sharp('rgba.png')
+  .removeAlpha()
+  .toFile('rgb.png', function(err, info) {
+    // rgb.png is a 3 channel image without an alpha channel
+  });
+```
+
+Returns **Sharp** 
+
+## ensureAlpha
+
+Ensure alpha channel, if missing. The added alpha channel will be fully opaque. This is a no-op if the image already has an alpha channel.
+
+### Examples
+
+```javascript
+sharp('rgb.jpg')
+  .ensureAlpha()
+  .toFile('rgba.png', function(err, info) {
+    // rgba.png is a 4 channel image with a fully opaque alpha channel
+  });
+```
+
+Returns **Sharp** 
+
+**Meta**
+
+-   **since**: 0.21.2
+
+## extractChannel
+
+Extract a single channel from a multi-channel image.
+
+### Parameters
+
+-   `channel` **([number][1] \| [string][2])** zero-indexed channel/band number to extract, or `red`, `green`, `blue` or `alpha`.
+
+### Examples
+
+```javascript
+sharp(input)
+  .extractChannel('green')
+  .toColourspace('b-w')
+  .toFile('green.jpg', function(err, info) {
+    // info.channels === 1
+    // green.jpg is a greyscale image containing the green channel of the input
+   });
+```
+
+-   Throws **[Error][3]** Invalid channel
+
+Returns **Sharp** 
+
+## joinChannel
+
+Join one or more channels 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.
+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.
+For raw pixel input, the `options` object should contain a `raw` attribute, which follows the format of the attribute of the same name in the `sharp()` constructor.
+
+### Parameters
+
+-   `images` **([Array][4]&lt;([string][2] \| [Buffer][5])> | [string][2] \| [Buffer][5])** one or more images (file paths, Buffers).
+-   `options` **[Object][6]** image options, see `sharp()` constructor.
+
+
+-   Throws **[Error][3]** Invalid parameters
+
+Returns **Sharp** 
+
+## bandbool
+
+Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
+
+### Parameters
+
+-   `boolOp` **[string][2]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
+
+### Examples
+
+```javascript
+sharp('3-channel-rgb-input.png')
+  .bandbool(sharp.bool.and)
+  .toFile('1-channel-output.png', function (err, info) {
+    // The output will be a single channel image where each pixel `P = R & G & B`.
+    // If `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]`
+    // then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
+  });
+```
+
+-   Throws **[Error][3]** Invalid parameters
+
+Returns **Sharp** 
+
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+
+[5]: https://nodejs.org/api/buffer.html
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object

docs/api-colour.md

@@ -0,0 +1,87 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## tint
+
+Tint the image using the provided chroma while preserving the image luminance.
+An alpha channel may be present and will be unchanged by the operation.
+
+### Parameters
+
+-   `rgb` **([string][1] \| [Object][2])** parsed by the [color][3] module to extract chroma values.
+
+
+-   Throws **[Error][4]** Invalid parameter
+
+Returns **Sharp** 
+
+## 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.
+
+### Parameters
+
+-   `greyscale` **[Boolean][5]**  (optional, default `true`)
+
+Returns **Sharp** 
+
+## grayscale
+
+Alternative spelling of `greyscale`.
+
+### Parameters
+
+-   `grayscale` **[Boolean][5]**  (optional, default `true`)
+
+Returns **Sharp** 
+
+## toColourspace
+
+Set the output colourspace.
+By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
+
+### Parameters
+
+-   `colourspace` **[string][1]?** output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][6]
+
+### Examples
+
+```javascript
+// Output 16 bits per pixel RGB
+await sharp(input)
+ .toColourspace('rgb16')
+ .toFile('16-bpp.png')
+```
+
+-   Throws **[Error][4]** Invalid parameters
+
+Returns **Sharp** 
+
+## toColorspace
+
+Alternative spelling of `toColourspace`.
+
+### Parameters
+
+-   `colorspace` **[string][1]?** output colorspace.
+
+
+-   Throws **[Error][4]** Invalid parameters
+
+Returns **Sharp** 
+
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[3]: https://www.npmjs.org/package/color
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[6]: https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568

docs/api-composite.md

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

docs/api-constructor.md

@@ -0,0 +1,214 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## Sharp
+
+Constructor factory to create an instance of `sharp`, to which further methods are chained.
+
+JPEG, PNG, WebP, AVIF or TIFF format image data can be streamed out from this object.
+When using Stream based output, derived attributes are available from the `info` event.
+
+Non-critical problems encountered during processing are emitted as `warning` events.
+
+Implements the [stream.Duplex][1] class.
+
+### Parameters
+
+-   `input` **([Buffer][2] \| [Uint8Array][3] \| [Uint8ClampedArray][4] \| [string][5])?** if present, can be
+     a Buffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data, or
+     a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file.
+     JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
+-   `options` **[Object][6]?** if present, is an Object with optional attributes.
+    -   `options.failOnError` **[boolean][7]** by default halt processing and raise an error when loading invalid images.
+         Set this flag to `false` if you'd rather apply a "best effort" to decode images, even if the data is corrupt or invalid. (optional, default `true`)
+    -   `options.limitInputPixels` **([number][8] \| [boolean][7])** Do not process input images where the number of pixels
+         (width x height) exceeds this limit. Assumes image dimensions contained in the input metadata can be trusted.
+         An integral Number of pixels, zero or false to remove limit, true to use default limit of 268402689 (0x3FFF x 0x3FFF). (optional, default `268402689`)
+    -   `options.sequentialRead` **[boolean][7]** Set this to `true` to use sequential rather than random access where possible.
+         This can reduce memory usage and might improve performance on some systems. (optional, default `false`)
+    -   `options.density` **[number][8]** number representing the DPI for vector images in the range 1 to 100000. (optional, default `72`)
+    -   `options.pages` **[number][8]** number of pages to extract for multi-page input (GIF, WebP, AVIF, TIFF, PDF), use -1 for all pages. (optional, default `1`)
+    -   `options.page` **[number][8]** page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based. (optional, default `0`)
+    -   `options.level` **[number][8]** level to extract from a multi-level input (OpenSlide), zero based. (optional, default `0`)
+    -   `options.animated` **[boolean][7]** Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`). (optional, default `false`)
+    -   `options.raw` **[Object][6]?** describes raw pixel input image data. See `raw()` for pixel ordering.
+        -   `options.raw.width` **[number][8]?** integral number of pixels wide.
+        -   `options.raw.height` **[number][8]?** integral number of pixels high.
+        -   `options.raw.channels` **[number][8]?** integral number of channels, between 1 and 4.
+    -   `options.create` **[Object][6]?** describes a new image to be created.
+        -   `options.create.width` **[number][8]?** integral number of pixels wide.
+        -   `options.create.height` **[number][8]?** integral number of pixels high.
+        -   `options.create.channels` **[number][8]?** integral number of channels, either 3 (RGB) or 4 (RGBA).
+        -   `options.create.background` **([string][5] \| [Object][6])?** parsed by the [color][9] module to extract values for red, green, blue and alpha.
+        -   `options.create.noise` **[Object][6]?** describes a noise to be created.
+            -   `options.create.noise.type` **[string][5]?** type of generated noise, currently only `gaussian` is supported.
+            -   `options.create.noise.mean` **[number][8]?** mean of pixels in generated noise.
+            -   `options.create.noise.sigma` **[number][8]?** standard deviation of pixels in generated noise.
+
+### Examples
+
+```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);
+```
+
+```javascript
+// Create a blank 300x200 PNG image of semi-transluent red pixels
+sharp({
+  create: {
+    width: 300,
+    height: 200,
+    channels: 4,
+    background: { r: 255, g: 0, b: 0, alpha: 0.5 }
+  }
+})
+.png()
+.toBuffer()
+.then( ... );
+```
+
+```javascript
+// Convert an animated GIF to an animated WebP
+await sharp('in.gif', { animated: true }).toFile('out.webp');
+```
+
+```javascript
+// Read a raw array of pixels and save it to a png
+const input = Uint8Array.from([255, 255, 255, 0, 0, 0]); // or Uint8ClampedArray
+const image = sharp(input, {
+  // because the input does not contain its dimensions or how many channels it has
+  // we need to specify it in the constructor options
+  raw: {
+    width: 2,
+    height: 1,
+    channels: 3
+  }
+});
+await image.toFile('my-two-pixels.png');
+```
+
+```javascript
+// Generate RGB Gaussian noise
+await sharp({
+  create: {
+    width: 300,
+    height: 200,
+    channels: 3,
+    noise: {
+      type: 'gaussian',
+      mean: 128,
+      sigma: 30
+    }
+ }
+}).toFile('noise.png');
+```
+
+-   Throws **[Error][10]** Invalid parameters
+
+Returns **[Sharp][11]** 
+
+## clone
+
+Take a "snapshot" of the Sharp instance, returning a new instance.
+Cloned instances inherit the input of their parent instance.
+This allows multiple output Streams and therefore multiple processing pipelines to share a single input Stream.
+
+### Examples
+
+```javascript
+const 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
+```
+
+```javascript
+// Create a pipeline that will download an image, resize it and format it to different files
+// Using Promises to know when the pipeline is complete
+const fs = require("fs");
+const got = require("got");
+const sharpStream = sharp({
+  failOnError: false
+});
+
+const promises = [];
+
+promises.push(
+  sharpStream
+    .clone()
+    .jpeg({ quality: 100 })
+    .toFile("originalFile.jpg")
+);
+
+promises.push(
+  sharpStream
+    .clone()
+    .resize({ width: 500 })
+    .jpeg({ quality: 80 })
+    .toFile("optimized-500.jpg")
+);
+
+promises.push(
+  sharpStream
+    .clone()
+    .resize({ width: 500 })
+    .webp({ quality: 80 })
+    .toFile("optimized-500.webp")
+);
+
+// https://github.com/sindresorhus/got#gotstreamurl-options
+got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
+
+Promise.all(promises)
+  .then(res => { console.log("Done!", res); })
+  .catch(err => {
+    console.error("Error processing files, let's clean it up", err);
+    try {
+      fs.unlinkSync("originalFile.jpg");
+      fs.unlinkSync("optimized-500.jpg");
+      fs.unlinkSync("optimized-500.webp");
+    } catch (e) {}
+  });
+```
+
+Returns **[Sharp][11]** 
+
+[1]: http://nodejs.org/api/stream.html#stream_class_stream_duplex
+
+[2]: https://nodejs.org/api/buffer.html
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[9]: https://www.npmjs.org/package/color
+
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[11]: #sharp

docs/api-input.md

@@ -0,0 +1,109 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## metadata
+
+Fast access to (uncached) image metadata without decoding any compressed image data.
+A `Promise` is returned when `callback` is not provided.
+
+-   `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
+-   `size`: Total size of image in bytes, for Stream and Buffer input only
+-   `width`: Number of pixels wide (EXIF orientation is not taken into consideration)
+-   `height`: Number of pixels high (EXIF orientation is not taken into consideration)
+-   `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][1]
+-   `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
+-   `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...][2]
+-   `density`: Number of pixels per inch (DPI), if present
+-   `chromaSubsampling`: String containing JPEG chroma subsampling, `4:2:0` or `4:4:4` for RGB, `4:2:0:4` or `4:4:4:4` for CMYK
+-   `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
+-   `pages`: Number of pages/frames contained within the image, with support for TIFF, HEIF, PDF, animated GIF and animated WebP
+-   `pageHeight`: Number of pixels high each page in a multi-page image will be.
+-   `loop`: Number of times to loop an animated image, zero refers to a continuous loop.
+-   `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
+-   `pagePrimary`: Number of the primary page in a HEIF image
+-   `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
+-   `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][3] profile data, if present
+-   `iptc`: Buffer containing raw IPTC data, if present
+-   `xmp`: Buffer containing raw XMP data, if present
+-   `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
+
+### Parameters
+
+-   `callback` **[Function][4]?** called with the arguments `(err, metadata)`
+
+### Examples
+
+```javascript
+const 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
+  });
+```
+
+Returns **([Promise][5]&lt;[Object][6]> | Sharp)** 
+
+## stats
+
+Access to pixel-derived image statistics for every channel in the image.
+A `Promise` is returned when `callback` is not provided.
+
+-   `channels`: Array of channel statistics for each channel in the image. Each channel statistic contains
+    -   `min` (minimum value in the channel)
+    -   `max` (maximum value in the channel)
+    -   `sum` (sum of all values in a channel)
+    -   `squaresSum` (sum of squared values in a channel)
+    -   `mean` (mean of the values in a channel)
+    -   `stdev` (standard deviation for the values in a channel)
+    -   `minX` (x-coordinate of one of the pixel where the minimum lies)
+    -   `minY` (y-coordinate of one of the pixel where the minimum lies)
+    -   `maxX` (x-coordinate of one of the pixel where the maximum lies)
+    -   `maxY` (y-coordinate of one of the pixel where the maximum lies)
+-   `isOpaque`: Is the image fully opaque? Will be `true` if the image has no alpha channel or if every pixel is fully opaque.
+-   `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any (experimental)
+-   `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any (experimental)
+-   `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram (experimental)
+
+### Parameters
+
+-   `callback` **[Function][4]?** called with the arguments `(err, stats)`
+
+### Examples
+
+```javascript
+const image = sharp(inputJpg);
+image
+  .stats()
+  .then(function(stats) {
+     // stats contains the channel-wise statistics array and the isOpaque value
+  });
+```
+
+```javascript
+const { entropy, sharpness, dominant } = await sharp(input).stats();
+const { r, g, b } = dominant;
+```
+
+Returns **[Promise][5]&lt;[Object][6]>** 
+
+[1]: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation
+
+[2]: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsBandFormat
+
+[3]: https://www.npmjs.com/package/icc
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object

docs/api-operation.md

@@ -0,0 +1,401 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## rotate
+
+Rotate the output image by either an explicit angle
+or auto-orient based on the EXIF `Orientation` tag.
+
+If an angle is provided, it is converted to a valid positive degree rotation.
+For example, `-450` will produce a 270deg rotation.
+
+When rotating by an angle other than a multiple of 90,
+the background colour can be provided with the `background` option.
+
+If no angle is provided, it is determined from the EXIF data.
+Mirroring is supported and may infer the use of a flip operation.
+
+The use of `rotate` implies the removal of the EXIF `Orientation` tag, if any.
+
+Method order is important when both rotating and extracting regions,
+for example `rotate(x).extract(y)` will produce a different result to `extract(y).rotate(x)`.
+
+### Parameters
+
+-   `angle` **[number][1]** angle of rotation. (optional, default `auto`)
+-   `options` **[Object][2]?** if present, is an Object with optional attributes.
+    -   `options.background` **([string][3] \| [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
+
+### Examples
+
+```javascript
+const pipeline = sharp()
+  .rotate()
+  .resize(null, 200)
+  .toBuffer(function (err, outputBuffer, info) {
+    // outputBuffer contains 200px high JPEG image data,
+    // auto-rotated using EXIF Orientation tag
+    // info.width and info.height contain the dimensions of the resized image
+  });
+readableStream.pipe(pipeline);
+```
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## 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.
+
+### Parameters
+
+-   `flip` **[Boolean][6]**  (optional, default `true`)
+
+Returns **Sharp** 
+
+## 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.
+
+### Parameters
+
+-   `flop` **[Boolean][6]**  (optional, default `true`)
+
+Returns **Sharp** 
+
+## affine
+
+Perform an affine transform on an image. This operation will always occur after resizing, extraction and rotation, if any.
+
+You must provide an array of length 4 or a 2x2 affine transformation matrix.
+By default, new pixels are filled with a black background. You can provide a background color with the `background` option.
+A particular interpolator may also be specified. Set the `interpolator` option to an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.nohalo`.
+
+In the case of a 2x2 matrix, the transform is:
+
+-   X = `matrix[0, 0]` \* (x + `idx`) + `matrix[0, 1]` \* (y + `idy`) + `odx`
+-   Y = `matrix[1, 0]` \* (x + `idx`) + `matrix[1, 1]` \* (y + `idy`) + `ody`
+
+where:
+
+-   x and y are the coordinates in input image.
+-   X and Y are the coordinates in output image.
+-   (0,0) is the upper left corner.
+
+### Parameters
+
+-   `matrix` **([Array][7]&lt;[Array][7]&lt;[number][1]>> | [Array][7]&lt;[number][1]>)** affine transformation matrix
+-   `options` **[Object][2]?** if present, is an Object with optional attributes.
+    -   `options.background` **([String][3] \| [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
+    -   `options.idx` **[Number][1]** input horizontal offset (optional, default `0`)
+    -   `options.idy` **[Number][1]** input vertical offset (optional, default `0`)
+    -   `options.odx` **[Number][1]** output horizontal offset (optional, default `0`)
+    -   `options.ody` **[Number][1]** output vertical offset (optional, default `0`)
+    -   `options.interpolator` **[String][3]** interpolator (optional, default `sharp.interpolators.bicubic`)
+
+### Examples
+
+```javascript
+const pipeline = sharp()
+  .affine([[1, 0.3], [0.1, 0.7]], {
+     background: 'white',
+     interpolate: sharp.interpolators.nohalo
+  })
+  .toBuffer((err, outputBuffer, info) => {
+     // outputBuffer contains the transformed image
+     // info.width and info.height contain the new dimensions
+  });
+
+inputStream
+  .pipe(pipeline);
+```
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+**Meta**
+
+-   **since**: 0.27.0
+
+## sharpen
+
+Sharpen the image.
+When used without parameters, performs a fast, mild sharpen of the output image.
+When a `sigma` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space.
+Separate control over the level of sharpening in "flat" and "jagged" areas is available.
+
+### Parameters
+
+-   `sigma` **[number][1]?** the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+-   `flat` **[number][1]** the level of sharpening to apply to "flat" areas. (optional, default `1.0`)
+-   `jagged` **[number][1]** the level of sharpening to apply to "jagged" areas. (optional, default `2.0`)
+
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## median
+
+Apply median filter.
+When used without parameters the default window is 3x3.
+
+### Parameters
+
+-   `size` **[number][1]** square mask size: size x size (optional, default `3`)
+
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## blur
+
+Blur the image.
+When used without parameters, performs a fast, mild blur of the output image.
+When a `sigma` is provided, performs a slower, more accurate Gaussian blur.
+
+### Parameters
+
+-   `sigma` **[number][1]?** a value between 0.3 and 1000 representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## flatten
+
+Merge alpha transparency channel, if any, with a background.
+
+### Parameters
+
+-   `options` **[Object][2]?** 
+    -   `options.background` **([string][3] \| [Object][2])** background colour, parsed by the [color][4] module, defaults to black. (optional, default `{r:0,g:0,b:0}`)
+
+Returns **Sharp** 
+
+## 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`.
+This can improve the perceived brightness of a resized image in non-linear colour spaces.
+JPEG and WebP input images will not take advantage of the shrink-on-load performance optimisation
+when applying a gamma correction.
+
+Supply a second argument to use a different output gamma value, otherwise the first value is used in both cases.
+
+### Parameters
+
+-   `gamma` **[number][1]** value between 1.0 and 3.0. (optional, default `2.2`)
+-   `gammaOut` **[number][1]?** value between 1.0 and 3.0. (optional, defaults to same as `gamma`)
+
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## negate
+
+Produce the "negative" of the image.
+
+### Parameters
+
+-   `negate` **[Boolean][6]**  (optional, default `true`)
+
+Returns **Sharp** 
+
+## normalise
+
+Enhance output image contrast by stretching its luminance to cover the full dynamic range.
+
+### Parameters
+
+-   `normalise` **[Boolean][6]**  (optional, default `true`)
+
+Returns **Sharp** 
+
+## normalize
+
+Alternative spelling of normalise.
+
+### Parameters
+
+-   `normalize` **[Boolean][6]**  (optional, default `true`)
+
+Returns **Sharp** 
+
+## convolve
+
+Convolve the image with the specified kernel.
+
+### Parameters
+
+-   `kernel` **[Object][2]** 
+    -   `kernel.width` **[number][1]** width of the kernel in pixels.
+    -   `kernel.height` **[number][1]** width of the kernel in pixels.
+    -   `kernel.kernel` **[Array][7]&lt;[number][1]>** Array of length `width*height` containing the kernel values.
+    -   `kernel.scale` **[number][1]** the scale of the kernel in pixels. (optional, default `sum`)
+    -   `kernel.offset` **[number][1]** the offset of the kernel in pixels. (optional, default `0`)
+
+### Examples
+
+```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
+  });
+```
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## threshold
+
+Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+
+### Parameters
+
+-   `threshold` **[number][1]** a value in the range 0-255 representing the level at which the threshold will be applied. (optional, default `128`)
+-   `options` **[Object][2]?** 
+    -   `options.greyscale` **[Boolean][6]** convert to single channel greyscale. (optional, default `true`)
+    -   `options.grayscale` **[Boolean][6]** alternative spelling for greyscale. (optional, default `true`)
+
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## boolean
+
+Perform a bitwise boolean operation with operand image.
+
+This operation creates an output image where each pixel is the result of
+the selected bitwise boolean `operation` between the corresponding pixels of the input images.
+
+### Parameters
+
+-   `operand` **([Buffer][8] \| [string][3])** Buffer containing image data or string containing the path to an image file.
+-   `operator` **[string][3]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
+-   `options` **[Object][2]?** 
+    -   `options.raw` **[Object][2]?** describes operand when using raw pixel data.
+        -   `options.raw.width` **[number][1]?** 
+        -   `options.raw.height` **[number][1]?** 
+        -   `options.raw.channels` **[number][1]?** 
+
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## linear
+
+Apply the linear formula a \* input + b to the image (levels adjustment)
+
+### Parameters
+
+-   `a` **[number][1]** multiplier (optional, default `1.0`)
+-   `b` **[number][1]** offset (optional, default `0.0`)
+
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## recomb
+
+Recomb the image with the specified matrix.
+
+### Parameters
+
+-   `inputMatrix` **[Array][7]&lt;[Array][7]&lt;[number][1]>>** 3x3 Recombination matrix
+
+### Examples
+
+```javascript
+sharp(input)
+  .recomb([
+   [0.3588, 0.7044, 0.1368],
+   [0.2990, 0.5870, 0.1140],
+   [0.2392, 0.4696, 0.0912],
+  ])
+  .raw()
+  .toBuffer(function(err, data, info) {
+    // data contains the raw pixel data after applying the recomb
+    // With this example input, a sepia filter has been applied
+  });
+```
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+**Meta**
+
+-   **since**: 0.21.1
+
+## modulate
+
+Transforms the image using brightness, saturation and hue rotation.
+
+### Parameters
+
+-   `options` **[Object][2]?** 
+    -   `options.brightness` **[number][1]?** Brightness multiplier
+    -   `options.saturation` **[number][1]?** Saturation multiplier
+    -   `options.hue` **[number][1]?** Degrees for hue rotation
+
+### Examples
+
+```javascript
+sharp(input)
+  .modulate({
+    brightness: 2 // increase lightness by a factor of 2
+  });
+
+sharp(input)
+  .modulate({
+    hue: 180 // hue-rotate by 180 degrees
+  });
+
+// decreate brightness and saturation while also hue-rotating by 90 degrees
+sharp(input)
+  .modulate({
+    brightness: 0.5,
+    saturation: 0.5,
+    hue: 90
+  });
+```
+
+Returns **Sharp** 
+
+**Meta**
+
+-   **since**: 0.22.1
+
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[4]: https://www.npmjs.org/package/color
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+
+[8]: https://nodejs.org/api/buffer.html

docs/api-output.md

@@ -0,0 +1,455 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## toFile
+
+Write output image data to a file.
+
+If an explicit output format is not selected, it will be inferred from the extension,
+with JPEG, PNG, WebP, AVIF, TIFF, DZI, and libvips' V format supported.
+Note that raw pixel data is only supported for buffer output.
+
+By default all metadata will be removed, which includes EXIF-based orientation.
+See [withMetadata][1] for control over this.
+
+A `Promise` is returned when `callback` is not provided.
+
+### Parameters
+
+-   `fileOut` **[string][2]** the path to write the image data to.
+-   `callback` **[Function][3]?** called on completion with two arguments `(err, info)`.
+    `info` contains the output image `format`, `size` (bytes), `width`, `height`,
+    `channels` and `premultiplied` (indicating if premultiplication was used).
+    When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
+
+### Examples
+
+```javascript
+sharp(input)
+  .toFile('output.png', (err, info) => { ... });
+```
+
+```javascript
+sharp(input)
+  .toFile('output.png')
+  .then(info => { ... })
+  .catch(err => { ... });
+```
+
+-   Throws **[Error][4]** Invalid parameters
+
+Returns **[Promise][5]&lt;[Object][6]>** when no callback is provided
+
+## toBuffer
+
+Write output to a Buffer.
+JPEG, PNG, WebP, AVIF, TIFF and raw pixel data output are supported.
+
+If no explicit format is set, the output format will match the input image, except GIF and SVG input which become PNG output.
+
+By default all metadata will be removed, which includes EXIF-based orientation.
+See [withMetadata][1] for control over this.
+
+`callback`, if present, gets three arguments `(err, data, info)` where:
+
+-   `err` is an error, if any.
+-   `data` is the output image data.
+-   `info` contains the output image `format`, `size` (bytes), `width`, `height`,
+    `channels` and `premultiplied` (indicating if premultiplication was used).
+    When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
+
+A `Promise` is returned when `callback` is not provided.
+
+### Parameters
+
+-   `options` **[Object][6]?** 
+    -   `options.resolveWithObject` **[boolean][7]?** Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
+-   `callback` **[Function][3]?** 
+
+### Examples
+
+```javascript
+sharp(input)
+  .toBuffer((err, data, info) => { ... });
+```
+
+```javascript
+sharp(input)
+  .toBuffer()
+  .then(data => { ... })
+  .catch(err => { ... });
+```
+
+```javascript
+sharp(input)
+  .toBuffer({ resolveWithObject: true })
+  .then(({ data, info }) => { ... })
+  .catch(err => { ... });
+```
+
+```javascript
+const data = await sharp('my-image.jpg')
+  // output the raw pixels
+  .raw()
+  .toBuffer();
+
+// create a more type safe way to work with the raw pixel data
+// this will not copy the data, instead it will change `data`s underlying ArrayBuffer
+// so `data` and `pixelArray` point to the same memory location
+const pixelArray = new Uint8ClampedArray(data.buffer);
+
+// When you are done changing the pixelArray, sharp takes the `pixelArray` as an input
+await sharp(pixelArray).toFile('my-changed-image.jpg');
+```
+
+Returns **[Promise][5]&lt;[Buffer][8]>** when no callback is provided
+
+## withMetadata
+
+Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
+This will also convert to and add a web-friendly sRGB ICC profile unless a custom
+output profile is provided.
+
+The default behaviour, when `withMetadata` is not used, is to convert to the device-independent
+sRGB colour space and strip all metadata, including the removal of any ICC profile.
+
+### Parameters
+
+-   `options` **[Object][6]?** 
+    -   `options.orientation` **[number][9]?** value between 1 and 8, used to update the EXIF `Orientation` tag.
+    -   `options.icc` **[string][2]?** filesystem path to output ICC profile, defaults to sRGB.
+
+### Examples
+
+```javascript
+sharp('input.jpg')
+  .withMetadata()
+  .toFile('output-with-metadata.jpg')
+  .then(info => { ... });
+```
+
+-   Throws **[Error][4]** Invalid parameters
+
+Returns **Sharp** 
+
+## toFormat
+
+Force output to a given format.
+
+### Parameters
+
+-   `format` **([string][2] \| [Object][6])** as a string or an Object with an 'id' attribute
+-   `options` **[Object][6]** output options
+
+### Examples
+
+```javascript
+// Convert any input to PNG output
+const data = await sharp(input)
+  .toFormat('png')
+  .toBuffer();
+```
+
+-   Throws **[Error][4]** unsupported format or options
+
+Returns **Sharp** 
+
+## jpeg
+
+Use these JPEG options for output image.
+
+Some of these options require the use of a globally-installed libvips compiled with support for mozjpeg.
+
+### Parameters
+
+-   `options` **[Object][6]?** output options
+    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
+    -   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
+    -   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling (optional, default `'4:2:0'`)
+    -   `options.optimiseCoding` **[boolean][7]** optimise Huffman coding tables (optional, default `true`)
+    -   `options.optimizeCoding` **[boolean][7]** alternative spelling of optimiseCoding (optional, default `true`)
+    -   `options.trellisQuantisation` **[boolean][7]** apply trellis quantisation, requires libvips compiled with support for mozjpeg (optional, default `false`)
+    -   `options.overshootDeringing` **[boolean][7]** apply overshoot deringing, requires libvips compiled with support for mozjpeg (optional, default `false`)
+    -   `options.optimiseScans` **[boolean][7]** optimise progressive scans, forces progressive, requires libvips compiled with support for mozjpeg (optional, default `false`)
+    -   `options.optimizeScans` **[boolean][7]** alternative spelling of optimiseScans, requires libvips compiled with support for mozjpeg (optional, default `false`)
+    -   `options.quantisationTable` **[number][9]** quantization table to use, integer 0-8, requires libvips compiled with support for mozjpeg (optional, default `0`)
+    -   `options.quantizationTable` **[number][9]** alternative spelling of quantisationTable, requires libvips compiled with support for mozjpeg (optional, default `0`)
+    -   `options.force` **[boolean][7]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
+
+### Examples
+
+```javascript
+// Convert any input to very high quality JPEG output
+const data = await sharp(input)
+  .jpeg({
+    quality: 100,
+    chromaSubsampling: '4:4:4'
+  })
+  .toBuffer();
+```
+
+-   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+## png
+
+Use these PNG options for output image.
+
+PNG output is always full colour at 8 or 16 bits per pixel.
+Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
+
+Some of these options require the use of a globally-installed libvips compiled with support for libimagequant (GPL).
+
+### Parameters
+
+-   `options` **[Object][6]?** 
+    -   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
+    -   `options.compressionLevel` **[number][9]** zlib compression level, 0-9 (optional, default `9`)
+    -   `options.adaptiveFiltering` **[boolean][7]** use adaptive row filtering (optional, default `false`)
+    -   `options.palette` **[boolean][7]** quantise to a palette-based image with alpha transparency support, requires libvips compiled with support for libimagequant (optional, default `false`)
+    -   `options.quality` **[number][9]** use the lowest number of colours needed to achieve given quality, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `100`)
+    -   `options.colours` **[number][9]** maximum number of palette entries, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `256`)
+    -   `options.colors` **[number][9]** alternative spelling of `options.colours`, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `256`)
+    -   `options.dither` **[number][9]** level of Floyd-Steinberg error diffusion, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `1.0`)
+    -   `options.force` **[boolean][7]** force PNG output, otherwise attempt to use input format (optional, default `true`)
+
+### Examples
+
+```javascript
+// Convert any input to PNG output
+const data = await sharp(input)
+  .png()
+  .toBuffer();
+```
+
+-   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+## webp
+
+Use these WebP options for output image.
+
+### Parameters
+
+-   `options` **[Object][6]?** output options
+    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
+    -   `options.alphaQuality` **[number][9]** quality of alpha layer, integer 0-100 (optional, default `100`)
+    -   `options.lossless` **[boolean][7]** use lossless compression mode (optional, default `false`)
+    -   `options.nearLossless` **[boolean][7]** use near_lossless compression mode (optional, default `false`)
+    -   `options.smartSubsample` **[boolean][7]** use high quality chroma subsampling (optional, default `false`)
+    -   `options.reductionEffort` **[number][9]** level of CPU effort to reduce file size, integer 0-6 (optional, default `4`)
+    -   `options.pageHeight` **[number][9]?** page height for animated output
+    -   `options.loop` **[number][9]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
+    -   `options.delay` **[Array][10]&lt;[number][9]>?** list of delays between animation frames (in milliseconds)
+    -   `options.force` **[boolean][7]** force WebP output, otherwise attempt to use input format (optional, default `true`)
+
+### Examples
+
+```javascript
+// Convert any input to lossless WebP output
+const data = await sharp(input)
+  .webp({ lossless: true })
+  .toBuffer();
+```
+
+-   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+## gif
+
+Use these GIF options for output image.
+
+Requires libvips compiled with support for ImageMagick or GraphicsMagick.
+The prebuilt binaries do not include this - see
+[installing a custom libvips][11].
+
+### Parameters
+
+-   `options` **[Object][6]?** output options
+    -   `options.pageHeight` **[number][9]?** page height for animated output
+    -   `options.loop` **[number][9]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
+    -   `options.delay` **[Array][10]&lt;[number][9]>?** list of delays between animation frames (in milliseconds)
+    -   `options.force` **[boolean][7]** force GIF output, otherwise attempt to use input format (optional, default `true`)
+
+
+-   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+## tiff
+
+Use these TIFF options for output image.
+
+### Parameters
+
+-   `options` **[Object][6]?** output options
+    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
+    -   `options.force` **[boolean][7]** force TIFF output, otherwise attempt to use input format (optional, default `true`)
+    -   `options.compression` **[string][2]** compression options: lzw, deflate, jpeg, ccittfax4 (optional, default `'jpeg'`)
+    -   `options.predictor` **[string][2]** compression predictor options: none, horizontal, float (optional, default `'horizontal'`)
+    -   `options.pyramid` **[boolean][7]** write an image pyramid (optional, default `false`)
+    -   `options.tile` **[boolean][7]** write a tiled tiff (optional, default `false`)
+    -   `options.tileWidth` **[number][9]** horizontal tile size (optional, default `256`)
+    -   `options.tileHeight` **[number][9]** vertical tile size (optional, default `256`)
+    -   `options.xres` **[number][9]** horizontal resolution in pixels/mm (optional, default `1.0`)
+    -   `options.yres` **[number][9]** vertical resolution in pixels/mm (optional, default `1.0`)
+    -   `options.bitdepth` **[number][9]** reduce bitdepth to 1, 2 or 4 bit (optional, default `8`)
+
+### Examples
+
+```javascript
+// Convert SVG input to LZW-compressed, 1 bit per pixel TIFF output
+sharp('input.svg')
+  .tiff({
+    compression: 'lzw',
+    bitdepth: 1
+  })
+  .toFile('1-bpp-output.tiff')
+  .then(info => { ... });
+```
+
+-   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+## avif
+
+Use these AVIF options for output image.
+
+Whilst it is possible to create AVIF images smaller than 16x16 pixels,
+most web browsers do not display these properly.
+
+### Parameters
+
+-   `options` **[Object][6]?** output options
+    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `50`)
+    -   `options.lossless` **[boolean][7]** use lossless compression (optional, default `false`)
+    -   `options.speed` **[number][9]** CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest) (optional, default `5`)
+    -   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0 (optional, default `'4:2:0'`)
+
+
+-   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+**Meta**
+
+-   **since**: 0.27.0
+
+## heif
+
+Use these HEIF options for output image.
+
+Support for patent-encumbered HEIC images requires the use of a
+globally-installed libvips compiled with support for libheif, libde265 and x265.
+
+### Parameters
+
+-   `options` **[Object][6]?** output options
+    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `50`)
+    -   `options.compression` **[string][2]** compression format: av1, hevc (optional, default `'av1'`)
+    -   `options.lossless` **[boolean][7]** use lossless compression (optional, default `false`)
+    -   `options.speed` **[number][9]** CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest) (optional, default `5`)
+    -   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0 (optional, default `'4:2:0'`)
+
+
+-   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+**Meta**
+
+-   **since**: 0.23.0
+
+## raw
+
+Force output to be raw, uncompressed, 8-bit unsigned integer (unit8) pixel data.
+Pixel ordering is left-to-right, top-to-bottom, without padding.
+Channel ordering will be RGB or RGBA for non-greyscale colourspaces.
+
+### Examples
+
+```javascript
+// Extract raw RGB pixel data from JPEG input
+const { data, info } = await sharp('input.jpg')
+  .raw()
+  .toBuffer({ resolveWithObject: true });
+```
+
+```javascript
+// Extract alpha channel as raw pixel data from PNG input
+const data = await sharp('input.png')
+  .ensureAlpha()
+  .extractChannel(3)
+  .toColourspace('b-w')
+  .raw()
+  .toBuffer();
+```
+
+Returns **Sharp** 
+
+## tile
+
+Use tile-based deep zoom (image pyramid) output.
+Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
+Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed archive file format.
+
+Warning: multiple sharp instances concurrently producing tile output can expose a possible race condition in some versions of libgsf.
+
+### Parameters
+
+-   `options` **[Object][6]?** 
+    -   `options.size` **[number][9]** tile size in pixels, a value between 1 and 8192. (optional, default `256`)
+    -   `options.overlap` **[number][9]** tile overlap in pixels, a value between 0 and 8192. (optional, default `0`)
+    -   `options.angle` **[number][9]** tile angle of rotation, must be a multiple of 90. (optional, default `0`)
+    -   `options.background` **([string][2] \| [Object][6])** background colour, parsed by the [color][12] module, defaults to white without transparency. (optional, default `{r:255,g:255,b:255,alpha:1}`)
+    -   `options.depth` **[string][2]?** how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
+    -   `options.skipBlanks` **[number][9]** threshold to skip tile generation, a value 0 - 255 for 8-bit images or 0 - 65535 for 16-bit images (optional, default `-1`)
+    -   `options.container` **[string][2]** tile container, with value `fs` (filesystem) or `zip` (compressed file). (optional, default `'fs'`)
+    -   `options.layout` **[string][2]** filesystem layout, possible values are `dz`, `iiif`, `zoomify` or `google`. (optional, default `'dz'`)
+    -   `options.centre` **[boolean][7]** centre image in tile. (optional, default `false`)
+    -   `options.center` **[boolean][7]** alternative spelling of centre. (optional, default `false`)
+
+### Examples
+
+```javascript
+sharp('input.tiff')
+  .png()
+  .tile({
+    size: 512
+  })
+  .toFile('output.dz', function(err, info) {
+    // output.dzi is the Deep Zoom XML definition
+    // output_files contains 512x512 tiles grouped by zoom level
+  });
+```
+
+-   Throws **[Error][4]** Invalid parameters
+
+Returns **Sharp** 
+
+[1]: #withmetadata
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[8]: https://nodejs.org/api/buffer.html
+
+[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+
+[11]: https://sharp.pixelplumbing.com/install#custom-libvips
+
+[12]: https://www.npmjs.org/package/color

docs/api-resize.md

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

docs/api-utility.md

@@ -0,0 +1,185 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## format
+
+An Object containing nested boolean values representing the available input and output formats/methods.
+
+### Examples
+
+```javascript
+console.log(sharp.format);
+```
+
+Returns **[Object][1]** 
+
+## interpolators
+
+An Object containing the available interpolators and their proper values
+
+Type: [string][2]
+
+### nearest
+
+[Nearest neighbour interpolation][3]. Suitable for image enlargement only.
+
+### bilinear
+
+[Bilinear interpolation][4]. Faster than bicubic but with less smooth results.
+
+### bicubic
+
+[Bicubic interpolation][5] (the default).
+
+### locallyBoundedBicubic
+
+[LBB interpolation][6]. Prevents some "[acutance][7]" but typically reduces performance by a factor of 2.
+
+### nohalo
+
+[Nohalo interpolation][8]. Prevents acutance but typically reduces performance by a factor of 3.
+
+### vertexSplitQuadraticBasisSpline
+
+[VSQBS interpolation][9]. Prevents "staircasing" when enlarging.
+
+## versions
+
+An Object containing the version numbers of libvips and its dependencies.
+
+### Examples
+
+```javascript
+console.log(sharp.versions);
+```
+
+## cache
+
+Gets or, when options are provided, sets the limits of _libvips'_ operation cache.
+Existing entries in the cache will be trimmed after any change in limits.
+This method always returns cache statistics,
+useful for determining how much working memory is required for a particular task.
+
+### Parameters
+
+-   `options` **([Object][1] \| [boolean][10])** Object with the following attributes, or boolean where true uses default cache settings and false removes all caching (optional, default `true`)
+    -   `options.memory` **[number][11]** is the maximum memory in MB to use for this cache (optional, default `50`)
+    -   `options.files` **[number][11]** is the maximum number of files to hold open (optional, default `20`)
+    -   `options.items` **[number][11]** is the maximum number of operations to cache (optional, default `100`)
+
+### Examples
+
+```javascript
+const stats = sharp.cache();
+```
+
+```javascript
+sharp.cache( { items: 200 } );
+sharp.cache( { files: 0 } );
+sharp.cache(false);
+```
+
+Returns **[Object][1]** 
+
+## concurrency
+
+Gets or, when a concurrency is provided, sets
+the number of threads _libvips'_ should create to process each image.
+The default value is the number of CPU cores.
+A value of `0` will reset to this default.
+
+The maximum number of images that can be processed in parallel
+is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
+
+This method always returns the current concurrency.
+
+### Parameters
+
+-   `concurrency` **[number][11]?** 
+
+### Examples
+
+```javascript
+const threads = sharp.concurrency(); // 4
+sharp.concurrency(2); // 2
+sharp.concurrency(0); // 4
+```
+
+Returns **[number][11]** concurrency
+
+## queue
+
+An EventEmitter that emits a `change` event when a task is either:
+
+-   queued, waiting for _libuv_ to provide a worker thread
+-   complete
+
+### Examples
+
+```javascript
+sharp.queue.on('change', function(queueLength) {
+  console.log('Queue contains ' + queueLength + ' task(s)');
+});
+```
+
+## 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.
+
+### Examples
+
+```javascript
+const counters = sharp.counters(); // { queue: 2, process: 4 }
+```
+
+Returns **[Object][1]** 
+
+## simd
+
+Get and set use of SIMD vector unit instructions.
+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.
+
+### Parameters
+
+-   `simd` **[boolean][10]**  (optional, default `true`)
+
+### Examples
+
+```javascript
+const simd = sharp.simd();
+// simd is `true` if the runtime use of liborc is currently enabled
+```
+
+```javascript
+const simd = sharp.simd(false);
+// prevent libvips from using liborc at runtime
+```
+
+Returns **[boolean][10]** 
+
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[3]: http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation
+
+[4]: http://en.wikipedia.org/wiki/Bilinear_interpolation
+
+[5]: http://en.wikipedia.org/wiki/Bicubic_interpolation
+
+[6]: https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100
+
+[7]: http://en.wikipedia.org/wiki/Acutance
+
+[8]: http://eprints.soton.ac.uk/268086/
+
+[9]: https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48
+
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number

docs/build.js

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

docs/firebase.json

@@ -0,0 +1,118 @@
+{
+  "hosting": {
+    "site": "pixelplumbing-sharp",
+    "public": ".",
+    "ignore": [
+      ".*",
+      "build.js",
+      "firebase.json",
+      "*.md",
+      "image/**",
+      "search-index/**"
+    ],
+    "headers": [
+      {
+        "source": "**",
+        "headers": [
+          {
+            "key": "Cache-Control",
+            "value": "max-age=86400"
+          }
+        ]
+      }
+    ],
+    "redirects": [
+      {
+        "source": "**/install/**",
+        "destination": "/install",
+        "type": 301
+      },
+      {
+        "source": "/page/install",
+        "destination": "/install",
+        "type": 301
+      },
+      {
+        "source": "**/api-constructor/**",
+        "destination": "/api-constructor",
+        "type": 301
+      },
+      {
+        "source": "**/api-input/**",
+        "destination": "/api-input",
+        "type": 301
+      },
+      {
+        "source": "**/api-output/**",
+        "destination": "/api-output",
+        "type": 301
+      },
+      {
+        "source": "**/api-resize/**",
+        "destination": "/api-resize",
+        "type": 301
+      },
+      {
+        "source": "**/api-compsite/**",
+        "destination": "/api-compsite",
+        "type": 301
+      },
+      {
+        "source": "**/api-operation/**",
+        "destination": "/api-operation",
+        "type": 301
+      },
+      {
+        "source": "**/api-colour/**",
+        "destination": "/api-colour",
+        "type": 301
+      },
+      {
+        "source": "**/api-channel/**",
+        "destination": "/api-channel",
+        "type": 301
+      },
+      {
+        "source": "**/api-utility/**",
+        "destination": "/api-utility",
+        "type": 301
+      },
+      {
+        "source": "/page/api",
+        "destination": "/api-constructor",
+        "type": 301
+      },
+      {
+        "source": "**/performance/**",
+        "destination": "/performance",
+        "type": 301
+      },
+      {
+        "source": "/page/performance",
+        "destination": "/performance",
+        "type": 301
+      },
+      {
+        "source": "**/changelog/**",
+        "destination": "/changelog",
+        "type": 301
+      },
+      {
+        "source": "/page/changelog",
+        "destination": "/changelog",
+        "type": 301
+      },
+      {
+        "source": "/en/**",
+        "destination": "/",
+        "type": 301
+      }
+    ],
+    "rewrites": [
+      {
+        "source": "**",
+        "destination": "/index.html"
+      }
+    ]
+  }
+}

docs/humans.txt

@@ -0,0 +1,211 @@
+/* THANKS */
+
+Name: John Cupitt
+GitHub: https://github.com/jcupitt
+
+Name: Pierre Inglebert
+GitHub: https://github.com/pierreinglebert
+
+Name: Jonathan Ong
+GitHub: https://github.com/jonathanong
+
+Name: Chanon Sajjamanochai
+GitHub: https://github.com/chanon
+
+Name: Juliano Julio
+GitHub: https://github.com/julianojulio
+
+Name: Daniel Gasienica
+GitHub: https://github.com/gasi
+
+Name: Julian Walker
+GitHub: https://github.com/julianwa
+
+Name: Amit Pitaru
+GitHub: https://github.com/apitaru
+
+Name: Brandon Aaron
+GitHub: https://github.com/brandonaaron
+
+Name: Andreas Lind
+GitHub: https://github.com/papandreouGitHub:
+
+Name: Maurus Cuelenaere
+GitHub: https://github.com/mcuelenaere
+
+Name: Linus Unnebäck
+GitHub: https://github.com/LinusU
+
+Name: Victor Mateevitsi
+GitHub: https://github.com/mvictoras
+
+Name: Alaric Holloway
+GitHub: https://github.com/skedastik
+
+Name: Bernhard K. Weisshuhn
+GitHub: https://github.com/bkw
+
+Name: David A. Carley
+GitHub: https://github.com/dacarley
+
+Name: John Tobin
+GitHub: https://github.com/jtobinisaniceguy
+
+Name: Kenton Gray
+GitHub: https://github.com/kentongray
+
+Name: Felix Bünemann
+GitHub: https://github.com/felixbuenemann
+
+Name: Samy Al Zahrani
+GitHub: https://github.com/salzhrani
+
+Name: Chintan Thakkar
+GitHub: https://github.com/lemnisk8
+
+Name: F. Orlando Galashan
+GitHub: https://github.com/frulo
+
+Name: Kleis Auke Wolthuizen
+GitHub: https://github.com/kleisauke
+
+Name: Matt Hirsch
+GitHub: https://github.com/mhirsch
+
+Name: Rahul Nanwani
+GitHub: https://github.com/rnanwani
+
+Name: Matthias Thoemmes
+GitHub: https://github.com/cmtt
+
+Name: Patrick Paskaris
+GitHub: https://github.com/ppaskaris
+
+Name: Jérémy Lal
+GitHub: https://github.com/kapouer
+
+Name: Alice Monday
+GitHub: https://github.com/alice0meta
+
+Name: Kristo Jorgenson
+GitHub: https://github.com/kristojorg
+
+Name: Yves Bos
+GitHub: https://github.com/YvesBos
+
+Name: Nicolas Coden
+GitHub: https://github.com/ncoden
+
+Name: Matt Parrish
+GitHub: https://github.com/pbomb
+
+Name: Matthew McEachen
+GitHub: https://github.com/mceachen
+
+Name: Jarda Kotěšovec
+GitHub: https://github.com/jardakotesovec
+
+Name: Kenric D'Souza
+GitHub: https://github.com/AzureByte
+
+Name: Oleh Aleinyk
+GitHub: https://github.com/oaleynik
+
+Name: Marcel Bretschneider
+GitHub: https://github.com/3epnm
+
+Name: Andrea Bianco
+GitHub: https://github.com/BiancoA
+
+Name: Rik Heywood
+GitHub: https://github.com/rikh42
+
+Name: Thomas Parisot
+GitHub: https://github.com/oncletom
+
+Name: Nathan Graves
+GitHub: https://github.com/woolite64
+
+Name: Tom Lokhorst
+GitHub: https://github.com/tomlokhorst
+
+Name: Espen Hovlandsdal
+GitHub: https://github.com/rexxars
+
+Name: Sylvain Dumont
+GitHub: https://github.com/sylvaindumont
+
+Name: Alun Davies
+GitHub: https://github.com/alundavies
+
+Name: Aidan Hoolachan
+GitHub: https://github.com/ajhool
+
+Name: Axel Eirola
+GitHub: https://github.com/aeirola
+
+Name: Freezy
+GitHub: https://github.com/freezy
+
+Name: Julian Aubourg
+GitHub: https://github.com/jaubourg
+
+Name: Keith Belovay
+GitHub: https://github.com/fromkeith
+
+Name: Michael B. Klein
+GitHub: https://github.com/mbklein
+
+Name: Jakub Michálek
+GitHub: https://github.com/Goues
+
+Name: Ilya Ovdin
+GitHub: https://github.com/iovdin
+
+Name: Andargor
+GitHub: https://github.com/Andargor
+
+Name: Nicolas Stepien
+GitHub: https://github.com/MayhemYDG
+
+Name: Paul Neave
+GitHub: https://github.com/neave
+
+Name: Brendan Kennedy
+GitHub: https://github.com/rustyguts
+
+Name: Brychan Bennett-Odlum
+GitHub: https://github.com/BrychanOdlum
+
+Name: Edward Silverton
+GitHub: https://github.com/edsilv
+
+Name: Dumitru Deveatii
+GitHub: https://github.com/dimadeveatii
+
+Name: Roland Asmann
+GitHub: https://github.com/malice00
+
+Name: Roman Malieiev
+GitHub: https://github.com/romaleev
+
+Name: Jerome Vouillon
+GitHub: https://github.com/vouillon
+
+Name: Tomáš Szabo
+GitHub: https://github.com/deftomat
+
+Name: Robert O'Rourke
+GitHub: https://github.com/roborourke
+
+Name: Denis Soldatov
+GitHub: https://github.com/derom
+
+Name: Stefan Probst
+GitHub: https://github.com/stefanprobst
+
+Name: Thomas Beiganz
+GitHub: https://github.com/beig
+
+Name: Florian Busch
+GitHub: https://github.com/florian-busch

docs/image/sharp-logo-mono.svg

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

docs/image/sharp-logo.svg

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

docs/install.md

@@ -0,0 +1,247 @@
+# Installation
+
+```sh
+npm install sharp
+```
+
+```sh
+yarn add sharp
+```
+
+## Prerequisites
+
+* Node.js v10+
+
+## Prebuilt binaries
+
+Ready-compiled sharp and libvips binaries are provided for use with
+Node.js v10+ on the most common platforms:
+
+* macOS x64 (>= 10.13)
+* Linux x64 (glibc >= 2.17, musl >=1.1.24 <1.2.0)
+* Linux ARM64 (glibc >= 2.29)
+* Windows x64
+* Windows x86
+
+A ~9MB tarball containing libvips and its most commonly used dependencies
+is downloaded via HTTPS and stored within `node_modules/sharp/vendor` during `npm install`.
+
+This provides support for the
+JPEG, PNG, WebP, AVIF, TIFF, GIF (input) and SVG (input) image formats.
+
+The following platforms have prebuilt libvips but not sharp:
+
+* Linux ARMv6
+* Linux ARMv7 (glibc >= 2.28)
+* Windows ARM64
+
+The following platforms require compilation of both libvips and sharp from source:
+
+* macOS ARM64
+* Linux x86
+* Linux x64 (glibc <= 2.16, includes RHEL/CentOS 6)
+* Linux ARM64 (glibc <= 2.28, musl)
+* Linux PowerPC
+* FreeBSD
+* OpenBSD
+
+## Common problems
+
+The architecture and platform of Node.js used for `npm install`
+must be the same as the architecture and platform of Node.js used at runtime.
+
+When using npm v6 or earlier, the `npm install --unsafe-perm` flag must be used when installing as `root` or a `sudo` user.
+
+When using npm v7, the user running `npm install` must own the directory it is run in.
+
+The `npm install --ignore-scripts=false` flag must be used when `npm` has been configured to ignore installation scripts.
+
+Check the output of running `npm install --verbose sharp` for useful error messages.
+
+## Apple M1
+
+If you are using ARM64 Node.js, which can be checked using:
+
+```sh
+node -p "process.arch === 'arm64'"
+```
+
+then libvips must currently be installed via Homebrew before installing sharp.
+
+```sh
+brew install vips
+```
+
+When this new ARM64 CPU is made freely available
+to open source projects via a CI service
+then prebuilt binaries can be provided.
+
+## Custom libvips
+
+To use a custom, 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`.
+
+For help compiling libvips from source, please see
+[https://libvips.github.io/libvips/install.html#building-libvips-from-a-source-tarball](https://libvips.github.io/libvips/install.html#building-libvips-from-a-source-tarball).
+
+The use of a globally-installed libvips is unsupported on Windows.
+
+## Building from source
+
+This module will be compiled from source at `npm install` time when:
+
+* a globally-installed libvips is detected (set the `SHARP_IGNORE_GLOBAL_LIBVIPS` environment variable to skip this),
+* prebuilt sharp binaries do not exist for the current platform, or
+* when the `npm install --build-from-source` flag is used.
+
+Building from source requires:
+
+* C++11 compiler
+* [node-gyp](https://github.com/nodejs/node-gyp#installation) and its dependencies
+
+## Custom prebuilt binaries
+
+This is an advanced approach that most people will not require.
+
+To install the prebuilt sharp binaries from a custom URL,
+set the `sharp_binary_host` npm config option
+or the `npm_config_sharp_binary_host` environment variable.
+
+To install the prebuilt libvips binaries from a custom URL,
+set the `sharp_libvips_binary_host` npm config option
+or the `npm_config_sharp_libvips_binary_host` environment variable.
+
+The version subpath and file name are appended to these. There should be tarballs available
+that are compressed with both gzip and Brotli, as the format downloaded will vary depending
+on whether the user's version of Node supports Brotli decompression (Node.js v10.16.0+)
+
+For example, if `sharp_libvips_binary_host` is set to `https://hostname/path`
+and the libvips version is `1.2.3` then the resultant URL will be
+`https://hostname/path/v1.2.3/libvips-1.2.3-platform-arch.tar.br` or 
+`https://hostname/path/v1.2.3/libvips-1.2.3-platform-arch.tar.gz`.
+
+See the Chinese mirror below for a further example.
+
+## Chinese mirror
+
+Alibaba provide a mirror site based in China containing binaries for both sharp and libvips.
+
+To use this either set the following configuration:
+
+```sh
+npm config set sharp_binary_host "https://npm.taobao.org/mirrors/sharp"
+npm config set sharp_libvips_binary_host "https://npm.taobao.org/mirrors/sharp-libvips"
+npm install sharp
+```
+
+or set the following environment variables:
+
+```sh
+npm_config_sharp_binary_host="https://npm.taobao.org/mirrors/sharp" \
+  npm_config_sharp_libvips_binary_host="https://npm.taobao.org/mirrors/sharp-libvips" \
+  npm install sharp
+```
+
+## FreeBSD
+
+The `vips` package must be installed before `npm install` is run.
+
+```sh
+pkg install -y pkgconf vips
+```
+
+```sh
+cd /usr/ports/graphics/vips/ && make install clean
+```
+
+## Heroku
+
+Add the
+[jemalloc buildpack](https://github.com/gaffneyc/heroku-buildpack-jemalloc)
+to reduce the effects of memory fragmentation.
+
+Set
+[NODE_MODULES_CACHE](https://devcenter.heroku.com/articles/nodejs-support#cache-behavior)
+to `false` when using the `yarn` package manager.
+
+## AWS Lambda
+
+Set the Lambda runtime to `nodejs12.x`.
+
+The binaries in the `node_modules` directory of the
+[deployment package](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-package.html)
+must be for the Linux x64 platform.
+
+When building your deployment package on machines other than Linux x64 (glibc),
+run the following commands:
+
+macOS:
+```sh
+rm -rf node_modules/sharp
+SHARP_IGNORE_GLOBAL_LIBVIPS=1 npm install --arch=x64 --platform=linux sharp
+```
+
+Windows:
+```sh
+rmdir /s /q node_modules/sharp
+npm install --arch=x64 --platform=linux sharp
+```
+
+Alternatively a Docker container closely matching the Lambda runtime can be used:
+
+```sh
+rm -rf node_modules/sharp
+docker run -v "$PWD":/var/task lambci/lambda:build-nodejs12.x npm install sharp
+```
+
+To get the best performance select the largest memory available.
+A 1536 MB function provides ~12x more CPU time than a 128 MB function.
+
+## Webpack
+
+Ensure sharp is added to the
+[externals](https://webpack.js.org/configuration/externals/)
+configuration.
+
+```js
+externals: {
+  'sharp': 'commonjs sharp'
+}
+```
+
+## Worker threads
+
+The main thread must call `require('sharp')`
+before worker threads are created
+to ensure shared libraries remain loaded in memory
+until after all threads are complete.
+
+## Known conflicts
+
+### Electron and Linux
+
+The prebuilt binaries provided by Electron for Linux depend on many shared system libraries.
+
+One of these, `libgobject-2.0.so`,
+is known to conflict with the statically-linked binaries provided by sharp
+and the following error can occur:
+```
+basic_string::_S_construct null not valid
+```
+
+To workaround this, set the `LD_PRELOAD` environment variable before the `electron` binary is run.
+```sh
+LD_PRELOAD=node_modules/sharp/vendor/8.10.5/lib/libvips.so.42 electron script.js
+```
+
+### Canvas and Windows
+
+The prebuilt binaries provided by `canvas` for Windows depend on the unmaintained GTK 2, last updated in 2011.
+
+These conflict with the modern, up-to-date binaries provided by sharp.
+
+If both modules are used in the same Windows process, the following error will occur:
+```
+The specified procedure could not be found.
+```

docs/performance.md

@@ -0,0 +1,68 @@
+# Performance
+
+A test to benchmark the performance of this module relative to alternatives.
+
+## The contenders
+
+* [jimp](https://www.npmjs.com/package/jimp) v0.16.1 - Image processing in pure JavaScript. Provides bicubic interpolation.
+* [mapnik](https://www.npmjs.org/package/mapnik) v4.5.5 - Whilst primarily a map renderer, Mapnik contains bitmap image utilities.
+* [imagemagick](https://www.npmjs.com/package/imagemagick) v0.1.3 - Supports filesystem only and "*has been unmaintained for a long time*".
+* [gm](https://www.npmjs.com/package/gm) v1.23.1 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
+* sharp v0.27.0 / libvips v8.10.5 - Caching within libvips disabled to ensure a fair comparison.
+
+## The task
+
+Decompress a 2725x2225 JPEG image,
+resize to 720x588 using Lanczos 3 resampling (where available),
+then compress to JPEG at a "quality" setting of 80.
+
+## Test environment
+
+* AWS EC2 eu-west-1 [c5d.large](https://aws.amazon.com/ec2/instance-types/c5/) (2x Xeon Platinum 8275CL CPU @ 3.00GHz)
+* Ubuntu 20.10 (ami-046cdbcee95cdd75c)
+* Node.js v14.15.3
+
+## Results
+
+| Module             | Input  | Output | Ops/sec | Speed-up |
+| :----------------- | :----- | :----- | ------: | -------: |
+| jimp               | buffer | buffer |    0.77 |      1.0 |
+| mapnik             | buffer | buffer |    3.39 |      4.4 |
+| gm                 | buffer | buffer |    4.30 |      5.6 |
+| gm                 | file   | file   |    4.33 |      5.6 |
+| imagemagick        | file   | file   |    4.39 |      5.7 |
+| sharp              | stream | stream |   23.81 |     30.9 |
+| sharp              | file   | file   |   25.09 |     32.6 |
+| sharp              | buffer | buffer |   25.60 |     33.2 |
+
+Greater libvips performance can be expected with caching enabled (default)
+and using 4+ 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.
+
+## Running the benchmark test
+
+Requires _ImageMagick_, _GraphicsMagick_ and _Mapnik_:
+
+```sh
+brew install imagemagick
+brew install graphicsmagick
+brew install mapnik
+```
+
+```sh
+sudo apt-get install imagemagick libmagick++-dev graphicsmagick libmapnik-dev
+```
+
+```sh
+sudo yum install ImageMagick-devel ImageMagick-c++-devel GraphicsMagick mapnik-devel
+```
+
+```sh
+git clone https://github.com/lovell/sharp.git
+cd sharp
+npm install
+cd test/bench
+npm install
+npm test
+```

docs/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow:

docs/search-index/build.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { extractDescription, extractKeywords } = require('./extract');
+
+const searchIndex = [];
+
+// Install
+const contents = fs.readFileSync(path.join(__dirname, '..', 'install.md'), 'utf8');
+const matches = contents.matchAll(
+  /## (?<title>[A-Za-z0-9 ]+)\n\n(?<body>[^#]+)/gs
+);
+for (const match of matches) {
+  const { title, body } = match.groups;
+  const description = extractDescription(body);
+
+  searchIndex.push({
+    t: title,
+    d: description,
+    k: extractKeywords(`${title} ${description}`),
+    l: `/install#${title.toLowerCase().replace(/ /g, '-')}`
+  });
+}
+
+// API
+[
+  'constructor',
+  'input',
+  'output',
+  'resize',
+  'composite',
+  'operation',
+  'channel',
+  'colour',
+  'utility'
+].forEach((section) => {
+  const contents = fs.readFileSync(path.join(__dirname, '..', `api-${section}.md`), 'utf8');
+  const matches = contents.matchAll(
+    /\n## (?<title>[A-Za-z]+)\n\n(?<firstparagraph>.+?)\n\n/gs
+  );
+  for (const match of matches) {
+    const { title, firstparagraph } = match.groups;
+    const description = firstparagraph.startsWith('###')
+      ? 'Constructor'
+      : extractDescription(firstparagraph);
+
+    searchIndex.push({
+      t: title,
+      d: description,
+      k: extractKeywords(`${title} ${description}`),
+      l: `/api-${section}#${title.toLowerCase()}`
+    });
+  }
+});
+
+fs.writeFileSync(
+  path.join(__dirname, '..', 'search-index.json'),
+  JSON.stringify(searchIndex)
+);

docs/search-index/extract.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const stopWords = require('./stop-words');
+
+const extractDescription = (str) =>
+  str
+    .replace(/\(http[^)]+/g, '')
+    .replace(/\s+/g, ' ')
+    .replace(/[^A-Za-z0-9_/\-,. ]/g, '')
+    .replace(/\s+/g, ' ')
+    .substr(0, 140)
+    .trim();
+
+const extractKeywords = (str) =>
+  [
+    ...new Set(
+      str
+        .split(/[ -/]/)
+        .map((word) => word.toLowerCase().replace(/[^a-z]/g, ''))
+        .filter((word) => word.length > 2 && word.length < 15 && !stopWords.includes(word))
+    )
+  ].join(' ');
+
+module.exports = { extractDescription, extractKeywords };

docs/search-index/stop-words.js

@@ -0,0 +1,73 @@
+'use strict';
+
+module.exports = [
+  'about',
+  'after',
+  'all',
+  'already',
+  'alternative',
+  'always',
+  'and',
+  'any',
+  'are',
+  'been',
+  'before',
+  'can',
+  'containing',
+  'default',
+  'does',
+  'each',
+  'either',
+  'ensure',
+  'etc',
+  'every',
+  'for',
+  'from',
+  'get',
+  'gets',
+  'given',
+  'has',
+  'have',
+  'how',
+  'image',
+  'its',
+  'may',
+  'more',
+  'most',
+  'much',
+  'must',
+  'non',
+  'not',
+  'occur',
+  'occurs',
+  'over',
+  'perform',
+  'performs',
+  'provide',
+  'provided',
+  'set',
+  'sets',
+  'should',
+  'spelling',
+  'support',
+  'supported',
+  'take',
+  'that',
+  'the',
+  'their',
+  'there',
+  'therefore',
+  'these',
+  'this',
+  'use',
+  'used',
+  'using',
+  'value',
+  'values',
+  'when',
+  'which',
+  'while',
+  'will',
+  'with',
+  'without'
+];

index.js

@@ -1,13 +0,0 @@
-var sharp = require("./build/Release/sharp");
-
-module.exports.crop = function(input, output, width, height, callback) {
-  sharp.resize(input, output, width, height, "c", callback)
-}
-
-module.exports.embedWhite = function(input, output, width, height, callback) {
-  sharp.resize(input, output, width, height, "w", callback)
-}
-
-module.exports.embedBlack = function(input, output, width, height, callback) {
-  sharp.resize(input, output, width, height, "b", callback)
-}

install/dll-copy.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const libvips = require('../lib/libvips');
+const npmLog = require('npmlog');
+
+const minimumLibvipsVersion = libvips.minimumLibvipsVersion;
+
+const platform = process.env.npm_config_platform || process.platform;
+if (platform === 'win32') {
+  const buildDir = path.join(__dirname, '..', 'build');
+  const buildReleaseDir = path.join(buildDir, 'Release');
+  npmLog.info('sharp', `Creating ${buildReleaseDir}`);
+  try {
+    libvips.mkdirSync(buildDir);
+    libvips.mkdirSync(buildReleaseDir);
+  } catch (err) {}
+  const vendorLibDir = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion, 'lib');
+  npmLog.info('sharp', `Copying DLLs from ${vendorLibDir} to ${buildReleaseDir}`);
+  try {
+    fs
+      .readdirSync(vendorLibDir)
+      .filter(function (filename) {
+        return /\.dll$/.test(filename);
+      })
+      .forEach(function (filename) {
+        fs.copyFileSync(
+          path.join(vendorLibDir, filename),
+          path.join(buildReleaseDir, filename)
+        );
+      });
+  } catch (err) {
+    npmLog.error('sharp', err.message);
+  }
+}

install/libvips.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const stream = require('stream');
+const zlib = require('zlib');
+
+const detectLibc = require('detect-libc');
+const npmLog = require('npmlog');
+const semver = require('semver');
+const simpleGet = require('simple-get');
+const tarFs = require('tar-fs');
+
+const agent = require('../lib/agent');
+const libvips = require('../lib/libvips');
+const platform = require('../lib/platform');
+
+const minimumGlibcVersionByArch = {
+  arm: '2.28',
+  arm64: '2.29',
+  x64: '2.17'
+};
+
+const { minimumLibvipsVersion, minimumLibvipsVersionLabelled } = libvips;
+const distHost = process.env.npm_config_sharp_libvips_binary_host || 'https://github.com/lovell/sharp-libvips/releases/download';
+const distBaseUrl = process.env.npm_config_sharp_dist_base_url || process.env.SHARP_DIST_BASE_URL || `${distHost}/v${minimumLibvipsVersionLabelled}/`;
+const supportsBrotli = ('BrotliDecompress' in zlib);
+
+const fail = function (err) {
+  npmLog.error('sharp', err.message);
+  if (err.code === 'EACCES') {
+    npmLog.info('sharp', 'Are you trying to install as a root or sudo user? Try again with the --unsafe-perm flag');
+  }
+  npmLog.info('sharp', 'Attempting to build from source via node-gyp but this may fail due to the above error');
+  npmLog.info('sharp', 'Please see https://sharp.pixelplumbing.com/install for required dependencies');
+  process.exit(1);
+};
+
+const extractTarball = function (tarPath) {
+  const vendorPath = path.join(__dirname, '..', 'vendor');
+  libvips.mkdirSync(vendorPath);
+  const versionedVendorPath = path.join(vendorPath, minimumLibvipsVersion);
+  libvips.mkdirSync(versionedVendorPath);
+  stream.pipeline(
+    fs.createReadStream(tarPath),
+    supportsBrotli ? new zlib.BrotliDecompress() : new zlib.Gunzip(),
+    tarFs.extract(versionedVendorPath),
+    function (err) {
+      if (err) {
+        if (/unexpected end of file/.test(err.message)) {
+          npmLog.error('sharp', `Please delete ${tarPath} as it is not a valid tarball`);
+        }
+        fail(err);
+      }
+    }
+  );
+};
+
+try {
+  const useGlobalLibvips = libvips.useGlobalLibvips();
+
+  if (useGlobalLibvips) {
+    const globalLibvipsVersion = libvips.globalLibvipsVersion();
+    npmLog.info('sharp', `Detected globally-installed libvips v${globalLibvipsVersion}`);
+    npmLog.info('sharp', 'Building from source via node-gyp');
+    process.exit(1);
+  } else if (libvips.hasVendoredLibvips()) {
+    npmLog.info('sharp', `Using existing vendored libvips v${minimumLibvipsVersion}`);
+  } else {
+    // Is this arch/platform supported?
+    const arch = process.env.npm_config_arch || process.arch;
+    const platformAndArch = platform();
+    if (arch === 'ia32' && !platformAndArch.startsWith('win32')) {
+      throw new Error(`Intel Architecture 32-bit systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
+    }
+    if (platformAndArch === 'darwin-arm64') {
+      throw new Error("Please run 'brew install vips' to install libvips on Apple M1 (ARM64) systems");
+    }
+    if (platformAndArch === 'freebsd-x64' || platformAndArch === 'openbsd-x64' || platformAndArch === 'sunos-x64') {
+      throw new Error(`BSD/SunOS systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
+    }
+    if (detectLibc.family === detectLibc.GLIBC && detectLibc.version) {
+      if (semver.lt(`${detectLibc.version}.0`, `${minimumGlibcVersionByArch[arch]}.0`)) {
+        throw new Error(`Use with glibc ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
+      }
+    }
+    if (detectLibc.family === detectLibc.MUSL && detectLibc.version) {
+      if (!semver.satisfies(detectLibc.version, '>=1.1.24 <1.2.0')) {
+        throw new Error(`Use with musl ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
+      }
+    }
+
+    const supportedNodeVersion = process.env.npm_package_engines_node || require('../package.json').engines.node;
+    if (!semver.satisfies(process.versions.node, supportedNodeVersion)) {
+      throw new Error(`Expected Node.js version ${supportedNodeVersion} but found ${process.versions.node}`);
+    }
+
+    const extension = supportsBrotli ? 'br' : 'gz';
+
+    // Download to per-process temporary file
+    const tarFilename = ['libvips', minimumLibvipsVersion, platformAndArch].join('-') + '.tar.' + extension;
+    const tarPathCache = path.join(libvips.cachePath(), tarFilename);
+    if (fs.existsSync(tarPathCache)) {
+      npmLog.info('sharp', `Using cached ${tarPathCache}`);
+      extractTarball(tarPathCache);
+    } else {
+      const tarPathTemp = path.join(os.tmpdir(), `${process.pid}-${tarFilename}`);
+      const tmpFile = fs.createWriteStream(tarPathTemp);
+      const url = distBaseUrl + tarFilename;
+      npmLog.info('sharp', `Downloading ${url}`);
+      simpleGet({ url: url, agent: agent() }, function (err, response) {
+        if (err) {
+          fail(err);
+        } else if (response.statusCode === 404) {
+          fail(new Error(`Prebuilt libvips ${minimumLibvipsVersion} binaries are not yet available for ${platformAndArch}`));
+        } else if (response.statusCode !== 200) {
+          fail(new Error(`Status ${response.statusCode} ${response.statusMessage}`));
+        } else {
+          response
+            .on('error', fail)
+            .pipe(tmpFile);
+        }
+      });
+      tmpFile
+        .on('error', fail)
+        .on('close', function () {
+          try {
+            // Attempt to rename
+            fs.renameSync(tarPathTemp, tarPathCache);
+          } catch (err) {
+            // Fall back to copy and unlink
+            fs.copyFileSync(tarPathTemp, tarPathCache);
+            fs.unlinkSync(tarPathTemp);
+          }
+          extractTarball(tarPathCache);
+        });
+    }
+  }
+} catch (err) {
+  fail(err);
+}

lib/agent.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const url = require('url');
+const tunnelAgent = require('tunnel-agent');
+
+const is = require('./is');
+
+const proxies = [
+  'HTTPS_PROXY',
+  'https_proxy',
+  'HTTP_PROXY',
+  'http_proxy',
+  'npm_config_https_proxy',
+  'npm_config_proxy'
+];
+
+function env (key) {
+  return process.env[key];
+}
+
+module.exports = function () {
+  try {
+    const proxy = new url.URL(proxies.map(env).find(is.string));
+    const tunnel = proxy.protocol === 'https:'
+      ? tunnelAgent.httpsOverHttps
+      : tunnelAgent.httpsOverHttp;
+    const proxyAuth = proxy.username && proxy.password
+      ? `${proxy.username}:${proxy.password}`
+      : null;
+    return tunnel({
+      proxy: {
+        port: Number(proxy.port),
+        host: proxy.hostname,
+        proxyAuth
+      }
+    });
+  } catch (err) {
+    return null;
+  }
+};

lib/channel.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const is = require('./is');
+
+/**
+ * Boolean operations for bandbool.
+ * @private
+ */
+const bool = {
+  and: 'and',
+  or: 'or',
+  eor: 'eor'
+};
+
+/**
+ * Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel.
+ *
+ * @example
+ * sharp('rgba.png')
+ *   .removeAlpha()
+ *   .toFile('rgb.png', function(err, info) {
+ *     // rgb.png is a 3 channel image without an alpha channel
+ *   });
+ *
+ * @returns {Sharp}
+ */
+function removeAlpha () {
+  this.options.removeAlpha = true;
+  return this;
+}
+
+/**
+ * Ensure alpha channel, if missing. The added alpha channel will be fully opaque. This is a no-op if the image already has an alpha channel.
+ *
+ * @since 0.21.2
+ *
+ * @example
+ * sharp('rgb.jpg')
+ *   .ensureAlpha()
+ *   .toFile('rgba.png', function(err, info) {
+ *     // rgba.png is a 4 channel image with a fully opaque alpha channel
+ *   });
+ *
+ * @returns {Sharp}
+ */
+function ensureAlpha () {
+  this.options.ensureAlpha = true;
+  return this;
+}
+
+/**
+ * Extract a single channel from a multi-channel image.
+ *
+ * @example
+ * sharp(input)
+ *   .extractChannel('green')
+ *   .toColourspace('b-w')
+ *   .toFile('green.jpg', function(err, info) {
+ *     // info.channels === 1
+ *     // green.jpg is a greyscale image containing the green channel of the input
+ *    });
+ *
+ * @param {number|string} channel - zero-indexed channel/band number to extract, or `red`, `green`, `blue` or `alpha`.
+ * @returns {Sharp}
+ * @throws {Error} Invalid channel
+ */
+function extractChannel (channel) {
+  const channelMap = { red: 0, green: 1, blue: 2, alpha: 3 };
+  if (Object.keys(channelMap).includes(channel)) {
+    channel = channelMap[channel];
+  }
+  if (is.integer(channel) && is.inRange(channel, 0, 4)) {
+    this.options.extractChannel = channel;
+  } else {
+    throw is.invalidParameterError('channel', 'integer or one of: red, green, blue, alpha', channel);
+  }
+  return this;
+}
+
+/**
+ * Join one or more channels 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.
+ * 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.
+ * For raw pixel input, the `options` object should contain a `raw` attribute, which follows the format of the attribute of the same name in the `sharp()` constructor.
+ *
+ * @param {Array<string|Buffer>|string|Buffer} images - one or more images (file paths, Buffers).
+ * @param {Object} options - image options, see `sharp()` constructor.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function joinChannel (images, options) {
+  if (Array.isArray(images)) {
+    images.forEach(function (image) {
+      this.options.joinChannelIn.push(this._createInputDescriptor(image, options));
+    }, this);
+  } else {
+    this.options.joinChannelIn.push(this._createInputDescriptor(images, options));
+  }
+  return this;
+}
+
+/**
+ * Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
+ *
+ * @example
+ * sharp('3-channel-rgb-input.png')
+ *   .bandbool(sharp.bool.and)
+ *   .toFile('1-channel-output.png', function (err, info) {
+ *     // The output will be a single channel image where each pixel `P = R & G & B`.
+ *     // If `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]`
+ *     // then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
+ *   });
+ *
+ * @param {string} boolOp - one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function bandbool (boolOp) {
+  if (is.string(boolOp) && is.inArray(boolOp, ['and', 'or', 'eor'])) {
+    this.options.bandBoolOp = boolOp;
+  } else {
+    throw is.invalidParameterError('boolOp', 'one of: and, or, eor', boolOp);
+  }
+  return this;
+}
+
+/**
+ * Decorate the Sharp prototype with channel-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Object.assign(Sharp.prototype, {
+    // Public instance functions
+    removeAlpha,
+    ensureAlpha,
+    extractChannel,
+    joinChannel,
+    bandbool
+  });
+  // Class attributes
+  Sharp.bool = bool;
+};

lib/colour.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const color = require('color');
+const is = require('./is');
+
+/**
+ * Colourspaces.
+ * @private
+ */
+const colourspace = {
+  multiband: 'multiband',
+  'b-w': 'b-w',
+  bw: 'b-w',
+  cmyk: 'cmyk',
+  srgb: 'srgb'
+};
+
+/**
+ * Tint the image using the provided chroma while preserving the image luminance.
+ * An alpha channel may be present and will be unchanged by the operation.
+ *
+ * @param {string|Object} rgb - parsed by the [color](https://www.npmjs.org/package/color) module to extract chroma values.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameter
+ */
+function tint (rgb) {
+  const colour = color(rgb);
+  this.options.tintA = colour.a();
+  this.options.tintB = colour.b();
+  return this;
+}
+
+/**
+ * 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.
+ * @param {Boolean} [greyscale=true]
+ * @returns {Sharp}
+ */
+function greyscale (greyscale) {
+  this.options.greyscale = is.bool(greyscale) ? greyscale : true;
+  return this;
+}
+
+/**
+ * Alternative spelling of `greyscale`.
+ * @param {Boolean} [grayscale=true]
+ * @returns {Sharp}
+ */
+function grayscale (grayscale) {
+  return this.greyscale(grayscale);
+}
+
+/**
+ * Set the output colourspace.
+ * By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
+ *
+ * @example
+ * // Output 16 bits per pixel RGB
+ * await sharp(input)
+ *  .toColourspace('rgb16')
+ *  .toFile('16-bpp.png')
+ *
+ * @param {string} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function toColourspace (colourspace) {
+  if (!is.string(colourspace)) {
+    throw is.invalidParameterError('colourspace', 'string', colourspace);
+  }
+  this.options.colourspace = colourspace;
+  return this;
+}
+
+/**
+ * Alternative spelling of `toColourspace`.
+ * @param {string} [colorspace] - output colorspace.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function toColorspace (colorspace) {
+  return this.toColourspace(colorspace);
+}
+
+/**
+ * Update a colour attribute of the this.options Object.
+ * @private
+ * @param {string} key
+ * @param {string|Object} value
+ * @throws {Error} Invalid value
+ */
+function _setBackgroundColourOption (key, value) {
+  if (is.defined(value)) {
+    if (is.object(value) || is.string(value)) {
+      const colour = color(value);
+      this.options[key] = [
+        colour.red(),
+        colour.green(),
+        colour.blue(),
+        Math.round(colour.alpha() * 255)
+      ];
+    } else {
+      throw is.invalidParameterError('background', 'object or string', value);
+    }
+  }
+}
+
+/**
+ * Decorate the Sharp prototype with colour-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Object.assign(Sharp.prototype, {
+    // Public
+    tint,
+    greyscale,
+    grayscale,
+    toColourspace,
+    toColorspace,
+    // Private
+    _setBackgroundColourOption
+  });
+  // Class attributes
+  Sharp.colourspace = colourspace;
+  Sharp.colorspace = colourspace;
+};

lib/composite.js

@@ -0,0 +1,176 @@
+'use strict';
+
+const is = require('./is');
+
+/**
+ * Blend modes.
+ * @member
+ * @private
+ */
+const blend = {
+  clear: 'clear',
+  source: 'source',
+  over: 'over',
+  in: 'in',
+  out: 'out',
+  atop: 'atop',
+  dest: 'dest',
+  'dest-over': 'dest-over',
+  'dest-in': 'dest-in',
+  'dest-out': 'dest-out',
+  'dest-atop': 'dest-atop',
+  xor: 'xor',
+  add: 'add',
+  saturate: 'saturate',
+  multiply: 'multiply',
+  screen: 'screen',
+  overlay: 'overlay',
+  darken: 'darken',
+  lighten: 'lighten',
+  'colour-dodge': 'colour-dodge',
+  'color-dodge': 'colour-dodge',
+  'colour-burn': 'colour-burn',
+  'color-burn': 'colour-burn',
+  'hard-light': 'hard-light',
+  'soft-light': 'soft-light',
+  difference: 'difference',
+  exclusion: 'exclusion'
+};
+
+/**
+ * Composite image(s) over the processed (resized, extracted etc.) image.
+ *
+ * The images to composite must be the same size or smaller than the processed image.
+ * If both `top` and `left` options are provided, they take precedence over `gravity`.
+ *
+ * The `blend` option can be one of `clear`, `source`, `over`, `in`, `out`, `atop`,
+ * `dest`, `dest-over`, `dest-in`, `dest-out`, `dest-atop`,
+ * `xor`, `add`, `saturate`, `multiply`, `screen`, `overlay`, `darken`, `lighten`,
+ * `colour-dodge`, `color-dodge`, `colour-burn`,`color-burn`,
+ * `hard-light`, `soft-light`, `difference`, `exclusion`.
+ *
+ * More information about blend modes can be found at
+ * https://libvips.github.io/libvips/API/current/libvips-conversion.html#VipsBlendMode
+ * and https://www.cairographics.org/operators/
+ *
+ * @since 0.22.0
+ *
+ * @example
+ * sharp('input.png')
+ *   .rotate(180)
+ *   .resize(300)
+ *   .flatten( { background: '#ff6600' } )
+ *   .composite([{ input: 'overlay.png', gravity: 'southeast' }])
+ *   .sharpen()
+ *   .withMetadata()
+ *   .webp( { quality: 90 } )
+ *   .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!
+ *   });
+ *
+ * @param {Object[]} images - Ordered list of images to composite
+ * @param {Buffer|String} [images[].input] - Buffer containing image data, String containing the path to an image file, or Create object (see below)
+ * @param {Object} [images[].input.create] - describes a blank overlay to be created.
+ * @param {Number} [images[].input.create.width]
+ * @param {Number} [images[].input.create.height]
+ * @param {Number} [images[].input.create.channels] - 3-4
+ * @param {String|Object} [images[].input.create.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {String} [images[].blend='over'] - how to blend this image with the image below.
+ * @param {String} [images[].gravity='centre'] - gravity at which to place the overlay.
+ * @param {Number} [images[].top] - the pixel offset from the top edge.
+ * @param {Number} [images[].left] - the pixel offset from the left edge.
+ * @param {Boolean} [images[].tile=false] - set to true to repeat the overlay image across the entire image with the given `gravity`.
+ * @param {Boolean} [images[].premultiplied=false] - set to true to avoid premultipling the image below. Equivalent to the `--premultiplied` vips option.
+ * @param {Number} [images[].density=72] - number representing the DPI for vector overlay image.
+ * @param {Object} [images[].raw] - describes overlay when using raw pixel data.
+ * @param {Number} [images[].raw.width]
+ * @param {Number} [images[].raw.height]
+ * @param {Number} [images[].raw.channels]
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function composite (images) {
+  if (!Array.isArray(images)) {
+    throw is.invalidParameterError('images to composite', 'array', images);
+  }
+  this.options.composite = images.map(image => {
+    if (!is.object(image)) {
+      throw is.invalidParameterError('image to composite', 'object', image);
+    }
+    const inputOptions = this._inputOptionsFromObject(image);
+    const composite = {
+      input: this._createInputDescriptor(image.input, inputOptions, { allowStream: false }),
+      blend: 'over',
+      tile: false,
+      left: 0,
+      top: 0,
+      hasOffset: false,
+      gravity: 0,
+      premultiplied: false
+    };
+    if (is.defined(image.blend)) {
+      if (is.string(blend[image.blend])) {
+        composite.blend = blend[image.blend];
+      } else {
+        throw is.invalidParameterError('blend', 'valid blend name', image.blend);
+      }
+    }
+    if (is.defined(image.tile)) {
+      if (is.bool(image.tile)) {
+        composite.tile = image.tile;
+      } else {
+        throw is.invalidParameterError('tile', 'boolean', image.tile);
+      }
+    }
+    if (is.defined(image.left)) {
+      if (is.integer(image.left)) {
+        composite.left = image.left;
+      } else {
+        throw is.invalidParameterError('left', 'integer', image.left);
+      }
+    }
+    if (is.defined(image.top)) {
+      if (is.integer(image.top)) {
+        composite.top = image.top;
+      } else {
+        throw is.invalidParameterError('top', 'integer', image.top);
+      }
+    }
+    if (is.defined(image.top) !== is.defined(image.left)) {
+      throw new Error('Expected both left and top to be set');
+    } else {
+      composite.hasOffset = is.integer(image.top) && is.integer(image.left);
+    }
+    if (is.defined(image.gravity)) {
+      if (is.integer(image.gravity) && is.inRange(image.gravity, 0, 8)) {
+        composite.gravity = image.gravity;
+      } else if (is.string(image.gravity) && is.integer(this.constructor.gravity[image.gravity])) {
+        composite.gravity = this.constructor.gravity[image.gravity];
+      } else {
+        throw is.invalidParameterError('gravity', 'valid gravity', image.gravity);
+      }
+    }
+    if (is.defined(image.premultiplied)) {
+      if (is.bool(image.premultiplied)) {
+        composite.premultiplied = image.premultiplied;
+      } else {
+        throw is.invalidParameterError('premultiplied', 'boolean', image.premultiplied);
+      }
+    }
+
+    return composite;
+  });
+  return this;
+}
+
+/**
+ * Decorate the Sharp prototype with composite-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Sharp.prototype.composite = composite;
+  Sharp.blend = blend;
+};

lib/constructor.js

@@ -0,0 +1,385 @@
+'use strict';
+
+const util = require('util');
+const stream = require('stream');
+const is = require('./is');
+
+require('./libvips').hasVendoredLibvips();
+
+/* istanbul ignore next */
+try {
+  require('../build/Release/sharp.node');
+} catch (err) {
+  // Bail early if bindings aren't available
+  const help = ['', 'Something went wrong installing the "sharp" module', '', err.message, ''];
+  if (/NODE_MODULE_VERSION/.test(err.message)) {
+    help.push('- Ensure the version of Node.js used at install time matches that used at runtime');
+  } else if (/invalid ELF header/.test(err.message)) {
+    help.push(`- Ensure "${process.platform}" is used at install time as well as runtime`);
+  } else if (/dylib/.test(err.message) && /Incompatible library version/.test(err.message)) {
+    help.push('- Run "brew update && brew upgrade vips"');
+  } else if (/Cannot find module/.test(err.message)) {
+    help.push('- Run "npm rebuild --verbose sharp" and look for errors');
+  } else {
+    help.push(
+      '- Remove the "node_modules/sharp" directory then run',
+      '  "npm install --ignore-scripts=false --verbose" and look for errors'
+    );
+  }
+  help.push(
+    '- Consult the installation documentation at https://sharp.pixelplumbing.com/install',
+    '- Search for this error at https://github.com/lovell/sharp/issues', ''
+  );
+  const error = help.join('\n');
+  throw new Error(error);
+}
+
+// Use NODE_DEBUG=sharp to enable libvips warnings
+const debuglog = util.debuglog('sharp');
+
+/**
+ * Constructor factory to create an instance of `sharp`, to which further methods are chained.
+ *
+ * JPEG, PNG, WebP, AVIF or TIFF format image data can be streamed out from this object.
+ * When using Stream based output, derived attributes are available from the `info` event.
+ *
+ * Non-critical problems encountered during processing are emitted as `warning` events.
+ *
+ * Implements the [stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
+ *
+ * @constructs Sharp
+ *
+ * @emits Sharp#info
+ * @emits Sharp#warning
+ *
+ * @example
+ * 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
+ *   });
+ *
+ * @example
+ * // 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);
+ *
+ * @example
+ * // Create a blank 300x200 PNG image of semi-transluent red pixels
+ * sharp({
+ *   create: {
+ *     width: 300,
+ *     height: 200,
+ *     channels: 4,
+ *     background: { r: 255, g: 0, b: 0, alpha: 0.5 }
+ *   }
+ * })
+ * .png()
+ * .toBuffer()
+ * .then( ... );
+ *
+ * @example
+ * // Convert an animated GIF to an animated WebP
+ * await sharp('in.gif', { animated: true }).toFile('out.webp');
+ *
+ * @example
+ * // Read a raw array of pixels and save it to a png
+ * const input = Uint8Array.from([255, 255, 255, 0, 0, 0]); // or Uint8ClampedArray
+ * const image = sharp(input, {
+ *   // because the input does not contain its dimensions or how many channels it has
+ *   // we need to specify it in the constructor options
+ *   raw: {
+ *     width: 2,
+ *     height: 1,
+ *     channels: 3
+ *   }
+ * });
+ * await image.toFile('my-two-pixels.png');
+ *
+ * @example
+ * // Generate RGB Gaussian noise
+ * await sharp({
+ *   create: {
+ *     width: 300,
+ *     height: 200,
+ *     channels: 3,
+ *     noise: {
+ *       type: 'gaussian',
+ *       mean: 128,
+ *       sigma: 30
+ *     }
+ *  }
+ * }).toFile('noise.png');
+ *
+ * @param {(Buffer|Uint8Array|Uint8ClampedArray|string)} [input] - if present, can be
+ *  a Buffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data, or
+ *  a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file.
+ *  JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
+ * @param {Object} [options] - if present, is an Object with optional attributes.
+ * @param {boolean} [options.failOnError=true] - by default halt processing and raise an error when loading invalid images.
+ *  Set this flag to `false` if you'd rather apply a "best effort" to decode images, even if the data is corrupt or invalid.
+ * @param {number|boolean} [options.limitInputPixels=268402689] - Do not process input images where the number of pixels
+ *  (width x height) exceeds this limit. Assumes image dimensions contained in the input metadata can be trusted.
+ *  An integral Number of pixels, zero or false to remove limit, true to use default limit of 268402689 (0x3FFF x 0x3FFF).
+ * @param {boolean} [options.sequentialRead=false] - Set this to `true` to use sequential rather than random access where possible.
+ *  This can reduce memory usage and might improve performance on some systems.
+ * @param {number} [options.density=72] - number representing the DPI for vector images in the range 1 to 100000.
+ * @param {number} [options.pages=1] - number of pages to extract for multi-page input (GIF, WebP, AVIF, TIFF, PDF), use -1 for all pages.
+ * @param {number} [options.page=0] - page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based.
+ * @param {number} [options.level=0] - level to extract from a multi-level input (OpenSlide), zero based.
+ * @param {boolean} [options.animated=false] - Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`).
+ * @param {Object} [options.raw] - describes raw pixel input image data. See `raw()` for pixel ordering.
+ * @param {number} [options.raw.width] - integral number of pixels wide.
+ * @param {number} [options.raw.height] - integral number of pixels high.
+ * @param {number} [options.raw.channels] - integral number of channels, between 1 and 4.
+ * @param {Object} [options.create] - describes a new image to be created.
+ * @param {number} [options.create.width] - integral number of pixels wide.
+ * @param {number} [options.create.height] - integral number of pixels high.
+ * @param {number} [options.create.channels] - integral number of channels, either 3 (RGB) or 4 (RGBA).
+ * @param {string|Object} [options.create.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {Object} [options.create.noise] - describes a noise to be created.
+ * @param {string} [options.create.noise.type] - type of generated noise, currently only `gaussian` is supported.
+ * @param {number} [options.create.noise.mean] - mean of pixels in generated noise.
+ * @param {number} [options.create.noise.sigma] - standard deviation of pixels in generated noise.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+const Sharp = function (input, options) {
+  if (arguments.length === 1 && !is.defined(input)) {
+    throw new Error('Invalid input');
+  }
+  if (!(this instanceof Sharp)) {
+    return new Sharp(input, options);
+  }
+  stream.Duplex.call(this);
+  this.options = {
+    // resize options
+    topOffsetPre: -1,
+    leftOffsetPre: -1,
+    widthPre: -1,
+    heightPre: -1,
+    topOffsetPost: -1,
+    leftOffsetPost: -1,
+    widthPost: -1,
+    heightPost: -1,
+    width: -1,
+    height: -1,
+    canvas: 'crop',
+    position: 0,
+    resizeBackground: [0, 0, 0, 255],
+    useExifOrientation: false,
+    angle: 0,
+    rotationAngle: 0,
+    rotationBackground: [0, 0, 0, 255],
+    rotateBeforePreExtract: false,
+    flip: false,
+    flop: false,
+    extendTop: 0,
+    extendBottom: 0,
+    extendLeft: 0,
+    extendRight: 0,
+    extendBackground: [0, 0, 0, 255],
+    withoutEnlargement: false,
+    affineMatrix: [],
+    affineBackground: [0, 0, 0, 255],
+    affineIdx: 0,
+    affineIdy: 0,
+    affineOdx: 0,
+    affineOdy: 0,
+    affineInterpolator: this.constructor.interpolators.bilinear,
+    kernel: 'lanczos3',
+    fastShrinkOnLoad: true,
+    // operations
+    tintA: 128,
+    tintB: 128,
+    flatten: false,
+    flattenBackground: [0, 0, 0],
+    negate: false,
+    medianSize: 0,
+    blurSigma: 0,
+    sharpenSigma: 0,
+    sharpenFlat: 1,
+    sharpenJagged: 2,
+    threshold: 0,
+    thresholdGrayscale: true,
+    trimThreshold: 0,
+    gamma: 0,
+    gammaOut: 0,
+    greyscale: false,
+    normalise: false,
+    brightness: 1,
+    saturation: 1,
+    hue: 0,
+    booleanBufferIn: null,
+    booleanFileIn: '',
+    joinChannelIn: [],
+    extractChannel: -1,
+    removeAlpha: false,
+    ensureAlpha: false,
+    colourspace: 'srgb',
+    composite: [],
+    // output
+    fileOut: '',
+    formatOut: 'input',
+    streamOut: false,
+    withMetadata: false,
+    withMetadataOrientation: -1,
+    withMetadataIcc: '',
+    resolveWithObject: false,
+    // output format
+    jpegQuality: 80,
+    jpegProgressive: false,
+    jpegChromaSubsampling: '4:2:0',
+    jpegTrellisQuantisation: false,
+    jpegOvershootDeringing: false,
+    jpegOptimiseScans: false,
+    jpegOptimiseCoding: true,
+    jpegQuantisationTable: 0,
+    pngProgressive: false,
+    pngCompressionLevel: 9,
+    pngAdaptiveFiltering: false,
+    pngPalette: false,
+    pngQuality: 100,
+    pngColours: 256,
+    pngDither: 1,
+    webpQuality: 80,
+    webpAlphaQuality: 100,
+    webpLossless: false,
+    webpNearLossless: false,
+    webpSmartSubsample: false,
+    webpReductionEffort: 4,
+    tiffQuality: 80,
+    tiffCompression: 'jpeg',
+    tiffPredictor: 'horizontal',
+    tiffPyramid: false,
+    tiffBitdepth: 8,
+    tiffTile: false,
+    tiffTileHeight: 256,
+    tiffTileWidth: 256,
+    tiffXres: 1.0,
+    tiffYres: 1.0,
+    heifQuality: 50,
+    heifLossless: false,
+    heifCompression: 'av1',
+    heifSpeed: 5,
+    heifChromaSubsampling: '4:2:0',
+    tileSize: 256,
+    tileOverlap: 0,
+    tileContainer: 'fs',
+    tileLayout: 'dz',
+    tileFormat: 'last',
+    tileDepth: 'last',
+    tileAngle: 0,
+    tileSkipBlanks: -1,
+    tileBackground: [255, 255, 255, 255],
+    tileCentre: false,
+    linearA: 1,
+    linearB: 0,
+    // Function to notify of libvips warnings
+    debuglog: warning => {
+      this.emit('warning', warning);
+      debuglog(warning);
+    },
+    // Function to notify of queue length changes
+    queueListener: function (queueLength) {
+      Sharp.queue.emit('change', queueLength);
+    }
+  };
+  this.options.input = this._createInputDescriptor(input, options, { allowStream: true });
+  return this;
+};
+util.inherits(Sharp, stream.Duplex);
+
+/**
+ * Take a "snapshot" of the Sharp instance, returning a new instance.
+ * Cloned instances inherit the input of their parent instance.
+ * This allows multiple output Streams and therefore multiple processing pipelines to share a single input Stream.
+ *
+ * @example
+ * const 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
+ *
+ * @example
+ * // Create a pipeline that will download an image, resize it and format it to different files
+ * // Using Promises to know when the pipeline is complete
+ * const fs = require("fs");
+ * const got = require("got");
+ * const sharpStream = sharp({
+ *   failOnError: false
+ * });
+ *
+ * const promises = [];
+ *
+ * promises.push(
+ *   sharpStream
+ *     .clone()
+ *     .jpeg({ quality: 100 })
+ *     .toFile("originalFile.jpg")
+ * );
+ *
+ * promises.push(
+ *   sharpStream
+ *     .clone()
+ *     .resize({ width: 500 })
+ *     .jpeg({ quality: 80 })
+ *     .toFile("optimized-500.jpg")
+ * );
+ *
+ * promises.push(
+ *   sharpStream
+ *     .clone()
+ *     .resize({ width: 500 })
+ *     .webp({ quality: 80 })
+ *     .toFile("optimized-500.webp")
+ * );
+ *
+ * // https://github.com/sindresorhus/got#gotstreamurl-options
+ * got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
+ *
+ * Promise.all(promises)
+ *   .then(res => { console.log("Done!", res); })
+ *   .catch(err => {
+ *     console.error("Error processing files, let's clean it up", err);
+ *     try {
+ *       fs.unlinkSync("originalFile.jpg");
+ *       fs.unlinkSync("optimized-500.jpg");
+ *       fs.unlinkSync("optimized-500.webp");
+ *     } catch (e) {}
+ *   });
+ *
+ * @returns {Sharp}
+ */
+function clone () {
+  // Clone existing options
+  const clone = this.constructor.call();
+  clone.options = Object.assign({}, this.options);
+  // Pass 'finish' event to clone for Stream-based input
+  if (this._isStreamInput()) {
+    this.on('finish', () => {
+      // Clone inherits input data
+      this._flattenBufferIn();
+      clone.options.bufferIn = this.options.bufferIn;
+      clone.emit('finish');
+    });
+  }
+  return clone;
+}
+Object.assign(Sharp.prototype, { clone });
+
+/**
+ * Export constructor.
+ * @private
+ */
+module.exports = Sharp;

lib/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const Sharp = require('./constructor');
+require('./input')(Sharp);
+require('./resize')(Sharp);
+require('./composite')(Sharp);
+require('./operation')(Sharp);
+require('./colour')(Sharp);
+require('./channel')(Sharp);
+require('./output')(Sharp);
+require('./utility')(Sharp);
+
+module.exports = Sharp;

lib/input.js

@@ -0,0 +1,413 @@
+'use strict';
+
+const color = require('color');
+const is = require('./is');
+const sharp = require('../build/Release/sharp.node');
+
+/**
+ * Extract input options, if any, from an object.
+ * @private
+ */
+function _inputOptionsFromObject (obj) {
+  const { raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages } = obj;
+  return [raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages].some(is.defined)
+    ? { raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages }
+    : undefined;
+}
+
+/**
+ * Create Object containing input and input-related options.
+ * @private
+ */
+function _createInputDescriptor (input, inputOptions, containerOptions) {
+  const inputDescriptor = {
+    failOnError: true,
+    limitInputPixels: Math.pow(0x3FFF, 2),
+    sequentialRead: false
+  };
+  if (is.string(input)) {
+    // filesystem
+    inputDescriptor.file = input;
+  } else if (is.buffer(input)) {
+    // Buffer
+    inputDescriptor.buffer = input;
+  } else if (is.uint8Array(input)) {
+    // Uint8Array or Uint8ClampedArray
+    inputDescriptor.buffer = Buffer.from(input.buffer);
+  } else if (is.plainObject(input) && !is.defined(inputOptions)) {
+    // Plain Object descriptor, e.g. create
+    inputOptions = input;
+    if (_inputOptionsFromObject(inputOptions)) {
+      // Stream with options
+      inputDescriptor.buffer = [];
+    }
+  } else if (!is.defined(input) && !is.defined(inputOptions) && is.object(containerOptions) && containerOptions.allowStream) {
+    // Stream without options
+    inputDescriptor.buffer = [];
+  } else {
+    throw new Error(`Unsupported input '${input}' of type ${typeof input}${
+      is.defined(inputOptions) ? ` when also providing options of type ${typeof inputOptions}` : ''
+    }`);
+  }
+  if (is.object(inputOptions)) {
+    // Fail on error
+    if (is.defined(inputOptions.failOnError)) {
+      if (is.bool(inputOptions.failOnError)) {
+        inputDescriptor.failOnError = inputOptions.failOnError;
+      } else {
+        throw is.invalidParameterError('failOnError', 'boolean', inputOptions.failOnError);
+      }
+    }
+    // Density
+    if (is.defined(inputOptions.density)) {
+      if (is.inRange(inputOptions.density, 1, 100000)) {
+        inputDescriptor.density = inputOptions.density;
+      } else {
+        throw is.invalidParameterError('density', 'number between 1 and 100000', inputOptions.density);
+      }
+    }
+    // limitInputPixels
+    if (is.defined(inputOptions.limitInputPixels)) {
+      if (is.bool(inputOptions.limitInputPixels)) {
+        inputDescriptor.limitInputPixels = inputOptions.limitInputPixels
+          ? Math.pow(0x3FFF, 2)
+          : 0;
+      } else if (is.integer(inputOptions.limitInputPixels) && inputOptions.limitInputPixels >= 0) {
+        inputDescriptor.limitInputPixels = inputOptions.limitInputPixels;
+      } else {
+        throw is.invalidParameterError('limitInputPixels', 'integer >= 0', inputOptions.limitInputPixels);
+      }
+    }
+    // sequentialRead
+    if (is.defined(inputOptions.sequentialRead)) {
+      if (is.bool(inputOptions.sequentialRead)) {
+        inputDescriptor.sequentialRead = inputOptions.sequentialRead;
+      } else {
+        throw is.invalidParameterError('sequentialRead', 'boolean', inputOptions.sequentialRead);
+      }
+    }
+    // Raw pixel input
+    if (is.defined(inputOptions.raw)) {
+      if (
+        is.object(inputOptions.raw) &&
+        is.integer(inputOptions.raw.width) && inputOptions.raw.width > 0 &&
+        is.integer(inputOptions.raw.height) && inputOptions.raw.height > 0 &&
+        is.integer(inputOptions.raw.channels) && is.inRange(inputOptions.raw.channels, 1, 4)
+      ) {
+        inputDescriptor.rawWidth = inputOptions.raw.width;
+        inputDescriptor.rawHeight = inputOptions.raw.height;
+        inputDescriptor.rawChannels = inputOptions.raw.channels;
+      } else {
+        throw new Error('Expected width, height and channels for raw pixel input');
+      }
+    }
+    // Multi-page input (GIF, TIFF, PDF)
+    if (is.defined(inputOptions.animated)) {
+      if (is.bool(inputOptions.animated)) {
+        inputDescriptor.pages = inputOptions.animated ? -1 : 1;
+      } else {
+        throw is.invalidParameterError('animated', 'boolean', inputOptions.animated);
+      }
+    }
+    if (is.defined(inputOptions.pages)) {
+      if (is.integer(inputOptions.pages) && is.inRange(inputOptions.pages, -1, 100000)) {
+        inputDescriptor.pages = inputOptions.pages;
+      } else {
+        throw is.invalidParameterError('pages', 'integer between -1 and 100000', inputOptions.pages);
+      }
+    }
+    if (is.defined(inputOptions.page)) {
+      if (is.integer(inputOptions.page) && is.inRange(inputOptions.page, 0, 100000)) {
+        inputDescriptor.page = inputOptions.page;
+      } else {
+        throw is.invalidParameterError('page', 'integer between 0 and 100000', inputOptions.page);
+      }
+    }
+    // Multi-level input (OpenSlide)
+    if (is.defined(inputOptions.level)) {
+      if (is.integer(inputOptions.level) && is.inRange(inputOptions.level, 0, 256)) {
+        inputDescriptor.level = inputOptions.level;
+      } else {
+        throw is.invalidParameterError('level', 'integer between 0 and 256', inputOptions.level);
+      }
+    }
+    // Create new image
+    if (is.defined(inputOptions.create)) {
+      if (
+        is.object(inputOptions.create) &&
+        is.integer(inputOptions.create.width) && inputOptions.create.width > 0 &&
+        is.integer(inputOptions.create.height) && inputOptions.create.height > 0 &&
+        is.integer(inputOptions.create.channels)
+      ) {
+        inputDescriptor.createWidth = inputOptions.create.width;
+        inputDescriptor.createHeight = inputOptions.create.height;
+        inputDescriptor.createChannels = inputOptions.create.channels;
+        // Noise
+        if (is.defined(inputOptions.create.noise)) {
+          if (!is.object(inputOptions.create.noise)) {
+            throw new Error('Expected noise to be an object');
+          }
+          if (!is.inArray(inputOptions.create.noise.type, ['gaussian'])) {
+            throw new Error('Only gaussian noise is supported at the moment');
+          }
+          if (!is.inRange(inputOptions.create.channels, 1, 4)) {
+            throw is.invalidParameterError('create.channels', 'number between 1 and 4', inputOptions.create.channels);
+          }
+          inputDescriptor.createNoiseType = inputOptions.create.noise.type;
+          if (is.number(inputOptions.create.noise.mean) && is.inRange(inputOptions.create.noise.mean, 0, 10000)) {
+            inputDescriptor.createNoiseMean = inputOptions.create.noise.mean;
+          } else {
+            throw is.invalidParameterError('create.noise.mean', 'number between 0 and 10000', inputOptions.create.noise.mean);
+          }
+          if (is.number(inputOptions.create.noise.sigma) && is.inRange(inputOptions.create.noise.sigma, 0, 10000)) {
+            inputDescriptor.createNoiseSigma = inputOptions.create.noise.sigma;
+          } else {
+            throw is.invalidParameterError('create.noise.sigma', 'number between 0 and 10000', inputOptions.create.noise.sigma);
+          }
+        } else if (is.defined(inputOptions.create.background)) {
+          if (!is.inRange(inputOptions.create.channels, 3, 4)) {
+            throw is.invalidParameterError('create.channels', 'number between 3 and 4', inputOptions.create.channels);
+          }
+          const background = color(inputOptions.create.background);
+          inputDescriptor.createBackground = [
+            background.red(),
+            background.green(),
+            background.blue(),
+            Math.round(background.alpha() * 255)
+          ];
+        } else {
+          throw new Error('Expected valid noise or background to create a new input image');
+        }
+        delete inputDescriptor.buffer;
+      } else {
+        throw new Error('Expected valid width, height and channels to create a new input image');
+      }
+    }
+  } else if (is.defined(inputOptions)) {
+    throw new Error('Invalid input options ' + inputOptions);
+  }
+  return inputDescriptor;
+}
+
+/**
+ * Handle incoming Buffer chunk on Writable Stream.
+ * @private
+ * @param {Buffer} chunk
+ * @param {string} encoding - unused
+ * @param {Function} callback
+ */
+function _write (chunk, encoding, callback) {
+  /* istanbul ignore else */
+  if (Array.isArray(this.options.input.buffer)) {
+    /* istanbul ignore else */
+    if (is.buffer(chunk)) {
+      if (this.options.input.buffer.length === 0) {
+        this.on('finish', () => {
+          this.streamInFinished = true;
+        });
+      }
+      this.options.input.buffer.push(chunk);
+      callback();
+    } else {
+      callback(new Error('Non-Buffer data on Writable Stream'));
+    }
+  } else {
+    callback(new Error('Unexpected data on Writable Stream'));
+  }
+}
+
+/**
+ * Flattens the array of chunks accumulated in input.buffer.
+ * @private
+ */
+function _flattenBufferIn () {
+  if (this._isStreamInput()) {
+    this.options.input.buffer = Buffer.concat(this.options.input.buffer);
+  }
+}
+
+/**
+ * Are we expecting Stream-based input?
+ * @private
+ * @returns {boolean}
+ */
+function _isStreamInput () {
+  return Array.isArray(this.options.input.buffer);
+}
+
+/**
+ * Fast access to (uncached) image metadata without decoding any compressed image data.
+ * A `Promise` is returned when `callback` is not provided.
+ *
+ * - `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
+ * - `size`: Total size of image in bytes, for Stream and Buffer input only
+ * - `width`: Number of pixels wide (EXIF orientation is not taken into consideration)
+ * - `height`: Number of pixels high (EXIF orientation is not taken into consideration)
+ * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation)
+ * - `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
+ * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://libvips.github.io/libvips/API/current/VipsImage.html#VipsBandFormat)
+ * - `density`: Number of pixels per inch (DPI), if present
+ * - `chromaSubsampling`: String containing JPEG chroma subsampling, `4:2:0` or `4:4:4` for RGB, `4:2:0:4` or `4:4:4:4` for CMYK
+ * - `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
+ * - `pages`: Number of pages/frames contained within the image, with support for TIFF, HEIF, PDF, animated GIF and animated WebP
+ * - `pageHeight`: Number of pixels high each page in a multi-page image will be.
+ * - `loop`: Number of times to loop an animated image, zero refers to a continuous loop.
+ * - `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
+ * - `pagePrimary`: Number of the primary page in a HEIF image
+ * - `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
+ * - `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
+ * - `iptc`: Buffer containing raw IPTC data, if present
+ * - `xmp`: Buffer containing raw XMP data, if present
+ * - `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
+ *
+ * @example
+ * const 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
+ *   });
+ *
+ * @param {Function} [callback] - called with the arguments `(err, metadata)`
+ * @returns {Promise<Object>|Sharp}
+ */
+function metadata (callback) {
+  if (is.fn(callback)) {
+    if (this._isStreamInput()) {
+      this.on('finish', () => {
+        this._flattenBufferIn();
+        sharp.metadata(this.options, callback);
+      });
+    } else {
+      sharp.metadata(this.options, callback);
+    }
+    return this;
+  } else {
+    if (this._isStreamInput()) {
+      return new Promise((resolve, reject) => {
+        this.on('finish', () => {
+          this._flattenBufferIn();
+          sharp.metadata(this.options, (err, metadata) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(metadata);
+            }
+          });
+        });
+      });
+    } else {
+      return new Promise((resolve, reject) => {
+        sharp.metadata(this.options, (err, metadata) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(metadata);
+          }
+        });
+      });
+    }
+  }
+}
+
+/**
+ * Access to pixel-derived image statistics for every channel in the image.
+ * A `Promise` is returned when `callback` is not provided.
+ *
+ * - `channels`: Array of channel statistics for each channel in the image. Each channel statistic contains
+ *     - `min` (minimum value in the channel)
+ *     - `max` (maximum value in the channel)
+ *     - `sum` (sum of all values in a channel)
+ *     - `squaresSum` (sum of squared values in a channel)
+ *     - `mean` (mean of the values in a channel)
+ *     - `stdev` (standard deviation for the values in a channel)
+ *     - `minX` (x-coordinate of one of the pixel where the minimum lies)
+ *     - `minY` (y-coordinate of one of the pixel where the minimum lies)
+ *     - `maxX` (x-coordinate of one of the pixel where the maximum lies)
+ *     - `maxY` (y-coordinate of one of the pixel where the maximum lies)
+ * - `isOpaque`: Is the image fully opaque? Will be `true` if the image has no alpha channel or if every pixel is fully opaque.
+ * - `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any (experimental)
+ * - `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any (experimental)
+ * - `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram (experimental)
+ *
+ * @example
+ * const image = sharp(inputJpg);
+ * image
+ *   .stats()
+ *   .then(function(stats) {
+ *      // stats contains the channel-wise statistics array and the isOpaque value
+ *   });
+ *
+ * @example
+ * const { entropy, sharpness, dominant } = await sharp(input).stats();
+ * const { r, g, b } = dominant;
+ *
+ * @param {Function} [callback] - called with the arguments `(err, stats)`
+ * @returns {Promise<Object>}
+ */
+function stats (callback) {
+  if (is.fn(callback)) {
+    if (this._isStreamInput()) {
+      this.on('finish', () => {
+        this._flattenBufferIn();
+        sharp.stats(this.options, callback);
+      });
+    } else {
+      sharp.stats(this.options, callback);
+    }
+    return this;
+  } else {
+    if (this._isStreamInput()) {
+      return new Promise((resolve, reject) => {
+        this.on('finish', function () {
+          this._flattenBufferIn();
+          sharp.stats(this.options, (err, stats) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(stats);
+            }
+          });
+        });
+      });
+    } else {
+      return new Promise((resolve, reject) => {
+        sharp.stats(this.options, (err, stats) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(stats);
+          }
+        });
+      });
+    }
+  }
+}
+
+/**
+ * Decorate the Sharp prototype with input-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Object.assign(Sharp.prototype, {
+    // Private
+    _inputOptionsFromObject,
+    _createInputDescriptor,
+    _write,
+    _flattenBufferIn,
+    _isStreamInput,
+    // Public
+    metadata,
+    stats
+  });
+};

lib/is.js

@@ -0,0 +1,129 @@
+'use strict';
+
+/**
+ * Is this value defined and not null?
+ * @private
+ */
+const defined = function (val) {
+  return typeof val !== 'undefined' && val !== null;
+};
+
+/**
+ * Is this value an object?
+ * @private
+ */
+const object = function (val) {
+  return typeof val === 'object';
+};
+
+/**
+ * Is this value a plain object?
+ * @private
+ */
+const plainObject = function (val) {
+  return Object.prototype.toString.call(val) === '[object Object]';
+};
+
+/**
+ * Is this value a function?
+ * @private
+ */
+const fn = function (val) {
+  return typeof val === 'function';
+};
+
+/**
+ * Is this value a boolean?
+ * @private
+ */
+const bool = function (val) {
+  return typeof val === 'boolean';
+};
+
+/**
+ * Is this value a Buffer object?
+ * @private
+ */
+const buffer = function (val) {
+  return val instanceof Buffer;
+};
+
+/**
+ * Is this value a Uint8Array or Uint8ClampedArray object?
+ * @private
+ */
+const uint8Array = function (val) {
+  // allow both since Uint8ClampedArray simply clamps the values between 0-255
+  return val instanceof Uint8Array || val instanceof Uint8ClampedArray;
+};
+
+/**
+ * Is this value a non-empty string?
+ * @private
+ */
+const string = function (val) {
+  return typeof val === 'string' && val.length > 0;
+};
+
+/**
+ * Is this value a real number?
+ * @private
+ */
+const number = function (val) {
+  return typeof val === 'number' && !Number.isNaN(val);
+};
+
+/**
+ * Is this value an integer?
+ * @private
+ */
+const integer = function (val) {
+  return Number.isInteger(val);
+};
+
+/**
+ * Is this value within an inclusive given range?
+ * @private
+ */
+const inRange = function (val, min, max) {
+  return val >= min && val <= max;
+};
+
+/**
+ * Is this value within the elements of an array?
+ * @private
+ */
+const inArray = function (val, list) {
+  return list.includes(val);
+};
+
+/**
+ * Create an Error with a message relating to an invalid parameter.
+ *
+ * @param {string} name - parameter name.
+ * @param {string} expected - description of the type/value/range expected.
+ * @param {*} actual - the value received.
+ * @returns {Error} Containing the formatted message.
+ * @private
+ */
+const invalidParameterError = function (name, expected, actual) {
+  return new Error(
+    `Expected ${expected} for ${name} but received ${actual} of type ${typeof actual}`
+  );
+};
+
+module.exports = {
+  defined: defined,
+  object: object,
+  plainObject: plainObject,
+  fn: fn,
+  bool: bool,
+  buffer: buffer,
+  uint8Array: uint8Array,
+  string: string,
+  number: number,
+  integer: integer,
+  inRange: inRange,
+  inArray: inArray,
+  invalidParameterError: invalidParameterError
+};

lib/libvips.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const spawnSync = require('child_process').spawnSync;
+const semver = require('semver');
+const platform = require('./platform');
+
+const env = process.env;
+const minimumLibvipsVersionLabelled = env.npm_package_config_libvips || /* istanbul ignore next */
+  require('../package.json').config.libvips;
+const minimumLibvipsVersion = semver.coerce(minimumLibvipsVersionLabelled).version;
+
+const spawnSyncOptions = {
+  encoding: 'utf8',
+  shell: true
+};
+
+const mkdirSync = function (dirPath) {
+  try {
+    fs.mkdirSync(dirPath);
+  } catch (err) {
+    /* istanbul ignore if */
+    if (err.code !== 'EEXIST') {
+      throw err;
+    }
+  }
+};
+
+const cachePath = function () {
+  const npmCachePath = env.npm_config_cache || /* istanbul ignore next */
+    (env.APPDATA ? path.join(env.APPDATA, 'npm-cache') : path.join(os.homedir(), '.npm'));
+  mkdirSync(npmCachePath);
+  const libvipsCachePath = path.join(npmCachePath, '_libvips');
+  mkdirSync(libvipsCachePath);
+  return libvipsCachePath;
+};
+
+const isRosetta = function () {
+  /* istanbul ignore next */
+  if (process.platform === 'darwin' && process.arch === 'x64') {
+    const translated = spawnSync('sysctl sysctl.proc_translated', spawnSyncOptions).stdout;
+    return (translated || '').trim() === 'sysctl.proc_translated: 1';
+  }
+  return false;
+};
+
+const globalLibvipsVersion = function () {
+  if (process.platform !== 'win32') {
+    const globalLibvipsVersion = spawnSync(`PKG_CONFIG_PATH="${pkgConfigPath()}" pkg-config --modversion vips-cpp`, spawnSyncOptions).stdout;
+    /* istanbul ignore next */
+    return (globalLibvipsVersion || '').trim();
+  } else {
+    return '';
+  }
+};
+
+const hasVendoredLibvips = function () {
+  const currentPlatformId = platform();
+  const vendorPath = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion);
+  let vendorPlatformId;
+  try {
+    vendorPlatformId = require(path.join(vendorPath, 'platform.json'));
+  } catch (err) {}
+  /* istanbul ignore else */
+  if (vendorPlatformId) {
+    /* istanbul ignore else */
+    if (currentPlatformId === vendorPlatformId) {
+      return true;
+    } else {
+      throw new Error(`'${vendorPlatformId}' binaries cannot be used on the '${currentPlatformId}' platform. Please remove the 'node_modules/sharp' directory and run 'npm install' on the '${currentPlatformId}' platform.`);
+    }
+  } else {
+    return false;
+  }
+};
+
+const pkgConfigPath = function () {
+  if (process.platform !== 'win32') {
+    const brewPkgConfigPath = spawnSync('which brew >/dev/null 2>&1 && eval $(brew --env) && echo $PKG_CONFIG_LIBDIR', spawnSyncOptions).stdout || '';
+    return [brewPkgConfigPath.trim(), env.PKG_CONFIG_PATH, '/usr/local/lib/pkgconfig', '/usr/lib/pkgconfig']
+      .filter(function (p) { return !!p; })
+      .join(':');
+  } else {
+    return '';
+  }
+};
+
+const useGlobalLibvips = function () {
+  if (Boolean(env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
+    return false;
+  }
+  /* istanbul ignore next */
+  if (isRosetta()) {
+    return false;
+  }
+  const globalVipsVersion = globalLibvipsVersion();
+  return !!globalVipsVersion && /* istanbul ignore next */
+    semver.gte(globalVipsVersion, minimumLibvipsVersion);
+};
+
+module.exports = {
+  minimumLibvipsVersion,
+  minimumLibvipsVersionLabelled,
+  cachePath,
+  globalLibvipsVersion,
+  hasVendoredLibvips,
+  pkgConfigPath,
+  useGlobalLibvips,
+  mkdirSync
+};

lib/operation.js

@@ -0,0 +1,599 @@
+'use strict';
+
+const { flatten: flattenArray } = require('array-flatten');
+const color = require('color');
+const is = require('./is');
+
+/**
+ * Rotate the output image by either an explicit angle
+ * or auto-orient based on the EXIF `Orientation` tag.
+ *
+ * If an angle is provided, it is converted to a valid positive degree rotation.
+ * For example, `-450` will produce a 270deg rotation.
+ *
+ * When rotating by an angle other than a multiple of 90,
+ * the background colour can be provided with the `background` option.
+ *
+ * If no angle is provided, it is determined from the EXIF data.
+ * Mirroring is supported and may infer the use of a flip operation.
+ *
+ * The use of `rotate` implies the removal of the EXIF `Orientation` tag, if any.
+ *
+ * Method order is important when both rotating and extracting regions,
+ * for example `rotate(x).extract(y)` will produce a different result to `extract(y).rotate(x)`.
+ *
+ * @example
+ * const pipeline = sharp()
+ *   .rotate()
+ *   .resize(null, 200)
+ *   .toBuffer(function (err, outputBuffer, info) {
+ *     // outputBuffer contains 200px high JPEG image data,
+ *     // auto-rotated using EXIF Orientation tag
+ *     // info.width and info.height contain the dimensions of the resized image
+ *   });
+ * readableStream.pipe(pipeline);
+ *
+ * @param {number} [angle=auto] angle of rotation.
+ * @param {Object} [options] - if present, is an Object with optional attributes.
+ * @param {string|Object} [options.background="#000000"] parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function rotate (angle, options) {
+  if (!is.defined(angle)) {
+    this.options.useExifOrientation = true;
+  } else if (is.integer(angle) && !(angle % 90)) {
+    this.options.angle = angle;
+  } else if (is.number(angle)) {
+    this.options.rotationAngle = angle;
+    if (is.object(options) && options.background) {
+      const backgroundColour = color(options.background);
+      this.options.rotationBackground = [
+        backgroundColour.red(),
+        backgroundColour.green(),
+        backgroundColour.blue(),
+        Math.round(backgroundColour.alpha() * 255)
+      ];
+    }
+  } else {
+    throw is.invalidParameterError('angle', 'numeric', angle);
+  }
+  return this;
+}
+
+/**
+ * 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.
+ * @param {Boolean} [flip=true]
+ * @returns {Sharp}
+ */
+function flip (flip) {
+  this.options.flip = is.bool(flip) ? flip : true;
+  return this;
+}
+
+/**
+ * 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.
+ * @param {Boolean} [flop=true]
+ * @returns {Sharp}
+ */
+function flop (flop) {
+  this.options.flop = is.bool(flop) ? flop : true;
+  return this;
+}
+
+/**
+ * Perform an affine transform on an image. This operation will always occur after resizing, extraction and rotation, if any.
+ *
+ * You must provide an array of length 4 or a 2x2 affine transformation matrix.
+ * By default, new pixels are filled with a black background. You can provide a background color with the `background` option.
+ * A particular interpolator may also be specified. Set the `interpolator` option to an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.nohalo`.
+ *
+ * In the case of a 2x2 matrix, the transform is:
+ * - X = `matrix[0, 0]` \* (x + `idx`) + `matrix[0, 1]` \* (y + `idy`) + `odx`
+ * - Y = `matrix[1, 0]` \* (x + `idx`) + `matrix[1, 1]` \* (y + `idy`) + `ody`
+ *
+ * where:
+ * - x and y are the coordinates in input image.
+ * - X and Y are the coordinates in output image.
+ * - (0,0) is the upper left corner.
+ *
+ * @since 0.27.0
+ *
+ * @example
+ * const pipeline = sharp()
+ *   .affine([[1, 0.3], [0.1, 0.7]], {
+ *      background: 'white',
+ *      interpolate: sharp.interpolators.nohalo
+ *   })
+ *   .toBuffer((err, outputBuffer, info) => {
+ *      // outputBuffer contains the transformed image
+ *      // info.width and info.height contain the new dimensions
+ *   });
+ *
+ * inputStream
+ *   .pipe(pipeline);
+ *
+ * @param {Array<Array<number>>|Array<number>} matrix - affine transformation matrix
+ * @param {Object} [options] - if present, is an Object with optional attributes.
+ * @param {String|Object} [options.background="#000000"] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {Number} [options.idx=0] - input horizontal offset
+ * @param {Number} [options.idy=0] - input vertical offset
+ * @param {Number} [options.odx=0] - output horizontal offset
+ * @param {Number} [options.ody=0] - output vertical offset
+ * @param {String} [options.interpolator=sharp.interpolators.bicubic] - interpolator
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function affine (matrix, options) {
+  const flatMatrix = flattenArray(matrix);
+  if (flatMatrix.length === 4 && flatMatrix.every(is.number)) {
+    this.options.affineMatrix = flatMatrix;
+  } else {
+    throw is.invalidParameterError('matrix', '1x4 or 2x2 array', matrix);
+  }
+
+  if (is.defined(options)) {
+    if (is.object(options)) {
+      this._setBackgroundColourOption('affineBackground', options.background);
+      if (is.defined(options.idx)) {
+        if (is.number(options.idx)) {
+          this.options.affineIdx = options.idx;
+        } else {
+          throw is.invalidParameterError('options.idx', 'number', options.idx);
+        }
+      }
+      if (is.defined(options.idy)) {
+        if (is.number(options.idy)) {
+          this.options.affineIdy = options.idy;
+        } else {
+          throw is.invalidParameterError('options.idy', 'number', options.idy);
+        }
+      }
+      if (is.defined(options.odx)) {
+        if (is.number(options.odx)) {
+          this.options.affineOdx = options.odx;
+        } else {
+          throw is.invalidParameterError('options.odx', 'number', options.odx);
+        }
+      }
+      if (is.defined(options.ody)) {
+        if (is.number(options.ody)) {
+          this.options.affineOdy = options.ody;
+        } else {
+          throw is.invalidParameterError('options.ody', 'number', options.ody);
+        }
+      }
+      if (is.defined(options.interpolator)) {
+        if (is.inArray(options.interpolator, Object.values(this.constructor.interpolators))) {
+          this.options.affineInterpolator = options.interpolator;
+        } else {
+          throw is.invalidParameterError('options.interpolator', 'valid interpolator name', options.interpolator);
+        }
+      }
+    } else {
+      throw is.invalidParameterError('options', 'object', options);
+    }
+  }
+
+  return this;
+}
+
+/**
+ * Sharpen the image.
+ * When used without parameters, performs a fast, mild sharpen of the output image.
+ * When a `sigma` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space.
+ * Separate control over the level of sharpening in "flat" and "jagged" areas is available.
+ *
+ * @param {number} [sigma] - the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+ * @param {number} [flat=1.0] - the level of sharpening to apply to "flat" areas.
+ * @param {number} [jagged=2.0] - the level of sharpening to apply to "jagged" areas.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function sharpen (sigma, flat, jagged) {
+  if (!is.defined(sigma)) {
+    // No arguments: default to mild sharpen
+    this.options.sharpenSigma = -1;
+  } else if (is.bool(sigma)) {
+    // Boolean argument: apply mild sharpen?
+    this.options.sharpenSigma = sigma ? -1 : 0;
+  } else if (is.number(sigma) && is.inRange(sigma, 0.01, 10000)) {
+    // Numeric argument: specific sigma
+    this.options.sharpenSigma = sigma;
+    // Control over flat areas
+    if (is.defined(flat)) {
+      if (is.number(flat) && is.inRange(flat, 0, 10000)) {
+        this.options.sharpenFlat = flat;
+      } else {
+        throw is.invalidParameterError('flat', 'number between 0 and 10000', flat);
+      }
+    }
+    // Control over jagged areas
+    if (is.defined(jagged)) {
+      if (is.number(jagged) && is.inRange(jagged, 0, 10000)) {
+        this.options.sharpenJagged = jagged;
+      } else {
+        throw is.invalidParameterError('jagged', 'number between 0 and 10000', jagged);
+      }
+    }
+  } else {
+    throw is.invalidParameterError('sigma', 'number between 0.01 and 10000', sigma);
+  }
+  return this;
+}
+
+/**
+ * Apply median filter.
+ * When used without parameters the default window is 3x3.
+ * @param {number} [size=3] square mask size: size x size
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function median (size) {
+  if (!is.defined(size)) {
+    // No arguments: default to 3x3
+    this.options.medianSize = 3;
+  } else if (is.integer(size) && is.inRange(size, 1, 1000)) {
+    // Numeric argument: specific sigma
+    this.options.medianSize = size;
+  } else {
+    throw is.invalidParameterError('size', 'integer between 1 and 1000', size);
+  }
+  return this;
+}
+
+/**
+ * Blur the image.
+ * When used without parameters, performs a fast, mild blur of the output image.
+ * When a `sigma` is provided, performs a slower, more accurate Gaussian blur.
+ * @param {number} [sigma] a value between 0.3 and 1000 representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function blur (sigma) {
+  if (!is.defined(sigma)) {
+    // No arguments: default to mild blur
+    this.options.blurSigma = -1;
+  } else if (is.bool(sigma)) {
+    // Boolean argument: apply mild blur?
+    this.options.blurSigma = sigma ? -1 : 0;
+  } else if (is.number(sigma) && is.inRange(sigma, 0.3, 1000)) {
+    // Numeric argument: specific sigma
+    this.options.blurSigma = sigma;
+  } else {
+    throw is.invalidParameterError('sigma', 'number between 0.3 and 1000', sigma);
+  }
+  return this;
+}
+
+/**
+ * Merge alpha transparency channel, if any, with a background.
+ * @param {Object} [options]
+ * @param {string|Object} [options.background={r: 0, g: 0, b: 0}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black.
+ * @returns {Sharp}
+ */
+function flatten (options) {
+  this.options.flatten = is.bool(options) ? options : true;
+  if (is.object(options)) {
+    this._setBackgroundColourOption('flattenBackground', options.background);
+  }
+  return this;
+}
+
+/**
+ * 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`.
+ * This can improve the perceived brightness of a resized image in non-linear colour spaces.
+ * JPEG and WebP input images will not take advantage of the shrink-on-load performance optimisation
+ * when applying a gamma correction.
+ *
+ * Supply a second argument to use a different output gamma value, otherwise the first value is used in both cases.
+ *
+ * @param {number} [gamma=2.2] value between 1.0 and 3.0.
+ * @param {number} [gammaOut] value between 1.0 and 3.0. (optional, defaults to same as `gamma`)
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function gamma (gamma, gammaOut) {
+  if (!is.defined(gamma)) {
+    // Default gamma correction of 2.2 (sRGB)
+    this.options.gamma = 2.2;
+  } else if (is.number(gamma) && is.inRange(gamma, 1, 3)) {
+    this.options.gamma = gamma;
+  } else {
+    throw is.invalidParameterError('gamma', 'number between 1.0 and 3.0', gamma);
+  }
+  if (!is.defined(gammaOut)) {
+    // Default gamma correction for output is same as input
+    this.options.gammaOut = this.options.gamma;
+  } else if (is.number(gammaOut) && is.inRange(gammaOut, 1, 3)) {
+    this.options.gammaOut = gammaOut;
+  } else {
+    throw is.invalidParameterError('gammaOut', 'number between 1.0 and 3.0', gammaOut);
+  }
+  return this;
+}
+
+/**
+ * Produce the "negative" of the image.
+ * @param {Boolean} [negate=true]
+ * @returns {Sharp}
+ */
+function negate (negate) {
+  this.options.negate = is.bool(negate) ? negate : true;
+  return this;
+}
+
+/**
+ * Enhance output image contrast by stretching its luminance to cover the full dynamic range.
+ * @param {Boolean} [normalise=true]
+ * @returns {Sharp}
+ */
+function normalise (normalise) {
+  this.options.normalise = is.bool(normalise) ? normalise : true;
+  return this;
+}
+
+/**
+ * Alternative spelling of normalise.
+ * @param {Boolean} [normalize=true]
+ * @returns {Sharp}
+ */
+function normalize (normalize) {
+  return this.normalise(normalize);
+}
+
+/**
+ * Convolve the image with the specified kernel.
+ *
+ * @example
+ * 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
+ *   });
+ *
+ * @param {Object} kernel
+ * @param {number} kernel.width - width of the kernel in pixels.
+ * @param {number} kernel.height - width of the kernel in pixels.
+ * @param {Array<number>} kernel.kernel - Array of length `width*height` containing the kernel values.
+ * @param {number} [kernel.scale=sum] - the scale of the kernel in pixels.
+ * @param {number} [kernel.offset=0] - the offset of the kernel in pixels.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function convolve (kernel) {
+  if (!is.object(kernel) || !Array.isArray(kernel.kernel) ||
+      !is.integer(kernel.width) || !is.integer(kernel.height) ||
+      !is.inRange(kernel.width, 3, 1001) || !is.inRange(kernel.height, 3, 1001) ||
+      kernel.height * kernel.width !== kernel.kernel.length
+  ) {
+    // must pass in a kernel
+    throw new Error('Invalid convolution kernel');
+  }
+  // Default scale is sum of kernel values
+  if (!is.integer(kernel.scale)) {
+    kernel.scale = kernel.kernel.reduce(function (a, b) {
+      return a + b;
+    }, 0);
+  }
+  // Clip scale to a minimum value of 1
+  if (kernel.scale < 1) {
+    kernel.scale = 1;
+  }
+  if (!is.integer(kernel.offset)) {
+    kernel.offset = 0;
+  }
+  this.options.convKernel = kernel;
+  return this;
+}
+
+/**
+ * Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+ * @param {number} [threshold=128] - a value in the range 0-255 representing the level at which the threshold will be applied.
+ * @param {Object} [options]
+ * @param {Boolean} [options.greyscale=true] - convert to single channel greyscale.
+ * @param {Boolean} [options.grayscale=true] - alternative spelling for greyscale.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function threshold (threshold, options) {
+  if (!is.defined(threshold)) {
+    this.options.threshold = 128;
+  } else if (is.bool(threshold)) {
+    this.options.threshold = threshold ? 128 : 0;
+  } else if (is.integer(threshold) && is.inRange(threshold, 0, 255)) {
+    this.options.threshold = threshold;
+  } else {
+    throw is.invalidParameterError('threshold', 'integer between 0 and 255', threshold);
+  }
+  if (!is.object(options) || options.greyscale === true || options.grayscale === true) {
+    this.options.thresholdGrayscale = true;
+  } else {
+    this.options.thresholdGrayscale = false;
+  }
+  return this;
+}
+
+/**
+ * Perform a bitwise boolean operation with operand image.
+ *
+ * This operation creates an output image where each pixel is the result of
+ * the selected bitwise boolean `operation` between the corresponding pixels of the input images.
+ *
+ * @param {Buffer|string} operand - Buffer containing image data or string containing the path to an image file.
+ * @param {string} operator - one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
+ * @param {Object} [options]
+ * @param {Object} [options.raw] - describes operand when using raw pixel data.
+ * @param {number} [options.raw.width]
+ * @param {number} [options.raw.height]
+ * @param {number} [options.raw.channels]
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function boolean (operand, operator, options) {
+  this.options.boolean = this._createInputDescriptor(operand, options);
+  if (is.string(operator) && is.inArray(operator, ['and', 'or', 'eor'])) {
+    this.options.booleanOp = operator;
+  } else {
+    throw is.invalidParameterError('operator', 'one of: and, or, eor', operator);
+  }
+  return this;
+}
+
+/**
+ * Apply the linear formula a * input + b to the image (levels adjustment)
+ * @param {number} [a=1.0] multiplier
+ * @param {number} [b=0.0] offset
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function linear (a, b) {
+  if (!is.defined(a)) {
+    this.options.linearA = 1.0;
+  } else if (is.number(a)) {
+    this.options.linearA = a;
+  } else {
+    throw is.invalidParameterError('a', 'numeric', a);
+  }
+  if (!is.defined(b)) {
+    this.options.linearB = 0.0;
+  } else if (is.number(b)) {
+    this.options.linearB = b;
+  } else {
+    throw is.invalidParameterError('b', 'numeric', b);
+  }
+  return this;
+}
+
+/**
+ * Recomb the image with the specified matrix.
+ *
+ * @since 0.21.1
+ *
+ * @example
+ * sharp(input)
+ *   .recomb([
+ *    [0.3588, 0.7044, 0.1368],
+ *    [0.2990, 0.5870, 0.1140],
+ *    [0.2392, 0.4696, 0.0912],
+ *   ])
+ *   .raw()
+ *   .toBuffer(function(err, data, info) {
+ *     // data contains the raw pixel data after applying the recomb
+ *     // With this example input, a sepia filter has been applied
+ *   });
+ *
+ * @param {Array<Array<number>>} inputMatrix - 3x3 Recombination matrix
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function recomb (inputMatrix) {
+  if (!Array.isArray(inputMatrix) || inputMatrix.length !== 3 ||
+      inputMatrix[0].length !== 3 ||
+      inputMatrix[1].length !== 3 ||
+      inputMatrix[2].length !== 3
+  ) {
+    // must pass in a kernel
+    throw new Error('Invalid recombination matrix');
+  }
+  this.options.recombMatrix = [
+    inputMatrix[0][0], inputMatrix[0][1], inputMatrix[0][2],
+    inputMatrix[1][0], inputMatrix[1][1], inputMatrix[1][2],
+    inputMatrix[2][0], inputMatrix[2][1], inputMatrix[2][2]
+  ].map(Number);
+  return this;
+}
+
+/**
+ * Transforms the image using brightness, saturation and hue rotation.
+ *
+ * @since 0.22.1
+ *
+ * @example
+ * sharp(input)
+ *   .modulate({
+ *     brightness: 2 // increase lightness by a factor of 2
+ *   });
+ *
+ * sharp(input)
+ *   .modulate({
+ *     hue: 180 // hue-rotate by 180 degrees
+ *   });
+ *
+ * // decreate brightness and saturation while also hue-rotating by 90 degrees
+ * sharp(input)
+ *   .modulate({
+ *     brightness: 0.5,
+ *     saturation: 0.5,
+ *     hue: 90
+ *   });
+ *
+ * @param {Object} [options]
+ * @param {number} [options.brightness] Brightness multiplier
+ * @param {number} [options.saturation] Saturation multiplier
+ * @param {number} [options.hue] Degrees for hue rotation
+ * @returns {Sharp}
+ */
+function modulate (options) {
+  if (!is.plainObject(options)) {
+    throw is.invalidParameterError('options', 'plain object', options);
+  }
+  if ('brightness' in options) {
+    if (is.number(options.brightness) && options.brightness >= 0) {
+      this.options.brightness = options.brightness;
+    } else {
+      throw is.invalidParameterError('brightness', 'number above zero', options.brightness);
+    }
+  }
+  if ('saturation' in options) {
+    if (is.number(options.saturation) && options.saturation >= 0) {
+      this.options.saturation = options.saturation;
+    } else {
+      throw is.invalidParameterError('saturation', 'number above zero', options.saturation);
+    }
+  }
+  if ('hue' in options) {
+    if (is.integer(options.hue)) {
+      this.options.hue = options.hue % 360;
+    } else {
+      throw is.invalidParameterError('hue', 'number', options.hue);
+    }
+  }
+  return this;
+}
+
+/**
+ * Decorate the Sharp prototype with operation-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Object.assign(Sharp.prototype, {
+    rotate,
+    flip,
+    flop,
+    affine,
+    sharpen,
+    median,
+    blur,
+    flatten,
+    gamma,
+    negate,
+    normalise,
+    normalize,
+    convolve,
+    threshold,
+    boolean,
+    linear,
+    recomb,
+    modulate
+  });
+};

lib/output.js

@@ -0,0 +1,949 @@
+'use strict';
+
+const is = require('./is');
+const sharp = require('../build/Release/sharp.node');
+
+const formats = new Map([
+  ['heic', 'heif'],
+  ['heif', 'heif'],
+  ['avif', 'avif'],
+  ['jpeg', 'jpeg'],
+  ['jpg', 'jpeg'],
+  ['png', 'png'],
+  ['raw', 'raw'],
+  ['tiff', 'tiff'],
+  ['webp', 'webp'],
+  ['gif', 'gif']
+]);
+
+const errMagickSave = new Error('GIF output requires libvips with support for ImageMagick');
+
+/**
+ * Write output image data to a file.
+ *
+ * If an explicit output format is not selected, it will be inferred from the extension,
+ * with JPEG, PNG, WebP, AVIF, TIFF, DZI, and libvips' V format supported.
+ * Note that raw pixel data is only supported for buffer output.
+ *
+ * By default all metadata will be removed, which includes EXIF-based orientation.
+ * See {@link withMetadata} for control over this.
+ *
+ * A `Promise` is returned when `callback` is not provided.
+ *
+ * @example
+ * sharp(input)
+ *   .toFile('output.png', (err, info) => { ... });
+ *
+ * @example
+ * sharp(input)
+ *   .toFile('output.png')
+ *   .then(info => { ... })
+ *   .catch(err => { ... });
+ *
+ * @param {string} fileOut - the path to write the image data to.
+ * @param {Function} [callback] - called on completion with two arguments `(err, info)`.
+ * `info` contains the output image `format`, `size` (bytes), `width`, `height`,
+ * `channels` and `premultiplied` (indicating if premultiplication was used).
+ * When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
+ * @returns {Promise<Object>} - when no callback is provided
+ * @throws {Error} Invalid parameters
+ */
+function toFile (fileOut, callback) {
+  let err;
+  if (!is.string(fileOut)) {
+    err = new Error('Missing output file path');
+  } else if (this.options.input.file === fileOut) {
+    err = new Error('Cannot use same file for input and output');
+  } else if (this.options.formatOut === 'input' && fileOut.toLowerCase().endsWith('.gif') && !this.constructor.format.magick.output.file) {
+    err = errMagickSave;
+  }
+  if (err) {
+    if (is.fn(callback)) {
+      callback(err);
+    } else {
+      return Promise.reject(err);
+    }
+  } else {
+    this.options.fileOut = fileOut;
+    return this._pipeline(callback);
+  }
+  return this;
+}
+
+/**
+ * Write output to a Buffer.
+ * JPEG, PNG, WebP, AVIF, TIFF and raw pixel data output are supported.
+ *
+ * If no explicit format is set, the output format will match the input image, except GIF and SVG input which become PNG output.
+ *
+ * By default all metadata will be removed, which includes EXIF-based orientation.
+ * See {@link withMetadata} for control over this.
+ *
+ * `callback`, if present, gets three arguments `(err, data, info)` where:
+ * - `err` is an error, if any.
+ * - `data` is the output image data.
+ * - `info` contains the output image `format`, `size` (bytes), `width`, `height`,
+ * `channels` and `premultiplied` (indicating if premultiplication was used).
+ * When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
+ *
+ * A `Promise` is returned when `callback` is not provided.
+ *
+ * @example
+ * sharp(input)
+ *   .toBuffer((err, data, info) => { ... });
+ *
+ * @example
+ * sharp(input)
+ *   .toBuffer()
+ *   .then(data => { ... })
+ *   .catch(err => { ... });
+ *
+ * @example
+ * sharp(input)
+ *   .toBuffer({ resolveWithObject: true })
+ *   .then(({ data, info }) => { ... })
+ *   .catch(err => { ... });
+ *
+ * @example
+ * const data = await sharp('my-image.jpg')
+ *   // output the raw pixels
+ *   .raw()
+ *   .toBuffer();
+ *
+ * // create a more type safe way to work with the raw pixel data
+ * // this will not copy the data, instead it will change `data`s underlying ArrayBuffer
+ * // so `data` and `pixelArray` point to the same memory location
+ * const pixelArray = new Uint8ClampedArray(data.buffer);
+ *
+ * // When you are done changing the pixelArray, sharp takes the `pixelArray` as an input
+ * await sharp(pixelArray).toFile('my-changed-image.jpg');
+ *
+ * @param {Object} [options]
+ * @param {boolean} [options.resolveWithObject] Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
+ * @param {Function} [callback]
+ * @returns {Promise<Buffer>} - when no callback is provided
+ */
+function toBuffer (options, callback) {
+  if (is.object(options)) {
+    this._setBooleanOption('resolveWithObject', options.resolveWithObject);
+  } else if (this.options.resolveWithObject) {
+    this.options.resolveWithObject = false;
+  }
+  return this._pipeline(is.fn(options) ? options : callback);
+}
+
+/**
+ * Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
+ * This will also convert to and add a web-friendly sRGB ICC profile unless a custom
+ * output profile is provided.
+ *
+ * The default behaviour, when `withMetadata` is not used, is to convert to the device-independent
+ * sRGB colour space and strip all metadata, including the removal of any ICC profile.
+ *
+ * @example
+ * sharp('input.jpg')
+ *   .withMetadata()
+ *   .toFile('output-with-metadata.jpg')
+ *   .then(info => { ... });
+ *
+ * @param {Object} [options]
+ * @param {number} [options.orientation] value between 1 and 8, used to update the EXIF `Orientation` tag.
+ * @param {string} [options.icc] filesystem path to output ICC profile, defaults to sRGB.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function withMetadata (options) {
+  this.options.withMetadata = is.bool(options) ? options : true;
+  if (is.object(options)) {
+    if (is.defined(options.orientation)) {
+      if (is.integer(options.orientation) && is.inRange(options.orientation, 1, 8)) {
+        this.options.withMetadataOrientation = options.orientation;
+      } else {
+        throw is.invalidParameterError('orientation', 'integer between 1 and 8', options.orientation);
+      }
+    }
+    if (is.defined(options.icc)) {
+      if (is.string(options.icc)) {
+        this.options.withMetadataIcc = options.icc;
+      } else {
+        throw is.invalidParameterError('icc', 'string filesystem path to ICC profile', options.icc);
+      }
+    }
+  }
+  return this;
+}
+
+/**
+ * Force output to a given format.
+ *
+ * @example
+ * // Convert any input to PNG output
+ * const data = await sharp(input)
+ *   .toFormat('png')
+ *   .toBuffer();
+ *
+ * @param {(string|Object)} format - as a string or an Object with an 'id' attribute
+ * @param {Object} options - output options
+ * @returns {Sharp}
+ * @throws {Error} unsupported format or options
+ */
+function toFormat (format, options) {
+  const actualFormat = formats.get((is.object(format) && is.string(format.id) ? format.id : format).toLowerCase());
+  if (!actualFormat) {
+    throw is.invalidParameterError('format', `one of: ${[...formats.keys()].join(', ')}`, format);
+  }
+  return this[actualFormat](options);
+}
+
+/**
+ * Use these JPEG options for output image.
+ *
+ * Some of these options require the use of a globally-installed libvips compiled with support for mozjpeg.
+ *
+ * @example
+ * // Convert any input to very high quality JPEG output
+ * const data = await sharp(input)
+ *   .jpeg({
+ *     quality: 100,
+ *     chromaSubsampling: '4:4:4'
+ *   })
+ *   .toBuffer();
+ *
+ * @param {Object} [options] - output options
+ * @param {number} [options.quality=80] - quality, integer 1-100
+ * @param {boolean} [options.progressive=false] - use progressive (interlace) scan
+ * @param {string} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling
+ * @param {boolean} [options.optimiseCoding=true] - optimise Huffman coding tables
+ * @param {boolean} [options.optimizeCoding=true] - alternative spelling of optimiseCoding
+ * @param {boolean} [options.trellisQuantisation=false] - apply trellis quantisation, requires libvips compiled with support for mozjpeg
+ * @param {boolean} [options.overshootDeringing=false] - apply overshoot deringing, requires libvips compiled with support for mozjpeg
+ * @param {boolean} [options.optimiseScans=false] - optimise progressive scans, forces progressive, requires libvips compiled with support for mozjpeg
+ * @param {boolean} [options.optimizeScans=false] - alternative spelling of optimiseScans, requires libvips compiled with support for mozjpeg
+ * @param {number} [options.quantisationTable=0] - quantization table to use, integer 0-8, requires libvips compiled with support for mozjpeg
+ * @param {number} [options.quantizationTable=0] - alternative spelling of quantisationTable, requires libvips compiled with support for mozjpeg
+ * @param {boolean} [options.force=true] - force JPEG output, otherwise attempt to use input format
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+function jpeg (options) {
+  if (is.object(options)) {
+    if (is.defined(options.quality)) {
+      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
+        this.options.jpegQuality = options.quality;
+      } else {
+        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+      }
+    }
+    if (is.defined(options.progressive)) {
+      this._setBooleanOption('jpegProgressive', options.progressive);
+    }
+    if (is.defined(options.chromaSubsampling)) {
+      if (is.string(options.chromaSubsampling) && is.inArray(options.chromaSubsampling, ['4:2:0', '4:4:4'])) {
+        this.options.jpegChromaSubsampling = options.chromaSubsampling;
+      } else {
+        throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
+      }
+    }
+    const trellisQuantisation = is.bool(options.trellisQuantization) ? options.trellisQuantization : options.trellisQuantisation;
+    if (is.defined(trellisQuantisation)) {
+      this._setBooleanOption('jpegTrellisQuantisation', trellisQuantisation);
+    }
+    if (is.defined(options.overshootDeringing)) {
+      this._setBooleanOption('jpegOvershootDeringing', options.overshootDeringing);
+    }
+    const optimiseScans = is.bool(options.optimizeScans) ? options.optimizeScans : options.optimiseScans;
+    if (is.defined(optimiseScans)) {
+      this._setBooleanOption('jpegOptimiseScans', optimiseScans);
+      if (optimiseScans) {
+        this.options.jpegProgressive = true;
+      }
+    }
+    const optimiseCoding = is.bool(options.optimizeCoding) ? options.optimizeCoding : options.optimiseCoding;
+    if (is.defined(optimiseCoding)) {
+      this._setBooleanOption('jpegOptimiseCoding', optimiseCoding);
+    }
+    const quantisationTable = is.number(options.quantizationTable) ? options.quantizationTable : options.quantisationTable;
+    if (is.defined(quantisationTable)) {
+      if (is.integer(quantisationTable) && is.inRange(quantisationTable, 0, 8)) {
+        this.options.jpegQuantisationTable = quantisationTable;
+      } else {
+        throw is.invalidParameterError('quantisationTable', 'integer between 0 and 8', quantisationTable);
+      }
+    }
+  }
+  return this._updateFormatOut('jpeg', options);
+}
+
+/**
+ * Use these PNG options for output image.
+ *
+ * PNG output is always full colour at 8 or 16 bits per pixel.
+ * Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
+ *
+ * Some of these options require the use of a globally-installed libvips compiled with support for libimagequant (GPL).
+ *
+ * @example
+ * // Convert any input to PNG output
+ * const data = await sharp(input)
+ *   .png()
+ *   .toBuffer();
+ *
+ * @param {Object} [options]
+ * @param {boolean} [options.progressive=false] - use progressive (interlace) scan
+ * @param {number} [options.compressionLevel=9] - zlib compression level, 0-9
+ * @param {boolean} [options.adaptiveFiltering=false] - use adaptive row filtering
+ * @param {boolean} [options.palette=false] - quantise to a palette-based image with alpha transparency support, requires libvips compiled with support for libimagequant
+ * @param {number} [options.quality=100] - use the lowest number of colours needed to achieve given quality, sets `palette` to `true`, requires libvips compiled with support for libimagequant
+ * @param {number} [options.colours=256] - maximum number of palette entries, sets `palette` to `true`, requires libvips compiled with support for libimagequant
+ * @param {number} [options.colors=256] - alternative spelling of `options.colours`, sets `palette` to `true`, requires libvips compiled with support for libimagequant
+ * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, sets `palette` to `true`, requires libvips compiled with support for libimagequant
+ * @param {boolean} [options.force=true] - force PNG output, otherwise attempt to use input format
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+function png (options) {
+  if (is.object(options)) {
+    if (is.defined(options.progressive)) {
+      this._setBooleanOption('pngProgressive', options.progressive);
+    }
+    if (is.defined(options.compressionLevel)) {
+      if (is.integer(options.compressionLevel) && is.inRange(options.compressionLevel, 0, 9)) {
+        this.options.pngCompressionLevel = options.compressionLevel;
+      } else {
+        throw is.invalidParameterError('compressionLevel', 'integer between 0 and 9', options.compressionLevel);
+      }
+    }
+    if (is.defined(options.adaptiveFiltering)) {
+      this._setBooleanOption('pngAdaptiveFiltering', options.adaptiveFiltering);
+    }
+    if (is.defined(options.palette)) {
+      this._setBooleanOption('pngPalette', options.palette);
+    } else if (is.defined(options.quality) || is.defined(options.colours || options.colors) || is.defined(options.dither)) {
+      this._setBooleanOption('pngPalette', true);
+    }
+    if (this.options.pngPalette) {
+      if (is.defined(options.quality)) {
+        if (is.integer(options.quality) && is.inRange(options.quality, 0, 100)) {
+          this.options.pngQuality = options.quality;
+        } else {
+          throw is.invalidParameterError('quality', 'integer between 0 and 100', options.quality);
+        }
+      }
+      const colours = options.colours || options.colors;
+      if (is.defined(colours)) {
+        if (is.integer(colours) && is.inRange(colours, 2, 256)) {
+          this.options.pngColours = colours;
+        } else {
+          throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
+        }
+      }
+      if (is.defined(options.dither)) {
+        if (is.number(options.dither) && is.inRange(options.dither, 0, 1)) {
+          this.options.pngDither = options.dither;
+        } else {
+          throw is.invalidParameterError('dither', 'number between 0.0 and 1.0', options.dither);
+        }
+      }
+    }
+  }
+  return this._updateFormatOut('png', options);
+}
+
+/**
+ * Use these WebP options for output image.
+ *
+ * @example
+ * // Convert any input to lossless WebP output
+ * const data = await sharp(input)
+ *   .webp({ lossless: true })
+ *   .toBuffer();
+ *
+ * @param {Object} [options] - output options
+ * @param {number} [options.quality=80] - quality, integer 1-100
+ * @param {number} [options.alphaQuality=100] - quality of alpha layer, integer 0-100
+ * @param {boolean} [options.lossless=false] - use lossless compression mode
+ * @param {boolean} [options.nearLossless=false] - use near_lossless compression mode
+ * @param {boolean} [options.smartSubsample=false] - use high quality chroma subsampling
+ * @param {number} [options.reductionEffort=4] - level of CPU effort to reduce file size, integer 0-6
+ * @param {number} [options.pageHeight] - page height for animated output
+ * @param {number} [options.loop=0] - number of animation iterations, use 0 for infinite animation
+ * @param {number[]} [options.delay] - list of delays between animation frames (in milliseconds)
+ * @param {boolean} [options.force=true] - force WebP output, otherwise attempt to use input format
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+function webp (options) {
+  if (is.object(options) && is.defined(options.quality)) {
+    if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
+      this.options.webpQuality = options.quality;
+    } else {
+      throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+    }
+  }
+  if (is.object(options) && is.defined(options.alphaQuality)) {
+    if (is.integer(options.alphaQuality) && is.inRange(options.alphaQuality, 0, 100)) {
+      this.options.webpAlphaQuality = options.alphaQuality;
+    } else {
+      throw is.invalidParameterError('alphaQuality', 'integer between 0 and 100', options.alphaQuality);
+    }
+  }
+  if (is.object(options) && is.defined(options.lossless)) {
+    this._setBooleanOption('webpLossless', options.lossless);
+  }
+  if (is.object(options) && is.defined(options.nearLossless)) {
+    this._setBooleanOption('webpNearLossless', options.nearLossless);
+  }
+  if (is.object(options) && is.defined(options.smartSubsample)) {
+    this._setBooleanOption('webpSmartSubsample', options.smartSubsample);
+  }
+  if (is.object(options) && is.defined(options.reductionEffort)) {
+    if (is.integer(options.reductionEffort) && is.inRange(options.reductionEffort, 0, 6)) {
+      this.options.webpReductionEffort = options.reductionEffort;
+    } else {
+      throw is.invalidParameterError('reductionEffort', 'integer between 0 and 6', options.reductionEffort);
+    }
+  }
+
+  trySetAnimationOptions(options, this.options);
+  return this._updateFormatOut('webp', options);
+}
+
+/**
+ * Use these GIF options for output image.
+ *
+ * Requires libvips compiled with support for ImageMagick or GraphicsMagick.
+ * The prebuilt binaries do not include this - see
+ * {@link https://sharp.pixelplumbing.com/install#custom-libvips installing a custom libvips}.
+ *
+ * @param {Object} [options] - output options
+ * @param {number} [options.pageHeight] - page height for animated output
+ * @param {number} [options.loop=0] - number of animation iterations, use 0 for infinite animation
+ * @param {number[]} [options.delay] - list of delays between animation frames (in milliseconds)
+ * @param {boolean} [options.force=true] - force GIF output, otherwise attempt to use input format
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+/* istanbul ignore next */
+function gif (options) {
+  if (!this.constructor.format.magick.output.buffer) {
+    throw errMagickSave;
+  }
+  trySetAnimationOptions(options, this.options);
+  return this._updateFormatOut('gif', options);
+}
+
+/**
+ * Set animation options if available.
+ * @private
+ *
+ * @param {Object} [source] - output options
+ * @param {number} [source.pageHeight] - page height for animated output
+ * @param {number} [source.loop=0] - number of animation iterations, use 0 for infinite animation
+ * @param {number[]} [source.delay] - list of delays between animation frames (in milliseconds)
+ * @param {Object} [target] - target object for valid options
+ * @throws {Error} Invalid options
+ */
+function trySetAnimationOptions (source, target) {
+  if (is.object(source) && is.defined(source.pageHeight)) {
+    if (is.integer(source.pageHeight) && source.pageHeight > 0) {
+      target.pageHeight = source.pageHeight;
+    } else {
+      throw is.invalidParameterError('pageHeight', 'integer larger than 0', source.pageHeight);
+    }
+  }
+  if (is.object(source) && is.defined(source.loop)) {
+    if (is.integer(source.loop) && is.inRange(source.loop, 0, 65535)) {
+      target.loop = source.loop;
+    } else {
+      throw is.invalidParameterError('loop', 'integer between 0 and 65535', source.loop);
+    }
+  }
+  if (is.object(source) && is.defined(source.delay)) {
+    if (
+      Array.isArray(source.delay) &&
+      source.delay.every(is.integer) &&
+      source.delay.every(v => is.inRange(v, 0, 65535))) {
+      target.delay = source.delay;
+    } else {
+      throw is.invalidParameterError('delay', 'array of integers between 0 and 65535', source.delay);
+    }
+  }
+}
+
+/**
+ * Use these TIFF options for output image.
+ *
+ * @example
+ * // Convert SVG input to LZW-compressed, 1 bit per pixel TIFF output
+ * sharp('input.svg')
+ *   .tiff({
+ *     compression: 'lzw',
+ *     bitdepth: 1
+ *   })
+ *   .toFile('1-bpp-output.tiff')
+ *   .then(info => { ... });
+ *
+ * @param {Object} [options] - output options
+ * @param {number} [options.quality=80] - quality, integer 1-100
+ * @param {boolean} [options.force=true] - force TIFF output, otherwise attempt to use input format
+ * @param {string} [options.compression='jpeg'] - compression options: lzw, deflate, jpeg, ccittfax4
+ * @param {string} [options.predictor='horizontal'] - compression predictor options: none, horizontal, float
+ * @param {boolean} [options.pyramid=false] - write an image pyramid
+ * @param {boolean} [options.tile=false] - write a tiled tiff
+ * @param {number} [options.tileWidth=256] - horizontal tile size
+ * @param {number} [options.tileHeight=256] - vertical tile size
+ * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm
+ * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm
+ * @param {number} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+function tiff (options) {
+  if (is.object(options)) {
+    if (is.defined(options.quality)) {
+      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
+        this.options.tiffQuality = options.quality;
+      } else {
+        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+      }
+    }
+    if (is.defined(options.bitdepth)) {
+      if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4, 8])) {
+        this.options.tiffBitdepth = options.bitdepth;
+      } else {
+        throw is.invalidParameterError('bitdepth', '1, 2, 4 or 8', options.bitdepth);
+      }
+    }
+    // tiling
+    if (is.defined(options.tile)) {
+      this._setBooleanOption('tiffTile', options.tile);
+    }
+    if (is.defined(options.tileWidth)) {
+      if (is.integer(options.tileWidth) && options.tileWidth > 0) {
+        this.options.tiffTileWidth = options.tileWidth;
+      } else {
+        throw is.invalidParameterError('tileWidth', 'integer greater than zero', options.tileWidth);
+      }
+    }
+    if (is.defined(options.tileHeight)) {
+      if (is.integer(options.tileHeight) && options.tileHeight > 0) {
+        this.options.tiffTileHeight = options.tileHeight;
+      } else {
+        throw is.invalidParameterError('tileHeight', 'integer greater than zero', options.tileHeight);
+      }
+    }
+    // pyramid
+    if (is.defined(options.pyramid)) {
+      this._setBooleanOption('tiffPyramid', options.pyramid);
+    }
+    // resolution
+    if (is.defined(options.xres)) {
+      if (is.number(options.xres) && options.xres > 0) {
+        this.options.tiffXres = options.xres;
+      } else {
+        throw is.invalidParameterError('xres', 'number greater than zero', options.xres);
+      }
+    }
+    if (is.defined(options.yres)) {
+      if (is.number(options.yres) && options.yres > 0) {
+        this.options.tiffYres = options.yres;
+      } else {
+        throw is.invalidParameterError('yres', 'number greater than zero', options.yres);
+      }
+    }
+    // compression
+    if (is.defined(options.compression)) {
+      if (is.string(options.compression) && is.inArray(options.compression, ['lzw', 'deflate', 'jpeg', 'ccittfax4', 'none'])) {
+        this.options.tiffCompression = options.compression;
+      } else {
+        throw is.invalidParameterError('compression', 'one of: lzw, deflate, jpeg, ccittfax4, none', options.compression);
+      }
+    }
+    // predictor
+    if (is.defined(options.predictor)) {
+      if (is.string(options.predictor) && is.inArray(options.predictor, ['none', 'horizontal', 'float'])) {
+        this.options.tiffPredictor = options.predictor;
+      } else {
+        throw is.invalidParameterError('predictor', 'one of: none, horizontal, float', options.predictor);
+      }
+    }
+  }
+  return this._updateFormatOut('tiff', options);
+}
+
+/**
+ * Use these AVIF options for output image.
+ *
+ * Whilst it is possible to create AVIF images smaller than 16x16 pixels,
+ * most web browsers do not display these properly.
+ *
+ * @since 0.27.0
+ *
+ * @param {Object} [options] - output options
+ * @param {number} [options.quality=50] - quality, integer 1-100
+ * @param {boolean} [options.lossless=false] - use lossless compression
+ * @param {number} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
+ * @param {string} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+function avif (options) {
+  return this.heif({ ...options, compression: 'av1' });
+}
+
+/**
+ * Use these HEIF options for output image.
+ *
+ * Support for patent-encumbered HEIC images requires the use of a
+ * globally-installed libvips compiled with support for libheif, libde265 and x265.
+ *
+ * @since 0.23.0
+ *
+ * @param {Object} [options] - output options
+ * @param {number} [options.quality=50] - quality, integer 1-100
+ * @param {string} [options.compression='av1'] - compression format: av1, hevc
+ * @param {boolean} [options.lossless=false] - use lossless compression
+ * @param {number} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
+ * @param {string} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+function heif (options) {
+  if (is.object(options)) {
+    if (is.defined(options.quality)) {
+      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
+        this.options.heifQuality = options.quality;
+      } else {
+        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+      }
+    }
+    if (is.defined(options.lossless)) {
+      if (is.bool(options.lossless)) {
+        this.options.heifLossless = options.lossless;
+      } else {
+        throw is.invalidParameterError('lossless', 'boolean', options.lossless);
+      }
+    }
+    if (is.defined(options.compression)) {
+      if (is.string(options.compression) && is.inArray(options.compression, ['av1', 'hevc'])) {
+        this.options.heifCompression = options.compression;
+      } else {
+        throw is.invalidParameterError('compression', 'one of: av1, hevc', options.compression);
+      }
+    }
+    if (is.defined(options.speed)) {
+      if (is.integer(options.speed) && is.inRange(options.speed, 0, 8)) {
+        this.options.heifSpeed = options.speed;
+      } else {
+        throw is.invalidParameterError('speed', 'integer between 0 and 8', options.speed);
+      }
+    }
+    if (is.defined(options.chromaSubsampling)) {
+      if (is.string(options.chromaSubsampling) && is.inArray(options.chromaSubsampling, ['4:2:0', '4:4:4'])) {
+        this.options.heifChromaSubsampling = options.chromaSubsampling;
+      } else {
+        throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
+      }
+    }
+  }
+  return this._updateFormatOut('heif', options);
+}
+
+/**
+ * Force output to be raw, uncompressed, 8-bit unsigned integer (unit8) pixel data.
+ * Pixel ordering is left-to-right, top-to-bottom, without padding.
+ * Channel ordering will be RGB or RGBA for non-greyscale colourspaces.
+ *
+ * @example
+ * // Extract raw RGB pixel data from JPEG input
+ * const { data, info } = await sharp('input.jpg')
+ *   .raw()
+ *   .toBuffer({ resolveWithObject: true });
+ *
+ * @example
+ * // Extract alpha channel as raw pixel data from PNG input
+ * const data = await sharp('input.png')
+ *   .ensureAlpha()
+ *   .extractChannel(3)
+ *   .toColourspace('b-w')
+ *   .raw()
+ *   .toBuffer();
+ *
+ * @returns {Sharp}
+ */
+function raw () {
+  return this._updateFormatOut('raw');
+}
+
+/**
+ * Use tile-based deep zoom (image pyramid) output.
+ * Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
+ * Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed archive file format.
+ *
+ * Warning: multiple sharp instances concurrently producing tile output can expose a possible race condition in some versions of libgsf.
+ *
+ * @example
+ *  sharp('input.tiff')
+ *   .png()
+ *   .tile({
+ *     size: 512
+ *   })
+ *   .toFile('output.dz', function(err, info) {
+ *     // output.dzi is the Deep Zoom XML definition
+ *     // output_files contains 512x512 tiles grouped by zoom level
+ *   });
+ *
+ * @param {Object} [options]
+ * @param {number} [options.size=256] tile size in pixels, a value between 1 and 8192.
+ * @param {number} [options.overlap=0] tile overlap in pixels, a value between 0 and 8192.
+ * @param {number} [options.angle=0] tile angle of rotation, must be a multiple of 90.
+ * @param {string|Object} [options.background={r: 255, g: 255, b: 255, alpha: 1}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to white without transparency.
+ * @param {string} [options.depth] how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
+ * @param {number} [options.skipBlanks=-1] threshold to skip tile generation, a value 0 - 255 for 8-bit images or 0 - 65535 for 16-bit images
+ * @param {string} [options.container='fs'] tile container, with value `fs` (filesystem) or `zip` (compressed file).
+ * @param {string} [options.layout='dz'] filesystem layout, possible values are `dz`, `iiif`, `zoomify` or `google`.
+ * @param {boolean} [options.centre=false] centre image in tile.
+ * @param {boolean} [options.center=false] alternative spelling of centre.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function tile (options) {
+  if (is.object(options)) {
+    // Size of square tiles, in pixels
+    if (is.defined(options.size)) {
+      if (is.integer(options.size) && is.inRange(options.size, 1, 8192)) {
+        this.options.tileSize = options.size;
+      } else {
+        throw is.invalidParameterError('size', 'integer between 1 and 8192', options.size);
+      }
+    }
+    // Overlap of tiles, in pixels
+    if (is.defined(options.overlap)) {
+      if (is.integer(options.overlap) && is.inRange(options.overlap, 0, 8192)) {
+        if (options.overlap > this.options.tileSize) {
+          throw is.invalidParameterError('overlap', `<= size (${this.options.tileSize})`, options.overlap);
+        }
+        this.options.tileOverlap = options.overlap;
+      } else {
+        throw is.invalidParameterError('overlap', 'integer between 0 and 8192', options.overlap);
+      }
+    }
+    // Container
+    if (is.defined(options.container)) {
+      if (is.string(options.container) && is.inArray(options.container, ['fs', 'zip'])) {
+        this.options.tileContainer = options.container;
+      } else {
+        throw is.invalidParameterError('container', 'one of: fs, zip', options.container);
+      }
+    }
+    // Layout
+    if (is.defined(options.layout)) {
+      if (is.string(options.layout) && is.inArray(options.layout, ['dz', 'google', 'iiif', 'zoomify'])) {
+        this.options.tileLayout = options.layout;
+      } else {
+        throw is.invalidParameterError('layout', 'one of: dz, google, iiif, zoomify', options.layout);
+      }
+    }
+    // Angle of rotation,
+    if (is.defined(options.angle)) {
+      if (is.integer(options.angle) && !(options.angle % 90)) {
+        this.options.tileAngle = options.angle;
+      } else {
+        throw is.invalidParameterError('angle', 'positive/negative multiple of 90', options.angle);
+      }
+    }
+    // Background colour
+    this._setBackgroundColourOption('tileBackground', options.background);
+    // Depth of tiles
+    if (is.defined(options.depth)) {
+      if (is.string(options.depth) && is.inArray(options.depth, ['onepixel', 'onetile', 'one'])) {
+        this.options.tileDepth = options.depth;
+      } else {
+        throw is.invalidParameterError('depth', 'one of: onepixel, onetile, one', options.depth);
+      }
+    }
+    // Threshold to skip blank tiles
+    if (is.defined(options.skipBlanks)) {
+      if (is.integer(options.skipBlanks) && is.inRange(options.skipBlanks, -1, 65535)) {
+        this.options.tileSkipBlanks = options.skipBlanks;
+      } else {
+        throw is.invalidParameterError('skipBlanks', 'integer between -1 and 255/65535', options.skipBlanks);
+      }
+    } else if (is.defined(options.layout) && options.layout === 'google') {
+      this.options.tileSkipBlanks = 5;
+    }
+    // Center image in tile
+    const centre = is.bool(options.center) ? options.center : options.centre;
+    if (is.defined(centre)) {
+      this._setBooleanOption('tileCentre', centre);
+    }
+  }
+  // Format
+  if (is.inArray(this.options.formatOut, ['jpeg', 'png', 'webp'])) {
+    this.options.tileFormat = this.options.formatOut;
+  } else if (this.options.formatOut !== 'input') {
+    throw is.invalidParameterError('format', 'one of: jpeg, png, webp', this.options.formatOut);
+  }
+  return this._updateFormatOut('dz');
+}
+
+/**
+ * Update the output format unless options.force is false,
+ * in which case revert to input format.
+ * @private
+ * @param {string} formatOut
+ * @param {Object} [options]
+ * @param {boolean} [options.force=true] - force output format, otherwise attempt to use input format
+ * @returns {Sharp}
+ */
+function _updateFormatOut (formatOut, options) {
+  if (!(is.object(options) && options.force === false)) {
+    this.options.formatOut = formatOut;
+  }
+  return this;
+}
+
+/**
+ * Update a boolean attribute of the this.options Object.
+ * @private
+ * @param {string} key
+ * @param {boolean} val
+ * @throws {Error} Invalid key
+ */
+function _setBooleanOption (key, val) {
+  if (is.bool(val)) {
+    this.options[key] = val;
+  } else {
+    throw is.invalidParameterError(key, 'boolean', val);
+  }
+}
+
+/**
+ * Called by a WriteableStream to notify us it is ready for data.
+ * @private
+ */
+function _read () {
+  /* istanbul ignore else */
+  if (!this.options.streamOut) {
+    this.options.streamOut = true;
+    this._pipeline();
+  }
+}
+
+/**
+ * Invoke the C++ image processing pipeline
+ * Supports callback, stream and promise variants
+ * @private
+ */
+function _pipeline (callback) {
+  if (typeof callback === 'function') {
+    // output=file/buffer
+    if (this._isStreamInput()) {
+      // output=file/buffer, input=stream
+      this.on('finish', () => {
+        this._flattenBufferIn();
+        sharp.pipeline(this.options, callback);
+      });
+    } else {
+      // output=file/buffer, input=file/buffer
+      sharp.pipeline(this.options, callback);
+    }
+    return this;
+  } else if (this.options.streamOut) {
+    // output=stream
+    if (this._isStreamInput()) {
+      // output=stream, input=stream
+      this.once('finish', () => {
+        this._flattenBufferIn();
+        sharp.pipeline(this.options, (err, data, info) => {
+          if (err) {
+            this.emit('error', err);
+          } else {
+            this.emit('info', info);
+            this.push(data);
+          }
+          this.push(null);
+        });
+      });
+      if (this.streamInFinished) {
+        this.emit('finish');
+      }
+    } else {
+      // output=stream, input=file/buffer
+      sharp.pipeline(this.options, (err, data, info) => {
+        if (err) {
+          this.emit('error', err);
+        } else {
+          this.emit('info', info);
+          this.push(data);
+        }
+        this.push(null);
+      });
+    }
+    return this;
+  } else {
+    // output=promise
+    if (this._isStreamInput()) {
+      // output=promise, input=stream
+      return new Promise((resolve, reject) => {
+        this.once('finish', () => {
+          this._flattenBufferIn();
+          sharp.pipeline(this.options, (err, data, info) => {
+            if (err) {
+              reject(err);
+            } else {
+              if (this.options.resolveWithObject) {
+                resolve({ data, info });
+              } else {
+                resolve(data);
+              }
+            }
+          });
+        });
+      });
+    } else {
+      // output=promise, input=file/buffer
+      return new Promise((resolve, reject) => {
+        sharp.pipeline(this.options, (err, data, info) => {
+          if (err) {
+            reject(err);
+          } else {
+            if (this.options.resolveWithObject) {
+              resolve({ data: data, info: info });
+            } else {
+              resolve(data);
+            }
+          }
+        });
+      });
+    }
+  }
+}
+
+/**
+ * Decorate the Sharp prototype with output-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Object.assign(Sharp.prototype, {
+    // Public
+    toFile,
+    toBuffer,
+    withMetadata,
+    toFormat,
+    jpeg,
+    png,
+    webp,
+    tiff,
+    avif,
+    heif,
+    gif,
+    raw,
+    tile,
+    // Private
+    _updateFormatOut,
+    _setBooleanOption,
+    _read,
+    _pipeline
+  });
+};

lib/platform.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const detectLibc = require('detect-libc');
+
+const env = process.env;
+
+module.exports = function () {
+  const arch = env.npm_config_arch || process.arch;
+  const platform = env.npm_config_platform || process.platform;
+  /* istanbul ignore next */
+  const libc = (platform === 'linux' && detectLibc.isNonGlibcLinux) ? detectLibc.family : '';
+
+  const platformId = [`${platform}${libc}`];
+
+  if (arch === 'arm') {
+    const fallback = process.versions.electron ? '7' : '6';
+    platformId.push(`armv${env.npm_config_arm_version || process.config.variables.arm_version || fallback}`);
+  } else if (arch === 'arm64') {
+    platformId.push(`arm64v${env.npm_config_arm_version || '8'}`);
+  } else {
+    platformId.push(arch);
+  }
+
+  return platformId.join('-');
+};

lib/resize.js

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

lib/utility.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const events = require('events');
+const is = require('./is');
+const sharp = require('../build/Release/sharp.node');
+
+/**
+ * An Object containing nested boolean values representing the available input and output formats/methods.
+ * @member
+ * @example
+ * console.log(sharp.format);
+ * @returns {Object}
+ */
+const format = sharp.format();
+
+/**
+ * An Object containing the available interpolators and their proper values
+ * @readonly
+ * @enum {string}
+ */
+const interpolators = {
+  /** [Nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation). Suitable for image enlargement only. */
+  nearest: 'nearest',
+  /** [Bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation). Faster than bicubic but with less smooth results. */
+  bilinear: 'bilinear',
+  /** [Bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default). */
+  bicubic: 'bicubic',
+  /** [LBB interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100). Prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2. */
+  locallyBoundedBicubic: 'lbb',
+  /** [Nohalo interpolation](http://eprints.soton.ac.uk/268086/). Prevents acutance but typically reduces performance by a factor of 3. */
+  nohalo: 'nohalo',
+  /** [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
+  vertexSplitQuadraticBasisSpline: 'vsqbs'
+};
+
+/**
+ * An Object containing the version numbers of libvips and its dependencies.
+ * @member
+ * @example
+ * console.log(sharp.versions);
+ */
+let versions = {
+  vips: sharp.libvipsVersion()
+};
+try {
+  versions = require(`../vendor/${versions.vips}/versions.json`);
+} catch (err) {}
+
+/**
+ * Gets or, when options are provided, sets the limits of _libvips'_ operation cache.
+ * 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.
+ *
+ * @example
+ * const stats = sharp.cache();
+ * @example
+ * sharp.cache( { items: 200 } );
+ * sharp.cache( { files: 0 } );
+ * sharp.cache(false);
+ *
+ * @param {Object|boolean} [options=true] - Object with the following attributes, or boolean where true uses default cache settings and false removes all caching
+ * @param {number} [options.memory=50] - is the maximum memory in MB to use for this cache
+ * @param {number} [options.files=20] - is the maximum number of files to hold open
+ * @param {number} [options.items=100] - is the maximum number of operations to cache
+ * @returns {Object}
+ */
+function cache (options) {
+  if (is.bool(options)) {
+    if (options) {
+      // Default cache settings of 50MB, 20 files, 100 items
+      return sharp.cache(50, 20, 100);
+    } else {
+      return sharp.cache(0, 0, 0);
+    }
+  } else if (is.object(options)) {
+    return sharp.cache(options.memory, options.files, options.items);
+  } else {
+    return sharp.cache();
+  }
+}
+cache(true);
+
+/**
+ * Gets or, when a concurrency is provided, sets
+ * the number of threads _libvips'_ should create to process each image.
+ * The default value is the number of CPU cores.
+ * A value of `0` will reset to this default.
+ *
+ * The maximum number of images that can be processed in parallel
+ * is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
+ *
+ * This method always returns the current concurrency.
+ *
+ * @example
+ * const threads = sharp.concurrency(); // 4
+ * sharp.concurrency(2); // 2
+ * sharp.concurrency(0); // 4
+ *
+ * @param {number} [concurrency]
+ * @returns {number} concurrency
+ */
+function concurrency (concurrency) {
+  return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
+}
+
+/**
+ * An EventEmitter that emits a `change` event when a task is either:
+ * - queued, waiting for _libuv_ to provide a worker thread
+ * - complete
+ * @member
+ * @example
+ * sharp.queue.on('change', function(queueLength) {
+ *   console.log('Queue contains ' + queueLength + ' task(s)');
+ * });
+ */
+const queue = new events.EventEmitter();
+
+/**
+ * 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.
+ *
+ * @example
+ * const counters = sharp.counters(); // { queue: 2, process: 4 }
+ *
+ * @returns {Object}
+ */
+function counters () {
+  return sharp.counters();
+}
+
+/**
+ * Get and set use of SIMD vector unit instructions.
+ * 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.
+ *
+ * @example
+ * const simd = sharp.simd();
+ * // simd is `true` if the runtime use of liborc is currently enabled
+ * @example
+ * const simd = sharp.simd(false);
+ * // prevent libvips from using liborc at runtime
+ *
+ * @param {boolean} [simd=true]
+ * @returns {boolean}
+ */
+function simd (simd) {
+  return sharp.simd(is.bool(simd) ? simd : null);
+}
+simd(true);
+
+/**
+ * Decorate the Sharp class with utility-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Sharp.cache = cache;
+  Sharp.concurrency = concurrency;
+  Sharp.counters = counters;
+  Sharp.simd = simd;
+  Sharp.format = format;
+  Sharp.interpolators = interpolators;
+  Sharp.versions = versions;
+  Sharp.queue = queue;
+};

package.json

@@ -1,34 +1,174 @@
 {
   "name": "sharp",
-  "version": "0.0.4",
-  "main": "index.js",
-  "description": "High performance Node.js module to resize JPEG images using the libvips image processing library",
+  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, AVIF and TIFF images",
+  "version": "0.27.2",
+  "author": "Lovell Fuller <npm@lovell.info>",
+  "homepage": "https://github.com/lovell/sharp",
+  "contributors": [
+    "Pierre Inglebert <pierre.inglebert@gmail.com>",
+    "Jonathan Ong <jonathanrichardong@gmail.com>",
+    "Chanon Sajjamanochai <chanon.s@gmail.com>",
+    "Juliano Julio <julianojulio@gmail.com>",
+    "Daniel Gasienica <daniel@gasienica.ch>",
+    "Julian Walker <julian@fiftythree.com>",
+    "Amit Pitaru <pitaru.amit@gmail.com>",
+    "Brandon Aaron <hello.brandon@aaron.sh>",
+    "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>",
+    "Patrick Paskaris <patrick@paskaris.gr>",
+    "Jérémy Lal <kapouer@melix.org>",
+    "Rahul Nanwani <r.nanwani@gmail.com>",
+    "Alice Monday <alice0meta@gmail.com>",
+    "Kristo Jorgenson <kristo.jorgenson@gmail.com>",
+    "YvesBos <yves_bos@outlook.com>",
+    "Guy Maliar <guy@tailorbrands.com>",
+    "Nicolas Coden <nicolas@ncoden.fr>",
+    "Matt Parrish <matt.r.parrish@gmail.com>",
+    "Marcel Bretschneider <marcel.bretschneider@gmail.com>",
+    "Matthew McEachen <matthew+github@mceachen.org>",
+    "Jarda Kotěšovec <jarda.kotesovec@gmail.com>",
+    "Kenric D'Souza <kenric.dsouza@gmail.com>",
+    "Oleh Aleinyk <oleg.aleynik@gmail.com>",
+    "Marcel Bretschneider <marcel.bretschneider@gmail.com>",
+    "Andrea Bianco <andrea.bianco@unibas.ch>",
+    "Rik Heywood <rik@rik.org>",
+    "Thomas Parisot <hi@oncletom.io>",
+    "Nathan Graves <nathanrgraves+github@gmail.com>",
+    "Tom Lokhorst <tom@lokhorst.eu>",
+    "Espen Hovlandsdal <espen@hovlandsdal.com>",
+    "Sylvain Dumont <sylvain.dumont35@gmail.com>",
+    "Alun Davies <alun.owain.davies@googlemail.com>",
+    "Aidan Hoolachan <ajhoolachan21@gmail.com>",
+    "Axel Eirola <axel.eirola@iki.fi>",
+    "Freezy <freezy@xbmc.org>",
+    "Daiz <taneli.vatanen@gmail.com>",
+    "Julian Aubourg <j@ubourg.net>",
+    "Keith Belovay <keith@picthrive.com>",
+    "Michael B. Klein <mbklein@gmail.com>",
+    "Jordan Prudhomme <jordan@raboland.fr>",
+    "Ilya Ovdin <iovdin@gmail.com>",
+    "Andargor <andargor@yahoo.com>",
+    "Paul Neave <paul.neave@gmail.com>",
+    "Brendan Kennedy <brenwken@gmail.com>",
+    "Brychan Bennett-Odlum <git@brychan.io>",
+    "Edward Silverton <e.silverton@gmail.com>",
+    "Roman Malieiev <aromaleev@gmail.com>",
+    "Tomas Szabo <tomas.szabo@deftomat.com>",
+    "Robert O'Rourke <robert@o-rourke.org>",
+    "Guillermo Alfonso Varela Chouciño <guillevch@gmail.com>",
+    "Christian Flintrup <chr@gigahost.dk>",
+    "Manan Jadhav <manan@motionden.com>",
+    "Leon Radley <leon@radley.se>",
+    "alza54 <alza54@thiocod.in>"
+  ],
+  "scripts": {
+    "install": "(node install/libvips && node install/dll-copy && prebuild-install) || (node-gyp rebuild && node install/dll-copy)",
+    "clean": "rm -rf node_modules/ build/ vendor/ .nyc_output/ coverage/ test/fixtures/output.*",
+    "test": "semistandard && cpplint && npm run test-unit && npm run test-licensing",
+    "test-unit": "nyc --reporter=lcov --branches=99 mocha --slow=5000 --timeout=60000 ./test/unit/*.js",
+    "test-licensing": "license-checker --production --summary --onlyAllow=\"Apache-2.0;BSD;ISC;MIT\"",
+    "test-coverage": "./test/coverage/report.sh",
+    "test-leak": "./test/leak/leak.sh",
+    "docs-build": "documentation lint lib && node docs/build && node docs/search-index/build",
+    "docs-serve": "cd docs && npx serve",
+    "docs-publish": "cd docs && npx firebase-tools deploy --project pixelplumbing --only hosting:pixelplumbing-sharp"
+  },
+  "main": "lib/index.js",
+  "files": [
+    "binding.gyp",
+    "install/**",
+    "lib/**",
+    "src/**"
+  ],
   "repository": {
     "type": "git",
     "url": "git://github.com/lovell/sharp"
   },
-  "devDependencies": {
-    "imagemagick": "*",
-    "gm": "*",
-    "epeg": "*",
-    "benchmark": "*"
-  },
-  "scripts": {
-    "test": "node tests/perf.js"
-  },
-  "engines": {
-    "node": ">=0.8"
-  },
   "keywords": [
     "jpeg",
+    "png",
+    "webp",
+    "avif",
+    "tiff",
+    "gif",
+    "svg",
+    "dzi",
+    "image",
     "resize",
     "thumbnail",
-    "sharpen",
     "crop",
     "embed",
     "libvips",
-    "fast"
+    "vips"
   ],
-  "author": "Lovell Fuller",
-  "license": "Apache 2.0"
-}
+  "dependencies": {
+    "array-flatten": "^3.0.0",
+    "color": "^3.1.3",
+    "detect-libc": "^1.0.3",
+    "node-addon-api": "^3.1.0",
+    "npmlog": "^4.1.2",
+    "prebuild-install": "^6.0.1",
+    "semver": "^7.3.4",
+    "simple-get": "^4.0.0",
+    "tar-fs": "^2.1.1",
+    "tunnel-agent": "^0.6.0"
+  },
+  "devDependencies": {
+    "async": "^3.2.0",
+    "cc": "^3.0.1",
+    "decompress-zip": "^0.3.3",
+    "documentation": "^13.1.1",
+    "exif-reader": "^1.0.3",
+    "icc": "^2.0.0",
+    "license-checker": "^25.0.1",
+    "mocha": "^8.3.0",
+    "mock-fs": "^4.13.0",
+    "nyc": "^15.1.0",
+    "prebuild": "^10.0.1",
+    "rimraf": "^3.0.2",
+    "semistandard": "^16.0.0"
+  },
+  "license": "Apache-2.0",
+  "config": {
+    "libvips": "8.10.5",
+    "runtime": "napi",
+    "target": 3
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "funding": {
+    "url": "https://opencollective.com/libvips"
+  },
+  "binary": {
+    "napi_versions": [
+      3
+    ]
+  },
+  "semistandard": {
+    "env": [
+      "mocha"
+    ]
+  },
+  "cc": {
+    "linelength": "120",
+    "filter": [
+      "build/include"
+    ]
+  }
+}

src/common.cc

@@ -0,0 +1,808 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#include <cstdlib>
+#include <string>
+#include <string.h>
+#include <vector>
+#include <queue>
+#include <map>
+#include <mutex>  // NOLINT(build/c++11)
+
+#include <napi.h>
+#include <vips/vips8>
+
+#include "common.h"
+
+using vips::VImage;
+
+namespace sharp {
+
+  // Convenience methods to access the attributes of a Napi::Object
+  bool HasAttr(Napi::Object obj, std::string attr) {
+    return obj.Has(attr);
+  }
+  std::string AttrAsStr(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::String>();
+  }
+  uint32_t AttrAsUint32(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::Number>().Uint32Value();
+  }
+  int32_t AttrAsInt32(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::Number>().Int32Value();
+  }
+  int32_t AttrAsInt32(Napi::Object obj, unsigned int const attr) {
+    return obj.Get(attr).As<Napi::Number>().Int32Value();
+  }
+  double AttrAsDouble(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::Number>().DoubleValue();
+  }
+  double AttrAsDouble(Napi::Object obj, unsigned int const attr) {
+    return obj.Get(attr).As<Napi::Number>().DoubleValue();
+  }
+  bool AttrAsBool(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::Boolean>().Value();
+  }
+  std::vector<double> AttrAsVectorOfDouble(Napi::Object obj, std::string attr) {
+    Napi::Array napiArray = obj.Get(attr).As<Napi::Array>();
+    std::vector<double> vectorOfDouble(napiArray.Length());
+    for (unsigned int i = 0; i < napiArray.Length(); i++) {
+      vectorOfDouble[i] = AttrAsDouble(napiArray, i);
+    }
+    return vectorOfDouble;
+  }
+  std::vector<int32_t> AttrAsInt32Vector(Napi::Object obj, std::string attr) {
+    Napi::Array array = obj.Get(attr).As<Napi::Array>();
+    std::vector<int32_t> vector(array.Length());
+    for (unsigned int i = 0; i < array.Length(); i++) {
+      vector[i] = AttrAsInt32(array, i);
+    }
+    return vector;
+  }
+
+  // Create an InputDescriptor instance from a Napi::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(Napi::Object input) {
+    InputDescriptor *descriptor = new InputDescriptor;
+    if (HasAttr(input, "file")) {
+      descriptor->file = AttrAsStr(input, "file");
+    } else if (HasAttr(input, "buffer")) {
+      Napi::Buffer<char> buffer = input.Get("buffer").As<Napi::Buffer<char>>();
+      descriptor->bufferLength = buffer.Length();
+      descriptor->buffer = buffer.Data();
+      descriptor->isBuffer = TRUE;
+    }
+    descriptor->failOnError = AttrAsBool(input, "failOnError");
+    // Density for vector-based input
+    if (HasAttr(input, "density")) {
+      descriptor->density = AttrAsDouble(input, "density");
+    }
+    // Raw pixel input
+    if (HasAttr(input, "rawChannels")) {
+      descriptor->rawChannels = AttrAsUint32(input, "rawChannels");
+      descriptor->rawWidth = AttrAsUint32(input, "rawWidth");
+      descriptor->rawHeight = AttrAsUint32(input, "rawHeight");
+    }
+    // Multi-page input (GIF, TIFF, PDF)
+    if (HasAttr(input, "pages")) {
+      descriptor->pages = AttrAsInt32(input, "pages");
+    }
+    if (HasAttr(input, "page")) {
+      descriptor->page = AttrAsUint32(input, "page");
+    }
+    // Multi-level input (OpenSlide)
+    if (HasAttr(input, "level")) {
+      descriptor->level = AttrAsUint32(input, "level");
+    }
+    // Create new image
+    if (HasAttr(input, "createChannels")) {
+      descriptor->createChannels = AttrAsUint32(input, "createChannels");
+      descriptor->createWidth = AttrAsUint32(input, "createWidth");
+      descriptor->createHeight = AttrAsUint32(input, "createHeight");
+      if (HasAttr(input, "createNoiseType")) {
+        descriptor->createNoiseType = AttrAsStr(input, "createNoiseType");
+        descriptor->createNoiseMean = AttrAsDouble(input, "createNoiseMean");
+        descriptor->createNoiseSigma = AttrAsDouble(input, "createNoiseSigma");
+      } else {
+        descriptor->createBackground = AttrAsVectorOfDouble(input, "createBackground");
+      }
+    }
+    // Limit input images to a given number of pixels, where pixels = width * height
+    descriptor->limitInputPixels = AttrAsUint32(input, "limitInputPixels");
+    // Allow switch from random to sequential access
+    descriptor->access = AttrAsBool(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
+    return descriptor;
+  }
+
+  // How many tasks are in the queue?
+  volatile int counterQueue = 0;
+
+  // How many tasks are being processed?
+  volatile int counterProcess = 0;
+
+  // Filename extension checkers
+  static bool EndsWith(std::string const &str, std::string const &end) {
+    return str.length() >= end.length() && 0 == str.compare(str.length() - end.length(), end.length(), end);
+  }
+  bool IsJpeg(std::string const &str) {
+    return EndsWith(str, ".jpg") || EndsWith(str, ".jpeg") || EndsWith(str, ".JPG") || EndsWith(str, ".JPEG");
+  }
+  bool IsPng(std::string const &str) {
+    return EndsWith(str, ".png") || EndsWith(str, ".PNG");
+  }
+  bool IsWebp(std::string const &str) {
+    return EndsWith(str, ".webp") || EndsWith(str, ".WEBP");
+  }
+  bool IsGif(std::string const &str) {
+    return EndsWith(str, ".gif") || EndsWith(str, ".GIF");
+  }
+  bool IsTiff(std::string const &str) {
+    return EndsWith(str, ".tif") || EndsWith(str, ".tiff") || EndsWith(str, ".TIF") || EndsWith(str, ".TIFF");
+  }
+  bool IsHeic(std::string const &str) {
+    return EndsWith(str, ".heic") || EndsWith(str, ".HEIC");
+  }
+  bool IsHeif(std::string const &str) {
+    return EndsWith(str, ".heif") || EndsWith(str, ".HEIF") || IsHeic(str) || IsAvif(str);
+  }
+  bool IsAvif(std::string const &str) {
+    return EndsWith(str, ".avif") || EndsWith(str, ".AVIF");
+  }
+  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");
+  }
+
+  /*
+    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::HEIF: id = "heif"; 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::EXR: id = "exr"; break;
+      case ImageType::VIPS: id = "vips"; break;
+      case ImageType::RAW: id = "raw"; break;
+      case ImageType::UNKNOWN: id = "unknown"; break;
+      case ImageType::MISSING: id = "missing"; break;
+    }
+    return id;
+  }
+
+  /**
+   * Regenerate this table with something like:
+   *
+   * $ vips -l foreign | grep -i load | awk '{ print $2, $1; }'
+   *
+   * Plus a bit of editing.
+   */
+  std::map<std::string, ImageType> loaderToType = {
+    { "VipsForeignLoadJpegFile", ImageType::JPEG },
+    { "VipsForeignLoadJpegBuffer", ImageType::JPEG },
+    { "VipsForeignLoadPngFile", ImageType::PNG },
+    { "VipsForeignLoadPngBuffer", ImageType::PNG },
+    { "VipsForeignLoadWebpFile", ImageType::WEBP },
+    { "VipsForeignLoadWebpBuffer", ImageType::WEBP },
+    { "VipsForeignLoadTiffFile", ImageType::TIFF },
+    { "VipsForeignLoadTiffBuffer", ImageType::TIFF },
+    { "VipsForeignLoadGifFile", ImageType::GIF },
+    { "VipsForeignLoadGifBuffer", ImageType::GIF },
+    { "VipsForeignLoadSvgFile", ImageType::SVG },
+    { "VipsForeignLoadSvgBuffer", ImageType::SVG },
+    { "VipsForeignLoadHeifFile", ImageType::HEIF },
+    { "VipsForeignLoadHeifBuffer", ImageType::HEIF },
+    { "VipsForeignLoadPdfFile", ImageType::PDF },
+    { "VipsForeignLoadPdfBuffer", ImageType::PDF },
+    { "VipsForeignLoadMagickFile", ImageType::MAGICK },
+    { "VipsForeignLoadMagickBuffer", ImageType::MAGICK },
+    { "VipsForeignLoadOpenslide", ImageType::OPENSLIDE },
+    { "VipsForeignLoadPpmFile", ImageType::PPM },
+    { "VipsForeignLoadFits", ImageType::FITS },
+    { "VipsForeignLoadOpenexr", ImageType::EXR },
+    { "VipsForeignLoadVips", ImageType::VIPS },
+    { "VipsForeignLoadRaw", ImageType::RAW }
+  };
+
+  /*
+    Determine image format of a buffer.
+  */
+  ImageType DetermineImageType(void *buffer, size_t const length) {
+    ImageType imageType = ImageType::UNKNOWN;
+    char const *load = vips_foreign_find_load_buffer(buffer, length);
+    if (load != nullptr) {
+      auto it = loaderToType.find(load);
+      if (it != loaderToType.end()) {
+        imageType = it->second;
+      }
+    }
+    return imageType;
+  }
+
+  /*
+    Determine image format, reads the first few bytes of the file
+  */
+  ImageType DetermineImageType(char const *file) {
+    ImageType imageType = ImageType::UNKNOWN;
+    char const *load = vips_foreign_find_load(file);
+    if (load != nullptr) {
+      auto it = loaderToType.find(load);
+      if (it != loaderToType.end()) {
+        imageType = it->second;
+      }
+    } else {
+      if (EndsWith(vips::VError().what(), " does not exist\n")) {
+        imageType = ImageType::MISSING;
+      }
+    }
+    return imageType;
+  }
+
+  /*
+    Does this image type support multiple pages?
+  */
+  bool ImageTypeSupportsPage(ImageType imageType) {
+    return
+      imageType == ImageType::WEBP ||
+      imageType == ImageType::MAGICK ||
+      imageType == ImageType::GIF ||
+      imageType == ImageType::TIFF ||
+      imageType == ImageType::HEIF ||
+      imageType == ImageType::PDF;
+  }
+
+  /*
+    Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
+  */
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor) {
+    VImage image;
+    ImageType imageType;
+    if (descriptor->isBuffer) {
+      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", descriptor->access)
+              ->set("fail", descriptor->failOnError);
+            if (imageType == ImageType::SVG) {
+              option->set("unlimited", TRUE);
+            }
+            if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
+              option->set("dpi", descriptor->density);
+            }
+            if (imageType == ImageType::MAGICK) {
+              option->set("density", std::to_string(descriptor->density).data());
+            }
+            if (ImageTypeSupportsPage(imageType)) {
+              option->set("n", descriptor->pages);
+              option->set("page", descriptor->page);
+            }
+            if (imageType == ImageType::OPENSLIDE) {
+              option->set("level", descriptor->level);
+            }
+            image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
+            if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
+              image = SetDensity(image, descriptor->density);
+            }
+          } catch (vips::VError const &err) {
+            throw vips::VError(std::string("Input buffer has corrupt header: ") + err.what());
+          }
+        } else {
+          throw vips::VError("Input buffer contains unsupported image format");
+        }
+      }
+    } else {
+      if (descriptor->createChannels > 0) {
+        // Create new image
+        if (descriptor->createNoiseType == "gaussian") {
+          int const channels = descriptor->createChannels;
+          image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight);
+          std::vector<VImage> bands = {};
+          bands.reserve(channels);
+          for (int _band = 0; _band < channels; _band++) {
+            bands.push_back(image.gaussnoise(
+              descriptor->createWidth,
+              descriptor->createHeight,
+              VImage::option()->set("mean", descriptor->createNoiseMean)->set("sigma", descriptor->createNoiseSigma)));
+          }
+          image = image.bandjoin(bands);
+          image = image.cast(VipsBandFormat::VIPS_FORMAT_UCHAR);
+          if (channels < 3) {
+            image = image.colourspace(VIPS_INTERPRETATION_B_W);
+          } else {
+            image = image.colourspace(VIPS_INTERPRETATION_sRGB);
+          }
+        } else {
+          std::vector<double> background = {
+            descriptor->createBackground[0],
+            descriptor->createBackground[1],
+            descriptor->createBackground[2]
+          };
+          if (descriptor->createChannels == 4) {
+            background.push_back(descriptor->createBackground[3]);
+          }
+          image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight).new_from_image(background);
+        }
+        image.get_image()->Type = VIPS_INTERPRETATION_sRGB;
+        imageType = ImageType::RAW;
+      } else {
+        // From filesystem
+        imageType = DetermineImageType(descriptor->file.data());
+        if (imageType == ImageType::MISSING) {
+          throw vips::VError("Input file is missing");
+        }
+        if (imageType != ImageType::UNKNOWN) {
+          try {
+            vips::VOption *option = VImage::option()
+              ->set("access", descriptor->access)
+              ->set("fail", descriptor->failOnError);
+            if (imageType == ImageType::SVG) {
+              option->set("unlimited", TRUE);
+            }
+            if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
+              option->set("dpi", descriptor->density);
+            }
+            if (imageType == ImageType::MAGICK) {
+              option->set("density", std::to_string(descriptor->density).data());
+            }
+            if (ImageTypeSupportsPage(imageType)) {
+              option->set("n", descriptor->pages);
+              option->set("page", descriptor->page);
+            }
+            if (imageType == ImageType::OPENSLIDE) {
+              option->set("level", descriptor->level);
+            }
+            image = VImage::new_from_file(descriptor->file.data(), option);
+            if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
+              image = SetDensity(image, descriptor->density);
+            }
+          } catch (vips::VError const &err) {
+            throw vips::VError(std::string("Input file has corrupt header: ") + err.what());
+          }
+        } else {
+          throw vips::VError("Input file contains unsupported image format");
+        }
+      }
+    }
+    // Limit input images to a given number of pixels, where pixels = width * height
+    if (descriptor->limitInputPixels > 0 &&
+      static_cast<uint64_t>(image.width() * image.height()) > static_cast<uint64_t>(descriptor->limitInputPixels)) {
+      throw vips::VError("Input image exceeds pixel limit");
+    }
+    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(VImage image) {
+    return image.has_alpha();
+  }
+
+  /*
+    Get EXIF Orientation of image, if any.
+  */
+  int ExifOrientation(VImage image) {
+    int orientation = 0;
+    if (image.get_typeof(VIPS_META_ORIENTATION) != 0) {
+      orientation = image.get_int(VIPS_META_ORIENTATION);
+    }
+    return orientation;
+  }
+
+  /*
+    Set EXIF Orientation of image.
+  */
+  VImage SetExifOrientation(VImage image, int const orientation) {
+    VImage copy = image.copy();
+    copy.set(VIPS_META_ORIENTATION, orientation);
+    return copy;
+  }
+
+  /*
+    Remove EXIF Orientation from image.
+  */
+  VImage RemoveExifOrientation(VImage image) {
+    VImage copy = image.copy();
+    copy.remove(VIPS_META_ORIENTATION);
+    return copy;
+  }
+
+  /*
+    Set animation properties if necessary.
+    Non-provided properties will be loaded from image.
+  */
+  VImage SetAnimationProperties(VImage image, int pageHeight, std::vector<int> delay, int loop) {
+    bool hasDelay = delay.size() != 1 || delay.front() != -1;
+
+    if (pageHeight == 0 && image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT) {
+      pageHeight = image.get_int(VIPS_META_PAGE_HEIGHT);
+    }
+
+    if (!hasDelay && image.get_typeof("delay") == VIPS_TYPE_ARRAY_INT) {
+      delay = image.get_array_int("delay");
+      hasDelay = true;
+    }
+
+    if (loop == -1 && image.get_typeof("loop") == G_TYPE_INT) {
+      loop = image.get_int("loop");
+    }
+
+    if (pageHeight == 0) return image;
+
+    // It is necessary to create the copy as otherwise, pageHeight will be ignored!
+    VImage copy = image.copy();
+
+    copy.set(VIPS_META_PAGE_HEIGHT, pageHeight);
+    if (hasDelay) copy.set("delay", delay);
+    if (loop != -1) copy.set("loop", loop);
+
+    return copy;
+  }
+
+  /*
+    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.
+  */
+  VImage SetDensity(VImage image, const double density) {
+    const double pixelsPerMm = density / 25.4;
+    VImage copy = image.copy();
+    copy.set("Xres", pixelsPerMm);
+    copy.set("Yres", pixelsPerMm);
+    copy.set(VIPS_META_RESOLUTION_UNIT, "in");
+    return copy;
+  }
+
+  /*
+    Check the proposed format supports the current dimensions.
+  */
+  void AssertImageTypeDimensions(VImage image, ImageType const imageType) {
+    const int height = image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT
+      ? image.get_int(VIPS_META_PAGE_HEIGHT)
+      : image.height();
+    if (imageType == ImageType::JPEG) {
+      if (image.width() > 65535 || height > 65535) {
+        throw vips::VError("Processed image is too large for the JPEG format");
+      }
+    } else if (imageType == ImageType::WEBP) {
+      if (image.width() > 16383 || height > 16383) {
+        throw vips::VError("Processed image is too large for the WebP format");
+      }
+    } else if (imageType == ImageType::GIF) {
+      if (image.width() > 65535 || height > 65535) {
+        throw vips::VError("Processed image is too large for the GIF format");
+      }
+    }
+  }
+
+  /*
+    Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
+  */
+  std::function<void(void*, char*)> FreeCallback = [](void*, char* data) {
+    g_free(data);
+  };
+
+  /*
+    Temporary buffer of warnings
+  */
+  std::queue<std::string> vipsWarnings;
+  std::mutex vipsWarningsMutex;
+
+  /*
+    Called with warnings from the glib-registered "VIPS" domain
+  */
+  void VipsWarningCallback(char const* log_domain, GLogLevelFlags log_level, char const* message, void* ignore) {
+    std::lock_guard<std::mutex> lock(vipsWarningsMutex);
+    vipsWarnings.emplace(message);
+  }
+
+  /*
+    Pop the oldest warning message from the queue
+  */
+  std::string VipsWarningPop() {
+    std::string warning;
+    std::lock_guard<std::mutex> lock(vipsWarningsMutex);
+    if (!vipsWarnings.empty()) {
+      warning = vipsWarnings.front();
+      vipsWarnings.pop();
+    }
+    return warning;
+  }
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity during an embed.
+
+    @Azurebyte: We are basically swapping the inWidth and outWidth, inHeight and outHeight from the CalculateCrop function.
+  */
+  std::tuple<int, int> CalculateEmbedPosition(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 = (outWidth - inWidth) / 2;
+        break;
+      case 2:
+        // East
+        left = outWidth - inWidth;
+        top = (outHeight - inHeight) / 2;
+        break;
+      case 3:
+        // South
+        left = (outWidth - inWidth) / 2;
+        top = outHeight - inHeight;
+        break;
+      case 4:
+        // West
+        top = (outHeight - inHeight) / 2;
+        break;
+      case 5:
+        // Northeast
+        left = outWidth - inWidth;
+        break;
+      case 6:
+        // Southeast
+        left = outWidth - inWidth;
+        top = outHeight - inHeight;
+        break;
+      case 7:
+        // Southwest
+        top = outHeight - inHeight;
+        break;
+      case 8:
+        // Northwest
+        // Which is the default is 0,0 so we do not assign anything here.
+        break;
+      default:
+        // Centre
+        left = (outWidth - inWidth) / 2;
+        top = (outHeight - inHeight) / 2;
+    }
+    return std::make_tuple(left, top);
+  }
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity during a crop.
+  */
+  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;
+        break;
+      case 7:
+        // Southwest
+        top = inHeight - outHeight;
+        break;
+      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 < (inWidth - outWidth)) {
+      left = x;
+    } else if (x >= (inWidth - outWidth)) {
+      left = inWidth - outWidth;
+    }
+
+    if (y < (inHeight - outHeight)) {
+      top = y;
+    } else if (y >= (inHeight - outHeight)) {
+      top = inHeight - outHeight;
+    }
+
+    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()));
+  }
+
+  /*
+    Convert RGBA value to another colourspace
+  */
+  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba, VipsInterpretation const interpretation) {
+    int const bands = static_cast<int>(rgba.size());
+    if (bands < 3 || interpretation == VIPS_INTERPRETATION_sRGB || interpretation == VIPS_INTERPRETATION_RGB) {
+      return rgba;
+    } else {
+      VImage pixel = VImage::new_matrix(1, 1);
+      pixel.set("bands", bands);
+      pixel = pixel.new_from_image(rgba);
+      pixel = pixel.colourspace(interpretation, VImage::option()->set("source_space", VIPS_INTERPRETATION_sRGB));
+      return pixel(0, 0);
+    }
+  }
+
+  /*
+    Apply the alpha channel to a given colour
+  */
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour) {
+    // Scale up 8-bit values to match 16-bit input image
+    double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
+    // Create alphaColour colour
+    std::vector<double> alphaColour;
+    if (image.bands() > 2) {
+      alphaColour = {
+        multiplier * colour[0],
+        multiplier * colour[1],
+        multiplier * colour[2]
+      };
+    } else {
+      // Convert sRGB to greyscale
+      alphaColour = { multiplier * (
+        0.2126 * colour[0] +
+        0.7152 * colour[1] +
+        0.0722 * colour[2])
+      };
+    }
+    // Add alpha channel to alphaColour colour
+    if (colour[3] < 255.0 || HasAlpha(image)) {
+      alphaColour.push_back(colour[3] * multiplier);
+    }
+    // Ensure alphaColour colour uses correct colourspace
+    alphaColour = sharp::GetRgbaAsColourspace(alphaColour, image.interpretation());
+    // Add non-transparent alpha channel, if required
+    if (colour[3] < 255.0 && !HasAlpha(image)) {
+      image = image.bandjoin(
+        VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier));
+    }
+    return std::make_tuple(image, alphaColour);
+  }
+
+  /*
+    Removes alpha channel, if any.
+  */
+  VImage RemoveAlpha(VImage image) {
+    if (HasAlpha(image)) {
+      image = image.extract_band(0, VImage::option()->set("n", image.bands() - 1));
+    }
+    return image;
+  }
+
+  /*
+    Ensures alpha channel, if missing.
+  */
+  VImage EnsureAlpha(VImage image) {
+    if (!HasAlpha(image)) {
+      std::vector<double> alpha;
+      alpha.push_back(sharp::MaximumImageAlpha(image.interpretation()));
+      image = image.bandjoin_const(alpha);
+    }
+    return image;
+  }
+}  // namespace sharp

src/common.h

@@ -0,0 +1,303 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#ifndef SRC_COMMON_H_
+#define SRC_COMMON_H_
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include <napi.h>
+#include <vips/vips8>
+
+// Verify platform and compiler compatibility
+
+#if (VIPS_MAJOR_VERSION < 8) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 10) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 10 && VIPS_MICRO_VERSION < 5)
+#error "libvips version 8.10.5+ is required - please see https://sharp.pixelplumbing.com/install"
+#endif
+
+#if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
+#error "GCC version 4.6+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
+#endif
+
+#if (defined(__clang__) && defined(__has_feature))
+#if (!__has_feature(cxx_range_for))
+#error "clang version 3.0+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
+#endif
+#endif
+
+using vips::VImage;
+
+namespace sharp {
+
+  struct InputDescriptor {  // NOLINT(runtime/indentation_namespace)
+    std::string name;
+    std::string file;
+    char *buffer;
+    bool failOnError;
+    int limitInputPixels;
+    VipsAccess access;
+    size_t bufferLength;
+    bool isBuffer;
+    double density;
+    int rawChannels;
+    int rawWidth;
+    int rawHeight;
+    int pages;
+    int page;
+    int level;
+    int createChannels;
+    int createWidth;
+    int createHeight;
+    std::vector<double> createBackground;
+    std::string createNoiseType;
+    double createNoiseMean;
+    double createNoiseSigma;
+
+    InputDescriptor():
+      buffer(nullptr),
+      failOnError(TRUE),
+      limitInputPixels(0x3FFF * 0x3FFF),
+      access(VIPS_ACCESS_RANDOM),
+      bufferLength(0),
+      isBuffer(FALSE),
+      density(72.0),
+      rawChannels(0),
+      rawWidth(0),
+      rawHeight(0),
+      pages(1),
+      page(0),
+      level(0),
+      createChannels(0),
+      createWidth(0),
+      createHeight(0),
+      createBackground{ 0.0, 0.0, 0.0, 255.0 },
+      createNoiseMean(0.0),
+      createNoiseSigma(0.0) {}
+  };
+
+  // Convenience methods to access the attributes of a Napi::Object
+  bool HasAttr(Napi::Object obj, std::string attr);
+  std::string AttrAsStr(Napi::Object obj, std::string attr);
+  uint32_t AttrAsUint32(Napi::Object obj, std::string attr);
+  int32_t AttrAsInt32(Napi::Object obj, std::string attr);
+  int32_t AttrAsInt32(Napi::Object obj, unsigned int const attr);
+  double AttrAsDouble(Napi::Object obj, std::string attr);
+  double AttrAsDouble(Napi::Object obj, unsigned int const attr);
+  bool AttrAsBool(Napi::Object obj, std::string attr);
+  std::vector<double> AttrAsVectorOfDouble(Napi::Object obj, std::string attr);
+  std::vector<int32_t> AttrAsInt32Vector(Napi::Object obj, std::string attr);
+
+  // Create an InputDescriptor instance from a Napi::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(Napi::Object input);
+
+  enum class ImageType {
+    JPEG,
+    PNG,
+    WEBP,
+    TIFF,
+    GIF,
+    SVG,
+    HEIF,
+    PDF,
+    MAGICK,
+    OPENSLIDE,
+    PPM,
+    FITS,
+    EXR,
+    VIPS,
+    RAW,
+    UNKNOWN,
+    MISSING
+  };
+
+  // How many tasks are in the queue?
+  extern volatile int counterQueue;
+
+  // How many tasks are being processed?
+  extern volatile int counterProcess;
+
+  // Filename extension checkers
+  bool IsJpeg(std::string const &str);
+  bool IsPng(std::string const &str);
+  bool IsWebp(std::string const &str);
+  bool IsGif(std::string const &str);
+  bool IsTiff(std::string const &str);
+  bool IsHeic(std::string const &str);
+  bool IsHeif(std::string const &str);
+  bool IsAvif(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.
+  */
+  ImageType DetermineImageType(void *buffer, size_t const length);
+
+  /*
+    Determine image format of a file.
+  */
+  ImageType DetermineImageType(char const *file);
+
+  /*
+    Does this image type support multiple pages?
+  */
+  bool ImageTypeSupportsPage(ImageType imageType);
+
+  /*
+    Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
+  */
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor);
+
+  /*
+    Does this image have an embedded profile?
+  */
+  bool HasProfile(VImage image);
+
+  /*
+    Does this image have an alpha channel?
+    Uses colour space interpretation with number of channels to guess this.
+  */
+  bool HasAlpha(VImage image);
+
+  /*
+    Get EXIF Orientation of image, if any.
+  */
+  int ExifOrientation(VImage image);
+
+  /*
+    Set EXIF Orientation of image.
+  */
+  VImage SetExifOrientation(VImage image, int const orientation);
+
+  /*
+    Remove EXIF Orientation from image.
+  */
+  VImage RemoveExifOrientation(VImage image);
+
+  /*
+    Set animation properties if necessary.
+    Non-provided properties will be loaded from image.
+  */
+  VImage SetAnimationProperties(VImage image, int pageHeight, std::vector<int> delay, int loop);
+
+  /*
+    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.
+  */
+  VImage SetDensity(VImage image, const double density);
+
+  /*
+    Check the proposed format supports the current dimensions.
+  */
+  void AssertImageTypeDimensions(VImage image, ImageType const imageType);
+
+  /*
+    Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
+  */
+  extern std::function<void(void*, char*)> FreeCallback;
+
+  /*
+    Called with warnings from the glib-registered "VIPS" domain
+  */
+  void VipsWarningCallback(char const* log_domain, GLogLevelFlags log_level, char const* message, void* ignore);
+
+  /*
+    Pop the oldest warning message from the queue
+  */
+  std::string VipsWarningPop();
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity during an embed.
+  */
+  std::tuple<int, int> CalculateEmbedPosition(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 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);
+
+  /*
+    Convert RGBA value to another colourspace
+  */
+  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba, VipsInterpretation const interpretation);
+
+  /*
+    Apply the alpha channel to a given colour
+   */
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour);
+
+  /*
+    Removes alpha channel, if any.
+  */
+  VImage RemoveAlpha(VImage image);
+
+  /*
+    Ensures alpha channel, if missing.
+  */
+  VImage EnsureAlpha(VImage image);
+
+}  // namespace sharp
+
+#endif  // SRC_COMMON_H_

src/libvips/cplusplus/VConnection.cpp

@@ -0,0 +1,178 @@
+/* Object part of the VSource and VTarget 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
+
+VSource 
+VSource::new_from_descriptor( int descriptor )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_descriptor( descriptor )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_file( const char *filename )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_file( filename )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_blob( VipsBlob *blob )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_blob( blob )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_memory( const void *data, 
+	size_t size )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_memory( data, size )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_options( const char *options )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_options( options )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VOption *
+VOption::set( const char *name, const VSource value )
+{
+	Pair *pair = new Pair( name );
+
+	pair->input = true;
+	g_value_init( &pair->value, VIPS_TYPE_SOURCE );
+	g_value_set_object( &pair->value, value.get_source() );
+	options.push_back( pair );
+
+	return( this );
+}
+
+VTarget 
+VTarget::new_to_descriptor( int descriptor )
+{
+	VipsTarget *output;
+
+	if( !(output = vips_target_new_to_descriptor( descriptor )) )
+		throw VError();
+
+	VTarget out( output ); 
+
+	return( out ); 
+}
+
+VTarget 
+VTarget::new_to_file( const char *filename )
+{
+	VipsTarget *output;
+
+	if( !(output = vips_target_new_to_file( filename )) )
+		throw VError();
+
+	VTarget out( output ); 
+
+	return( out ); 
+}
+
+VTarget 
+VTarget::new_to_memory()
+{
+	VipsTarget *output;
+
+	if( !(output = vips_target_new_to_memory()) )
+		throw VError();
+
+	VTarget out( output ); 
+
+	return( out ); 
+}
+
+VOption *
+VOption::set( const char *name, const VTarget value )
+{
+	Pair *pair = new Pair( name );
+
+	pair->input = true;
+	g_value_init( &pair->value, VIPS_TYPE_TARGET );
+	g_value_set_object( &pair->value, value.get_target() );
+	options.push_back( pair );
+
+	return( this );
+}
+
+VIPS_NAMESPACE_END

src/libvips/cplusplus/VError.cpp

@@ -0,0 +1,50 @@
+// 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 <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, const 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

@@ -0,0 +1,265 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#include <numeric>
+#include <vector>
+
+#include <napi.h>
+#include <vips/vips8>
+
+#include "common.h"
+#include "metadata.h"
+
+class MetadataWorker : public Napi::AsyncWorker {
+ public:
+  MetadataWorker(Napi::Function callback, MetadataBaton *baton, Napi::Function debuglog) :
+    Napi::AsyncWorker(callback), baton(baton), debuglog(Napi::Persistent(debuglog)) {}
+  ~MetadataWorker() {}
+
+  void Execute() {
+    // Decrement queued task counter
+    g_atomic_int_dec_and_test(&sharp::counterQueue);
+
+    vips::VImage image;
+    sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
+    try {
+      std::tie(image, imageType) = OpenInput(baton->input);
+    } catch (vips::VError const &err) {
+      (baton->err).append(err.what());
+    }
+    if (imageType != sharp::ImageType::UNKNOWN) {
+      // Image type
+      baton->format = sharp::ImageTypeId(imageType);
+      // VipsImage attributes
+      baton->width = image.width();
+      baton->height = image.height();
+      baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image.interpretation());
+      baton->channels = image.bands();
+      baton->depth = vips_enum_nick(VIPS_TYPE_BAND_FORMAT, image.format());
+      if (sharp::HasDensity(image)) {
+        baton->density = sharp::GetDensity(image);
+      }
+      if (image.get_typeof("jpeg-chroma-subsample") == VIPS_TYPE_REF_STRING) {
+        baton->chromaSubsampling = image.get_string("jpeg-chroma-subsample");
+      }
+      if (image.get_typeof("interlaced") == G_TYPE_INT) {
+        baton->isProgressive = image.get_int("interlaced") == 1;
+      }
+      if (image.get_typeof("palette-bit-depth") == G_TYPE_INT) {
+        baton->paletteBitDepth = image.get_int("palette-bit-depth");
+      }
+      if (image.get_typeof(VIPS_META_N_PAGES) == G_TYPE_INT) {
+        baton->pages = image.get_int(VIPS_META_N_PAGES);
+      }
+      if (image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT) {
+        baton->pageHeight = image.get_int(VIPS_META_PAGE_HEIGHT);
+      }
+      if (image.get_typeof("loop") == G_TYPE_INT) {
+        baton->loop = image.get_int("loop");
+      }
+      if (image.get_typeof("delay") == VIPS_TYPE_ARRAY_INT) {
+        baton->delay = image.get_array_int("delay");
+      }
+      if (image.get_typeof("heif-primary") == G_TYPE_INT) {
+        baton->pagePrimary = image.get_int("heif-primary");
+      }
+      if (image.get_typeof("heif-compression") == VIPS_TYPE_REF_STRING) {
+        baton->compression = image.get_string("heif-compression");
+      }
+      if (image.get_typeof("openslide.level-count") == VIPS_TYPE_REF_STRING) {
+        int const levels = std::stoi(image.get_string("openslide.level-count"));
+        for (int l = 0; l < levels; l++) {
+          std::string prefix = "openslide.level[" + std::to_string(l) + "].";
+          int const width = std::stoi(image.get_string((prefix + "width").data()));
+          int const height = std::stoi(image.get_string((prefix + "height").data()));
+          baton->levels.push_back(std::pair<int, int>(width, height));
+        }
+      }
+      baton->hasProfile = sharp::HasProfile(image);
+      // Derived attributes
+      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;
+      }
+      // IPTC
+      if (image.get_typeof(VIPS_META_IPTC_NAME) == VIPS_TYPE_BLOB) {
+        size_t iptcLength;
+        void const *iptc = image.get_blob(VIPS_META_IPTC_NAME, &iptcLength);
+        baton->iptc = static_cast<char *>(g_malloc(iptcLength));
+        memcpy(baton->iptc, iptc, iptcLength);
+        baton->iptcLength = iptcLength;
+      }
+      // XMP
+      if (image.get_typeof(VIPS_META_XMP_NAME) == VIPS_TYPE_BLOB) {
+        size_t xmpLength;
+        void const *xmp = image.get_blob(VIPS_META_XMP_NAME, &xmpLength);
+        baton->xmp = static_cast<char *>(g_malloc(xmpLength));
+        memcpy(baton->xmp, xmp, xmpLength);
+        baton->xmpLength = xmpLength;
+      }
+      // TIFFTAG_PHOTOSHOP
+      if (image.get_typeof(VIPS_META_PHOTOSHOP_NAME) == VIPS_TYPE_BLOB) {
+        size_t tifftagPhotoshopLength;
+        void const *tifftagPhotoshop = image.get_blob(VIPS_META_PHOTOSHOP_NAME, &tifftagPhotoshopLength);
+        baton->tifftagPhotoshop = static_cast<char *>(g_malloc(tifftagPhotoshopLength));
+        memcpy(baton->tifftagPhotoshop, tifftagPhotoshop, tifftagPhotoshopLength);
+        baton->tifftagPhotoshopLength = tifftagPhotoshopLength;
+      }
+    }
+
+    // Clean up
+    vips_error_clear();
+    vips_thread_shutdown();
+  }
+
+  void OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
+
+    // Handle warnings
+    std::string warning = sharp::VipsWarningPop();
+    while (!warning.empty()) {
+      debuglog.Call({ Napi::String::New(env, warning) });
+      warning = sharp::VipsWarningPop();
+    }
+
+    if (baton->err.empty()) {
+      Napi::Object info = Napi::Object::New(env);
+      info.Set("format", baton->format);
+      if (baton->input->bufferLength > 0) {
+        info.Set("size", baton->input->bufferLength);
+      }
+      info.Set("width", baton->width);
+      info.Set("height", baton->height);
+      info.Set("space", baton->space);
+      info.Set("channels", baton->channels);
+      info.Set("depth", baton->depth);
+      if (baton->density > 0) {
+        info.Set("density", baton->density);
+      }
+      if (!baton->chromaSubsampling.empty()) {
+        info.Set("chromaSubsampling", baton->chromaSubsampling);
+      }
+      info.Set("isProgressive", baton->isProgressive);
+      if (baton->paletteBitDepth > 0) {
+        info.Set("paletteBitDepth", baton->paletteBitDepth);
+      }
+      if (baton->pages > 0) {
+        info.Set("pages", baton->pages);
+      }
+      if (baton->pageHeight > 0) {
+        info.Set("pageHeight", baton->pageHeight);
+      }
+      if (baton->loop >= 0) {
+        info.Set("loop", baton->loop);
+      }
+      if (!baton->delay.empty()) {
+        int i = 0;
+        Napi::Array delay = Napi::Array::New(env, static_cast<size_t>(baton->delay.size()));
+        for (int const d : baton->delay) {
+          delay.Set(i++, d);
+        }
+        info.Set("delay", delay);
+      }
+      if (baton->pagePrimary > -1) {
+        info.Set("pagePrimary", baton->pagePrimary);
+      }
+      if (!baton->compression.empty()) {
+        info.Set("compression", baton->compression);
+      }
+      if (!baton->levels.empty()) {
+        int i = 0;
+        Napi::Array levels = Napi::Array::New(env, static_cast<size_t>(baton->levels.size()));
+        for (std::pair<int, int> const &l : baton->levels) {
+          Napi::Object level = Napi::Object::New(env);
+          level.Set("width", l.first);
+          level.Set("height", l.second);
+          levels.Set(i++, level);
+        }
+        info.Set("levels", levels);
+      }
+      info.Set("hasProfile", baton->hasProfile);
+      info.Set("hasAlpha", baton->hasAlpha);
+      if (baton->orientation > 0) {
+        info.Set("orientation", baton->orientation);
+      }
+      if (baton->exifLength > 0) {
+        info.Set("exif", Napi::Buffer<char>::New(env, baton->exif, baton->exifLength, sharp::FreeCallback));
+      }
+      if (baton->iccLength > 0) {
+        info.Set("icc", Napi::Buffer<char>::New(env, baton->icc, baton->iccLength, sharp::FreeCallback));
+      }
+      if (baton->iptcLength > 0) {
+        info.Set("iptc", Napi::Buffer<char>::New(env, baton->iptc, baton->iptcLength, sharp::FreeCallback));
+      }
+      if (baton->xmpLength > 0) {
+        info.Set("xmp", Napi::Buffer<char>::New(env, baton->xmp, baton->xmpLength, sharp::FreeCallback));
+      }
+      if (baton->tifftagPhotoshopLength > 0) {
+        info.Set("tifftagPhotoshop",
+          Napi::Buffer<char>::New(env, baton->tifftagPhotoshop, baton->tifftagPhotoshopLength, sharp::FreeCallback));
+      }
+      Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+    } else {
+      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, baton->err).Value() });
+    }
+
+    delete baton->input;
+    delete baton;
+  }
+
+ private:
+  MetadataBaton* baton;
+  Napi::FunctionReference debuglog;
+};
+
+/*
+  metadata(options, callback)
+*/
+Napi::Value metadata(const Napi::CallbackInfo& info) {
+  // V8 objects are converted to non-V8 types held in the baton struct
+  MetadataBaton *baton = new MetadataBaton;
+  Napi::Object options = info[0].As<Napi::Object>();
+
+  // Input
+  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
+
+  // Function to notify of libvips warnings
+  Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();
+
+  // Join queue for worker thread
+  Napi::Function callback = info[1].As<Napi::Function>();
+  MetadataWorker *worker = new MetadataWorker(callback, baton, debuglog);
+  worker->Receiver().Set("options", options);
+  worker->Queue();
+
+  // Increment queued task counter
+  g_atomic_int_inc(&sharp::counterQueue);
+
+  return info.Env().Undefined();
+}

src/metadata.h

@@ -0,0 +1,88 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#ifndef SRC_METADATA_H_
+#define SRC_METADATA_H_
+
+#include <string>
+#include <napi.h>
+
+#include "./common.h"
+
+struct MetadataBaton {
+  // Input
+  sharp::InputDescriptor *input;
+  // Output
+  std::string format;
+  int width;
+  int height;
+  std::string space;
+  int channels;
+  std::string depth;
+  int density;
+  std::string chromaSubsampling;
+  bool isProgressive;
+  int paletteBitDepth;
+  int pages;
+  int pageHeight;
+  int loop;
+  std::vector<int> delay;
+  int pagePrimary;
+  std::string compression;
+  std::vector<std::pair<int, int>> levels;
+  bool hasProfile;
+  bool hasAlpha;
+  int orientation;
+  char *exif;
+  size_t exifLength;
+  char *icc;
+  size_t iccLength;
+  char *iptc;
+  size_t iptcLength;
+  char *xmp;
+  size_t xmpLength;
+  char *tifftagPhotoshop;
+  size_t tifftagPhotoshopLength;
+  std::string err;
+
+  MetadataBaton():
+    input(nullptr),
+    width(0),
+    height(0),
+    channels(0),
+    density(0),
+    isProgressive(false),
+    paletteBitDepth(0),
+    pages(0),
+    pageHeight(0),
+    loop(-1),
+    pagePrimary(-1),
+    hasProfile(false),
+    hasAlpha(false),
+    orientation(0),
+    exif(nullptr),
+    exifLength(0),
+    icc(nullptr),
+    iccLength(0),
+    iptc(nullptr),
+    iptcLength(0),
+    xmp(nullptr),
+    xmpLength(0),
+    tifftagPhotoshop(nullptr),
+    tifftagPhotoshopLength(0) {}
+};
+
+Napi::Value metadata(const Napi::CallbackInfo& info);
+
+#endif  // SRC_METADATA_H_

src/operations.cc

@@ -0,0 +1,278 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <tuple>
+#include <vector>
+
+#include <vips/vips8>
+
+#include "common.h"
+#include "operations.h"
+
+using vips::VImage;
+using vips::VError;
+
+namespace sharp {
+  /*
+   * Tint an image using the specified chroma, preserving the original image luminance
+   */
+  VImage Tint(VImage image, double const a, double const b) {
+    // Get original colourspace
+    VipsInterpretation typeBeforeTint = image.interpretation();
+    if (typeBeforeTint == VIPS_INTERPRETATION_RGB) {
+      typeBeforeTint = VIPS_INTERPRETATION_sRGB;
+    }
+    // Extract luminance
+    VImage luminance = image.colourspace(VIPS_INTERPRETATION_LAB)[0];
+    // Create the tinted version by combining the L from the original and the chroma from the tint
+    std::vector<double> chroma {a, b};
+    VImage tinted = luminance
+      .bandjoin(chroma)
+      .copy(VImage::option()->set("interpretation", VIPS_INTERPRETATION_LAB))
+      .colourspace(typeBeforeTint);
+    // Attach original alpha channel, if any
+    if (HasAlpha(image)) {
+      // Extract original alpha channel
+      VImage alpha = image[image.bands() - 1];
+      // Join alpha channel to normalised image
+      tinted = tinted.bandjoin(alpha);
+    }
+    return tinted;
+  }
+
+  /*
+   * Stretch luminance to cover full dynamic range.
+   */
+  VImage Normalise(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 alpha = image[image.bands() - 1];
+      return RemoveAlpha(image).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);
+  }
+
+  /*
+   * Recomb with a Matrix of the given bands/channel size.
+   * Eg. RGB will be a 3x3 matrix.
+   */
+  VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix) {
+    double *m = matrix.get();
+    image = image.colourspace(VIPS_INTERPRETATION_sRGB);
+    return image
+      .recomb(image.bands() == 3
+        ? VImage::new_from_memory(
+          m, 9 * sizeof(double), 3, 3, 1, VIPS_FORMAT_DOUBLE
+        )
+        : VImage::new_matrixv(4, 4,
+          m[0], m[1], m[2], 0.0,
+          m[3], m[4], m[5], 0.0,
+          m[6], m[7], m[8], 0.0,
+          0.0, 0.0, 0.0, 1.0));
+  }
+
+  VImage Modulate(VImage image, double const brightness, double const saturation, int const hue) {
+    if (HasAlpha(image)) {
+      // Separate alpha channel
+      VImage alpha = image[image.bands() - 1];
+      return RemoveAlpha(image)
+        .colourspace(VIPS_INTERPRETATION_LCH)
+        .linear(
+          { brightness, saturation, 1},
+          { 0.0, 0.0, static_cast<double>(hue) }
+        )
+        .colourspace(VIPS_INTERPRETATION_sRGB)
+        .bandjoin(alpha);
+    } else {
+      return image
+        .colourspace(VIPS_INTERPRETATION_LCH)
+        .linear(
+          { brightness, saturation, 1 },
+          { 0.0, 0.0, static_cast<double>(hue) }
+        )
+        .colourspace(VIPS_INTERPRETATION_sRGB);
+    }
+  }
+
+  /*
+   * 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);
+    }
+  }
+
+  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);
+  }
+
+  /*
+    Trim an image
+  */
+  VImage Trim(VImage image, double const threshold) {
+    if (image.width() < 3 && image.height() < 3) {
+      throw VError("Image to trim must be at least 3x3 pixels");
+    }
+    // Top-left pixel provides the background colour
+    VImage background = image.extract_area(0, 0, 1, 1);
+    if (HasAlpha(background)) {
+      background = background.flatten();
+    }
+    int left, top, width, height;
+    left = image.find_trim(&top, &width, &height, VImage::option()
+      ->set("background", background(0, 0))
+      ->set("threshold", threshold));
+    if (width == 0 || height == 0) {
+      if (HasAlpha(image)) {
+        // Search alpha channel
+        VImage alpha = image[image.bands() - 1];
+        VImage backgroundAlpha = alpha.extract_area(0, 0, 1, 1);
+        left = alpha.find_trim(&top, &width, &height, VImage::option()
+          ->set("background", backgroundAlpha(0, 0))
+          ->set("threshold", threshold));
+      }
+      if (width == 0 || height == 0) {
+        throw VError("Unexpected error while trimming. Try to lower the tolerance");
+      }
+    }
+    return image.extract_area(left, top, width, height);
+  }
+
+  /*
+   * Calculate (a * in + b)
+   */
+  VImage Linear(VImage image, double const a, double const b) {
+    if (HasAlpha(image)) {
+      // Separate alpha channel
+      VImage alpha = image[image.bands() - 1];
+      return RemoveAlpha(image).linear(a, b).bandjoin(alpha);
+    } else {
+      return image.linear(a, b);
+    }
+  }
+}  // namespace sharp

src/operations.h

@@ -0,0 +1,97 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#ifndef SRC_OPERATIONS_H_
+#define SRC_OPERATIONS_H_
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <tuple>
+#include <vips/vips8>
+
+using vips::VImage;
+
+namespace sharp {
+
+  /*
+   * Tint an image using the specified chroma, preserving the original image luminance
+   */
+  VImage Tint(VImage image, double const a, double const b);
+
+  /*
+   * Stretch luminance to cover full dynamic range.
+   */
+  VImage Normalise(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);
+
+  /*
+    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, double const threshold);
+
+  /*
+   * Linear adjustment (a * in + b)
+   */
+  VImage Linear(VImage image, double const a, double const b);
+
+  /*
+   * Recomb with a Matrix of the given bands/channel size.
+   * Eg. RGB will be a 3x3 matrix.
+   */
+  VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix);
+
+  /*
+   * Modulate brightness, saturation and hue
+   */
+  VImage Modulate(VImage image, double const brightness, double const saturation, int const hue);
+
+}  // namespace sharp
+
+#endif  // SRC_OPERATIONS_H_

src/pipeline.h

@@ -0,0 +1,314 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#ifndef SRC_PIPELINE_H_
+#define SRC_PIPELINE_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <napi.h>
+#include <vips/vips8>
+
+#include "./common.h"
+
+Napi::Value pipeline(const Napi::CallbackInfo& info);
+
+enum class Canvas {
+  CROP,
+  EMBED,
+  MAX,
+  MIN,
+  IGNORE_ASPECT
+};
+
+struct Composite {
+  sharp::InputDescriptor *input;
+  VipsBlendMode mode;
+  int gravity;
+  int left;
+  int top;
+  bool hasOffset;
+  bool tile;
+  bool premultiplied;
+
+  Composite():
+    input(nullptr),
+    mode(VIPS_BLEND_MODE_OVER),
+    gravity(0),
+    left(0),
+    top(0),
+    hasOffset(false),
+    tile(false),
+    premultiplied(false) {}
+};
+
+struct PipelineBaton {
+  sharp::InputDescriptor *input;
+  std::string formatOut;
+  std::string fileOut;
+  void *bufferOut;
+  size_t bufferOutLength;
+  std::vector<Composite *> composite;
+  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 position;
+  std::vector<double> resizeBackground;
+  bool hasCropOffset;
+  int cropOffsetLeft;
+  int cropOffsetTop;
+  bool premultiplied;
+  bool tileCentre;
+  std::string kernel;
+  bool fastShrinkOnLoad;
+  double tintA;
+  double tintB;
+  bool flatten;
+  std::vector<double> flattenBackground;
+  bool negate;
+  double blurSigma;
+  double brightness;
+  double saturation;
+  int hue;
+  int medianSize;
+  double sharpenSigma;
+  double sharpenFlat;
+  double sharpenJagged;
+  int threshold;
+  bool thresholdGrayscale;
+  double trimThreshold;
+  int trimOffsetLeft;
+  int trimOffsetTop;
+  double linearA;
+  double linearB;
+  double gamma;
+  double gammaOut;
+  bool greyscale;
+  bool normalise;
+  bool useExifOrientation;
+  int angle;
+  double rotationAngle;
+  std::vector<double> rotationBackground;
+  bool rotateBeforePreExtract;
+  bool flip;
+  bool flop;
+  int extendTop;
+  int extendBottom;
+  int extendLeft;
+  int extendRight;
+  std::vector<double> extendBackground;
+  bool withoutEnlargement;
+  std::vector<double> affineMatrix;
+  std::vector<double> affineBackground;
+  double affineIdx;
+  double affineIdy;
+  double affineOdx;
+  double affineOdy;
+  vips::VInterpolate affineInterpolator;
+  int jpegQuality;
+  bool jpegProgressive;
+  std::string jpegChromaSubsampling;
+  bool jpegTrellisQuantisation;
+  int jpegQuantisationTable;
+  bool jpegOvershootDeringing;
+  bool jpegOptimiseScans;
+  bool jpegOptimiseCoding;
+  bool pngProgressive;
+  int pngCompressionLevel;
+  bool pngAdaptiveFiltering;
+  bool pngPalette;
+  int pngQuality;
+  int pngColours;
+  double pngDither;
+  int webpQuality;
+  int webpAlphaQuality;
+  bool webpNearLossless;
+  bool webpLossless;
+  bool webpSmartSubsample;
+  int webpReductionEffort;
+  int tiffQuality;
+  VipsForeignTiffCompression tiffCompression;
+  VipsForeignTiffPredictor tiffPredictor;
+  bool tiffPyramid;
+  int tiffBitdepth;
+  bool tiffTile;
+  int tiffTileHeight;
+  int tiffTileWidth;
+  double tiffXres;
+  double tiffYres;
+  int heifQuality;
+  VipsForeignHeifCompression heifCompression;
+  int heifSpeed;
+  std::string heifChromaSubsampling;
+  bool heifLossless;
+  std::string err;
+  bool withMetadata;
+  int withMetadataOrientation;
+  std::string withMetadataIcc;
+  std::unique_ptr<double[]> convKernel;
+  int convKernelWidth;
+  int convKernelHeight;
+  double convKernelScale;
+  double convKernelOffset;
+  sharp::InputDescriptor *boolean;
+  VipsOperationBoolean booleanOp;
+  VipsOperationBoolean bandBoolOp;
+  int extractChannel;
+  bool removeAlpha;
+  bool ensureAlpha;
+  VipsInterpretation colourspace;
+  int pageHeight;
+  std::vector<int> delay;
+  int loop;
+  int tileSize;
+  int tileOverlap;
+  VipsForeignDzContainer tileContainer;
+  VipsForeignDzLayout tileLayout;
+  std::string tileFormat;
+  int tileAngle;
+  std::vector<double> tileBackground;
+  int tileSkipBlanks;
+  VipsForeignDzDepth tileDepth;
+  std::unique_ptr<double[]> recombMatrix;
+
+  PipelineBaton():
+    input(nullptr),
+    bufferOutLength(0),
+    topOffsetPre(-1),
+    topOffsetPost(-1),
+    channels(0),
+    canvas(Canvas::CROP),
+    position(0),
+    resizeBackground{ 0.0, 0.0, 0.0, 255.0 },
+    hasCropOffset(false),
+    cropOffsetLeft(0),
+    cropOffsetTop(0),
+    premultiplied(false),
+    tintA(128.0),
+    tintB(128.0),
+    flatten(false),
+    flattenBackground{ 0.0, 0.0, 0.0 },
+    negate(false),
+    blurSigma(0.0),
+    brightness(1.0),
+    saturation(1.0),
+    hue(0),
+    medianSize(0),
+    sharpenSigma(0.0),
+    sharpenFlat(1.0),
+    sharpenJagged(2.0),
+    threshold(0),
+    thresholdGrayscale(true),
+    trimThreshold(0.0),
+    trimOffsetLeft(0),
+    trimOffsetTop(0),
+    linearA(1.0),
+    linearB(0.0),
+    gamma(0.0),
+    greyscale(false),
+    normalise(false),
+    useExifOrientation(false),
+    angle(0),
+    rotationAngle(0.0),
+    rotationBackground{ 0.0, 0.0, 0.0, 255.0 },
+    flip(false),
+    flop(false),
+    extendTop(0),
+    extendBottom(0),
+    extendLeft(0),
+    extendRight(0),
+    extendBackground{ 0.0, 0.0, 0.0, 255.0 },
+    withoutEnlargement(false),
+    affineMatrix{ 1.0, 0.0, 0.0, 1.0 },
+    affineBackground{ 0.0, 0.0, 0.0, 255.0 },
+    affineIdx(0),
+    affineIdy(0),
+    affineOdx(0),
+    affineOdy(0),
+    affineInterpolator(vips::VInterpolate::new_from_name("bicubic")),
+    jpegQuality(80),
+    jpegProgressive(false),
+    jpegChromaSubsampling("4:2:0"),
+    jpegTrellisQuantisation(false),
+    jpegQuantisationTable(0),
+    jpegOvershootDeringing(false),
+    jpegOptimiseScans(false),
+    jpegOptimiseCoding(true),
+    pngProgressive(false),
+    pngCompressionLevel(9),
+    pngAdaptiveFiltering(false),
+    pngPalette(false),
+    pngQuality(100),
+    pngColours(256),
+    pngDither(1.0),
+    webpQuality(80),
+    webpAlphaQuality(100),
+    webpNearLossless(false),
+    webpLossless(false),
+    webpSmartSubsample(false),
+    webpReductionEffort(4),
+    tiffQuality(80),
+    tiffCompression(VIPS_FOREIGN_TIFF_COMPRESSION_JPEG),
+    tiffPredictor(VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL),
+    tiffPyramid(false),
+    tiffBitdepth(8),
+    tiffTile(false),
+    tiffTileHeight(256),
+    tiffTileWidth(256),
+    tiffXres(1.0),
+    tiffYres(1.0),
+    heifQuality(50),
+    heifCompression(VIPS_FOREIGN_HEIF_COMPRESSION_AV1),
+    heifSpeed(5),
+    heifChromaSubsampling("4:2:0"),
+    heifLossless(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),
+    removeAlpha(false),
+    ensureAlpha(false),
+    colourspace(VIPS_INTERPRETATION_LAST),
+    pageHeight(0),
+    delay{-1},
+    loop(-1),
+    tileSize(256),
+    tileOverlap(0),
+    tileContainer(VIPS_FOREIGN_DZ_CONTAINER_FS),
+    tileLayout(VIPS_FOREIGN_DZ_LAYOUT_DZ),
+    tileAngle(0),
+    tileBackground{ 255.0, 255.0, 255.0, 255.0 },
+    tileSkipBlanks(-1),
+    tileDepth(VIPS_FOREIGN_DZ_DEPTH_LAST) {}
+};
+
+#endif  // SRC_PIPELINE_H_

src/sharp.cc

@@ -1,173 +1,51 @@
-#include <node.h>
-#include <math.h>
-#include <string>
-#include <vector>
-#include <vips/vips.h>
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
 
-using namespace v8;
+#include <napi.h>
+#include <vips/vips8>
 
-// Free VipsImage children when object goes out of scope
-// Thanks due to https://github.com/dosx/node-vips
-class ImageFreer {
-  public:
-    ImageFreer() {}
-    ~ImageFreer() {
-      for (uint16_t i = 0; i < v_.size(); i++) {
-        if (v_[i] != NULL) {
-          g_object_unref(v_[i]);
-        }
-      }
-      v_.clear();
-    }
-    void add(VipsImage* i) { v_.push_back(i); }
-  private:
-    std::vector<VipsImage*> v_;
-};
+#include "common.h"
+#include "metadata.h"
+#include "pipeline.h"
+#include "utilities.h"
+#include "stats.h"
 
-struct ResizeBaton {
-  std::string src;
-  std::string dst;
-  int  cols;
-  int  rows;
-  bool crop;
-  int  embed;
-  std::string err;
-  Persistent<Function> callback;
-};
-
-void ResizeAsync(uv_work_t *work) {
-  ResizeBaton* baton = static_cast<ResizeBaton*>(work->data);
-
-  VipsImage *in = vips_image_new_mode((baton->src).c_str(), "p");
-  vips_jpegload((baton->src).c_str(), &in, NULL);
-  if (in == NULL) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
-  ImageFreer freer;
-  freer.add(in);
-
-  VipsImage* img = in;
-  VipsImage* t[4];
-
-  if (im_open_local_array(img, t, 4, "temp", "p")) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
-
-  double xfactor = static_cast<double>(img->Xsize) / std::max(baton->cols, 1);
-  double yfactor = static_cast<double>(img->Ysize) / std::max(baton->rows, 1);
-  double factor = baton->crop ? std::min(xfactor, yfactor) : std::max(xfactor, yfactor);
-  factor = std::max(factor, 1.0);
-  int shrink = floor(factor);
-  double residual = shrink / factor;
-
-  // Use im_shrink with the integral reduction
-  if (im_shrink(img, t[0], shrink, shrink)) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
-
-  // Use im_affinei with the remaining float part using bilinear interpolation
-  if (im_affinei_all(t[0], t[1], vips_interpolate_bilinear_static(), residual, 0, 0, residual, 0, 0)) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
-  img = t[1];
-
-  if (baton->crop) {
-    int width = std::min(img->Xsize, baton->cols);
-    int height = std::min(img->Ysize, baton->rows);
-    int left = (img->Xsize - width + 1) / 2;
-    int top = (img->Ysize - height + 1) / 2;
-    if (im_extract_area(img, t[2], left, top, width, height)) {
-      (baton->err).append(vips_error_buffer());
-      vips_error_clear();
-      return;
-    }
-    img = t[2];
-  } else {
-    int left = (baton->cols - img->Xsize) / 2;
-    int top = (baton->rows - img->Ysize) / 2;
-    if (im_embed(img, t[2], baton->embed, left, top, baton->cols, baton->rows)) {
-      (baton->err).append(vips_error_buffer());
-      vips_error_clear();
-      return;
-    }
-    img = t[2];
-  }
-
-  // Mild sharpen
-  INTMASK* sharpen = im_create_imaskv("sharpen", 3, 3,
-    -1, -1, -1,
-    -1, 32, -1,
-    -1, -1, -1);
-  sharpen->scale = 24;
-  if (im_conv(img, t[3], sharpen)) { 
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
-  img = t[3];
-
-  if (vips_jpegsave(img, baton->dst.c_str(), "Q", 80, "profile", "none", "optimize_coding", TRUE, NULL)) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-  }
+static void* sharp_vips_init(void*) {
+  g_setenv("VIPS_MIN_STACK_SIZE", "2m", FALSE);
+  vips_init("sharp");
+  return nullptr;
 }
 
-void ResizeAsyncAfter(uv_work_t *work, int status) {
-  HandleScope scope;
+Napi::Object init(Napi::Env env, Napi::Object exports) {
+  static GOnce sharp_vips_init_once = G_ONCE_INIT;
+  g_once(&sharp_vips_init_once, static_cast<GThreadFunc>(sharp_vips_init), nullptr);
 
-  ResizeBaton *baton = static_cast<ResizeBaton*>(work->data);
+  g_log_set_handler("VIPS", static_cast<GLogLevelFlags>(G_LOG_LEVEL_WARNING),
+    static_cast<GLogFunc>(sharp::VipsWarningCallback), nullptr);
 
-  Local<Value> argv[1];
-  if (!baton->err.empty()) {
-    argv[0] = String::New(baton->err.data(), baton->err.size());
-  } else {
-    argv[0] = Local<Value>::New(Null());
-  }
-
-  baton->callback->Call(Context::GetCurrent()->Global(), 1, argv);
-  baton->callback.Dispose();
-  delete baton;
-  delete work;
+  // Methods available to JavaScript
+  exports.Set("metadata", Napi::Function::New(env, metadata));
+  exports.Set("pipeline", Napi::Function::New(env, pipeline));
+  exports.Set("cache", Napi::Function::New(env, cache));
+  exports.Set("concurrency", Napi::Function::New(env, concurrency));
+  exports.Set("counters", Napi::Function::New(env, counters));
+  exports.Set("simd", Napi::Function::New(env, simd));
+  exports.Set("libvipsVersion", Napi::Function::New(env, libvipsVersion));
+  exports.Set("format", Napi::Function::New(env, format));
+  exports.Set("_maxColourDistance", Napi::Function::New(env, _maxColourDistance));
+  exports.Set("stats", Napi::Function::New(env, stats));
+  return exports;
 }
 
-Handle<Value> Resize(const Arguments& args) {
-  HandleScope scope;
-  
-  ResizeBaton *baton = new ResizeBaton;
-  baton->src = *String::Utf8Value(args[0]->ToString());
-  baton->dst = *String::Utf8Value(args[1]->ToString());
-  baton->cols = args[2]->Int32Value();
-  baton->rows = args[3]->Int32Value();
-  Local<String> canvas = args[4]->ToString();
-  if (canvas->Equals(String::NewSymbol("c"))) {
-	baton->crop = true;
-  } else if (canvas->Equals(String::NewSymbol("w"))) {
-    baton->crop = false;
-    baton->embed = 4;
-  } else if (canvas->Equals(String::NewSymbol("b"))) {
-    baton->crop = false;
-    baton->embed = 0;
-  }	
-  baton->callback = Persistent<Function>::New(Local<Function>::Cast(args[5]));
-
-  uv_work_t *work = new uv_work_t;
-  work->data = baton;
-  uv_queue_work(uv_default_loop(), work, ResizeAsync, (uv_after_work_cb)ResizeAsyncAfter);
-  return Undefined();
-}
-
-extern "C" void init(Handle<Object> target) {
-  HandleScope scope;
-  vips_init("");
-  NODE_SET_METHOD(target, "resize", Resize);
-};
-
-NODE_MODULE(sharp, init)
+NODE_API_MODULE(sharp, init)

src/stats.cc

@@ -0,0 +1,193 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#include <numeric>
+#include <vector>
+#include <iostream>
+
+#include <napi.h>
+#include <vips/vips8>
+
+#include "common.h"
+#include "stats.h"
+
+class StatsWorker : public Napi::AsyncWorker {
+ public:
+  StatsWorker(Napi::Function callback, StatsBaton *baton, Napi::Function debuglog) :
+    Napi::AsyncWorker(callback), baton(baton), debuglog(Napi::Persistent(debuglog)) {}
+  ~StatsWorker() {}
+
+  const int STAT_MIN_INDEX = 0;
+  const int STAT_MAX_INDEX = 1;
+  const int STAT_SUM_INDEX = 2;
+  const int STAT_SQ_SUM_INDEX = 3;
+  const int STAT_MEAN_INDEX = 4;
+  const int STAT_STDEV_INDEX = 5;
+  const int STAT_MINX_INDEX = 6;
+  const int STAT_MINY_INDEX = 7;
+  const int STAT_MAXX_INDEX = 8;
+  const int STAT_MAXY_INDEX = 9;
+
+  void Execute() {
+    // Decrement queued task counter
+    g_atomic_int_dec_and_test(&sharp::counterQueue);
+
+    vips::VImage image;
+    sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
+    try {
+      std::tie(image, imageType) = OpenInput(baton->input);
+    } catch (vips::VError const &err) {
+      (baton->err).append(err.what());
+    }
+    if (imageType != sharp::ImageType::UNKNOWN) {
+      try {
+        vips::VImage stats = image.stats();
+        int const bands = image.bands();
+        for (int b = 1; b <= bands; b++) {
+          ChannelStats cStats(
+            static_cast<int>(stats.getpoint(STAT_MIN_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MAX_INDEX, b).front()),
+            stats.getpoint(STAT_SUM_INDEX, b).front(),
+            stats.getpoint(STAT_SQ_SUM_INDEX, b).front(),
+            stats.getpoint(STAT_MEAN_INDEX, b).front(),
+            stats.getpoint(STAT_STDEV_INDEX, b).front(),
+            static_cast<int>(stats.getpoint(STAT_MINX_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MINY_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MAXX_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MAXY_INDEX, b).front()));
+          baton->channelStats.push_back(cStats);
+        }
+        // Image is not opaque when alpha layer is present and contains a non-mamixa value
+        if (sharp::HasAlpha(image)) {
+          double const minAlpha = static_cast<double>(stats.getpoint(STAT_MIN_INDEX, bands).front());
+          if (minAlpha != sharp::MaximumImageAlpha(image.interpretation())) {
+            baton->isOpaque = false;
+          }
+        }
+        // Convert to greyscale
+        vips::VImage greyscale = image.colourspace(VIPS_INTERPRETATION_B_W)[0];
+        // Estimate entropy via histogram of greyscale value frequency
+        baton->entropy = std::abs(greyscale.hist_find().hist_entropy());
+        // Estimate sharpness via standard deviation of greyscale laplacian
+        if (image.width() > 1 || image.height() > 1) {
+          VImage laplacian = VImage::new_matrixv(3, 3,
+            0.0,  1.0, 0.0,
+            1.0, -4.0, 1.0,
+            0.0,  1.0, 0.0);
+          laplacian.set("scale", 9.0);
+          baton->sharpness = greyscale.conv(laplacian).deviate();
+        }
+        // Most dominant sRGB colour via 4096-bin 3D histogram
+        vips::VImage hist = sharp::RemoveAlpha(image)
+          .colourspace(VIPS_INTERPRETATION_sRGB)
+          .hist_find_ndim(VImage::option()->set("bins", 16));
+        std::complex<double> maxpos = hist.maxpos();
+        int const dx = static_cast<int>(std::real(maxpos));
+        int const dy = static_cast<int>(std::imag(maxpos));
+        std::vector<double> pel = hist(dx, dy);
+        int const dz = std::distance(pel.begin(), std::find(pel.begin(), pel.end(), hist.max()));
+        baton->dominantRed = dx * 16 + 8;
+        baton->dominantGreen = dy * 16 + 8;
+        baton->dominantBlue = dz * 16 + 8;
+      } catch (vips::VError const &err) {
+        (baton->err).append(err.what());
+      }
+    }
+
+    // Clean up
+    vips_error_clear();
+    vips_thread_shutdown();
+  }
+
+  void OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
+
+    // Handle warnings
+    std::string warning = sharp::VipsWarningPop();
+    while (!warning.empty()) {
+      debuglog.Call({ Napi::String::New(env, warning) });
+      warning = sharp::VipsWarningPop();
+    }
+
+    if (baton->err.empty()) {
+      // Stats Object
+      Napi::Object info = Napi::Object::New(env);
+      Napi::Array channels = Napi::Array::New(env);
+
+      std::vector<ChannelStats>::iterator it;
+      int i = 0;
+      for (it = baton->channelStats.begin(); it < baton->channelStats.end(); it++, i++) {
+        Napi::Object channelStat = Napi::Object::New(env);
+        channelStat.Set("min", it->min);
+        channelStat.Set("max", it->max);
+        channelStat.Set("sum", it->sum);
+        channelStat.Set("squaresSum", it->squaresSum);
+        channelStat.Set("mean", it->mean);
+        channelStat.Set("stdev", it->stdev);
+        channelStat.Set("minX", it->minX);
+        channelStat.Set("minY", it->minY);
+        channelStat.Set("maxX", it->maxX);
+        channelStat.Set("maxY", it->maxY);
+        channels.Set(i, channelStat);
+      }
+
+      info.Set("channels", channels);
+      info.Set("isOpaque", baton->isOpaque);
+      info.Set("entropy", baton->entropy);
+      info.Set("sharpness", baton->sharpness);
+      Napi::Object dominant = Napi::Object::New(env);
+      dominant.Set("r", baton->dominantRed);
+      dominant.Set("g", baton->dominantGreen);
+      dominant.Set("b", baton->dominantBlue);
+      info.Set("dominant", dominant);
+      Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+    } else {
+      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, baton->err).Value() });
+    }
+
+    delete baton->input;
+    delete baton;
+  }
+
+ private:
+  StatsBaton* baton;
+  Napi::FunctionReference debuglog;
+};
+
+/*
+  stats(options, callback)
+*/
+Napi::Value stats(const Napi::CallbackInfo& info) {
+  // V8 objects are converted to non-V8 types held in the baton struct
+  StatsBaton *baton = new StatsBaton;
+  Napi::Object options = info[0].As<Napi::Object>();
+
+  // Input
+  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
+
+  // Function to notify of libvips warnings
+  Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();
+
+  // Join queue for worker thread
+  Napi::Function callback = info[1].As<Napi::Function>();
+  StatsWorker *worker = new StatsWorker(callback, baton, debuglog);
+  worker->Receiver().Set("options", options);
+  worker->Queue();
+
+  // Increment queued task counter
+  g_atomic_int_inc(&sharp::counterQueue);
+
+  return info.Env().Undefined();
+}

src/stats.h

@@ -0,0 +1,70 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#ifndef SRC_STATS_H_
+#define SRC_STATS_H_
+
+#include <string>
+#include <napi.h>
+
+#include "./common.h"
+
+struct ChannelStats {
+  // stats per channel
+  int min;
+  int max;
+  double sum;
+  double squaresSum;
+  double mean;
+  double stdev;
+  int minX;
+  int minY;
+  int maxX;
+  int maxY;
+
+  ChannelStats(int minVal, int maxVal, double sumVal, double squaresSumVal,
+    double meanVal, double stdevVal, int minXVal, int minYVal, int maxXVal, int maxYVal):
+    min(minVal), max(maxVal), sum(sumVal), squaresSum(squaresSumVal),
+    mean(meanVal), stdev(stdevVal), minX(minXVal), minY(minYVal), maxX(maxXVal), maxY(maxYVal) {}
+};
+
+struct StatsBaton {
+  // Input
+  sharp::InputDescriptor *input;
+
+  // Output
+  std::vector<ChannelStats> channelStats;
+  bool isOpaque;
+  double entropy;
+  double sharpness;
+  int dominantRed;
+  int dominantGreen;
+  int dominantBlue;
+
+  std::string err;
+
+  StatsBaton():
+    input(nullptr),
+    isOpaque(true),
+    entropy(0.0),
+    sharpness(0.0),
+    dominantRed(0),
+    dominantGreen(0),
+    dominantBlue(0)
+    {}
+};
+
+Napi::Value stats(const Napi::CallbackInfo& info);
+
+#endif  // SRC_STATS_H_

src/utilities.cc

@@ -0,0 +1,227 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#include <cmath>
+#include <string>
+
+#include <napi.h>
+#include <vips/vips8>
+#include <vips/vector.h>
+
+#include "common.h"
+#include "operations.h"
+#include "utilities.h"
+
+/*
+  Get and set cache limits
+*/
+Napi::Value cache(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  // Set memory limit
+  if (info[0].IsNumber()) {
+    vips_cache_set_max_mem(info[0].As<Napi::Number>().Int32Value() * 1048576);
+  }
+  // Set file limit
+  if (info[1].IsNumber()) {
+    vips_cache_set_max_files(info[1].As<Napi::Number>().Int32Value());
+  }
+  // Set items limit
+  if (info[2].IsNumber()) {
+    vips_cache_set_max(info[2].As<Napi::Number>().Int32Value());
+  }
+
+  // Get memory stats
+  Napi::Object memory = Napi::Object::New(env);
+  memory.Set("current", round(vips_tracked_get_mem() / 1048576));
+  memory.Set("high", round(vips_tracked_get_mem_highwater() / 1048576));
+  memory.Set("max", round(vips_cache_get_max_mem() / 1048576));
+  // Get file stats
+  Napi::Object files = Napi::Object::New(env);
+  files.Set("current", vips_tracked_get_files());
+  files.Set("max", vips_cache_get_max_files());
+
+  // Get item stats
+  Napi::Object items = Napi::Object::New(env);
+  items.Set("current", vips_cache_get_size());
+  items.Set("max", vips_cache_get_max());
+
+  Napi::Object cache = Napi::Object::New(env);
+  cache.Set("memory", memory);
+  cache.Set("files", files);
+  cache.Set("items", items);
+  return cache;
+}
+
+/*
+  Get and set size of thread pool
+*/
+Napi::Value concurrency(const Napi::CallbackInfo& info) {
+  // Set concurrency
+  if (info[0].IsNumber()) {
+    vips_concurrency_set(info[0].As<Napi::Number>().Int32Value());
+  }
+  // Get concurrency
+  return Napi::Number::New(info.Env(), vips_concurrency_get());
+}
+
+/*
+  Get internal counters (queued tasks, processing tasks)
+*/
+Napi::Value counters(const Napi::CallbackInfo& info) {
+  Napi::Object counters = Napi::Object::New(info.Env());
+  counters.Set("queue", sharp::counterQueue);
+  counters.Set("process", sharp::counterProcess);
+  return counters;
+}
+
+/*
+  Get and set use of SIMD vector unit instructions
+*/
+Napi::Value simd(const Napi::CallbackInfo& info) {
+  // Set state
+  if (info[0].IsBoolean()) {
+    vips_vector_set_enabled(info[0].As<Napi::Boolean>().Value());
+  }
+  // Get state
+  return Napi::Boolean::New(info.Env(), vips_vector_isenabled());
+}
+
+/*
+  Get libvips version
+*/
+Napi::Value libvipsVersion(const Napi::CallbackInfo& info) {
+  char version[9];
+  g_snprintf(version, sizeof(version), "%d.%d.%d", vips_version(0), vips_version(1), vips_version(2));
+  return Napi::String::New(info.Env(), version);
+}
+
+/*
+  Get available input/output file/buffer/stream formats
+*/
+Napi::Value format(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Object format = Napi::Object::New(env);
+  for (std::string const f : {
+    "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz",
+    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips"
+  }) {
+    // Input
+    Napi::Boolean hasInputFile =
+      Napi::Boolean::New(env, vips_type_find("VipsOperation", (f + "load").c_str()));
+    Napi::Boolean hasInputBuffer =
+      Napi::Boolean::New(env, vips_type_find("VipsOperation", (f + "load_buffer").c_str()));
+    Napi::Object input = Napi::Object::New(env);
+    input.Set("file", hasInputFile);
+    input.Set("buffer", hasInputBuffer);
+    input.Set("stream", hasInputBuffer);
+    // Output
+    Napi::Boolean hasOutputFile =
+      Napi::Boolean::New(env, vips_type_find("VipsOperation", (f + "save").c_str()));
+    Napi::Boolean hasOutputBuffer =
+      Napi::Boolean::New(env, vips_type_find("VipsOperation", (f + "save_buffer").c_str()));
+    Napi::Object output = Napi::Object::New(env);
+    output.Set("file", hasOutputFile);
+    output.Set("buffer", hasOutputBuffer);
+    output.Set("stream", hasOutputBuffer);
+    // Other attributes
+    Napi::Object container = Napi::Object::New(env);
+    container.Set("id", f);
+    container.Set("input", input);
+    container.Set("output", output);
+    // Add to set of formats
+    format.Set(f, container);
+  }
+
+  // Raw, uncompressed data
+  Napi::Boolean supported = Napi::Boolean::New(env, true);
+  Napi::Boolean unsupported = Napi::Boolean::New(env, false);
+  Napi::Object rawInput = Napi::Object::New(env);
+  rawInput.Set("file", unsupported);
+  rawInput.Set("buffer", supported);
+  rawInput.Set("stream", supported);
+  Napi::Object rawOutput = Napi::Object::New(env);
+  rawOutput.Set("file", unsupported);
+  rawOutput.Set("buffer", supported);
+  rawOutput.Set("stream", supported);
+  Napi::Object raw = Napi::Object::New(env);
+  raw.Set("id", "raw");
+  raw.Set("input", rawInput);
+  raw.Set("output", rawOutput);
+  format.Set("raw", raw);
+
+  return 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.
+*/
+Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  // Open input files
+  VImage image1;
+  sharp::ImageType imageType1 = sharp::DetermineImageType(info[0].As<Napi::String>().Utf8Value().data());
+  if (imageType1 != sharp::ImageType::UNKNOWN) {
+    try {
+      image1 = VImage::new_from_file(info[0].As<Napi::String>().Utf8Value().c_str());
+    } catch (...) {
+      throw Napi::Error::New(env, "Input file 1 has corrupt header");
+    }
+  } else {
+    throw Napi::Error::New(env, "Input file 1 is of an unsupported image format");
+  }
+  VImage image2;
+  sharp::ImageType imageType2 = sharp::DetermineImageType(info[1].As<Napi::String>().Utf8Value().data());
+  if (imageType2 != sharp::ImageType::UNKNOWN) {
+    try {
+      image2 = VImage::new_from_file(info[1].As<Napi::String>().Utf8Value().c_str());
+    } catch (...) {
+      throw Napi::Error::New(env, "Input file 2 has corrupt header");
+    }
+  } else {
+    throw Napi::Error::New(env, "Input file 2 is of an unsupported image format");
+  }
+  // Ensure same number of channels
+  if (image1.bands() != image2.bands()) {
+    throw Napi::Error::New(env, "mismatchedBands");
+  }
+  // Ensure same dimensions
+  if (image1.width() != image2.width() || image1.height() != image2.height()) {
+    throw Napi::Error::New(env, "mismatchedDimensions");
+  }
+
+  double maxColourDistance;
+  try {
+    // Premultiply and remove alpha
+    if (sharp::HasAlpha(image1)) {
+      image1 = image1.premultiply().extract_band(1, VImage::option()->set("n", image1.bands() - 1));
+    }
+    if (sharp::HasAlpha(image2)) {
+      image2 = image2.premultiply().extract_band(1, VImage::option()->set("n", image2.bands() - 1));
+    }
+    // Calculate colour distance
+    maxColourDistance = image1.dE00(image2).max();
+  } catch (vips::VError const &err) {
+    throw Napi::Error::New(env, err.what());
+  }
+
+  // Clean up libvips' per-request data and threads
+  vips_error_clear();
+  vips_thread_shutdown();
+
+  return Napi::Number::New(env, maxColourDistance);
+}

src/utilities.h

@@ -0,0 +1,28 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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
+//
+// 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.
+
+#ifndef SRC_UTILITIES_H_
+#define SRC_UTILITIES_H_
+
+#include <napi.h>
+
+Napi::Value cache(const Napi::CallbackInfo& info);
+Napi::Value concurrency(const Napi::CallbackInfo& info);
+Napi::Value counters(const Napi::CallbackInfo& info);
+Napi::Value simd(const Napi::CallbackInfo& info);
+Napi::Value libvipsVersion(const Napi::CallbackInfo& info);
+Napi::Value format(const Napi::CallbackInfo& info);
+Napi::Value _maxColourDistance(const Napi::CallbackInfo& info);
+
+#endif  // SRC_UTILITIES_H_

test/bench/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "sharp-benchmark",
+  "version": "0.0.1",
+  "private": true,
+  "author": "Lovell Fuller <npm@lovell.info>",
+  "description": "Benchmark and performance tests for sharp",
+  "scripts": {
+    "test": "node perf && node random && node parallel"
+  },
+  "devDependencies": {
+    "async": "3.2.0",
+    "benchmark": "2.1.4",
+    "gm": "1.23.1",
+    "imagemagick": "0.1.3",
+    "jimp": "0.16.1",
+    "mapnik": "4.5.5",
+    "semver": "7.3.4"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": "14"
+  }
+}

test/bench/parallel.js

@@ -0,0 +1,45 @@
+'use strict';
+
+process.env.UV_THREADPOOL_SIZE = 64;
+
+const assert = require('assert');
+const async = require('async');
+
+const sharp = require('../../');
+const fixtures = require('../fixtures');
+
+const width = 720;
+const height = 480;
+
+sharp.concurrency(1);
+sharp.simd(true);
+
+const timer = setInterval(function () {
+  console.dir(sharp.counters());
+}, 100);
+
+async.mapSeries([1, 1, 2, 4, 8, 16, 32, 64], function (parallelism, next) {
+  const start = new Date().getTime();
+  async.times(parallelism,
+    function (id, callback) {
+      /* jslint unused: false */
+      sharp(fixtures.inputJpg).resize(width, height).toBuffer(function (err, buffer) {
+        buffer = null;
+        callback(err, new Date().getTime() - start);
+      });
+    },
+    function (err, ids) {
+      assert(!err);
+      assert(ids.length === parallelism);
+      ids.sort();
+      const mean = ids.reduce(function (a, b) {
+        return a + b;
+      }) / ids.length;
+      console.log(parallelism + ' parallel calls: fastest=' + ids[0] + 'ms slowest=' + ids[ids.length - 1] + 'ms mean=' + mean + 'ms');
+      next();
+    }
+  );
+}, function () {
+  clearInterval(timer);
+  console.dir(sharp.counters());
+});

test/bench/perf.js

@@ -0,0 +1,911 @@
+'use strict';
+
+const fs = require('fs');
+
+const async = require('async');
+const assert = require('assert');
+const Benchmark = require('benchmark');
+
+// Contenders
+const sharp = require('../../');
+const gm = require('gm');
+const imagemagick = require('imagemagick');
+const mapnik = require('mapnik');
+const jimp = require('jimp');
+
+const fixtures = require('../fixtures');
+
+const outputJpg = fixtures.path('output.jpg');
+const outputPng = fixtures.path('output.png');
+const outputWebP = fixtures.path('output.webp');
+
+const width = 720;
+const height = 588;
+
+// Disable libvips cache to ensure tests are as fair as they can be
+sharp.cache(false);
+
+async.series({
+  jpeg: function (callback) {
+    const inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
+    const jpegSuite = new Benchmark.Suite('jpeg');
+    // jimp
+    jpegSuite.add('jimp-buffer-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        jimp.read(inputJpgBuffer, function (err, image) {
+          if (err) {
+            throw err;
+          } else {
+            image
+              .resize(width, height, jimp.RESIZE_BICUBIC)
+              .quality(80)
+              .getBuffer(jimp.MIME_JPEG, function (err) {
+                if (err) {
+                  throw err;
+                } else {
+                  deferred.resolve();
+                }
+              });
+          }
+        });
+      }
+    }).add('jimp-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        jimp.read(fixtures.inputJpg, function (err, image) {
+          if (err) {
+            throw err;
+          } else {
+            image
+              .resize(width, height, jimp.RESIZE_BICUBIC)
+              .quality(80)
+              .write(outputJpg, function (err) {
+                if (err) {
+                  throw err;
+                } else {
+                  deferred.resolve();
+                }
+              });
+          }
+        });
+      }
+    });
+    // mapnik
+    jpegSuite.add('mapnik-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        mapnik.Image.open(fixtures.inputJpg, function (err, img) {
+          if (err) throw err;
+          img
+            .resize(width, height, {
+              scaling_method: mapnik.imageScaling.lanczos
+            })
+            .save(outputJpg, 'jpeg:quality=80', function (err) {
+              if (err) throw err;
+              deferred.resolve();
+            });
+        });
+      }
+    }).add('mapnik-buffer-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        mapnik.Image.fromBytes(inputJpgBuffer, { max_size: 3000 }, function (err, img) {
+          if (err) throw err;
+          img
+            .resize(width, height, {
+              scaling_method: mapnik.imageScaling.lanczos
+            })
+            .encode('jpeg:quality=80', function (err) {
+              if (err) throw err;
+              deferred.resolve();
+            });
+        });
+      }
+    });
+    // imagemagick
+    jpegSuite.add('imagemagick-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        imagemagick.resize({
+          srcPath: fixtures.inputJpg,
+          dstPath: outputJpg,
+          quality: 0.8,
+          width: width,
+          height: height,
+          format: 'jpg',
+          filter: 'Lanczos'
+        }, function (err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    });
+    // gm
+    jpegSuite.add('gm-buffer-file', {
+      defer: true,
+      fn: function (deferred) {
+        gm(inputJpgBuffer)
+          .filter('Lanczos')
+          .resize(width, height)
+          .quality(80)
+          .write(outputJpg, function (err) {
+            if (err) {
+              throw err;
+            } else {
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('gm-buffer-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        gm(inputJpgBuffer)
+          .filter('Lanczos')
+          .resize(width, height)
+          .quality(80)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('gm-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        gm(fixtures.inputJpg)
+          .filter('Lanczos')
+          .resize(width, height)
+          .quality(80)
+          .write(outputJpg, function (err) {
+            if (err) {
+              throw err;
+            } else {
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('gm-file-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        gm(fixtures.inputJpg)
+          .filter('Lanczos')
+          .resize(width, height)
+          .quality(80)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    });
+    // sharp
+    jpegSuite.add('sharp-buffer-file', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .toFile(outputJpg, function (err) {
+            if (err) {
+              throw err;
+            } else {
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-buffer-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(fixtures.inputJpg)
+          .resize(width, height)
+          .toFile(outputJpg, function (err) {
+            if (err) {
+              throw err;
+            } else {
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-stream-stream', {
+      defer: true,
+      fn: function (deferred) {
+        const readable = fs.createReadStream(fixtures.inputJpg);
+        const writable = fs.createWriteStream(outputJpg);
+        writable.on('finish', function () {
+          deferred.resolve();
+        });
+        const pipeline = sharp()
+          .resize(width, height);
+        readable.pipe(pipeline).pipe(writable);
+      }
+    }).add('sharp-file-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(fixtures.inputJpg)
+          .resize(width, height)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-promise', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .toBuffer()
+          .then(function (buffer) {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          })
+          .catch(function (err) {
+            throw err;
+          });
+      }
+    }).on('cycle', function (event) {
+      console.log('jpeg ' + String(event.target));
+    }).on('complete', function () {
+      callback(null, this.filter('fastest').map('name'));
+    }).run();
+  },
+  // Effect of applying operations
+  operations: function (callback) {
+    const inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
+    const operationsSuite = new Benchmark.Suite('operations');
+    operationsSuite.add('sharp-sharpen-mild', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .sharpen()
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-sharpen-radius', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .sharpen(3, 1, 3)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-blur-mild', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .blur()
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-blur-radius', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .blur(3)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-gamma', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .gamma()
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-normalise', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .normalise()
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-greyscale', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .greyscale()
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-greyscale-gamma', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .gamma()
+          .greyscale()
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-progressive', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .jpeg({ progressive: true })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-without-chroma-subsampling', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .jpeg({ chromaSubsampling: '4:4:4' })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-rotate', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .rotate(90)
+          .resize(width, height)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-without-simd', {
+      defer: true,
+      fn: function (deferred) {
+        sharp.simd(false);
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .toBuffer(function (err, buffer) {
+            sharp.simd(true);
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-sequentialRead', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer, { sequentialRead: true })
+          .resize(width, height)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-crop-entropy', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height, {
+            fit: 'cover',
+            position: sharp.strategy.entropy
+          })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-crop-attention', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height, {
+            fit: 'cover',
+            position: sharp.strategy.attention
+          })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).on('cycle', function (event) {
+      console.log('operations ' + String(event.target));
+    }).on('complete', function () {
+      callback(null, this.filter('fastest').map('name'));
+    }).run();
+  },
+  // Comparative speed of kernels
+  kernels: function (callback) {
+    const inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
+    (new Benchmark.Suite('kernels')).add('sharp-cubic', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height, { kernel: 'cubic' })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-lanczos2', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height, { kernel: 'lanczos2' })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-lanczos3', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height, { kernel: 'lanczos3' })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).on('cycle', function (event) {
+      console.log('kernels ' + String(event.target));
+    }).on('complete', function () {
+      callback(null, this.filter('fastest').map('name'));
+    }).run();
+  },
+  // PNG
+  png: function (callback) {
+    const inputPngBuffer = fs.readFileSync(fixtures.inputPngAlphaPremultiplicationLarge);
+    const pngSuite = new Benchmark.Suite('png');
+    const minSamples = 64;
+    // jimp
+    pngSuite.add('jimp-buffer-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        jimp.read(inputPngBuffer, function (err, image) {
+          if (err) {
+            throw err;
+          } else {
+            image
+              .resize(width, height)
+              .deflateLevel(6)
+              .filterType(0)
+              .getBuffer(jimp.MIME_PNG, function (err) {
+                if (err) {
+                  throw err;
+                } else {
+                  deferred.resolve();
+                }
+              });
+          }
+        });
+      }
+    }).add('jimp-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        jimp.read(fixtures.inputPngAlphaPremultiplicationLarge, function (err, image) {
+          if (err) {
+            throw err;
+          } else {
+            image
+              .resize(width, height)
+              .deflateLevel(6)
+              .filterType(0)
+              .write(outputPng, function (err) {
+                if (err) {
+                  throw err;
+                } else {
+                  deferred.resolve();
+                }
+              });
+          }
+        });
+      }
+    });
+    // mapnik
+    pngSuite.add('mapnik-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        mapnik.Image.open(fixtures.inputPngAlphaPremultiplicationLarge, function (err, img) {
+          if (err) throw err;
+          img.premultiply(function (err, img) {
+            if (err) throw err;
+            img.resize(width, height, {
+              scaling_method: mapnik.imageScaling.lanczos
+            }, function (err, img) {
+              if (err) throw err;
+              img.demultiply(function (err, img) {
+                if (err) throw err;
+                img.save(outputPng, 'png', function (err) {
+                  if (err) throw err;
+                  deferred.resolve();
+                });
+              });
+            });
+          });
+        });
+      }
+    }).add('mapnik-buffer-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        mapnik.Image.fromBytes(inputPngBuffer, { max_size: 3000 }, function (err, img) {
+          if (err) throw err;
+          img.premultiply(function (err, img) {
+            if (err) throw err;
+            img.resize(width, height, {
+              scaling_method: mapnik.imageScaling.lanczos
+            }, function (err, img) {
+              if (err) throw err;
+              img.demultiply(function (err, img) {
+                if (err) throw err;
+                img.encode('png', function (err) {
+                  if (err) throw err;
+                  deferred.resolve();
+                });
+              });
+            });
+          });
+        });
+      }
+    });
+    // imagemagick
+    pngSuite.add('imagemagick-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        imagemagick.resize({
+          srcPath: fixtures.inputPngAlphaPremultiplicationLarge,
+          dstPath: outputPng,
+          width: width,
+          height: height,
+          filter: 'Lanczos',
+          customArgs: [
+            '-define', 'PNG:compression-level=6',
+            '-define', 'PNG:compression-filter=0'
+          ]
+        }, function (err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    });
+    // gm
+    pngSuite.add('gm-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        gm(fixtures.inputPngAlphaPremultiplicationLarge)
+          .filter('Lanczos')
+          .resize(width, height)
+          .define('PNG:compression-level=6')
+          .define('PNG:compression-filter=0')
+          .write(outputPng, function (err) {
+            if (err) {
+              throw err;
+            } else {
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('gm-file-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        gm(fixtures.inputPngAlphaPremultiplicationLarge)
+          .filter('Lanczos')
+          .resize(width, height)
+          .define('PNG:compression-level=6')
+          .define('PNG:compression-filter=0')
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    });
+    // sharp
+    pngSuite.add('sharp-buffer-file', {
+      defer: true,
+      minSamples,
+      fn: function (deferred) {
+        sharp(inputPngBuffer)
+          .resize(width, height)
+          .png({ compressionLevel: 6 })
+          .toFile(outputPng, function (err) {
+            if (err) {
+              throw err;
+            } else {
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-buffer-buffer', {
+      defer: true,
+      minSamples,
+      fn: function (deferred) {
+        sharp(inputPngBuffer)
+          .resize(width, height)
+          .png({ compressionLevel: 6 })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-file-file', {
+      defer: true,
+      minSamples,
+      fn: function (deferred) {
+        sharp(fixtures.inputPngAlphaPremultiplicationLarge)
+          .resize(width, height)
+          .png({ compressionLevel: 6 })
+          .toFile(outputPng, function (err) {
+            if (err) {
+              throw err;
+            } else {
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-file-buffer', {
+      defer: true,
+      minSamples,
+      fn: function (deferred) {
+        sharp(fixtures.inputPngAlphaPremultiplicationLarge)
+          .resize(width, height)
+          .png({ compressionLevel: 6 })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-progressive', {
+      defer: true,
+      minSamples,
+      fn: function (deferred) {
+        sharp(inputPngBuffer)
+          .resize(width, height)
+          .png({ compressionLevel: 6, progressive: true })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-adaptiveFiltering', {
+      defer: true,
+      minSamples,
+      fn: function (deferred) {
+        sharp(inputPngBuffer)
+          .resize(width, height)
+          .png({ adaptiveFiltering: true, compressionLevel: 6 })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-compressionLevel=9', {
+      defer: true,
+      minSamples,
+      fn: function (deferred) {
+        sharp(inputPngBuffer)
+          .resize(width, height)
+          .png({ compressionLevel: 9 })
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    });
+    pngSuite.on('cycle', function (event) {
+      console.log(' png ' + String(event.target));
+    }).on('complete', function () {
+      callback(null, this.filter('fastest').map('name'));
+    }).run();
+  },
+  // WebP
+  webp: function (callback) {
+    const inputWebPBuffer = fs.readFileSync(fixtures.inputWebP);
+    (new Benchmark.Suite('webp')).add('sharp-buffer-file', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputWebPBuffer)
+          .resize(width, height)
+          .toFile(outputWebP, function (err) {
+            if (err) {
+              throw err;
+            } else {
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-buffer-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(inputWebPBuffer)
+          .resize(width, height)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(fixtures.inputWebP)
+          .resize(width, height)
+          .toFile(outputWebP, function (err) {
+            if (err) {
+              throw err;
+            } else {
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-file-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        sharp(fixtures.inputWebP)
+          .resize(width, height)
+          .toBuffer(function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).on('cycle', function (event) {
+      console.log('webp ' + String(event.target));
+    }).on('complete', function () {
+      callback(null, this.filter('fastest').map('name'));
+    }).run();
+  }
+}, function (err, results) {
+  assert(!err, err);
+  Object.keys(results).forEach(function (format) {
+    if (results[format].toString().substr(0, 5) !== 'sharp') {
+      console.log('sharp was slower than ' + results[format] + ' for ' + format);
+    }
+  });
+  console.dir(sharp.cache());
+});

test/bench/random.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const imagemagick = require('imagemagick');
+const gm = require('gm');
+const assert = require('assert');
+const Benchmark = require('benchmark');
+
+const sharp = require('../../');
+const fixtures = require('../fixtures');
+
+sharp.cache(false);
+sharp.simd(true);
+
+const min = 320;
+const max = 960;
+
+const randomDimension = function () {
+  return Math.ceil((Math.random() * (max - min)) + min);
+};
+
+new Benchmark.Suite('random').add('imagemagick', {
+  defer: true,
+  fn: function (deferred) {
+    imagemagick.resize({
+      srcPath: fixtures.inputJpg,
+      dstPath: fixtures.path('output.jpg'),
+      quality: 0.8,
+      width: randomDimension(),
+      height: randomDimension(),
+      format: 'jpg',
+      filter: 'Lanczos'
+    }, function (err) {
+      if (err) {
+        throw err;
+      } else {
+        deferred.resolve();
+      }
+    });
+  }
+}).add('gm', {
+  defer: true,
+  fn: function (deferred) {
+    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();
+        }
+      });
+  }
+}).on('cycle', function (event) {
+  console.log(String(event.target));
+}).on('complete', function () {
+  const winner = this.filter('fastest').map('name');
+  assert.strictEqual('sharp', String(winner), 'sharp was slower than ' + winner);
+}).run();

test/coverage/report.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+CPPFLAGS="--coverage" LDFLAGS="--coverage" npm rebuild
+npm test
+geninfo --no-external --base-directory src --output-file coverage/sharp.info build/Release/obj.target/sharp/src
+genhtml --title sharp --demangle-cpp --output-directory coverage/sharp coverage/*.info