Release v0.28.1

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

.cirrus.yml

@@ -1,13 +1,15 @@
 freebsd_instance:
-  image_family: freebsd-12-0
+  image_family: freebsd-13-0-snap
 
 task:
+  name: FreeBSD 13.0
+  env:
+    IGNORE_OSVERSION: yes
   prerequisites_script:
-    - sed -i '' 's/quarterly/latest/g' /etc/pkg/FreeBSD.conf
     - pkg update -f
     - pkg upgrade -y
-    - pkg install -y pkgconf vips libnghttp2 node npm
+    - pkg install -y pkgconf vips node npm
   install_script:
-    - npm install --unsafe-perm
+    - npm install --build-from-source --unsafe-perm
   test_script:
     - npm test

.github/CONTRIBUTING.md

@@ -27,7 +27,7 @@ Please select the `master` branch as the destination for your Pull Request so yo
 
 Please squash your changes into a single commit using a command like `git rebase -i upstream/master`.
 
-To test C++ changes, you can compile the module using `npm install` and then run the tests using `npm test`.
+To test C++ changes, you can compile the module using `npm install --build-from-source` and then run the tests using `npm test`.
 
 ## Submit a Pull Request with a new feature
 
@@ -42,11 +42,6 @@ You deserve to add your details to the [list of contributors](https://github.com
 
 Any change that modifies the existing public API should be added to the relevant work-in-progress branch for inclusion in the next major release.
 
-| Release | WIP branch |
-| ------: | :--------- |
-| v0.24.0 | wit        |
-| v0.25.0 | yield      |
-
 Please squash your changes into a single commit using a command like `git rebase -i upstream/<wip-branch>`.
 
 ### Add a new public method
@@ -71,7 +66,7 @@ The public API is documented with [JSDoc](http://usejsdoc.org/) annotated commen
 
 These can be converted to Markdown by running:
 ```sh
-npm run docs
+npm run docs-build
 ```
 
 Please include documentation updates in any Pull Request that modifies the public API.

.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

@@ -1,9 +1,7 @@
 ---
 name: Feature request
 about: Suggest an idea
-title: ''
 labels: enhancement
-assignees: ''
 
 ---
 

.github/ISSUE_TEMPLATE/installation.md

@@ -1,18 +1,22 @@
 ---
 name: Installation
-about: Something went wrong **installing** sharp
-title: ''
+about: Something went wrong during either 'npm install sharp' or 'require("sharp")'
 labels: installation
-assignees: ''
 
 ---
 
-Did you see the [documentation relating to installation](https://sharp.pixelplumbing.com/en/stable/install/)?
+Did you see the [documentation relating to installation](https://sharp.pixelplumbing.com/install)?
 
-Have you ensured the platform and version of Node.js used for `npm install` is the same as the platform and version of Node.js used at runtime?
+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?
 
-If you are installing as a `root` or `sudo` user, have you tried with the `npm install --unsafe-perm` flag?
+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 --languages --system --utilities`?
+What is the output of running `npx envinfo --binaries --system`?

.github/ISSUE_TEMPLATE/possible-bug.md

@@ -1,20 +1,20 @@
 ---
 name: Possible bug
-about: Something unexpected occurred **using** sharp
-title: ''
+about: Installation of sharp was successful but then something unexpected occurred using one of its features
 labels: triage
-assignees: ''
 
 ---
 
 <!-- If this issue relates to installation, please use https://github.com/lovell/sharp/issues/new?labels=installation&template=installation.md instead. -->
 
-What is the output of running `npx envinfo --binaries --languages --system --utilities`?
+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 standalone code sample, without other dependencies, that demonstrates this problem?
+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

@@ -1,9 +1,7 @@
 ---
 name: Question
 about: For help understanding an existing feature
-title: ''
 labels: question
-assignees: ''
 
 ---
 
@@ -13,6 +11,6 @@ What are you trying to achieve?
 
 Have you searched for similar questions?
 
-Are you able to provide a standalone code sample that demonstrates this question?
+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,87 @@
+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:14-alpine3.13
+          - 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

@@ -15,3 +15,4 @@ vendor
 .vscode/
 package-lock.json
 .idea
+.firebase

.travis.yml

@@ -1,91 +1,108 @@
-matrix:
+jobs:
   include:
-    - name: "Linux (glibc) - Node 8"
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 10"
+      arch: arm64
       os: linux
-      dist: trusty
-      sudo: false
-      language: node_js
-      node_js: "8"
-    - name: "Linux (glibc) - Node 10"
-      os: linux
-      dist: trusty
-      sudo: false
-      language: node_js
-      node_js: "10"
-    - name: "Linux (glibc) - Node 12"
-      os: linux
-      dist: trusty
-      sudo: false
-      language: node_js
-      node_js: "12"
-    - name: "Linux (glibc) - Node 13"
-      os: linux
-      dist: trusty
-      sudo: false
-      language: node_js
-      node_js: "13"
-      after_success:
-        - npm install coveralls
-        - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js
-    - name: "Linux (musl) - Node 8"
-      os: linux
-      dist: trusty
-      sudo: true
-      language: minimal
+      dist: bionic
+      language: shell
       before_install:
-        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:8-alpine
-        - sudo docker exec sharp apk add build-base git python2 --update-cache
-      install: sudo docker exec sharp sh -c "npm install --unsafe-perm"
+        - 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"
-    - name: "Linux (musl) - Node 10"
+      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: trusty
-      sudo: true
-      language: minimal
+      dist: bionic
+      language: shell
       before_install:
-        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:10-alpine
-        - sudo docker exec sharp apk add build-base git python2 --update-cache
-      install: sudo docker exec sharp sh -c "npm install --unsafe-perm"
+        - 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 (musl) - Node 12"
+
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 14"
+      arch: arm64
       os: linux
-      dist: trusty
-      sudo: true
-      language: minimal
+      dist: bionic
+      language: shell
       before_install:
-        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:12.0-alpine
-        - sudo docker exec sharp apk add build-base git python2 --update-cache
-      install: sudo docker exec sharp sh -c "npm install --unsafe-perm"
+        - 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 (musl) - Node 13"
+
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 15"
+      arch: arm64
       os: linux
-      dist: trusty
-      sudo: true
-      language: minimal
+      dist: bionic
+      language: shell
       before_install:
-        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:13.0-alpine
-        - sudo docker exec sharp apk add build-base git python2 --update-cache
-      install: sudo docker exec sharp sh -c "npm install --unsafe-perm"
+        - 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"
-    - name: "OS X - Node 8"
-      os: osx
-      osx_image: xcode9.2
-      language: node_js
-      node_js: "8"
-    - name: "OS X - Node 10"
-      os: osx
-      osx_image: xcode9.2
-      language: node_js
-      node_js: "10"
-    - name: "OS X - Node 12"
-      os: osx
-      osx_image: xcode9.2
-      language: node_js
-      node_js: "12"
-    - name: "OS X - Node 13"
-      os: osx
-      osx_image: xcode10
-      language: node_js
-      node_js: "13"
+
+    - name: "Linux ARM64v8 (Alpine 3.11, musl 1.1.24) - Node.js 10"
+      arch: arm64
+      os: linux
+      dist: focal
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:10-alpine3.11
+        - sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+      after_success: "[[ -n $TRAVIS_TAG ]] && sudo docker exec --env prebuild_upload sharp sh -c \"npx prebuild --runtime napi --target 3\""
+
+    - name: "Linux ARM64v8 (Alpine 3.11, musl 1.1.24) - Node.js 12"
+      arch: arm64
+      os: linux
+      dist: focal
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:12-alpine3.11
+        - sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "Linux ARM64v8 (Alpine 3.11, musl 1.1.24) - Node.js 14"
+      arch: arm64
+      os: linux
+      dist: focal
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:14-alpine3.11
+        - sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "Linux ARM64v8 (Alpine 3.11, musl 1.1.24) - Node.js 15"
+      arch: arm64
+      os: linux
+      dist: focal
+      language: shell
+      before_install:
+        - sudo chown 0.0 ${PWD}
+        - sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:15-alpine3.11
+        - sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+      install: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
 cache:
   npm: false

README.md

@@ -1,14 +1,10 @@
 # sharp
 
-<img src="https://raw.githubusercontent.com/lovell/sharp/master/docs/image/sharp-logo.svg?sanitize=true" width="160" height="160" alt="sharp logo" align="right">
-
-```sh
-npm install sharp
-```
+<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 and WebP images of varying dimensions.
+smaller, web-friendly JPEG, PNG, WebP and AVIF images of varying dimensions.
 
 Resizing an image is typically 4x-5x faster than using the
 quickest ImageMagick and GraphicsMagick settings
@@ -20,12 +16,23 @@ Lanczos resampling ensures quality is not sacrificed for speed.
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
 
-Most modern 64-bit OS X, Windows and Linux systems running
-Node versions 8, 10, 12 and 13
+Most modern macOS, Windows and Linux systems running Node.js v10+
 do not require any additional install or runtime dependencies.
 
+## Documentation
+
+Visit [sharp.pixelplumbing.com](https://sharp.pixelplumbing.com/) for complete
+[installation instructions](https://sharp.pixelplumbing.com/install),
+[API documentation](https://sharp.pixelplumbing.com/api-constructor),
+[benchmark tests](https://sharp.pixelplumbing.com/performance) and
+[changelog](https://sharp.pixelplumbing.com/changelog).
+
 ## Examples
 
+```sh
+npm install sharp
+```
+
 ```javascript
 const sharp = require('sharp');
 ```
@@ -44,6 +51,7 @@ sharp(inputBuffer)
 sharp('input.jpg')
   .rotate()
   .resize(200)
+  .jpeg({ mozjpeg: true })
   .toBuffer()
   .then( data => { ... })
   .catch( err => { ... });
@@ -85,24 +93,17 @@ readableStream
   .pipe(writableStream);
 ```
 
-[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.svg?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
-
-### Documentation
-
-Visit [sharp.pixelplumbing.com](https://sharp.pixelplumbing.com/) for complete
-[installation instructions](https://sharp.pixelplumbing.com/page/install),
-[API documentation](https://sharp.pixelplumbing.com/page/api),
-[benchmark tests](https://sharp.pixelplumbing.com/page/performance) and
-[changelog](https://sharp.pixelplumbing.com/page/changelog).
-
-### Contributing
+## Contributing
 
 A [guide for contributors](https://github.com/lovell/sharp/blob/master/.github/CONTRIBUTING.md)
 covers reporting bugs, requesting features and submitting code changes.
 
-### Licensing
+[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.svg?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
+[![N-API v3](https://img.shields.io/badge/N--API-v3-green.svg)](https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api_version_matrix)
 
-Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+## Licensing
+
+Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Lovell Fuller and contributors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

appveyor.yml

@@ -1,16 +1,18 @@
-os: Visual Studio 2015
+os: Visual Studio 2019
 version: "{build}"
 build: off
-platform: x64
+platform: x86
 environment:
   matrix:
-  - nodejs_version: "8"
   - nodejs_version: "10"
+    prebuild: true
   - nodejs_version: "12"
-  - nodejs_version: "13"
+  - nodejs_version: "14"
+  - nodejs_version: "15"
 install:
-  - ps: Update-NodeJsInstallation (Get-NodeJsLatestBuild $env:nodejs_version) x64
-  - npm install -g npm@6
-  - npm 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,4 +1,8 @@
 {
+  'variables': {
+    'vips_version': '<!(node -p "require(\'./lib/libvips\').minimumLibvipsVersion")',
+    'sharp_vendor_dir': '<(module_root_dir)/vendor/<(vips_version)'
+  },
   'targets': [{
     'target_name': 'libvips-cpp',
     'conditions': [
@@ -11,24 +15,43 @@
         ],
         'sources': [
           'src/libvips/cplusplus/VError.cpp',
+          'src/libvips/cplusplus/VConnection.cpp',
           'src/libvips/cplusplus/VInterpolate.cpp',
           'src/libvips/cplusplus/VImage.cpp'
         ],
         'include_dirs': [
-          'vendor/include',
-          'vendor/include/glib-2.0',
-          'vendor/lib/glib-2.0/include'
-        ],
-        'libraries': [
-          '../vendor/lib/libvips.lib',
-          '../vendor/lib/libglib-2.0.lib',
-          '../vendor/lib/libgobject-2.0.lib'
+          '<(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
+                'ExceptionHandling': 1,
+                'WholeProgramOptimization': 'true'
+              },
+              'VCLibrarianTool': {
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              },
+              'VCLinkerTool': {
+                'ImageHasSafeExceptionHandlers': 'false',
+                'OptimizeReferences': 2,
+                'EnableCOMDATFolding': 2,
+                'LinkIncremental': 1,
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
               }
             },
             'msvs_disabled_warnings': [
@@ -43,15 +66,19 @@
     ]
   }, {
     'target_name': 'sharp',
+    '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 -e "console.log(require(\'./lib/libvips\').pkgConfigPath())")',
-          'use_global_libvips': '<!(node -e "console.log(Boolean(require(\'./lib/libvips\').useGlobalLibvips()).toString())")'
+          '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': ''
@@ -64,11 +91,11 @@
       'src/stats.cc',
       'src/operations.cc',
       'src/pipeline.cc',
-      'src/sharp.cc',
-      'src/utilities.cc'
+      'src/utilities.cc',
+      'src/sharp.cc'
     ],
     'include_dirs': [
-      '<!(node -e "require(\'nan\')")'
+      '<!(node -p "require(\'node-addon-api\').include_dir")',
     ],
     'conditions': [
       ['use_global_libvips == "true"', {
@@ -90,9 +117,9 @@
       }, {
         # Use pre-built libvips stored locally within node_modules
         'include_dirs': [
-          'vendor/include',
-          'vendor/include/glib-2.0',
-          'vendor/lib/glib-2.0/include'
+          '<(sharp_vendor_dir)/include',
+          '<(sharp_vendor_dir)/include/glib-2.0',
+          '<(sharp_vendor_dir)/lib/glib-2.0/include'
         ],
         'conditions': [
           ['OS == "win"', {
@@ -100,65 +127,43 @@
               '_ALLOW_KEYWORD_MACROS',
               '_FILE_OFFSET_BITS=64'
             ],
-            'libraries': [
-              '../vendor/lib/libvips.lib',
-              '../vendor/lib/libglib-2.0.lib',
-              '../vendor/lib/libgobject-2.0.lib'
-            ]
+            'link_settings': {
+              'library_dirs': ['<(sharp_vendor_dir)/lib'],
+              'libraries': [
+                'libvips.lib',
+                'libglib-2.0.lib',
+                'libgobject-2.0.lib'
+              ]
+            }
           }],
           ['OS == "mac"', {
-            'libraries': [
-              '../vendor/lib/libvips-cpp.42.dylib',
-              '../vendor/lib/libvips.42.dylib',
-              '../vendor/lib/libglib-2.0.0.dylib',
-              '../vendor/lib/libgobject-2.0.0.dylib',
-              # Ensure runtime linking is relative to sharp.node
-              '-rpath \'@loader_path/../../vendor/lib\''
-            ]
+            'link_settings': {
+              'library_dirs': ['<(sharp_vendor_dir)/lib'],
+              'libraries': [
+                'libvips-cpp.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'
+              '_GLIBCXX_USE_CXX11_ABI=1'
             ],
-            'libraries': [
-              '../vendor/lib/libvips-cpp.so',
-              '../vendor/lib/libvips.so',
-              '../vendor/lib/libglib-2.0.so',
-              '../vendor/lib/libgobject-2.0.so',
-              # Dependencies of dependencies, included for openSUSE support
-              '../vendor/lib/libcairo.so',
-              '../vendor/lib/libcroco-0.6.so',
-              '../vendor/lib/libexif.so',
-              '../vendor/lib/libexpat.so',
-              '../vendor/lib/libffi.so',
-              '../vendor/lib/libfontconfig.so',
-              '../vendor/lib/libfreetype.so',
-              '../vendor/lib/libfribidi.so',
-              '../vendor/lib/libgdk_pixbuf-2.0.so',
-              '../vendor/lib/libgif.so',
-              '../vendor/lib/libgio-2.0.so',
-              '../vendor/lib/libgmodule-2.0.so',
-              '../vendor/lib/libgsf-1.so',
-              '../vendor/lib/libgthread-2.0.so',
-              '../vendor/lib/libharfbuzz.so',
-              '../vendor/lib/libjpeg.so',
-              '../vendor/lib/liblcms2.so',
-              '../vendor/lib/liborc-0.4.so',
-              '../vendor/lib/libpango-1.0.so',
-              '../vendor/lib/libpangocairo-1.0.so',
-              '../vendor/lib/libpangoft2-1.0.so',
-              '../vendor/lib/libpixman-1.so',
-              '../vendor/lib/libpng.so',
-              '../vendor/lib/librsvg-2.so',
-              '../vendor/lib/libtiff.so',
-              '../vendor/lib/libwebp.so',
-              '../vendor/lib/libwebpdemux.so',
-              '../vendor/lib/libwebpmux.so',
-              '../vendor/lib/libxml2.so',
-              '../vendor/lib/libz.so',
-              # Ensure runtime linking is relative to sharp.node
-              '-Wl,--disable-new-dtags -Wl,-rpath=\'$${ORIGIN}/../../vendor/lib\''
-            ]
+            'link_settings': {
+              'library_dirs': ['<(sharp_vendor_dir)/lib'],
+              'libraries': [
+                '-l:libvips-cpp.so.42'
+              ],
+              'ldflags': [
+                # Ensure runtime linking is relative to sharp.node
+                '-Wl,-s -Wl,--disable-new-dtags -Wl,-rpath=\'$$ORIGIN/../../vendor/<(vips_version)/lib\''
+              ]
+            }
           }]
         ]
       }]
@@ -171,8 +176,7 @@
     ],
     'xcode_settings': {
       'CLANG_CXX_LANGUAGE_STANDARD': 'c++11',
-      'CLANG_CXX_LIBRARY': 'libc++',
-      'MACOSX_DEPLOYMENT_TARGET': '10.7',
+      'MACOSX_DEPLOYMENT_TARGET': '10.9',
       'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
       'GCC_ENABLE_CPP_RTTI': 'YES',
       'OTHER_CPLUSPLUSFLAGS': [
@@ -189,10 +193,30 @@
               '-Wno-cast-function-type'
             ]
           }],
+          ['target_arch == "arm"', {
+            'cflags_cc': [
+              '-Wno-psabi'
+            ]
+          }],
           ['OS == "win"', {
             'msvs_settings': {
               'VCCLCompilerTool': {
-                'ExceptionHandling': 1
+                'ExceptionHandling': 1,
+                'WholeProgramOptimization': 'true'
+              },
+              'VCLibrarianTool': {
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              },
+              'VCLinkerTool': {
+                'ImageHasSafeExceptionHandlers': 'false',
+                'OptimizeReferences': 2,
+                'EnableCOMDATFolding': 2,
+                'LinkIncremental': 1,
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
               }
             },
             'msvs_disabled_warnings': [

docs/README.md

@@ -0,0 +1,84 @@
+# 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
+
+The features of `mozjpeg` and `pngquant` can be used
+to optimise the file size of JPEG and PNG images respectively,
+without having to invoke separate `imagemin` processes.
+
+Huffman tables are optimised when generating JPEG output images
+without having to use separate command line tools like
+[jpegoptim](https://github.com/tjko/jpegoptim) and
+[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

@@ -18,40 +18,60 @@ 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.
+Ensure the output image has an alpha transparency channel.
+If missing, the added alpha channel will have the specified
+transparency level, defaulting to fully-opaque (1).
+This is a no-op if the image already has an alpha channel.
+
+### Parameters
+
+-   `alpha` **[number][1]** alpha transparency level (0=fully-transparent, 1=fully-opaque) (optional, default `1`)
 
 ### Examples
 
 ```javascript
-sharp('rgb.jpg')
+// rgba.png will be a 4 channel image with a fully-opaque alpha channel
+await sharp('rgb.jpg')
   .ensureAlpha()
-  .toFile('rgba.png', function(err, info) {
-    // rgba.png is a 4 channel image with a fully opaque alpha channel
-  });
+  .toFile('rgba.png')
 ```
 
+```javascript
+// rgba is a 4 channel image with a fully-transparent alpha channel
+const rgba = await sharp(rgb)
+  .ensureAlpha(0)
+  .toBuffer();
+```
+
+-   Throws **[Error][2]** Invalid alpha transparency level
+
 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 band number to extract, or `red`, `green` or `blue` as alternative to `0`, `1` or `2` respectively.
+-   `channel` **([number][1] \| [string][3])** zero-indexed channel/band number to extract, or `red`, `green`, `blue` or `alpha`.
 
 ### Examples
 
 ```javascript
 sharp(input)
   .extractChannel('green')
-  .toFile('input_green.jpg', function(err, info) {
+  .toColourspace('b-w')
+  .toFile('green.jpg', function(err, info) {
     // info.channels === 1
-    // input_green.jpg contains the green channel of the input image
+    // green.jpg is a greyscale image containing the green channel of the input
    });
 ```
 
--   Throws **[Error][3]** Invalid channel
+-   Throws **[Error][2]** Invalid channel
 
 Returns **Sharp** 
 
@@ -65,16 +85,16 @@ Channel ordering follows vips convention:
 -   sRGB: 0: Red, 1: Green, 2: Blue, 3: Alpha.
 -   CMYK: 0: Magenta, 1: Cyan, 2: Yellow, 3: Black, 4: Alpha.
 
-Buffers may be any of the image formats supported by sharp: JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data.
+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]<([String][2] \| [Buffer][5])> | [String][2] \| [Buffer][5])** one or more images (file paths, Buffers).
+-   `images` **([Array][4]<([string][3] \| [Buffer][5])> | [string][3] \| [Buffer][5])** one or more images (file paths, Buffers).
 -   `options` **[Object][6]** image options, see `sharp()` constructor.
 
 
--   Throws **[Error][3]** Invalid parameters
+-   Throws **[Error][2]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -84,7 +104,7 @@ Perform a bitwise boolean operation on all input image channels (bands) to produ
 
 ### Parameters
 
--   `boolOp` **[String][2]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
+-   `boolOp` **[string][3]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
 
 ### Examples
 
@@ -98,15 +118,15 @@ sharp('3-channel-rgb-input.png')
   });
 ```
 
--   Throws **[Error][3]** Invalid parameters
+-   Throws **[Error][2]** 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
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
 
-[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
 [4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
 

docs/api-colour.md

@@ -7,7 +7,7 @@ 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.
+-   `rgb` **([string][1] \| [Object][2])** parsed by the [color][3] module to extract chroma values.
 
 
 -   Throws **[Error][4]** Invalid parameter
@@ -46,8 +46,16 @@ By default output image will be web-friendly sRGB, with additional channels inte
 
 ### Parameters
 
--   `colourspace` **[String][1]?** output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][6]
+-   `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
 
@@ -59,7 +67,7 @@ Alternative spelling of `toColourspace`.
 
 ### Parameters
 
--   `colorspace` **[String][1]?** output colorspace.
+-   `colorspace` **[string][1]?** output colorspace.
 
 
 -   Throws **[Error][4]** Invalid parameters

docs/api-composite.md

@@ -20,7 +20,7 @@ and [https://www.cairographics.org/operators/][2]
 ### Parameters
 
 -   `images` **[Array][3]<[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 bellow)
+    -   `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]?** 
@@ -61,6 +61,10 @@ sharp('input.png')
 
 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/

docs/api-constructor.md

@@ -2,27 +2,48 @@
 
 ## 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][1] \| [String][2])?** if present, can be
-     a Buffer containing JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data, or
-     a String containing the filesystem path to an JPEG, PNG, WebP, GIF, SVG or TIFF image file.
-     JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
--   `options` **[Object][3]?** if present, is an Object with optional attributes.
-    -   `options.failOnError` **[Boolean][4]** by default halt processing and raise an error when loading invalid images.
+-   `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.density` **[Number][5]** number representing the DPI for vector images. (optional, default `72`)
-    -   `options.pages` **[Number][5]** number of pages to extract for multi-page input (GIF, TIFF, PDF), use -1 for all pages. (optional, default `1`)
-    -   `options.page` **[Number][5]** page number to start extracting from for multi-page input (GIF, TIFF, PDF), zero based. (optional, default `0`)
-    -   `options.raw` **[Object][3]?** describes raw pixel input image data. See `raw()` for pixel ordering.
-        -   `options.raw.width` **[Number][5]?** 
-        -   `options.raw.height` **[Number][5]?** 
-        -   `options.raw.channels` **[Number][5]?** 1-4
-    -   `options.create` **[Object][3]?** describes a new image to be created.
-        -   `options.create.width` **[Number][5]?** 
-        -   `options.create.height` **[Number][5]?** 
-        -   `options.create.channels` **[Number][5]?** 3-4
-        -   `options.create.background` **([String][2] \| [Object][3])?** parsed by the [color][6] module to extract values for red, green, blue and alpha.
+    -   `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.subifd` **[number][8]** subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image. (optional, default `-1`)
+    -   `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
 
@@ -63,59 +84,132 @@ sharp({
 .then( ... );
 ```
 
--   Throws **[Error][7]** Invalid parameters
-
-Returns **[Sharp][8]** 
-
-### format
-
-An Object containing nested boolean values representing the available input and output formats/methods.
-
-#### Examples
-
 ```javascript
-console.log(sharp.format);
+// Convert an animated GIF to an animated WebP
+await sharp('in.gif', { animated: true }).toFile('out.webp');
 ```
 
-Returns **[Object][3]** 
-
-### versions
-
-An Object containing the version numbers of libvips and its dependencies.
-
-#### Examples
-
 ```javascript
-console.log(sharp.versions);
+// 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');
 ```
 
-## queue
+```javascript
+// Generate RGB Gaussian noise
+await sharp({
+  create: {
+    width: 300,
+    height: 200,
+    channels: 3,
+    noise: {
+      type: 'gaussian',
+      mean: 128,
+      sigma: 30
+    }
+ }
+}).toFile('noise.png');
+```
 
-An EventEmitter that emits a `change` event when a task is either:
+-   Throws **[Error][10]** Invalid parameters
 
--   queued, waiting for _libuv_ to provide a worker thread
--   complete
+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
-sharp.queue.on('change', function(queueLength) {
-  console.log('Queue contains ' + queueLength + ' task(s)');
-});
+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
 ```
 
-[1]: https://nodejs.org/api/buffer.html
+```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
+});
 
-[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+const promises = [];
 
-[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+promises.push(
+  sharpStream
+    .clone()
+    .jpeg({ quality: 100 })
+    .toFile("originalFile.jpg")
+);
 
-[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+promises.push(
+  sharpStream
+    .clone()
+    .resize({ width: 500 })
+    .jpeg({ quality: 80 })
+    .toFile("optimized-500.jpg")
+);
 
-[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+promises.push(
+  sharpStream
+    .clone()
+    .resize({ width: 500 })
+    .webp({ quality: 80 })
+    .toFile("optimized-500.webp")
+);
 
-[6]: https://www.npmjs.org/package/color
+// https://github.com/sindresorhus/got#gotstreamurl-options
+got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
 
-[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+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) {}
+  });
+```
 
-[8]: #sharp
+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

@@ -1,24 +1,5 @@
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->
 
-## 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
-```
-
-Returns **Sharp** 
-
 ## metadata
 
 Fast access to (uncached) image metadata without decoding any compressed image data.
@@ -35,8 +16,12 @@ A `Promise` is returned when `callback` is not provided.
 -   `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 this PDF image will be.
+-   `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
+-   `subifds`: Number of Sub Image File Directories in an OME-TIFF image
 -   `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
@@ -85,8 +70,10 @@ A `Promise` is returned when `callback` is not provided.
     -   `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`: Value to identify if the image is opaque or transparent, based on the presence and use of alpha channel
+-   `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
 
@@ -103,39 +90,16 @@ image
   });
 ```
 
+```javascript
+const { entropy, sharpness, dominant } = await sharp(input).stats();
+const { r, g, b } = dominant;
+```
+
 Returns **[Promise][5]&lt;[Object][6]>** 
 
-## limitInputPixels
+[1]: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation
 
-Do not process input images where the number of pixels (width x height) exceeds this limit.
-Assumes image dimensions contained in the input metadata can be trusted.
-The default limit is 268402689 (0x3FFF x 0x3FFF) pixels.
-
-### Parameters
-
--   `limit` **([Number][7] \| [Boolean][8])** an integral Number of pixels, zero or false to remove limit, true to use default limit.
-
-
--   Throws **[Error][9]** Invalid limit
-
-Returns **Sharp** 
-
-## sequentialRead
-
-An advanced setting that switches the libvips access method to `VIPS_ACCESS_SEQUENTIAL`.
-This will reduce memory usage and can improve performance on some systems.
-
-The default behaviour _before_ function call is `false`, meaning the libvips access method is not sequential.
-
-### Parameters
-
--   `sequentialRead` **[Boolean][8]**  (optional, default `true`)
-
-Returns **Sharp** 
-
-[1]: https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L636
-
-[2]: https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L672
+[2]: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsBandFormat
 
 [3]: https://www.npmjs.com/package/icc
 
@@ -144,9 +108,3 @@ Returns **Sharp**
 [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/Number
-
-[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-
-[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error

docs/api-operation.md

@@ -21,9 +21,9 @@ for example `rotate(x).extract(y)` will produce a different result to `extract(y
 
 ### Parameters
 
--   `angle` **[Number][1]** angle of rotation. (optional, default `auto`)
+-   `angle` **[number][1]** angle of rotation. (optional, default `auto`)
 -   `options` **[Object][2]?** if present, is an Object with optional attributes.
-    -   `options.background` **([String][3] \| [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
+    -   `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
 
@@ -65,6 +65,61 @@ The use of `flop` implies the removal of the EXIF `Orientation` tag, if any.
 
 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]<[Array][7]<[number][1]>> | [Array][7]<[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.
@@ -74,9 +129,9 @@ Separate control over the level of sharpening in "flat" and "jagged" areas is av
 
 ### 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`)
+-   `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
@@ -90,7 +145,7 @@ When used without parameters the default window is 3x3.
 
 ### Parameters
 
--   `size` **[Number][1]** square mask size: size x size (optional, default `3`)
+-   `size` **[number][1]** square mask size: size x size (optional, default `3`)
 
 
 -   Throws **[Error][5]** Invalid parameters
@@ -105,7 +160,7 @@ 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`.
+-   `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
@@ -114,12 +169,20 @@ Returns **Sharp**
 
 ## flatten
 
-Merge alpha transparency channel, if any, with a background.
+Merge alpha transparency channel, if any, with a background, then remove the alpha channel.
 
 ### Parameters
 
 -   `options` **[Object][2]?** 
-    -   `options.background` **([String][3] \| [Object][2])** background colour, parsed by the [color][4] module, defaults to black. (optional, default `{r:0,g:0,b:0}`)
+    -   `options.background` **([string][3] \| [Object][2])** background colour, parsed by the [color][4] module, defaults to black. (optional, default `{r:0,g:0,b:0}`)
+
+### Examples
+
+```javascript
+await sharp(rgbaInput)
+  .flatten('#F0A703')
+  .toBuffer();
+```
 
 Returns **Sharp** 
 
@@ -135,8 +198,8 @@ Supply a second argument to use a different output gamma value, otherwise the fi
 
 ### 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`)
+-   `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
@@ -180,11 +243,11 @@ 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]<[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`)
+    -   `kernel.width` **[number][1]** width of the kernel in pixels.
+    -   `kernel.height` **[number][1]** width of the kernel in pixels.
+    -   `kernel.kernel` **[Array][7]<[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
 
@@ -208,11 +271,11 @@ Returns **Sharp**
 
 ## threshold
 
-Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+Any pixel value greater than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
 
 ### Parameters
 
--   `threshold` **[Number][1]** a value in the range 0-255 representing the level at which the threshold will be applied. (optional, default `128`)
+-   `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`)
@@ -231,13 +294,13 @@ the selected bitwise boolean `operation` between the corresponding pixels of the
 
 ### 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.
+-   `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]?** 
+        -   `options.raw.width` **[number][1]?** 
+        -   `options.raw.height` **[number][1]?** 
+        -   `options.raw.channels` **[number][1]?** 
 
 
 -   Throws **[Error][5]** Invalid parameters
@@ -250,8 +313,8 @@ 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`)
+-   `a` **[number][1]** multiplier (optional, default `1.0`)
+-   `b` **[number][1]** offset (optional, default `0.0`)
 
 
 -   Throws **[Error][5]** Invalid parameters
@@ -264,8 +327,7 @@ Recomb the image with the specified matrix.
 
 ### Parameters
 
--   `inputMatrix`  
--   `3x3` **[Array][7]<[Array][7]<[Number][1]>>** Recombination matrix
+-   `inputMatrix` **[Array][7]<[Array][7]<[number][1]>>** 3x3 Recombination matrix
 
 ### Examples
 
@@ -287,6 +349,10 @@ sharp(input)
 
 Returns **Sharp** 
 
+**Meta**
+
+-   **since**: 0.21.1
+
 ## modulate
 
 Transforms the image using brightness, saturation and hue rotation.
@@ -294,9 +360,9 @@ 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
+    -   `options.brightness` **[number][1]?** Brightness multiplier
+    -   `options.saturation` **[number][1]?** Saturation multiplier
+    -   `options.hue` **[number][1]?** Degrees for hue rotation
 
 ### Examples
 
@@ -322,6 +388,10 @@ sharp(input)
 
 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

docs/api-output.md

@@ -5,7 +5,7 @@
 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, TIFF, DZI, and libvips' V format supported.
+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.
@@ -15,7 +15,7 @@ A `Promise` is returned when `callback` is not provided.
 
 ### Parameters
 
--   `fileOut` **[String][2]** the path to write the image data to.
+-   `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).
@@ -42,7 +42,7 @@ Returns **[Promise][5]<[Object][6]>** when no callback is provided
 ## toBuffer
 
 Write output to a Buffer.
-JPEG, PNG, WebP, TIFF and RAW output are supported.
+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.
 
@@ -62,7 +62,7 @@ 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`.
+    -   `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
@@ -86,18 +86,40 @@ sharp(input)
   .catch(err => { ... });
 ```
 
+```javascript
+const { data, info } = await sharp('my-image.jpg')
+  // output the raw pixels
+  .raw()
+  .toBuffer({ resolveWithObject: true });
+
+// create a more type safe way to work with the raw pixel data
+// this will not copy the data, instead it will change `data`s underlying ArrayBuffer
+// so `data` and `pixelArray` point to the same memory location
+const pixelArray = new Uint8ClampedArray(data.buffer);
+
+// When you are done changing the pixelArray, sharp takes the `pixelArray` as an input
+const { width, height, channels } = info;
+await sharp(pixelArray, { raw: { width, height, channels } })
+  .toFile('my-changed-image.jpg');
+```
+
 Returns **[Promise][5]<[Buffer][8]>** when no callback is provided
 
 ## withMetadata
 
 Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
-The default behaviour, when `withMetadata` is not used, is to strip all metadata and convert to the device-independent sRGB colour space.
-This will also convert to and add a web-friendly sRGB ICC profile.
+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.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.
+    -   `options.exif` **[Object][6]<[Object][6]>** Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data. (optional, default `{}`)
 
 ### Examples
 
@@ -108,188 +130,30 @@ sharp('input.jpg')
   .then(info => { ... });
 ```
 
+```javascript
+// Set "IFD0-Copyright" in output EXIF metadata
+await sharp(input)
+  .withMetadata({
+    exif: {
+      IFD0: {
+        Copyright: 'Wernham Hogg'
+      }
+    }
+  })
+  .toBuffer();
+```
+
 -   Throws **[Error][4]** Invalid parameters
 
 Returns **Sharp** 
 
-## jpeg
-
-Use these JPEG options for output image.
-
-### 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 when quality <= 90 (optional, default `'4:2:0'`)
-    -   `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 (optional, default `false`)
-    -   `options.optimiseCoding` **[Boolean][7]** optimise Huffman coding tables (optional, default `true`)
-    -   `options.optimizeCoding` **[Boolean][7]** alternative spelling of optimiseCoding (optional, default `true`)
-    -   `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 (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.
-
-### 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, requires libvips compiled with support for libimagequant (optional, default `100`)
-    -   `options.colours` **[Number][9]** maximum number of palette entries, requires libvips compiled with support for libimagequant (optional, default `256`)
-    -   `options.colors` **[Number][9]** alternative spelling of `options.colours`, requires libvips compiled with support for libimagequant (optional, default `256`)
-    -   `options.dither` **[Number][9]** level of Floyd-Steinberg error diffusion, 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.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** 
-
-## 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` **[Boolean][7]** compression options: lzw, deflate, jpeg, ccittfax4 (optional, default `'jpeg'`)
-    -   `options.predictor` **[Boolean][7]** compression predictor options: none, horizontal, float (optional, default `'horizontal'`)
-    -   `options.pyramid` **[Boolean][7]** write an image pyramid (optional, default `false`)
-    -   `options.tile` **[Boolean][7]** write a tiled tiff (optional, default `false`)
-    -   `options.tileWidth` **[Boolean][7]** horizontal tile size (optional, default `256`)
-    -   `options.tileHeight` **[Boolean][7]** vertical tile size (optional, default `256`)
-    -   `options.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.squash` **[Boolean][7]** squash 8-bit images down to 1 bit (optional, default `false`)
-
-### Examples
-
-```javascript
-// Convert SVG input to LZW-compressed, 1 bit per pixel TIFF output
-sharp('input.svg')
-  .tiff({
-    compression: 'lzw',
-    squash: true
-  })
-  .toFile('1-bpp-output.tiff')
-  .then(info => { ... });
-```
-
--   Throws **[Error][4]** Invalid options
-
-Returns **Sharp** 
-
-## heif
-
-Use these HEIF options for output image.
-
-Support for HEIF (HEIC/AVIF) is experimental.
-Do not use this in production systems.
-
-Requires a custom, globally-installed libvips compiled with support for libheif.
-
-Most versions of libheif support only the patent-encumbered HEVC compression format.
-
-### Parameters
-
--   `options` **[Object][6]?** output options
-    -   `options.quality` **[Number][9]** quality, integer 1-100 (optional, default `80`)
-    -   `options.compression` **[Boolean][7]** compression format: hevc, avc, jpeg, av1 (optional, default `'hevc'`)
-    -   `options.lossless` **[Boolean][7]** use lossless compression (optional, default `false`)
-
-
--   Throws **[Error][4]** Invalid options
-
-Returns **Sharp** 
-
-## raw
-
-Force output to be raw, uncompressed uint8 pixel data.
-
-### Examples
-
-```javascript
-// Extract raw RGB pixel data from JPEG input
-const { data, info } = await sharp('input.jpg')
-  .raw()
-  .toBuffer({ resolveWithObject: true });
-```
-
-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
+-   `format` **([string][2] \| [Object][6])** as a string or an Object with an 'id' attribute
 -   `options` **[Object][6]** output options
 
 ### Examples
@@ -305,6 +169,262 @@ const data = await sharp(input)
 
 Returns **Sharp** 
 
+## jpeg
+
+Use these JPEG options for output image.
+
+### 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.mozjpeg` **[boolean][7]** use mozjpeg defaults, equivalent to `{ trellisQuantisation: true, overshootDeringing: true, optimiseScans: true, quantisationTable: 3 }` (optional, default `false`)
+    -   `options.trellisQuantisation` **[boolean][7]** apply trellis quantisation (optional, default `false`)
+    -   `options.overshootDeringing` **[boolean][7]** apply overshoot deringing (optional, default `false`)
+    -   `options.optimiseScans` **[boolean][7]** optimise progressive scans, forces progressive (optional, default `false`)
+    -   `options.optimizeScans` **[boolean][7]** alternative spelling of optimiseScans (optional, default `false`)
+    -   `options.quantisationTable` **[number][9]** quantization table to use, integer 0-8 (optional, default `0`)
+    -   `options.quantizationTable` **[number][9]** alternative spelling of quantisationTable (optional, default `0`)
+    -   `options.force` **[boolean][7]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
+
+### Examples
+
+```javascript
+// Convert any input to very high quality JPEG output
+const data = await sharp(input)
+  .jpeg({
+    quality: 100,
+    chromaSubsampling: '4:4:4'
+  })
+  .toBuffer();
+```
+
+```javascript
+// Use mozjpeg to reduce output JPEG file size (slower)
+const data = await sharp(input)
+  .jpeg({ mozjpeg: true })
+  .toBuffer();
+```
+
+-   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+## png
+
+Use these PNG options for output image.
+
+By default, PNG output is full colour at 8 or 16 bits per pixel.
+Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
+Set `palette` to `true` for slower, indexed PNG output.
+
+### Parameters
+
+-   `options` **[Object][6]?** 
+    -   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
+    -   `options.compressionLevel` **[number][9]** zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest) (optional, default `6`)
+    -   `options.adaptiveFiltering` **[boolean][7]** use adaptive row filtering (optional, default `false`)
+    -   `options.palette` **[boolean][7]** quantise to a palette-based image with alpha transparency support (optional, default `false`)
+    -   `options.quality` **[number][9]** use the lowest number of colours needed to achieve given quality, sets `palette` to `true` (optional, default `100`)
+    -   `options.colours` **[number][9]** maximum number of palette entries, sets `palette` to `true` (optional, default `256`)
+    -   `options.colors` **[number][9]** alternative spelling of `options.colours`, sets `palette` to `true` (optional, default `256`)
+    -   `options.dither` **[number][9]** level of Floyd-Steinberg error diffusion, sets `palette` to `true` (optional, default `1.0`)
+    -   `options.force` **[boolean][7]** force PNG output, otherwise attempt to use input format (optional, default `true`)
+
+### Examples
+
+```javascript
+// Convert any input to full colour PNG output
+const data = await sharp(input)
+  .png()
+  .toBuffer();
+```
+
+```javascript
+// Convert any input to indexed PNG output (slower)
+const data = await sharp(input)
+  .png({ palette: true })
+  .toBuffer();
+```
+
+-   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+## 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]<[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();
+```
+
+```javascript
+// Optimise the file size of an animated WebP
+const outputWebp = await sharp(inputWebp, { animated: true })
+  .webp({ reductionEffort: 6 })
+  .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]<[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.
@@ -316,14 +436,17 @@ Warning: multiple sharp instances concurrently producing tile output can expose
 ### 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][10] 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`, `zoomify` or `google`. (optional, default `'dz'`)
+    -   `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`)
+    -   `options.id` **[string][2]** when `layout` is `iiif`, sets the `@id` attribute of `info.json` (optional, default `'https://example.com/iiif'`)
 
 ### Examples
 
@@ -361,4 +484,8 @@ Returns **Sharp**
 
 [9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
-[10]: https://www.npmjs.org/package/color
+[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

@@ -6,19 +6,21 @@ 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`: Crop to cover both provided dimensions (the default).
--   `contain`: Embed within both provided dimensions.
+-   `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.
+
+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.
+
+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.
@@ -36,8 +38,8 @@ Possible interpolation kernels are:
 
 ### 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.
+-   `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.
@@ -114,6 +116,15 @@ sharp(input)
   });
 ```
 
+```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** 
@@ -125,11 +136,11 @@ 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` **([number][8] \| [Object][9])** single pixel count to add to all edges or an Object with per-edge counts
+    -   `extend.top` **[number][8]**  (optional, default `0`)
+    -   `extend.left` **[number][8]**  (optional, default `0`)
+    -   `extend.bottom` **[number][8]**  (optional, default `0`)
+    -   `extend.right` **[number][8]**  (optional, default `0`)
     -   `extend.background` **([String][10] \| [Object][9])** background colour, parsed by the [color][11] module, defaults to black without transparency. (optional, default `{r:0,g:0,b:0,alpha:1}`)
 
 ### Examples
@@ -149,13 +160,23 @@ sharp(input)
   ...
 ```
 
+```javascript
+// Add a row of 10 red pixels to the bottom
+sharp(input)
+  .extend({
+    bottom: 10,
+    background: 'red'
+  })
+  ...
+```
+
 -   Throws **[Error][13]** Invalid parameters
 
 Returns **Sharp** 
 
 ## extract
 
-Extract a region of the image.
+Extract/crop a region of the image.
 
 -   Use `extract` before `resize` for pre-resize extraction.
 -   Use `extract` after `resize` for post-resize extraction.
@@ -164,10 +185,10 @@ Extract a region of the image.
 ### 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
+    -   `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
 
@@ -198,11 +219,12 @@ Returns **Sharp**
 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 will contain `trimOffsetLeft` and `trimOffsetTop` properties.
+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`)
+-   `threshold` **[number][8]** the allowed difference from the top-left pixel, a number greater than zero. (optional, default `10`)
 
 
 -   Throws **[Error][13]** Invalid parameters

docs/api-utility.md

@@ -1,5 +1,57 @@
 <!-- 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.
@@ -9,10 +61,10 @@ useful for determining how much working memory is required for a particular task
 
 ### Parameters
 
--   `options` **([Object][1] \| [Boolean][2])** Object with the following attributes, or Boolean where true uses default cache settings and false removes all caching (optional, default `true`)
-    -   `options.memory` **[Number][3]** is the maximum memory in MB to use for this cache (optional, default `50`)
-    -   `options.files` **[Number][3]** is the maximum number of files to hold open (optional, default `20`)
-    -   `options.items` **[Number][3]** is the maximum number of operations to cache (optional, default `100`)
+-   `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
 
@@ -32,8 +84,12 @@ Returns **[Object][1]**
 
 Gets or, when a concurrency is provided, sets
 the number of threads _libvips'_ should create to process each image.
-The default value is the number of CPU cores.
-A value of `0` will reset to this default.
+
+The default value is the number of CPU cores,
+except when using glibc-based Linux without jemalloc,
+where the default is `1` to help reduce memory fragmentation.
+
+A value of `0` will reset this to the number of CPU cores.
 
 The maximum number of images that can be processed in parallel
 is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
@@ -42,7 +98,7 @@ This method always returns the current concurrency.
 
 ### Parameters
 
--   `concurrency` **[Number][3]?** 
+-   `concurrency` **[number][11]?** 
 
 ### Examples
 
@@ -52,7 +108,22 @@ sharp.concurrency(2); // 2
 sharp.concurrency(0); // 4
 ```
 
-Returns **[Number][3]** concurrency
+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
 
@@ -79,7 +150,7 @@ by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM N
 
 ### Parameters
 
--   `simd` **[Boolean][2]**  (optional, default `true`)
+-   `simd` **[boolean][10]**  (optional, default `true`)
 
 ### Examples
 
@@ -93,10 +164,26 @@ const simd = sharp.simd(false);
 // prevent libvips from using liborc at runtime
 ```
 
-Returns **[Boolean][2]** 
+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/Boolean
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
-[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[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/changelog.md

@@ -1,10 +1,302 @@
 # Changelog
 
-### v0.23 - "*vision*"
+## v0.28 - *bijou*
+
+Requires libvips v8.10.6
+
+### v0.28.1 - 5th April 2021
+
+* Ensure all installation errors are logged with a more obvious prefix.
+
+* Allow `withMetadata` to set and update EXIF metadata.
+  [#650](https://github.com/lovell/sharp/issues/650)
+
+* Add support for OME-TIFF Sub Image File Directories (subIFD).
+  [#2557](https://github.com/lovell/sharp/issues/2557)
+
+* Allow `ensureAlpha` to set the alpha transparency level.
+  [#2634](https://github.com/lovell/sharp/issues/2634)
+
+### v0.28.0 - 29th March 2021
+
+* Prebuilt binaries now include mozjpeg and libimagequant (BSD 2-Clause).
+
+* Prebuilt binaries limit AVIF support to the most common 8-bit depth.
+
+* Add `mozjpeg` option to `jpeg` method, sets mozjpeg defaults.
+
+* Reduce the default PNG `compressionLevel` to the more commonly used 6.
+
+* Reduce concurrency on glibc-based Linux when using the default memory allocator to help prevent fragmentation.
+
+* Default missing edge properties of extend operation to zero.
+  [#2578](https://github.com/lovell/sharp/issues/2578)
+
+* Ensure composite does not clip top and left offsets.
+  [#2594](https://github.com/lovell/sharp/pull/2594)
+  [@SHG42](https://github.com/SHG42)
+
+* Improve error handling of network failure at install time.
+  [#2608](https://github.com/lovell/sharp/pull/2608)
+  [@abradley](https://github.com/abradley)
+
+* Ensure `@id` attribute can be set for IIIF tile-based output.
+  [#2612](https://github.com/lovell/sharp/issues/2612)
+  [@edsilv](https://github.com/edsilv)
+
+* Ensure composite replicates the correct number of tiles for centred gravities.
+  [#2626](https://github.com/lovell/sharp/issues/2626)
+
+## v0.27 - *avif*
+
+Requires libvips v8.10.5
+
+### v0.27.2 - 22nd February 2021
+
+* macOS: Prevent use of globally-installed ARM64 libvips with Rosetta x64 emulation.
+  [#2460](https://github.com/lovell/sharp/issues/2460)
+
+* Linux (musl): Prevent use of prebuilt linuxmusl-x64 binaries with musl >= 1.2.0.
+  [#2570](https://github.com/lovell/sharp/issues/2570)
+
+* Improve 16-bit grey+alpha support by using libvips' `has_alpha` detection.
+  [#2569](https://github.com/lovell/sharp/issues/2569)
+
+* Allow the use of non lower case extensions with `toFormat`.
+  [#2581](https://github.com/lovell/sharp/pull/2581)
+  [@florian-busch](https://github.com/florian-busch)
+
+* Allow use of `recomb` operation with single channel input.
+  [#2584](https://github.com/lovell/sharp/issues/2584)
+
+### v0.27.1 - 27th January 2021
+
+* Ensure TIFF is cast when using float predictor.
+  [#2502](https://github.com/lovell/sharp/pull/2502)
+  [@randyridge](https://github.com/randyridge)
+
+* Add support for Uint8Array and Uint8ClampedArray input.
+  [#2511](https://github.com/lovell/sharp/pull/2511)
+  [@leon](https://github.com/leon)
+
+* Revert: ensure all platforms use fontconfig for font rendering.
+  [#2515](https://github.com/lovell/sharp/issues/2515)
+
+* Expose libvips gaussnoise operation to allow creation of Gaussian noise.
+  [#2527](https://github.com/lovell/sharp/pull/2527)
+  [@alza54](https://github.com/alza54)
+
+### v0.27.0 - 22nd December 2020
+
+* Add support for AVIF to prebuilt binaries.
+
+* Remove experimental status from `heif` output, defaults are now AVIF-centric.
+
+* Allow negative top/left offsets for composite operation.
+  [#2391](https://github.com/lovell/sharp/pull/2391)
+  [@CurosMJ](https://github.com/CurosMJ)
+
+* Ensure all platforms use fontconfig for font rendering.
+  [#2399](https://github.com/lovell/sharp/issues/2399)
+
+## v0.26 - *zoom*
+
+Requires libvips v8.10.0
+
+### v0.26.3 - 16th November 2020
+
+* Expose libvips' affine operation.
+  [#2336](https://github.com/lovell/sharp/pull/2336)
+  [@guillevc](https://github.com/guillevc)
+
+* Fallback to tar.gz for prebuilt libvips when Brotli not available.
+  [#2412](https://github.com/lovell/sharp/pull/2412)
+  [@ascorbic](https://github.com/ascorbic)
+
+### v0.26.2 - 14th October 2020
+
+* Add support for EXR input. Requires libvips compiled with OpenEXR.
+  [#698](https://github.com/lovell/sharp/issues/698)
+
+* Ensure support for yarn v2.
+  [#2379](https://github.com/lovell/sharp/pull/2379)
+  [@jalovatt](https://github.com/jalovatt)
+
+* Add centre/center option to tile-based output.
+  [#2397](https://github.com/lovell/sharp/pull/2397)
+  [@beig](https://github.com/beig)
+
+### v0.26.1 - 20th September 2020
+
+* Ensure correct pageHeight when verifying multi-page image dimensions.
+  [#2343](https://github.com/lovell/sharp/pull/2343)
+  [@derom](https://github.com/derom)
+
+* Allow input density range up to 100000 DPI.
+  [#2348](https://github.com/lovell/sharp/pull/2348)
+  [@stefanprobst](https://github.com/stefanprobst)
+
+* Ensure animation-related properties can be set for Stream-based input.
+  [#2369](https://github.com/lovell/sharp/pull/2369)
+  [@AcrylicShrimp](https://github.com/AcrylicShrimp)
+
+* Ensure `stats` can be calculated for 1x1 input.
+  [#2372](https://github.com/lovell/sharp/issues/2372)
+
+* Ensure animated GIF output is optimised.
+  [#2376](https://github.com/lovell/sharp/issues/2376)
+
+### v0.26.0 - 25th August 2020
+
+* Prebuilt libvips binaries are now statically-linked and Brotli-compressed, requiring Node.js 10.16.0+.
+
+* TIFF output `squash` is replaced by `bitdepth` to reduce to 1, 2 or 4 bit.
+
+* JPEG output `quality` >= 90 no longer automatically sets `chromaSubsampling` to `4:4:4`.
+
+* Add most `dominant` colour to image `stats`.
+  [#640](https://github.com/lovell/sharp/issues/640)
+
+* Add support for animated GIF (requires \*magick) and WebP output.
+  [#2012](https://github.com/lovell/sharp/pull/2012)
+  [@deftomat](https://github.com/deftomat)
+
+* Add support for libvips ImageMagick v7 loaders.
+  [#2258](https://github.com/lovell/sharp/pull/2258)
+  [@vouillon](https://github.com/vouillon)
+
+* Allow multi-page input via \*magick.
+  [#2259](https://github.com/lovell/sharp/pull/2259)
+  [@vouillon](https://github.com/vouillon)
+
+* Add support to `withMetadata` for custom ICC profile.
+  [#2271](https://github.com/lovell/sharp/pull/2271)
+  [@roborourke](https://github.com/roborourke)
+
+* Ensure prebuilt binaries for ARM default to v7 when using Electron.
+  [#2292](https://github.com/lovell/sharp/pull/2292)
+  [@diegodev3](https://github.com/diegodev3)
+
+## v0.25 - *yield*
+
+Requires libvips v8.9.1
+
+### v0.25.4 - 12th June 2020
+
+* Allow libvips binary location override where version is appended.
+  [#2217](https://github.com/lovell/sharp/pull/2217)
+  [@malice00](https://github.com/malice00)
+
+* Enable PNG palette when setting quality, colours, colors or dither.
+  [#2226](https://github.com/lovell/sharp/pull/2226)
+  [@romaleev](https://github.com/romaleev)
+
+* Add `level` constructor option to use a specific level of a multi-level image.
+  Expose `levels` metadata for multi-level images.
+  [#2222](https://github.com/lovell/sharp/issues/2222)
+
+* Add support for named `alpha` channel to `extractChannel` operation.
+  [#2138](https://github.com/lovell/sharp/issues/2138)
+
+* Add experimental `sharpness` calculation to `stats()` response.
+  [#2251](https://github.com/lovell/sharp/issues/2251)
+
+* Emit `warning` event for non-critical processing problems.
+  [#2032](https://github.com/lovell/sharp/issues/2032)
+
+### v0.25.3 - 17th May 2020
+
+* Ensure libvips is initialised only once, improves worker thread safety.
+  [#2143](https://github.com/lovell/sharp/issues/2143)
+
+* Ensure npm platform flag is respected when copying DLLs.
+  [#2188](https://github.com/lovell/sharp/pull/2188)
+  [@dimadeveatii](https://github.com/dimadeveatii)
+
+* Allow SVG input with large inline images to be parsed.
+  [#2195](https://github.com/lovell/sharp/issues/2195)
+
+### v0.25.2 - 20th March 2020
+
+* Provide prebuilt binaries for Linux ARM64v8.
+
+* Add IIIF layout support to tile-based output.
+  [#2098](https://github.com/lovell/sharp/pull/2098)
+  [@edsilv](https://github.com/edsilv)
+
+* Ensure input options are consistently and correctly detected.
+  [#2118](https://github.com/lovell/sharp/issues/2118)
+
+* Ensure N-API prebuilt binaries work on RHEL7 and its derivatives.
+  [#2119](https://github.com/lovell/sharp/issues/2119)
+
+* Ensure AsyncWorker options are persisted.
+  [#2130](https://github.com/lovell/sharp/issues/2130)
+
+### v0.25.1 - 7th March 2020
+
+* Ensure prebuilt binaries are fetched based on N-API version.
+  [#2117](https://github.com/lovell/sharp/issues/2117)
+
+### v0.25.0 - 7th March 2020
+
+* Remove `limitInputPixels` and `sequentialRead` previously deprecated in v0.24.0.
+
+* Migrate internals to N-API.
+  [#1282](https://github.com/lovell/sharp/issues/1282)
+
+* Add support for 32-bit Windows.
+  [#2088](https://github.com/lovell/sharp/issues/2088)
+
+* Ensure correct ordering of rotate-then-trim operations.
+  [#2087](https://github.com/lovell/sharp/issues/2087)
+
+* Ensure composite accepts `limitInputPixels` and `sequentialRead` input options.
+  [#2099](https://github.com/lovell/sharp/issues/2099)
+
+## v0.24 - "*wit*"
+
+Requires libvips v8.9.0.
+
+### v0.24.1 - 15<sup>th</sup> February 2020
+
+* Prevent use of sequentialRead for EXIF-based rotate operation.
+  [#2042](https://github.com/lovell/sharp/issues/2042)
+
+* Ensure RGBA LZW TIFF returns correct channel count.
+  [#2064](https://github.com/lovell/sharp/issues/2064)
+
+### v0.24.0 - 16<sup>th</sup> January 2020
+
+* Drop support for Node.js 8.
+  [#1910](https://github.com/lovell/sharp/issues/1910)
+
+* Drop support for undefined input where options also provided.
+  [#1768](https://github.com/lovell/sharp/issues/1768)
+
+* Move `limitInputPixels` and `sequentialRead` to input options, deprecating functions of the same name.
+
+* Expose `delay` and `loop` metadata for animated images.
+  [#1905](https://github.com/lovell/sharp/issues/1905)
+
+* Ensure correct colour output for 16-bit, 2-channel PNG input with ICC profile.
+  [#2013](https://github.com/lovell/sharp/issues/2013)
+
+* Prevent use of sequentialRead for rotate operations.
+  [#2016](https://github.com/lovell/sharp/issues/2016)
+
+* Correctly bind max width and height values when using withoutEnlargement.
+  [#2024](https://github.com/lovell/sharp/pull/2024)
+  [@BrychanOdlum](https://github.com/BrychanOdlum)
+
+* Add support for input with 16-bit RGB profile.
+  [#2037](https://github.com/lovell/sharp/issues/2037)
+
+## v0.23 - "*vision*"
 
 Requires libvips v8.8.1.
 
-#### v0.23.4 - 5<sup>th</sup> December 2019
+### v0.23.4 - 5<sup>th</sup> December 2019
 
 * Handle zero-length Buffer objects when using Node.js v13.2.0+.
 
@@ -14,7 +306,7 @@ Requires libvips v8.8.1.
 * Improve thread safety by using copy-on-write when updating metadata.
   [#1986](https://github.com/lovell/sharp/issues/1986)
 
-#### v0.23.3 - 17<sup>th</sup> November 2019
+### v0.23.3 - 17<sup>th</sup> November 2019
 
 * Ensure `trim` operation supports images contained in the alpha channel.
   [#1597](https://github.com/lovell/sharp/issues/1597)
@@ -30,7 +322,7 @@ Requires libvips v8.8.1.
 * Ensure `modulate` and other colour-based operations can co-exist.
   [#1958](https://github.com/lovell/sharp/issues/1958)
 
-#### v0.23.2 - 28<sup>th</sup> October 2019
+### v0.23.2 - 28<sup>th</sup> October 2019
 
 * Add `background` option to tile output operation.
   [#1924](https://github.com/lovell/sharp/pull/1924)
@@ -40,7 +332,7 @@ Requires libvips v8.8.1.
   [#1932](https://github.com/lovell/sharp/pull/1932)
   [@MayhemYDG](https://github.com/MayhemYDG)
 
-#### v0.23.1 - 26<sup>th</sup> September 2019
+### v0.23.1 - 26<sup>th</sup> September 2019
 
 * Ensure `sharp.format.vips` is present and correct (filesystem only).
   [#1813](https://github.com/lovell/sharp/issues/1813)
@@ -62,7 +354,7 @@ Requires libvips v8.8.1.
 
 * Ensure image is at least 3x3 pixels before attempting trim operation.
 
-#### v0.23.0 - 29<sup>th</sup> July 2019
+### v0.23.0 - 29<sup>th</sup> July 2019
 
 * Remove `overlayWith` previously deprecated in v0.22.0.
 
@@ -92,11 +384,11 @@ Requires libvips v8.8.1.
   [#1755](https://github.com/lovell/sharp/pull/1755)
   [@iovdin](https://github.com/iovdin)
 
-### v0.22 - "*uptake*"
+## v0.22 - "*uptake*"
 
 Requires libvips v8.7.4.
 
-#### v0.22.1 - 25<sup>th</sup> April 2019
+### v0.22.1 - 25<sup>th</sup> April 2019
 
 * Add `modulate` operation for brightness, saturation and hue.
   [#1601](https://github.com/lovell/sharp/pull/1601)
@@ -109,7 +401,7 @@ Requires libvips v8.7.4.
 * Add support for Node 12.
   [#1668](https://github.com/lovell/sharp/issues/1668)
 
-#### v0.22.0 - 18<sup>th</sup> March 2019
+### v0.22.0 - 18<sup>th</sup> March 2019
 
 * Remove functions previously deprecated in v0.21.0:
     `background`, `crop`, `embed`, `ignoreAspectRatio`, `max`, `min` and `withoutEnlargement`.
@@ -127,18 +419,18 @@ Requires libvips v8.7.4.
   [#1595](https://github.com/lovell/sharp/pull/1595)
   [@ramiel](https://github.com/ramiel)
 
-### v0.21 - "*teeth*"
+## v0.21 - "*teeth*"
 
 Requires libvips v8.7.0.
 
-#### v0.21.3 - 19<sup>th</sup> January 2019
+### v0.21.3 - 19<sup>th</sup> January 2019
 
 * Input image decoding now fails fast, set `failOnError` to change this behaviour.
 
 * Failed filesystem-based input now separates missing file and invalid format errors.
   [#1542](https://github.com/lovell/sharp/issues/1542)
 
-#### v0.21.2 - 13<sup>th</sup> January 2019
+### v0.21.2 - 13<sup>th</sup> January 2019
 
 * Ensure all metadata is removed from PNG output unless `withMetadata` used.
 
@@ -163,7 +455,7 @@ Requires libvips v8.7.0.
 * Ensure forced output format applied correctly when output chaining.
   [#1528](https://github.com/lovell/sharp/issues/1528)
 
-#### v0.21.1 - 7<sup>th</sup> December 2018
+### v0.21.1 - 7<sup>th</sup> December 2018
 
 * Install: support `sharp_dist_base_url` npm config, like existing `SHARP_DIST_BASE_URL`.
   [#1422](https://github.com/lovell/sharp/pull/1422)
@@ -192,7 +484,7 @@ Requires libvips v8.7.0.
   [#1483](https://github.com/lovell/sharp/pull/1483)
   [@mbklein](https://github.com/mbklein)
 
-#### v0.21.0 - 4<sup>th</sup> October 2018
+### v0.21.0 - 4<sup>th</sup> October 2018
 
 * Deprecate the following resize-related functions:
     `crop`, `embed`, `ignoreAspectRatio`, `max`, `min` and `withoutEnlargement`.
@@ -229,11 +521,11 @@ Requires libvips v8.7.0.
   [#1385](https://github.com/lovell/sharp/pull/1385)
   [@freezy](https://github.com/freezy)
 
-### v0.20 - "*prebuild*"
+## v0.20 - "*prebuild*"
 
 Requires libvips v8.6.1.
 
-#### v0.20.8 - 5<sup>th</sup> September 2018
+### v0.20.8 - 5<sup>th</sup> September 2018
 
 * Avoid race conditions when creating directories during installation.
   [#1358](https://github.com/lovell/sharp/pull/1358)
@@ -243,12 +535,12 @@ Requires libvips v8.6.1.
   [#1362](https://github.com/lovell/sharp/pull/1362)
   [@aeirola](https://github.com/aeirola)
 
-#### v0.20.7 - 21<sup>st</sup> August 2018
+### v0.20.7 - 21<sup>st</sup> August 2018
 
 * Use copy+unlink if rename operation fails during installation.
   [#1345](https://github.com/lovell/sharp/issues/1345)
 
-#### v0.20.6 - 20<sup>th</sup> August 2018
+### v0.20.6 - 20<sup>th</sup> August 2018
 
 * Add removeAlpha operation to remove alpha channel, if any.
   [#1248](https://github.com/lovell/sharp/issues/1248)
@@ -279,13 +571,13 @@ Requires libvips v8.6.1.
 
 * Add experimental entropy field to stats response.
 
-#### v0.20.5 - 27<sup>th</sup> June 2018
+### v0.20.5 - 27<sup>th</sup> June 2018
 
 * Expose libjpeg optimize_coding flag.
   [#1265](https://github.com/lovell/sharp/pull/1265)
   [@tomlokhorst](https://github.com/tomlokhorst)
 
-#### v0.20.4 - 20<sup>th</sup> June 2018
+### v0.20.4 - 20<sup>th</sup> June 2018
 
 * Prevent possible rounding error when using shrink-on-load and 90/270 degree rotation.
   [#1241](https://github.com/lovell/sharp/issues/1241)
@@ -295,13 +587,13 @@ Requires libvips v8.6.1.
   [#1257](https://github.com/lovell/sharp/issues/1257)
   [@jeremychone](https://github.com/jeremychone)
 
-#### v0.20.3 - 29<sup>th</sup> May 2018
+### v0.20.3 - 29<sup>th</sup> May 2018
 
 * Fix tint operation by ensuring LAB interpretation and allowing negative values.
   [#1235](https://github.com/lovell/sharp/issues/1235)
   [@wezside](https://github.com/wezside)
 
-#### v0.20.2 - 28<sup>th</sup> April 2018
+### v0.20.2 - 28<sup>th</sup> April 2018
 
 * Add tint operation to set image chroma.
   [#825](https://github.com/lovell/sharp/pull/825)
@@ -319,7 +611,7 @@ Requires libvips v8.6.1.
   [#1208](https://github.com/lovell/sharp/pull/1208)
   [@woolite64](https://github.com/woolite64)
 
-#### v0.20.1 - 17<sup>th</sup> March 2018
+### v0.20.1 - 17<sup>th</sup> March 2018
 
 * Improve installation experience when a globally-installed libvips below the minimum required version is found.
   [#1148](https://github.com/lovell/sharp/issues/1148)
@@ -332,16 +624,16 @@ Requires libvips v8.6.1.
   [#1161](https://github.com/lovell/sharp/pull/1161)
   [@BiancoA](https://github.com/BiancoA)
 
-#### v0.20.0 - 5<sup>th</sup> March 2018
+### v0.20.0 - 5<sup>th</sup> March 2018
 
 * Add support for prebuilt sharp binaries on common platforms.
   [#186](https://github.com/lovell/sharp/issues/186)
 
-### v0.19 - "*suit*"
+## v0.19 - "*suit*"
 
 Requires libvips v8.6.1.
 
-#### v0.19.1 - 24<sup>th</sup> February 2018
+### v0.19.1 - 24<sup>th</sup> February 2018
 
 * Expose libvips' linear transform feature.
   [#1024](https://github.com/lovell/sharp/pull/1024)
@@ -355,7 +647,7 @@ Requires libvips v8.6.1.
   [#1134](https://github.com/lovell/sharp/issues/1134)
   [@pieh](https://github.com/pieh)
 
-#### v0.19.0 - 11<sup>th</sup> January 2018
+### v0.19.0 - 11<sup>th</sup> January 2018
 
 * Expose offset coordinates of strategy-based crop.
   [#868](https://github.com/lovell/sharp/issues/868)
@@ -399,17 +691,17 @@ Requires libvips v8.6.1.
 
 * TIFF output: switch default predictor from 'none' to 'horizontal' to match libvips' behaviour.
 
-### v0.18 - "*ridge*"
+## v0.18 - "*ridge*"
 
 Requires libvips v8.5.5.
 
-#### v0.18.4 - 18<sup>th</sup> September 2017
+### v0.18.4 - 18<sup>th</sup> September 2017
 
 * Ensure input Buffer really is marked as Persistent, prevents mark-sweep GC.
   [#950](https://github.com/lovell/sharp/issues/950)
   [@lfdoherty](https://github.com/lfdoherty)
 
-#### v0.18.3 - 13<sup>th</sup> September 2017
+### v0.18.3 - 13<sup>th</sup> September 2017
 
 * Skip shrink-on-load when trimming.
   [#888](https://github.com/lovell/sharp/pull/888)
@@ -419,7 +711,7 @@ Requires libvips v8.5.5.
   [#945](https://github.com/lovell/sharp/pull/945)
   [@pbomb](https://github.com/pbomb)
 
-#### v0.18.2 - 1<sup>st</sup> July 2017
+### v0.18.2 - 1<sup>st</sup> July 2017
 
 * Expose libvips' xres and yres properties for TIFF output.
   [#828](https://github.com/lovell/sharp/pull/828)
@@ -436,13 +728,13 @@ Requires libvips v8.5.5.
   [#857](https://github.com/lovell/sharp/pull/857)
   [@ekremkaraca](https://github.com/ekremkaraca)
 
-#### v0.18.1 - 30<sup>th</sup> May 2017
+### v0.18.1 - 30<sup>th</sup> May 2017
 
 * Remove regression from #781 that could cause incorrect shrink calculation.
   [#831](https://github.com/lovell/sharp/issues/831)
   [@suprMax](https://github.com/suprMax)
 
-#### v0.18.0 - 30<sup>th</sup> May 2017
+### v0.18.0 - 30<sup>th</sup> May 2017
 
 * Remove the previously-deprecated output format "option" functions:
     quality, progressive, compressionLevel, withoutAdaptiveFiltering,
@@ -500,11 +792,11 @@ Requires libvips v8.5.5.
   [#814](https://github.com/lovell/sharp/pull/814)
   [@jingsam](https://github.com/jingsam)
 
-### v0.17 - "*quill*"
+## v0.17 - "*quill*"
 
 Requires libvips v8.4.2.
 
-#### v0.17.3 - 1<sup>st</sup> April 2017
+### v0.17.3 - 1<sup>st</sup> April 2017
 
 * Allow toBuffer to optionally resolve a Promise with both info and data.
   [#143](https://github.com/lovell/sharp/issues/143)
@@ -522,7 +814,7 @@ Requires libvips v8.4.2.
   [#738](https://github.com/lovell/sharp/pull/738)
   [@kristojorg](https://github.com/kristojorg)
 
-#### v0.17.2 - 11<sup>th</sup> February 2017
+### v0.17.2 - 11<sup>th</sup> February 2017
 
 * Ensure Readable side of Stream can start flowing after Writable side has finished.
   [#671](https://github.com/lovell/sharp/issues/671)
@@ -532,7 +824,7 @@ Requires libvips v8.4.2.
   [#685](https://github.com/lovell/sharp/pull/685)
   [@rnanwani](https://github.com/rnanwani)
 
-#### v0.17.1 - 15<sup>th</sup> January 2017
+### v0.17.1 - 15<sup>th</sup> January 2017
 
 * Improve error messages for invalid parameters.
   [@spikeon](https://github.com/spikeon)
@@ -545,7 +837,7 @@ Requires libvips v8.4.2.
   [@wangzhiwei1888](https://github.com/wangzhiwei1888)
   [#679](https://github.com/lovell/sharp/issues/679)
 
-#### v0.17.0 - 11<sup>th</sup> December 2016
+### v0.17.0 - 11<sup>th</sup> December 2016
 
 * Drop support for versions of Node prior to v4.
 
@@ -582,17 +874,17 @@ Requires libvips v8.4.2.
   [#646](https://github.com/lovell/sharp/issues/646)
   [@DaGaMs](https://github.com/DaGaMs)
 
-### v0.16 - "*pencil*"
+## v0.16 - "*pencil*"
 
 Requires libvips v8.3.3
 
-#### v0.16.2 - 22<sup>nd</sup> October 2016
+### v0.16.2 - 22<sup>nd</sup> October 2016
 
 * Restrict readelf usage to Linux only when detecting global libvips version.
   [#602](https://github.com/lovell/sharp/issues/602)
   [@caoko](https://github.com/caoko)
 
-#### v0.16.1 - 13<sup>th</sup> October 2016
+### v0.16.1 - 13<sup>th</sup> October 2016
 
 * C++11 ABI version is now auto-detected, remove sharp-cxx11 installation flag.
 
@@ -611,7 +903,7 @@ Requires libvips v8.3.3
   [#566](https://github.com/lovell/sharp/issues/566)
   [@Nateowami](https://github.com/Nateowami)
 
-#### v0.16.0 - 18<sup>th</sup> August 2016
+### v0.16.0 - 18<sup>th</sup> August 2016
 
 * Add pre-compiled libvips for OS X, ARMv7 and ARMv8.
   [#312](https://github.com/lovell/sharp/issues/312)
@@ -651,11 +943,11 @@ Requires libvips v8.3.3
 * Remove deprecated interpolateWith method - use resize(w, h, { interpolator: ... })
   [#310](https://github.com/lovell/sharp/issues/310)
 
-### v0.15 - "*outfit*"
+## v0.15 - "*outfit*"
 
 Requires libvips v8.3.1
 
-#### v0.15.1 - 12<sup>th</sup> July 2016
+### v0.15.1 - 12<sup>th</sup> July 2016
 
 * Concat Stream-based input in single operation for ~+3% perf and less GC.
   [#429](https://github.com/lovell/sharp/issues/429)
@@ -721,7 +1013,7 @@ Requires libvips v8.3.1
   [#501](https://github.com/lovell/sharp/pull/501)
   [@mhirsch](https://github.com/mhirsch)
 
-#### v0.15.0 - 21<sup>st</sup> May 2016
+### v0.15.0 - 21<sup>st</sup> May 2016
 
 * Use libvips' new Lanczos 3 kernel as default for image reduction.
   Deprecate interpolateWith method, now provided as a resize option.
@@ -739,11 +1031,11 @@ Requires libvips v8.3.1
   [#413](https://github.com/lovell/sharp/issues/413)
   [@jardakotesovec](https://github.com/jardakotesovec)
 
-### v0.14 - "*needle*"
+## v0.14 - "*needle*"
 
 Requires libvips v8.2.3
 
-#### v0.14.1 - 16<sup>th</sup> April 2016
+### v0.14.1 - 16<sup>th</sup> April 2016
 
 * Allow removal of limitation on input pixel count via limitInputPixels. Use with care.
   [#250](https://github.com/lovell/sharp/issues/250)
@@ -767,7 +1059,7 @@ Requires libvips v8.2.3
   [#412](https://github.com/lovell/sharp/issues/412)
   [@nouh](https://github.com/nouh)
 
-#### v0.14.0 - 2<sup>nd</sup> April 2016
+### v0.14.0 - 2<sup>nd</sup> April 2016
 
 * Add ability to extend (pad) the edges of an image.
   [#128](https://github.com/lovell/sharp/issues/128)
@@ -804,17 +1096,17 @@ Requires libvips v8.2.3
 * Remove deprecated style of calling extract API. Breaks calls using positional arguments.
   [#276](https://github.com/lovell/sharp/issues/276)
 
-### v0.13 - "*mind*"
+## v0.13 - "*mind*"
 
 Requires libvips v8.2.2
 
-#### v0.13.1 - 27<sup>th</sup> February 2016
+### v0.13.1 - 27<sup>th</sup> February 2016
 
 * Fix embedding onto transparent backgrounds; regression introduced in v0.13.0.
   [#366](https://github.com/lovell/sharp/issues/366)
   [@diegocsandrim](https://github.com/diegocsandrim)
 
-#### v0.13.0 - 15<sup>th</sup> February 2016
+### v0.13.0 - 15<sup>th</sup> February 2016
 
 * Improve vector image support by allowing control of density/DPI.
   Switch pre-built libs from Imagemagick to Graphicsmagick.
@@ -859,11 +1151,11 @@ Requires libvips v8.2.2
 
 * Add support for gamma correction of images with an alpha channel.
 
-### v0.12 - "*look*"
+## v0.12 - "*look*"
 
 Requires libvips v8.2.0
 
-#### v0.12.2 - 16<sup>th</sup> January 2016
+### v0.12.2 - 16<sup>th</sup> January 2016
 
 * Upgrade libvips to v8.2.0 for improved vips_shrink.
 
@@ -881,7 +1173,7 @@ Requires libvips v8.2.0
   [#331](https://github.com/lovell/sharp/issues/331)
   [@dtoubelis](https://github.com/dtoubelis)
 
-#### v0.12.1 - 12<sup>th</sup> December 2015
+### v0.12.1 - 12<sup>th</sup> December 2015
 
 * Allow use of SIMD vector instructions (via liborc) to be toggled on/off.
   [#172](https://github.com/lovell/sharp/issues/172)
@@ -894,7 +1186,7 @@ Requires libvips v8.2.0
 
 * Use the NPM-configured HTTPS proxy, if any, for binary downloads.
 
-#### v0.12.0 - 23<sup>rd</sup> November 2015
+### v0.12.0 - 23<sup>rd</sup> November 2015
 
 * Bundle pre-compiled libvips and its dependencies for 64-bit Linux and Windows.
   [#42](https://github.com/lovell/sharp/issues/42)
@@ -930,9 +1222,9 @@ Requires libvips v8.2.0
   [#309](https://github.com/lovell/sharp/pull/309)
   [@papandreou](https://github.com/papandreou)
 
-### v0.11 - "*knife*"
+## v0.11 - "*knife*"
 
-#### v0.11.4 - 5<sup>th</sup> November 2015
+### v0.11.4 - 5<sup>th</sup> November 2015
 
 * Add corners, e.g. `northeast`, to existing `gravity` option.
   [#291](https://github.com/lovell/sharp/pull/291)
@@ -946,13 +1238,13 @@ Requires libvips v8.2.0
   [#287](https://github.com/lovell/sharp/pull/287)
   [@vlapo](https://github.com/vlapo)
 
-#### v0.11.3 - 8<sup>th</sup> September 2015
+### v0.11.3 - 8<sup>th</sup> September 2015
 
 * Intrepret blurSigma, sharpenFlat, and sharpenJagged as double precision.
   [#263](https://github.com/lovell/sharp/pull/263)
   [@chrisriley](https://github.com/chrisriley)
 
-#### v0.11.2 - 28<sup>th</sup> August 2015
+### v0.11.2 - 28<sup>th</sup> August 2015
 
 * Allow crop gravity to be provided as a String.
   [#255](https://github.com/lovell/sharp/pull/255)
@@ -960,7 +1252,7 @@ Requires libvips v8.2.0
 * Add support for io.js v3 and Node v4.
   [#246](https://github.com/lovell/sharp/issues/246)
 
-#### v0.11.1 - 12<sup>th</sup> August 2015
+### v0.11.1 - 12<sup>th</sup> August 2015
 
 * Silence MSVC warning: "C4530: C++ exception handler used, but unwind semantics are not enabled".
   [#244](https://github.com/lovell/sharp/pull/244)
@@ -970,7 +1262,7 @@ Requires libvips v8.2.0
   [#249](https://github.com/lovell/sharp/issues/249)
   [@compeak](https://github.com/compeak)
 
-#### v0.11.0 - 15<sup>th</sup> July 2015
+### v0.11.0 - 15<sup>th</sup> July 2015
 
 * Allow alpha transparency compositing via new `overlayWith` method.
   [#97](https://github.com/lovell/sharp/issues/97)
@@ -998,9 +1290,9 @@ Requires libvips v8.2.0
   [#238](https://github.com/lovell/sharp/issues/238)
   [@richardadjogah](https://github.com/richardadjogah)
 
-### v0.10 - "*judgment*"
+## v0.10 - "*judgment*"
 
-#### v0.10.1 - 1<sup>st</sup> June 2015
+### v0.10.1 - 1<sup>st</sup> June 2015
 
 * Allow embed of image with alpha transparency onto non-transparent background.
   [#204](https://github.com/lovell/sharp/issues/204)
@@ -1010,7 +1302,7 @@ Requires libvips v8.2.0
   [#228](https://github.com/lovell/sharp/issues/228)
   [@doggan](https://github.com/doggan)
 
-#### v0.10.0 - 23<sup>rd</sup> April 2015
+### v0.10.0 - 23<sup>rd</sup> April 2015
 
 * Add support for Windows (x86).
   [#19](https://github.com/lovell/sharp/issues/19)

docs/css/extra.css

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

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

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

docs/index.md

@@ -1,150 +0,0 @@
-# sharp
-
-<img src="image/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
-
-The typical use case for this high speed Node.js module
-is to convert large images in common formats to
-smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
-
-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 64-bit OS X, Windows and Linux systems running
-Node versions 8, 10, 12 and 13
-do not require any additional install or runtime dependencies.
-
-[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
-
-### Formats
-
-This module supports reading JPEG, PNG, WebP, TIFF, GIF and SVG images.
-
-Output images can be in JPEG, PNG, WebP 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)
-and [Leaflet](https://github.com/turban/Leaflet.Zoomify).
-
-### 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
-[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.
-
-### Credits
-
-This module would never have been possible without
-the help and code contributions of the following people:
-
-* [John Cupitt](https://github.com/jcupitt)
-* [Pierre Inglebert](https://github.com/pierreinglebert)
-* [Jonathan Ong](https://github.com/jonathanong)
-* [Chanon Sajjamanochai](https://github.com/chanon)
-* [Juliano Julio](https://github.com/julianojulio)
-* [Daniel Gasienica](https://github.com/gasi)
-* [Julian Walker](https://github.com/julianwa)
-* [Amit Pitaru](https://github.com/apitaru)
-* [Brandon Aaron](https://github.com/brandonaaron)
-* [Andreas Lind](https://github.com/papandreou)
-* [Maurus Cuelenaere](https://github.com/mcuelenaere)
-* [Linus Unnebäck](https://github.com/LinusU)
-* [Victor Mateevitsi](https://github.com/mvictoras)
-* [Alaric Holloway](https://github.com/skedastik)
-* [Bernhard K. Weisshuhn](https://github.com/bkw)
-* [David A. Carley](https://github.com/dacarley)
-* [John Tobin](https://github.com/jtobinisaniceguy)
-* [Kenton Gray](https://github.com/kentongray)
-* [Felix Bünemann](https://github.com/felixbuenemann)
-* [Samy Al Zahrani](https://github.com/salzhrani)
-* [Chintan Thakkar](https://github.com/lemnisk8)
-* [F. Orlando Galashan](https://github.com/frulo)
-* [Kleis Auke Wolthuizen](https://github.com/kleisauke)
-* [Matt Hirsch](https://github.com/mhirsch)
-* [Rahul Nanwani](https://github.com/rnanwani)
-* [Matthias Thoemmes](https://github.com/cmtt)
-* [Patrick Paskaris](https://github.com/ppaskaris)
-* [Jérémy Lal](https://github.com/kapouer)
-* [Alice Monday](https://github.com/alice0meta)
-* [Kristo Jorgenson](https://github.com/kristojorg)
-* [Yves Bos](https://github.com/YvesBos)
-* [Nicolas Coden](https://github.com/ncoden)
-* [Matt Parrish](https://github.com/pbomb)
-* [Matthew McEachen](https://github.com/mceachen)
-* [Jarda Kotěšovec](https://github.com/jardakotesovec)
-* [Kenric D'Souza](https://github.com/AzureByte)
-* [Oleh Aleinyk](https://github.com/oaleynik)
-* [Marcel Bretschneider](https://github.com/3epnm)
-* [Andrea Bianco](https://github.com/BiancoA)
-* [Rik Heywood](https://github.com/rikh42)
-* [Thomas Parisot](https://github.com/oncletom)
-* [Nathan Graves](https://github.com/woolite64)
-* [Tom Lokhorst](https://github.com/tomlokhorst)
-* [Espen Hovlandsdal](https://github.com/rexxars)
-* [Sylvain Dumont](https://github.com/sylvaindumont)
-* [Alun Davies](https://github.com/alundavies)
-* [Aidan Hoolachan](https://github.com/ajhool)
-* [Axel Eirola](https://github.com/aeirola)
-* [Freezy](https://github.com/freezy)
-* [Julian Aubourg](https://github.com/jaubourg)
-* [Keith Belovay](https://github.com/fromkeith)
-* [Michael B. Klein](https://github.com/mbklein)
-* [Jakub Michálek](https://github.com/Goues)
-* [Ilya Ovdin](https://github.com/iovdin)
-* [Andargor](https://github.com/Andargor)
-* [Nicolas Stepien](https://github.com/MayhemYDG)
-* [Paul Neave](https://github.com/neave)
-* [Brendan Kennedy](https://github.com/rustyguts)
-
-Thank you!
-
-### Licensing
-
-Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-[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/install.md

@@ -10,107 +10,140 @@ yarn add sharp
 
 ## Prerequisites
 
-* Node.js v8.5.0+
+* Node.js v10+
 
-### Building from source
+## Prebuilt binaries
 
-Pre-compiled binaries for sharp are provided for use with
-Node versions 8, 10, 12 and 13 on
-64-bit Windows, OS X and Linux platforms.
+Ready-compiled sharp and libvips binaries are provided for use with
+Node.js v10+ on the most common platforms:
 
-Sharp will be built from source at install time when:
+* macOS x64 (>= 10.13)
+* Linux x64 (glibc >= 2.17, musl >= 1.1.24)
+* Linux ARM64 (glibc >= 2.29, musl >= 1.1.24)
+* Windows x64
+* Windows x86
 
-* a globally-installed libvips is detected,
-* pre-compiled binaries do not exist for the current platform and Node version, or
+An ~7.5MB tarball containing libvips and its most commonly used dependencies
+is downloaded via HTTPS and stored within `node_modules/sharp/vendor` during `npm install`.
+
+This provides support for the
+JPEG, PNG, WebP, AVIF, TIFF, GIF (input) and SVG (input) image formats.
+
+The following platforms have prebuilt libvips but not sharp:
+
+* macOS ARM64
+* Linux ARMv6
+* Linux ARMv7 (glibc >= 2.28)
+* Windows ARM64
+
+The following platforms require compilation of both libvips and sharp from source:
+
+* Linux x86
+* Linux x64 (glibc <= 2.16, includes RHEL/CentOS 6)
+* Linux ARM64 (glibc <= 2.28)
+* 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
+
+Prebuilt libvips binaries are provided for macOS on ARM64 (since sharp v0.28.0).
+
+During `npm install` sharp will be built locally,
+which requires Xcode and Python - see
+[building from source](#building-from-source).
+
+When this new ARM64 CPU is made freely available
+to open source projects via a CI service
+then prebuilt sharp binaries can also be provided.
+
+## Custom libvips
+
+To use a custom, globally-installed version of libvips instead of the provided binaries,
+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 compatible compiler such as gcc 4.8+, clang 3.0+ or MSVC 2013+
-* [node-gyp](https://github.com/nodejs/node-gyp#installation) and its dependencies (includes Python 2.7)
+* C++11 compiler
+* [node-gyp](https://github.com/nodejs/node-gyp#installation) and its dependencies
 
-## libvips
+## Custom prebuilt binaries
 
-### Linux
+This is an advanced approach that most people will not require.
 
-[![Ubuntu 16.04 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
+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.
 
-libvips and its dependencies are fetched and stored within `node_modules/sharp/vendor` during `npm install`.
-This involves an automated HTTPS download of approximately 10MB.
+To install the prebuilt sharp binaries from a directory on the local filesystem,
+set the `sharp_local_prebuilds` npm config option
+or the `npm_config_sharp_local_prebuilds` environment variable.
 
-Most Linux-based (glibc, musl) operating systems running on x64 and ARMv6+ CPUs should "just work", e.g.:
+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.
 
-* Debian 8+
-* Ubuntu 14.04+
-* Red Hat Enterprise 7+
-* CentOS 7+
-* Alpine 3.10+
-* Fedora 21+
-* openSUSE 13.2+
-* Archlinux
-* Raspbian Jessie
-* Amazon Linux
-* Solus
+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+)
 
-To use a globally-installed version of libvips instead of the provided binaries,
-make sure it is at least the version listed under `config.libvips` in the `package.json` file
-and that it can be located using `pkg-config --modversion vips-cpp`.
+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`.
 
-If you are using non-standard paths (anything other than `/usr` or `/usr/local`),
-you might need to set `PKG_CONFIG_PATH` during `npm install`
-and `LD_LIBRARY_PATH` at runtime.
+See the Chinese mirror below for a further example.
 
-This allows the use of newer versions of libvips with older versions of sharp.
+## Chinese mirror
 
-For 32-bit Intel CPUs and older Linux-based operating systems such as
-those based on Red Hat Enterprise 6 (e.g. CentOS 6)
-compiling libvips from source is recommended.
+Alibaba provide a mirror site based in China containing binaries for both sharp and libvips.
 
-[https://libvips.github.io/libvips/install.html#building-libvips-from-a-source-tarball](https://libvips.github.io/libvips/install.html#building-libvips-from-a-source-tarball)
-
-#### Alpine Linux
-
-libvips is available in the
-[community repository](https://pkgs.alpinelinux.org/packages?name=vips-dev):
+To use this either set the following configuration:
 
 ```sh
-apk add --upgrade --no-cache vips-dev build-base \
-  --repository https://alpine.global.ssl.fastly.net/alpine/v3.10/community/
+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
 ```
 
-The smaller stack size of musl libc means
-libvips may need to be used without a cache
-via `sharp.cache(false)` to avoid a stack overflow.
+or set the following environment variables:
 
-### Mac OS
+```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
+```
 
-[![OS X 10.12 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
+## FreeBSD
 
-libvips and its dependencies are fetched and stored within `node_modules/sharp/vendor` during `npm install`.
-This involves an automated HTTPS download of approximately 8MB.
-
-To use your own version of libvips instead of the provided binaries, make sure it is
-at least the version listed under `config.libvips` in the `package.json` file and
-that it can be located using `pkg-config --modversion vips-cpp`.
-
-### Windows x64
-
-[![Windows x64 Build Status](https://ci.appveyor.com/api/projects/status/pgtul704nkhhg6sg)](https://ci.appveyor.com/project/lovell/sharp)
-
-libvips and its dependencies are fetched and stored within `node_modules\sharp\vendor` during `npm install`.
-This involves an automated HTTPS download of approximately 10MB.
-If you are having issues during installation consider removing the directory
-`C:\Users\[user]\AppData\Roaming\npm-cache\_libvips`.
-
-Only 64-bit (x64) `node.exe` is supported.
-
-### FreeBSD
-
-[![FreeBSD Build Status](https://api.cirrus-ci.com/github/lovell/sharp.svg)](https://cirrus-ci.com/github/lovell/sharp)
-
-libvips must be installed before `npm install` is run.
-
-This can be achieved via package or ports:
+The `vips` package must be installed before `npm install` is run.
 
 ```sh
 pkg install -y pkgconf vips
@@ -120,175 +153,92 @@ pkg install -y pkgconf vips
 cd /usr/ports/graphics/vips/ && make install clean
 ```
 
-FreeBSD's gcc v4 and v5 need `CXXFLAGS=-D_GLIBCXX_USE_C99` set for C++11 support due to
-https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=193528
+## Linux memory allocator
 
-### Heroku
+The default memory allocator on most glibc-based Linux systems
+(e.g. Debian, Red Hat) is unsuitable for long-running, multi-threaded
+processes that involve lots of small memory allocations.
 
-Set [NODE_MODULES_CACHE](https://devcenter.heroku.com/articles/nodejs-support#cache-behavior)
+For this reason, by default, sharp will limit the use of thread-based
+[concurrency](api-utility#concurrency) when the glibc allocator is
+detected at runtime.
+
+To help avoid fragmentation and improve performance on these systems,
+the use of an alternative memory allocator such as
+[jemalloc](https://github.com/jemalloc/jemalloc) is recommended.
+
+Those using musl-based Linux (e.g. Alpine) and non-Linux systems are
+unaffected.
+
+## Heroku
+
+Add the
+[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.
 
-To reduce the effects of memory fragmentation, add the
-[jemalloc buildpack](https://github.com/gaffneyc/heroku-buildpack-jemalloc).
-
-### Docker
-
-[Marc Bachmann](https://github.com/marcbachmann) maintains an
-[Ubuntu-based Dockerfile for libvips](https://github.com/marcbachmann/dockerfile-libvips).
-
-```sh
-docker pull marcbachmann/libvips
-```
-
-[Will Jordan](https://github.com/wjordan) maintains an
-[Alpine-based Dockerfile for libvips](https://github.com/wjordan/dockerfile-libvips).
-
-```sh
-docker pull wjordan/libvips
-```
-
-[Tailor Brands](https://github.com/TailorBrands) maintain
-[Debian-based Dockerfiles for libvips and nodejs](https://github.com/TailorBrands/docker-libvips).
-
-```sh
-docker pull tailor/docker-libvips
-```
-
-### AWS Lambda
-
-Set the Lambda runtime to `nodejs10.x`.
+## AWS Lambda
 
 The binaries in the `node_modules` directory of the
-[deployment package](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-create-deployment-pkg.html)
-must be for the Linux x64 platform/architecture.
+[deployment package](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-package.html)
+must be for the Linux x64 platform.
 
-On non-Linux machines such as OS X and Windows run the following:
+When building your deployment package on machines other than Linux x64 (glibc),
+run the following commands:
 
+macOS:
 ```sh
 rm -rf node_modules/sharp
-npm install --arch=x64 --platform=linux --target=10.15.0 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-nodejs10.x npm install 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.
 
-### NW.js
+## Webpack
 
-Run the `nw-gyp` tool after installation.
+Ensure sharp is added to the
+[externals](https://webpack.js.org/configuration/externals/)
+configuration.
 
-```sh
-cd node-modules/sharp
-nw-gyp rebuild --arch=x64 --target=[your nw version]
-node node_modules/sharp/install/dll-copy
+```js
+externals: {
+  'sharp': 'commonjs sharp'
+}
 ```
 
-[http://docs.nwjs.io/en/latest/For%20Users/Advanced/Use%20Native%20Node%20Modules/](http://docs.nwjs.io/en/latest/For%20Users/Advanced/Use%20Native%20Node%20Modules/)
+## Worker threads
 
-### Build tools
+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.
 
-* [gulp-responsive](https://www.npmjs.com/package/gulp-responsive)
-* [grunt-sharp](https://www.npmjs.com/package/grunt-sharp)
+## Known conflicts
 
-### Coding tools
+### Canvas and Windows
 
-* [Sharp TypeScript Types](https://www.npmjs.com/package/@types/sharp)
+The prebuilt binaries provided by `canvas` for Windows depend on the unmaintained GTK 2, last updated in 2011.
 
-### CLI tools
+These conflict with the modern, up-to-date binaries provided by sharp.
 
-* [sharp-cli](https://www.npmjs.com/package/sharp-cli)
-
-### Security
-
-Many users of this module process untrusted, user-supplied images,
-but there are aspects of security to consider when doing so.
-
-It is possible to compile libvips with support for various third-party image loaders.
-Each of these libraries has undergone differing levels of security testing.
-
-Whilst tools such as [American Fuzzy Lop](http://lcamtuf.coredump.cx/afl/)
-and [Valgrind](http://valgrind.org/) have been used to test
-the most popular web-based formats, as well as libvips itself,
-you are advised to perform your own testing and sandboxing.
-
-### Pre-compiled libvips binaries
-
-This module will attempt to download a pre-compiled bundle of libvips
-and its dependencies on Linux and Windows machines under either of these
-conditions:
-
-1. If a global installation of libvips that meets the
-minimum version requirement cannot be found;
-1. If `SHARP_IGNORE_GLOBAL_LIBVIPS` environment variable is set.
-
-```sh
-SHARP_IGNORE_GLOBAL_LIBVIPS=1 npm install sharp
+If both modules are used in the same Windows process, the following error will occur:
 ```
-
-Should you need to manually download and inspect these files,
-you can do so via
-[https://github.com/lovell/sharp-libvips/releases](https://github.com/lovell/sharp-libvips/releases)
-
-Should you wish to install these from your own location,
-set the `sharp_dist_base_url` npm config option, e.g.
-
-```sh
-npm config set sharp_dist_base_url "https://hostname/path/"
-npm install sharp
+The specified procedure could not be found.
 ```
-
-or set the `SHARP_DIST_BASE_URL` environment variable, e.g.
-
-```sh
-SHARP_DIST_BASE_URL="https://hostname/path/" npm install sharp
-```
-
-to use `https://hostname/path/libvips-x.y.z-platform.tar.gz`.
-
-To install the prebuilt sharp binaries from a custom URL, please see
-[https://github.com/prebuild/prebuild-install#custom-binaries](https://github.com/prebuild/prebuild-install#custom-binaries)
-
-### Licences
-
-This module is licensed under the terms of the
-[Apache 2.0 Licence](https://github.com/lovell/sharp/blob/master/LICENSE).
-
-The libraries downloaded and used by this module
-are done so under the terms of the following licences,
-all of which are compatible with the Apache 2.0 Licence.
-
-Use of libraries under the terms of the LGPLv3 is via the
-"any later version" clause of the LGPLv2 or LGPLv2.1.
-
-| Library       | Used under the terms of                                                                                  |
-|---------------|----------------------------------------------------------------------------------------------------------|
-| cairo         | Mozilla Public License 2.0                                                                               |
-| expat         | MIT Licence                                                                                              |
-| fontconfig    | [fontconfig Licence](https://cgit.freedesktop.org/fontconfig/tree/COPYING) (BSD-like)                    |
-| freetype      | [freetype Licence](http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT) (BSD-like) |
-| fribidi       | LGPLv3                                                                                                   |
-| gettext       | LGPLv3                                                                                                   |
-| giflib        | MIT Licence                                                                                              |
-| glib          | LGPLv3                                                                                                   |
-| harfbuzz      | MIT Licence                                                                                              |
-| lcms          | MIT Licence                                                                                              |
-| libcroco      | LGPLv3                                                                                                   |
-| libexif       | LGPLv3                                                                                                   |
-| libffi        | MIT Licence                                                                                              |
-| libgsf        | LGPLv3                                                                                                   |
-| libjpeg-turbo | [zlib License, IJG License](https://github.com/libjpeg-turbo/libjpeg-turbo/blob/master/LICENSE.md)       |
-| libpng        | [libpng License](http://www.libpng.org/pub/png/src/libpng-LICENSE.txt)                                   |
-| librsvg       | LGPLv3                                                                                                   |
-| libtiff       | [libtiff License](http://www.libtiff.org/misc.html) (BSD-like)                                           |
-| libvips       | LGPLv3                                                                                                   |
-| libwebp       | New BSD License                                                                                          |
-| libxml2       | MIT Licence                                                                                              |
-| pango         | LGPLv3                                                                                                   |
-| pixman        | MIT Licence                                                                                              |
-| zlib          | [zlib Licence](https://github.com/madler/zlib/blob/master/zlib.h)                                        |

docs/performance.md

@@ -1,44 +1,46 @@
 # Performance
 
-### Test environment
+A test to benchmark the performance of this module relative to alternatives.
 
-* AWS EC2 eu-west-1 [c5.large](https://aws.amazon.com/ec2/instance-types/c5/) (2x Xeon Platinum 8124M CPU @ 3.00GHz)
-* Ubuntu 18.04 (hvm-ssd/ubuntu-bionic-18.04-amd64-server-20180912 ami-00035f41c82244dab)
-* Node.js v12.10.0
+## The contenders
 
-### The contenders
-
-* [jimp](https://www.npmjs.com/package/jimp) v0.8.4 - Image processing in pure JavaScript. Provides bicubic interpolation.
-* [mapnik](https://www.npmjs.org/package/mapnik) v4.3.1 - Whilst primarily a map renderer, Mapnik contains bitmap image utilities.
+* [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.6 - Whilst primarily a map renderer, Mapnik contains bitmap image utilities.
 * [imagemagick](https://www.npmjs.com/package/imagemagick) v0.1.3 - Supports filesystem only and "*has been unmaintained for a long time*".
 * [gm](https://www.npmjs.com/package/gm) v1.23.1 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
-* sharp v0.23.1 / libvips v8.8.1 - Caching within libvips disabled to ensure a fair comparison.
+* sharp v0.28.0 / libvips v8.10.6 - Caching within libvips disabled to ensure a fair comparison.
 
-### The task
+## 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.
 
-### Results
+## Test environment
+
+* AWS EC2 eu-west-1 [c5ad.xlarge](https://aws.amazon.com/ec2/instance-types/c5/) (4x AMD EPYC 7R32)
+* Ubuntu 20.10 (ami-03f10415e8b0bfb86)
+* Node.js v14.16.0
+
+## Results
 
 | Module             | Input  | Output | Ops/sec | Speed-up |
 | :----------------- | :----- | :----- | ------: | -------: |
-| jimp               | buffer | buffer |    0.66 |      1.0 |
-| mapnik             | buffer | buffer |    3.31 |      5.0 |
-| gm                 | buffer | buffer |    3.79 |      5.7 |
-| gm                 | file   | file   |    3.82 |      5.8 |
-| imagemagick        | file   | file   |    4.17 |      6.3 |
-| sharp              | stream | stream |   25.81 |     39.1 |
-| sharp              | file   | file   |   26.76 |     40.5 |
-| sharp              | buffer | buffer |   28.06 |     42.5 |
+| jimp               | buffer | buffer |    0.78 |      1.0 |
+| mapnik             | buffer | buffer |    3.39 |      4.3 |
+| gm                 | buffer | buffer |    7.84 |     10.1 |
+| gm                 | file   | file   |    9.24 |     11.8 |
+| imagemagick        | file   | file   |    9.37 |     12.0 |
+| sharp              | stream | stream |   26.84 |     34.4 |
+| sharp              | file   | file   |   29.76 |     38.2 |
+| sharp              | buffer | buffer |   31.60 |     40.5 |
 
 Greater libvips performance can be expected with caching enabled (default)
 and using 8+ core machines, especially those with larger L1/L2 CPU caches.
 
 The I/O limits of the relevant (de)compression library will generally determine maximum throughput.
 
-### Benchmark test prerequisites
+## Running the benchmark test
 
 Requires _ImageMagick_, _GraphicsMagick_ and _Mapnik_:
 
@@ -49,19 +51,17 @@ brew install mapnik
 ```
 
 ```sh
-sudo apt-get install imagemagick libmagick++-dev graphicsmagick libmapnik-dev
+sudo apt-get install build-essential imagemagick libmagick++-dev graphicsmagick libmapnik-dev
 ```
 
 ```sh
 sudo yum install ImageMagick-devel ImageMagick-c++-devel GraphicsMagick mapnik-devel
 ```
 
-### Running the benchmark test
-
 ```sh
 git clone https://github.com/lovell/sharp.git
 cd sharp
-npm install
+npm install --build-from-source
 cd test/bench
 npm install
 npm test

docs/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, 180)
+    .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,92 @@
+'use strict';
+
+module.exports = [
+  'about',
+  'after',
+  'all',
+  'allows',
+  'already',
+  'also',
+  'alternative',
+  'always',
+  'and',
+  'any',
+  'are',
+  'based',
+  'been',
+  'before',
+  'both',
+  'call',
+  'can',
+  'containing',
+  'default',
+  'does',
+  'each',
+  'either',
+  'ensure',
+  'etc',
+  'every',
+  'for',
+  'from',
+  'get',
+  'gets',
+  'given',
+  'has',
+  'have',
+  'how',
+  'image',
+  'involve',
+  'its',
+  'least',
+  'lots',
+  'may',
+  'more',
+  'most',
+  'much',
+  'must',
+  'non',
+  'not',
+  'occur',
+  'occurs',
+  'options',
+  'over',
+  'perform',
+  'performs',
+  'provide',
+  'provided',
+  'ready',
+  'same',
+  'see',
+  'set',
+  'sets',
+  'should',
+  'since',
+  'spelling',
+  'such',
+  'support',
+  'supported',
+  'sure',
+  'take',
+  'that',
+  'the',
+  'their',
+  'there',
+  'therefore',
+  'these',
+  'this',
+  'under',
+  'unless',
+  'until',
+  'use',
+  'used',
+  'using',
+  'value',
+  'values',
+  'when',
+  'which',
+  'while',
+  'will',
+  'with',
+  'without',
+  'you'
+];

install/dll-copy.js

@@ -4,18 +4,20 @@ const fs = require('fs');
 const path = require('path');
 
 const libvips = require('../lib/libvips');
-const npmLog = require('npmlog');
 
-if (process.platform === 'win32') {
+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}`);
+  libvips.log(`Creating ${buildReleaseDir}`);
   try {
     libvips.mkdirSync(buildDir);
     libvips.mkdirSync(buildReleaseDir);
   } catch (err) {}
-  const vendorLibDir = path.join(__dirname, '..', 'vendor', 'lib');
-  npmLog.info('sharp', `Copying DLLs from ${vendorLibDir} to ${buildReleaseDir}`);
+  const vendorLibDir = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion, 'lib');
+  libvips.log(`Copying DLLs from ${vendorLibDir} to ${buildReleaseDir}`);
   try {
     fs
       .readdirSync(vendorLibDir)
@@ -29,6 +31,7 @@ if (process.platform === 'win32') {
         );
       });
   } catch (err) {
-    npmLog.error('sharp', err.message);
+    libvips.log(err);
+    process.exit(1);
   }
 }

install/libvips.js

@@ -3,109 +3,166 @@
 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 tar = require('tar');
+const tarFs = require('tar-fs');
 
 const agent = require('../lib/agent');
 const libvips = require('../lib/libvips');
 const platform = require('../lib/platform');
 
-const minimumLibvipsVersion = libvips.minimumLibvipsVersion;
-const distBaseUrl = process.env.npm_config_sharp_dist_base_url || process.env.SHARP_DIST_BASE_URL || `https://github.com/lovell/sharp-libvips/releases/download/v${minimumLibvipsVersion}/`;
+const minimumGlibcVersionByArch = {
+  arm: '2.28',
+  arm64: '2.29',
+  x64: '2.17'
+};
+
+const hasSharpPrebuild = [
+  'darwin-x64',
+  'linux-arm64',
+  'linux-x64',
+  'linuxmusl-x64',
+  'linuxmusl-arm64',
+  'win32-ia32',
+  'win32-x64'
+];
+
+const { minimumLibvipsVersion, minimumLibvipsVersionLabelled } = libvips;
+const distHost = process.env.npm_config_sharp_libvips_binary_host || 'https://github.com/lovell/sharp-libvips/releases/download';
+const distBaseUrl = process.env.npm_config_sharp_dist_base_url || process.env.SHARP_DIST_BASE_URL || `${distHost}/v${minimumLibvipsVersionLabelled}/`;
+const supportsBrotli = ('BrotliDecompress' in zlib);
 
 const fail = function (err) {
-  npmLog.error('sharp', err.message);
+  libvips.log(err);
   if (err.code === 'EACCES') {
-    npmLog.info('sharp', 'Are you trying to install as a root or sudo user? Try again with the --unsafe-perm flag');
+    libvips.log('Are you trying to install as a root or sudo user? Try again with the --unsafe-perm flag');
   }
-  npmLog.info('sharp', 'Attempting to build from source via node-gyp but this may fail due to the above error');
-  npmLog.info('sharp', 'Please see https://sharp.pixelplumbing.com/page/install for required dependencies');
+  libvips.log('Attempting to build from source via node-gyp but this may fail due to the above error');
+  libvips.log('Please see https://sharp.pixelplumbing.com/install for required dependencies');
   process.exit(1);
 };
 
-const extractTarball = function (tarPath) {
+const extractTarball = function (tarPath, platformAndArch) {
   const vendorPath = path.join(__dirname, '..', 'vendor');
   libvips.mkdirSync(vendorPath);
-  tar
-    .extract({
-      file: tarPath,
-      cwd: vendorPath,
-      strict: true
-    })
-    .catch(function (err) {
-      if (/unexpected end of file/.test(err.message)) {
-        npmLog.error('sharp', `Please delete ${tarPath} as it is not a valid tarball`);
+  const versionedVendorPath = path.join(vendorPath, minimumLibvipsVersion);
+  libvips.mkdirSync(versionedVendorPath);
+
+  const ignoreVendorInclude = hasSharpPrebuild.includes(platformAndArch) && !process.env.npm_config_build_from_source;
+  const ignore = function (name) {
+    return ignoreVendorInclude && name.includes('include/');
+  };
+
+  stream.pipeline(
+    fs.createReadStream(tarPath),
+    supportsBrotli ? new zlib.BrotliDecompress() : new zlib.Gunzip(),
+    tarFs.extract(versionedVendorPath, { ignore }),
+    function (err) {
+      if (err) {
+        if (/unexpected end of file/.test(err.message)) {
+          fail(new Error(`Please delete ${tarPath} as it is not a valid tarball`));
+        }
+        fail(err);
       }
-      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');
+    libvips.log(`Detected globally-installed libvips v${globalLibvipsVersion}`);
+    libvips.log('Building from source via node-gyp');
     process.exit(1);
   } else if (libvips.hasVendoredLibvips()) {
-    npmLog.info('sharp', `Using existing vendored libvips v${minimumLibvipsVersion}`);
+    libvips.log(`Using existing vendored libvips v${minimumLibvipsVersion}`);
   } else {
     // Is this arch/platform supported?
     const arch = process.env.npm_config_arch || process.arch;
     const platformAndArch = platform();
-    if (platformAndArch === 'win32-ia32') {
-      throw new Error('Windows x86 (32-bit) node.exe is not supported');
-    }
-    if (arch === 'ia32') {
+    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 && semver.lt(`${detectLibc.version}.0`, '2.17.0')) {
-      throw new Error(`Use with glibc version ${detectLibc.version} requires 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.lt(detectLibc.version, '1.1.24')) {
+        throw new Error(`Use with musl ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
+      }
+    }
+
+    const supportedNodeVersion = process.env.npm_package_engines_node || require('../package.json').engines.node;
+    if (!semver.satisfies(process.versions.node, supportedNodeVersion)) {
+      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.gz';
+    const tarFilename = ['libvips', minimumLibvipsVersion, platformAndArch].join('-') + '.tar.' + extension;
     const tarPathCache = path.join(libvips.cachePath(), tarFilename);
     if (fs.existsSync(tarPathCache)) {
-      npmLog.info('sharp', `Using cached ${tarPathCache}`);
-      extractTarball(tarPathCache);
+      libvips.log(`Using cached ${tarPathCache}`);
+      extractTarball(tarPathCache, platformAndArch);
     } else {
-      const tarPathTemp = path.join(os.tmpdir(), `${process.pid}-${tarFilename}`);
-      const tmpFile = fs.createWriteStream(tarPathTemp);
       const url = distBaseUrl + tarFilename;
-      npmLog.info('sharp', `Downloading ${url}`);
+      libvips.log(`Downloading ${url}`);
       simpleGet({ url: url, agent: agent() }, function (err, response) {
         if (err) {
           fail(err);
         } else if (response.statusCode === 404) {
-          fail(new Error(`Prebuilt libvips binaries are not yet available for ${platformAndArch}`));
+          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 {
+          const tarPathTemp = path.join(os.tmpdir(), `${process.pid}-${tarFilename}`);
+          const tmpFileStream = fs.createWriteStream(tarPathTemp);
           response
-            .on('error', fail)
-            .pipe(tmpFile);
+            .on('error', function (err) {
+              tmpFileStream.destroy(err);
+            })
+            .on('close', function () {
+              if (!response.complete) {
+                tmpFileStream.destroy(new Error('Download incomplete (connection was terminated)'));
+              }
+            })
+            .pipe(tmpFileStream);
+          tmpFileStream
+            .on('error', function (err) {
+              // Clean up temporary file
+              try {
+                fs.unlinkSync(tarPathTemp);
+              } catch (e) {}
+              fail(err);
+            })
+            .on('close', function () {
+              try {
+                // Attempt to rename
+                fs.renameSync(tarPathTemp, tarPathCache);
+              } catch (err) {
+                // Fall back to copy and unlink
+                fs.copyFileSync(tarPathTemp, tarPathCache);
+                fs.unlinkSync(tarPathTemp);
+              }
+              extractTarball(tarPathCache, platformAndArch);
+            });
         }
       });
-      tmpFile
-        .on('error', fail)
-        .on('close', function () {
-          try {
-            // Attempt to rename
-            fs.renameSync(tarPathTemp, tarPathCache);
-          } catch (err) {
-            // Fall back to copy and unlink
-            fs.copyFileSync(tarPathTemp, tarPathCache);
-            fs.unlinkSync(tarPathTemp);
-          }
-          extractTarball(tarPathCache);
-        });
     }
   }
 } catch (err) {

lib/channel.js

@@ -30,19 +30,39 @@ function removeAlpha () {
 }
 
 /**
- * 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.
+ * Ensure the output image has an alpha transparency channel.
+ * If missing, the added alpha channel will have the specified
+ * transparency level, defaulting to fully-opaque (1).
+ * This is a no-op if the image already has an alpha channel.
+ *
+ * @since 0.21.2
  *
  * @example
- * sharp('rgb.jpg')
+ * // rgba.png will be a 4 channel image with a fully-opaque alpha channel
+ * await sharp('rgb.jpg')
  *   .ensureAlpha()
- *   .toFile('rgba.png', function(err, info) {
- *     // rgba.png is a 4 channel image with a fully opaque alpha channel
- *   });
+ *   .toFile('rgba.png')
  *
+ * @example
+ * // rgba is a 4 channel image with a fully-transparent alpha channel
+ * const rgba = await sharp(rgb)
+ *   .ensureAlpha(0)
+ *   .toBuffer();
+ *
+ * @param {number} [alpha=1] - alpha transparency level (0=fully-transparent, 1=fully-opaque)
  * @returns {Sharp}
+ * @throws {Error} Invalid alpha transparency level
  */
-function ensureAlpha () {
-  this.options.ensureAlpha = true;
+function ensureAlpha (alpha) {
+  if (is.defined(alpha)) {
+    if (is.number(alpha) && is.inRange(alpha, 0, 1)) {
+      this.options.ensureAlpha = alpha;
+    } else {
+      throw is.invalidParameterError('alpha', 'number between 0 and 1', alpha);
+    }
+  } else {
+    this.options.ensureAlpha = 1;
+  }
   return this;
 }
 
@@ -52,27 +72,25 @@ function ensureAlpha () {
  * @example
  * sharp(input)
  *   .extractChannel('green')
- *   .toFile('input_green.jpg', function(err, info) {
+ *   .toColourspace('b-w')
+ *   .toFile('green.jpg', function(err, info) {
  *     // info.channels === 1
- *     // input_green.jpg contains the green channel of the input image
+ *     // green.jpg is a greyscale image containing the green channel of the input
  *    });
  *
- * @param {Number|String} channel - zero-indexed band number to extract, or `red`, `green` or `blue` as alternative to `0`, `1` or `2` respectively.
+ * @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) {
-  if (channel === 'red') {
-    channel = 0;
-  } else if (channel === 'green') {
-    channel = 1;
-  } else if (channel === 'blue') {
-    channel = 2;
+  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', channel);
+    throw is.invalidParameterError('channel', 'integer or one of: red, green, blue, alpha', channel);
   }
   return this;
 }
@@ -85,10 +103,10 @@ function extractChannel (channel) {
  * - sRGB: 0: Red, 1: Green, 2: Blue, 3: Alpha.
  * - CMYK: 0: Magenta, 1: Cyan, 2: Yellow, 3: Black, 4: Alpha.
  *
- * Buffers may be any of the image formats supported by sharp: JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data.
+ * 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 {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
@@ -116,7 +134,7 @@ function joinChannel (images, options) {
  *     // 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.
+ * @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
  */

lib/colour.js

@@ -19,7 +19,7 @@ const colourspace = {
  * 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.
+ * @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
  */
@@ -57,7 +57,14 @@ function grayscale (grayscale) {
 /**
  * Set the output colourspace.
  * By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
- * @param {String} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
+ *
+ * @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
  */
@@ -71,7 +78,7 @@ function toColourspace (colourspace) {
 
 /**
  * Alternative spelling of `toColourspace`.
- * @param {String} [colorspace] - output colorspace.
+ * @param {string} [colorspace] - output colorspace.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -82,8 +89,8 @@ function toColorspace (colorspace) {
 /**
  * Update a colour attribute of the this.options Object.
  * @private
- * @param {String} key
- * @param {String|Object} value
+ * @param {string} key
+ * @param {string|Object} value
  * @throws {Error} Invalid value
  */
 function _setBackgroundColourOption (key, value) {

lib/composite.js

@@ -53,6 +53,8 @@ const blend = {
  * 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)
@@ -70,7 +72,7 @@ const blend = {
  *   });
  *
  * @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 bellow)
+ * @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]
@@ -98,14 +100,14 @@ function composite (images) {
     if (!is.object(image)) {
       throw is.invalidParameterError('image to composite', 'object', image);
     }
-    const { raw, density } = image;
-    const inputOptions = (raw || density) ? { raw, density } : undefined;
+    const inputOptions = this._inputOptionsFromObject(image);
     const composite = {
       input: this._createInputDescriptor(image.input, inputOptions, { allowStream: false }),
       blend: 'over',
       tile: false,
-      left: -1,
-      top: -1,
+      left: 0,
+      top: 0,
+      hasOffset: false,
       gravity: 0,
       premultiplied: false
     };
@@ -124,21 +126,23 @@ function composite (images) {
       }
     }
     if (is.defined(image.left)) {
-      if (is.integer(image.left) && image.left >= 0) {
+      if (is.integer(image.left)) {
         composite.left = image.left;
       } else {
-        throw is.invalidParameterError('left', 'positive integer', image.left);
+        throw is.invalidParameterError('left', 'integer', image.left);
       }
     }
     if (is.defined(image.top)) {
-      if (is.integer(image.top) && image.top >= 0) {
+      if (is.integer(image.top)) {
         composite.top = image.top;
       } else {
-        throw is.invalidParameterError('top', 'positive integer', image.top);
+        throw is.invalidParameterError('top', 'integer', image.top);
       }
     }
-    if (composite.left !== composite.top && Math.min(composite.left, composite.top) === -1) {
+    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)) {

lib/constructor.js

@@ -2,15 +2,13 @@
 
 const util = require('util');
 const stream = require('stream');
-const events = require('events');
 const is = require('./is');
 
 require('./libvips').hasVendoredLibvips();
 
-let sharp;
 /* istanbul ignore next */
 try {
-  sharp = require('../build/Release/sharp.node');
+  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, ''];
@@ -18,30 +16,40 @@ try {
     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 {
-    help.push('- Remove the "node_modules/sharp" directory, run "npm install" and look for errors');
+    help.push(
+      '- Remove the "node_modules/sharp" directory then run',
+      '  "npm install --ignore-scripts=false --verbose sharp" and look for errors'
+    );
   }
   help.push(
-    '- Consult the installation documentation at https://sharp.pixelplumbing.com/en/stable/install/',
+    '- Consult the installation documentation at https://sharp.pixelplumbing.com/install',
     '- Search for this error at https://github.com/lovell/sharp/issues', ''
   );
-  console.error(help.join('\n'));
-  process.exit(1);
+  const error = help.join('\n');
+  throw new Error(error);
 }
 
 // Use NODE_DEBUG=sharp to enable libvips warnings
 const debuglog = util.debuglog('sharp');
 
 /**
- * @class Sharp
- *
  * Constructor factory to create an instance of `sharp`, to which further methods are chained.
  *
- * JPEG, PNG, WebP or TIFF format image data can be streamed out from this object.
+ * 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)
@@ -76,25 +84,70 @@ const debuglog = util.debuglog('sharp');
  * .toBuffer()
  * .then( ... );
  *
- * @param {(Buffer|String)} [input] - if present, can be
- *  a Buffer containing JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data, or
- *  a String containing the filesystem path to an JPEG, PNG, WebP, GIF, SVG or TIFF image file.
- *  JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
+ * @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.
+ * @param {boolean} [options.failOnError=true] - by default halt processing and raise an error when loading invalid images.
  *  Set this flag to `false` if you'd rather apply a "best effort" to decode images, even if the data is corrupt or invalid.
- * @param {Number} [options.density=72] - number representing the DPI for vector images.
- * @param {Number} [options.pages=1] - number of pages to extract for multi-page input (GIF, TIFF, PDF), use -1 for all pages.
- * @param {Number} [options.page=0] - page number to start extracting from for multi-page input (GIF, TIFF, PDF), zero based.
+ * @param {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.subifd=-1] - subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image.
+ * @param {number} [options.level=0] - level to extract from a multi-level input (OpenSlide), zero based.
+ * @param {boolean} [options.animated=false] - Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`).
  * @param {Object} [options.raw] - describes raw pixel input image data. See `raw()` for pixel ordering.
- * @param {Number} [options.raw.width]
- * @param {Number} [options.raw.height]
- * @param {Number} [options.raw.channels] - 1-4
+ * @param {number} [options.raw.width] - integral number of pixels wide.
+ * @param {number} [options.raw.height] - integral number of pixels high.
+ * @param {number} [options.raw.channels] - integral number of channels, between 1 and 4.
  * @param {Object} [options.create] - describes a new image to be created.
- * @param {Number} [options.create.width]
- * @param {Number} [options.create.height]
- * @param {Number} [options.create.channels] - 3-4
- * @param {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 {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
  */
@@ -107,9 +160,6 @@ const Sharp = function (input, options) {
   }
   stream.Duplex.call(this);
   this.options = {
-    // input options
-    sequentialRead: false,
-    limitInputPixels: Math.pow(0x3FFF, 2),
     // resize options
     topOffsetPre: -1,
     leftOffsetPre: -1,
@@ -137,6 +187,13 @@ const Sharp = function (input, options) {
     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
@@ -156,7 +213,7 @@ const Sharp = function (input, options) {
     gamma: 0,
     gammaOut: 0,
     greyscale: false,
-    normalise: 0,
+    normalise: false,
     brightness: 1,
     saturation: 1,
     hue: 0,
@@ -165,7 +222,7 @@ const Sharp = function (input, options) {
     joinChannelIn: [],
     extractChannel: -1,
     removeAlpha: false,
-    ensureAlpha: false,
+    ensureAlpha: -1,
     colourspace: 'srgb',
     composite: [],
     // output
@@ -174,6 +231,8 @@ const Sharp = function (input, options) {
     streamOut: false,
     withMetadata: false,
     withMetadataOrientation: -1,
+    withMetadataIcc: '',
+    withMetadataStrs: {},
     resolveWithObject: false,
     // output format
     jpegQuality: 80,
@@ -185,7 +244,7 @@ const Sharp = function (input, options) {
     jpegOptimiseCoding: true,
     jpegQuantisationTable: 0,
     pngProgressive: false,
-    pngCompressionLevel: 9,
+    pngCompressionLevel: 6,
     pngAdaptiveFiltering: false,
     pngPalette: false,
     pngQuality: 100,
@@ -201,26 +260,38 @@ const Sharp = function (input, options) {
     tiffCompression: 'jpeg',
     tiffPredictor: 'horizontal',
     tiffPyramid: false,
-    tiffSquash: false,
+    tiffBitdepth: 8,
     tiffTile: false,
     tiffTileHeight: 256,
     tiffTileWidth: 256,
     tiffXres: 1.0,
     tiffYres: 1.0,
-    heifQuality: 80,
+    heifQuality: 50,
     heifLossless: false,
-    heifCompression: 'hevc',
+    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,
+    tileId: 'https://example.com/iiif',
     linearA: 1,
     linearB: 0,
     // Function to notify of libvips warnings
-    debuglog: debuglog,
+    debuglog: warning => {
+      this.emit('warning', warning);
+      debuglog(warning);
+    },
     // Function to notify of queue length changes
     queueListener: function (queueLength) {
-      queue.emit('change', queueLength);
+      Sharp.queue.emit('change', queueLength);
     }
   };
   this.options.input = this._createInputDescriptor(input, options, { allowStream: true });
@@ -229,38 +300,84 @@ const Sharp = function (input, options) {
 util.inherits(Sharp, stream.Duplex);
 
 /**
- * An EventEmitter that emits a `change` event when a task is either:
- * - queued, waiting for _libuv_ to provide a worker thread
- * - complete
- * @member
+ * 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
- * sharp.queue.on('change', function(queueLength) {
- *   console.log('Queue contains ' + queueLength + ' task(s)');
+ * 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}
  */
-const queue = new events.EventEmitter();
-Sharp.queue = queue;
-
-/**
- * An Object containing nested boolean values representing the available input and output formats/methods.
- * @example
- * console.log(sharp.format);
- * @returns {Object}
- */
-Sharp.format = sharp.format();
-
-/**
- * An Object containing the version numbers of libvips and its dependencies.
- * @member
- * @example
- * console.log(sharp.versions);
- */
-Sharp.versions = {
-  vips: sharp.libvipsVersion()
-};
-try {
-  Sharp.versions = require('../vendor/versions.json');
-} catch (err) {}
+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.

lib/input.js

@@ -4,30 +4,50 @@ 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, subifd } = obj;
+  return [raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages, subifd].some(is.defined)
+    ? { raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages, subifd }
+    : undefined;
+}
+
 /**
  * Create Object containing input and input-related options.
  * @private
  */
 function _createInputDescriptor (input, inputOptions, containerOptions) {
-  const inputDescriptor = { failOnError: true };
+  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 (is.plainObject(inputOptions.raw) || is.bool(inputOptions.failOnError)) {
-      // Raw Stream
+    if (_inputOptionsFromObject(inputOptions)) {
+      // Stream with options
       inputDescriptor.buffer = [];
     }
-  } else if (!is.defined(input) && is.object(containerOptions) && containerOptions.allowStream) {
-    // Stream
+  } else if (!is.defined(input) && !is.defined(inputOptions) && is.object(containerOptions) && containerOptions.allowStream) {
+    // Stream without options
     inputDescriptor.buffer = [];
   } else {
-    throw new Error('Unsupported input ' + typeof input);
+    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
@@ -40,10 +60,30 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     }
     // Density
     if (is.defined(inputOptions.density)) {
-      if (is.inRange(inputOptions.density, 1, 2400)) {
+      if (is.inRange(inputOptions.density, 1, 100000)) {
         inputDescriptor.density = inputOptions.density;
       } else {
-        throw is.invalidParameterError('density', 'number between 1 and 2400', inputOptions.density);
+        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
@@ -62,6 +102,13 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
       }
     }
     // 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;
@@ -76,28 +123,72 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         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);
+      }
+    }
+    // Sub Image File Directory (TIFF)
+    if (is.defined(inputOptions.subifd)) {
+      if (is.integer(inputOptions.subifd) && is.inRange(inputOptions.subifd, -1, 100000)) {
+        inputDescriptor.subifd = inputOptions.subifd;
+      } else {
+        throw is.invalidParameterError('subifd', 'integer between -1 and 100000', inputOptions.subifd);
+      }
+    }
     // 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) && is.inRange(inputOptions.create.channels, 3, 4) &&
-        is.defined(inputOptions.create.background)
+        is.integer(inputOptions.create.channels)
       ) {
         inputDescriptor.createWidth = inputOptions.create.width;
         inputDescriptor.createHeight = inputOptions.create.height;
         inputDescriptor.createChannels = inputOptions.create.channels;
-        const background = color(inputOptions.create.background);
-        inputDescriptor.createBackground = [
-          background.red(),
-          background.green(),
-          background.blue(),
-          Math.round(background.alpha() * 255)
-        ];
+        // Noise
+        if (is.defined(inputOptions.create.noise)) {
+          if (!is.object(inputOptions.create.noise)) {
+            throw new Error('Expected noise to be an object');
+          }
+          if (!is.inArray(inputOptions.create.noise.type, ['gaussian'])) {
+            throw new Error('Only gaussian noise is supported at the moment');
+          }
+          if (!is.inRange(inputOptions.create.channels, 1, 4)) {
+            throw is.invalidParameterError('create.channels', 'number between 1 and 4', inputOptions.create.channels);
+          }
+          inputDescriptor.createNoiseType = inputOptions.create.noise.type;
+          if (is.number(inputOptions.create.noise.mean) && is.inRange(inputOptions.create.noise.mean, 0, 10000)) {
+            inputDescriptor.createNoiseMean = inputOptions.create.noise.mean;
+          } else {
+            throw is.invalidParameterError('create.noise.mean', 'number between 0 and 10000', inputOptions.create.noise.mean);
+          }
+          if (is.number(inputOptions.create.noise.sigma) && is.inRange(inputOptions.create.noise.sigma, 0, 10000)) {
+            inputDescriptor.createNoiseSigma = inputOptions.create.noise.sigma;
+          } else {
+            throw is.invalidParameterError('create.noise.sigma', 'number between 0 and 10000', inputOptions.create.noise.sigma);
+          }
+        } else if (is.defined(inputOptions.create.background)) {
+          if (!is.inRange(inputOptions.create.channels, 3, 4)) {
+            throw is.invalidParameterError('create.channels', 'number between 3 and 4', inputOptions.create.channels);
+          }
+          const background = color(inputOptions.create.background);
+          inputDescriptor.createBackground = [
+            background.red(),
+            background.green(),
+            background.blue(),
+            Math.round(background.alpha() * 255)
+          ];
+        } else {
+          throw new Error('Expected valid noise or background to create a new input image');
+        }
         delete inputDescriptor.buffer;
       } else {
-        throw new Error('Expected width, height, channels and background to create a new input image');
+        throw new Error('Expected valid width, height and channels to create a new input image');
       }
     }
   } else if (is.defined(inputOptions)) {
@@ -110,7 +201,7 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
  * Handle incoming Buffer chunk on Writable Stream.
  * @private
  * @param {Buffer} chunk
- * @param {String} encoding - unused
+ * @param {string} encoding - unused
  * @param {Function} callback
  */
 function _write (chunk, encoding, callback) {
@@ -146,43 +237,12 @@ function _flattenBufferIn () {
 /**
  * Are we expecting Stream-based input?
  * @private
- * @returns {Boolean}
+ * @returns {boolean}
  */
 function _isStreamInput () {
   return Array.isArray(this.options.input.buffer);
 }
 
-/**
- * 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
- *
- * @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;
-}
-
 /**
  * Fast access to (uncached) image metadata without decoding any compressed image data.
  * A `Promise` is returned when `callback` is not provided.
@@ -191,15 +251,19 @@ function clone () {
  * - `size`: Total size of image in bytes, for Stream and Buffer input only
  * - `width`: Number of pixels wide (EXIF orientation is not taken into consideration)
  * - `height`: Number of pixels high (EXIF orientation is not taken into consideration)
- * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L636)
+ * - `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://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L672)
+ * - `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 this PDF image will be.
+ * - `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
+ * - `subifds`: Number of Sub Image File Directories in an OME-TIFF image
  * - `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
@@ -280,8 +344,10 @@ function metadata (callback) {
  *     - `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`: Value to identify if the image is opaque or transparent, based on the presence and use of alpha channel
+ * - `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);
@@ -291,6 +357,10 @@ function metadata (callback) {
  *      // 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>}
  */
@@ -333,43 +403,6 @@ function stats (callback) {
   }
 }
 
-/**
- * Do not process input images where the number of pixels (width x height) exceeds this limit.
- * Assumes image dimensions contained in the input metadata can be trusted.
- * The default limit is 268402689 (0x3FFF x 0x3FFF) pixels.
- * @param {(Number|Boolean)} limit - an integral Number of pixels, zero or false to remove limit, true to use default limit.
- * @returns {Sharp}
- * @throws {Error} Invalid limit
-*/
-function limitInputPixels (limit) {
-  // if we pass in false we represent the integer as 0 to disable
-  if (limit === false) {
-    limit = 0;
-  } else if (limit === true) {
-    limit = Math.pow(0x3FFF, 2);
-  }
-  if (is.integer(limit) && limit >= 0) {
-    this.options.limitInputPixels = limit;
-  } else {
-    throw is.invalidParameterError('limitInputPixels', 'integer', limit);
-  }
-  return this;
-}
-
-/**
- * An advanced setting that switches the libvips access method to `VIPS_ACCESS_SEQUENTIAL`.
- * This will reduce memory usage and can improve performance on some systems.
- *
- * The default behaviour *before* function call is `false`, meaning the libvips access method is not sequential.
- *
- * @param {Boolean} [sequentialRead=true]
- * @returns {Sharp}
- */
-function sequentialRead (sequentialRead) {
-  this.options.sequentialRead = is.bool(sequentialRead) ? sequentialRead : true;
-  return this;
-}
-
 /**
  * Decorate the Sharp prototype with input-related functions.
  * @private
@@ -377,15 +410,13 @@ function sequentialRead (sequentialRead) {
 module.exports = function (Sharp) {
   Object.assign(Sharp.prototype, {
     // Private
+    _inputOptionsFromObject,
     _createInputDescriptor,
     _write,
     _flattenBufferIn,
     _isStreamInput,
     // Public
-    clone,
     metadata,
-    stats,
-    limitInputPixels,
-    sequentialRead
+    stats
   });
 };

lib/is.js

@@ -21,7 +21,7 @@ const object = function (val) {
  * @private
  */
 const plainObject = function (val) {
-  return object(val) && Object.prototype.toString.call(val) === '[object Object]';
+  return Object.prototype.toString.call(val) === '[object Object]';
 };
 
 /**
@@ -45,7 +45,16 @@ const bool = function (val) {
  * @private
  */
 const buffer = function (val) {
-  return object(val) && val instanceof Buffer;
+  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;
 };
 
 /**
@@ -69,7 +78,7 @@ const number = function (val) {
  * @private
  */
 const integer = function (val) {
-  return number(val) && val % 1 === 0;
+  return Number.isInteger(val);
 };
 
 /**
@@ -85,14 +94,14 @@ const inRange = function (val, min, max) {
  * @private
  */
 const inArray = function (val, list) {
-  return list.indexOf(val) !== -1;
+  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 {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
@@ -110,6 +119,7 @@ module.exports = {
   fn: fn,
   bool: bool,
   buffer: buffer,
+  uint8Array: uint8Array,
   string: string,
   number: number,
   integer: integer,

lib/libvips.js

@@ -8,8 +8,9 @@ const semver = require('semver');
 const platform = require('./platform');
 
 const env = process.env;
-const minimumLibvipsVersion = env.npm_package_config_libvips || /* istanbul ignore next */
+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',
@@ -36,10 +37,28 @@ const cachePath = function () {
   return libvipsCachePath;
 };
 
+const log = function (item) {
+  if (item instanceof Error) {
+    console.error(`sharp: Installation error: ${item.message}`);
+  } else {
+    console.log(`sharp: ${item}`);
+  }
+};
+
+const isRosetta = function () {
+  /* istanbul ignore next */
+  if (process.platform === 'darwin' && process.arch === 'x64') {
+    const translated = spawnSync('sysctl sysctl.proc_translated', spawnSyncOptions).stdout;
+    return (translated || '').trim() === 'sysctl.proc_translated: 1';
+  }
+  return false;
+};
+
 const globalLibvipsVersion = function () {
   if (process.platform !== 'win32') {
-    const globalLibvipsVersion = spawnSync(`PKG_CONFIG_PATH="${pkgConfigPath()}" pkg-config --modversion vips-cpp`, spawnSyncOptions).stdout || '';
-    return globalLibvipsVersion.trim();
+    const globalLibvipsVersion = spawnSync(`PKG_CONFIG_PATH="${pkgConfigPath()}" pkg-config --modversion vips-cpp`, spawnSyncOptions).stdout;
+    /* istanbul ignore next */
+    return (globalLibvipsVersion || '').trim();
   } else {
     return '';
   }
@@ -47,24 +66,18 @@ const globalLibvipsVersion = function () {
 
 const hasVendoredLibvips = function () {
   const currentPlatformId = platform();
-  const vendorPath = path.join(__dirname, '..', 'vendor');
-  let vendorVersionId;
+  const vendorPath = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion);
   let vendorPlatformId;
   try {
-    vendorVersionId = require(path.join(vendorPath, 'versions.json')).vips;
     vendorPlatformId = require(path.join(vendorPath, 'platform.json'));
   } catch (err) {}
-  /* istanbul ignore if */
-  if (vendorVersionId && vendorVersionId !== minimumLibvipsVersion) {
-    throw new Error(`Found vendored libvips v${vendorVersionId} but require v${minimumLibvipsVersion}. Please remove the 'node_modules/sharp/vendor' directory and run 'npm install'.`);
-  }
   /* 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/vendor' directory and run 'npm install'.`);
+      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;
@@ -86,18 +99,23 @@ 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: minimumLibvipsVersion,
-  cachePath: cachePath,
-  globalLibvipsVersion: globalLibvipsVersion,
-  hasVendoredLibvips: hasVendoredLibvips,
-  pkgConfigPath: pkgConfigPath,
-  useGlobalLibvips: useGlobalLibvips,
-  mkdirSync: mkdirSync
+  minimumLibvipsVersion,
+  minimumLibvipsVersionLabelled,
+  cachePath,
+  log,
+  globalLibvipsVersion,
+  hasVendoredLibvips,
+  pkgConfigPath,
+  useGlobalLibvips,
+  mkdirSync
 };

lib/operation.js

@@ -32,9 +32,9 @@ const is = require('./is');
  *   });
  * readableStream.pipe(pipeline);
  *
- * @param {Number} [angle=auto] angle of rotation.
+ * @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.
+ * @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
  */
@@ -82,15 +82,112 @@ function flop (flop) {
   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 = [].concat(...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.
+ * @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
  */
@@ -129,7 +226,7 @@ function sharpen (sigma, flat, jagged) {
 /**
  * Apply median filter.
  * When used without parameters the default window is 3x3.
- * @param {Number} [size=3] square mask size: size x size
+ * @param {number} [size=3] square mask size: size x size
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -150,7 +247,7 @@ function median (size) {
  * 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`.
+ * @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
  */
@@ -171,9 +268,15 @@ function blur (sigma) {
 }
 
 /**
- * Merge alpha transparency channel, if any, with a background.
+ * Merge alpha transparency channel, if any, with a background, then remove the alpha channel.
+ *
+ * @example
+ * await sharp(rgbaInput)
+ *   .flatten('#F0A703')
+ *   .toBuffer();
+ *
  * @param {Object} [options]
- * @param {String|Object} [options.background={r: 0, g: 0, b: 0}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black.
+ * @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) {
@@ -193,8 +296,8 @@ function flatten (options) {
  *
  * 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`)
+ * @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
  */
@@ -264,11 +367,11 @@ function normalize (normalize) {
  *   });
  *
  * @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.
+ * @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
  */
@@ -299,8 +402,8 @@ function convolve (kernel) {
 }
 
 /**
- * Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
- * @param {Number} [threshold=128] - a value in the range 0-255 representing the level at which the threshold will be applied.
+ * Any pixel value greater than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+ * @param {number} [threshold=128] - a value in the range 0-255 representing the level at which the threshold will be applied.
  * @param {Object} [options]
  * @param {Boolean} [options.greyscale=true] - convert to single channel greyscale.
  * @param {Boolean} [options.grayscale=true] - alternative spelling for greyscale.
@@ -331,13 +434,13 @@ function threshold (threshold, options) {
  * 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 {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]
+ * @param {number} [options.raw.width]
+ * @param {number} [options.raw.height]
+ * @param {number} [options.raw.channels]
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -353,8 +456,8 @@ function boolean (operand, operator, options) {
 
 /**
  * Apply the linear formula a * input + b to the image (levels adjustment)
- * @param {Number} [a=1.0] multiplier
- * @param {Number} [b=0.0] offset
+ * @param {number} [a=1.0] multiplier
+ * @param {number} [b=0.0] offset
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -379,6 +482,8 @@ function linear (a, b) {
 /**
  * Recomb the image with the specified matrix.
  *
+ * @since 0.21.1
+ *
  * @example
  * sharp(input)
  *   .recomb([
@@ -392,7 +497,7 @@ function linear (a, b) {
  *     // With this example input, a sepia filter has been applied
  *   });
  *
- * @param {Array<Array<Number>>} 3x3 Recombination matrix
+ * @param {Array<Array<number>>} inputMatrix - 3x3 Recombination matrix
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -416,6 +521,8 @@ function recomb (inputMatrix) {
 /**
  * Transforms the image using brightness, saturation and hue rotation.
  *
+ * @since 0.22.1
+ *
  * @example
  * sharp(input)
  *   .modulate({
@@ -436,9 +543,9 @@ function recomb (inputMatrix) {
  *   });
  *
  * @param {Object} [options]
- * @param {Number} [options.brightness] Brightness multiplier
- * @param {Number} [options.saturation] Saturation multiplier
- * @param {Number} [options.hue] Degrees for hue rotation
+ * @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) {
@@ -478,6 +585,7 @@ module.exports = function (Sharp) {
     rotate,
     flip,
     flop,
+    affine,
     sharpen,
     median,
     blur,

lib/output.js

@@ -3,11 +3,26 @@
 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, TIFF, DZI, and libvips' V format supported.
+ * 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.
@@ -25,7 +40,7 @@ const sharp = require('../build/Release/sharp.node');
  *   .then(info => { ... })
  *   .catch(err => { ... });
  *
- * @param {String} fileOut - the path to write the image data to.
+ * @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).
@@ -34,32 +49,30 @@ const sharp = require('../build/Release/sharp.node');
  * @throws {Error} Invalid parameters
  */
 function toFile (fileOut, callback) {
-  if (!fileOut || fileOut.length === 0) {
-    const errOutputInvalid = new Error('Missing output file path');
+  let err;
+  if (!is.string(fileOut)) {
+    err = new Error('Missing output file path');
+  } else if (this.options.input.file === fileOut) {
+    err = new Error('Cannot use same file for input and output');
+  } else if (this.options.formatOut === 'input' && fileOut.toLowerCase().endsWith('.gif') && !this.constructor.format.magick.output.file) {
+    err = errMagickSave;
+  }
+  if (err) {
     if (is.fn(callback)) {
-      callback(errOutputInvalid);
+      callback(err);
     } else {
-      return Promise.reject(errOutputInvalid);
+      return Promise.reject(err);
     }
   } else {
-    if (this.options.input.file === fileOut) {
-      const errOutputIsInput = new Error('Cannot use same file for input and output');
-      if (is.fn(callback)) {
-        callback(errOutputIsInput);
-      } else {
-        return Promise.reject(errOutputIsInput);
-      }
-    } else {
-      this.options.fileOut = fileOut;
-      return this._pipeline(callback);
-    }
+    this.options.fileOut = fileOut;
+    return this._pipeline(callback);
   }
   return this;
 }
 
 /**
  * Write output to a Buffer.
- * JPEG, PNG, WebP, TIFF and RAW output are supported.
+ * 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.
  *
@@ -91,8 +104,24 @@ function toFile (fileOut, callback) {
  *   .then(({ data, info }) => { ... })
  *   .catch(err => { ... });
  *
+ * @example
+ * const { data, info } = await sharp('my-image.jpg')
+ *   // output the raw pixels
+ *   .raw()
+ *   .toBuffer({ resolveWithObject: true });
+ *
+ * // create a more type safe way to work with the raw pixel data
+ * // this will not copy the data, instead it will change `data`s underlying ArrayBuffer
+ * // so `data` and `pixelArray` point to the same memory location
+ * const pixelArray = new Uint8ClampedArray(data.buffer);
+ *
+ * // When you are done changing the pixelArray, sharp takes the `pixelArray` as an input
+ * const { width, height, channels } = info;
+ * await sharp(pixelArray, { raw: { width, height, channels } })
+ *   .toFile('my-changed-image.jpg');
+ *
  * @param {Object} [options]
- * @param {Boolean} [options.resolveWithObject] Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
+ * @param {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
  */
@@ -107,8 +136,11 @@ function toBuffer (options, callback) {
 
 /**
  * Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
- * The default behaviour, when `withMetadata` is not used, is to strip all metadata and convert to the device-independent sRGB colour space.
- * This will also convert to and add a web-friendly sRGB ICC profile.
+ * 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')
@@ -116,8 +148,22 @@ function toBuffer (options, callback) {
  *   .toFile('output-with-metadata.jpg')
  *   .then(info => { ... });
  *
+ * @example
+ * // Set "IFD0-Copyright" in output EXIF metadata
+ * await sharp(input)
+ *   .withMetadata({
+ *     exif: {
+ *       IFD0: {
+ *         Copyright: 'Wernham Hogg'
+ *       }
+ *     }
+ *   })
+ *   .toBuffer();
+ *
  * @param {Object} [options]
- * @param {Number} [options.orientation] value between 1 and 8, used to update the EXIF `Orientation` tag.
+ * @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.
+ * @param {Object<Object>} [options.exif={}] Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -131,10 +177,58 @@ function withMetadata (options) {
         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);
+      }
+    }
+    if (is.defined(options.exif)) {
+      if (is.object(options.exif)) {
+        for (const [ifd, entries] of Object.entries(options.exif)) {
+          if (is.object(entries)) {
+            for (const [k, v] of Object.entries(entries)) {
+              if (is.string(v)) {
+                this.options.withMetadataStrs[`exif-${ifd.toLowerCase()}-${k}`] = v;
+              } else {
+                throw is.invalidParameterError(`exif.${ifd}.${k}`, 'string', v);
+              }
+            }
+          } else {
+            throw is.invalidParameterError(`exif.${ifd}`, 'object', entries);
+          }
+        }
+      } else {
+        throw is.invalidParameterError('exif', 'object', options.exif);
+      }
+    }
   }
   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.
  *
@@ -147,19 +241,26 @@ function withMetadata (options) {
  *   })
  *   .toBuffer();
  *
+ * @example
+ * // Use mozjpeg to reduce output JPEG file size (slower)
+ * const data = await sharp(input)
+ *   .jpeg({ mozjpeg: true })
+ *   .toBuffer();
+ *
  * @param {Object} [options] - output options
- * @param {Number} [options.quality=80] - quality, integer 1-100
- * @param {Boolean} [options.progressive=false] - use progressive (interlace) scan
- * @param {String} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling when quality <= 90
- * @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
- * @param {Boolean} [options.optimiseCoding=true] - optimise Huffman coding tables
- * @param {Boolean} [options.optimizeCoding=true] - alternative spelling of optimiseCoding
- * @param {Number} [options.quantisationTable=0] - quantization table to use, integer 0-8, requires libvips compiled with support for mozjpeg
- * @param {Number} [options.quantizationTable=0] - alternative spelling of quantisationTable
- * @param {Boolean} [options.force=true] - force JPEG output, otherwise attempt to use input format
+ * @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.mozjpeg=false] - use mozjpeg defaults, equivalent to `{ trellisQuantisation: true, overshootDeringing: true, optimiseScans: true, quantisationTable: 3 }`
+ * @param {boolean} [options.trellisQuantisation=false] - apply trellis quantisation
+ * @param {boolean} [options.overshootDeringing=false] - apply overshoot deringing
+ * @param {boolean} [options.optimiseScans=false] - optimise progressive scans, forces progressive
+ * @param {boolean} [options.optimizeScans=false] - alternative spelling of optimiseScans
+ * @param {number} [options.quantisationTable=0] - quantization table to use, integer 0-8
+ * @param {number} [options.quantizationTable=0] - alternative spelling of quantisationTable
+ * @param {boolean} [options.force=true] - force JPEG output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -182,6 +283,23 @@ function jpeg (options) {
         throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
       }
     }
+    const optimiseCoding = is.bool(options.optimizeCoding) ? options.optimizeCoding : options.optimiseCoding;
+    if (is.defined(optimiseCoding)) {
+      this._setBooleanOption('jpegOptimiseCoding', optimiseCoding);
+    }
+    if (is.defined(options.mozjpeg)) {
+      if (is.bool(options.mozjpeg)) {
+        if (options.mozjpeg) {
+          this.options.jpegTrellisQuantisation = true;
+          this.options.jpegOvershootDeringing = true;
+          this.options.jpegOptimiseScans = true;
+          this.options.jpegProgressive = true;
+          this.options.jpegQuantisationTable = 3;
+        }
+      } else {
+        throw is.invalidParameterError('mozjpeg', 'boolean', options.mozjpeg);
+      }
+    }
     const trellisQuantisation = is.bool(options.trellisQuantization) ? options.trellisQuantization : options.trellisQuantisation;
     if (is.defined(trellisQuantisation)) {
       this._setBooleanOption('jpegTrellisQuantisation', trellisQuantisation);
@@ -196,10 +314,6 @@ function jpeg (options) {
         this.options.jpegProgressive = true;
       }
     }
-    const optimiseCoding = is.bool(options.optimizeCoding) ? options.optimizeCoding : options.optimiseCoding;
-    if (is.defined(optimiseCoding)) {
-      this._setBooleanOption('jpegOptimiseCoding', optimiseCoding);
-    }
     const quantisationTable = is.number(options.quantizationTable) ? options.quantizationTable : options.quantisationTable;
     if (is.defined(quantisationTable)) {
       if (is.integer(quantisationTable) && is.inRange(quantisationTable, 0, 8)) {
@@ -215,25 +329,32 @@ function jpeg (options) {
 /**
  * Use these PNG options for output image.
  *
- * PNG output is always full colour at 8 or 16 bits per pixel.
+ * By default, PNG output is full colour at 8 or 16 bits per pixel.
  * Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
+ * Set `palette` to `true` for slower, indexed PNG output.
  *
  * @example
- * // Convert any input to PNG output
+ * // Convert any input to full colour PNG output
  * const data = await sharp(input)
  *   .png()
  *   .toBuffer();
  *
+ * @example
+ * // Convert any input to indexed PNG output (slower)
+ * const data = await sharp(input)
+ *   .png({ palette: true })
+ *   .toBuffer();
+ *
  * @param {Object} [options]
- * @param {Boolean} [options.progressive=false] - use progressive (interlace) scan
- * @param {Number} [options.compressionLevel=9] - zlib compression level, 0-9
- * @param {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, requires libvips compiled with support for libimagequant
- * @param {Number} [options.colours=256] - maximum number of palette entries, requires libvips compiled with support for libimagequant
- * @param {Number} [options.colors=256] - alternative spelling of `options.colours`, requires libvips compiled with support for libimagequant
- * @param {Number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, requires libvips compiled with support for libimagequant
- * @param {Boolean} [options.force=true] - force PNG output, otherwise attempt to use input format
+ * @param {boolean} [options.progressive=false] - use progressive (interlace) scan
+ * @param {number} [options.compressionLevel=6] - zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest)
+ * @param {boolean} [options.adaptiveFiltering=false] - use adaptive row filtering
+ * @param {boolean} [options.palette=false] - quantise to a palette-based image with alpha transparency support
+ * @param {number} [options.quality=100] - use the lowest number of colours needed to achieve given quality, sets `palette` to `true`
+ * @param {number} [options.colours=256] - maximum number of palette entries, sets `palette` to `true`
+ * @param {number} [options.colors=256] - alternative spelling of `options.colours`, sets `palette` to `true`
+ * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, sets `palette` to `true`
+ * @param {boolean} [options.force=true] - force PNG output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -254,28 +375,30 @@ function png (options) {
     }
     if (is.defined(options.palette)) {
       this._setBooleanOption('pngPalette', options.palette);
-      if (this.options.pngPalette) {
-        if (is.defined(options.quality)) {
-          if (is.integer(options.quality) && is.inRange(options.quality, 0, 100)) {
-            this.options.pngQuality = options.quality;
-          } else {
-            throw is.invalidParameterError('quality', 'integer between 0 and 100', options.quality);
-          }
+    } 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);
-          }
+      }
+      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);
-          }
+      }
+      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);
         }
       }
     }
@@ -292,14 +415,23 @@ function png (options) {
  *   .webp({ lossless: true })
  *   .toBuffer();
  *
+ * @example
+ * // Optimise the file size of an animated WebP
+ * const outputWebp = await sharp(inputWebp, { animated: true })
+ *   .webp({ reductionEffort: 6 })
+ *   .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 {Boolean} [options.force=true] - force WebP output, otherwise attempt to use input format
+ * @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
  */
@@ -334,9 +466,73 @@ function webp (options) {
       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.
  *
@@ -345,23 +541,23 @@ function webp (options) {
  * sharp('input.svg')
  *   .tiff({
  *     compression: 'lzw',
- *     squash: true
+ *     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 {Boolean} [options.compression='jpeg'] - compression options: lzw, deflate, jpeg, ccittfax4
- * @param {Boolean} [options.predictor='horizontal'] - compression predictor options: none, horizontal, float
- * @param {Boolean} [options.pyramid=false] - write an image pyramid
- * @param {Boolean} [options.tile=false] - write a tiled tiff
- * @param {Boolean} [options.tileWidth=256] - horizontal tile size
- * @param {Boolean} [options.tileHeight=256] - vertical tile size
- * @param {Number} [options.xres=1.0] - horizontal resolution in pixels/mm
- * @param {Number} [options.yres=1.0] - vertical resolution in pixels/mm
- * @param {Boolean} [options.squash=false] - squash 8-bit images down to 1 bit
+ * @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
  */
@@ -374,8 +570,12 @@ function tiff (options) {
         throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
       }
     }
-    if (is.defined(options.squash)) {
-      this._setBooleanOption('tiffSquash', options.squash);
+    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)) {
@@ -435,26 +635,43 @@ function tiff (options) {
 }
 
 /**
- * Use these HEIF options for output image.
+ * Use these AVIF options for output image.
  *
- * Support for HEIF (HEIC/AVIF) is experimental.
- * Do not use this in production systems.
+ * Whilst it is possible to create AVIF images smaller than 16x16 pixels,
+ * most web browsers do not display these properly.
  *
- * Requires a custom, globally-installed libvips compiled with support for libheif.
- *
- * Most versions of libheif support only the patent-encumbered HEVC compression format.
+ * @since 0.27.0
  *
  * @param {Object} [options] - output options
- * @param {Number} [options.quality=80] - quality, integer 1-100
- * @param {Boolean} [options.compression='hevc'] - compression format: hevc, avc, jpeg, av1
- * @param {Boolean} [options.lossless=false] - use lossless compression
+ * @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 (!this.constructor.format.heif.output.buffer) {
-    throw new Error('The heif operation requires libvips to have been installed with support for libheif');
-  }
   if (is.object(options)) {
     if (is.defined(options.quality)) {
       if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
@@ -471,10 +688,24 @@ function heif (options) {
       }
     }
     if (is.defined(options.compression)) {
-      if (is.string(options.compression) && is.inArray(options.compression, ['hevc', 'avc', 'jpeg', 'av1'])) {
+      if (is.string(options.compression) && is.inArray(options.compression, ['av1', 'hevc'])) {
         this.options.heifCompression = options.compression;
       } else {
-        throw is.invalidParameterError('compression', 'one of: hevc, avc, jpeg, av1', options.compression);
+        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);
       }
     }
   }
@@ -482,7 +713,9 @@ function heif (options) {
 }
 
 /**
- * Force output to be raw, uncompressed uint8 pixel data.
+ * 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
@@ -490,45 +723,21 @@ function heif (options) {
  *   .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');
 }
 
-const formats = new Map([
-  ['heic', 'heif'],
-  ['heif', 'heif'],
-  ['jpeg', 'jpeg'],
-  ['jpg', 'jpeg'],
-  ['png', 'png'],
-  ['raw', 'raw'],
-  ['tiff', 'tiff'],
-  ['webp', 'webp']
-]);
-
-/**
- * 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);
-  if (!actualFormat) {
-    throw is.invalidParameterError('format', `one of: ${[...formats.keys()].join(', ')}`, format);
-  }
-  return this[actualFormat](options);
-}
-
 /**
  * Use tile-based deep zoom (image pyramid) output.
  * Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
@@ -548,14 +757,17 @@ function toFormat (format, options) {
  *   });
  *
  * @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`, `zoomify` or `google`.
+ * @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.
+ * @param {string} [options.id='https://example.com/iiif'] when `layout` is `iiif`, sets the `@id` attribute of `info.json`
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -590,10 +802,10 @@ function tile (options) {
     }
     // Layout
     if (is.defined(options.layout)) {
-      if (is.string(options.layout) && is.inArray(options.layout, ['dz', 'google', 'zoomify'])) {
+      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, zoomify', options.layout);
+        throw is.invalidParameterError('layout', 'one of: dz, google, iiif, zoomify', options.layout);
       }
     }
     // Angle of rotation,
@@ -624,6 +836,19 @@ function tile (options) {
     } 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);
+    }
+    // @id attribute for IIIF layout
+    if (is.defined(options.id)) {
+      if (is.string(options.id)) {
+        this.options.tileId = options.id;
+      } else {
+        throw is.invalidParameterError('id', 'string', options.id);
+      }
+    }
   }
   // Format
   if (is.inArray(this.options.formatOut, ['jpeg', 'png', 'webp'])) {
@@ -638,9 +863,9 @@ function tile (options) {
  * Update the output format unless options.force is false,
  * in which case revert to input format.
  * @private
- * @param {String} formatOut
+ * @param {string} formatOut
  * @param {Object} [options]
- * @param {Boolean} [options.force=true] - force output format, otherwise attempt to use input format
+ * @param {boolean} [options.force=true] - force output format, otherwise attempt to use input format
  * @returns {Sharp}
  */
 function _updateFormatOut (formatOut, options) {
@@ -651,10 +876,10 @@ function _updateFormatOut (formatOut, options) {
 }
 
 /**
- * Update a Boolean attribute of the this.options Object.
+ * Update a boolean attribute of the this.options Object.
  * @private
- * @param {String} key
- * @param {Boolean} val
+ * @param {string} key
+ * @param {boolean} val
  * @throws {Error} Invalid key
  */
 function _setBooleanOption (key, val) {
@@ -777,13 +1002,15 @@ module.exports = function (Sharp) {
     toFile,
     toBuffer,
     withMetadata,
+    toFormat,
     jpeg,
     png,
     webp,
     tiff,
+    avif,
     heif,
+    gif,
     raw,
-    toFormat,
     tile,
     // Private
     _updateFormatOut,

lib/platform.js

@@ -13,7 +13,8 @@ module.exports = function () {
   const platformId = [`${platform}${libc}`];
 
   if (arch === 'arm') {
-    platformId.push(`armv${env.npm_config_arm_version || process.config.variables.arm_version || '6'}`);
+    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 {

lib/resize.js

@@ -85,21 +85,30 @@ const mapFitToCanvas = {
   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`: Crop to cover both provided dimensions (the default).
- * - `contain`: Embed within both provided dimensions.
+ * - `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
@@ -173,8 +182,16 @@ const mapFitToCanvas = {
  *     // and no larger than the input image
  *   });
  *
- * @param {Number} [width] - pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
- * @param {Number} [height] - pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
+ * @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.
@@ -285,11 +302,20 @@ function resize (width, height, options) {
  *   })
  *   ...
  *
- * @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]
+* @example
+ * // Add a row of 10 red pixels to the bottom
+ * sharp(input)
+ *   .extend({
+ *     bottom: 10,
+ *     background: 'red'
+ *   })
+ *   ...
+ *
+ * @param {(number|Object)} extend - single pixel count to add to all edges or an Object with per-edge counts
+ * @param {number} [extend.top=0]
+ * @param {number} [extend.left=0]
+ * @param {number} [extend.bottom=0]
+ * @param {number} [extend.right=0]
  * @param {String|Object} [extend.background={r: 0, g: 0, b: 0, alpha: 1}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black without transparency.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
@@ -300,17 +326,35 @@ function extend (extend) {
     this.options.extendBottom = extend;
     this.options.extendLeft = extend;
     this.options.extendRight = extend;
-  } else if (
-    is.object(extend) &&
-    is.integer(extend.top) && extend.top >= 0 &&
-    is.integer(extend.bottom) && extend.bottom >= 0 &&
-    is.integer(extend.left) && extend.left >= 0 &&
-    is.integer(extend.right) && extend.right >= 0
-  ) {
-    this.options.extendTop = extend.top;
-    this.options.extendBottom = extend.bottom;
-    this.options.extendLeft = extend.left;
-    this.options.extendRight = extend.right;
+  } else if (is.object(extend)) {
+    if (is.defined(extend.top)) {
+      if (is.integer(extend.top) && extend.top >= 0) {
+        this.options.extendTop = extend.top;
+      } else {
+        throw is.invalidParameterError('top', 'positive integer', extend.top);
+      }
+    }
+    if (is.defined(extend.bottom)) {
+      if (is.integer(extend.bottom) && extend.bottom >= 0) {
+        this.options.extendBottom = extend.bottom;
+      } else {
+        throw is.invalidParameterError('bottom', 'positive integer', extend.bottom);
+      }
+    }
+    if (is.defined(extend.left)) {
+      if (is.integer(extend.left) && extend.left >= 0) {
+        this.options.extendLeft = extend.left;
+      } else {
+        throw is.invalidParameterError('left', 'positive integer', extend.left);
+      }
+    }
+    if (is.defined(extend.right)) {
+      if (is.integer(extend.right) && extend.right >= 0) {
+        this.options.extendRight = extend.right;
+      } else {
+        throw is.invalidParameterError('right', 'positive integer', extend.right);
+      }
+    }
     this._setBackgroundColourOption('extendBackground', extend.background);
   } else {
     throw is.invalidParameterError('extend', 'integer or object', extend);
@@ -319,7 +363,7 @@ function extend (extend) {
 }
 
 /**
- * Extract a region of the image.
+ * Extract/crop a region of the image.
  *
  * - Use `extract` before `resize` for pre-resize extraction.
  * - Use `extract` after `resize` for post-resize extraction.
@@ -341,10 +385,10 @@ function extend (extend) {
  *   });
  *
  * @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
+ * @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
  */
@@ -359,7 +403,7 @@ function extract (options) {
     }
   }, this);
   // Ensure existing rotation occurs before pre-resize extraction
-  if (suffix === 'Pre' && ((this.options.angle % 360) !== 0 || this.options.useExifOrientation === true || this.options.rotationAngle !== 0)) {
+  if (suffix === 'Pre' && isRotationExpected(this.options)) {
     this.options.rotateBeforePreExtract = true;
   }
   return this;
@@ -369,9 +413,10 @@ function extract (options) {
  * 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 will contain `trimOffsetLeft` and `trimOffsetTop` properties.
+ * 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.
+ * @param {number} [threshold=10] the allowed difference from the top-left pixel, a number greater than zero.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -383,6 +428,9 @@ function trim (threshold) {
   } else {
     throw is.invalidParameterError('threshold', 'number greater than zero', threshold);
   }
+  if (this.options.trimThreshold && isRotationExpected(this.options)) {
+    this.options.rotateBeforePreExtract = true;
+  }
   return this;
 }
 

lib/utility.js

@@ -1,8 +1,53 @@
 'use strict';
 
+const events = require('events');
+const detectLibc = require('detect-libc');
+
 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.
@@ -16,10 +61,10 @@ const sharp = require('../build/Release/sharp.node');
  * 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
+ * @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) {
@@ -41,8 +86,12 @@ cache(true);
 /**
  * Gets or, when a concurrency is provided, sets
  * the number of threads _libvips'_ should create to process each image.
- * The default value is the number of CPU cores.
- * A value of `0` will reset to this default.
+ *
+ * The default value is the number of CPU cores,
+ * except when using glibc-based Linux without jemalloc,
+ * where the default is `1` to help reduce memory fragmentation.
+ *
+ * A value of `0` will reset this to the number of CPU cores.
  *
  * The maximum number of images that can be processed in parallel
  * is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
@@ -54,12 +103,29 @@ cache(true);
  * sharp.concurrency(2); // 2
  * sharp.concurrency(0); // 4
  *
- * @param {Number} [concurrency]
- * @returns {Number} concurrency
+ * @param {number} [concurrency]
+ * @returns {number} concurrency
  */
 function concurrency (concurrency) {
   return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
 }
+/* istanbul ignore next */
+if (detectLibc.family === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+  // Reduce default concurrency to 1 when using glibc memory allocator
+  sharp.concurrency(1);
+}
+
+/**
+ * An EventEmitter that emits a `change` event when a task is either:
+ * - 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.
@@ -89,8 +155,8 @@ function counters () {
  * const simd = sharp.simd(false);
  * // prevent libvips from using liborc at runtime
  *
- * @param {Boolean} [simd=true]
- * @returns {Boolean}
+ * @param {boolean} [simd=true]
+ * @returns {boolean}
  */
 function simd (simd) {
   return sharp.simd(is.bool(simd) ? simd : null);
@@ -102,12 +168,12 @@ simd(true);
  * @private
  */
 module.exports = function (Sharp) {
-  [
-    cache,
-    concurrency,
-    counters,
-    simd
-  ].forEach(function (f) {
-    Sharp[f.name] = f;
-  });
+  Sharp.cache = cache;
+  Sharp.concurrency = concurrency;
+  Sharp.counters = counters;
+  Sharp.simd = simd;
+  Sharp.format = format;
+  Sharp.interpolators = interpolators;
+  Sharp.versions = versions;
+  Sharp.queue = queue;
 };

mkdocs.yml

@@ -1,27 +0,0 @@
-site_name: sharp
-site_url: https://sharp.pixelplumbing.com/
-repo_url: https://github.com/lovell/sharp
-site_description: High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images
-copyright: <a href="https://pixelplumbing.com/">pixelplumbing.com</a>
-google_analytics: ['UA-13034748-12', 'sharp.pixelplumbing.com']
-theme: readthedocs
-extra_css:
-  - css/extra.css
-markdown_extensions:
-  - toc:
-      permalink: True
-pages:
-  - Home: index.md
-  - Installation: install.md
-  - API:
-    - Constructor: api-constructor.md
-    - Input: api-input.md
-    - Output: api-output.md
-    - "Resizing images": api-resize.md
-    - "Compositing images": api-composite.md
-    - "Image operations": api-operation.md
-    - "Colour manipulation": api-colour.md
-    - "Channel manipulation": api-channel.md
-    - Utilities: api-utility.md
-  - Performance: performance.md
-  - Changelog: changelog.md

package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
-  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images",
-  "version": "0.23.4",
+  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, AVIF and TIFF images",
+  "version": "0.28.1",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -64,23 +64,33 @@
     "Ilya Ovdin <iovdin@gmail.com>",
     "Andargor <andargor@yahoo.com>",
     "Paul Neave <paul.neave@gmail.com>",
-    "Brendan Kennedy <brenwken@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 && prebuild-ci",
-    "test-unit": "nyc --reporter=lcov --branches=99 mocha --slow=5000 --timeout=60000 ./test/unit/*.js",
+    "test": "semistandard && cpplint && npm run test-unit && npm run test-licensing",
+    "test-unit": "nyc --reporter=lcov --branches=99 mocha --slow=1000 --timeout=60000 ./test/unit/*.js",
     "test-licensing": "license-checker --production --summary --onlyAllow=\"Apache-2.0;BSD;ISC;MIT\"",
     "test-coverage": "./test/coverage/report.sh",
     "test-leak": "./test/leak/leak.sh",
-    "docs": "for m in constructor input resize composite operation colour channel output utility; do documentation build --shallow --format=md --markdown-toc=false lib/$m.js >docs/api-$m.md; done"
+    "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",
-    "docs/**",
-    "!docs/css/**",
     "install/**",
     "lib/**",
     "src/**"
@@ -93,6 +103,7 @@
     "jpeg",
     "png",
     "webp",
+    "avif",
     "tiff",
     "gif",
     "svg",
@@ -106,42 +117,47 @@
     "vips"
   ],
   "dependencies": {
-    "color": "^3.1.2",
+    "color": "^3.1.3",
     "detect-libc": "^1.0.3",
-    "nan": "^2.14.0",
-    "npmlog": "^4.1.2",
-    "prebuild-install": "^5.3.3",
-    "semver": "^6.3.0",
+    "node-addon-api": "^3.1.0",
+    "prebuild-install": "^6.1.1",
+    "semver": "^7.3.5",
     "simple-get": "^3.1.0",
-    "tar": "^5.0.5",
+    "tar-fs": "^2.1.1",
     "tunnel-agent": "^0.6.0"
   },
   "devDependencies": {
-    "async": "^3.1.0",
-    "cc": "^2.0.1",
-    "decompress-zip": "^0.3.2",
-    "documentation": "^12.1.4",
+    "async": "^3.2.0",
+    "cc": "^3.0.1",
+    "decompress-zip": "^0.3.3",
+    "documentation": "^13.2.0",
     "exif-reader": "^1.0.3",
-    "icc": "^1.0.0",
+    "icc": "^2.0.0",
     "license-checker": "^25.0.1",
-    "mocha": "^6.2.2",
-    "mock-fs": "^4.10.4",
-    "nyc": "^14.1.1",
-    "prebuild": "^9.1.1",
-    "prebuild-ci": "^3.1.0",
-    "rimraf": "^3.0.0",
-    "semistandard": "^14.2.0"
+    "mocha": "^8.3.2",
+    "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.8.1"
+    "libvips": "8.10.6",
+    "runtime": "napi",
+    "target": 3
   },
   "engines": {
-    "node": ">=8.5.0"
+    "node": ">=10"
   },
   "funding": {
     "url": "https://opencollective.com/libvips"
   },
+  "binary": {
+    "napi_versions": [
+      3
+    ]
+  },
   "semistandard": {
     "env": [
       "mocha"

src/common.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -17,11 +17,10 @@
 #include <string.h>
 #include <vector>
 #include <queue>
+#include <map>
 #include <mutex>  // NOLINT(build/c++11)
 
-#include <node.h>
-#include <node_buffer.h>
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 #include "common.h"
@@ -30,62 +29,105 @@ using vips::VImage;
 
 namespace sharp {
 
-  // Convenience methods to access the attributes of a v8::Object
-  bool HasAttr(v8::Local<v8::Object> obj, std::string attr) {
-    return Nan::Has(obj, Nan::New(attr).ToLocalChecked()).FromJust();
+  // 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(v8::Local<v8::Object> obj, std::string attr) {
-    return *Nan::Utf8String(Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked());
+  std::string AttrAsStr(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::String>();
   }
-  std::vector<double> AttrAsRgba(v8::Local<v8::Object> obj, std::string attr) {
-    v8::Local<v8::Object> background = AttrAs<v8::Object>(obj, attr);
-    std::vector<double> rgba(4);
-    for (unsigned int i = 0; i < 4; i++) {
-      rgba[i] = AttrTo<double>(background, i);
+  std::string AttrAsStr(Napi::Object obj, unsigned int const 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 rgba;
+    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 v8::Object describing an input image
-  InputDescriptor* CreateInputDescriptor(
-    v8::Local<v8::Object> input, std::vector<v8::Local<v8::Object>> &buffersToPersist
-  ) {
-    Nan::HandleScope();
+  // 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")) {
-      v8::Local<v8::Object> buffer = AttrAs<v8::Object>(input, "buffer");
-      descriptor->bufferLength = node::Buffer::Length(buffer);
-      descriptor->buffer = node::Buffer::Data(buffer);
+      Napi::Buffer<char> buffer = input.Get("buffer").As<Napi::Buffer<char>>();
+      descriptor->bufferLength = buffer.Length();
+      descriptor->buffer = buffer.Data();
       descriptor->isBuffer = TRUE;
-      buffersToPersist.push_back(buffer);
     }
-    descriptor->failOnError = AttrTo<bool>(input, "failOnError");
+    descriptor->failOnError = AttrAsBool(input, "failOnError");
     // Density for vector-based input
     if (HasAttr(input, "density")) {
-      descriptor->density = AttrTo<double>(input, "density");
+      descriptor->density = AttrAsDouble(input, "density");
     }
     // Raw pixel input
     if (HasAttr(input, "rawChannels")) {
-      descriptor->rawChannels = AttrTo<uint32_t>(input, "rawChannels");
-      descriptor->rawWidth = AttrTo<uint32_t>(input, "rawWidth");
-      descriptor->rawHeight = AttrTo<uint32_t>(input, "rawHeight");
+      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 = AttrTo<int32_t>(input, "pages");
+      descriptor->pages = AttrAsInt32(input, "pages");
     }
     if (HasAttr(input, "page")) {
-      descriptor->page = AttrTo<uint32_t>(input, "page");
+      descriptor->page = AttrAsUint32(input, "page");
+    }
+    // Multi-level input (OpenSlide)
+    if (HasAttr(input, "level")) {
+      descriptor->level = AttrAsUint32(input, "level");
+    }
+    // subIFD (OME-TIFF)
+    if (HasAttr(input, "subifd")) {
+      descriptor->subifd = AttrAsInt32(input, "subifd");
     }
     // Create new image
     if (HasAttr(input, "createChannels")) {
-      descriptor->createChannels = AttrTo<uint32_t>(input, "createChannels");
-      descriptor->createWidth = AttrTo<uint32_t>(input, "createWidth");
-      descriptor->createHeight = AttrTo<uint32_t>(input, "createHeight");
-      descriptor->createBackground = AttrAsRgba(input, "createBackground");
+      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;
   }
 
@@ -108,6 +150,9 @@ namespace sharp {
   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");
   }
@@ -148,6 +193,7 @@ namespace sharp {
       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;
@@ -156,32 +202,52 @@ namespace sharp {
     return id;
   }
 
+  /**
+   * Regenerate this table with something like:
+   *
+   * $ vips -l foreign | grep -i load | awk '{ print $2, $1; }'
+   *
+   * Plus a bit of editing.
+   */
+  std::map<std::string, ImageType> loaderToType = {
+    { "VipsForeignLoadJpegFile", ImageType::JPEG },
+    { "VipsForeignLoadJpegBuffer", ImageType::JPEG },
+    { "VipsForeignLoadPngFile", ImageType::PNG },
+    { "VipsForeignLoadPngBuffer", ImageType::PNG },
+    { "VipsForeignLoadWebpFile", ImageType::WEBP },
+    { "VipsForeignLoadWebpBuffer", ImageType::WEBP },
+    { "VipsForeignLoadTiffFile", ImageType::TIFF },
+    { "VipsForeignLoadTiffBuffer", ImageType::TIFF },
+    { "VipsForeignLoadGifFile", ImageType::GIF },
+    { "VipsForeignLoadGifBuffer", ImageType::GIF },
+    { "VipsForeignLoadNsgifFile", ImageType::GIF },
+    { "VipsForeignLoadNsgifBuffer", ImageType::GIF },
+    { "VipsForeignLoadSvgFile", ImageType::SVG },
+    { "VipsForeignLoadSvgBuffer", ImageType::SVG },
+    { "VipsForeignLoadHeifFile", ImageType::HEIF },
+    { "VipsForeignLoadHeifBuffer", ImageType::HEIF },
+    { "VipsForeignLoadPdfFile", ImageType::PDF },
+    { "VipsForeignLoadPdfBuffer", ImageType::PDF },
+    { "VipsForeignLoadMagickFile", ImageType::MAGICK },
+    { "VipsForeignLoadMagickBuffer", ImageType::MAGICK },
+    { "VipsForeignLoadOpenslide", ImageType::OPENSLIDE },
+    { "VipsForeignLoadPpmFile", ImageType::PPM },
+    { "VipsForeignLoadFits", ImageType::FITS },
+    { "VipsForeignLoadOpenexr", ImageType::EXR },
+    { "VipsForeignLoadVips", ImageType::VIPS },
+    { "VipsForeignLoadRaw", ImageType::RAW }
+  };
+
   /*
     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 != NULL) {
-      std::string const loader = load;
-      if (EndsWith(loader, "JpegBuffer")) {
-        imageType = ImageType::JPEG;
-      } else if (EndsWith(loader, "PngBuffer")) {
-        imageType = ImageType::PNG;
-      } else if (EndsWith(loader, "WebpBuffer")) {
-        imageType = ImageType::WEBP;
-      } else if (EndsWith(loader, "TiffBuffer")) {
-        imageType = ImageType::TIFF;
-      } else if (EndsWith(loader, "GifBuffer")) {
-        imageType = ImageType::GIF;
-      } else if (EndsWith(loader, "SvgBuffer")) {
-        imageType = ImageType::SVG;
-      } else if (EndsWith(loader, "HeifBuffer")) {
-        imageType = ImageType::HEIF;
-      } else if (EndsWith(loader, "PdfBuffer")) {
-        imageType = ImageType::PDF;
-      } else if (EndsWith(loader, "MagickBuffer")) {
-        imageType = ImageType::MAGICK;
+    if (load != nullptr) {
+      auto it = loaderToType.find(load);
+      if (it != loaderToType.end()) {
+        imageType = it->second;
       }
     }
     return imageType;
@@ -194,36 +260,12 @@ namespace sharp {
     ImageType imageType = ImageType::UNKNOWN;
     char const *load = vips_foreign_find_load(file);
     if (load != nullptr) {
-      std::string const loader = load;
-      if (EndsWith(loader, "JpegFile")) {
-        imageType = ImageType::JPEG;
-      } else if (EndsWith(loader, "Png")) {
-        imageType = ImageType::PNG;
-      } else if (EndsWith(loader, "WebpFile")) {
-        imageType = ImageType::WEBP;
-      } else if (EndsWith(loader, "Openslide")) {
-        imageType = ImageType::OPENSLIDE;
-      } else if (EndsWith(loader, "TiffFile")) {
-        imageType = ImageType::TIFF;
-      } else if (EndsWith(loader, "GifFile")) {
-        imageType = ImageType::GIF;
-      } else if (EndsWith(loader, "SvgFile")) {
-        imageType = ImageType::SVG;
-      } else if (EndsWith(loader, "HeifFile")) {
-        imageType = ImageType::HEIF;
-      } else if (EndsWith(loader, "PdfFile")) {
-        imageType = ImageType::PDF;
-      } else if (EndsWith(loader, "Ppm")) {
-        imageType = ImageType::PPM;
-      } else if (EndsWith(loader, "Fits")) {
-        imageType = ImageType::FITS;
-      } else if (EndsWith(loader, "Vips")) {
-        imageType = ImageType::VIPS;
-      } else if (EndsWith(loader, "Magick") || EndsWith(loader, "MagickFile")) {
-        imageType = ImageType::MAGICK;
+      auto it = loaderToType.find(load);
+      if (it != loaderToType.end()) {
+        imageType = it->second;
       }
     } else {
-      if (EndsWith(vips::VError().what(), " not found\n")) {
+      if (EndsWith(vips::VError().what(), " does not exist\n")) {
         imageType = ImageType::MISSING;
       }
     }
@@ -235,6 +277,8 @@ namespace sharp {
   */
   bool ImageTypeSupportsPage(ImageType imageType) {
     return
+      imageType == ImageType::WEBP ||
+      imageType == ImageType::MAGICK ||
       imageType == ImageType::GIF ||
       imageType == ImageType::TIFF ||
       imageType == ImageType::HEIF ||
@@ -244,7 +288,7 @@ namespace sharp {
   /*
     Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
-  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor, VipsAccess accessMethod) {
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor) {
     VImage image;
     ImageType imageType;
     if (descriptor->isBuffer) {
@@ -264,8 +308,11 @@ namespace sharp {
         if (imageType != ImageType::UNKNOWN) {
           try {
             vips::VOption *option = VImage::option()
-              ->set("access", accessMethod)
+              ->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);
             }
@@ -276,6 +323,12 @@ namespace sharp {
               option->set("n", descriptor->pages);
               option->set("page", descriptor->page);
             }
+            if (imageType == ImageType::OPENSLIDE) {
+              option->set("level", descriptor->level);
+            }
+            if (imageType == ImageType::TIFF) {
+              option->set("subifd", descriptor->subifd);
+            }
             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);
@@ -290,15 +343,35 @@ namespace sharp {
     } else {
       if (descriptor->createChannels > 0) {
         // Create new image
-        std::vector<double> background = {
-          descriptor->createBackground[0],
-          descriptor->createBackground[1],
-          descriptor->createBackground[2]
-        };
-        if (descriptor->createChannels == 4) {
-          background.push_back(descriptor->createBackground[3]);
+        if (descriptor->createNoiseType == "gaussian") {
+          int const channels = descriptor->createChannels;
+          image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight);
+          std::vector<VImage> bands = {};
+          bands.reserve(channels);
+          for (int _band = 0; _band < channels; _band++) {
+            bands.push_back(image.gaussnoise(
+              descriptor->createWidth,
+              descriptor->createHeight,
+              VImage::option()->set("mean", descriptor->createNoiseMean)->set("sigma", descriptor->createNoiseSigma)));
+          }
+          image = image.bandjoin(bands);
+          image = image.cast(VipsBandFormat::VIPS_FORMAT_UCHAR);
+          if (channels < 3) {
+            image = image.colourspace(VIPS_INTERPRETATION_B_W);
+          } else {
+            image = image.colourspace(VIPS_INTERPRETATION_sRGB);
+          }
+        } else {
+          std::vector<double> background = {
+            descriptor->createBackground[0],
+            descriptor->createBackground[1],
+            descriptor->createBackground[2]
+          };
+          if (descriptor->createChannels == 4) {
+            background.push_back(descriptor->createBackground[3]);
+          }
+          image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight).new_from_image(background);
         }
-        image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight).new_from_image(background);
         image.get_image()->Type = VIPS_INTERPRETATION_sRGB;
         imageType = ImageType::RAW;
       } else {
@@ -310,8 +383,11 @@ namespace sharp {
         if (imageType != ImageType::UNKNOWN) {
           try {
             vips::VOption *option = VImage::option()
-              ->set("access", accessMethod)
+              ->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);
             }
@@ -322,6 +398,12 @@ namespace sharp {
               option->set("n", descriptor->pages);
               option->set("page", descriptor->page);
             }
+            if (imageType == ImageType::OPENSLIDE) {
+              option->set("level", descriptor->level);
+            }
+            if (imageType == ImageType::TIFF) {
+              option->set("subifd", descriptor->subifd);
+            }
             image = VImage::new_from_file(descriptor->file.data(), option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
@@ -334,6 +416,11 @@ namespace sharp {
         }
       }
     }
+    // Limit input images to a given number of pixels, where pixels = width * height
+    if (descriptor->limitInputPixels > 0 &&
+      static_cast<uint64_t>(image.width() * image.height()) > static_cast<uint64_t>(descriptor->limitInputPixels)) {
+      throw vips::VError("Input image exceeds pixel limit");
+    }
     return std::make_tuple(image, imageType);
   }
 
@@ -349,12 +436,7 @@ namespace sharp {
     Uses colour space interpretation with number of channels to guess this.
   */
   bool HasAlpha(VImage image) {
-    int const bands = image.bands();
-    VipsInterpretation const interpretation = image.interpretation();
-    return (
-      (bands == 2 && interpretation == VIPS_INTERPRETATION_B_W) ||
-      (bands == 4 && interpretation != VIPS_INTERPRETATION_CMYK) ||
-      (bands == 5 && interpretation == VIPS_INTERPRETATION_CMYK));
+    return image.has_alpha();
   }
 
   /*
@@ -386,6 +468,38 @@ namespace sharp {
     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?
   */
@@ -416,25 +530,30 @@ namespace sharp {
     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 || image.height() > 65535) {
+      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 || image.height() > 16383) {
+      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
   */
-  void FreeCallback(char* data, void* hint) {
-    if (data != nullptr) {
-      g_free(data);
-    }
-  }
+  std::function<void(void*, char*)> FreeCallback = [](void*, char* data) {
+    g_free(data);
+  };
 
   /*
     Temporary buffer of warnings
@@ -582,26 +701,18 @@ namespace sharp {
     int top = 0;
 
     // assign only if valid
-    if (x >= 0 && x < (inWidth - outWidth)) {
+    if (x < (inWidth - outWidth)) {
       left = x;
     } else if (x >= (inWidth - outWidth)) {
       left = inWidth - outWidth;
     }
 
-    if (y >= 0 && y < (inHeight - outHeight)) {
+    if (y < (inHeight - outHeight)) {
       top = y;
     } else if (y >= (inHeight - outHeight)) {
       top = inHeight - outHeight;
     }
 
-    // the resulting left and top could have been outside the image after calculation from bottom/right edges
-    if (left < 0) {
-      left = 0;
-    }
-    if (top < 0) {
-      top = 0;
-    }
-
     return std::make_tuple(left, top);
   }
 
@@ -688,4 +799,25 @@ namespace sharp {
     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, double const value) {
+    if (!HasAlpha(image)) {
+      std::vector<double> alpha;
+      alpha.push_back(value * sharp::MaximumImageAlpha(image.interpretation()));
+      image = image.bandjoin_const(alpha);
+    }
+    return image;
+  }
 }  // namespace sharp

src/common.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -19,23 +19,24 @@
 #include <tuple>
 #include <vector>
 
-#include <node.h>
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 // Verify platform and compiler compatibility
 
-#if (VIPS_MAJOR_VERSION < 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 8))
-#error libvips version 8.8.0+ is required - see sharp.pixelplumbing.com/page/install
+#if (VIPS_MAJOR_VERSION < 8) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 10) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 10 && VIPS_MICRO_VERSION < 6)
+#error "libvips version 8.10.6+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
-#error GCC version 4.6+ is required for C++11 features - see sharp.pixelplumbing.com/page/install#prerequisites
+#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 - see sharp.pixelplumbing.com/page/install#prerequisites
+#error "clang version 3.0+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
 #endif
 #endif
 
@@ -48,6 +49,8 @@ namespace sharp {
     std::string file;
     char *buffer;
     bool failOnError;
+    int limitInputPixels;
+    VipsAccess access;
     size_t bufferLength;
     bool isBuffer;
     double density;
@@ -56,14 +59,21 @@ namespace sharp {
     int rawHeight;
     int pages;
     int page;
+    int level;
+    int subifd;
     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),
@@ -72,29 +82,31 @@ namespace sharp {
       rawHeight(0),
       pages(1),
       page(0),
+      level(0),
+      subifd(-1),
       createChannels(0),
       createWidth(0),
       createHeight(0),
-      createBackground{ 0.0, 0.0, 0.0, 255.0 } {}
+      createBackground{ 0.0, 0.0, 0.0, 255.0 },
+      createNoiseMean(0.0),
+      createNoiseSigma(0.0) {}
   };
 
-  // Convenience methods to access the attributes of a v8::Object
-  bool HasAttr(v8::Local<v8::Object> obj, std::string attr);
-  std::string AttrAsStr(v8::Local<v8::Object> obj, std::string attr);
-  std::vector<double> AttrAsRgba(v8::Local<v8::Object> obj, std::string attr);
-  template<typename T> v8::Local<T> AttrAs(v8::Local<v8::Object> obj, std::string attr) {
-    return Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked().As<T>();
-  }
-  template<typename T> T AttrTo(v8::Local<v8::Object> obj, std::string attr) {
-    return Nan::To<T>(Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked()).FromJust();
-  }
-  template<typename T> T AttrTo(v8::Local<v8::Object> obj, int attr) {
-    return Nan::To<T>(Nan::Get(obj, attr).ToLocalChecked()).FromJust();
-  }
+  // 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);
+  std::string AttrAsStr(Napi::Object obj, unsigned int const 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 v8::Object describing an input image
-  InputDescriptor* CreateInputDescriptor(
-    v8::Local<v8::Object> input, std::vector<v8::Local<v8::Object>> &buffersToPersist);  // NOLINT(runtime/references)
+  // Create an InputDescriptor instance from a Napi::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(Napi::Object input);
 
   enum class ImageType {
     JPEG,
@@ -109,6 +121,7 @@ namespace sharp {
     OPENSLIDE,
     PPM,
     FITS,
+    EXR,
     VIPS,
     RAW,
     UNKNOWN,
@@ -125,6 +138,7 @@ namespace sharp {
   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);
@@ -156,7 +170,7 @@ namespace sharp {
   /*
     Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
-  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor, VipsAccess accessMethod);
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor);
 
   /*
     Does this image have an embedded profile?
@@ -184,6 +198,12 @@ namespace sharp {
   */
   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?
   */
@@ -207,7 +227,7 @@ namespace sharp {
   /*
     Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
   */
-  void FreeCallback(char* data, void* hint);
+  extern std::function<void(void*, char*)> FreeCallback;
 
   /*
     Called with warnings from the glib-registered "VIPS" domain
@@ -271,6 +291,16 @@ namespace sharp {
    */
   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, double const value);
+
 }  // 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/VInterpolate.cpp

@@ -61,7 +61,7 @@ VInterpolate::new_from_name( const char *name, VOption *options )
 }
 
 VOption *
-VOption::set( const char *name, VInterpolate value )
+VOption::set( const char *name, const VInterpolate value )
 {
 	Pair *pair = new Pair( name );
 

src/libvips/cplusplus/vips-operators.cpp

@@ -1,5 +1,5 @@
 // bodies for vips operations
-// Wed Apr 24 15:50:21 CEST 2019
+// Sun  5 Jul 22:36:37 BST 2020
 // this file is generated automatically, do not edit!
 
 VImage VImage::CMC2LCh( VOption *options ) const
@@ -491,6 +491,19 @@ VImage VImage::canny( VOption *options ) const
     return( out );
 }
 
+VImage VImage::case_image( std::vector<VImage> cases, VOption *options ) const
+{
+    VImage out;
+
+    call( "case",
+        (options ? options : VImage::option())->
+            set( "index", *this )->
+            set( "out", &out )->
+            set( "cases", cases ) );
+
+    return( out );
+}
+
 VImage VImage::cast( VipsBandFormat format, VOption *options ) const
 {
     VImage out;
@@ -741,6 +754,18 @@ VImage VImage::csvload( const char *filename, VOption *options )
     return( out );
 }
 
+VImage VImage::csvload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "csvload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::csvsave( const char *filename, VOption *options ) const
 {
     call( "csvsave",
@@ -749,6 +774,14 @@ void VImage::csvsave( const char *filename, VOption *options ) const
             set( "filename", filename ) );
 }
 
+void VImage::csvsave_target( VTarget target, VOption *options ) const
+{
+    call( "csvsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::dE00( VImage right, VOption *options ) const
 {
     VImage out;
@@ -1205,6 +1238,18 @@ VImage VImage::gifload_buffer( VipsBlob *buffer, VOption *options )
     return( out );
 }
 
+VImage VImage::gifload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "gifload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 VImage VImage::globalbalance( VOption *options ) const
 {
     VImage out;
@@ -1284,6 +1329,18 @@ VImage VImage::heifload_buffer( VipsBlob *buffer, VOption *options )
     return( out );
 }
 
+VImage VImage::heifload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "heifload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::heifsave( const char *filename, VOption *options ) const
 {
     call( "heifsave",
@@ -1304,6 +1361,14 @@ VipsBlob *VImage::heifsave_buffer( VOption *options ) const
     return( buffer );
 }
 
+void VImage::heifsave_target( VTarget target, VOption *options ) const
+{
+    call( "heifsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::hist_cum( VOption *options ) const
 {
     VImage out;
@@ -1615,6 +1680,18 @@ VImage VImage::jpegload_buffer( VipsBlob *buffer, VOption *options )
     return( out );
 }
 
+VImage VImage::jpegload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "jpegload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::jpegsave( const char *filename, VOption *options ) const
 {
     call( "jpegsave",
@@ -1642,6 +1719,14 @@ void VImage::jpegsave_mime( VOption *options ) const
             set( "in", *this ) );
 }
 
+void VImage::jpegsave_target( VTarget target, VOption *options ) const
+{
+    call( "jpegsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::labelregions( VOption *options ) const
 {
     VImage mask;
@@ -1995,6 +2080,18 @@ VImage VImage::matload( const char *filename, VOption *options )
     return( out );
 }
 
+VImage VImage::matrixinvert( VOption *options ) const
+{
+    VImage out;
+
+    call( "matrixinvert",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "out", &out ) );
+
+    return( out );
+}
+
 VImage VImage::matrixload( const char *filename, VOption *options )
 {
     VImage out;
@@ -2007,6 +2104,18 @@ VImage VImage::matrixload( const char *filename, VOption *options )
     return( out );
 }
 
+VImage VImage::matrixload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "matrixload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::matrixprint( VOption *options ) const
 {
     call( "matrixprint",
@@ -2022,6 +2131,14 @@ void VImage::matrixsave( const char *filename, VOption *options ) const
             set( "filename", filename ) );
 }
 
+void VImage::matrixsave_target( VTarget target, VOption *options ) const
+{
+    call( "matrixsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 double VImage::max( VOption *options ) const
 {
     double out;
@@ -2223,6 +2340,18 @@ VImage VImage::pdfload_buffer( VipsBlob *buffer, VOption *options )
     return( out );
 }
 
+VImage VImage::pdfload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "pdfload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 int VImage::percent( double percent, VOption *options ) const
 {
     int threshold;
@@ -2286,6 +2415,18 @@ VImage VImage::pngload_buffer( VipsBlob *buffer, VOption *options )
     return( out );
 }
 
+VImage VImage::pngload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "pngload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::pngsave( const char *filename, VOption *options ) const
 {
     call( "pngsave",
@@ -2306,6 +2447,14 @@ VipsBlob *VImage::pngsave_buffer( VOption *options ) const
     return( buffer );
 }
 
+void VImage::pngsave_target( VTarget target, VOption *options ) const
+{
+    call( "pngsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::ppmload( const char *filename, VOption *options )
 {
     VImage out;
@@ -2318,6 +2467,18 @@ VImage VImage::ppmload( const char *filename, VOption *options )
     return( out );
 }
 
+VImage VImage::ppmload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "ppmload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::ppmsave( const char *filename, VOption *options ) const
 {
     call( "ppmsave",
@@ -2326,6 +2487,14 @@ void VImage::ppmsave( const char *filename, VOption *options ) const
             set( "filename", filename ) );
 }
 
+void VImage::ppmsave_target( VTarget target, VOption *options ) const
+{
+    call( "ppmsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::premultiply( VOption *options ) const
 {
     VImage out;
@@ -2413,6 +2582,30 @@ VImage VImage::radload( const char *filename, VOption *options )
     return( out );
 }
 
+VImage VImage::radload_buffer( VipsBlob *buffer, VOption *options )
+{
+    VImage out;
+
+    call( "radload_buffer",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "buffer", buffer ) );
+
+    return( out );
+}
+
+VImage VImage::radload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "radload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::radsave( const char *filename, VOption *options ) const
 {
     call( "radsave",
@@ -2433,6 +2626,14 @@ VipsBlob *VImage::radsave_buffer( VOption *options ) const
     return( buffer );
 }
 
+void VImage::radsave_target( VTarget target, VOption *options ) const
+{
+    call( "radsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::rank( int width, int height, int index, VOption *options ) const
 {
     VImage out;
@@ -2977,6 +3178,30 @@ VImage VImage::svgload_buffer( VipsBlob *buffer, VOption *options )
     return( out );
 }
 
+VImage VImage::svgload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "svgload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
+VImage VImage::switch_image( std::vector<VImage> tests, VOption *options )
+{
+    VImage out;
+
+    call( "switch",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "tests", tests ) );
+
+    return( out );
+}
+
 void VImage::system( const char *cmd_format, VOption *options )
 {
     call( "system",
@@ -3035,6 +3260,19 @@ VImage VImage::thumbnail_image( int width, VOption *options ) const
     return( out );
 }
 
+VImage VImage::thumbnail_source( VSource source, int width, VOption *options )
+{
+    VImage out;
+
+    call( "thumbnail_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source )->
+            set( "width", width ) );
+
+    return( out );
+}
+
 VImage VImage::tiffload( const char *filename, VOption *options )
 {
     VImage out;
@@ -3059,6 +3297,18 @@ VImage VImage::tiffload_buffer( VipsBlob *buffer, VOption *options )
     return( out );
 }
 
+VImage VImage::tiffload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "tiffload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::tiffsave( const char *filename, VOption *options ) const
 {
     call( "tiffsave",
@@ -3170,6 +3420,18 @@ VImage VImage::webpload_buffer( VipsBlob *buffer, VOption *options )
     return( out );
 }
 
+VImage VImage::webpload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "webpload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::webpsave( const char *filename, VOption *options ) const
 {
     call( "webpsave",
@@ -3190,6 +3452,14 @@ VipsBlob *VImage::webpsave_buffer( VOption *options ) const
     return( buffer );
 }
 
+void VImage::webpsave_target( VTarget target, VOption *options ) const
+{
+    call( "webpsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::worley( int width, int height, VOption *options )
 {
     VImage out;

src/metadata.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -15,28 +15,16 @@
 #include <numeric>
 #include <vector>
 
-#include <node.h>
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 #include "common.h"
 #include "metadata.h"
 
-class MetadataWorker : public Nan::AsyncWorker {
+class MetadataWorker : public Napi::AsyncWorker {
  public:
-  MetadataWorker(
-    Nan::Callback *callback, MetadataBaton *baton, Nan::Callback *debuglog,
-    std::vector<v8::Local<v8::Object>> const buffersToPersist) :
-    Nan::AsyncWorker(callback, "sharp:MetadataWorker"),
-    baton(baton), debuglog(debuglog),
-    buffersToPersist(buffersToPersist) {
-    // Protect Buffer objects from GC, keyed on index
-    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
-      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
-        SaveToPersistent(index, buffer);
-        return index + 1;
-      });
-  }
+  MetadataWorker(Napi::Function callback, MetadataBaton *baton, Napi::Function debuglog) :
+    Napi::AsyncWorker(callback), baton(baton), debuglog(Napi::Persistent(debuglog)) {}
   ~MetadataWorker() {}
 
   void Execute() {
@@ -46,7 +34,7 @@ class MetadataWorker : public Nan::AsyncWorker {
     vips::VImage image;
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
     try {
-      std::tie(image, imageType) = OpenInput(baton->input, VIPS_ACCESS_SEQUENTIAL);
+      std::tie(image, imageType) = OpenInput(baton->input);
     } catch (vips::VError const &err) {
       (baton->err).append(err.what());
     }
@@ -77,9 +65,30 @@ class MetadataWorker : public Nan::AsyncWorker {
       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));
+        }
+      }
+      if (image.get_typeof(VIPS_META_N_SUBIFDS) == G_TYPE_INT) {
+        baton->subifds = image.get_int(VIPS_META_N_SUBIFDS);
+      }
       baton->hasProfile = sharp::HasProfile(image);
       // Derived attributes
       baton->hasAlpha = sharp::HasAlpha(image);
@@ -131,129 +140,132 @@ class MetadataWorker : public Nan::AsyncWorker {
     vips_thread_shutdown();
   }
 
-  void HandleOKCallback() {
-    using Nan::New;
-    using Nan::Set;
-    Nan::HandleScope();
-
-    v8::Local<v8::Value> argv[2] = { Nan::Null(), Nan::Null() };
-    if (!baton->err.empty()) {
-      argv[0] = Nan::Error(baton->err.data());
-    } else {
-      // Metadata Object
-      v8::Local<v8::Object> info = New<v8::Object>();
-      Set(info, New("format").ToLocalChecked(), New<v8::String>(baton->format).ToLocalChecked());
-      if (baton->input->bufferLength > 0) {
-        Set(info, New("size").ToLocalChecked(), New<v8::Uint32>(static_cast<uint32_t>(baton->input->bufferLength)));
-      }
-      Set(info, New("width").ToLocalChecked(), New<v8::Uint32>(baton->width));
-      Set(info, New("height").ToLocalChecked(), New<v8::Uint32>(baton->height));
-      Set(info, New("space").ToLocalChecked(), New<v8::String>(baton->space).ToLocalChecked());
-      Set(info, New("channels").ToLocalChecked(), New<v8::Uint32>(baton->channels));
-      Set(info, New("depth").ToLocalChecked(), New<v8::String>(baton->depth).ToLocalChecked());
-      if (baton->density > 0) {
-        Set(info, New("density").ToLocalChecked(), New<v8::Uint32>(baton->density));
-      }
-      if (!baton->chromaSubsampling.empty()) {
-        Set(info,
-          New("chromaSubsampling").ToLocalChecked(),
-          New<v8::String>(baton->chromaSubsampling).ToLocalChecked());
-      }
-      Set(info, New("isProgressive").ToLocalChecked(), New<v8::Boolean>(baton->isProgressive));
-      if (baton->paletteBitDepth > 0) {
-        Set(info, New("paletteBitDepth").ToLocalChecked(), New<v8::Uint32>(baton->paletteBitDepth));
-      }
-      if (baton->pages > 0) {
-        Set(info, New("pages").ToLocalChecked(), New<v8::Uint32>(baton->pages));
-      }
-      if (baton->pageHeight > 0) {
-        Set(info, New("pageHeight").ToLocalChecked(), New<v8::Uint32>(baton->pageHeight));
-      }
-      if (baton->pagePrimary > -1) {
-        Set(info, New("pagePrimary").ToLocalChecked(), New<v8::Uint32>(baton->pagePrimary));
-      }
-      Set(info, New("hasProfile").ToLocalChecked(), New<v8::Boolean>(baton->hasProfile));
-      Set(info, New("hasAlpha").ToLocalChecked(), New<v8::Boolean>(baton->hasAlpha));
-      if (baton->orientation > 0) {
-        Set(info, New("orientation").ToLocalChecked(), New<v8::Uint32>(baton->orientation));
-      }
-      if (baton->exifLength > 0) {
-        Set(info,
-          New("exif").ToLocalChecked(),
-          Nan::NewBuffer(baton->exif, baton->exifLength, sharp::FreeCallback, nullptr).ToLocalChecked());
-      }
-      if (baton->iccLength > 0) {
-        Set(info,
-          New("icc").ToLocalChecked(),
-          Nan::NewBuffer(baton->icc, baton->iccLength, sharp::FreeCallback, nullptr).ToLocalChecked());
-      }
-      if (baton->iptcLength > 0) {
-        Set(info,
-          New("iptc").ToLocalChecked(),
-          Nan::NewBuffer(baton->iptc, baton->iptcLength, sharp::FreeCallback, nullptr).ToLocalChecked());
-      }
-      if (baton->xmpLength > 0) {
-        Set(info,
-          New("xmp").ToLocalChecked(),
-          Nan::NewBuffer(baton->xmp, baton->xmpLength, sharp::FreeCallback, nullptr).ToLocalChecked());
-      }
-      if (baton->tifftagPhotoshopLength > 0) {
-        Set(info,
-          New("tifftagPhotoshop").ToLocalChecked(),
-          Nan::NewBuffer(baton->tifftagPhotoshop, baton->tifftagPhotoshopLength, sharp::FreeCallback, nullptr)
-            .ToLocalChecked());
-      }
-      argv[1] = info;
-    }
-
-    // Dispose of Persistent wrapper around input Buffers so they can be garbage collected
-    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
-      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
-        GetFromPersistent(index);
-        return index + 1;
-      });
-    delete baton->input;
-    delete baton;
+  void OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
 
     // Handle warnings
     std::string warning = sharp::VipsWarningPop();
     while (!warning.empty()) {
-      v8::Local<v8::Value> message[1] = { New(warning).ToLocalChecked() };
-      debuglog->Call(1, message, async_resource);
+      debuglog.Call({ Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
 
-    // Return to JavaScript
-    callback->Call(2, argv, async_resource);
+    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);
+      }
+      if (baton->subifds > 0) {
+        info.Set("subifds", baton->subifds);
+      }
+      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;
-  Nan::Callback *debuglog;
-  std::vector<v8::Local<v8::Object>> buffersToPersist;
+  Napi::FunctionReference debuglog;
 };
 
 /*
   metadata(options, callback)
 */
-NAN_METHOD(metadata) {
-  // Input Buffers must not undergo GC compaction during processing
-  std::vector<v8::Local<v8::Object>> buffersToPersist;
-
+Napi::Value metadata(const Napi::CallbackInfo& info) {
   // V8 objects are converted to non-V8 types held in the baton struct
   MetadataBaton *baton = new MetadataBaton;
-  v8::Local<v8::Object> options = info[0].As<v8::Object>();
+  Napi::Object options = info[0].As<Napi::Object>();
 
   // Input
-  baton->input = sharp::CreateInputDescriptor(sharp::AttrAs<v8::Object>(options, "input"), buffersToPersist);
+  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
 
   // Function to notify of libvips warnings
-  Nan::Callback *debuglog = new Nan::Callback(sharp::AttrAs<v8::Function>(options, "debuglog"));
+  Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();
 
   // Join queue for worker thread
-  Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
-  Nan::AsyncQueueWorker(new MetadataWorker(callback, baton, debuglog, buffersToPersist));
+  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

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -16,7 +16,7 @@
 #define SRC_METADATA_H_
 
 #include <string>
-#include <nan.h>
+#include <napi.h>
 
 #include "./common.h"
 
@@ -36,7 +36,12 @@ struct MetadataBaton {
   int paletteBitDepth;
   int pages;
   int pageHeight;
+  int loop;
+  std::vector<int> delay;
   int pagePrimary;
+  std::string compression;
+  std::vector<std::pair<int, int>> levels;
+  int subifds;
   bool hasProfile;
   bool hasAlpha;
   int orientation;
@@ -62,7 +67,9 @@ struct MetadataBaton {
     paletteBitDepth(0),
     pages(0),
     pageHeight(0),
+    loop(-1),
     pagePrimary(-1),
+    subifds(0),
     hasProfile(false),
     hasAlpha(false),
     orientation(0),
@@ -78,6 +85,6 @@ struct MetadataBaton {
     tifftagPhotoshopLength(0) {}
 };
 
-NAN_METHOD(metadata);
+Napi::Value metadata(const Napi::CallbackInfo& info);
 
 #endif  // SRC_METADATA_H_

src/operations.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -27,29 +27,6 @@ using vips::VImage;
 using vips::VError;
 
 namespace sharp {
-
-  /*
-    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;
-  }
-
   /*
    * Tint an image using the specified chroma, preserving the original image luminance
    */
@@ -172,8 +149,8 @@ namespace sharp {
    */
   VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix) {
     double *m = matrix.get();
+    image = image.colourspace(VIPS_INTERPRETATION_sRGB);
     return image
-      .colourspace(VIPS_INTERPRETATION_sRGB)
       .recomb(image.bands() == 3
         ? VImage::new_from_memory(
           m, 9 * sizeof(double), 3, 3, 1, VIPS_FORMAT_DOUBLE

src/operations.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -25,16 +25,6 @@ using vips::VImage;
 
 namespace sharp {
 
-  /*
-    Removes alpha channel, if any.
-  */
-  VImage RemoveAlpha(VImage image);
-
-  /*
-    Ensures alpha channel, if missing.
-  */
-  VImage EnsureAlpha(VImage image);
-
   /*
    * Tint an image using the specified chroma, preserving the original image luminance
    */

src/pipeline.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -18,13 +18,14 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <unordered_map>
 
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 #include "./common.h"
 
-NAN_METHOD(pipeline);
+Napi::Value pipeline(const Napi::CallbackInfo& info);
 
 enum class Canvas {
   CROP,
@@ -40,6 +41,7 @@ struct Composite {
   int gravity;
   int left;
   int top;
+  bool hasOffset;
   bool tile;
   bool premultiplied;
 
@@ -47,15 +49,15 @@ struct Composite {
     input(nullptr),
     mode(VIPS_BLEND_MODE_OVER),
     gravity(0),
-    left(-1),
-    top(-1),
+    left(0),
+    top(0),
+    hasOffset(false),
     tile(false),
     premultiplied(false) {}
 };
 
 struct PipelineBaton {
   sharp::InputDescriptor *input;
-  int limitInputPixels;
   std::string formatOut;
   std::string fileOut;
   void *bufferOut;
@@ -80,6 +82,7 @@ struct PipelineBaton {
   int cropOffsetLeft;
   int cropOffsetTop;
   bool premultiplied;
+  bool tileCentre;
   std::string kernel;
   bool fastShrinkOnLoad;
   double tintA;
@@ -119,7 +122,13 @@ struct PipelineBaton {
   int extendRight;
   std::vector<double> extendBackground;
   bool withoutEnlargement;
-  VipsAccess accessMethod;
+  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;
@@ -145,18 +154,22 @@ struct PipelineBaton {
   VipsForeignTiffCompression tiffCompression;
   VipsForeignTiffPredictor tiffPredictor;
   bool tiffPyramid;
-  bool tiffSquash;
+  int tiffBitdepth;
   bool tiffTile;
   int tiffTileHeight;
   int tiffTileWidth;
   double tiffXres;
   double tiffYres;
   int heifQuality;
-  int heifCompression;  // TODO(libvips 8.9.0): VipsForeignHeifCompression
+  VipsForeignHeifCompression heifCompression;
+  int heifSpeed;
+  std::string heifChromaSubsampling;
   bool heifLossless;
   std::string err;
   bool withMetadata;
   int withMetadataOrientation;
+  std::string withMetadataIcc;
+  std::unordered_map<std::string, std::string> withMetadataStrs;
   std::unique_ptr<double[]> convKernel;
   int convKernelWidth;
   int convKernelHeight;
@@ -167,8 +180,11 @@ struct PipelineBaton {
   VipsOperationBoolean bandBoolOp;
   int extractChannel;
   bool removeAlpha;
-  bool ensureAlpha;
+  double ensureAlpha;
   VipsInterpretation colourspace;
+  int pageHeight;
+  std::vector<int> delay;
+  int loop;
   int tileSize;
   int tileOverlap;
   VipsForeignDzContainer tileContainer;
@@ -178,11 +194,11 @@ struct PipelineBaton {
   std::vector<double> tileBackground;
   int tileSkipBlanks;
   VipsForeignDzDepth tileDepth;
+  std::string tileId;
   std::unique_ptr<double[]> recombMatrix;
 
   PipelineBaton():
     input(nullptr),
-    limitInputPixels(0),
     bufferOutLength(0),
     topOffsetPre(-1),
     topOffsetPost(-1),
@@ -229,6 +245,13 @@ struct PipelineBaton {
     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"),
@@ -238,7 +261,7 @@ struct PipelineBaton {
     jpegOptimiseScans(false),
     jpegOptimiseCoding(true),
     pngProgressive(false),
-    pngCompressionLevel(9),
+    pngCompressionLevel(6),
     pngAdaptiveFiltering(false),
     pngPalette(false),
     pngQuality(100),
@@ -254,14 +277,16 @@ struct PipelineBaton {
     tiffCompression(VIPS_FOREIGN_TIFF_COMPRESSION_JPEG),
     tiffPredictor(VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL),
     tiffPyramid(false),
-    tiffSquash(false),
+    tiffBitdepth(8),
     tiffTile(false),
     tiffTileHeight(256),
     tiffTileWidth(256),
     tiffXres(1.0),
     tiffYres(1.0),
-    heifQuality(80),
-    heifCompression(1),  // TODO(libvips 8.9.0): VIPS_FOREIGN_HEIF_COMPRESSION_HEVC
+    heifQuality(50),
+    heifCompression(VIPS_FOREIGN_HEIF_COMPRESSION_AV1),
+    heifSpeed(5),
+    heifChromaSubsampling("4:2:0"),
     heifLossless(false),
     withMetadata(false),
     withMetadataOrientation(-1),
@@ -274,8 +299,11 @@ struct PipelineBaton {
     bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
     extractChannel(-1),
     removeAlpha(false),
-    ensureAlpha(false),
+    ensureAlpha(-1.0),
     colourspace(VIPS_INTERPRETATION_LAST),
+    pageHeight(0),
+    delay{-1},
+    loop(-1),
     tileSize(256),
     tileOverlap(0),
     tileContainer(VIPS_FOREIGN_DZ_CONTAINER_FS),

src/sharp.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -12,8 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <node.h>
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 #include "common.h"
@@ -22,33 +21,32 @@
 #include "utilities.h"
 #include "stats.h"
 
-NAN_MODULE_INIT(init) {
+static void* sharp_vips_init(void*) {
+  g_setenv("VIPS_MIN_STACK_SIZE", "2m", FALSE);
   vips_init("sharp");
+  return nullptr;
+}
+
+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);
 
   g_log_set_handler("VIPS", static_cast<GLogLevelFlags>(G_LOG_LEVEL_WARNING),
     static_cast<GLogFunc>(sharp::VipsWarningCallback), nullptr);
 
   // Methods available to JavaScript
-  Nan::Set(target, Nan::New("metadata").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(metadata)).ToLocalChecked());
-  Nan::Set(target, Nan::New("pipeline").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(pipeline)).ToLocalChecked());
-  Nan::Set(target, Nan::New("cache").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(cache)).ToLocalChecked());
-  Nan::Set(target, Nan::New("concurrency").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(concurrency)).ToLocalChecked());
-  Nan::Set(target, Nan::New("counters").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(counters)).ToLocalChecked());
-  Nan::Set(target, Nan::New("simd").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(simd)).ToLocalChecked());
-  Nan::Set(target, Nan::New("libvipsVersion").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(libvipsVersion)).ToLocalChecked());
-  Nan::Set(target, Nan::New("format").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(format)).ToLocalChecked());
-  Nan::Set(target, Nan::New("_maxColourDistance").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(_maxColourDistance)).ToLocalChecked());
-  Nan::Set(target, Nan::New("stats").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(stats)).ToLocalChecked());
+  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("_isUsingJemalloc", Napi::Function::New(env, _isUsingJemalloc));
+  exports.Set("stats", Napi::Function::New(env, stats));
+  return exports;
 }
 
-NAN_MODULE_WORKER_ENABLED(sharp, init)
+NODE_API_MODULE(sharp, init)

src/stats.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -16,28 +16,16 @@
 #include <vector>
 #include <iostream>
 
-#include <node.h>
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 #include "common.h"
 #include "stats.h"
 
-class StatsWorker : public Nan::AsyncWorker {
+class StatsWorker : public Napi::AsyncWorker {
  public:
-  StatsWorker(
-    Nan::Callback *callback, StatsBaton *baton, Nan::Callback *debuglog,
-    std::vector<v8::Local<v8::Object>> const buffersToPersist) :
-    Nan::AsyncWorker(callback, "sharp:StatsWorker"),
-    baton(baton), debuglog(debuglog),
-    buffersToPersist(buffersToPersist) {
-    // Protect Buffer objects from GC, keyed on index
-    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
-      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
-        SaveToPersistent(index, buffer);
-        return index + 1;
-      });
-  }
+  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;
@@ -54,15 +42,11 @@ class StatsWorker : public Nan::AsyncWorker {
   void Execute() {
     // Decrement queued task counter
     g_atomic_int_dec_and_test(&sharp::counterQueue);
-    using Nan::New;
-    using Nan::Set;
-    using sharp::MaximumImageAlpha;
 
     vips::VImage image;
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
-
     try {
-      std::tie(image, imageType) = OpenInput(baton->input, baton->accessMethod);
+      std::tie(image, imageType) = OpenInput(baton->input);
     } catch (vips::VError const &err) {
       (baton->err).append(err.what());
     }
@@ -71,25 +55,51 @@ class StatsWorker : public Nan::AsyncWorker {
         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()));
+          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 != MaximumImageAlpha(image.interpretation())) {
+          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(image.colourspace(VIPS_INTERPRETATION_B_W)[0].hist_find().hist_entropy());
+        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());
       }
@@ -100,93 +110,84 @@ class StatsWorker : public Nan::AsyncWorker {
     vips_thread_shutdown();
   }
 
-  void HandleOKCallback() {
-    using Nan::New;
-    using Nan::Set;
-    Nan::HandleScope();
-
-    v8::Local<v8::Value> argv[2] = { Nan::Null(), Nan::Null() };
-    if (!baton->err.empty()) {
-      argv[0] = Nan::Error(baton->err.data());
-    } else {
-      // Stats Object
-      v8::Local<v8::Object> info = New<v8::Object>();
-      v8::Local<v8::Array> channels = New<v8::Array>();
-
-      std::vector<ChannelStats>::iterator it;
-      int i = 0;
-      for (it = baton->channelStats.begin(); it < baton->channelStats.end(); it++, i++) {
-        v8::Local<v8::Object> channelStat = New<v8::Object>();
-        Set(channelStat, New("min").ToLocalChecked(), New<v8::Number>(it->min));
-        Set(channelStat, New("max").ToLocalChecked(), New<v8::Number>(it->max));
-        Set(channelStat, New("sum").ToLocalChecked(), New<v8::Number>(it->sum));
-        Set(channelStat, New("squaresSum").ToLocalChecked(), New<v8::Number>(it->squaresSum));
-        Set(channelStat, New("mean").ToLocalChecked(), New<v8::Number>(it->mean));
-        Set(channelStat, New("stdev").ToLocalChecked(), New<v8::Number>(it->stdev));
-        Set(channelStat, New("minX").ToLocalChecked(), New<v8::Number>(it->minX));
-        Set(channelStat, New("minY").ToLocalChecked(), New<v8::Number>(it->minY));
-        Set(channelStat, New("maxX").ToLocalChecked(), New<v8::Number>(it->maxX));
-        Set(channelStat, New("maxY").ToLocalChecked(), New<v8::Number>(it->maxY));
-        Set(channels, i, channelStat);
-      }
-
-      Set(info, New("channels").ToLocalChecked(), channels);
-      Set(info, New("isOpaque").ToLocalChecked(), New<v8::Boolean>(baton->isOpaque));
-      Set(info, New("entropy").ToLocalChecked(), New<v8::Number>(baton->entropy));
-      argv[1] = info;
-    }
-
-    // Dispose of Persistent wrapper around input Buffers so they can be garbage collected
-    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
-      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
-        GetFromPersistent(index);
-        return index + 1;
-      });
-    delete baton->input;
-    delete baton;
+  void OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
 
     // Handle warnings
     std::string warning = sharp::VipsWarningPop();
     while (!warning.empty()) {
-      v8::Local<v8::Value> message[1] = { New(warning).ToLocalChecked() };
-      debuglog->Call(1, message, async_resource);
+      debuglog.Call({ Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
 
-    // Return to JavaScript
-    callback->Call(2, argv, async_resource);
+    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;
-  Nan::Callback *debuglog;
-  std::vector<v8::Local<v8::Object>> buffersToPersist;
+  Napi::FunctionReference debuglog;
 };
 
 /*
   stats(options, callback)
 */
-NAN_METHOD(stats) {
-  using sharp::AttrTo;
-
-  // Input Buffers must not undergo GC compaction during processing
-  std::vector<v8::Local<v8::Object>> buffersToPersist;
-
+Napi::Value stats(const Napi::CallbackInfo& info) {
   // V8 objects are converted to non-V8 types held in the baton struct
   StatsBaton *baton = new StatsBaton;
-  v8::Local<v8::Object> options = info[0].As<v8::Object>();
+  Napi::Object options = info[0].As<Napi::Object>();
 
   // Input
-  baton->input = sharp::CreateInputDescriptor(sharp::AttrAs<v8::Object>(options, "input"), buffersToPersist);
-  baton->accessMethod = AttrTo<bool>(options, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
+  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
 
   // Function to notify of libvips warnings
-  Nan::Callback *debuglog = new Nan::Callback(sharp::AttrAs<v8::Function>(options, "debuglog"));
+  Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();
 
   // Join queue for worker thread
-  Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
-  Nan::AsyncQueueWorker(new StatsWorker(callback, baton, debuglog, buffersToPersist));
+  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

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -16,7 +16,7 @@
 #define SRC_STATS_H_
 
 #include <string>
-#include <nan.h>
+#include <napi.h>
 
 #include "./common.h"
 
@@ -33,12 +33,8 @@ struct ChannelStats {
   int maxX;
   int maxY;
 
-  ChannelStats():
-    min(0), max(0), sum(0), squaresSum(0), mean(0), stdev(0)
-    , minX(0), minY(0), maxX(0), maxY(0) {}
-
-    ChannelStats(int minVal, int maxVal, double sumVal, double squaresSumVal,
-                  double meanVal, double stdevVal, int minXVal, int minYVal, int maxXVal, int maxYVal):
+  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) {}
 };
@@ -46,22 +42,29 @@ struct ChannelStats {
 struct StatsBaton {
   // Input
   sharp::InputDescriptor *input;
-  VipsAccess accessMethod;
 
   // 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)
+    entropy(0.0),
+    sharpness(0.0),
+    dominantRed(0),
+    dominantGreen(0),
+    dominantBlue(0)
     {}
 };
 
-NAN_METHOD(stats);
+Napi::Value stats(const Napi::CallbackInfo& info);
 
 #endif  // SRC_STATS_H_

src/utilities.cc

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -15,8 +15,7 @@
 #include <cmath>
 #include <string>
 
-#include <node.h>
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 #include <vips/vector.h>
 
@@ -24,183 +23,145 @@
 #include "operations.h"
 #include "utilities.h"
 
-using v8::Boolean;
-using v8::Integer;
-using v8::Local;
-using v8::Number;
-using v8::Object;
-using v8::String;
-
-using Nan::HandleScope;
-using Nan::New;
-using Nan::Set;
-using Nan::ThrowError;
-using Nan::To;
-using Nan::Utf8String;
-
 /*
   Get and set cache limits
 */
-NAN_METHOD(cache) {
-  HandleScope();
+Napi::Value cache(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
 
   // Set memory limit
-  if (info[0]->IsInt32()) {
-    vips_cache_set_max_mem(To<int32_t>(info[0]).FromJust() * 1048576);
+  if (info[0].IsNumber()) {
+    vips_cache_set_max_mem(info[0].As<Napi::Number>().Int32Value() * 1048576);
   }
   // Set file limit
-  if (info[1]->IsInt32()) {
-    vips_cache_set_max_files(To<int32_t>(info[1]).FromJust());
+  if (info[1].IsNumber()) {
+    vips_cache_set_max_files(info[1].As<Napi::Number>().Int32Value());
   }
   // Set items limit
-  if (info[2]->IsInt32()) {
-    vips_cache_set_max(To<int32_t>(info[2]).FromJust());
+  if (info[2].IsNumber()) {
+    vips_cache_set_max(info[2].As<Napi::Number>().Int32Value());
   }
 
   // Get memory stats
-  Local<Object> memory = New<Object>();
-  Set(memory, New("current").ToLocalChecked(),
-    New<Integer>(static_cast<int>(round(vips_tracked_get_mem() / 1048576))));
-  Set(memory, New("high").ToLocalChecked(),
-    New<Integer>(static_cast<int>(round(vips_tracked_get_mem_highwater() / 1048576))));
-  Set(memory, New("max").ToLocalChecked(),
-    New<Integer>(static_cast<int>(round(vips_cache_get_max_mem() / 1048576))));
+  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
-  Local<Object> files = New<Object>();
-  Set(files, New("current").ToLocalChecked(), New<Integer>(vips_tracked_get_files()));
-  Set(files, New("max").ToLocalChecked(), New<Integer>(vips_cache_get_max_files()));
+  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
-  Local<Object> items = New<Object>();
-  Set(items, New("current").ToLocalChecked(), New<Integer>(vips_cache_get_size()));
-  Set(items, New("max").ToLocalChecked(), New<Integer>(vips_cache_get_max()));
+  Napi::Object items = Napi::Object::New(env);
+  items.Set("current", vips_cache_get_size());
+  items.Set("max", vips_cache_get_max());
 
-  Local<Object> cache = New<Object>();
-  Set(cache, New("memory").ToLocalChecked(), memory);
-  Set(cache, New("files").ToLocalChecked(), files);
-  Set(cache, New("items").ToLocalChecked(), items);
-  info.GetReturnValue().Set(cache);
+  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
 */
-NAN_METHOD(concurrency) {
-  HandleScope();
-
+Napi::Value concurrency(const Napi::CallbackInfo& info) {
   // Set concurrency
-  if (info[0]->IsInt32()) {
-    vips_concurrency_set(To<int32_t>(info[0]).FromJust());
+  if (info[0].IsNumber()) {
+    vips_concurrency_set(info[0].As<Napi::Number>().Int32Value());
   }
   // Get concurrency
-  info.GetReturnValue().Set(New<Integer>(vips_concurrency_get()));
+  return Napi::Number::New(info.Env(), vips_concurrency_get());
 }
 
 /*
   Get internal counters (queued tasks, processing tasks)
 */
-NAN_METHOD(counters) {
-  using sharp::counterProcess;
-  using sharp::counterQueue;
-
-  HandleScope();
-  Local<Object> counters = New<Object>();
-  Set(counters, New("queue").ToLocalChecked(), New<Integer>(counterQueue));
-  Set(counters, New("process").ToLocalChecked(), New<Integer>(counterProcess));
-  info.GetReturnValue().Set(counters);
+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
 */
-NAN_METHOD(simd) {
-  HandleScope();
-
+Napi::Value simd(const Napi::CallbackInfo& info) {
   // Set state
-  if (info[0]->IsBoolean()) {
-    vips_vector_set_enabled(To<bool>(info[0]).FromJust());
+  if (info[0].IsBoolean()) {
+    vips_vector_set_enabled(info[0].As<Napi::Boolean>().Value());
   }
   // Get state
-  info.GetReturnValue().Set(New<Boolean>(vips_vector_isenabled()));
+  return Napi::Boolean::New(info.Env(), vips_vector_isenabled());
 }
 
 /*
   Get libvips version
 */
-NAN_METHOD(libvipsVersion) {
-  HandleScope();
+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));
-  info.GetReturnValue().Set(New(version).ToLocalChecked());
+  return Napi::String::New(info.Env(), version);
 }
 
 /*
   Get available input/output file/buffer/stream formats
 */
-NAN_METHOD(format) {
-  HandleScope();
-
-  // Attribute names
-  Local<String> attrId = New("id").ToLocalChecked();
-  Local<String> attrInput = New("input").ToLocalChecked();
-  Local<String> attrOutput = New("output").ToLocalChecked();
-  Local<String> attrFile = New("file").ToLocalChecked();
-  Local<String> attrBuffer = New("buffer").ToLocalChecked();
-  Local<String> attrStream = New("stream").ToLocalChecked();
-
-  // Which load/save operations are available for each compressed format?
-  Local<Object> format = New<Object>();
+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
-    Local<Boolean> hasInputFile =
-      New<Boolean>(vips_type_find("VipsOperation", (f + "load").c_str()));
-    Local<Boolean> hasInputBuffer =
-      New<Boolean>(vips_type_find("VipsOperation", (f + "load_buffer").c_str()));
-    Local<Object> input = New<Object>();
-    Set(input, attrFile, hasInputFile);
-    Set(input, attrBuffer, hasInputBuffer);
-    Set(input, attrStream, hasInputBuffer);
+    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
-    Local<Boolean> hasOutputFile =
-      New<Boolean>(vips_type_find("VipsOperation", (f + "save").c_str()));
-    Local<Boolean> hasOutputBuffer =
-      New<Boolean>(vips_type_find("VipsOperation", (f + "save_buffer").c_str()));
-    Local<Object> output = New<Object>();
-    Set(output, attrFile, hasOutputFile);
-    Set(output, attrBuffer, hasOutputBuffer);
-    Set(output, attrStream, hasOutputBuffer);
+    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
-    Local<Object> container = New<Object>();
-    Local<String> formatId = New(f).ToLocalChecked();
-    Set(container, attrId, formatId);
-    Set(container, attrInput, input);
-    Set(container, attrOutput, output);
+    Napi::Object container = Napi::Object::New(env);
+    container.Set("id", f);
+    container.Set("input", input);
+    container.Set("output", output);
     // Add to set of formats
-    Set(format, formatId, container);
+    format.Set(f, container);
   }
 
   // Raw, uncompressed data
-  Local<Object> raw = New<Object>();
-  Local<String> rawId = New("raw").ToLocalChecked();
-  Set(raw, attrId, rawId);
-  Set(format, rawId, raw);
-  Local<Boolean> supported = New<Boolean>(true);
-  Local<Boolean> unsupported = New<Boolean>(false);
-  Local<Object> rawInput = New<Object>();
-  Set(rawInput, attrFile, unsupported);
-  Set(rawInput, attrBuffer, supported);
-  Set(rawInput, attrStream, supported);
-  Set(raw, attrInput, rawInput);
-  Local<Object> rawOutput = New<Object>();
-  Set(rawOutput, attrFile, unsupported);
-  Set(rawOutput, attrBuffer, supported);
-  Set(rawOutput, attrStream, supported);
-  Set(raw, attrOutput, rawOutput);
+  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);
 
-  info.GetReturnValue().Set(format);
+  return format;
 }
 
 /*
@@ -208,65 +169,75 @@ NAN_METHOD(format) {
   Calculates the maximum colour distance using the DE2000 algorithm
   between two images of the same dimensions and number of channels.
 */
-NAN_METHOD(_maxColourDistance) {
-  using vips::VImage;
-  using vips::VError;
-  using sharp::DetermineImageType;
-  using sharp::ImageType;
-  using sharp::HasAlpha;
-
-  HandleScope();
+Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
 
   // Open input files
   VImage image1;
-  ImageType imageType1 = DetermineImageType(*Utf8String(info[0]));
-  if (imageType1 != ImageType::UNKNOWN) {
+  sharp::ImageType imageType1 = sharp::DetermineImageType(info[0].As<Napi::String>().Utf8Value().data());
+  if (imageType1 != sharp::ImageType::UNKNOWN) {
     try {
-      image1 = VImage::new_from_file(*Utf8String(info[0]));
+      image1 = VImage::new_from_file(info[0].As<Napi::String>().Utf8Value().c_str());
     } catch (...) {
-      return ThrowError("Input file 1 has corrupt header");
+      throw Napi::Error::New(env, "Input file 1 has corrupt header");
     }
   } else {
-    return ThrowError("Input file 1 is of an unsupported image format");
+    throw Napi::Error::New(env, "Input file 1 is of an unsupported image format");
   }
   VImage image2;
-  ImageType imageType2 = DetermineImageType(*Utf8String(info[1]));
-  if (imageType2 != ImageType::UNKNOWN) {
+  sharp::ImageType imageType2 = sharp::DetermineImageType(info[1].As<Napi::String>().Utf8Value().data());
+  if (imageType2 != sharp::ImageType::UNKNOWN) {
     try {
-      image2 = VImage::new_from_file(*Utf8String(info[1]));
+      image2 = VImage::new_from_file(info[1].As<Napi::String>().Utf8Value().c_str());
     } catch (...) {
-      return ThrowError("Input file 2 has corrupt header");
+      throw Napi::Error::New(env, "Input file 2 has corrupt header");
     }
   } else {
-    return ThrowError("Input file 2 is of an unsupported image format");
+    throw Napi::Error::New(env, "Input file 2 is of an unsupported image format");
   }
   // Ensure same number of channels
   if (image1.bands() != image2.bands()) {
-    return ThrowError("mismatchedBands");
+    throw Napi::Error::New(env, "mismatchedBands");
   }
   // Ensure same dimensions
   if (image1.width() != image2.width() || image1.height() != image2.height()) {
-    return ThrowError("mismatchedDimensions");
+    throw Napi::Error::New(env, "mismatchedDimensions");
   }
 
   double maxColourDistance;
   try {
     // Premultiply and remove alpha
-    if (HasAlpha(image1)) {
+    if (sharp::HasAlpha(image1)) {
       image1 = image1.premultiply().extract_band(1, VImage::option()->set("n", image1.bands() - 1));
     }
-    if (HasAlpha(image2)) {
+    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 (VError const &err) {
-    return ThrowError(err.what());
+  } 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();
 
-  info.GetReturnValue().Set(New<Number>(maxColourDistance));
+  return Napi::Number::New(env, maxColourDistance);
 }
+
+#if defined(__GNUC__)
+// mallctl will be resolved by the runtime linker when jemalloc is being used
+extern "C" {
+  int mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp, size_t newlen) __attribute__((weak));
+}
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, mallctl != nullptr);
+}
+#else
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, false);
+}
+#endif

src/utilities.h

@@ -1,4 +1,4 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019 Lovell Fuller and contributors.
+// 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.
@@ -15,14 +15,15 @@
 #ifndef SRC_UTILITIES_H_
 #define SRC_UTILITIES_H_
 
-#include <nan.h>
+#include <napi.h>
 
-NAN_METHOD(cache);
-NAN_METHOD(concurrency);
-NAN_METHOD(counters);
-NAN_METHOD(simd);
-NAN_METHOD(libvipsVersion);
-NAN_METHOD(format);
-NAN_METHOD(_maxColourDistance);
+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);
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info);
 
 #endif  // SRC_UTILITIES_H_

test/bench/package.json

@@ -8,16 +8,16 @@
     "test": "node perf && node random && node parallel"
   },
   "devDependencies": {
-    "async": "^3.1.0",
-    "benchmark": "^2.1.4",
-    "gm": "^1.23.1",
-    "imagemagick": "^0.1.3",
-    "jimp": "^0.8.4",
-    "mapnik": "^4.3.1",
-    "semver": "^6.3.0"
+    "async": "3.2.0",
+    "benchmark": "2.1.4",
+    "gm": "1.23.1",
+    "imagemagick": "0.1.3",
+    "jimp": "0.16.1",
+    "mapnik": "4.5.6",
+    "semver": "7.3.4"
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=8.5.0"
+    "node": "14"
   }
 }

test/bench/perf.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const os = require('os');
 const fs = require('fs');
 
 const async = require('async');
@@ -15,12 +16,19 @@ const jimp = require('jimp');
 
 const fixtures = require('../fixtures');
 
+const outputJpg = fixtures.path('output.jpg');
+const outputPng = fixtures.path('output.png');
+const outputWebP = fixtures.path('output.webp');
+
 const width = 720;
 const height = 588;
 
 // Disable libvips cache to ensure tests are as fair as they can be
 sharp.cache(false);
 
+// Spawn one thread per CPU
+sharp.concurrency(os.cpus().length);
+
 async.series({
   jpeg: function (callback) {
     const inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
@@ -56,7 +64,7 @@ async.series({
             image
               .resize(width, height, jimp.RESIZE_BICUBIC)
               .quality(80)
-              .write(fixtures.outputJpg, function (err) {
+              .write(outputJpg, function (err) {
                 if (err) {
                   throw err;
                 } else {
@@ -77,7 +85,7 @@ async.series({
             .resize(width, height, {
               scaling_method: mapnik.imageScaling.lanczos
             })
-            .save(fixtures.outputJpg, 'jpeg:quality=80', function (err) {
+            .save(outputJpg, 'jpeg:quality=80', function (err) {
               if (err) throw err;
               deferred.resolve();
             });
@@ -105,7 +113,7 @@ async.series({
       fn: function (deferred) {
         imagemagick.resize({
           srcPath: fixtures.inputJpg,
-          dstPath: fixtures.outputJpg,
+          dstPath: outputJpg,
           quality: 0.8,
           width: width,
           height: height,
@@ -128,7 +136,7 @@ async.series({
           .filter('Lanczos')
           .resize(width, height)
           .quality(80)
-          .write(fixtures.outputJpg, function (err) {
+          .write(outputJpg, function (err) {
             if (err) {
               throw err;
             } else {
@@ -159,7 +167,7 @@ async.series({
           .filter('Lanczos')
           .resize(width, height)
           .quality(80)
-          .write(fixtures.outputJpg, function (err) {
+          .write(outputJpg, function (err) {
             if (err) {
               throw err;
             } else {
@@ -190,7 +198,7 @@ async.series({
       fn: function (deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .toFile(fixtures.outputJpg, function (err) {
+          .toFile(outputJpg, function (err) {
             if (err) {
               throw err;
             } else {
@@ -217,7 +225,7 @@ async.series({
       fn: function (deferred) {
         sharp(fixtures.inputJpg)
           .resize(width, height)
-          .toFile(fixtures.outputJpg, function (err) {
+          .toFile(outputJpg, function (err) {
             if (err) {
               throw err;
             } else {
@@ -229,7 +237,7 @@ async.series({
       defer: true,
       fn: function (deferred) {
         const readable = fs.createReadStream(fixtures.inputJpg);
-        const writable = fs.createWriteStream(fixtures.outputJpg);
+        const writable = fs.createWriteStream(outputJpg);
         writable.on('finish', function () {
           deferred.resolve();
         });
@@ -460,8 +468,7 @@ async.series({
     }).add('sharp-sequentialRead', {
       defer: true,
       fn: function (deferred) {
-        sharp(inputJpgBuffer)
-          .sequentialRead()
+        sharp(inputJpgBuffer, { sequentialRead: true })
           .resize(width, height)
           .toBuffer(function (err, buffer) {
             if (err) {
@@ -565,8 +572,9 @@ async.series({
   },
   // PNG
   png: function (callback) {
-    const inputPngBuffer = fs.readFileSync(fixtures.inputPng);
+    const inputPngBuffer = fs.readFileSync(fixtures.inputPngAlphaPremultiplicationLarge);
     const pngSuite = new Benchmark.Suite('png');
+    const minSamples = 64;
     // jimp
     pngSuite.add('jimp-buffer-buffer', {
       defer: true,
@@ -577,6 +585,8 @@ async.series({
           } else {
             image
               .resize(width, height)
+              .deflateLevel(6)
+              .filterType(0)
               .getBuffer(jimp.MIME_PNG, function (err) {
                 if (err) {
                   throw err;
@@ -590,13 +600,15 @@ async.series({
     }).add('jimp-file-file', {
       defer: true,
       fn: function (deferred) {
-        jimp.read(fixtures.inputPng, function (err, image) {
+        jimp.read(fixtures.inputPngAlphaPremultiplicationLarge, function (err, image) {
           if (err) {
             throw err;
           } else {
             image
               .resize(width, height)
-              .write(fixtures.outputPng, function (err) {
+              .deflateLevel(6)
+              .filterType(0)
+              .write(outputPng, function (err) {
                 if (err) {
                   throw err;
                 } else {
@@ -611,7 +623,7 @@ async.series({
     pngSuite.add('mapnik-file-file', {
       defer: true,
       fn: function (deferred) {
-        mapnik.Image.open(fixtures.inputPng, function (err, img) {
+        mapnik.Image.open(fixtures.inputPngAlphaPremultiplicationLarge, function (err, img) {
           if (err) throw err;
           img.premultiply(function (err, img) {
             if (err) throw err;
@@ -621,7 +633,7 @@ async.series({
               if (err) throw err;
               img.demultiply(function (err, img) {
                 if (err) throw err;
-                img.save(fixtures.outputPng, 'png', function (err) {
+                img.save(outputPng, 'png', function (err) {
                   if (err) throw err;
                   deferred.resolve();
                 });
@@ -658,11 +670,15 @@ async.series({
       defer: true,
       fn: function (deferred) {
         imagemagick.resize({
-          srcPath: fixtures.inputPng,
-          dstPath: fixtures.outputPng,
+          srcPath: fixtures.inputPngAlphaPremultiplicationLarge,
+          dstPath: outputPng,
           width: width,
           height: height,
-          filter: 'Lanczos'
+          filter: 'Lanczos',
+          customArgs: [
+            '-define', 'PNG:compression-level=6',
+            '-define', 'PNG:compression-filter=0'
+          ]
         }, function (err) {
           if (err) {
             throw err;
@@ -676,10 +692,12 @@ async.series({
     pngSuite.add('gm-file-file', {
       defer: true,
       fn: function (deferred) {
-        gm(fixtures.inputPng)
+        gm(fixtures.inputPngAlphaPremultiplicationLarge)
           .filter('Lanczos')
           .resize(width, height)
-          .write(fixtures.outputPng, function (err) {
+          .define('PNG:compression-level=6')
+          .define('PNG:compression-filter=0')
+          .write(outputPng, function (err) {
             if (err) {
               throw err;
             } else {
@@ -690,9 +708,11 @@ async.series({
     }).add('gm-file-buffer', {
       defer: true,
       fn: function (deferred) {
-        gm(fixtures.inputPng)
+        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;
@@ -706,10 +726,12 @@ async.series({
     // sharp
     pngSuite.add('sharp-buffer-file', {
       defer: true,
+      minSamples,
       fn: function (deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .toFile(fixtures.outputPng, function (err) {
+          .png({ compressionLevel: 6 })
+          .toFile(outputPng, function (err) {
             if (err) {
               throw err;
             } else {
@@ -719,9 +741,11 @@ async.series({
       }
     }).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;
@@ -733,10 +757,12 @@ async.series({
       }
     }).add('sharp-file-file', {
       defer: true,
+      minSamples,
       fn: function (deferred) {
-        sharp(fixtures.inputPng)
+        sharp(fixtures.inputPngAlphaPremultiplicationLarge)
           .resize(width, height)
-          .toFile(fixtures.outputPng, function (err) {
+          .png({ compressionLevel: 6 })
+          .toFile(outputPng, function (err) {
             if (err) {
               throw err;
             } else {
@@ -746,9 +772,11 @@ async.series({
       }
     }).add('sharp-file-buffer', {
       defer: true,
+      minSamples,
       fn: function (deferred) {
-        sharp(fixtures.inputPng)
+        sharp(fixtures.inputPngAlphaPremultiplicationLarge)
           .resize(width, height)
+          .png({ compressionLevel: 6 })
           .toBuffer(function (err, buffer) {
             if (err) {
               throw err;
@@ -760,10 +788,11 @@ async.series({
       }
     }).add('sharp-progressive', {
       defer: true,
+      minSamples,
       fn: function (deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .png({ progressive: true })
+          .png({ compressionLevel: 6, progressive: true })
           .toBuffer(function (err, buffer) {
             if (err) {
               throw err;
@@ -775,10 +804,27 @@ async.series({
       }
     }).add('sharp-adaptiveFiltering', {
       defer: true,
+      minSamples,
       fn: function (deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .png({ adaptiveFiltering: true })
+          .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;
@@ -803,7 +849,7 @@ async.series({
       fn: function (deferred) {
         sharp(inputWebPBuffer)
           .resize(width, height)
-          .toFile(fixtures.outputWebP, function (err) {
+          .toFile(outputWebP, function (err) {
             if (err) {
               throw err;
             } else {
@@ -830,7 +876,7 @@ async.series({
       fn: function (deferred) {
         sharp(fixtures.inputWebP)
           .resize(width, height)
-          .toFile(fixtures.outputWebP, function (err) {
+          .toFile(outputWebP, function (err) {
             if (err) {
               throw err;
             } else {

test/bench/random.js

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

test/fixtures/circle.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 8 8">
+      <circle r="3.75" cx="4" cy="4" fill="deeppink" />
+</svg>